工作中常用的6种设计模式
谈起设计模式，你一定会问？这玩意到底有啥用？我好像没用过也不影响做一个码农。也可能项目中实际用了，但是你不自知。虽然Java设计模式有23种，但是工作中常用的可能并没有那麽多。就像新华字典有多少字，你没必要都学一样。本章我们只谈常用的几种设计模式，通过设计模式的理念、规约、到应用，理解实战中如何正确使用设计模式，不论对面试还是实际工作中都有益处。
文章提纲
设计理念
最为Java开发者，程序员基本修养名言绝句：
该露露，该藏藏
该封装的要封装
万事万物兼对象
程序代码要健壮
我们简单归纳为2个核心词：高内聚、低耦合。
很小的时候看过动画片，封神演义中哪吒：三头八臂显威力，千征百战斗魔法。
我们根据这首歌词抽象一下，哪吒：三头八臂是静态特征，千征百战是动态技能。把这些特征归纳映射一下：类 = 属性 + 方法如下图：
以上是高内聚的概念，什么是低耦合？
如果可能，我写一本神话《封神演戏》，说哪吒有：三头九臂。你肯定和我吵吵，要给它再配一把兵器。虽然还没想好是啥，但是有个总则：绝对不影响先前这八臂的演技。这就是低耦合！！！所谓程序健壮、拓展性强，也是这个道理。我们真诚地希望：
上述例子不是特别恰当，但是对于设计模式，我们终级的理念是：封装变化的内容，保留不变的宗旨。
设计原则
设计原则可以归纳为2大类：
开闭原则（李氏替换，组合复用，依赖倒置）
规定：软件中的对象（类、模块、函数等等）应该对于扩展是开放的，但是对于修改是封闭的。换句话说，一个实体是允许在不改变它的源代码的前提下变更它的行为。
单一职责（接口隔离，迪米特法则）
规定：一个类只应该有一个职责，只有一个改变它的原因
Spring中的设计模式
在Spring框架中，各种设计模式被广泛应用以支持其强大的功能和灵活性。下面我将结合Spring的源码，鉴赏下Spring中常见的几种设计模式。
- 单例模式
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);
}
// ...
}
- 工厂模式
Spring使用工厂模式通过BeanFactory、ApplicationContext等接口创建和管理Bean对象。DefaultListableBeanFactory是Spring中Bean工厂的实现类。
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);
}
// ... 省略部分代码
}
- 代理模式
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);
}
// ...
}
- 观察者模式（监听模式）
在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) {
// ... 省略部分代码，处理类型不匹配异常
}
}
// ...
}
- 责任链模式
在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表示中断请求
}
// ... 其他方法实现
}
- 模版模式
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;
}
}
场景二、记录用户登录信息
单例模式
日志记录器通常设计为单例，确保全局只有一个实例。
