多处理器模式

当需要根据实体类型来作出相对的处理的时候，我们可以使用此模式来减化if else语句

• 测试controller

@RestController
public class TestController {

    @Autowired
    private IService service;

    @GetMapping("/1")
    public String test1(){
        Entity1 entity1=new Entity1(1);
        return service.method(entity1);
    }
    @GetMapping("/2")
    public String test2(){
        Entity2 entity2=new Entity2(2);
        return service.method(entity2);
    }
    @GetMapping("/3")
    public String test3(){
        Entity3 entity3=new Entity3(3);
        return service.method(entity3);
    }
}

• 服务接口

public interface IService {
    String method(BaseEntity entity);
}

• 服务实现类 

在服务实现类中包含一个map，key为实体类的类对象，value为处理器。当spring注入完成之后会执行@PostContruct注解的方法，可以在此处使用处理器实现类实现的接口上的泛型类，反射出实体类的类对象，然后把对应的处理器放到map中以完成初始化，并提供获取处理器handler的方法getHandler(Class entityClass)。当然我们也可以不使用反射，给处理器接口提供一个方法来获取实体类的类对象，也就不需要强制使用在处理器接口上的泛型了。

@Service
public class ServiceImpl implements IService {
    @Autowired
    private List<IHandler> handlerList;

    private Map<Class,IHandler> handlerMap=new HashMap<>();
    @PostConstruct
    private void init(){
        System.out.println("依赖注入完成之后执行处理器配置操作");
        for (IHandler service :handlerList) {
            //1 获取类
            Class<? extends IHandler> handlerClass = service.getClass();
            //2 获取类上实现的接口
            Type[] genericInterfaces = handlerClass.getGenericInterfaces();
            for (Type genericInterface : genericInterfaces) {
                if(genericInterface instanceof ParameterizedType){
                    ParameterizedType parameterizedType= (ParameterizedType) genericInterface;
                    //3 获取接口上的所有泛型
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    for (Type actualTypeArgument : actualTypeArguments) {
                        if(actualTypeArgument instanceof Class){
                            //把泛型类的父类为BaseEntity的处理器加入到集合
                            Class clazz= (Class) actualTypeArgument;
                            if(clazz.getSuperclass() == BaseEntity.class){
                                handlerMap.put(clazz,service);
                            }
                        }
                    }
                }
            }
        }
    }

    private IHandler getHandler(Class entityClass){
        IHandler iHandler = handlerMap.get(entityClass);
        if(iHandler==null)
            throw new RuntimeException(entityClass.getName()+"类型的实体处理器没有找到");
        return iHandler;
    }

    @Override
    public String method(BaseEntity entity) {
        return getHandler(entity.getClass()).doSomething(entity);
    }
}

• 处理器接口

public interface IHandler<T> {
    String doSomething(BaseEntity entity);
}

• 处理器实现

@Component
public class Handler1Impl implements IHandler<Entity1> {
    @Override
    public String doSomething(BaseEntity entity) {
        return "处理器："+Handler1Impl.class.getName()+" 收到的参数为："+entity;
    }
}

@Component
public class Handler2Impl implements IHandler<Entity2> {
    @Override
    public String doSomething(BaseEntity entity) {
        return "处理器："+ Handler2Impl.class.getName()+" 收到的参数为："+entity;
    }
}

• 实体类

public class BaseEntity {
    private int id;

    public BaseEntity(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "BaseEntity{" +
                "id=" + id +
                '}';
    }
}

public class Entity1  extends BaseEntity{
    public Entity1(int id) {
        super(id);
    }
}

public class Entity2 extends BaseEntity{
    public Entity2(int id) {
        super(id);
    }
}

public class Entity3 extends BaseEntity{
    public Entity3(int id) {
        super(id);
    }
}