策略模式

设计模式之策略模式

在Spring Boot中实现策略模式是一种常见的设计模式应用，可以帮助我们将算法或行为封装起来，通过动态地选择不同的策略来实现不同的功能。以下是实现策略模式的详细步骤和代码示例：

1. 策略模式的基本概念

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列的算法，将每个算法封装起来，并使它们之间可以互换。策略模式让算法的变化独立于使用算法的客户。

在策略模式中，通常包含以下角色：

• 策略接口（Strategy） ：定义了策略的通用接口，所有的策略类都实现这个接口。
• 具体策略类（Concrete Strategy） ：实现了策略接口，具体实现某种算法。
• 上下文类（Context） ：用于封装策略类的调用逻辑，客户端通过上下文类来使用策略。

2. Spring Boot实现策略模式的步骤

（1）定义策略接口

首先定义一个策略接口，声明所有策略类需要实现的方法。

public interface Strategy {
    void execute();
}

（2）实现具体策略类

然后实现具体的策略类，每个策略类都实现策略接口，并提供具体的算法实现。

@Component
public class StrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A的算法");
    }
}
​
@Component
public class StrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B的算法");
    }
}

（3）创建策略上下文类

策略上下文类负责封装策略的调用逻辑，并提供一个方法供客户端调用。通过上下文类，客户端可以动态地选择不同的策略。

@Service
public class StrategyContext {
    @Autowired
    private Map<String, Strategy> strategies;
​
    public void executeStrategy(String strategyName) {
        Strategy strategy = strategies.get(strategyName);
        if (strategy != null) {
            strategy.execute();
        } else {
            throw new IllegalArgumentException("未知的策略：" + strategyName);
        }
    }
}

在Spring Boot中，可以通过@Autowired注入一个Map<String, Strategy>，Spring会自动将所有实现了Strategy接口的Bean注入到这个Map中，其中键是Bean的名称，值是对应的Bean实例。

（4）注册策略Bean

在Spring Boot中，可以通过@Component注解自动注册Bean，也可以通过@Bean注解手动注册Bean。如果需要自定义Bean的名称，可以通过@Component注解的value属性或@Bean注解的方法名来指定。

@Component("strategyA")
public class StrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A的算法");
    }
}
​
@Component("strategyB")
public class StrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B的算法");
    }
}

或者通过@Bean注解手动注册：

@Configuration
public class StrategyConfig {
    @Bean
    public Strategy strategyA() {
        return new StrategyA();
    }
​
    @Bean
    public Strategy strategyB() {
        return new StrategyB();
    }
}

（5）使用策略模式

在客户端代码中，通过策略上下文类调用不同的策略。

@RestController
public class StrategyController {
    @Autowired
    private StrategyContext strategyContext;
​
    @GetMapping("/execute/{strategyName}")
    public String executeStrategy(@PathVariable String strategyName) {
        strategyContext.executeStrategy(strategyName);
        return "策略" + strategyName + "执行完成";
    }
}

3. 完整代码示例

（1）策略接口

public interface Strategy {
    void execute();
}

（2）具体策略类

@Component("strategyA")
public class StrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A的算法");
    }
}
​
@Component("strategyB")
public class StrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B的算法");
    }
}

（3）策略上下文类

@Service
public class StrategyContext {
    @Autowired
    private Map<String, Strategy> strategies;

    public void executeStrategy(String strategyName) {
        Strategy strategy = strategies.get(strategyName);
        if (strategy != null) {
            strategy.execute();
        } else {
            throw new IllegalArgumentException("未知的策略：" + strategyName);
        }
    }
}

（4）控制器类

@RestController
public class StrategyController {
    @Autowired
    private StrategyContext strategyContext;

    @GetMapping("/execute/{strategyName}")
    public String executeStrategy(@PathVariable String strategyName) {
        strategyContext.executeStrategy(strategyName);
        return "策略" + strategyName + "执行完成";
    }
}

4. 测试

启动Spring Boot应用后，可以通过访问以下URL来测试策略模式：

• http://localhost:8080/execute/strategyA：执行策略A的算法
• http://localhost:8080/execute/strategyB：执行策略B的算法

如果访问http://localhost:8080/execute/strategyC，会抛出IllegalArgumentException异常，提示"未知的策略：strategyC"。

5. 总结

通过Spring Boot实现策略模式，可以利用Spring的依赖注入功能，方便地管理和切换不同的策略。策略模式可以提高代码的可扩展性和可维护性，使得算法的变化独立于使用算法的客户端代码。