策略者模式

JokerDJ

发布于 2023-11-27 15:44:03

920

发布于 2023-11-27 15:44:03

文章被收录于专栏：JokerDJJokerDJ

策略者模式&框架源码应用

所谓的策略者模式：定义了ー系列的算法，并将每一个算法封装起来，而且使他们可以互相换，让算法独立于使用它的喜户而独立变化算法：程序执行的逻辑，或者顺序。封装：可以是方法，也可以是函数，也可以是类、接口、抽象关相互替换：

代表每一种算法，功能定义是一样的，具体实现不同
Java中可以直接替换的是接口实现、子类

(看到 f elseif esleif if)可以考虑用设计模式进行重构
看到一对多的触发可以用观察者模式
看到很多公共的部分很多，局部不同可以考虑用模板方法模式

实例

public class CourseRelationService {
    public void byCourse(String userType,String CourseID,double CoursePrice){
        double price=0;
        if("monthvip".equals(userType)){
            price=CoursePrice*1.0;
        }
        if("yearvip".equals(userType)){
            price=CoursePrice*0.75;
        }
        if("svip".equals(userType)){
            price=CoursePrice*0.5;
        }
    }
}

根据不同用户，购买同一件商品，打折的折数不一样，就会产生很多个if判断通过策略者模式改进定义一个接口封装不同用户所打折的额度 CalculationService

/**
 * @Author Joker DJ
 * @Date 2021/8/7 0:10
 * @Version 1.0
 */
public interface CalculationService {

    public String userType();

    public double coursePrice(double coursePrice);
}

分别实现 MonthVipServiceImpl.java

/**
 * @Author Joker DJ
 * @Date 2021/8/7 0:10
 * @Version 1.0
 */
@Service
public class MonthVipServiceImpl implements CalculationService {

    @Override
    public String userType() {
        return "MonthVip";
    }

    @Override
    public double coursePrice(double coursePrice) {
        return coursePrice*1.0;
    }
}

YearVipServiceImpl.java

/**
 * @Author Joker DJ
 * @Date 2021/8/7 0:10
 * @Version 1.0
 */
@Service
public class YearVipServiceImpl implements CalculationService {

    @Override
    public String userType() {
        return "YearVip";
    }

    @Override
    public double coursePrice(double coursePrice) {
        return coursePrice*0.75;
    }
}

SVipServiceImpl.java

/**
 * @Author Joker DJ
 * @Date 2021/8/7 0:10
 * @Version 1.0
 */
@Service
public class SVipServiceImpl implements CalculationService {

    @Override
    public String userType() {
        return "sVip";
    }

    @Override
    public double coursePrice(double coursePrice) {
        return coursePrice*0.5;
    }
}

通过构造函数注入

@Service
public class CourseRelationService {
    /*public void byCourse(String userType,String CourseID,double CoursePrice){
        double price=0;
        if("monthvip".equals(userType)){
            price=CoursePrice*1.0;
        }
        if("yearvip".equals(userType)){
            price=CoursePrice*0.75;
        }
        if("svip".equals(userType)){
            price=CoursePrice*0.5;
        }
    }*/


    private Map<String,CalculationService> map=new HashMap<>();

    public CourseRelationService(List<CalculationService> CalculationList) {
        for (CalculationService calculationService : CalculationList) {
            map.put(calculationService.userType(),calculationService);
        }
    }

    public double byCourse(String userType, String CourseID, double CoursePrice){
        CalculationService calculationService = map.get(userType);
        return calculationService.coursePrice(CoursePrice);
    }
}

测试

@SpringBootTest
class ObserveApplicationTests {

    @Autowired
    private CourseRelationService courseRelationService;


   
    @Test
    void contextLoads2() {
        System.out.println(courseRelationService.byCourse("sVip", "11111", 56));
        System.out.println(courseRelationService.byCourse("YearVip", "11111", 56));
        System.out.println(courseRelationService.byCourse("MonthVip", "11111", 56));
    }


}

结果