趣談設(shè)計模式，你學(xué)會了嗎？
背景
談起設(shè)計模式，你一定會問？這玩意到底有啥用？我好像沒用過也不影響做一個碼農(nóng)。也可能項目中實際用了，但是你不自知。雖然Java設(shè)計模式有23種，但是工作中常用的可能并沒有那麼多。就像新華字典有多少字，你沒必要都學(xué)一樣。本章我們只談常用的幾種設(shè)計模式，通過設(shè)計模式的理念、規(guī)約、到應(yīng)用，理解實戰(zhàn)中如何正確使用設(shè)計模式，不論對面試還是實際工作中都有益處。
文章提綱
圖片
設(shè)計理念
最為Java開發(fā)者，程序員基本修養(yǎng)名言絕句：
- 該露露，該藏藏
- 該封裝的要封裝
- 萬事萬物兼對象
- 程序代碼要健壯
我們簡單歸納為2個核心詞：高內(nèi)聚、低耦合。
很小的時候看過動畫片，封神演義中哪吒：三頭八臂顯威力，千征百戰(zhàn)斗魔法。（串臺了。。。）
圖片
我們根據(jù)這首歌詞抽象一下，哪吒：三頭八臂是靜態(tài)特征，千征百戰(zhàn)是動態(tài)技能。把這些特征歸納映射一下：類 = 屬性 + 方法如下圖：
圖片
以上是高內(nèi)聚的概念，什么是低耦合？
如果可能，我寫一本神話《封神演戲》，說哪吒有：三頭九臂。你肯定和我吵吵，要給它再配一把兵器。雖然還沒想好是啥，但是有個總則：絕對不影響先前這八臂的演技。這就是低耦合?。?！所謂程序健壯、拓展性強，也是這個道理。我們真誠地希望：
圖片
上述例子不是特別恰當(dāng)，但是對于設(shè)計模式，我們終級的理念是：封裝變化的內(nèi)容，保留不變的宗旨。
設(shè)計原則
設(shè)計原則可以歸納為2大類：
- 開閉原則（李氏替換，組合復(fù)用，依賴倒置）
規(guī)定：軟件中的對象（類、模塊、函數(shù)等等）應(yīng)該對于擴展是開放的，但是對于修改是封閉的。換句話說，一個實體是允許在不改變它的源代碼的前提下變更它的行為。
- 單一職責(zé)（接口隔離，迪米特法則）
規(guī)定：一個類只應(yīng)該有一個職責(zé)，只有一個改變它的原因
Spring中的設(shè)計模式
在Spring框架中，各種設(shè)計模式被廣泛應(yīng)用以支持其強大的功能和靈活性。下面我將結(jié)合Spring的源碼，鑒賞下Spring中常見的幾種設(shè)計模式。
1. 單例模式
Spring框架中的Bean默認就是單例的。Spring IoC容器負責(zé)創(chuàng)建對象實例，并確保在整個應(yīng)用中，針對同一個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等接口創(chuàng)建和管理Bean對象。DefaultListableBeanFactory是Spring中Bean工廠的實現(xiàn)類。
// 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（面向切面編程）的實現(xiàn)就是基于代理模式。Spring創(chuàng)建目標(biāo)對象的代理對象，并在代理對象中織入切面邏輯。JdkDynamicAopProxy和CglibAopProxy是Spring AOP中創(chuàng)建代理的兩個核心類。
// JdkDynamicAopProxy類中的部分源碼
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
// ...
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// ... 省略部分代碼
// 獲取AdvisedSupport對象，包含了切面等AOP相關(guān)信息
final AdvisedSupport advised = this.advised;
// ... 省略部分代碼
// 獲取攔截器鏈（切面鏈）
List<Object> chain = advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// ... 省略部分代碼
// 執(zhí)行鏈?zhǔn)秸{(diào)用
return invokeJoinpointUsingReflection(target, method, args, targetClass, chain);
}
// ...
}4. 觀察者模式（監(jiān)聽模式）
在Spring中，事件處理機制就是基于觀察者模式實現(xiàn)的。當(dāng)事件發(fā)生時，所有注冊的觀察者都會收到通知并作出響應(yīng)。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
// 調(diào)用監(jiān)聽器的方法處理事件
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 {
// 調(diào)用監(jiān)聽器的onApplicationEvent方法
listener.onApplicationEvent(event);
} catch (ClassCastException ex) {
// ... 省略部分代碼，處理類型不匹配異常
}
}
// ...
}5. 責(zé)任鏈模式
在Spring中，HandlerInterceptor和HandlerInterceptorAdapter等類在處理請求攔截時，采用的就是責(zé)任鏈模式。一個請求會按照定義的攔截器順序，逐個被處理，直到找到對應(yīng)的處理器或者遍歷完所有的攔截器。
// 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;
}
// 實現(xiàn)HandlerInterceptor接口的自定義攔截器
public class CustomInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 在這里執(zhí)行前置處理邏輯
return true; // 返回true表示繼續(xù)向下執(zhí)行，返回false表示中斷請求
}
// ... 其他方法實現(xiàn)
}6. 模版模式
Spring中的JdbcTemplate、HibernateTemplate等類就是模版模式的典型應(yīng)用。它們定義了一個操作數(shù)據(jù)庫或Hibernate的骨架方法，允許子類在不改變算法結(jié)構(gòu)的情況下重定義某些步驟的具體內(nèi)容。
// 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);
}
// ... 省略部分代碼，這里是模版方法的實現(xiàn)
// 真正的SQL執(zhí)行和結(jié)果集處理邏輯在這里，但是允許子類通過RowMapper來定制結(jié)果集的處理方式
// ...
}
// 自定義RowMapper實現(xiàn)
public class CustomRowMapper implements RowMapper<MyObject> {
@Override
public MyObject mapRow(ResultSet rs, int rowNum) throws SQLException {
// 在這里定制如何從ResultSet中映射到MyObject對象
return new MyObject(/* 映射邏輯 */);
}
}這些設(shè)計模式在Spring框架中被廣泛應(yīng)用，能夠靈活地應(yīng)對各種復(fù)雜場景，提供強大且可擴展的功能。
實戰(zhàn)應(yīng)用
假設(shè)有這樣一個需求：
- 業(yè)務(wù)登錄商城用戶鑒權(quán)
- 購買產(chǎn)品下訂單
- 校驗訂單填寫是否合法
- 記錄接口中的參數(shù)
- 訂單確認后給買家發(fā)短信通知
根據(jù)業(yè)務(wù)場景，我們大致可拆分為：用戶流程、訂單流程
用戶登錄流程
在用戶登錄流程中，可能用到攔截器做鑒權(quán)校驗，日志記錄接口參數(shù)等，使用了一些常見的設(shè)計模式。
場景一、用戶鑒權(quán)校驗
責(zé)任鏈模式
攔截器通常按照定義的順序執(zhí)行，每個攔截器檢查特定的條件或執(zhí)行特定的任務(wù)。
// 攔截器接口
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; // 示例，實際中應(yīng)有具體校驗邏輯
}
}
// 鑒權(quán)校驗攔截器
public class AuthorizationInterceptor implements Interceptor {
@Override
public boolean intercept(AuthenticationContext context) {
// 鑒權(quán)校驗邏輯
if (isAuthorized(context.getUser(), context.getCredentials())) {
return true;
}
return false;
}
private boolean isAuthorized(User user, Credentials credentials) {
// 校驗用戶是否有權(quán)限
return true; // 示例，實際中應(yīng)有具體校驗邏輯
}
}
// 攔截器鏈
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，則中斷鏈的執(zhí)行
return false;
}
}
return true;
}
}場景二、記錄用戶登錄信息
單例模式
日志記錄器通常設(shè)計為單例，確保全局只有一個實例。
Logger logger = LoggerFactory.getLoggerFactoryInstance().getLogger();
logger.log("This is a user log message");在這行代碼中，體現(xiàn)了單例模式的核心思想，確保了無論多少次調(diào)用LoggerFactory.getLoggerFactoryInstance()，都只會返回一個LoggerFactory實例。事實上，我們從源碼中也可以看到。
訂單流程
根據(jù)業(yè)務(wù)場景，核心訂單流程如下：
場景三、訂單校驗
工廠模式
使用工廠模式實現(xiàn)的CheckOrderFactory，它用于創(chuàng)建不同類型的訂單校驗服務(wù)實例。
同時，我們定義一個校驗接口ICheckOrderService，并創(chuàng)建了兩個實現(xiàn)類:購買數(shù)量校驗：CountCheckOrder和訂單參數(shù)校驗：ParamCheckOrder。
public interface ICheckOrderService {
boolean checkOrder(Object order);
String getErrorMessage();
}購買數(shù)量校驗的實現(xiàn)類CountCheckOrder：
public class CountCheckOrder implements ICheckOrderService {
@Override
public boolean checkOrder(Object order) {
// 假設(shè)order是一個包含購買數(shù)量的對象
int quantity = ((Order) order).getQuantity();
return quantity > 0; // 只允許購買數(shù)量大于0
}
@Override
public String getErrorMessage() {
return "購買數(shù)量必須大于0。";
}
}訂單參數(shù)校驗的實現(xiàn)類ParamCheckOrder：
public class ParamCheckOrder implements ICheckOrderService {
@Override
public boolean checkOrder(Object order) {
// 假設(shè)order是一個包含各種訂單參數(shù)的對象
// 這里可以添加具體的訂單參數(shù)校驗邏輯
return true; // 示例代碼，默認返回true
}
@Override
public String getErrorMessage() {
return "訂單參數(shù)校驗失敗。";
}
}工廠類CheckOrderFactory，用于創(chuàng)建不同類型的校驗服務(wù)實例：
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);
}
}
}使用工廠模式有利于業(yè)務(wù)類的實現(xiàn)和拓展，但是有時候也存在過度設(shè)計，導(dǎo)致寫了很多的業(yè)務(wù)類。
場景四、短信通知
觀察者模式（監(jiān)聽模式）
在Spring框架中，我們可以使用ApplicationEvent和ApplicationListener來實現(xiàn)事件發(fā)布和監(jiān)聽的功能。
假設(shè)我們要下發(fā)一個購買成功的短信提醒，那么就可以發(fā)布一個自定義的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類，它實現(xiàn)了ApplicationListener接口，用于監(jiān)聽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) {
// 在這里實現(xiàn)發(fā)送短信的邏輯
System.out.println("Sending SMS to " + phoneNumber + ": " + message);
}
}然后，在Spring的配置中啟用事件發(fā)布功能。配置一個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();
}
}最后，在業(yè)務(wù)邏輯中發(fā)布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) {
// 模擬購買完成的業(yè)務(wù)邏輯
// ...
// 發(fā)布購買成功事件
applicationEventPublisher.publishEvent(new PurchaseSuccessEvent(this, buyerPhoneNumber, orderId));
}
}總結(jié)
- 使用設(shè)計模式的宗旨：封裝變化的部分，維護不變的宗旨
- 好處：提高代碼拓展性，程序更優(yōu)雅更健壯
- 對開源框架設(shè)計模式的使用，要提高鑒賞能力
- 考慮可讀性，不可為了設(shè)計模式而過度設(shè)計
