策略模式简单使用

例子：https://www.cnblogs.com/lm970585581/p/11065787.html

这里例子是进行一个类的重新创建，由于是重新生成的类所以只能进行逻辑编写，不支持spring的后续处理如果需要注入mapper等进行数据库查询，那么注入的mapper 则为null。

下面会进行一个修改，将创建的类修改为 获取spring 的bean 对象

方法调用

   public TableDataInfo list(DoHospital doHospital)
    {
        doHospital.setType(1);
        startPage();
        /**
         * 获取spring 的bean 实例  
         */
         //这里根据定义的（前台传递）的类型参数进行一个spring 的bean 获取  返回为被重写的通用接口
        IFacilityStrategy bean = FacilityContest.getBean(doHospital.getType());
     	//这里使用上面获取的bean 对象进行一个方法调用
        List<?> objects = bean.facilityByEnum(doHospital);
        /**
         * 根据设备类型创建对应的实例
         */
//        IFacilityStrategy instance = FacilityContest.getInstance(doHospital.getType());
//        List<?> date = instance.facilityByEnum(doHospital);
        return getDataTable(objects);
    }

枚举类

/**
 * 设备类型枚举类
 */
public enum FacilityEnum {

    /**
     * 取号机
     * key 为字典表对应值
     * clazz 类名称
     */
    QUEUING_MACHINE(1, "DoQueuingMachineStrategy"),
    /**
     * 体检台
     */
     //这里参数 第一个为对应的参数值  对应的value 为spring 需要获取的类对象，这里必须和需要生成的对象一对一关系
    FACILITY_EXAMINATION(2, "DoFacilityExaminationStrategy"); //如果是使用创建类对象的方法 这里vlase 则为对象的全路径及类名，如：com.wda.model.DoFacilityExaminationStrategy


    private Integer key;
    private String clazz;

    /**
     * 获取对应的名称
     * @param key
     * @return
     */
    public static String getValue(Integer key){
        for (FacilityEnum msgEnum : FacilityEnum.values()) {
           if (Objects.equals(msgEnum.getKey(), key)){
               return msgEnum.getClazz();
           }
        }
        return null;
    }

	// 这里是创建类对象使用的方法
    public static Map<Integer, String> getAllClazz() {
        Map<Integer, String> map = new HashMap<Integer, String>();
        for (FacilityEnum msgEnum : FacilityEnum.values()) {
            map.put(msgEnum.getKey(), msgEnum.getClazz());
        }
        return map;
    }

    FacilityEnum() {
    }

    FacilityEnum(Integer key, String clazz) {
        this.key = key;
        this.clazz = clazz;
    }

    public Integer getKey() {
        return key;
    }

    public void setKey(Integer key) {
        this.key = key;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

接口

/**
 * 策略处理
 * 查询对应的设备
 * 这里需要每个实现类进行实现
 */
public interface IFacilityStrategy {
    /**
     *  根据枚举类型查询对应设备
     * @param t  参数值
     */
    List<?> facilityByEnum(Object t);


}

spring bean对象的获取

/**
 * @ClassName: FacilityContest
 * @Author: 
 * @Date: 2021/1/18 17:38
 * @Type:
 * @Description: TODO   设备调用处理
 */
public class FacilityContest {



    /**
     * 根据设备标识获取spring bean对象
     *
     * @param facilityId 对应设备表示
     * @return
     */
    public static IFacilityStrategy getBean(Integer facilityId) {
        return (IFacilityStrategy)SpringUtil.getBean(FacilityEnum.getValue(facilityId));
    }


    /**
     * 根据设备标识获取实例 
     *
     * @param facilityId 对应设备表示
     * @return
     */
    public static IFacilityStrategy getInstance(Integer facilityId) {
        IFacilityStrategy inter = null;
        Map<Integer, String> allClazz = FacilityEnum.getAllClazz();
        String clazz = allClazz.get(facilityId);
        if (facilityId != null && facilityId > 0) {
            try {
                try {
                    /**
                     * 调用无参构造器创建实例
                     */
                    inter = (IFacilityStrategy) Class.forName(clazz).newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return inter;
    }

spring 工具类

@Component
public class SpringUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

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

        System.out.println("---------------me.shijunjie.util.SpringUtil------------------------------------------------------");

        System.out.println("========ApplicationContext配置成功,在普通类可以通过调用SpringUtils.getAppContext()获取applicationContext对象,applicationContext="+SpringUtil.applicationContext+"========");

    }

    //获取applicationContext
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    //通过name获取 Bean.
    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    //通过class获取Bean.
    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    //通过name,以及Clazz返回指定的Bean
    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }

}

实现类1

@Service("DoFacilityExaminationStrategy")
public class DoFacilityExaminationStrategy implements IFacilityStrategy{

    @Autowired
    private DoFacilityExaminationMapper facilityExaminationMapper;

    @Override
    public List<?> facilityByEnum(Object t) {
        DoFacilityExamination doFacilityExamination = new DoFacilityExamination();
        List<DoFacilityExamination> doFacilityExaminations = facilityExaminationMapper.selectDoFacilityExaminationList(doFacilityExamination);
        return doFacilityExaminations;
    }
}

实现类2

@Service("DoQueuingMachineStrategy")
public class DoQueuingMachineStrategy extends BaseController implements IFacilityStrategy {

    @Autowired
    private DoQueuingMachineMapper queuingMachineMapper;

    @Override
    public List<?> facilityByEnum(Object object) {
        DoQueuingMachine doQueuingMachine = new DoQueuingMachine();
        return queuingMachineMapper.selectDoQueuingMachineList(doQueuingMachine);
    }
}