责任链模式 手写实现

通过在写filter的时候，使用的是spring中带的，今天自己手写了一个
主要步骤
1、扫描包
2、找到对应的handler类
3、写@order 注解实现拦截器步骤
github 地址

先看测试结果

这里只是提供了一个Handler类

  public static void main(String[] args)  {
    ClassUtils classUtils = new ClassUtilsImpl();
    List<Class> handlerClass = classUtils.loadClass(Handler.class);
    CostomHandler costomHandler;
    for (Class aClass : handlerClass) {
      costomHandler = (CostomHandler) aClass.newInstance();
      costomHandler.handleMessage();
    }
  }

在写的时候只要

实现Handler

@Order(1)
public class CostomHandlerImpl extends CostomHandler {

  @Override
  public void handleMessage() {
    System.out.println(this.getClass().getName());
  }
}

结果

结果

public interface ClassUtils<Class> {

  /**
   * 指定路径加载
   */
  List<Class> loadClass(String scanPath, java.lang.Class extendClass) throws ClassNotFoundException;

  /**
   * 全局扫描
   */
  List<Class> loadClass(java.lang.Class extendClass) throws ClassNotFoundException;

}

1、扫描包

就是简单递归找到对应的文件的过程，主要就是需要判断下，当前包下的地址扫描

private void getFilesName(File file, List<String> fileList) {
    if (file.isDirectory()) {
      File[] files = file.listFiles();
      for (File f : files) {
        if (file.isFile()) {
          getClassFile(file, fileList);
        } else {
          getFilesName(f, fileList);
        }
      }
    } else {
      getClassFile(file, fileList);
    }
  }

2、找到对应的handler

找到对应的文件，除去handler 接口 ，抽象类等

 @Override
  public List<Class> loadClass(String scanPath, Class extendClass) throws ClassNotFoundException {
    List<String> className = getClassName(new File(getRootPath() + scanPath.replace(POINT, SLASH)));
    List<Class> list = new ArrayList<>();
    Class c;
    for (String str : className) {
      c = Class.forName(str);
      if (extendClass.isAssignableFrom(c) && extendClass != c && !Modifier
        .isAbstract(c.getModifiers())) {
        list.add(c);
      }
    }
    return sortByOrder(list);
  }

3、排序

在每个实现类上面写上注解，根据注解上面的值的大小，进行排序
主要规则是，没有写注解的话或者注解值为空的，就排到最后
注解

/**
 * @author liust
 */
@Retention(value = RUNTIME)
@Target(value = {TYPE})
@Documented
public @interface Order {

  int value() default Integer.MAX_VALUE;
}

排序规则

/**
  * 根据Order排序
  */
 private List<Class> sortByOrder(List<Class> classes) {
   return classes.stream().sorted((o1, o2) -> {
     Order a1 = (Order) o1.getAnnotation(Order.class);
     Order a2 = (Order) o2.getAnnotation(Order.class);
     return (a1 == null ? Integer.MAX_VALUE : a1.value()) -
       (a2 == null ? Integer.MAX_VALUE : a2.value());
   }).collect(Collectors.toList());
 }

这样就实现简单的责任链模式，同时做到了扩展性高，有排序功能
你可以随意的写实现了Handler的类，需要排序就写上注解。
还可以做一些扩展性的功能，比如需要什么时候进行加载，什么时候进行处理等等。

github 地址