趣談設計模式，你學會了嗎？
背景
談起設計模式，你一定會問？這玩意到底有啥用？我好像沒用過也不影響做一個碼農。也可能項目中實際用了，但是你不自知。雖然Java設計模式有23種，但是工作中常用的可能并沒有那麼多。就像新華字典有多少字，你沒必要都學一樣。本章我們只談常用的幾種設計模式，通過設計模式的理念、規約、到應用，理解實戰中如何正確使用設計模式，不論對面試還是實際工作中都有益處。
文章提綱
圖片
設計理念
最為Java開發者，程序員基本修養名言絕句：
- 該露露，該藏藏
- 該封裝的要封裝
- 萬事萬物兼對象
- 程序代碼要健壯
我們簡單歸納為2個核心詞：高內聚、低耦合。
很小的時候看過動畫片，封神演義中哪吒：三頭八臂顯威力，千征百戰斗魔法。（串臺了。。。）
圖片
我們根據這首歌詞抽象一下，哪吒：三頭八臂是靜態特征，千征百戰是動態技能。把這些特征歸納映射一下：類 = 屬性 + 方法如下圖：
圖片
以上是高內聚的概念，什么是低耦合？
如果可能，我寫一本神話《封神演戲》，說哪吒有：三頭九臂。你肯定和我吵吵，要給它再配一把兵器。雖然還沒想好是啥，但是有個總則：絕對不影響先前這八臂的演技。這就是低耦合！！！所謂程序健壯、拓展性強，也是這個道理。我們真誠地希望：
圖片
上述例子不是特別恰當，但是對于設計模式，我們終級的理念是：封裝變化的內容，保留不變的宗旨。
設計原則
設計原則可以歸納為2大類：
- 開閉原則（李氏替換，組合復用，依賴倒置）
規定：軟件中的對象（類、模塊、函數等等）應該對于擴展是開放的，但是對于修改是封閉的。換句話說，一個實體是允許在不改變它的源代碼的前提下變更它的行為。
- 單一職責（接口隔離，迪米特法則）
規定：一個類只應該有一個職責，只有一個改變它的原因
Spring中的設計模式
在Spring框架中，各種設計模式被廣泛應用以支持其強大的功能和靈活性。下面我將結合Spring的源碼，鑒賞下Spring中常見的幾種設計模式。
1. 單例模式
Spring框架中的Bean默認就是單例的。Spring IoC容器負責創建對象實例，并確保在整個應用中，針對同一個Bean的ID，只實例化一次對象。DefaultSingletonBeanRegistry類是Spring管理單例Bean的核心類。
// DefaultSingletonBeanRegistry類中的部分源碼
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// ...
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// ...
@Override
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// ... 省略部分代碼
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
// ...
}2. 工廠模式
Spring使用工廠模式通過BeanFactory、ApplicationContext等接口創建和管理Bean對象。DefaultListableBeanFactory是Spring中Bean工廠的實現類。
// DefaultListableBeanFactory類中的部分源碼
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
// ...
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
return doGetBean(null, requiredType, null, false);
}
// ... 省略部分代碼
}3. 代理模式
Spring AOP（面向切面編程）的實現就是基于代理模式。Spring創建目標對象的代理對象，并在代理對象中織入切面邏輯。JdkDynamicAopProxy和CglibAopProxy是Spring AOP中創建代理的兩個核心類。
// JdkDynamicAopProxy類中的部分源碼
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
// ...
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// ... 省略部分代碼
// 獲取AdvisedSupport對象，包含了切面等AOP相關信息
final AdvisedSupport advised = this.advised;
// ... 省略部分代碼
// 獲取攔截器鏈（切面鏈）
List<Object> chain = advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// ... 省略部分代碼
// 執行鏈式調用
return invokeJoinpointUsingReflection(target, method, args, targetClass, chain);
}
// ...
}4. 觀察者模式（監聽模式）
在Spring中，事件處理機制就是基于觀察者模式實現的。當事件發生時，所有注冊的觀察者都會收到通知并作出響應。ApplicationEventMulticaster接口和SimpleApplicationEventMulticaster類是Spring事件處理機制的核心。
// SimpleApplicationEventMulticaster類中的部分源碼
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
// ...
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {```java
// 調用監聽器的方法處理事件
invokeListener(listener, event);
}
}
private void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
try {
doInvokeListener(listener, event);
} catch (Throwable err) {
errorHandler.handleError(err);
}
} else {
doInvokeListener(listener, event);
}
}
private void doInvokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
try {
// 調用監聽器的onApplicationEvent方法
listener.onApplicationEvent(event);
} catch (ClassCastException ex) {
// ... 省略部分代碼，處理類型不匹配異常
}
}
// ...
}5. 責任鏈模式
在Spring中，HandlerInterceptor和HandlerInterceptorAdapter等類在處理請求攔截時，采用的就是責任鏈模式。一個請求會按照定義的攔截器順序，逐個被處理，直到找到對應的處理器或者遍歷完所有的攔截器。
// HandlerInterceptor接口定義
public interface HandlerInterceptor {
boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception;
void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception;
void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception;
}
// 實現HandlerInterceptor接口的自定義攔截器
public class CustomInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 在這里執行前置處理邏輯
return true; // 返回true表示繼續向下執行，返回false表示中斷請求
}
// ... 其他方法實現
}6. 模版模式
Spring中的JdbcTemplate、HibernateTemplate等類就是模版模式的典型應用。它們定義了一個操作數據庫或Hibernate的骨架方法，允許子類在不改變算法結構的情況下重定義某些步驟的具體內容。
// JdbcTemplate部分源碼
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations, BeanFactoryAware {
// ...
public <T> T query(String sql, RowMapper<T> rowMapper) {
return query(sql, new Object[0], rowMapper);
}
public <T> T query(String sql, Object[] args, RowMapper<T> rowMapper) {
return query(sql, args, rowMapper, true);
}
// ... 省略部分代碼，這里是模版方法的實現
// 真正的SQL執行和結果集處理邏輯在這里，但是允許子類通過RowMapper來定制結果集的處理方式
// ...
}
// 自定義RowMapper實現
public class CustomRowMapper implements RowMapper<MyObject> {
@Override
public MyObject mapRow(ResultSet rs, int rowNum) throws SQLException {
// 在這里定制如何從ResultSet中映射到MyObject對象
return new MyObject(/* 映射邏輯 */);
}
}這些設計模式在Spring框架中被廣泛應用，能夠靈活地應對各種復雜場景，提供強大且可擴展的功能。
實戰應用
假設有這樣一個需求：
- 業務登錄商城用戶鑒權
- 購買產品下訂單
- 校驗訂單填寫是否合法
- 記錄接口中的參數
- 訂單確認后給買家發短信通知
根據業務場景，我們大致可拆分為：用戶流程、訂單流程
用戶登錄流程
在用戶登錄流程中，可能用到攔截器做鑒權校驗，日志記錄接口參數等，使用了一些常見的設計模式。
場景一、用戶鑒權校驗
責任鏈模式
攔截器通常按照定義的順序執行，每個攔截器檢查特定的條件或執行特定的任務。
// 攔截器接口
public interface Interceptor {
boolean intercept(AuthenticationContext context);
}
// 用戶校驗攔截器
public class UserValidationInterceptor implements Interceptor {
@Override
public boolean intercept(AuthenticationContext context) {
// 用戶校驗邏輯
if (isValidUser(context.getUser())) {
return true;
}
return false;
}
private boolean isValidUser(User user) {
// 校驗用戶是否有效
return true; // 示例，實際中應有具體校驗邏輯
}
}
// 鑒權校驗攔截器
public class AuthorizationInterceptor implements Interceptor {
@Override
public boolean intercept(AuthenticationContext context) {
// 鑒權校驗邏輯
if (isAuthorized(context.getUser(), context.getCredentials())) {
return true;
}
return false;
}
private boolean isAuthorized(User user, Credentials credentials) {
// 校驗用戶是否有權限
return true; // 示例，實際中應有具體校驗邏輯
}
}
// 攔截器鏈
public class InterceptorChain {
private List<Interceptor> interceptors = new ArrayList<>();
public void addInterceptor(Interceptor interceptor) {
interceptors.add(interceptor);
}
public boolean execute(AuthenticationContext context) {
for (Interceptor interceptor : interceptors) {
if (!interceptor.intercept(context)) {
// 如果攔截器返回false，則中斷鏈的執行
return false;
}
}
return true;
}
}場景二、記錄用戶登錄信息
單例模式
日志記錄器通常設計為單例，確保全局只有一個實例。
Logger logger = LoggerFactory.getLoggerFactoryInstance().getLogger();
logger.log("This is a user log message");在這行代碼中，體現了單例模式的核心思想，確保了無論多少次調用LoggerFactory.getLoggerFactoryInstance()，都只會返回一個LoggerFactory實例。事實上，我們從源碼中也可以看到。
訂單流程
根據業務場景，核心訂單流程如下：
場景三、訂單校驗
工廠模式
使用工廠模式實現的CheckOrderFactory，它用于創建不同類型的訂單校驗服務實例。
同時，我們定義一個校驗接口ICheckOrderService，并創建了兩個實現類:購買數量校驗：CountCheckOrder和訂單參數校驗：ParamCheckOrder。
public interface ICheckOrderService {
boolean checkOrder(Object order);
String getErrorMessage();
}購買數量校驗的實現類CountCheckOrder：
public class CountCheckOrder implements ICheckOrderService {
@Override
public boolean checkOrder(Object order) {
// 假設order是一個包含購買數量的對象
int quantity = ((Order) order).getQuantity();
return quantity > 0; // 只允許購買數量大于0
}
@Override
public String getErrorMessage() {
return "購買數量必須大于0。";
}
}訂單參數校驗的實現類ParamCheckOrder：
public class ParamCheckOrder implements ICheckOrderService {
@Override
public boolean checkOrder(Object order) {
// 假設order是一個包含各種訂單參數的對象
// 這里可以添加具體的訂單參數校驗邏輯
return true; // 示例代碼，默認返回true
}
@Override
public String getErrorMessage() {
return "訂單參數校驗失敗。";
}
}工廠類CheckOrderFactory，用于創建不同類型的校驗服務實例：
public class CheckOrderFactory {
public static ICheckOrderService createCheckOrderService(String type) {
switch (type) {
case "count":
return new CountCheckOrder();
case "param":
return new ParamCheckOrder();
default:
throw new IllegalArgumentException("不支持的校驗類型: " + type);
}
}
}使用工廠模式有利于業務類的實現和拓展，但是有時候也存在過度設計，導致寫了很多的業務類。
場景四、短信通知
觀察者模式（監聽模式）
在Spring框架中，我們可以使用ApplicationEvent和ApplicationListener來實現事件發布和監聽的功能。
假設我們要下發一個購買成功的短信提醒，那么就可以發布一個自定義的PurchaseSuccessEvent事件。
import org.springframework.context.ApplicationEvent;
public class PurchaseSuccessEvent extends ApplicationEvent {
private final String buyerPhoneNumber;
private final String orderId;
public PurchaseSuccessEvent(Object source, String buyerPhoneNumber, String orderId) {
super(source);
this.buyerPhoneNumber = buyerPhoneNumber;
this.orderId = orderId;
}
public String getBuyerPhoneNumber() {
return buyerPhoneNumber;
}
public String getOrderId() {
return orderId;
}
}接著定義一個SmsNotificationListener類，它實現了ApplicationListener接口，用于監聽PurchaseSuccessEvent事件：
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class SmsNotificationListener implements ApplicationListener<PurchaseSuccessEvent> {
@Override
public void onApplicationEvent(PurchaseSuccessEvent event) {
String message = "親愛的買家，您的訂單 " + event.getOrderId() + " 購買成功！";
sendSms(event.getBuyerPhoneNumber(), message);
}
private void sendSms(String phoneNumber, String message) {
// 在這里實現發送短信的邏輯
System.out.println("Sending SMS to " + phoneNumber + ": " + message);
}
}然后，在Spring的配置中啟用事件發布功能。配置一個ApplicationEventPublisher的bean：
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.GenericApplicationContext;
@Configuration
public class AppConfig {
@Bean
public ApplicationEventPublisher applicationEventPublisher() {
return new GenericApplicationContext();
}
}最后，在業務邏輯中發布PurchaseSuccessEvent事件。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class PurchaseService {
private final ApplicationEventPublisher applicationEventPublisher;
@Autowired
public PurchaseService(ApplicationEventPublisher applicationEventPublisher) {
this.applicationEventPublisher = applicationEventPublisher;
}
public void completePurchase(String buyerPhoneNumber, String orderId) {
// 模擬購買完成的業務邏輯
// ...
// 發布購買成功事件
applicationEventPublisher.publishEvent(new PurchaseSuccessEvent(this, buyerPhoneNumber, orderId));
}
}總結
- 使用設計模式的宗旨：封裝變化的部分，維護不變的宗旨
- 好處：提高代碼拓展性，程序更優雅更健壯
- 對開源框架設計模式的使用，要提高鑒賞能力
- 考慮可讀性，不可為了設計模式而過度設計
