20K Java+AI 岗位高频考点 — 设计模式是写出优雅代码的基础,Spring源码中大量运用了23种设计模式。覆盖创建型/结构型/行为型模式、Spring中的设计模式应用、实战场景选型。
五种经典实现及对比:
| 实现方式 | 线程安全 | 延迟加载 | 防反射 | 防序列化 |
|---|---|---|---|---|
| 饿汉式 | ✅ | ❌ | ❌ | ❌ |
| DCL懒汉 | ✅ | ✅ | ❌ | ❌ |
| 静态内部类 | ✅ | ✅ | ❌ | ❌ |
| 枚举 | ✅ | ❌ | ✅ | ✅ |
| Spring单例Bean | ✅ | ✅ | - | - |
// 1. 饿汉式(类加载即创建)
public class EagerSingleton {
private static final EagerSingleton INSTANCE = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() { return INSTANCE; }
}
// 2. DCL懒汉式(Double-Checked Locking)
public class DCLSingleton {
private static volatile DCLSingleton instance; // volatile防止指令重排
private DCLSingleton() {}
public static DCLSingleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (DCLSingleton.class) {
if (instance == null) { // 第二次检查
instance = new DCLSingleton();
}
}
}
return instance;
}
}
// 3. 静态内部类(利用类加载机制保证线程安全)
public class InnerClassSingleton {
private InnerClassSingleton() {}
private static class Holder {
static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
public static InnerClassSingleton getInstance() { return Holder.INSTANCE; }
}
// 4. 枚举(Effective Java推荐,最安全)
public enum EnumSingleton {
INSTANCE;
public void doSomething() { }
}
Spring单例Bean:Spring IoC容器保证每个BeanDefinition只创建一个实例,存储在DefaultSingletonBeanRegistry.singletonObjects ConcurrentHashMap中。
结论:Spring的单例Bean本身不是线程安全的,但无状态Bean是安全的。
// ❌ 不安全:有状态的Singleton Bean
@Component
public class UnsafeService {
private int counter = 0; // 共享可变状态
public void increment() { counter++; } // 线程不安全
}
// ✅ 安全:无状态Singleton Bean(推荐)
@Component
public class SafeService {
public String process(String input) { // 无共享可变状态
return input.toUpperCase();
}
}
// ✅ 安全:ThreadLocal方案
@Component
public class ThreadSafeService {
private ThreadLocal<Integer> counter = ThreadLocal.withInitial(() -> 0);
public void increment() { counter.set(counter.get() + 1); }
}
解决有状态单例的方案:
@Scope("prototype"):每次获取创建新实例ThreadLocal:线程隔离| 模式 | 结构 | 产品 | 扩展性 |
|---|---|---|---|
| 简单工厂 | 1个工厂类 | 1种产品族 | 违反OCP |
| 工厂方法 | 每个产品1个工厂 | 1种产品 | 新增产品加工厂 |
| 抽象工厂 | 每个族1个工厂 | 多种产品族 | 新增族加工厂 |
// 工厂方法模式
public interface LoggerFactory { Logger createLogger(); }
public class FileLoggerFactory implements LoggerFactory {
public Logger createLogger() { return new FileLogger(); }
}
public class ConsoleLoggerFactory implements LoggerFactory {
public Logger createLogger() { return new ConsoleLogger(); }
}
// 抽象工厂模式(跨产品族)
public interface UIFactory {
Button createButton();
TextField createTextField();
}
public class WindowsUIFactory implements UIFactory {
public Button createButton() { return new WindowsButton(); }
public TextField createTextField() { return new WindowsTextField(); }
}
public class MacUIFactory implements UIFactory {
public Button createButton() { return new MacButton(); }
public TextField createTextField() { return new MacTextField(); }
}
Spring中的工厂:BeanFactory / ApplicationContext是最顶层的工厂,FactoryBean是工厂方法的具体应用。
FactoryBean:用来创建复杂Bean的特殊工厂Bean,Spring容器获取时调用getObject()返回实际对象。
// FactoryBean接口
public interface FactoryBean<T> {
T getObject() throws Exception; // 返回实际Bean实例
Class<?> getObjectType(); // 返回Bean类型
default boolean isSingleton() { return true; }
}
// 自定义FactoryBean示例
public class MyFactoryBean implements FactoryBean<MyService> {
@Override
public MyService getObject() {
return new MyService("complex-config");
}
@Override
public Class<?> getObjectType() {
return MyService.class;
}
}
// 获取FactoryBean本身:加 & 前缀
Object factory = applicationContext.getBean("&myFactoryBean");
// 获取FactoryBean创建的对象:不加前缀
MyService service = applicationContext.getBean("myFactoryBean");
典型应用:
SqlSessionFactoryBean创建SqlSessionFactoryProxyFactoryBean创建代理对象MessageChannel工厂适用:构造参数多(>4个)、很多可选参数、需要分步构建的复杂对象。
// Lombok @Builder
@Data
@Builder
public class HttpRequest {
private String url;
private String method;
@Builder.Default private int timeout = 5000;
private Map<String, String> headers;
private String body;
}
// 使用
HttpRequest request = HttpRequest.builder()
.url("https://api.example.com")
.method("POST")
.header("Content-Type", "application/json")
.body("{\"name\":\"test\"}")
.build();
Spring中的建造者模式:
RestTemplateBuilder:链式构建RestTemplateSpringSecurity:HttpSecurity链式配置BeanDefinitionBuilder:构建BeanDefinition
// Spring Security链式配置 = 建造者模式
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.csrf().disable()
.authorizeHttpRequests(auth -> auth
.requestMatchers("/public/**").permitAll()
.anyRequest().authenticated())
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and().addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
}
核心:通过拷贝已有实例创建新对象,避免重新初始化的开销。
// 浅拷贝 vs 深拷贝
@Data
public class Order implements Cloneable {
private String orderId;
private List<String> items; // 引用类型
private Address address; // 引用类型
@Override
public Order clone() {
try {
return (Order) super.clone(); // 浅拷贝:items和address仍是同一引用
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
}
// 深拷贝方案1:手动clone所有引用
public Order deepClone() {
Order cloned = this.clone();
cloned.setItems(new ArrayList<>(this.items));
cloned.setAddress(this.address.clone());
return cloned;
}
}
// 深拷贝方案2:序列化
@SuppressWarnings("unchecked")
public <T> T deepCopy(T obj) {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos)) {
oos.writeObject(obj);
try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis)) {
return (T) ois.readObject();
}
}
}
Spring原型Bean:@Scope("prototype")每次获取都创建新实例,AbstractBeanFactory.doGetBean()中判断scope为prototype时直接创建,不走缓存。
代理模式三要素:接口(Subject)、真实对象(RealSubject)、代理对象(Proxy)。
// 静态代理
public interface UserService {
User getUser(Long id);
}
public class UserServiceImpl implements UserService {
public User getUser(Long id) { return userMapper.selectById(id); }
}
public class UserServiceProxy implements UserService {
private UserService target;
public User getUser(Long id) {
log.info("before getUser");
User result = target.getUser(id);
log.info("after getUser");
return result;
}
}
Spring AOP代理创建流程:
@EnableAspectJAutoProxy
→ 导入 AspectJAutoProxyRegistrar
→ 注册 AnnotationAwareAspectJAutoProxyCreator (BeanPostProcessor)
→ postProcessAfterInitialization()
→ wrapIfNecessary() 创建代理
→ AopProxyFactory.getAopProxy()
→ JdkDynamicAopProxy 或 ObjenesisCglibAopProxy
| 维度 | JDK动态代理 | CGLIB |
|---|---|---|
| 代理方式 | 基于接口 | 基于子类继承 |
| 要求 | 目标类实现接口 | 目标类不能final |
| 性能 | 生成快,调用略慢 | 生成慢,调用快 |
| Spring默认 | Spring 5.x之前默认 | Spring Boot 2.x+默认 |
| 原理 | Proxy.newProxyInstance() | Enhancer.create() 生成子类 |
// JDK动态代理
public class JdkProxyDemo implements InvocationHandler {
private Object target;
public Object createProxy(Object target) {
this.target = target;
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log.info("before: {}", method.getName());
Object result = method.invoke(target, args);
log.info("after: {}", method.getName());
return result;
}
}
// CGLIB代理
public class CglibProxyDemo implements MethodInterceptor {
public Object createProxy(Class<?> targetClass) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
log.info("before: {}", method.getName());
Object result = proxy.invokeSuper(obj, args); // 调用父类方法
log.info("after: {}", method.getName());
return result;
}
}
Spring Boot 2.x默认使用CGLIB(spring.aop.proxy-target-class=true),因为大部分场景不强制要求接口。
| 维度 | 装饰器模式 | 代理模式 |
|---|---|---|
| 目的 | 增强功能 | 控制访问 |
| 对象创建 | 由调用方组合 | 由代理内部创建 |
| 层数 | 可多层装饰 | 通常一层 |
| 典型应用 | Java IO流 | Spring AOP |
// 装饰器模式:Java IO流(可层层包装)
InputStream in = new FileInputStream("data.txt"); // 被装饰者
in = new BufferedInputStream(in); // 装饰器1:缓冲
in = new GZIPInputStream(in); // 装饰器2:解压
Reader reader = new InputStreamReader(in, "UTF-8"); // 装饰器3:编码
// Spring中BeanWrapper是装饰器的应用
// BeanWrapperImpl包装Bean实例,增强属性访问能力
BeanWrapper wrapper = new BeanWrapperImpl(new User());
wrapper.setPropertyValue("name", "张三"); // 通过反射设置属性
适配器模式:将一个类的接口转换成客户端期望的另一种接口,使不兼容的类可以协同工作。
// Spring MVC的HandlerAdapter
// DispatcherServlet不直接调用Handler,而是通过适配器
public interface HandlerAdapter {
boolean supports(Object handler);
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);
}
// 适配不同类型的Handler
RequestMappingHandlerAdapter → 适配 @Controller 方法
HttpRequestHandlerAdapter → 适配 HttpRequestHandler
SimpleControllerHandlerAdapter → 适配 Controller 接口
// DispatcherServlet核心分发逻辑(简化)
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
Object handler = handlerMapping.getHandler(request); // 找到Handler
HandlerAdapter adapter = handlerAdapter.getAdapter(handler); // 找到适配器
adapter.handle(request, response, handler); // 统一调用
}
为什么用适配器:DispatcherServlet不需要知道具体Handler的类型,只通过HandlerAdapter统一调用。
客户端请求 → DispatcherServlet
├── HandlerMapping → 找到Handler
├── HandlerAdapter → 适配调用
│ ├── RequestMappingHandlerAdapter → @RequestMapping方法
│ ├── HttpRequestHandlerAdapter → HttpRequestHandler
│ └── SimpleControllerHandlerAdapter → Controller接口
├── ViewResolver → 视图解析
└── 返回响应
Spring AOP中的适配器:AdvisorAdapter将不同类型的Advice适配为MethodInterceptor。
// AdvisorAdapter适配器
public interface AdvisorAdapter {
boolean supports(Advice advice);
MethodInterceptor getInterceptor(Advisor advisor);
}
// 实现类:MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter、ThrowsAdviceAdapter
桥接模式:将抽象部分与实现部分分离,使它们可以独立变化。
// JDBC是经典的桥接模式
// 抽象层:Java API(Connection/Statement/ResultSet)
// 实现层:各数据库Driver
// 桥接点:DriverManager
// 切换数据库只需换Driver,应用代码不变
Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL
Class.forName("org.postgresql.Driver"); // PostgreSQL
Connection conn = DriverManager.getConnection(url, user, password);
// SLF4J日志桥接
// 抽象层:SLF4J API(Logger/LoggerFactory)
// 实现层:Logback / Log4j2 / JUL
// 桥接点:SLF4JServiceProvider
private static final Logger log = LoggerFactory.getLogger(MyService.class);
// 运行时由classpath中的实现决定用哪个日志框架
组合模式:将对象组合成树形结构以表示"部分-整体"的层次结构。
// Spring Cache的组合模式
// CacheManager(整体)→ 管理多个Cache(部分)
public interface CacheManager {
Cache getCache(String name); // 获取子节点
Collection<String> getCacheNames(); // 获取所有子节点名称
}
// CompositeCacheManager可以组合多个CacheManager
public class CompositeCacheManager implements CacheManager {
private final List<CacheManager> cacheManagers; // 组合子节点
}
// Spring Security的组合模式
// CompositeGrantedAuthority → 组合多个权限
// ProviderManager → 组合多个AuthenticationProvider
public class ProviderManager implements AuthenticationManager {
private List<AuthenticationProvider> providers; // 组合多个Provider
}
外观模式:为子系统中的一组接口提供统一的入口,简化调用。
// JdbcTemplate = JDBC的外观(封装Connection/Statement/ResultSet)
@Repository
public class UserDao {
@Autowired private JdbcTemplate jdbc;
public User findById(Long id) {
// 外观:一行代码隐藏了Connection创建、Statement执行、ResultSet处理、异常转换、资源关闭
return jdbc.queryForObject("SELECT * FROM user WHERE id = ?",
(rs, rowNum) -> {
User u = new User();
u.setId(rs.getLong("id"));
u.setName(rs.getString("name"));
return u;
}, id);
}
}
// SpringApplication.run() = Spring Boot启动的外观
// 内部封装了:创建ApplicationContext、注册Bean、刷新容器、启动内嵌服务器
SpringApplication.run(MyApp.class, args);
// RestTemplate = HTTP客户端的外观(封装URLConnection/HttpClient)
// 简化了HTTP连接创建、请求构建、响应解析、异常处理
策略模式:定义一系列算法,将每一个算法封装起来,并使它们可以互相替换。
// Spring的Resource接口 = 策略模式
// 不同策略处理不同来源的资源
Resource r1 = new ClassPathResource("config.xml"); // classpath策略
Resource r2 = new FileSystemResource("/etc/app.xml"); // 文件系统策略
Resource r3 = new UrlResource("https://example.com"); // URL策略
// Spring的InstantiationStrategy = 策略模式
// CglibSubclassingInstantiationStrategy vs SimpleInstantiationStrategy
// @Qualifier = 运行时选择策略
@Service
public class PaymentService {
@Autowired
@Qualifier("wechatPayStrategy") // 指定具体策略
private PayStrategy payStrategy;
}
经典场景:支付方式选择,用策略模式替代大量if-else分支。
// 策略接口
public interface PayStrategy {
String getType(); // 策略标识
PayResult pay(PayOrder order); // 执行逻辑
}
// 具体策略
@Service("alipayStrategy")
public class AlipayStrategy implements PayStrategy {
public String getType() { return "ALIPAY"; }
public PayResult pay(PayOrder order) { /* 支付宝支付 */ }
}
@Service("wechatPayStrategy")
public class WechatPayStrategy implements PayStrategy {
public String getType() { return "WECHAT"; }
public PayResult pay(PayOrder order) { /* 微信支付 */ }
}
// Spring自动收集策略 → Map注入
@Service
public class PayService {
// Spring自动将所有PayStrategy实现注入Map,key为Bean名称
@Autowired
private Map<String, PayStrategy> strategyMap;
// 也可以用List注入
@Autowired
private List<PayStrategy> strategyList;
public PayResult pay(String type, PayOrder order) {
PayStrategy strategy = strategyList.stream()
.filter(s -> s.getType().equals(type))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException("不支持的支付方式: " + type));
return strategy.pay(order);
}
}
观察者模式:定义对象间一对多的依赖关系,当一个对象状态改变时,所有依赖者收到通知。
// Spring Event机制 = 观察者模式
// 1. 定义事件
public class OrderCreatedEvent extends ApplicationEvent {
private final Order order;
public OrderCreatedEvent(Object source, Order order) {
super(source);
this.order = order;
}
public Order getOrder() { return order; }
}
// 2. 发布事件
@Service
public class OrderService {
@Autowired private ApplicationEventPublisher publisher;
public void createOrder(Order order) {
orderMapper.insert(order);
publisher.publishEvent(new OrderCreatedEvent(this, order)); // 发布
}
}
// 3. 监听事件
@Component
public class StockListener {
@EventListener
public void onOrderCreated(OrderCreatedEvent event) {
stockService.deduct(event.getOrder()); // 扣减库存
}
}
// Spring Boot内置事件
// ApplicationContextInitializedEvent → ApplicationPreparedEvent → ContextRefreshedEvent → ApplicationStartedEvent → ApplicationReadyEvent
// 自定义事件 + @TransactionalEventListener(事务提交后才处理)
@Component
public class OrderEventListener {
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreated(OrderCreatedEvent event) {
// 事务提交后才执行,保证数据一致性
smsService.sendNotification(event.getOrder());
pointsService.addPoints(event.getOrder());
logisticsService.createDelivery(event.getOrder());
}
// 异步事件处理
@Async
@EventListener
public void handleAsync(OrderCreatedEvent event) {
reportService.updateStatistics(event.getOrder()); // 耗时统计
}
}
// 启用异步支持
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(4);
executor.setMaxPoolSize(8);
executor.setQueueCapacity(100);
return executor;
}
}
模板方法:父类定义算法骨架,子类实现具体步骤,不改变算法结构。
// Spring的xxTemplate全家桶
JdbcTemplate → 封装JDBC操作骨架
RedisTemplate → 封装Redis操作骨架
RestTemplate → 封装HTTP操作骨架
TransactionTemplate → 封装事务操作骨架
// AbstractApplicationContext.refresh() = 模板方法
// 定义了容器刷新的骨架流程,子类可覆盖具体步骤
public void refresh() {
prepareRefresh(); // 1. 准备
obtainFreshBeanFactory(); // 2. 创建BeanFactory
prepareBeanFactory(beanFactory); // 3. 配置BeanFactory
postProcessBeanFactory(beanFactory); // 4. 子类扩展点
invokeBeanFactoryPostProcessors(beanFactory); // 5. 执行BeanFactory后置处理
registerBeanPostProcessors(beanFactory); // 6. 注册Bean后置处理器
initMessageSource(); // 7. 国际化
initApplicationEventMulticaster(); // 8. 事件广播
onRefresh(); // 9. 子类扩展点(模板方法)
registerListeners(); // 10. 注册监听器
finishBeanFactoryInitialization(beanFactory); // 11. 初始化单例Bean
finishRefresh(); // 12. 完成刷新
}
// JdbcTemplate.execute() 定义了操作骨架
public <T> T execute(StatementCallback<T> action) {
Connection con = DataSourceUtils.getConnection(dataSource); // 1. 获取连接
Statement stmt = null;
try {
stmt = con.createStatement(); // 2. 创建Statement
T result = action.doInStatement(stmt); // 3. 回调(变化的部分)
return result;
} catch (SQLException ex) {
throw translateException(ex); // 4. 统一异常转换
} finally {
JdbcUtils.closeStatement(stmt); // 5. 关资源
DataSourceUtils.releaseConnection(con, dataSource);
}
}
// 使用:只需关注变化的部分
jdbcTemplate.execute(conn -> {
// 回调:只写业务SQL,其余(连接/关闭/异常)由模板处理
CallableStatement cs = conn.prepareCall("{call update_salary(?,?)}");
cs.setLong(1, empId);
cs.setDouble(2, newSalary);
return cs.executeUpdate();
});
// RowMapper也是回调策略
List<User> users = jdbc.query("SELECT * FROM user",
(rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name")));
责任链:将请求沿着处理者链传递,每个处理者决定是否处理及是否传递。
请求 → Filter1 → Filter2 → Filter3 → Servlet
↓ ↓ ↓
日志记录 身份认证 权限校验
| 框架 | 责任链实现 |
|---|---|
| Servlet | FilterChain + Filter |
| Spring Security | SecurityFilterChain |
| Spring MVC | HandlerInterceptor链 |
| MyBatis | InterceptorChain + Interceptor |
// Spring MVC Interceptor链
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new AuthInterceptor()).addPathPatterns("/api/**");
registry.addInterceptor(new LogInterceptor()).addPathPatterns("/api/**");
registry.addInterceptor(new RateLimitInterceptor()).addPathPatterns("/api/**");
}
}
// Interceptor调用链路(DispatcherServlet中)
// applyPreHandle → 逐个调用preHandle → 任一返回false则停止
// 执行Handler
// applyPostHandle → 逐个调用postHandle(逆序)
// triggerAfterCompletion → 逐个调用afterCompletion(逆序)
// SecurityFilterChain:安全过滤器责任链
// DelegatingFilterProxy桥接Servlet Filter和Spring Bean
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.addFilterBefore(new JwtAuthFilter(), UsernamePasswordAuthenticationFilter.class)
.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(auth -> auth
.requestMatchers("/public/**").permitAll()
.anyRequest().authenticated());
return http.build();
}
}
// 默认过滤器链顺序(FilterOrderRegistration)
// ChannelProcessingFilter → ConcurrentSessionFilter → SecurityContextPersistenceFilter
// → LogoutFilter → UsernamePasswordAuthenticationFilter → DefaultLoginPageGeneratingFilter
// → BasicAuthenticationFilter → ... → ExceptionTranslationFilter → FilterSecurityInterceptor
自定义Filter注册方式:
addFilterBefore(filter, beforeClass):在指定Filter之前addFilterAfter(filter, afterClass):在指定Filter之后addFilterAt(filter, atClass):替换指定位置的Filter
// MyBatis四大对象的拦截链
// Executor → StatementHandler → ParameterHandler → ResultSetHandler
@Intercepts({
@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
@Component
public class SqlLogInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
long start = System.currentTimeMillis();
Object result = invocation.proceed(); // 传递给下一个拦截器
long cost = System.currentTimeMillis() - start;
log.info("SQL执行耗时: {}ms", cost);
return result;
}
@Override
public Object plugin(Object target) {
// 使用Plugin.wrap()创建代理(动态代理实现拦截)
return Plugin.wrap(target, this);
}
}
// 插件注册顺序:mybatis-config.xml或Spring Bean
// InterceptorChain.pluginAll()依次调用plugin(),形成多层代理
命令模式:将请求封装为对象,实现请求的参数化、排队、日志和撤销。
// Runnable = 最经典的命令接口
Runnable command = () -> System.out.println("执行任务");
Thread thread = new Thread(command); // 命令对象传入Thread
thread.start();
// 命令模式实现操作撤销
public interface Command {
void execute();
void undo();
}
public class TextEditor {
private StringBuilder text = new StringBuilder();
private Stack<Command> history = new Stack<>();
public void write(String content) {
Command cmd = new WriteCommand(text, content);
cmd.execute();
history.push(cmd);
}
public void undo() {
if (!history.isEmpty()) {
history.pop().undo();
}
}
}
// Spring Batch Tasklet = 命令模式
public class ImportTasklet implements Tasklet {
public RepeatStatus execute(StepContribution contribution, ChunkContext context) {
// 执行数据导入任务
return RepeatStatus.FINISHED;
}
}
// Collection.iterator() = 最基本的迭代器模式
List<String> list = Arrays.asList("a", "b", "c");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
// Java Stream = 迭代器 + 策略模式 + 函数式编程
list.stream()
.filter(s -> s.startsWith("a")) // 策略:过滤条件
.map(String::toUpperCase) // 策略:转换逻辑
.forEach(System.out::println); // 迭代消费
// Spring的CompositeIterator(组合+迭代器)
public class CompositeIterator<E> implements Iterator<E> {
private final List<Iterator<E>> iterators;
// 组合多个迭代器,统一遍历
}
中介者:用一个中介对象封装一系列对象交互,使对象不需要显式引用彼此。
// DispatcherServlet = 典型的中介者
// 它协调HandlerMapping、HandlerAdapter、ViewResolver等多个组件
// 各组件之间不直接通信,都通过DispatcherServlet交互
客户端请求 → DispatcherServlet(中介者)
├── 咨询 HandlerMapping → 得到Handler
├── 咨询 HandlerAdapter → 执行Handler
├── 咨询 ViewResolver → 解析视图
└── 返回响应
// 聊天室场景
public class ChatRoom { // 中介者
public static void showMessage(User user, String message) {
System.out.println(user.getName() + ": " + message);
}
}
public class User {
public void sendMessage(String msg) {
ChatRoom.showMessage(this, msg); // 通过中介者发送
}
}
备忘录:在不破坏封装的前提下,捕获对象内部状态,以便之后恢复。
// 备忘录模式实现撤销功能
public class EditorMemento { // 备忘录
private final String content;
public EditorMemento(String content) { this.content = content; }
public String getContent() { return content; }
}
public class TextEditor {
private StringBuilder content = new StringBuilder();
private Stack<EditorMemento> history = new Stack<>();
public void write(String text) {
history.push(new EditorMemento(content.toString())); // 保存快照
content.append(text);
}
public void undo() {
if (!history.isEmpty()) {
content = new StringBuilder(history.pop().getContent()); // 恢复快照
}
}
}
// Spring WebFlow的FlowExecution = 备忘录模式
// FlowExecutionSnapshot保存流程执行状态,支持流程恢复和重试
状态模式:允许对象在内部状态改变时改变行为,对象看起来像是修改了类。
// 订单状态机(不用状态模式 → 大量if-else)
// 用状态模式:
public interface OrderState {
void handle(OrderContext context);
}
public class PaidState implements OrderState {
public void handle(OrderContext context) {
context.setState(new ShippedState());
logisticsService.ship(context.getOrder());
}
}
// Spring StateMachine
@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStatus, OrderEvent> {
@Override
public void configure(StateMachineStateConfigurer<OrderStatus, OrderEvent> states) throws Exception {
states.withStates()
.initial(OrderStatus.CREATED)
.states(EnumSet.allOf(OrderStatus.class));
}
@Override
public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderEvent> transitions) throws Exception {
transitions
.withExternal().source(CREATED).target(PAID).event(PAY)
.and()
.withExternal().source(PAID).target(SHIPPED).event(SHIP)
.and()
.withExternal().source(SHIPPED).target(COMPLETED).event(COMPLETE);
}
}
访问者模式:表示一个作用于某对象结构中各元素的操作,使你可以在不改变各元素类的前提下定义新操作(Double Dispatch)。
// Java ASM字节码操作 = 访问者模式
// ClassReader读取字节码 → ClassVisitor访问各种结构
public class MyClassVisitor extends ClassVisitor {
@Override
public MethodVisitor visitMethod(int access, String name, String desc,
String signature, String[] exceptions) {
// 访问方法
return super.visitMethod(access, name, desc, signature, exceptions);
}
}
// Spring的BeanDefinitionVisitor
// 访问BeanDefinition中的各种属性值(用于属性占位符替换)
public class BeanDefinitionVisitor {
public void visitBeanDefinition(BeanDefinition beanDefinition) {
visitParentName(beanDefinition.getParentName()); // 访问父名称
visitBeanClassName(beanDefinition.getBeanClassName()); // 访问类名
// ... 访问所有属性
}
}
解释器模式:给定一个语言,定义其文法的一种表示,并定义一个解释器来解释句子。
// Spring EL表达式(SpEL)= 解释器模式
ExpressionParser parser = new SpelExpressionParser();
// 基本表达式
Expression exp = parser.parseExpression("'Hello ' + name");
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("name", "World");
String result = exp.getValue(context, String.class); // "Hello World"
// 方法调用
parser.parseExpression("#service.process(#data)").getValue(context);
// 安全表达式(@PreAuthorize)
@PreAuthorize("hasRole('ADMIN') and @securityService.canAccess(#id)")
public User getUser(Long id) { ... }
// SpEL内部实现
// ExpressionParser → 词法分析 → 语法分析 → AST(抽象语法树)→ 解释执行
// SpelExpression → CompositeExpression → OpAnd/OpOr/Literal/MethodReference等节点
┌─────────────────────────────────────────────────────────┐
│ Spring IoC容器设计模式全景 │
├─────────────┬───────────────────────────────────────────┤
│ 工厂模式 │ BeanFactory / ApplicationContext创建Bean │
│ 单例模式 │ 默认scope=singleton │
│ 观察者模式 │ ApplicationEvent + EventListener │
│ 模板方法 │ AbstractApplicationContext.refresh() │
│ 策略模式 │ Resource接口不同实现 │
│ 装饰器模式 │ BeanWrapper增强属性访问 │
│ 适配器模式 │ BeanDefinitionReader适配不同配置源 │
│ 外观模式 │ ApplicationContext统一入口 │
└─────────────┴───────────────────────────────────────────┘
Bean生命周期中的设计模式:
解析(策略) → 注册(工厂) → 实例化(工厂+策略) → 属性填充(装饰器)
→ 初始化(模板方法+观察者) → 使用 → 销毁(模板方法)
// AOP核心设计模式
// 1. 代理模式:JDK动态代理 / CGLIB
// AopProxy接口 → JdkDynamicAopProxy / CglibAopProxy
public interface AopProxy {
Object getProxy();
Object getProxy(ClassLoader classLoader);
}
// 2. 责任链模式:Advice链(InterceptorChain)
// MethodInvocation.proceed() 递归调用拦截器链
public interface MethodInterceptor {
Object invoke(MethodInvocation invocation) throws Throwable;
}
// 3. 策略模式:AopProxyFactory选择代理策略
public interface AopProxyFactory {
AopProxy createAopProxy(AdvisedSupport config);
}
// DefaultAopProxyFactory:有接口用JDK,无接口用CGLIB
// 4. 工厂模式:ProxyFactoryBean创建代理
ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
proxyFactoryBean.setTarget(new MyService());
proxyFactoryBean.addAdvice(new MyAdvice());
MyService proxy = (MyService) proxyFactoryBean.getObject();
// 1. 代理模式:TransactionInterceptor代理目标方法
// @Transactional注解 → AOP代理 → TransactionInterceptor拦截
// 2. 模板方法模式:TransactionTemplate
@Autowired private TransactionTemplate txTemplate;
public void transfer() {
txTemplate.execute(status -> {
accountMapper.deduct(fromId, amount);
accountMapper.add(toId, amount);
return null;
});
}
// 3. 策略模式:PlatformTransactionManager
// 不同数据源使用不同的事务管理策略
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition);
void commit(TransactionStatus status);
void rollback(TransactionStatus status);
}
// DataSourceTransactionManager → JDBC/MyBatis
// JpaTransactionManager → JPA
// JtaTransactionManager → 分布式事务
// 4. 装饰器模式:事务连接包装
// TransactionAwareCacheDecorator / TransactionSynchronizationManager
配置文件/注解 → BeanDefinitionReader(策略)
├── XmlBeanDefinitionReader → XML解析策略
├── PropertiesBeanDefinitionReader → Properties解析
├── AnnotatedBeanDefinitionReader → 注解解析
└── GroovyBeanDefinitionReader → Groovy解析
↓
BeanDefinitionBuilder(建造者)
→ 构建BeanDefinition对象
↓
BeanDefinitionRegistry(工厂)
→ 注册到IoC容器
// BeanDefinitionBuilder = 建造者模式
BeanDefinition bd = BeanDefinitionBuilder
.genericBeanDefinition(UserService.class)
.addPropertyValue("name", "张三")
.addPropertyReference("dao", "userDao")
.setScope(BeanDefinition.SCOPE_SINGLETON)
.setInitMethodName("init")
.getBeanDefinition();
// 1. 工厂模式:SpringFactoriesLoader / ImportCandidates
// 加载META-INF/spring.factories或META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
List<String> configs = SpringFactoriesLoader.loadFactoryNames(
EnableAutoConfiguration.class, classLoader);
// 2. 条件模式(策略变体):@Conditional系列
@ConditionalOnClass(DataSource.class) // 类路径条件
@ConditionalOnMissingBean(DataSource.class) // Bean不存在条件
@ConditionalOnProperty("spring.datasource.url") // 配置条件
@ConditionalOnWebApplication // 应用类型条件
// 3. 建造者模式:SpringApplicationBuilder
new SpringApplicationBuilder(MyApp.class)
.profiles("dev")
.bannerMode(Banner.Mode.OFF)
.logStartupInfo(false)
.run(args);
// 4. 模板方法:AutoConfigurationImportSelector.selectImports()
// 定义自动配置的选择和过滤骨架流程
// 策略接口
public interface PayStrategy {
String getType();
PayResult pay(PayOrder order);
PayResult refund(PayOrder order);
}
// 微信支付策略
@Service
public class WechatPayStrategy implements PayStrategy {
public String getType() { return "WECHAT"; }
public PayResult pay(PayOrder order) { /* 调用微信支付API */ }
public PayResult refund(PayOrder order) { /* 调用微信退款API */ }
}
// 支付宝策略
@Service
public class AlipayStrategy implements PayStrategy {
public String getType() { return "ALIPAY"; }
public PayResult pay(PayOrder order) { /* 调用支付宝API */ }
public PayResult refund(PayOrder order) { /* 调用支付宝退款API */ }
}
// 工厂 + Spring自动收集
@Service
public class PayStrategyFactory {
private final Map<String, PayStrategy> strategyMap;
// Spring自动注入所有PayStrategy实现,key为Bean名称
public PayStrategyFactory(List<PayStrategy> strategies) {
this.strategyMap = strategies.stream()
.collect(Collectors.toMap(PayStrategy::getType, Function.identity()));
}
public PayStrategy getStrategy(String type) {
PayStrategy strategy = strategyMap.get(type);
if (strategy == null) throw new IllegalArgumentException("不支持的支付方式: " + type);
return strategy;
}
}
// 扩展新支付方式:只需新增一个Strategy实现类,零修改现有代码(OCP)
// 校验器接口
public interface Validator<T> {
ValidationResult validate(T target);
Validator<T> next();
}
// 抽象校验器
public abstract class AbstractValidator<T> implements Validator<T> {
private Validator<T> next;
public Validator<T> next() { return next; }
public AbstractValidator<T> setNext(Validator<T> next) {
this.next = next;
return this;
}
public ValidationResult chain(T target) {
ValidationResult result = validate(target);
if (!result.isValid()) return result;
return next != null ? next.validate(target) : ValidationResult.ok();
}
}
// 具体校验器
public class NotNullValidator<T> extends AbstractValidator<T> {
private String field;
public ValidationResult validate(T target) {
Object value = ReflectUtil.getFieldValue(target, field);
return value != null ? ValidationResult.ok()
: ValidationResult.fail(field + "不能为空");
}
}
// 使用:链式构建
Validator<User> chain = new NotNullValidator<>("name")
.setNext(new LengthValidator<>("name", 2, 20))
.setNext(new PatternValidator<>("phone", "^1[3-9]\\d{9}$"));
ValidationResult result = chain.chain(user);
// 事件定义
public class OrderStatusEvent extends ApplicationEvent {
private final Long orderId;
private final OrderStatus fromStatus;
private final OrderStatus toStatus;
// constructor, getters
}
// 事件发布
@Service
public class OrderService {
@Autowired private ApplicationEventPublisher publisher;
@Transactional
public void updateStatus(Long orderId, OrderStatus newStatus) {
Order order = orderMapper.selectById(orderId);
OrderStatus oldStatus = order.getStatus();
order.setStatus(newStatus);
orderMapper.updateById(order);
// 发布事件
publisher.publishEvent(new OrderStatusEvent(this, orderId, oldStatus, newStatus));
}
}
// 多个监听者解耦
@Component
public class StockListener {
@TransactionalEventListener(phase = AFTER_COMMIT)
public void onOrderPaid(OrderStatusEvent event) {
if (event.getToStatus() == PAID) {
stockService.deduct(event.getOrderId());
}
}
}
@Component
public class PointsListener {
@Async
@TransactionalEventListener(phase = AFTER_COMMIT)
public void onOrderCompleted(OrderStatusEvent event) {
if (event.getToStatus() == COMPLETED) {
pointsService.addPoints(event.getOrderId());
}
}
}
@Component
public class NotificationListener {
@EventListener
public void onStatusChange(OrderStatusEvent event) {
smsService.notify(event.getOrderId(), event.getToStatus());
}
}
// 抽象模板
public abstract class AbstractReportExporter {
// 模板方法:定义导出骨架
public final byte[] export(ReportQuery query) {
List<?> data = fetchData(query); // 1. 查询数据
Object processed = processData(data); // 2. 处理数据
byte[] content = generateFile(processed); // 3. 生成文件
postProcess(query, content); // 4. 后处理(日志/审计)
return content;
}
protected abstract List<?> fetchData(ReportQuery query); // 子类实现
protected abstract byte[] generateFile(Object data); // 子类实现
protected Object processData(List<?> data) { return data; } // 可选覆盖
protected void postProcess(ReportQuery query, byte[] content) { // 钩子方法
log.info("导出报表: {}条数据", content.length);
}
}
// Excel导出
@Service
public class ExcelReportExporter extends AbstractReportExporter {
protected List<?> fetchData(ReportQuery query) {
return reportMapper.queryList(query);
}
protected byte[] generateFile(Object data) {
return EasyExcel.write().sheet("报表").doWrite((List<?>) data).getBytes();
}
}
// PDF导出
@Service
public class PdfReportExporter extends AbstractReportExporter {
protected List<?> fetchData(ReportQuery query) {
return reportMapper.queryList(query);
}
protected byte[] generateFile(Object data) {
return pdfGenerator.generate((List<?>) data);
}
}
// JDK动态代理实现方法级缓存
public class CacheProxy implements InvocationHandler {
private final Object target;
private final CacheManager cacheManager;
public <T> T createProxy(T target) {
return (T) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new CacheProxy(target, cacheManager));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 检查缓存注解
Cacheable cacheable = method.getAnnotation(Cacheable.class);
if (cacheable == null) {
return method.invoke(target, args); // 无缓存注解,直接调用
}
String key = generateKey(cacheable.key(), method, args);
Object cached = cacheManager.getCache(cacheable.cacheName()).get(key);
if (cached != null) return cached; // 缓存命中
Object result = method.invoke(target, args); // 执行原方法
cacheManager.getCache(cacheable.cacheName()).put(key, result); // 写入缓存
return result;
}
}
// Spring Cache @Cacheable原理类似
// CacheInterceptor → CacheOperationInvocationHandler → 代理目标方法
@Cacheable(value = "users", key = "#id")
public User getUser(Long id) { return userMapper.selectById(id); }
// 装饰器:在Service外层包日志
public interface OrderService {
Order createOrder(OrderRequest request);
Order getOrder(Long id);
}
// 原始实现
@Service
public class OrderServiceImpl implements OrderService {
public Order createOrder(OrderRequest request) { /* 业务逻辑 */ }
public Order getOrder(Long id) { /* 业务逻辑 */ }
}
// 日志装饰器
@Component
public class LoggingOrderServiceDecorator implements OrderService {
private final OrderService delegate;
public LoggingOrderServiceDecorator(OrderServiceImpl delegate) {
this.delegate = delegate;
}
@Override
public Order createOrder(OrderRequest request) {
log.info("创建订单: {}", request);
long start = System.currentTimeMillis();
try {
Order result = delegate.createOrder(request);
log.info("创建订单成功: {}, 耗时: {}ms", result.getId(),
System.currentTimeMillis() - start);
return result;
} catch (Exception e) {
log.error("创建订单失败: {}", e.getMessage(), e);
throw e;
}
}
// getOrder()类似...
}
// 与静态代理区别:装饰器侧重增强功能、可多层叠加、由调用方组合
// 装饰器可以叠加:Logging → Metrics → Caching → 实际Service
// 数据源工厂接口
public interface DataSourceFactory {
DataSource createDataSource(DataSourceConfig config);
}
// MySQL工厂
public class MySQLDataSourceFactory implements DataSourceFactory {
public DataSource createDataSource(DataSourceConfig config) {
HikariDataSource ds = new HikariDataSource();
ds.setJdbcUrl("jdbc:mysql://" + config.getHost() + ":" + config.getPort() + "/" + config.getDatabase());
ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
ds.setUsername(config.getUsername());
ds.setPassword(config.getPassword());
return ds;
}
}
// PostgreSQL工厂
public class PostgreSQLDataSourceFactory implements DataSourceFactory {
public DataSource createDataSource(DataSourceConfig config) {
HikariDataSource ds = new HikariDataSource();
ds.setJdbcUrl("jdbc:postgresql://" + config.getHost() + ":" + config.getPort() + "/" + config.getDatabase());
ds.setDriverClassName("org.postgresql.Driver");
ds.setUsername(config.getUsername());
ds.setPassword(config.getPassword());
return ds;
}
}
// 动态数据源路由(AbstractRoutingDataSource = 策略模式)
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DataSourceContextHolder.get(); // 从ThreadLocal获取当前数据源key
}
}
// 命令接口
public interface Command {
void execute();
void undo();
String getDescription();
}
// 文本编辑命令
public class InsertCommand implements Command {
private TextEditor editor;
private int position;
private String text;
public void execute() { editor.insert(position, text); }
public void undo() { editor.delete(position, text.length()); }
public String getDescription() { return "插入: " + text; }
}
// 命令管理器
public class CommandManager {
private Stack<Command> undoStack = new Stack<>();
private Stack<Command> redoStack = new Stack<>();
public void execute(Command command) {
command.execute();
undoStack.push(command);
redoStack.clear();
}
public void undo() {
if (undoStack.isEmpty()) return;
Command cmd = undoStack.pop();
cmd.undo();
redoStack.push(cmd);
}
public void redo() {
if (redoStack.isEmpty()) return;
Command cmd = redoStack.pop();
cmd.execute();
undoStack.push(cmd);
}
}
// 状态接口
public interface WorkState {
void approve(WorkItemContext context);
void reject(WorkItemContext context);
String getName();
}
// 具体状态
public class DraftState implements WorkState {
public void approve(WorkItemContext context) {
context.setState(new PendingState()); // 草稿 → 待审核
}
public void reject(WorkItemContext context) {
// 草稿不可驳回
throw new IllegalStateException("草稿状态不可驳回");
}
public String getName() { return "DRAFT"; }
}
public class PendingState implements WorkState {
public void approve(WorkItemContext context) {
context.setState(new ApprovedState()); // 待审核 → 已审批
}
public void reject(WorkItemContext context) {
context.setState(new RejectedState()); // 待审核 → 已驳回
}
public String getName() { return "PENDING"; }
}
// 上下文
public class WorkItemContext {
private WorkState state;
public void approve() { state.approve(this); }
public void reject() { state.reject(this); }
public void setState(WorkState state) { this.state = state; }
}
// 对比if-else方案:
// if-else: 每次新增状态都要修改所有方法,违反OCP
// 状态模式: 新增状态只需新建State实现类,零修改现有代码
// 查询建造者
public class QueryBuilder {
private String table;
private List<String> selectColumns = new ArrayList<>();
private List<String> conditions = new ArrayList<>();
private List<String> orderBy = new ArrayList<>();
private Integer limit;
public QueryBuilder table(String table) { this.table = table; return this; }
public QueryBuilder select(String... columns) {
selectColumns.addAll(Arrays.asList(columns)); return this;
}
public QueryBuilder where(String condition) { conditions.add(condition); return this; }
public QueryBuilder orderBy(String column) { orderBy.add(column); return this; }
public QueryBuilder limit(int limit) { this.limit = limit; return this; }
public String build() {
StringBuilder sql = new StringBuilder("SELECT ");
sql.append(selectColumns.isEmpty() ? "*" : String.join(", ", selectColumns));
sql.append(" FROM ").append(table);
if (!conditions.isEmpty()) sql.append(" WHERE ").append(String.join(" AND ", conditions));
if (!orderBy.isEmpty()) sql.append(" ORDER BY ").append(String.join(", ", orderBy));
if (limit != null) sql.append(" LIMIT ").append(limit);
return sql.toString();
}
}
// 使用
String sql = new QueryBuilder()
.table("orders")
.select("id", "user_id", "amount")
.where("status = 'PAID'")
.where("create_time > '2025-01-01'")
.orderBy("create_time DESC")
.limit(100)
.build();
// SELECT id, user_id, amount FROM orders WHERE status = 'PAID' AND create_time > '2025-01-01' ORDER BY create_time DESC LIMIT 100
// MyBatis-Plus Wrapper也是建造者模式
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.select("id", "name", "age")
.eq("status", 1)
.between("age", 18, 60)
.orderByDesc("create_time")
.last("LIMIT 100");
建议从IoC/AOP切入,结合设计模式讲解:
1. IoC容器启动流程(AbstractApplicationContext.refresh())
├── BeanDefinition解析(策略模式:XML/注解/Groovy)
├── BeanFactoryPostProcessor扩展点
├── BeanPostProcessor注册
└── 单例Bean实例化(工厂+单例模式)
2. Bean生命周期
实例化 → 属性注入 → Aware回调 → BeanPostProcessor前置处理
→ InitializingBean → @PostConstruct → 自定义init
→ BeanPostProcessor后置处理(AOP代理在此创建)
→ 使用 → DisposableBean → @PreDestroy → 自定义destroy
3. AOP实现(代理+责任链)
AnnotationAwareAspectJAutoProxyCreator → 创建代理
→ MethodInterceptor责任链 → 依次执行Before/After/Around/AfterThrowing
4. 设计模式贯穿始终
工厂、单例、代理、策略、模板方法、观察者、适配器、装饰器
原则:不要为了设计模式而设计模式,先有问题再有模式。
过度设计的信号:
├── 3个类解决的问题用了10个类
├── 简单if-else被拆成策略工厂+反射
├── 只有一个实现的接口
├── 为了"未来扩展"预留了用不到的抽象
└── 团队成员看不懂代码在做什么
何时用设计模式:
├── if-else超过3层且持续增长 → 策略模式
├── 新增类型需要改多处代码 → 开闭原则
├── 多个子系统需要统一入口 → 外观模式
├── 需要动态增减功能 → 装饰器/责任链
└── 业务流程固定但步骤可变 → 模板方法
YAGNI原则(You Aren't Gonna Need It):
不确定会不会用到,就别提前抽象。
先写简单代码,等变化出现时再重构引入模式。
| 设计模式 | JDK应用 |
|---|---|
| 工厂模式 | Collections.singleton()、Executors.newFixedThreadPool()、URL.openConnection() |
| 装饰器模式 | java.io流全家桶(BufferedInputStream装饰FileInputStream) |
| 代理模式 | java.lang.reflect.Proxy |
| 适配器模式 | java.util.Arrays.asList()、InputStreamReader(字节→字符) |
| 桥接模式 | JDBC Driver / DriverManager |
| 迭代器模式 | Collection.iterator()、Scanner |
| 策略模式 | Comparator、Comparator.comparing()、Collections.sort(list, comparator) |
| 模板方法 | HttpServlet.doGet()/doPost()、AbstractList |
| 观察者模式 | java.util.Observable(已废弃)/ java.beans.PropertyChangeListener |
| 命令模式 | Runnable |
| 享元模式 | Integer.valueOf()缓存-128~127、String常量池 |
| 单例模式 | Runtime.getRuntime() |
四步识别法:
1. 看接口抽象
├── 有接口+多个实现 → 可能是策略/工厂
├── 接口只有一个实现 → 可能过度设计
└── 回调接口(一个方法)→ 可能是策略/命令/观察者
2. 看继承关系
├── 子类覆盖父类的某些方法但保持骨架 → 模板方法
├── 继承只为了扩展功能 → 装饰器
└── 继承只为了重写行为 → 状态/策略
3. 看对象创建方式
├── 通过工厂方法创建 → 工厂模式
├── 通过clone/序列化创建 → 原型模式
├── 通过建造者链式调用 → 建造者模式
└── 全局唯一实例 → 单例模式
4. 看调用链路
├── A包含B的引用且类型相同 → 组合/装饰器
├── 链式传递请求 → 责任链
├── 通过中介者交互 → 中介者
└── 事件驱动通知 → 观察者
开闭原则:对扩展开放,对修改关闭。
// ❌ 违反OCP:每新增一种通知方式都要修改此类
public class NotificationService {
public void notify(String type, String message) {
if (type.equals("SMS")) { smsService.send(message); }
else if (type.equals("EMAIL")) { emailService.send(message); }
else if (type.equals("WECHAT")) { wechatService.send(message); }
// 新增PUSH?又要改这里...
}
}
// ✅ 符合OCP:策略模式 + Spring自动收集
public interface NotifyStrategy {
String getType();
void send(String message);
}
@Service public class SmsNotify implements NotifyStrategy { /* ... */ }
@Service public class EmailNotify implements NotifyStrategy { /* ... */ }
// 新增通知方式:只需新建实现类,零修改现有代码
// OCP的实战体现总结:
// 1. 策略模式 → 新增策略不改代码
// 2. 观察者模式 → 新增监听器不改主题
// 3. 模板方法 → 新增子类不改骨架
// 4. 责任链 → 新增处理器不改链路
// 5. Spring @Conditional → 自动配置的条件化扩展
// 6. Spring SPI(spring.factories) → 框架扩展点
创建型5种:单例、工厂方法、抽象工厂、建造者、原型
>
结构型7种:代理、适配器、装饰器、外观、桥接、组合、享元
>
行为型11种:策略、观察者、模板方法、责任链、命令、迭代器、中介者、备忘录、状态、访问者、解释器
>
Spring核心四模式:工厂(BeanFactory)、代理(AOP)、模板(xxTemplate)、观察者(Event)
>
消除if-else三件套:策略模式(类型分支)、责任链(校验链)、状态模式(状态流转)
>
面试回答公式:模式定义 + 应用场景 + Spring源码出处 + 手写代码 + 对比区别