策略模式（对不同情况的算法封装）

定义一个接口，里面有一个方法；
然后不同情况定义成不同的类试实现这个接口，重写方法；
再定义一个入参为接口的构造器的类，这样可以根据接口的实现不同而调用不同的算法方法。

举例子：不同的会员买书又不同的折扣

第一步：定义抽象策略对象（接口）

public interface MemberStrategy {
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double calcPrice(double booksPrice);
}

第二步：定义具体策略对象（类，个数看需要几个算法）

实现抽象策略接口，重写方法，方法体为具体的计算逻辑

// 初级会员
public class PrimaryMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        
        System.out.println("对于初级会员的没有折扣");
        return booksPrice;
    }

}

// 中级会员
public class IntermediateMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {

        System.out.println("对于中级会员的折扣为10%");
        return booksPrice * 0.9;
    }

}

// 高级会员
public class AdvancedMemberStrategy implements MemberStrategy {

    @Override
    public double calcPrice(double booksPrice) {
        
        System.out.println("对于高级会员的折扣为20%");
        return booksPrice * 0.8;
    }
}

第三步：定义一个持有抽象策略对象为入参的构造方法的类

再在里面定义一个抽象算法的方法，调用抽象策略接口的方法，具体实现看具体策略类是哪一个了。

public class Price {
    //持有一个具体的策略对象
    private MemberStrategy strategy;
    /**
     * 构造函数，传入一个具体的策略对象
     * @param strategy    具体的策略对象
     */
    public Price(MemberStrategy strategy){
        this.strategy = strategy;
    }
    
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public double quote(double booksPrice){
        return this.strategy.calcPrice(booksPrice);
    }
}

第四步：使用

public class Client {

    public static void main(String[] args) {
        //选择并创建需要使用的策略对象
        MemberStrategy strategy = new AdvancedMemberStrategy();
        //创建环境
        Price price = new Price(strategy);
        //计算价格
        double quote = price.quote(300);
        System.out.println("图书的最终价格为：" + quote);
    }

}

实战例子

• service的公共模板接口

import com.alibaba.fastjson.JSONObject;
import net.facelib.eam.mediacenter.common.model.Item;
import net.facelib.eam.mediacenter.common.model.MaterialDetail;
import net.facelib.eam.plancenter.db.dto.ApplyDto;
import net.facelib.eam.plancenter.webController.pojo.DeviceDto;
import net.facelib.eam.plancenter.webController.pojo.PcApply;

import java.util.List;
import java.util.Map;

/**
 * 使用策略模式操作申请的提交和节目单的创建发布
 *
 * @author lc
 * @version 1.0
 * @date 2022/11/8 10:52
 */
public interface ApplyCommonService {
    // 提交申请
    void createApply(ApplyDto applyDto);

    /**
     * 创建申请的节目单
     */
    void createItem(PcApply apply, Map<Integer, String> deviceAndItemCodeMap, List<Item> itemsTotal,
                    Map<Integer, String> oldDeviceIdAndTargetIdMap, Map<String, String> oldAndNewDeviceTargetIdMap,
                    Long remainTime, List<MaterialDetail> gyMaterialList, Map<Integer, JSONObject> statePlayTimeMap,
                    List<DeviceDto> deviceDtoList);

}

• 实现模板 UpApplyServiceImpl ,ChangeApplyServiceImpl

/**
 * @author lc
 * @version 1.0
 * @date 2022/11/8 10:53
 */
@Service
public class UpApplyServiceImpl implements ApplyCommonService {
    public static final Logger logger = LoggerFactory.getLogger(UpApplyServiceImpl.class);
    @Override
    public void createApply(ApplyDto applyDto) {
    }

    /**
     * 创建上刊申请的节目单
     */
    @Override
    public void createItem(PcApply apply, Map<Integer, String> deviceAndItemCodeMap, List<Item> itemsTotal,
                           Map<Integer, String> oldDeviceIdAndTargetIdMap, Map<String, String> oldAndNewDeviceTargetIdMap,
                           Long remainTime, List<MaterialDetail> gyMaterialList, Map<Integer, JSONObject> statePlayTimeMap,
                           List<DeviceDto> deviceDtoList) {
     
  
    }

}

/**
 * @author lc
 * @version 1.0
 * @date 2022/11/8 10:53
 */
@Service
public class ChangeApplyServiceImpl implements ApplyCommonService {
    public static final Logger logger = LoggerFactory.getLogger(UpApplyServiceImpl.class);
    @Override
    public void createApply(ApplyDto applyDto) {
    }

    /**
     * 创建上刊申请的节目单
     */
    @Override
    public void createItem(PcApply apply, Map<Integer, String> deviceAndItemCodeMap, List<Item> itemsTotal,
                           Map<Integer, String> oldDeviceIdAndTargetIdMap, Map<String, String> oldAndNewDeviceTargetIdMap,
                           Long remainTime, List<MaterialDetail> gyMaterialList, Map<Integer, JSONObject> statePlayTimeMap,
                           List<DeviceDto> deviceDtoList) {
     
  
    }

}

• 策略工厂

@Component
public class ApplyServiceFactory {
    @Autowired
    private  UpApplyServiceImpl upApplyService;
    @Autowired
    private  ChangeApplyServiceImpl changeApplyService;
 
    private static final Map<Integer, ApplyCommonService> map = new HashMap<>();



    @PostConstruct
    public void setMap() {
        map.put(ProcessTypeEnum.UP.getCode(), upApplyService);
        map.put(ProcessTypeEnum.CHANGE.getCode() , changeApplyService);
    }

    public static ApplyCommonService getApplyService(Integer type) {
        ApplyCommonService applyCommonService = map.get(type);
        return applyCommonService;
    }
}

使用

 public void submitApply(ApplyDto applyDto) {
        try {
            // 不同的type值走不同的逻辑
            Integer type = applyDto.getType();
            ApplyCommonService applyService = ApplyServiceFactory.getApplyService(type);
            applyService.createApply(applyDto);
        } catch (Exception e) {
            if (e instanceof PlanException) {
                throw e;
            }
            throw new PlanException(EamErrorType.EAM_UNCLASSIFIED.getValue(), e.getMessage(), e);
        }
    }