架构模式是软件架构中在给定环境下常遇到问题的通用的、可重用的解决方案。类似于软件设计模式但覆盖范围更广，致力于软件工程中不同问题，如计算机硬件性能限制、高可用性、业务风险极小化。一些架构模式在软件框架被实现。- 维基百科
说明
架构模式有很多种，本文只讨论工作中使用较多的几种：
- 分层架构
- Pipeline架构
- 事件驱动架构
分层架构
分层架构模式
分层架构模式工作中用的比较多，常见的有MVC等，通过分层将职责划分到某一层上，层次清晰，架构明了。
我们以MVC来举例说明：controller -> service -> dao
@RestController
@RequestMapping("/order")
publicclassOrderController{
@Autowired
privateOrderServiceorderService;
/**
*新增订单
*@paramorder
*@return
*/
@PostMapping("/add")
publicResponseaddOrder(Orderorder){
orderService.add(order);
returnResponse.success();
}
}
publicinterfaceOrderService{
/**
*添加订单
*@paramorder
*@return
*/
booleanadd(Orderorder);
}
publicinterfaceOrderRepository{
intsave(Orderorder);
}
按照依赖方向，上层依次依赖下层，每一层处理不同到逻辑。
之前到文章有讨论过通过依赖反转来改变依赖关系，从而更少到减少耦合。
Pipeline架构
Pipeline架构模式
Pipeline架构也称为管道或流水线架构，处理流程成线性，各个环节有相应到组件处理，从前到后顺序执行。
概念说明：
- source: 数据源，通常使用流数据为源，比如：KafkaSource;
- channel：信道或管道，用于处理或转换数据，比如：JsonChannel;
- Sink：数据落地，通常用于数据存储或转发，比如：DbSink, KafkaSink;
- Component: 组件，用于执行逻辑的最小单元，source,channel,sink都是一个Component;
- Pipeline: 管道或流水线，一个Pipeline由上面的组件组成，不同的业务可以组装成不同的Pipeline;
- 代码实现：数字数据源 -> 累加 -> 转成字符串 -> 落地
/**
*组件
*/
publicinterfaceComponent<T>{
/**
*组件名称
*@return
*/
StringgetName();
/**
*获取下游组件
*@return
*/
Collection<Component>getDownStrems();
/**
*组件执行
*/
voidexecute(To);
}
publicabstractclassAbstractComponent<T,R>implementsComponent<T>{
@Override
publicvoidexecute(To){
//当前组件执行
Rr=doExecute(o);
System.out.println(getName()+"receive"+o+"return"+r);
//获取下游组件，并执行
Collection<Component>downStreams=getDownStrems();
if(!CollectionUtils.isEmpty(downStreams)){
downStreams.forEach(c->c.execute(r));
}
}
protectedabstractRdoExecute(To);
}
/**
*数据来源
*/
publicabstractclassSource<T,R>extendsAbstractComponent<T,R>{
}
/**
*管道/信道
*@param<T>
*/
publicabstractclassChannel<T,R>extendsAbstractComponent<T,R>{
}
/**
*数据落地
*@param<T>
*/
publicabstractclassSink<T,R>extendsAbstractComponent<T,R>{
}
publicclassIntegerSourceextendsSource<Integer,Integer>{
@Override
protectedIntegerdoExecute(Integero){
returno;
}
@Override
publicStringgetName(){
return"Integer-Source";
}
@Override
publicCollection<Component>getDownStrems(){
returnCollections.singletonList(newIncrChannel());
}
}
publicclassIncrChannelextendsChannel<Integer,Integer>{
@Override
protectedIntegerdoExecute(Integero){
returno+1;
}
@Override
publicStringgetName(){
return"Incr-Channel";
}
@Override
publicCollection<Component>getDownStrems(){
returnCollections.singletonList(newStringChannel());
}
}
publicclassStringChannelextendsChannel<Integer,String>{
@Override
protectedStringdoExecute(Integero){
return"str"+o;
}
@Override
publicStringgetName(){
return"String-Channel";
}
@Override
publicCollection<Component>getDownStrems(){
returnCollections.singletonList(newStringSink());
}
}
publicclassStringSinkextendsSink<String,Void>{
@Override
protectedVoiddoExecute(Stringo){
returnnull;
}
@Override
publicStringgetName(){
return"String-Sink";
}
@Override
publicCollection<Component>getDownStrems(){
returnnull;
}
}
/**
*流水线
*/
publicclassPipeline{
/**
*数据源
*/
privateSourcesource;
publicPipeline(Sourcesource){
this.source=source;
}
/**
*启动
*/
publicvoidstart(){
source.execute(1);
}
}
测试：
publicclassPipelineTest{
@Test
publicvoidtest(){
Pipelinepipeline=newPipeline(newIntegerSource());
pipeline.start();
}
}
执行结果：
Integer-Sourcereceive1return1
Incr-Channelreceive1return2
String-Channelreceive2returnstr2
String-Sinkreceivestr2returnnull
事件驱动架构
事件驱动模式
事件驱动是以某个具体事件为触发条件，从而贯穿这个处理流程。通常事件驱动属于发布订阅模式或观察者模式， 用于异步处理，解耦业务逻辑。具体实现有进程内的和分布式的方式，比如：EventBus, MQ等等。
代码举例：
publicclassOrderEventListenerimplementsListener<OrderEvent>{
@Override
publicvoidonEvent(OrderEventevent){
System.out.println("receiveevent:"+event);
}
}
publicclassEventBus{
privatefinalstaticList<Listener>listeners=newArrayList<>();
/**
*注册监听器
*@paramlistener
*/
publicstaticvoidregisterListener(Listenerlistener){
listeners.add(listener);
}
/**
*发布事件
*@paramevent
*/
publicvoidpublishEvent(Eventevent){
//收到并处理事件
listeners.forEach(l->{
l.onEvent(event);
});
}
}
测试：
publicclassEventBusTest{
@Test
publicvoidpublish(){
OrderEventevent=newOrderEvent("order_2",OrderState.PENDING_PAYMENT);
EventBus.registerListener(newOrderEventListener());
EventBuseventBus=newEventBus();
eventBus.publishEvent(event);
}
}
Spring中也有事件发布和监听(深入浅出Spring/SpringBoot 事件监听机制)：
@Component
publicclassOrderEventListener{
@Async
@EventListener(OrderEvent.class)
publicvoidonEvent(OrderEventevent){
System.out.println("receiveevent:"+event);
}
}
publicclassEventTest{
@Autowired
privateApplicationContextcontext;
@Test
publicvoidpublishEvent(){
OrderEventevent=newOrderEvent("order_1",OrderState.PENDING_PAYMENT);
context.publishEvent(event);
}
}
总结
以上通过代码实例简单说明了工作中常用到的架构模式，但是模式不是固定的，工作中需结合实际情况按需使用即可。
原文地址：https://www.toutiao.com/a6910762028235784718/
