上一节我们分析到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，其最终的效果都是一样的，至于我们的应用需要使用某种方式或者使用静态+动态的方式就需要我们根据实际业务进行利益权衡了！
这里笔者还是推荐使用静态方式，因为作为网关，是流量的入口，网关的稳定是极为重要的，动态方式虽好，但是不利于管理！
