Spring Cloud Zuul 分析(二)之ZuulFilt

上一节我们分析到ZuulServlet会根据优先级依次执行pre filters、routing filters、post filters这些拦截器，也知道Zuul的核心就是filter拦截器，但是这么多filter拦截器是如何初始化以及如何调用到这些filter拦截器的？本节我们就带着这些疑问进行分析与总结！

ZuulConfiguration#ZuulFilterConfiguration

@Configuration
@EnableConfigurationProperties({ ZuulProperties.class })
@ConditionalOnClass(ZuulServlet.class)
@Import(ServerPropertiesAutoConfiguration.class)
public class ZuulConfiguration {
    ......
    @Configuration
    protected static class ZuulFilterConfiguration {
        @Autowired
        private Map<String, ZuulFilter> filters;
        @Bean
        public ZuulFilterInitializer zuulFilterInitializer() {
            return new ZuulFilterInitializer(this.filters);
        }
    }
    ......
}

Map<String, ZuulFilter> filters这个对象，key->SpringIoc容器中ZuulFilter对应的BeanName，当然默认的BeanName为注册ZuulFilter对应的方法名，获取到所有ZuulFilter然后传递给ZuulFilterInitializer进行初始化工作。

ZuulFilterInitializer

public class ZuulFilterInitializer implements ServletContextListener {
    private Map<String, ZuulFilter> filters;
    public ZuulFilterInitializer(Map<String, ZuulFilter> filters) {
        this.filters = filters;
    }
    //Servlet容器启动触发
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        log.info("Starting filter initializer context listener");
        //用于Mock数据
        MonitoringHelper.initMocks();
        //获取FilterRegistry单列
        FilterRegistry registry = FilterRegistry.instance();
        //将ZuulFilter填充到FilterRegistry#ConcurrentHashMap对象中,提供给其他地方使用
        for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
            registry.put(entry.getKey(), entry.getValue());
        }
    }
    //Servlet容器销毁触发
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        log.info("Stopping filter initializer context listener");
        FilterRegistry registry = FilterRegistry.instance();
        //删除ZuulFilter
        for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
            registry.remove(entry.getKey());
        }
        clearLoaderCache();
    }
    //清除缓存，主要就是清除hashFiltersByType这个ConcurrentHashMap的数据
    private void clearLoaderCache() {
        FilterLoader instance = FilterLoader.getInstance();
        Field field = ReflectionUtils.findField(FilterLoader.class, "hashFiltersByType");
        ReflectionUtils.makeAccessible(field);
        @SuppressWarnings("rawtypes")
        Map cache = (Map) ReflectionUtils.getField(field, instance);
        cache.clear();
    }
}

静态方式的注册方式就在ZuulFilterInitializer类中把ZuulFilter添加到了全局FilterRegistry#filters对象中,静态方式是我们比较常用的一种方式，不好的就是不能动态调整逻辑或者动态注册等等，但是业务隔离性比较好！那下面我们来看看Zuul官方的另一种方式，使用Groovy文件过滤器是如何初始化的。

FilterFileManager

public class FilterFileManager {
    ......
    //初始化入口
    public static void init(int pollingIntervalSeconds, String... directories) throws Exception, IllegalAccessException, InstantiationException {
        if (INSTANCE == null) INSTANCE = new FilterFileManager();
        //存放Groovy过滤器文件根目录-文件夹
        INSTANCE.aDirectories = directories;
        //刷新Groovy过滤器间隔时间,单位/秒
        INSTANCE.pollingIntervalSeconds = pollingIntervalSeconds;
        //初始化Groovy文件,将扫描到的Groovy过滤器文件添加到全局FilterLoader这个过滤器加载器中统一管理
        INSTANCE.manageFiles();
        //开启一个线程轮训刷新Groovy文件过滤器
        INSTANCE.startPoller();
    }
    public static FilterFileManager getInstance() {
        return INSTANCE;
    }
    public static void shutdown() {
        INSTANCE.stopPoller();
    }
    void stopPoller() {
        bRunning = false;
    }
    //开启轮训，就是一个线程sleep间隔时间然后重新扫描Groovy文件过滤器然后加入全局FilterLoader加载器中
    void startPoller() {
        poller = new Thread("GroovyFilterFileManagerPoller") {
            public void run() {
                while (bRunning) {
                    try {
                        sleep(pollingIntervalSeconds * 1000);
                        manageFiles();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        //设置守护线程，主线程关闭之后默认关闭
        poller.setDaemon(true);
        poller.start();
    }
    //根据当前sPath路径判断是否是文件夹路径，如果不是则抛异常x
    public File getDirectory(String sPath) {
        File  directory = new File(sPath);
        if (!directory.isDirectory()) {
            URL resource = FilterFileManager.class.getClassLoader().getResource(sPath);
            try {
                directory = new File(resource.toURI());
            } catch (Exception e) {
                LOG.error("Error accessing directory in classloader. path=" + sPath, e);
            }
            if (!directory.isDirectory()) {
                throw new RuntimeException(directory.getAbsolutePath() + " is not a valid directory");
            }
        }
        return directory;
    }
    //返回所有文件夹路径下的所有文件
    List<File> getFiles() {
        List<File> list = new ArrayList<File>();
        for (String sDirectory : aDirectories) {
            if (sDirectory != null) {
                File directory = getDirectory(sDirectory);
                File[] aFiles = directory.listFiles(FILENAME_FILTER);
                if (aFiles != null) {
                    list.addAll(Arrays.asList(aFiles));
                }
            }
        }
        return list;
    }
    //将Groovy文件加入FilterLoader进行初始化，转换为最终的ZuulFilter对象
    void processGroovyFiles(List<File> aFiles) throws Exception, InstantiationException, IllegalAccessException {
        for (File file : aFiles) {
            //内部会使用GroovyClassLoader将file文件转换为Java Class，然后实例化为ZuulFilter
            FilterLoader.getInstance().putFilter(file);
        }
    }
    //处理Groovy过滤器文件
    void manageFiles() throws Exception, IllegalAccessException, InstantiationException {
        List<File> aFiles = getFiles();
        processGroovyFiles(aFiles);
    }
}

通过分析我们能得知使用Groovy文件的方式，其实内部也是会将其转换为ZuulFilter接口，这样的方式可以实现动态加载ZuulFilter，看起来功能比较强大，但是需要使用Groovy语法支持，有兴趣的同学可以不妨试试这样的方式，只需要手动调用FilterFileManager#init()方法

综上所诉我们对Zuul网关的ZuulFilter过滤器的整个初始化过程有了一定了解，使用静态方式生成的ZuulFilter或者使用动态方式的Groovy文件生成ZuulFilter，其最终的效果都是一样的，至于我们的应用需要使用某种方式或者使用静态+动态的方式就需要我们根据实际业务进行利益权衡了！
这里笔者还是推荐使用静态方式，因为作为网关，是流量的入口，网关的稳定是极为重要的，动态方式虽好，但是不利于管理！