如何处理route的数据结构 ，如何构建route

如何处理route的数据结构 ，如何构建route

route是一个在web程序中扮演很重要的角色，我们的uri其实就是一个路由，通过路由我们可以区分不同的请求，然后分派到具体的类中去执行响应具体的操作，那么怎么知道当前的uri到底是请求的哪个呢，这个就涉及到了route的数据结构的问题，慢慢的去体会他的无穷的奥妙。
Route的数据结构

public class Route {

    /**
     * HTTP Request Method
     */
    private HttpMethod httpMethod;

    /**
     * Route path
     */
    private String path;

    /**
     * Logical controller object
     */
    private Object target;

    /**
     * Controller Class Type
     */
    private Class<?> targetType;

    /**
     * Implementation logic controller method
     */
    private Method action;

    public Route() {
    }

    public Route(HttpMethod httpMethod, String path, Object target, Class<?> targetType, Method action) {
        super();
        this.httpMethod = httpMethod;
        this.path = Path.fixPath(path);
        this.target = target;
        this.targetType = targetType;
        this.action = action;
    }

    public HttpMethod getHttpMethod() {
        return httpMethod;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Method getAction() {
        return action;
    }

    public Class<?> getTargetType() {
        return targetType;
    }

    @Override
    public String toString() {
        return httpMethod + "\t" + path;
    }

}

//修正路径的信息哦
 public static String fixPath(String path) {
        if (path == null) {
            return "/";
        }
        if (!path.startsWith("/")) {
            path = "/" + path;
        }
        if (path.length() > 1 && path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }
        return path;
}

HttpMethod 枚举信息

public enum HttpMethod {
    ALL, GET, POST, PUT, PATCH, DELETE, HEAD, TRACE, CONNECT, OPTIONS, BEFORE, AFTER
}

Route的数据包含

• 请求的类型
• 请求的路径
• 响应的Class
• 响应的Object
• 响应的Method
  根据以上的几点，我们根本上就可以根据请求的path路径找到相应的执行的的类的信息哦！你觉得了？是不是这个道理。

如何处理自己定义的Route

比如我们在使用spring mvc的时候，肯定在Controller层处理了好多的route对吧，那么我们怎么去获取这写处理的逻辑呢，这里进行简单的说明一下子。

下面的这个是Blade的核心类，里面包含的很多，什么Ioc，全局配置信息，自然也是拥有Routers和RouterBuilder（ this.routeBuilder = new RouteBuilder(this.routers)），这里的保存的都是核心的东西，Blade是一个单例，这两个类到底是有何用？慢慢的揭晓这个答案，体会别人是怎么书写，怎么去构造这么大的工程的。

/**
 * Blade Core Class 
 */
public final class Blade {

    /**
     * Framework Global Configuration
     */
    private BConfig bConfig;

    /**
     * Default ioc container
     */
    private Ioc ioc = new SimpleIoc();

    /**
     * Default routes 这个就是route的一个集合
     */
    private Routers routers = new Routers();

    /**
     * Route builder  这里估计就是为了构建工程中书写的route放置在routers中去
     */
    private RouteBuilder routeBuilder;

    /**
     * filters
     */
    private Map<Class<? extends Filter>, String[]> filters = CollectionKit.newHashMap(8);

    /**
     * servlets
     */
    private Map<Class<? extends HttpServlet>, String[]> servlets = CollectionKit.newHashMap(8);

    /**
     * embed web server e.g:jetty/tomcat
     */
    private EmbedServer embedServer;

    private Blade() {
        this.bConfig = new BConfig();
        this.plugins = CollectionKit.newHashSet();
        this.routeBuilder = new RouteBuilder(this.routers);
    }

    private static final class BladeHolder {
        private static final Blade $ = new Blade();
    }

    /**
     * @return Single case method returns Blade object
     */
    public static Blade $() {
        return BladeHolder.$;
    }

    /**
     * @return return route manager
     */
    public Routers routers() {
        return routers;
    }

    /**
     * Setting Ioc packages, e.g:com.bladejava.service
     *
     * @param packages All need to do into the package, can be introduced into a
     *                 number of
     * @return return blade
     */
    public Blade scan(String... packages) {
        bConfig.addScanPackage(packages);
        return this;
    }

    /**
     * Add a route
     *
     * @param path   route path
     * @param clazz  Target object for routing
     * @param method The method name of the route (at the same time, the HttpMethod
     *               is specified: post:saveUser, if not specified, HttpMethod.ALL)
     * @return return blade
     */
    public Blade route(String path, Class<?> clazz, String method) {
        routers.route(path, clazz, method);
        return this;
    }

    /**
     * regsiter filter
     *
     * @param clazz
     * @param pathSpec
     * @return
     */
    public Blade registerFilter(Class<? extends Filter> clazz, String... pathSpec) {
        filters.put(clazz, pathSpec);
        return this;
    }

    /**
     * regsiter servlet
     *
     * @param clazz
     * @param pathSpec
     * @return
     */
    public Blade registerServlet(Class<? extends HttpServlet> clazz, String... pathSpec) {
        servlets.put(clazz, pathSpec);
        return this;
    }


    /**
     * Register a functional route
     *
     * @param path       route url
     * @param clazz      route processing class
     * @param method     route processing method name
     * @param httpMethod HttpMethod Type, GET/POST/...
     * @return Blade return blade
     */
    public Blade route(String path, Class<?> clazz, String method, HttpMethod httpMethod) {
        routers.route(path, clazz, method, httpMethod);
        return this;
    }

    /**
     * Register a GET request route
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade get(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.GET);
        return this;
    }

    /**
     * Register a POST request route
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade post(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.POST);
        return this;
    }

    /**
     * Register a DELETE request route
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade delete(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.DELETE);
        return this;
    }

    /**
     * Register a PUT request route
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade put(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.PUT);
        return this;
    }

    /**
     * Register for any request routing
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade all(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.ALL);
        return this;
    }

    /**
     * Register for any request routing
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade any(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.ALL);
        return this;
    }



    /**
     * Register a pre routing request interceptor
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade before(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.BEFORE);
        return this;
    }

    /**
     * Register a after routing request interceptor
     *
     * @param path    route path, request url
     * @param handler execute route Handle
     * @return return blade
     */
    public Blade after(String path, RouteHandler handler) {
        routers.route(path, handler, HttpMethod.AFTER);
        return this;
    }

    /**
     * Setting the frame static file folder
     *
     * @param statics List of directories to filter, e.g: "/public,/static,/images"
     * @return return blade
     */
    public Blade addStatics(final String... statics) {
        bConfig.addStatic(statics);
        return this;
    }

    /**
     * add interceptor
     *
     * @param interceptor interceptor class
     * @return return blade obj
     */
    public Blade addInterceptor(Class<? extends Interceptor> interceptor) {
        routeBuilder.addInterceptor(interceptor);
        return this;
    }



    /**
     * @return Return blade config object
     */
    public BConfig bConfig() {
        return bConfig;
    }

    /**
     * @return Return blade config object
     */
    public Config config() {
        return bConfig.config();
    }

    /**
     * @return Return blade encoding, default is UTF-8
     */
    public String encoding() {
        return bConfig.getEncoding();
    }

    /**
     * @return Return blade web root path
     */
    public String webRoot() {
        return bConfig.webRoot();
    }
}

还记得之前controller注解？初始化Ioc的时候 ，Controller也是一样的不同的是需要处理route

classInfo 中为class< ?>和 className
下面的数据都是我们Blade这个核心类中的哦

 this.blade = Blade.$();//单例获取哦
 Ioc ioc = blade.ioc();
 //RouteBuilder中的routers也是blade中的哦。
 RouteBuilder routeBuilder = blade.routeBuilder();

下面的我们仅仅关注route和拦截器也是属于route的一部分哦。

 classInfos.forEach(c -> {
    Class< ?> clazz = c.getClazz();
    if (!clazz.isInterface() && !Modifier.isAbstract(clazz.getModifiers())) {
        Service service = clazz.getAnnotation(Service.class);
        Controller controller = clazz.getAnnotation(Controller.class);
        RestController restController = clazz.getAnnotation(RestController.class);
        Component component = clazz.getAnnotation(Component.class);
        if (null != service || null != component) {
            ioc.addBean(clazz);
        } else if (null != controller || null != restController) {
            ioc.addBean(clazz);
            routeBuilder.addRouter(clazz);//处理注解中的route
        } else if (clazz.getSuperclass().getName().equals("com.blade.aop.AbstractMethodInterceptor")) {
            aopInterceptors.add(ReflectKit.newInstance(clazz));
        } else {
            Class< ?>[] interfaces = clazz.getInterfaces();
            for (Class< ?> in : interfaces) {
                if (in.equals(Interceptor.class)) {
                    ioc.addBean(clazz);
                    routeBuilder.addInterceptor(clazz);
                } else if (in.equals(WebContextListener.class)) {
                    ctxClasses.add(c);
                } else if (in.equals(BeanProcessor.class)) {
                    processoers.add(c);
                }
            }
        }
    }
});

routerbuilder中处理Class类中的方法的注解哦，这个也是这个类的意思

基于设计模式的核心原则，单一原则（一个类只负责一件事）
addRouter,将当前类的所有的方法进行扫描，然后看看是否有注解，然后，将这个注解增加到routers中去处理涩，就是这样的逻辑。

     //Parse all routing in a controller

    public void addRouter(final Class< ?> router) {

        Method[] methods = router.getMethods();//得到当前Class的所有的方法
        if (null == methods || methods.length == 0) {
            return;
        }
        //route的空间和后缀
        String nameSpace = null, suffix = null;

        if (null != router.getAnnotation(Controller.class)) {
            nameSpace = router.getAnnotation(Controller.class).value();
            suffix = router.getAnnotation(Controller.class).suffix();
        }

        if (null != router.getAnnotation(RestController.class)) {
            nameSpace = router.getAnnotation(RestController.class).value();
            suffix = router.getAnnotation(RestController.class).suffix();
        }

        if (null == nameSpace) {
            LOGGER.warn("Route [{}] not controller annotation", router.getName());
            return;
        }
        for (Method method : methods) {
            //是否含有route的注解啊
            Route mapping = method.getAnnotation(Route.class);
            //route method
            if (null != mapping) {
                // build multiple route，一个方法对应多个路由哦
                HttpMethod methodType = mapping.method();
                String[] paths = mapping.value();
                if (paths.length > 0) {
                    for (String path : paths) {
                        String pathV = getRoutePath(path, nameSpace, suffix);
                        this.buildRoute(router, method, pathV, methodType);
                    }
                }
            }
        }
    }

修正不同的书写路径的写法

private String getRoutePath(String value, String nameSpace, String suffix) {
    String path = value.startsWith("/") ? value : "/" + value;

    nameSpace = nameSpace.startsWith("/") ? nameSpace : "/" + nameSpace;
    path = nameSpace + path;

    path = path.replaceAll("[/]+", "/");

    path = path.length() > 1 && path.endsWith("/") ? path.substring(0, path.length() - 1) : path;

    path = path + suffix;

    return path;
}

Route的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Route {

    /**
     * @return Request url
     */
    String[] value() default {"/"};

    /**
     * @return Request HttpMethod
     */
    HttpMethod method() default HttpMethod.ALL;

}

将所有的route需要耳朵class,Method,path等传递过去，,routers就是处理这个的哦，里面的Map<路径对应，一个route>,将当前的route信息扔过去就好了。

     /**
     * Build a route
     *
     * @param clazz        route target execution class
     * @param execMethod    route execution method
     * @param path            route path
     * @param method        route httpmethod
     */
    private void buildRoute(Class< ?> clazz, Method execMethod, String path, HttpMethod method) {
        routers.buildRoute(path, clazz, execMethod, method);
    }

看看routerbuilder整个类的完整的信息,这里还有个处理就是处理过滤器哦，拦截器哈哈！道理是一个样子的！

public class RouteBuilder {
    private Routers routers;

    public RouteBuilder(Routers routers) {
        this.routers = routers;
    }

    /**
     * Parse Interceptor
     *
     * @param interceptor    resolve the interceptor class
     */
    public void addInterceptor(final Class<?> interceptor) {

        boolean hasInterface = ReflectKit.hasInterface(interceptor, Interceptor.class);
        if (null == interceptor || !hasInterface) {
            return;
        }

        Intercept intercept = interceptor.getAnnotation(Intercept.class);
        String partten = "/.*";
        if (null != intercept) {
            partten = intercept.value();
        }

        try {
            Method before = interceptor.getMethod("before", Request.class, Response.class);
            Method after = interceptor.getMethod("after", Request.class, Response.class);
            buildInterceptor(partten, interceptor, before, HttpMethod.BEFORE);
            buildInterceptor(partten, interceptor, after, HttpMethod.AFTER);
        } catch (Exception e) {
            LOGGER.error("", e);
        }
    }

    /**
     * Parse all routing in a controller
     *
     * @param router    resolve the routing class
     */
    public void addRouter(final Class<?> router) {

        Method[] methods = router.getMethods();
        if (null == methods || methods.length == 0) {
            return;
        }
        String nameSpace = null, suffix = null;

        if (null != router.getAnnotation(Controller.class)) {
            nameSpace = router.getAnnotation(Controller.class).value();
            suffix = router.getAnnotation(Controller.class).suffix();
        }

        if (null != router.getAnnotation(RestController.class)) {
            nameSpace = router.getAnnotation(RestController.class).value();
            suffix = router.getAnnotation(RestController.class).suffix();
        }

        if (null == nameSpace) {
            LOGGER.warn("Route [{}] not controller annotation", router.getName());
            return;
        }
        for (Method method : methods) {
            Route mapping = method.getAnnotation(Route.class);
            //route method
            if (null != mapping) {
                // build multiple route
                HttpMethod methodType = mapping.method();
                String[] paths = mapping.value();
                if (paths.length > 0) {
                    for (String path : paths) {
                        String pathV = getRoutePath(path, nameSpace, suffix);
                        this.buildRoute(router, method, pathV, methodType);
                    }
                }
            }
        }
    }

    private String getRoutePath(String value, String nameSpace, String suffix) {
        String path = value.startsWith("/") ? value : "/" + value;

        nameSpace = nameSpace.startsWith("/") ? nameSpace : "/" + nameSpace;
        path = nameSpace + path;

        path = path.replaceAll("[/]+", "/");

        path = path.length() > 1 && path.endsWith("/") ? path.substring(0, path.length() - 1) : path;

        path = path + suffix;

        return path;
    }

    /**
     * Build a route
     *
     * @param clazz        route target execution class
     * @param execMethod    route execution method
     * @param path            route path
     * @param method        route httpmethod
     */
    private void buildRoute(Class<?> clazz, Method execMethod, String path, HttpMethod method) {
        routers.buildRoute(path, clazz, execMethod, method);
    }

    /**
     * Build a route
     *
     * @param path            route path
     * @param clazz        route target execution class
     * @param execMethod    route execution method
     * @param method        route httpmethod
     */
    private void buildInterceptor(String path, Class<?> clazz, Method execMethod, HttpMethod method) {
        routers.buildRoute(path, clazz, execMethod, method);
    }

}

Routers 这个比较好理解的直接贴代码了，其实就是Map < String,Route>

我们可以自己通过函数添加，或者自动扫描添加。可以发现，routers非常的完善，可以自己随意的定义一个处理器哦！

public class Routers {

    private Map<String, Route> routes = null;
    private Map<String, Route> interceptors = null;
    private static final String METHOD_NAME = "handle";

    public Routers() {
        this.routes = CollectionKit.newConcurrentHashMap();
        this.interceptors = CollectionKit.newConcurrentHashMap();
    }

    public Map<String, Route> getRoutes() {
        return routes;
    }

    public Map<String, Route> getInterceptors() {
        return interceptors;
    }
   //路径的信息=path#方法名称 
    public void addRoute(Route route) {
        String path = route.getPath();
        HttpMethod httpMethod = route.getHttpMethod();
        String key = path + "#" + httpMethod.toString();

        // existent
        if (null != this.routes.get(key)) {

        }

        if (httpMethod == HttpMethod.BEFORE || httpMethod == HttpMethod.AFTER) {
            if (null != this.interceptors.get(key)) {
            }
            this.interceptors.put(key, route);
            LOGGER.debug("Add Interceptor => {}", route);
        } else {
            this.routes.put(key, route);
            LOGGER.debug("Add Route => {}", route);
        }
    }

    public void addRoutes(List<Route> routes) {
        Assert.notNull(routes);
        routes.forEach(this::addRoute);
    }

    public void addRoute(HttpMethod httpMethod, String path, RouteHandler handler, String methodName) throws NoSuchMethodException {
        Class<?> handleType = handler.getClass();
        Method method = handleType.getMethod(methodName, Request.class, Response.class);
        addRoute(httpMethod, path, handler, RouteHandler.class, method);
    }

    public void addRoute(HttpMethod httpMethod, String path, Object controller, Class<?> controllerType, Method method) {

        Assert.notBlank(path);

        String key = path + "#" + httpMethod.toString();
        // existent
        if (null != this.routes.get(key)) {
        }

        Route route = new Route(httpMethod, path, controller, controllerType, method);
        if (httpMethod == HttpMethod.BEFORE || httpMethod == HttpMethod.AFTER) {
            if (null != this.interceptors.get(key)) {
            }
            this.interceptors.put(key, route);
            LOGGER.info("Add Interceptor: {}", route);
        } else {
            this.routes.put(key, route);
            LOGGER.info("Add Route => {}", route);
        }

    }

    public void route(String path, RouteHandler handler, HttpMethod httpMethod) {
        try {
            addRoute(httpMethod, path, handler, METHOD_NAME);
        } catch (NoSuchMethodException e) {
            throw new BladeException(e);
        }
    }

    public void route(String[] paths, RouteHandler handler, HttpMethod httpMethod) {
        for (String path : paths) {
            route(path, handler, httpMethod);
        }
    }

    private Map<String, Method[]> classMethosPool = CollectionKit.newConcurrentHashMap(16);
    private Map<Class<?>, Object> controllerPool = CollectionKit.newConcurrentHashMap(16);

    public void route(String path, Class<?> clazz, String methodName) {
        Assert.notNull(methodName, "Method name not is null");
        HttpMethod httpMethod = HttpMethod.ALL;
        if (methodName.contains(":")) {
            String[] methodArr = methodName.split(":");
            httpMethod = HttpMethod.valueOf(methodArr[0].toUpperCase());
            methodName = methodArr[1];
        }
        this.route(path, clazz, methodName, httpMethod);
    }

    public void route(String path, Class<?> clazz, String methodName, HttpMethod httpMethod) {
        try {
            Assert.notNull(path, "Route path not is null!");
            Assert.notNull(clazz, "Class Type not is null!");
            Assert.notNull(methodName, "Method name not is null");
            Assert.notNull(httpMethod, "Request Method not is null");

            Method[] methods = classMethosPool.get(clazz.getName());
            if (null == methods) {
                methods = clazz.getMethods();
                classMethosPool.put(clazz.getName(), methods);
            }
            if (null != methods) {
                for (Method method : methods) {
                    if (method.getName().equals(methodName)) {
                        Object controller = controllerPool.get(clazz);
                        if (null == controller) {
                            controller = ReflectKit.newInstance(clazz);
                            controllerPool.put(clazz, controller);
                        }
                        addRoute(httpMethod, path, controller, clazz, method);
                    }
                }
            }
        } catch (Exception e) {
            LOGGER.error("", e);
        }
    }

    public void buildRoute(String path, Class<?> clazz, Method method, HttpMethod httpMethod) {
        addRoute(httpMethod, path, null, clazz, method);
    }

}

public interface RouteHandler {

    void handle(Request request, Response response);

}