@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface HandlerType {

    String value();
}

public abstract class AbstractHandler {

    public  abstract String handle(OrderDTO dto);
}

@HandlerType(value = "1")
@Component
public class NomalHandler extends AbstractHandler{
    @Override
    public String handle(OrderDTO dto) {
        return "normal";
    }
}

@HandlerType(value = "2")
@Component
public class GroupHandler extends AbstractHandler{
    @Override
    public String handle(OrderDTO dto) {
        return "group";
    }
}

public class HandleContext {

    private Map<String,Class> handlerMap;

    public HandleContext(Map<String,Class> handlerMap){
        this.handlerMap=handlerMap;
    }

    public AbstractHandler getInstance(String type){
        Class<? extends AbstractHandler> aClass = handlerMap.get(type);
        if (aClass==null) {
            throw new IllegalArgumentException();
        }
        return SpringContextUtil.getBean(aClass);
    }
}

@Component
@SuppressWarnings("unchecked")
public class HandlerProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        Map<String, Class> handlerMap = new HashMap<>();
        //获取指定报下的所有类
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        MetadataReaderFactory metaReader = new CachingMetadataReaderFactory();
        List<Class<?>> list = new ArrayList();
        try {
            Resource[] resources = resolver.getResources("classpath*:designstrategy/demo/config/handler/*.class");

            ClassLoader loader = ClassLoader.getSystemClassLoader();
            for (Resource resource : resources) {
                MetadataReader reader = metaReader.getMetadataReader(resource);
                String className = reader.getClassMetadata().getClassName();
                Class<?> clazz = loader.loadClass(className);
                HandlerType annotation = clazz.getAnnotation(HandlerType.class);
                // System.out.println("格式化前:"+clazz); class designstrategy.demo.config.handler.AbstractHandler
                System.err.println("格式化后:" + ClassUtils.getQualifiedName(clazz));
                //获取所有接口
                ClassUtils.getAllInterfaces(clazz);
                //判断是一个类是不是抽象类
                boolean anAbstract = Modifier.isAbstract(clazz.getModifiers());
//                System.err.println("判断一个类是不是抽象类:" + anAbstract);如果不是抽象类,添加到集合
                if (!anAbstract) {
                    list.add(clazz);
                }
            }
            System.out.println("集合" + list);
            //将类添加到Map中
            for (Class<?> aClass : list) {
                Annotation[] annotations = aClass.getAnnotations();
//              这里有个坑  Annotation annotation = aClass.getAnnotation(HandlerType.class);获取到的annotation为null
                for (Annotation annotation : annotations) {
                    if (annotation instanceof HandlerType) {
                        String value = ((HandlerType) annotation).value();
                        handlerMap.put(value, aClass);
                        System.out.println(value);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        HandleContext handleContext = new HandleContext(handlerMap);
        //将上下文添加到spring bean容器中
        configurableListableBeanFactory.registerSingleton(HandleContext.class.getName(), handleContext);
    }
}

@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtil.applicationContext = 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);
    }

}

@RestController
@RequestMapping("/order")
public class OrderController {


    @Autowired
    private OrderService orderService;

    @RequestMapping("/handle")
    public String handle(OrderDTO dto){
        String str=orderService.handle(dto);
        System.out.println(str);
        return str;
    }
}

@Service
public class OrderServiceImpl implements OrderService{

    @Autowired
    private HandleContext handleContext;

    @Override
    public String handle(OrderDTO dto) {
        AbstractHandler handler = handleContext.getInstance(dto.getType());
        return handler.handle(dto);
    }
}

@Data
public class OrderDTO {
    /** 订单类型 */
    private String type;
}