工厂模式+策略模式

源代码

 @GetMapping("/ddd/{id}")
    public Result f1(@PathVariable int id) {
        if (id==1){
            System.out.println(1);
        }
        if (id==2){
            System.out.println(2);
        }
        if (id==3){
            System.out.println(3);
        }
        if (id==4){
            System.out.println(4);
        }
        return Result.success();
    }

1.抽取判断逻辑定义在接口中

继承InitializingBean方法是为了，在创建bean的过程中，将bean放去工厂类的Map中

public interface Strategy extends InitializingBean {

    public void pan(int id);

}

2.创建接口实现类

@Component
public class _1s implements  Strategy{
    @Override
    public void pan(int id) {
            System.out.println(id);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        Factor.register(1,this);
    }
}
@Component
public class _2s implements  Strategy{
    @Override
    public void pan(int id) {
            System.out.println(id);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        Factor.register(2,this);
    }
}
@Component
public class _3s implements  Strategy{
    @Override
    public void pan(int id) {
            System.out.println(id);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        Factor.register(3,this);
    }
}

3.定义工厂类

用于选择改用那个子类，并且使用map接收子类

public class Factor {

   private static Map< Integer,Strategy> map = new HashMap();

   public static  void  register(int id,Strategy strategy){
       map.put(id,strategy);
   }

    public static Strategy getstar(Integer id) {
        Strategy strategy = map.get(id);
        return strategy;
    }
}

4.测试

    @GetMapping("/ddd/{id}")
    public Result f1(@PathVariable int id) {
        Strategy getstar = Factor.getstar(id);
        getstar.pan(id);
        return Result.success();
    }

如果逻辑代码的返回值不同可以使用模板方法模式

模版方法模式，把相同的代码，放到抽象父类方法中，不同的代码定义新的方法，在相同的代码方法中调用不同代码的方法，不同的代码方法让子类重写，让子类调用父类方法

1.逻辑代码改成抽象类

public abstract  class abstStra implements InitializingBean {
        public void AAA(){
            //表示不支持操作的异常对象，防止没有该方法调用该方法，如果统一异常返回可以自定义一个异常枚举说明该异常
            throw new UnsupportedOperationException();
        }
        public String BBB(){
            throw new UnsupportedOperationException();
        }
}

2.子类继承父类重写子类特有方法

public class a extends abstStra{
    @Override
    public String BBB() {
        String a = "dasda";
        return a;
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        Factor1.register(4,this);
    }

}
public class b extends abstStra{
    @Override
    public void AAA() {
        System.out.println("aaa");
    }
    @Override
    public void afterPropertiesSet() throws Exception {

    }

}

3.工厂类

public class Factor1 {

   private static Map< Integer,abstStra> map = new HashMap();

   public static  void  register(int id,abstStra abstStra){
       map.put(id,abstStra);
   }

    public static abstStra getstar(Integer id) {
        abstStra abstStra = map.get(id);
        return abstStra;
    }
}

4.测试

   @RequestMapping("test")
    public Result f2(@Param("id") String id) {
        abstStra getstar = Factor1.getstar(id);
        getstar.AAA(id);
        getstar.BBB(id);
        return Result.success(id);
    }