Java 设计模式

单例模式（Singleton）

1. UML类图

   +------------------------+
   |       Singleton       |
   +------------------------+
   | -instance: Singleton  |
   | -Singleton()         |
   | +getInstance()        |
   +------------------------+
   

2. 实现方式

   • 饿汉式

   public class EagerSingleton {
       private static final EagerSingleton instance = new EagerSingleton();
       private EagerSingleton() {}
       public static EagerSingleton getInstance() {
           return instance;
       }
   }
   

   • 懒汉式（线程安全）

   public class LazySingleton {
       private static LazySingleton instance;
       private LazySingleton() {}
       public static synchronized LazySingleton getInstance() {
           if (instance == null) {
               instance = new LazySingleton();
           }
           return instance;
       }
   }
   

   • 双重检查锁定

   public class DoubleCheckedSingleton {
       private static volatile DoubleCheckedSingleton instance;
       private DoubleCheckedSingleton() {}
       public static DoubleCheckedSingleton getInstance() {
           if (instance == null) {
               synchronized (DoubleCheckedSingleton.class) {
                   if (instance == null) {
                       instance = new DoubleCheckedSingleton();
                   }
               }
           }
           return instance;
       }
   }
   

   • 静态内部类

   public class StaticInnerSingleton {
       private StaticInnerSingleton() {}
       private static class SingletonHolder {
           private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
       }
       public static StaticInnerSingleton getInstance() {
           return SingletonHolder.INSTANCE;
       }
   }
   

   • 枚举

   public enum EnumSingleton {
       INSTANCE;
       private EnumSingleton() {}
       public void doSomething() {
           // 业务方法
       }
   }
   

3. 最佳实践

   • 线程安全考虑

   // 推荐使用静态内部类或枚举实现
   // 静态内部类实现延迟加载，且保证线程安全
   // 枚举实现最简单，自动处理序列化
   

   • 序列化问题

   public class SerializableSingleton implements Serializable {
       private static final long serialVersionUID = 1L;
       private static final SerializableSingleton instance = new SerializableSingleton();
       
       private SerializableSingleton() {}
       
       public static SerializableSingleton getInstance() {
           return instance;
       }
       
       // 防止序列化破坏单例
       protected Object readResolve() {
           return instance;
       }
   }
   

   • 反射攻击防护

   public class ReflectionSafeSingleton {
       private static final ReflectionSafeSingleton instance = new ReflectionSafeSingleton();
       
       private ReflectionSafeSingleton() {
           if (instance != null) {
               throw new IllegalStateException("单例已存在，不能通过反射创建新实例");
           }
       }
       
       public static ReflectionSafeSingleton getInstance() {
           return instance;
       }
   }
   

4. Spring框架中的应用

   @Configuration
   public class SingletonBeanConfig {
       @Bean
       @Scope("singleton") // 默认就是单例
       public MyService myService() {
           return new MyService();
       }
   }
   

工厂模式

1. 简单工厂

   +------------------+       +------------------+
   |   SimpleFactory  |       |     Product     |
   +------------------+       +------------------+
   | +createProduct() |------>| +operation()     |
   +------------------+       +------------------+
                                      ^
                                      |
                             +------------------+
                             | ConcreteProduct  |
                             +------------------+
                             | +operation()     |
                             +------------------+
   

   // 产品接口
   interface Product {
       void operation();
   }
   
   // 具体产品
   class ConcreteProductA implements Product {
       public void operation() {
           System.out.println("ConcreteProductA");
       }
   }
   
   class ConcreteProductB implements Product {
       public void operation() {
           System.out.println("ConcreteProductB");
       }
   }
   
   // 简单工厂
   class SimpleFactory {
       public static Product createProduct(String type) {
           switch (type) {
               case "A": return new ConcreteProductA();
               case "B": return new ConcreteProductB();
               default: throw new IllegalArgumentException("Unknown product type");
           }
       }
   }
   

2. 工厂方法

   +------------------+       +------------------+
   |     Factory     |       |     Product     |
   +------------------+       +------------------+
   | +createProduct() |       | +operation()     |
   +------------------+       +------------------+
           ^
           |                          ^
           |                          |
   +------------------+       +------------------+
   | ConcreteFactory  |       | ConcreteProduct  |
   +------------------+       +------------------+
   | +createProduct() |       | +operation()     |
   +------------------+       +------------------+
   

   // 产品接口
   interface Product {
       void operation();
   }
   
   // 具体产品
   class ConcreteProductA implements Product {
       public void operation() {
           System.out.println("ConcreteProductA");
       }
   }
   
   class ConcreteProductB implements Product {
       public void operation() {
           System.out.println("ConcreteProductB");
       }
   }
   
   // 工厂接口
   interface Factory {
       Product createProduct();
   }
   
   // 具体工厂
   class ConcreteFactoryA implements Factory {
       public Product createProduct() {
           return new ConcreteProductA();
       }
   }
   
   class ConcreteFactoryB implements Factory {
       public Product createProduct() {
           return new ConcreteProductB();
       }
   }
   

3. 抽象工厂

   +-------------------+      +------------------+
   |  AbstractFactory |      |    ProductA     |
   +-------------------+      +------------------+
   | +createProductA() |----->| +operation()     |
   | +createProductB() |      +------------------+
   +-------------------+              ^
           ^
           |                  +------------------+
           |                  | ConcreteProductA |
   +-------------------+      +------------------+
   | ConcreteFactory1  |      | +operation()     |
   +-------------------+      +------------------+
   | +createProductA() |
   | +createProductB() |      +------------------+
   +-------------------+      |    ProductB     |
                             +------------------+
                             | +operation()     |
                             +------------------+
                                     ^
                                     |
                             +------------------+
                             | ConcreteProductB |
                             +------------------+
                             | +operation()     |
                             +------------------+
   

   // 产品族A
   interface ProductA {
       void operationA();
   }
   
   class ConcreteProductA1 implements ProductA {
       public void operationA() {
           System.out.println("ConcreteProductA1");
       }
   }
   
   class ConcreteProductA2 implements ProductA {
       public void operationA() {
           System.out.println("ConcreteProductA2");
       }
   }
   
   // 产品族B
   interface ProductB {
       void operationB();
   }
   
   class ConcreteProductB1 implements ProductB {
       public void operationB() {
           System.out.println("ConcreteProductB1");
       }
   }
   
   class ConcreteProductB2 implements ProductB {
       public void operationB() {
           System.out.println("ConcreteProductB2");
       }
   }
   
   // 抽象工厂
   interface AbstractFactory {
       ProductA createProductA();
       ProductB createProductB();
   }
   
   // 具体工厂1
   class ConcreteFactory1 implements AbstractFactory {
       public ProductA createProductA() {
           return new ConcreteProductA1();
       }
       public ProductB createProductB() {
           return new ConcreteProductB1();
       }
   }
   
   // 具体工厂2
   class ConcreteFactory2 implements AbstractFactory {
       public ProductA createProductA() {
           return new ConcreteProductA2();
       }
       public ProductB createProductB() {
           return new ConcreteProductB2();
       }
   }
   

4. Spring框架中的应用

   // BeanFactory作为工厂模式的典型应用
   @Configuration
   public class FactoryConfig {
       @Bean
       public ProductService productService() {
           // 根据配置创建不同的产品服务实现
           return new ConcreteProductService();
       }
   
       @Bean
       public AbstractFactory abstractFactory() {
           // 根据条件选择不同的工厂实现
           return new ConcreteFactory1();
       }
   }
   

观察者模式（Observer）

1. UML类图

   +------------------+       +------------------+
   |     Subject     |       |    Observer     |
   +------------------+       +------------------+
   | -observers      |<>---->| +update()        |
   | +attach()       |       +------------------+
   | +detach()       |               ^
   | +notify()       |               |
   +------------------+       +------------------+
           ^
           |               |ConcreteObserver |
   +------------------+     +------------------+
   |ConcreteSubject  |     | +update()        |
   +------------------+     +------------------+
   | +getState()     |
   | +setState()     |
   +------------------+
   

2. 基本实现

   // 观察者接口
   interface Observer {
       void update(String message);
   }
   
   // 具体观察者
   class ConcreteObserver implements Observer {
       private String name;
   
       public ConcreteObserver(String name) {
           this.name = name;
       }
   
       @Override
       public void update(String message) {
           System.out.println(name + "收到通知：" + message);
       }
   }
   
   // 主题
   class Subject {
       private List<Observer> observers = new ArrayList<>();
       private String state;
   
       public void attach(Observer observer) {
           observers.add(observer);
       }
   
       public void detach(Observer observer) {
           observers.remove(observer);
       }
   
       public void setState(String state) {
           this.state = state;
           notifyObservers();
       }
   
       private void notifyObservers() {
           for (Observer observer : observers) {
               observer.update(state);
           }
       }
   }
   

3. Spring事件机制

   // 自定义事件
   public class UserCreatedEvent extends ApplicationEvent {
       private User user;
   
       public UserCreatedEvent(Object source, User user) {
           super(source);
           this.user = user;
       }
   
       public User getUser() {
           return user;
       }
   }
   
   // 事件发布者
   @Service
   public class UserService {
       @Autowired
       private ApplicationEventPublisher eventPublisher;
   
       public void createUser(User user) {
           // 保存用户
           userRepository.save(user);
           // 发布事件
           eventPublisher.publishEvent(new UserCreatedEvent(this, user));
       }
   }
   
   // 事件监听者
   @Component
   public class UserEventListener {
       @EventListener
       public void handleUserCreatedEvent(UserCreatedEvent event) {
           User user = event.getUser();
           // 处理用户创建事件
           System.out.println("新用户创建：" + user.getUsername());
       }
   }
   

设计模式应用场景

1. 创建型模式

   • 单例模式：配置管理、连接池
   • 工厂模式：日志记录器、数据库连接
   • 建造者模式：复杂对象构建

2. 结构型模式

   • 适配器：第三方库集成
   • 装饰器：动态添加功能
   • 代理：权限控制、缓存

3. 行为型模式

   • 策略：支付方式选择
   • 观察者：事件处理
   • 责任链：请求处理流程

反模式与优化

1. 常见反模式

   • 过度工程化
   • 模式滥用
   • 违反SOLID原则

2. 优化建议

   • 保持简单原则
   • 合理抽象
   • 考虑扩展性
   • 注重可测试性

实际项目应用

1. Web应用架构

   • MVC模式
   • 前端控制器
   • 视图组合器

2. 微服务架构

   • 服务注册与发现
   • 断路器模式
   • 网关模式

3. 企业应用集成

   • 适配器模式
   • 外观模式
   • 代理模式

建造者模式（Builder）

1. UML类图

   +------------------+       +------------------+
   |     Product     |       |     Builder     |
   +------------------+       +------------------+
   | -partA: String  |<------|+buildPartA()     |
   | -partB: String  |       |+buildPartB()     |
   | -partC: String  |       |+getResult()      |
   +------------------+       +------------------+
                                      ^
                                      |
                             +------------------+
                             |ConcreteBuilder  |
                             +------------------+
                             |+buildPartA()     |
                             |+buildPartB()     |
                             |+getResult()      |
                             +------------------+
   

2. 实现示例

   // 产品类
   class Computer {
       private String cpu;
       private String memory;
       private String disk;
       private String gpu;
   
       public void setCpu(String cpu) { this.cpu = cpu; }
       public void setMemory(String memory) { this.memory = memory; }
       public void setDisk(String disk) { this.disk = disk; }
       public void setGpu(String gpu) { this.gpu = gpu; }
   
       @Override
       public String toString() {
           return String.format("Computer[cpu=%s, memory=%s, disk=%s, gpu=%s]", 
                              cpu, memory, disk, gpu);
       }
   }
   
   // 抽象建造者
   interface ComputerBuilder {
       ComputerBuilder buildCpu(String cpu);
       ComputerBuilder buildMemory(String memory);
       ComputerBuilder buildDisk(String disk);
       ComputerBuilder buildGpu(String gpu);
       Computer build();
   }
   
   // 具体建造者
   class GamingComputerBuilder implements ComputerBuilder {
       private Computer computer = new Computer();
   
       public ComputerBuilder buildCpu(String cpu) {
           computer.setCpu(cpu);
           return this;
       }
   
       public ComputerBuilder buildMemory(String memory) {
           computer.setMemory(memory);
           return this;
       }
   
       public ComputerBuilder buildDisk(String disk) {
           computer.setDisk(disk);
           return this;
       }
   
       public ComputerBuilder buildGpu(String gpu) {
           computer.setGpu(gpu);
           return this;
       }
   
       public Computer build() {
           return computer;
       }
   }
   
   // 指挥者
   class Director {
       private ComputerBuilder builder;
   
       public Director(ComputerBuilder builder) {
           this.builder = builder;
       }
   
       public Computer constructGamingComputer() {
           return builder.buildCpu("Intel i9")
                         .buildMemory("32GB")
                         .buildDisk("2TB SSD")
                         .buildGpu("RTX 4090")
                         .build();
       }
   }
   

3. Lombok实现

   @Builder
   @Data
   public class User {
       private String username;
       private String password;
       private String email;
       private String phone;
   }
   
   // 使用示例
   User user = User.builder()
                   .username("john_doe")
                   .password("secure123")
                   .email("john@example.com")
                   .phone("+1234567890")
                   .build();
   

4. Spring框架中的应用

   // UriComponentsBuilder示例
   UriComponents uriComponents = UriComponentsBuilder.newInstance()
       .scheme("https")
       .host("api.example.com")
       .path("/users/{id}")
       .queryParam("format", "json")
       .buildAndExpand(42)
       .encode();
   
   // RestTemplateBuilder示例
   @Configuration
   public class RestTemplateConfig {
       @Bean
       public RestTemplate restTemplate(RestTemplateBuilder builder) {
           return builder
               .setConnectTimeout(Duration.ofSeconds(5))
               .setReadTimeout(Duration.ofSeconds(5))
               .basicAuthentication("user", "password")
               .build();
       }
   }
   

装饰器模式（Decorator）

1. UML类图

   +------------------+
   |    Component    |
   +------------------+
   | +operation()     |
   +------------------+
           ^
           |
   +------------------+       +------------------+
   |ConcreteComponent |       |    Decorator    |
   +------------------+       +------------------+
   | +operation()     |       | -component      |
   +------------------+       | +operation()     |
                             +------------------+
                                     ^
                                     |
                             +------------------+
                             |ConcreteDecorator |
                             +------------------+
                             | +operation()     |
                             | +addedBehavior() |
                             +------------------+
   

2. 基本实现

   // 组件接口
   interface Component {
       void operation();
   }
   
   // 具体组件
   class ConcreteComponent implements Component {
       @Override
       public void operation() {
           System.out.println("具体组件的操作");
       }
   }
   
   // 装饰器抽象类
   abstract class Decorator implements Component {
       protected Component component;
   
       public Decorator(Component component) {
           this.component = component;
       }
   
       @Override
       public void operation() {
           component.operation();
       }
   }
   
   // 具体装饰器A
   class ConcreteDecoratorA extends Decorator {
       public ConcreteDecoratorA(Component component) {
           super(component);
       }
   
       @Override
       public void operation() {
           super.operation();
           addedBehavior();
       }
   
       private void addedBehavior() {
           System.out.println("装饰器A的附加功能");
       }
   }
   
   // 具体装饰器B
   class ConcreteDecoratorB extends Decorator {
       public ConcreteDecoratorB(Component component) {
           super(component);
       }
   
       @Override
       public void operation() {
           super.operation();
           addedBehavior();
       }
   
       private void addedBehavior() {
           System.out.println("装饰器B的附加功能");
       }
   }
   

3. IO流装饰器示例

   // 使用Java IO中的装饰器模式
   try (InputStream in = new BufferedInputStream(
           new FileInputStream("file.txt"))) {
       // BufferedInputStream装饰FileInputStream
       byte[] buffer = new byte[1024];
       int bytesRead;
       while ((bytesRead = in.read(buffer)) != -1) {
           // 处理数据
       }
   }
   

4. Spring框架中的应用

   // Spring中的缓存装饰器
   @Configuration
   @EnableCaching
   public class CacheConfig {
       @Bean
       public CacheManager cacheManager() {
           return new ConcurrentMapCacheManager();
       }
   }
   
   @Service
   public class UserService {
       @Cacheable("users") // 使用缓存装饰器
       public User getUser(String id) {
           // 从数据库获取用户
           return userRepository.findById(id);
       }
   }
   
   // Spring Security中的过滤器装饰器
   @Configuration
   @EnableWebSecurity
   public class SecurityConfig extends WebSecurityConfigurerAdapter {
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.addFilterBefore(new CustomFilter(), 
                               UsernamePasswordAuthenticationFilter.class)
               .authorizeRequests()
               .anyRequest().authenticated();
       }
   }
   

5. 对象适配器实现

   // 对象适配器
   class ObjectAdapter implements Target {
       private Adaptee adaptee;
   
       public ObjectAdapter(Adaptee adaptee) {
           this.adaptee = adaptee;
       }
   
       @Override
       public void request() {
           adaptee.specificRequest();
       }
   }
   

6. Spring框架中的应用

   // Spring MVC中的HandlerAdapter
   public interface HandlerAdapter {
       boolean supports(Object handler);
       ModelAndView handle(HttpServletRequest request, 
                         HttpServletResponse response, 
                         Object handler) throws Exception;
   }
   
   // 适配不同类型的Handler
   @Component
   public class SimpleControllerHandlerAdapter implements HandlerAdapter {
       @Override
       public boolean supports(Object handler) {
           return handler instanceof Controller;
       }
   
       @Override
       public ModelAndView handle(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler) throws Exception {
           return ((Controller) handler).handleRequest(request, response);
       }
   }
   
   // 使用示例
   @Configuration
   public class WebConfig implements WebMvcConfigurer {
       @Override
       public void configureHandlerAdapters(List<HandlerAdapter> adapters) {
           adapters.add(new SimpleControllerHandlerAdapter());
       }
   }
   

代理模式（Proxy）

1. UML类图

   +------------------+
   |     Subject     |
   +------------------+
   | +request()       |
   +------------------+
           ^
           |
   +------------------+       +------------------+
   |      Proxy      |------>|  RealSubject    |
   +------------------+       +------------------+
   | -realSubject    |       | +request()       |
   | +request()      |       +------------------+
   +------------------+
   

2. 静态代理实现

   // 主题接口
   interface Subject {
       void request();
   }
   
   // 真实主题
   class RealSubject implements Subject {
       @Override
       public void request() {
           System.out.println("RealSubject处理请求");
       }
   }
   
   // 代理类
   class Proxy implements Subject {
       private RealSubject realSubject;
   
       public Proxy() {
           this.realSubject = new RealSubject();
       }
   
       @Override
       public void request() {
           before();
           realSubject.request();
           after();
       }
   
       private void before() {
           System.out.println("在请求之前做一些事情");
       }
   
       private void after() {
           System.out.println("在请求之后做一些事情");
       }
   }
   

3. JDK动态代理

   import java.lang.reflect.Proxy;
   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   
   // 动态代理处理器
   class DynamicProxyHandler implements InvocationHandler {
       private Object target;
   
       public DynamicProxyHandler(Object target) {
           this.target = target;
       }
   
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           before();
           Object result = method.invoke(target, args);
           after();
           return result;
       }
   
       private void before() {
           System.out.println("动态代理 - 前置处理");
       }
   
       private void after() {
           System.out.println("动态代理 - 后置处理");
       }
   }
   
   // 使用示例
   public class DynamicProxyDemo {
       public static void main(String[] args) {
           Subject realSubject = new RealSubject();
           InvocationHandler handler = new DynamicProxyHandler(realSubject);
           Subject proxy = (Subject) Proxy.newProxyInstance(
               realSubject.getClass().getClassLoader(),
               realSubject.getClass().getInterfaces(),
               handler
           );
           proxy.request();
       }
   }
   

4. CGLIB动态代理

   import org.springframework.cglib.proxy.Enhancer;
   import org.springframework.cglib.proxy.MethodInterceptor;
   import org.springframework.cglib.proxy.MethodProxy;
   
   // CGLIB代理处理器
   class CglibProxyInterceptor implements MethodInterceptor {
       @Override
       public Object intercept(Object obj, Method method, Object[] args,
                             MethodProxy proxy) throws Throwable {
           before();
           Object result = proxy.invokeSuper(obj, args);
           after();
           return result;
       }
   
       private void before() {
           System.out.println("CGLIB代理 - 前置处理");
       }
   
       private void after() {
           System.out.println("CGLIB代理 - 后置处理");
       }
   }
   
   // 使用示例
   public class CglibProxyDemo {
       public static void main(String[] args) {
           Enhancer enhancer = new Enhancer();
           enhancer.setSuperclass(RealSubject.class);
           enhancer.setCallback(new CglibProxyInterceptor());
           RealSubject proxy = (RealSubject) enhancer.create();
           proxy.request();
       }
   }
   

5. Spring AOP中的应用

   @Aspect
   @Component
   public class LoggingAspect {
       @Around("execution(* com.example.service.*.*(..))")  
       public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
           String methodName = joinPoint.getSignature().getName();
           
           // 前置处理
           System.out.println("开始执行方法: " + methodName);
           
           try {
               // 执行目标方法
               Object result = joinPoint.proceed();
               
               // 返回处理
               System.out.println("方法执行完成: " + methodName);
               return result;
           } catch (Exception e) {
               // 异常处理
               System.out.println("方法执行异常: " + methodName);
               throw e;
           }
       }
   }
   
   // 使用示例
   @Service
   public class UserService {
       @Transactional  // 事务代理
       public void updateUser(User user) {
           // 业务逻辑
       }
   }
   

策略模式（Strategy）

1. UML类图

   +------------------+       +------------------+
   |     Context     |       |    Strategy     |
   +------------------+       +------------------+
   | -strategy       |------>| +execute()       |
   | +executeStrategy|       +------------------+
   +------------------+              ^
                                     |
                             +------------------+
                             |ConcreteStrategy  |
                             +------------------+
                             | +execute()       |
                             +------------------+
   

模板方法模式（Template Method）

1. UML类图

   +------------------+
   | AbstractClass    |
   +------------------+
   | +templateMethod()|
   | #primitiveOp1() |
   | #primitiveOp2() |
   +------------------+
           ^
           |
   +------------------+
   | ConcreteClass   |
   +------------------+
   | #primitiveOp1() |
   | #primitiveOp2() |
   +------------------+
   

2. 基本实现

   // 抽象类
   abstract class AbstractClass {
       // 模板方法
       public final void templateMethod() {
           primitiveOperation1();
           primitiveOperation2();
           hook();
       }
   
       // 基本操作1
       protected abstract void primitiveOperation1();
   
       // 基本操作2
       protected abstract void primitiveOperation2();
   
       // 钩子方法
       protected void hook() {
           // 默认实现
       }
   }
   
   // 具体类
   class ConcreteClass extends AbstractClass {
       @Override
       protected void primitiveOperation1() {
           System.out.println("具体类实现操作1");
       }
   
       @Override
       protected void primitiveOperation2() {
           System.out.println("具体类实现操作2");
       }
   
       @Override
       protected void hook() {
           System.out.println("具体类实现钩子方法");
       }
   }
   

3. Spring框架中的应用

   // JdbcTemplate示例
   @Repository
   public class UserDao extends JdbcDaoSupport {
       public User findById(long id) {
           return getJdbcTemplate().queryForObject(
               "SELECT * FROM users WHERE id = ?",
               new Object[]{id},
               (rs, rowNum) -> {
                   User user = new User();
                   user.setId(rs.getLong("id"));
                   user.setUsername(rs.getString("username"));
                   return user;
               }
           );
       }
   }
   
   // RestTemplate示例
   @Service
   public class UserService {
       @Autowired
       private RestTemplate restTemplate;
   
       public User getUser(String id) {
           return restTemplate.getForObject(
               "http://api.example.com/users/{id}",
               User.class,
               id
           );
       }
   }
   
   // TransactionTemplate示例
   @Service
   public class TransactionService {
       @Autowired
       private TransactionTemplate transactionTemplate;
   
       public void transferMoney(String fromAccount, String toAccount, BigDecimal amount) {
           transactionTemplate.execute(new TransactionCallback<Void>() {
               @Override
               public Void doInTransaction(TransactionStatus status) {
                   try {
                       // 转账操作
                       accountDao.debit(fromAccount, amount);
                       accountDao.credit(toAccount, amount);
                       return null;
                   } catch (Exception e) {
                       status.setRollbackOnly();
                       throw e;
                   }
               }
           });
       }
   }
   

4. 基本实现

   // 策略接口
   interface PaymentStrategy {
       void pay(int amount);
   }
   
   // 具体策略：信用卡支付
   class CreditCardPayment implements PaymentStrategy {
       private String cardNumber;
       private String cvv;
   
       public CreditCardPayment(String cardNumber, String cvv) {
           this.cardNumber = cardNumber;
           this.cvv = cvv;
       }
   
       @Override
       public void pay(int amount) {
           System.out.println("使用信用卡支付：" + amount);
       }
   }
   
   // 具体策略：支付宝支付
   class AlipayPayment implements PaymentStrategy {
       private String email;
   
       public AlipayPayment(String email) {
           this.email = email;
       }
   
       @Override
       public void pay(int amount) {
           System.out.println("使用支付宝支付：" + amount);
       }
   }
   
   // 上下文
   class PaymentContext {
       private PaymentStrategy strategy;
   
       public void setStrategy(PaymentStrategy strategy) {
           this.strategy = strategy;
       }
   
       public void executePayment(int amount) {
           strategy.pay(amount);
       }
   }
   

5. Spring框架中的应用

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service
   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies;
   
       public ValidationService(Map<String, ValidationStrategy> strategies) {
           this.strategies = strategies;
       }
   
       public boolean validateText(String text, String strategyName) {
           ValidationStrategy strategy = strategies.get(strategyName);
           if (strategy == null) {
               throw new IllegalArgumentException("未知的验证策略");
           }
           return strategy.validate(text);
       }
   }
   
   // 配置类
   @Configuration
   public class ValidationConfig {
       @Bean
       public ValidationService validationService(
           Map<String, ValidationStrategy> strategies) {
           return new ValidationService(strategies);
       }
   }
   

   // 策略接口
   public interface ValidationStrategy {
       boolean validate(String text);
   }
   
   // 具体策略实现
   @Component("lowerCase")
   public class LowerCaseValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("[a-z]+");
       }
   }
   
   @Component("numeric")
   public class NumericValidationStrategy implements ValidationStrategy {
       @Override
       public boolean validate(String text) {
           return text.matches("\\d+");
       }
   }
   
   // 使用策略的服务
   @Service   public class ValidationService {
       private final Map<String, ValidationStrategy> strategies