spring版本策略模式（超实用）

策略模式：顾名思义，按照不同的情况选择对应的对策略的模式

设计，策略对应 code枚举，决策谋略对应不同的类的执行方法，往下看

直接上代码

策略处理器枚举

/**
 * 描述: 策略处理器枚举 </br>
 * 时间: 2022-01-15 14:03  </br>
 * 作者：it学习道场
 */
public enum  HandlerEnum {
    first(1,"第一个处理器"),
    second(2,"第二个处理器"),
    third(3,"第三个处理器")
    ;
    private int code;
    private String desc;

    HandlerEnum(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "HandlerEnum{" +
                "code=" + code +
                ", desc='" + desc + '\'' +
                '}';
    }
}
策略模式顶级处理器抽象
/**
 * 描述: 策略模式顶级处理器抽象 </br>
 * 时间: 2022-01-15 14:01  </br>
 * 作者：it学习道场
 */
public interface Handler {
    /**
     * 执行业务逻辑抽象方法
     * @return
     */
    boolean handle();

    /**
     * 获取code方法
     * @return
     */
    int getCode();
}
第一个处理器
import org.springframework.stereotype.Component;

/**
 * 描述: 第一个处理器 </br>
 * 时间: 2022-01-15 14:13  </br>
 * 作者：it学习道场
 */
@Component
public class FirstHandler implements Handler {
    private static final int code = HandlerEnum.first.getCode();
    @Override
    public boolean handle() {
        System.out.println(HandlerEnum.first.getDesc() + "开始执行业务......");
        return true;
    }

    @Override
    public int getCode() {
        return code;
    }
}
第二个处理器

import org.springframework.stereotype.Component;

/**
 * 描述: 第二个处理器 </br>
 * 时间: 2022-01-15 14:13  </br>
 * 作者：it学习道场
 */
@Component
public class SecondHandler implements Handler {
    private static final int code = HandlerEnum.second.getCode();
    @Override
    public boolean handle() {
        System.out.println(HandlerEnum.second.getDesc() + "开始执行业务......");
        return true;
    }

    @Override
    public int getCode() {
        return code;
    }
}
第三个处理器
import org.springframework.stereotype.Component;

/**
 * 描述: 第三个处理器 </br>
 * 时间: 2022-01-15 14:13  </br>
 * 作者：it学习道场
 */
@Component
public class ThirdHandler implements Handler {
    private static final int code = HandlerEnum.third.getCode();
    @Override
    public boolean handle() {
        System.out.println(HandlerEnum.third.getDesc() + "开始执行业务......");
        return true;
    }

    @Override
    public int getCode() {
        return code;
    }
}
策略工厂
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 描述: 策略工厂 </br>
 * 时间: 2022-01-15 14:17  </br>
 * 作者：it学习道场
 */
@Component
public class StrategyFactory {
    @Autowired
    private Map<String, Handler> handlerBeanMap = new ConcurrentHashMap<>();

    /**
     * 根据code获取对应处理器
     * @param code handler的code码
     * @return Handler - 处理器
     */
    public Handler getHandler(int code){
        for (String beanName : handlerBeanMap.keySet()) {
            Handler handler = handlerBeanMap.get(beanName);
            if (handler.getCode() == code){
                return handler;
            }
        }
        return null;
    }
}
测试
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 描述: 工厂处理器测试 </br>
 * 时间: 2022-01-15 14:24  </br>
 * 作者：it学习道场
 */
public class StrategyTest {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(StrategyFactory.class,FirstHandler.class,SecondHandler.class,ThirdHandler.class);
        context.refresh();
        StrategyFactory bean = context.getBean(StrategyFactory.class);
        //1-对应第一个处理器，2-对应第二个处理器，3-对应第三个处理器
　　　　 Handler handler = bean.getHandler(HandlerEnum.first.getCode());
        handler.handle();
    }
}
自己来测试下吧











作者：IT学习道场

欢迎关注微信公众号 ： IT学习道场