灵活的策略模式示例

1、抽象策略

public interface Strategy<T> {

    /**
     * 获得策略的标识
     */
    T getStrategyId();
}

2、对抽象策略扩展

public interface MessageStrategy extends Strategy<String>{

   void  handler();
}

3、策略具体实现

@Component
public class AMessageStrategy implements MessageStrategy{
    @Override
    public String handler() {
        return "A ...handler";
    }

    @Override
    public String getStrategyId() {
        return "A";
    }
}

@Component
public class BMessageStrategy implements MessageStrategy{
    @Override
    public String handler() {
        return "B .. handler";
    }

    @Override
    public String getStrategyId() {
        return "B";
    }
}

4、抽象策略工厂

public class StrategyFactory<T,S extends Strategy<T>> implements InitializingBean, ApplicationContextAware {

    private   Class<S>  classType;

    private HashMap<T,S>  strategyMap;

    private  ApplicationContext applicationContext;

    public StrategyFactory(Class classType) {
        this.classType = classType;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
       Collection<S>  strategyList= applicationContext.getBeansOfType(classType).values();
        strategyMap=new HashMap<>(strategyList.size());
       for (S strategy:strategyList){
           strategyMap.put(strategy.getStrategyId(),strategy);
       }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
    }

    public S  getStrategy(T t){
        return  strategyMap.get(t);
    }
}

5、策略类型配置

@Configuration
public class StrategyConfig {
    @Bean
    public StrategyFactory<String,MessageStrategy>  getMessageStrategy(){
        return new StrategyFactory<String,MessageStrategy>(MessageStrategy.class);
    }
}

6、测试

@Service
public class StrategyTestService {
    @Autowired
    private StrategyFactory<String,MessageStrategy> strategyFactory;

    public  String hello(String strategyId){
       MessageStrategy messageStrategy= strategyFactory.getStrategy(strategyId);
      return messageStrategy.handler();
    }
}

 
@RestController
public class StrategyController {

    @Autowired
    StrategyTestService strategyTestService;
    @RequestMapping("/strategy")
    public String strategy(String strategyId){
        return strategyTestService.hello(strategyId);
    }
}

在这里插入图片描述
在这里插入图片描述

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Spring框架中,你可以使用策略模式来实现一些业务逻辑的灵活切换。下面是一个简单的示例来说明如何在Spring中使用策略模式: 首先,你需要定义一个策略接口,例如: ```java public interface PaymentStrategy { void pay(double amount); } ``` 然后,你可以创建多个实现该接口的策略类,每个类代表一种不同的支付方式,例如: ```java @Component public class CreditCardPaymentStrategy implements PaymentStrategy { @Override public void pay(double amount) { // 实现信用卡支付逻辑 System.out.println("Using credit card to pay: $" + amount); } } @Component public class PaypalPaymentStrategy implements PaymentStrategy { @Override public void pay(double amount) { // 实现Paypal支付逻辑 System.out.println("Using Paypal to pay: $" + amount); } } @Component public class WeChatPaymentStrategy implements PaymentStrategy { @Override public void pay(double amount) { // 实现微信支付逻辑 System.out.println("Using WeChat to pay: ¥" + amount); } } ``` 接下来,你可以创建一个使用策略的业务类,例如: ```java @Component public class PaymentService { private final Map<String, PaymentStrategy> paymentStrategies; public PaymentService(List<PaymentStrategy> paymentStrategies) { this.paymentStrategies = new HashMap<>(); for (PaymentStrategy strategy : paymentStrategies) { this.paymentStrategies.put(strategy.getClass().getSimpleName(), strategy); } } public void processPayment(String paymentStrategy, double amount) { PaymentStrategy strategy = paymentStrategies.get(paymentStrategy); if (strategy == null) { throw new IllegalArgumentException("Invalid payment strategy: " + paymentStrategy); } strategy.pay(amount); } } ``` 现在,你可以在其他地方使用`PaymentService`来处理支付操作。使用Spring的依赖注入功能,你可以轻松地切换不同的支付策略。 ```java @Service public class OrderService { private final PaymentService paymentService; public OrderService(PaymentService paymentService) { this.paymentService = paymentService; } public void placeOrder(double amount, String paymentStrategy) { // 处理订单逻辑 // 调用支付服务进行支付 paymentService.processPayment(paymentStrategy, amount); } } ``` 在上面的示例中,`PaymentService`使用了`PaymentStrategy`的实现类,通过依赖注入的方式将它们注入到了`PaymentService`中。当你调用`processPayment()`方法时,根据传入的支付策略名称,会选择相应的策略进行支付。 这就是一个使用策略模式的简单示例,在Spring框架中实现了灵活的支付方式切换。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值