23种设计模式-框架中的使用

系列文章目录

---

一、单例模式

核心思想：保证一个类仅有一个实例，并提供全局访问点
框架应用：全局共享资源，比如spring中的单例bean

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {// 存储单例Bean的缓存（key：beanName，value：实例）private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);// 获取单例Bean，核心逻辑：不存在则创建，存在则直接返回@Overridepublic Object getSingleton(String beanName) {return getSingleton(beanName, true);}protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 先从缓存查Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {// 加锁保证线程安全（双重检查锁）synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {// 若未创建，调用createBean创建实例并放入缓存singletonObject = createBean(beanName); // 简化逻辑this.singletonObjects.put(beanName, singletonObject);}}}return singletonObject;}
}

spring通过concurrentHashmap缓存单例实例，结合sync保证线程安全，是懒汉式单例+DCL的实现

二、工厂模式

比如spring中的工厂模式，BeanFactory是spring的核心工厂接口，负责创建和管理Bean

// 工厂接口
public interface BeanFactory {// 获取Bean（由子类实现创建逻辑）Object getBean(String name) throws BeansException;<T> T getBean(Class<T> requiredType) throws BeansException;
}// 实现类：DefaultListableBeanFactory（Spring 最核心的Bean工厂）
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory {// 存储Bean定义（创建Bean的元数据）private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);@Overridepublic Object getBean(String name) throws BeansException {// 根据Bean定义创建实例（简化逻辑）BeanDefinition bd = beanDefinitionMap.get(name);return createBean(bd); // 封装了复杂的创建逻辑（如依赖注入、初始化）}
}

用的时候，只需要通过getBean（“xxx”）获取对象，不需要关心Bean的创建依赖注入等细节，由工厂统一处理

三、代理模式

核心思想：通过代理对象控制原对象的访问，可以在原逻辑前后添加额外操作（日志，事务）

3.1 Spring AOP 中的动态代理

spring AOP基于JDK动态代理或者CGLIB代理实现，例如事务管理

// JDK动态代理示例（Spring 内部逻辑简化）
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {private final AdvisedSupport advised;public JdkDynamicAopProxy(AdvisedSupport config) {this.advised = config;}// 创建代理对象@Overridepublic Object getProxy() {return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),advised.getTargetSource().getTargetClass(),this // InvocationHandler，负责增强逻辑);}// 代理对象的方法调用会触发这里@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 1. 执行前置增强（如事务开始）List<Object> chain = advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);// 2. 执行目标方法（原对象的业务逻辑）Object retVal = method.invoke(target, args);// 3. 执行后置增强（如事务提交）return retVal;}
}

3.2 MyBatis中的Mapper代理

MyBatis 的 Mapper 接口没有实现类，通过代理生成实现

// Mapper代理工厂
public class MapperProxyFactory<T> {private final Class<T> mapperInterface;public MapperProxyFactory(Class<T> mapperInterface) {this.mapperInterface = mapperInterface;}// 创建代理对象public T newInstance(SqlSession sqlSession) {final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface);return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(),new Class[] { mapperInterface },mapperProxy);}
}// 代理逻辑
public class MapperProxy<T> implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 当调用Mapper接口的方法（如selectById），代理对象会执行SQL查询return sqlSession.selectOne(method.getName(), args);}
}

四、适配器模式

核心思想：将一个类的接口转换成客户端期望的另一个接口，解决接口不兼容问题
gateway过滤器里面的适配器模式

4.1.代码片段

这个实例gateway底层会把所有的过滤器整合到一起，所有的指的是普通过滤和全局过滤器

//普通过滤器实现GateWayFilter接口
List<GatewayFilter> gatewayFilters = route.getFilters();
//全局过滤器实现GlobalFilter接口
List<GatewayFilter> combined = new ArrayList(this.globalFilters);//从下面可以看出，全局过滤器怎么来的，是通过调用loadFilters(globalFilters);//GlobalFilter适配为GatewayFilter，适配是经过GatewayFilterAdapter ，所以这一行代码：
//List<GatewayFilter> combined = new ArrayList(this.globalFilters);
//最终也是成为普通过滤器
public class FilteringWebHandler implements WebHandler {public FilteringWebHandler(List<GlobalFilter> globalFilters) {this.globalFilters = loadFilters(globalFilters);}private static List<GatewayFilter> loadFilters(List<GlobalFilter> filters) {return (List)filters.stream().map((filter) -> {GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);if (filter instanceof Ordered) {int order = ((Ordered)filter).getOrder();return new OrderedGatewayFilter(gatewayFilter, order);} else {Order orderx = (Order)AnnotationUtils.findAnnotation(filter.getClass(), Order.class);return (GatewayFilter)(orderx != null ? new OrderedGatewayFilter(gatewayFilter, orderx.value()) : gatewayFilter);}}).collect(Collectors.toList());}

4.2、SpringMVC中的HandlerAdapter

spring mvc中，控制器有多种实现，@Controller\HttpRequestHandler, HandlerAdapter适配不同控制器接口，让DispatcherServlet统一调用

// 适配器接口
public interface HandlerAdapter {// 判断是否支持该控制器boolean supports(Object handler);// 执行控制器逻辑ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}// 适配 @Controller 注解的控制器
public class RequestMappingHandlerAdapter implements HandlerAdapter {@Overridepublic boolean supports(Object handler) {return handler instanceof HandlerMethod; // 检查是否是@Controller的方法}@Overridepublic ModelAndView handle(...) {// 调用@Controller中的@RequestMapping方法（适配逻辑）return invokeHandlerMethod(request, response, (HandlerMethod) handler);}
}// 适配 HttpRequestHandler 接口的控制器
public class SimpleControllerHandlerAdapter implements HandlerAdapter {@Overridepublic boolean supports(Object handler) {return handler instanceof HttpRequestHandler;}@Overridepublic ModelAndView handle(...) {((HttpRequestHandler) handler).handleRequest(request, response);return null;}
}

五、责任链模式

责任链模式（Chain of Responsibility） 是一种行为型设计模式，它让多个对象有机会处理请求，从而避免请求的发送者与接收者之间的耦合。请求沿着链传递，直到有对象能够处理它为止。

5.1、Spring Cloud Gateway 中的 Filter

在 Spring Cloud Gateway 中，每个 Filter 都可以对请求或响应进行处理。它们被组织成一个过滤器链（Filter Chain），按照一定的顺序依次执行。
每个 Filter 调用 chain.filter(exchange) 来将请求传递给下一个 Filter。
这种结构类似于责任链：每个节点决定是否处理请求，或者将请求传递给下个节点。

public class MyFilter implements GatewayFilter {@Overridepublic Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {// 做一些处理...return chain.filter(exchange); // 把请求传给下一个 Filter}
}

解耦请求的发起者和处理者: 请求（如 HTTP 请求）不需要知道具体的 Filter 是谁，只需要按顺序调用即可。
动态扩展性: 可以在运行时动态添加或移除 Filter，而无需修改原有代码。
灵活控制流程: 某些 Filter 可以提前终止请求（比如权限校验失败），而不必继续传递下去。
职责分离: 每个 Filter 只负责一个功能（如日志记录、限流、鉴权等）。

六、享元模式

待更新