在Spring mvc的開發中，我們可以通過RequestMapping來配，當前方法用于處理哪一個URL的請求.同樣我們現在有一個需求，有一個任務調度器，可以按照不同的任務類型路由到不同的任務執行器。其本質就是通過外部參數進行一次路由和Spring mvc做的事情類似。簡單看了Spring mvc的實現原理之后，決定使用自定義注解的方式來實現以上功能。

自定義TaskHandler注解

@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Component 
public @interface TaskHandler { 
 
    String taskType() default ""; 
}  

以上定義了任務處理器的注解，其中@Component表示在spring 啟動過程中，會掃描到并且注入到容器中。taskType表示類型。

任務處理器定義

public abstract class AbstractTaskHandler { 
 
    /** 
     * 任務執行器 
     * 
     * @param task 任務 
     * @return 執行結果 
     */ 
     public abstract BaseResult execute(Task task); 
}  

以上定義了一個任務執行的處理器，其他所有的具體的任務執行器繼承實現這個方法。其中Task表示任務的定義，包括任務Id，執行任務需要的參數等。

任務處理器實現

接下來，我們可以實現一個具體的任務處理器。

@TaskHandler(taskType = "UserNameChanged") 
public class UserNameChangedSender extends AbstractTaskHandler { 
    @Override 
    public BaseResult execute(Task task) { 
      return new BaseResult(); 
    } 
}  

以上我們就實現一個用戶名修改通知的任務處理器，具體的業務邏輯這里沒有實現。

其中：@TaskHandler(taskType = "UserNameChanged")，這里我們指定這個Handler用于處理用戶名變更的任務

任務處理Handler注冊

public class TaskHandlerRegister extends ApplicationObjectSupport { 
 
    private final static Map<String, AbstractTaskHandler> TASK_HANDLERS_MAP = new HashMap<>(); 
 
    private static final Logger LOGGER = LoggerFactory.getLogger(TaskHandlerRegister.class); 
 
    @Override 
    protected void initApplicationContext(ApplicationContext context) throws BeansException { 
        super.initApplicationContext(context); 
        Map<String, Object> taskBeanMap = context.getBeansWithAnnotation(TaskHandler.class); 
        taskBeanMap.keySet().forEach(beanName -> { 
            Object bean = taskBeanMap.get(beanName); 
            Class clazz = bean.getClass(); 
            if (bean instanceof AbstractTaskHandler && clazz.getAnnotation(TaskHandler.class) != null) { 
                TaskHandler taskHandler = (TaskHandler) clazz.getAnnotation(TaskHandler.class); 
                String taskType = taskHandler.taskType(); 
                if (TASK_HANDLERS_MAP.keySet().contains(taskType)) { 
                    throw new RuntimeException("TaskType has Exits. TaskType=" + taskType); 
                } 
                TASK_HANDLERS_MAP.put(taskHandler.taskType(), (AbstractTaskHandler) taskBeanMap.get(beanName)); 
                LOGGER.info("Task Handler Register. taskType={},beanName={}", taskHandler.taskType(), beanName); 
            } 
        }); 
    } 
 
    public static AbstractTaskHandler getTaskHandler(String taskType) { 
        return TASK_HANDLERS_MAP.get(taskType); 
    } 
}  

這里繼承了Spring的ApplicationObjectSupport類，具體的注冊過程如下

1. Spring完成bean的初始化
2. 查找spring的容器中，所有帶有TaskHandler注解的bean
3. 校驗bean是否為AbstractTaskHandler類型，獲取到taskType
4. 把該bean放到TASK_HANDLERS_MAP容器中，即注冊完成

任務執行

接下來我們來看下任務執行

public class TaskExecutor implements Job { 
 
    private static final String TASK_TYPE = "taskType"; 
 
    @Override 
    public BaseResult execute(Task task){ 
        String taskType=task.getTaskType(); 
        if (TaskHandlerRegister.getTaskHandler(taskType) == null) { 
            throw new RuntimeException("can't find taskHandler,taskType=" + taskType); 
        } 
        AbstractTaskHandler abstractHandler = TaskHandlerRegister.getTaskHandler(taskType); 
        return abstractHandler.execute(task); 
    } 
}  

這里發起任務執行的是一個Job，具體過程如下

1. 校驗該任務類型，有沒有在注冊中心注冊相關Handler
2. 從任務注冊中心獲取到對應的處理的Handelr
3. 執行該Handelr

以上過程就完成了，可以實現基于注解的一個任務路由過程。其實現思路來自于Spring mvc的RequestMapping的設計思路.