策略模式简单使用

分手后的思念是犯贱 2023-01-08 05:27 192阅读 0赞

### 策略模式替换if和else ###

*  方法调用
 *   *  枚举类
     *  接口
     *  spring bean对象的获取
     *  spring 工具类
     *  实现类1
     *  实现类2

例子：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);
        }
    }