架構(gòu)模式是軟件架構(gòu)中在給定環(huán)境下常遇到問(wèn)題的通用的、可重用的解決方案。類(lèi)似于軟件設(shè)計(jì)模式但覆蓋范圍更廣，致力于軟件工程中不同問(wèn)題，如計(jì)算機(jī)硬件性能限制、高可用性、業(yè)務(wù)風(fēng)險(xiǎn)極小化。一些架構(gòu)模式在軟件框架被實(shí)現(xiàn)。- 維基百科

說(shuō)明

架構(gòu)模式有很多種，本文只討論工作中使用較多的幾種：

• 分層架構(gòu)
• Pipeline架構(gòu)
• 事件驅(qū)動(dòng)架構(gòu)

分層架構(gòu)

分層架構(gòu)模式

分層架構(gòu)模式工作中用的比較多，常見(jiàn)的有MVC等，通過(guò)分層將職責(zé)劃分到某一層上，層次清晰，架構(gòu)明了。

我們以MVC來(lái)舉例說(shuō)明：controller -> service -> dao

@RestController 
@RequestMapping("/order") 
public class OrderController { 
    @Autowired 
    private OrderService orderService; 
 
    /** 
     * 新增訂單 
     * @param order 
     * @return 
     */ 
    @PostMapping("/add") 
    public Response addOrder(Order order) { 
        orderService.add(order); 
        return Response.success(); 
    } 
} 
 
public interface OrderService { 
    /** 
     *  添加訂單 
     * @param order 
     * @return 
     */ 
    boolean add(Order order); 
} 
 
public interface OrderRepository { 
 
    int save(Order order); 
} 

按照依賴(lài)方向，上層依次依賴(lài)下層，每一層處理不同到邏輯。

之前到文章有討論過(guò)通過(guò)依賴(lài)反轉(zhuǎn)來(lái)改變依賴(lài)關(guān)系，從而更少到減少耦合。

Pipeline架構(gòu)

Pipeline架構(gòu)模式

Pipeline架構(gòu)也稱(chēng)為管道或流水線(xiàn)架構(gòu)，處理流程成線(xiàn)性，各個(gè)環(huán)節(jié)有相應(yīng)到組件處理，從前到后順序執(zhí)行。

概念說(shuō)明：

• source: 數(shù)據(jù)源，通常使用流數(shù)據(jù)為源，比如：KafkaSource;
• channel：信道或管道，用于處理或轉(zhuǎn)換數(shù)據(jù)，比如：JsonChannel;
• Sink：數(shù)據(jù)落地，通常用于數(shù)據(jù)存儲(chǔ)或轉(zhuǎn)發(fā)，比如：DbSink, KafkaSink;
• Component: 組件，用于執(zhí)行邏輯的最小單元，source,channel,sink都是一個(gè)Component;
• Pipeline: 管道或流水線(xiàn)，一個(gè)Pipeline由上面的組件組成，不同的業(yè)務(wù)可以組裝成不同的Pipeline;
• 代碼實(shí)現(xiàn)：數(shù)字?jǐn)?shù)據(jù)源 -> 累加 -> 轉(zhuǎn)成字符串 -> 落地

/** 
 *  組件 
 */ 
public interface Component<T> { 
    /** 
     *  組件名稱(chēng) 
     * @return 
     */ 
    String getName(); 
 
    /** 
     *  獲取下游組件 
     * @return 
     */ 
    Collection<Component> getDownStrems(); 
 
    /** 
     *  組件執(zhí)行 
     */ 
    void execute(T o); 
} 
 
public abstract class AbstractComponent<T, R> implements Component<T>{ 
 
    @Override 
    public void execute(T o) { 
        // 當(dāng)前組件執(zhí)行 
        R r = doExecute(o); 
        System.out.println(getName() + " receive " + o + " return " + r); 
        // 獲取下游組件，并執(zhí)行 
        Collection<Component> downStreams = getDownStrems(); 
        if (!CollectionUtils.isEmpty(downStreams)) { 
            downStreams.forEach(c -> c.execute(r)); 
        } 
    } 
 
    protected abstract R doExecute(T o); 
} 
 
/** 
 *  數(shù)據(jù)來(lái)源 
 */ 
public abstract class Source<T, R> extends AbstractComponent<T, R>{ 
 
} 
 
/** 
 *  管道/信道 
 * @param <T> 
 */ 
public abstract class Channel<T, R> extends AbstractComponent<T, R> { 
 
} 
 
/** 
 *  數(shù)據(jù)落地 
 * @param <T> 
 */ 
public abstract class Sink<T, R> extends AbstractComponent<T, R> { 
 
} 
 
public class IntegerSource extends Source<Integer,  Integer>{ 
 
    @Override 
    protected Integer doExecute(Integer o) { 
        return o; 
    } 
 
    @Override 
    public String getName() { 
        return "Integer-Source"; 
    } 
 
    @Override 
    public Collection<Component> getDownStrems() { 
        return Collections.singletonList(new IncrChannel()); 
    } 
 
} 
 
public class IncrChannel extends Channel<Integer, Integer> { 
 
    @Override 
    protected Integer doExecute(Integer o) { 
        return o + 1; 
    } 
 
    @Override 
    public String getName() { 
        return "Incr-Channel"; 
    } 
 
    @Override 
    public Collection<Component> getDownStrems() { 
        return Collections.singletonList(new StringChannel()); 
    } 
 
} 
 
public class StringChannel extends Channel<Integer, String> { 
 
    @Override 
    protected String doExecute(Integer o) { 
        return "str" + o; 
    } 
 
    @Override 
    public String getName() { 
        return "String-Channel"; 
    } 
 
    @Override 
    public Collection<Component> getDownStrems() { 
        return Collections.singletonList(new StringSink()); 
    } 
 
} 
 
public class StringSink extends Sink<String, Void>{ 
 
    @Override 
    protected Void doExecute(String o) { 
        return null; 
    } 
 
    @Override 
    public String getName() { 
        return "String-Sink"; 
    } 
 
    @Override 
    public Collection<Component> getDownStrems() { 
        return null; 
    } 
 
} 
 
/** 
 *  流水線(xiàn) 
 */ 
public class Pipeline { 
    /** 
     *  數(shù)據(jù)源 
     */ 
    private Source source; 
 
    public Pipeline(Source source) { 
        this.source = source; 
    } 
 
    /** 
     *  啟動(dòng) 
     */ 
    public void start() { 
        source.execute(1); 
    } 
} 

測(cè)試：

public class PipelineTest { 
 
    @Test 
    public void test() { 
        Pipeline pipeline = new Pipeline(new IntegerSource()); 
        pipeline.start(); 
    } 
} 

執(zhí)行結(jié)果：

Integer-Source receive 1 return 1  
Incr-Channel receive 1 return 2  
String-Channel receive 2 return str2  
String-Sink receive str2 return null 

事件驅(qū)動(dòng)架構(gòu)

事件驅(qū)動(dòng)模式

事件驅(qū)動(dòng)是以某個(gè)具體事件為觸發(fā)條件，從而貫穿這個(gè)處理流程。通常事件驅(qū)動(dòng)屬于發(fā)布訂閱模式或觀察者模式， 用于異步處理，解耦業(yè)務(wù)邏輯。具體實(shí)現(xiàn)有進(jìn)程內(nèi)的和分布式的方式，比如：EventBus, MQ等等。

代碼舉例：

public class OrderEventListener implements Listener<OrderEvent> { 
 
    @Override 
    public void onEvent(OrderEvent event) { 
        System.out.println("receive event: " + event); 
    } 
} 
 
public class EventBus { 
 
    private final static List<Listener> listeners = new ArrayList<>(); 
 
    /** 
     *  注冊(cè)監(jiān)聽(tīng)器 
     * @param listener 
     */ 
    public static void registerListener(Listener listener) { 
        listeners.add(listener); 
    } 
 
    /** 
     *  發(fā)布事件 
     * @param event 
     */ 
    public void publishEvent(Event event) { 
        // 收到并處理事件 
        listeners.forEach(l -> { 
            l.onEvent(event); 
        }); 
    } 
} 

測(cè)試：

public class EventBusTest { 
 
    @Test 
    public void publish() { 
        OrderEvent event = new OrderEvent("order_2", OrderState.PENDING_PAYMENT); 
        EventBus.registerListener(new OrderEventListener()); 
        EventBus eventBus = new EventBus(); 
        eventBus.publishEvent(event); 
    } 
} 

Spring中也有事件發(fā)布和監(jiān)聽(tīng)(深入淺出Spring/SpringBoot 事件監(jiān)聽(tīng)機(jī)制)：

@Component 
public class OrderEventListener  { 
 
    @Async 
    @EventListener(OrderEvent.class) 
    public void onEvent(OrderEvent event) { 
        System.out.println("receive event: " + event); 
    } 
} 
 
public class EventTest { 
    @Autowired 
    private ApplicationContext context; 
 
    @Test 
    public void publishEvent() { 
        OrderEvent event = new OrderEvent("order_1", OrderState.PENDING_PAYMENT); 
        context.publishEvent(event); 
    } 
} 

總結(jié)

以上通過(guò)代碼實(shí)例簡(jiǎn)單說(shuō)明了工作中常用到的架構(gòu)模式，但是模式不是固定的，工作中需結(jié)合實(shí)際情況按需使用即可。