常用的架構模式有哪些

這篇文章主要介紹“常用的架構模式有哪些”，在日常操作中，相信很多人在常用的架構模式有哪些問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”常用的架構模式有哪些”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

分層架構

分層架構模式

分層架構模式工作中用的比較多，常見的有MVC等，通過分層將職責劃分到某一層上，層次清晰，架構明了。

我們以MVC來舉例說明：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); }

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

之前到文章有討論過通過依賴反轉來改變依賴關系，從而更少到減少耦合。

Pipeline架構

Pipeline架構模式

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

概念說明：

• source: 數(shù)據(jù)源，通常使用流數(shù)據(jù)為源，比如：KafkaSource;

• channel：信道或管道，用于處理或轉換數(shù)據(jù)，比如：JsonChannel;

• Sink：數(shù)據(jù)落地，通常用于數(shù)據(jù)存儲或轉發(fā)，比如：DbSink, KafkaSink;

• Component: 組件，用于執(zhí)行邏輯的最小單元，source,channel,sink都是一個Component;

• Pipeline: 管道或流水線，一個Pipeline由上面的組件組成，不同的業(yè)務可以組裝成不同的Pipeline;

• 代碼實現(xiàn)：數(shù)字數(shù)據(jù)源 -> 累加 -> 轉成字符串 -> 落地

/**  *  組件  */ public interface Component<T> {     /**      *  組件名稱      * @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) {         // 當前組件執(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ù)來源  */ 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;     }  }  /**  *  流水線  */ public class Pipeline {     /**      *  數(shù)據(jù)源      */     private Source source;      public Pipeline(Source source) {         this.source = source;     }      /**      *  啟動      */     public void start() {         source.execute(1);     } }

測試：

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

執(zhí)行結果：

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

事件驅動架構

事件驅動模式

事件驅動是以某個具體事件為觸發(fā)條件，從而貫穿這個處理流程。通常事件驅動屬于發(fā)布訂閱模式或觀察者模式，  用于異步處理，解耦業(yè)務邏輯。具體實現(xiàn)有進程內的和分布式的方式，比如：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<>();      /**      *  注冊監(jiān)聽器      * @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);         });     } }

測試：

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)聽(深入淺出Spring/SpringBoot 事件監(jiān)聽機制)：

@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);     } }

到此，關于“常用的架構模式有哪些”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續(xù)學習更多相關知識，請繼續(xù)關注億速云網(wǎng)站，小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>