策略模式+工厂模式的组合使用

策略模式+工厂模式的组合使用

策略模式：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
个人感觉特别好用，当你在一段代码中，有很多的候选算法，你就可以用这个策略模式了，可以有效的取出if…else这样的条件分支

工厂模式：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行
这个设计模式就很常见了，像我们的Spring中就用到了工厂模式

这里就直接上代码了

首先是枚举类

	public enum  IdGeneratorTypeEnums {
    //时间戳
    TIME_STAMP(2),
    //雪花算法
    SNOW_FLAKE(1);
	
	//类型
    int type;

    IdGeneratorTypeEnums(int type) {
        this.type = type;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

然后是我们的注解，毕竟在java里面，注解可以算是用的也很多了

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//子类可以继承该注解
@Inherited
public @interface GeneratorAnnotation {
    /**
     * @title
     * @description ：策略类型
     */
    IdGeneratorTypeEnums value() default IdGeneratorTypeEnums.SNOW_FLAKE;
}

策略接口，我这里拿我的唯一id生成的代码片段来作为模板

/**
 * 这个是我们的唯一id生成策略
 */
public interface IDGeneratorStrategy {
    /**
     * 生成唯一id
     * @param args
     * @return
     */
    String generateID(String ... args);
}

策略算法实现一

@Component
@GeneratorAnnotation(value = IdGeneratorTypeEnums.TIME_STAMP)
public class TimeStampStrategy implements IDGeneratorStrategy {
    @Override
    public String generateID(String ... args) {
    	//这里删掉就行了，毕竟是我自己的代码，
        StringBuilder sb=new StringBuilder();
        String s = DateUtils.formatDate(new Date());
        sb.append(s);
        for (String key:args){
            sb.append(key);
        }
        System.out.println("生成的id"+sb.toString());
        return sb.toString();
    }
}

策略实现二

@Component
@GeneratorAnnotation(value = IdGeneratorTypeEnums.SNOW_FLAKE)//这里就设置我们的这个为雪花算法
public class SnowGeneratorStrategy implements IDGeneratorStrategy {

	//可以去掉
    @Autowired
    private SnowGenerator snowGenerator;


    @Override
    public String generateID(String... args) {
    	//和上面一样，可以去掉
        return String.valueOf(snowGenerator.nextId()).substring(0,15);
    }
}

然后就是我们的在启动的时候初始化我们的工厂了

@Component
public class HandlerGeneratorProcessor implements ApplicationContextAware {
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //获取所有策略注解的Bean
        Map<String,Object> orderStrategyMap=applicationContext.getBeansWithAnnotation(GeneratorAnnotation.class);
        //遍历这个map
        orderStrategyMap.forEach((k,v)->{
            //获取加入了这个注解的类
            Class<IDGeneratorStrategy> strategyClass= (Class<IDGeneratorStrategy>) v.getClass();
            //获取这个注解的value值
            int type=strategyClass.getAnnotation(GeneratorAnnotation.class).value().getType();
            //将class加入map中。type为key
            //注入属性
            HandlerGeneratorContext.strategyBeanMap.put(type,strategyClass);
        });
    }
}

策略工厂类

@Component
public class HandlerGeneratorContext {
    //Spring容器
    @Autowired
    private ApplicationContext applicationContext;

    //策略容器
    public static Map<Integer,Class<IDGeneratorStrategy>> strategyBeanMap=new ConcurrentHashMap<>();

    //我们需要的时候去调用的方法
    public IDGeneratorStrategy getStrategy(){
        try {
            //获取到我们注解上的属性
            int value = ((IdGeneratorTypeEnums) GeneratorAnnotation.class.getDeclaredMethod("value").getDefaultValue()).getType();
            System.out.println(value);
            //然后调用
            return getStrategy(value);
        //如果出现下面这个异常，调用默认的Type
        } catch (NoSuchMethodException e) {

            e.printStackTrace();
            return getStrategy(1);
        }
    }
    
    //从我们的策略工厂中获取到一个策略
    public IDGeneratorStrategy getStrategy(Integer type){
        Class<IDGeneratorStrategy> cla = strategyBeanMap.get(type);
        if (cla==null){
            throw new IllegalArgumentException("对于IDGeneratorStrategy没有对应Bean");
        }
        return applicationContext.getBean(cla);
    }


}

最后就是使用了

		//这个也可以作为订单的id，这里就是我们的默认实现，当然，也可以在里面添加参数
        IDGeneratorStrategy strategy = handlerGeneratorContext.getStrategy();
        String id = strategy.generateID();