背景

Tomcat下使用JSP作为监控手段可以非常简单的处理. 而在SpringBoot下支持的不是蛮好了，也是需要我们手动进行支持，还是使用JSP去监控SpringBoot的运行.

目标

写一个兼容SpringBoot可以访问JSP的starter. 这些JSP是作为监控手段使用，基本上不会再发生变化，非常稳定. 而SpringBoot 1.x 和 SpringBoot 2.x 的版本变化很大，最为明显的就是SpringBoot 1.x中的一些类在SpringBoot 2.x中已经变更类package. 为了减少频繁变更jar包，一个兼容 SpringBoot1和SpringBoot2的jar包还挺好的。

行动

工欲善其事，必先利其器，
Q: 我们要做什么
A: SpringBoot支持访问JSP，且对业务方无感觉

Q: Tomcat是如何找到JSP的，如何处理JSP的
A: 不知道如何找到的，将jsp编译成class文件，使用jspClassloader单独加载使用. 处理jsp部分交给tomcat的DefaultServlet进行处理

Tomcat是怎么找到JSP的

已经知道了JSP是被DefaultServlet处理的222.jpeg

兼容SpringBoot1和SpringBoot2的Starter - 图2 综上所述聚焦于WebResourceRoot是如何查找到JSP文件的。沿着这里继续深入可以看到如下结果，过程不再赘述(不同的Tomcat版本可能会有小小的改变)

兼容SpringBoot1和SpringBoot2的Starter - 图3 查找源代码如下 getResourceInternal() 

  1. private final List<List<WebResourceSet>> allResources = new ArrayList<>();
  2. protected final WebResource getResourceInternal(String path,boolean useClassLoaderResources) {
  3.         WebResource result = null;
  4.         WebResource virtual = null;
  5.         WebResource mainEmpty = null;
  6.         //遍历
  7.         for (List<WebResourceSet> list : allResources) {
  8.             for (WebResourceSet webResourceSet : list) {
  9.                 if (!useClassLoaderResources &&  !webResourceSet.getClassLoaderOnly() ||
  10.                         useClassLoaderResources && !webResourceSet.getStaticOnly()) {
  11.                     result = webResourceSet.getResource(path);
  12.                     if (result.exists()) {
  13.                         return result;
  14.                     }
  15.                     if (virtual == null) {
  16.                         if (result.isVirtual()) {
  17.                             virtual = result;
  18.                         } else if (main.equals(webResourceSet)) {
  19.                             mainEmpty = result;
  20.                         }
  21.                     }
  22.                 }
  23.             }
  24.         }
  26.         // Use the first virtual result if no real result was found
  27.         if (virtual != null) {
  28.             return virtual;
  29.         }
  31.         // Default is empty resource in main resources
  32.         return mainEmpty;
  33.     }

如此看来，只要将JSP写入到allResources中去即可. 11.jpeg

如何注入JSP到指定地点

经过多方打探，终于找到地址，原来是 StandardRoot#createWebResourceSet 中有一个资源插入的过程. 

  1. @Override
  2.     public void createWebResourceSet(ResourceSetType type, String webAppMount,
  3.             URL url, String internalPath) {
  4.         BaseLocation baseLocation = new BaseLocation(url);
  5.         //引用的这里
  6.         createWebResourceSet(type, webAppMount, baseLocation.getBasePath(),
  7.                 baseLocation.getArchivePath(), internalPath);
  8.     }
  10.     //实际执行
  11.     @Override
  12.     public void createWebResourceSet(ResourceSetType type, String webAppMount,
  13.             String base, String archivePath, String internalPath) {
  14.         List<WebResourceSet> resourceList;
  15.         WebResourceSet resourceSet;
  17.         switch (type) {
  18.             case PRE:
  19.                 resourceList = preResources;
  20.                 break;
  21.             case CLASSES_JAR:
  22.                 resourceList = classResources;
  23.                 break;
  24.             case RESOURCE_JAR:
  25.                 resourceList = jarResources;
  26.                 break;
  27.             case POST:
  28.                 resourceList = postResources;
  29.                 break;
  30.             default:
  31.                 throw new IllegalArgumentException(
  32.                         sm.getString("standardRoot.createUnknownType", type));
  33.         }
  35.         // This implementation assumes that the base for all resources will be a
  36.         // file.
  37.         File file = new File(base);
  39.         if (file.isFile()) {
  40.             if (archivePath != null) {
  41.                 // Must be a JAR nested inside a WAR if archivePath is non-null
  42.                 resourceSet = new JarWarResourceSet(this, webAppMount, base,
  43.                         archivePath, internalPath);
  44.             } else if (file.getName().toLowerCase(Locale.ENGLISH).endsWith(".jar")) {
  45.                 resourceSet = new JarResourceSet(this, webAppMount, base,
  46.                         internalPath);
  47.             } else {
  48.                 resourceSet = new FileResourceSet(this, webAppMount, base,
  49.                         internalPath);
  50.             }
  51.         } else if (file.isDirectory()) {
  52.             resourceSet =
  53.                     new DirResourceSet(this, webAppMount, base, internalPath);
  54.         } else {
  55.             throw new IllegalArgumentException(
  56.                     sm.getString("standardRoot.createInvalidFile", file));
  57.         }
  59.         if (type.equals(ResourceSetType.CLASSES_JAR)) {
  60.             resourceSet.setClassLoaderOnly(true);
  61.         } else if (type.equals(ResourceSetType.RESOURCE_JAR)) {
  62.             resourceSet.setStaticOnly(true);
  63.         }
  65.         resourceList.add(resourceSet);
  66.     }

44.jpeg

这样依赖，我只要持有一个 WebResourceRoot 的引用即可实现找到JSP的这个过程了。 而这个引用在Tomcat中是线程的。可以用过Context可以获取到这个依赖.

兼容SpringBoot1和SpringBoot2的Tomcat

SpringBoot1 和 SpringBoot2到package换了，具体是Boot1是

  • org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer

这段代码写在 module1 下 

  1. /**
  2.  * @author chenshun00@gmail.com
  3.  * @since 2018/12/27
  4.  */
  5. public abstract class Boot1 {
  6.     public final static Object object;
  7.     static {
  8.         object = new EmbeddedServletContainerCustomizer() {
  9.                     @Override
  10.                     public void customize(ConfigurableEmbeddedServletContainer container) {
  11.                         if (container instanceof TomcatEmbeddedServletContainerFactory) {
  12.                             ((TomcatEmbeddedServletContainerFactory) container).addContextCustomizers(new TomcatContextCustomizer() {
  13.                                 @Override
  14.                                 public void customize(Context context) {
  15.                                     //没错 ResourceConfigurer是我加的
  16.                                     context.addLifecycleListener(new ResourceConfigurer(context));
  17.                                 }
  18.                             });
  19.                         }
  20.             }
  21.         };
  22.     }
  23. }

Boot2是

  • org.springframework.boot.web.server.WebServerFactoryCustomizer

这段写在module2下

  1. public abstract class AgentObject {
  2.     public static Object object;
  3.     static {
  4.         //没错 ResourceConfigurer是我加的
  5.         object = new WebServerFactoryCustomizer<WebServerFactory>() {
  6.             @Override
  7.             public void customize(WebServerFactory factory) {
  8.                 if (factory instanceof TomcatServletWebServerFactory) {
  9.                     TomcatServletWebServerFactory tomcatServletWebServerFactory = (TomcatServletWebServerFactory) factory;
  10.                     tomcatServletWebServerFactory.addContextCustomizers(new TomcatContextCustomizer() {
  11.                         @Override
  12.                         public void customize(Context context) {
  13.                             context.addLifecycleListener(new ResourceConfigurer(context));
  14.                         }
  15.                     });
  16.                 } else {
  17.                     if (factory instanceof TomcatReactiveWebServerFactory) {
  18.                         TomcatReactiveWebServerFactory tomcatServletWebServerFactory = (TomcatReactiveWebServerFactory) factory;
  19.                         tomcatServletWebServerFactory.addContextCustomizers(new TomcatContextCustomizer() {
  20.                             @Override
  21.                             public void customize(Context context) {
  22.                                 context.addLifecycleListener(new ResourceConfigurer(context));
  23.                             }
  24.                         });
  25.                     } else {
  26.                         throw new RuntimeException("未知容器,请和xxx联系修改starter实现");
  27.                     }
  28.                 }
  29.             }
  30.         };
  31.     }
  32. }

为啥子要分开2个呢，因为他们分别依赖段是SpringBoot 1.5.15.Release 和 SpringBoot 2.0.3.Release ， 如果不区分是过不了编译滴.

ResourceConfigurer 的作用就是用来传递Context ,然后将JSP代码所在目录传递进去. 

  1. public class ResourceConfigurer implements LifecycleListener {
  2.     private final Context context;
  3.     private volatile boolean init = false;
  5.     public ResourceConfigurer(Context context) {
  6.         this.context = context;
  7.     }
  9.     @Override
  10.     public void lifecycleEvent(LifecycleEvent event) {
  11.         //支持 META-INF/resources 下的jsp  需要拿到主目录的那个jar包
  12.         application(event);
  13.         starter(event);
  14.     }
  16.     private void starter(LifecycleEvent event) {
  17.         if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
  18.             if (!init) {
  19.                 init = true;
  20.                 try {
  21.                     String property = System.getProperty("springboot.home", System.getProperty("user.home"));
  22.                     System.out.println("property ===>" + property);
  23.                     property = property.endsWith("/") ? property : property + "/";
  24.                     property = property + "code";
  25.                     check(property);
  26.                     URL url = ResourceUtils.getURL(property);
  27.                     context.getResources().createWebResourceSet(WebResourceRoot.ResourceSetType.RESOURCE_JAR, "/", url, "/");
  28.                 } catch (FileNotFoundException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.             }
  32.         }
  33.     }
  35.     private void application(LifecycleEvent event) {
  36.         try {
  37.             if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
  38.                 URL location = ClassUtils.getDefaultClassLoader().getResource("");
  39.                 if (location != null) {
  40.                     if (ResourceUtils.isFileURL(location)) {
  41.                         // when run as exploded directory
  42.                         String rootFile = location.getFile();
  43.                         if (rootFile.endsWith("/BOOT-INF/classes/")) {
  44.                             rootFile = rootFile.substring(0, rootFile.length() - "/BOOT-INF/classes/".length() + 1);
  45.                         }
  46.                         if (!new File(rootFile, "META-INF" + File.separator + "resources").isDirectory()) {
  47.                             return;
  48.                         }
  49.                         try {
  50.                             location = new File(rootFile).toURI().toURL();
  51.                         } catch (MalformedURLException e) {
  52.                             throw new IllegalStateException("Can not add tomcat resources", e);
  53.                         }
  54.                     }
  56.                     String locationStr = location.toString();
  57.                     if (locationStr.endsWith("/BOOT-INF/classes!/")) {
  58.                         // when run as fat jar
  59.                         locationStr = locationStr.substring(0, locationStr.length() - "/BOOT-INF/classes!/".length() + 1);
  60.                         try {
  61.                             location = new URL(locationStr);
  62.                         } catch (MalformedURLException e) {
  63.                             throw new IllegalStateException("Can not add tomcat resources", e);
  64.                         }
  65.                     }
  66.                     this.context.getResources().createWebResourceSet(WebResourceRoot.ResourceSetType.RESOURCE_JAR, "/", location, "/META-INF/resources");
  67.                 }
  68.             }
  69.         } catch (Throwable ex) {
  70.             System.out.println("访问不了也没关系:" + ex.getMessage());
  71.         }
  72.     }
  74.     private void check(String property) {
  75.         File file = new File(property);
  76.         if (!file.exists()) {
  77.             System.err.println("错误:请检查[" + property + "]目录存不存在");
  78.             System.exit(1);
  79.         }
  80.     }
  81. }

到这里兼容2个Tomcat是搞定了 55.jpeg
但是我们希望要是只要一个jar包就好了，而且这个jar包是通过SpringBoot到 loader.path 进行处理的，业务无感知，当然这个无法阻挡我们，将这些jar包打在一起不就可以了吗 

  1. <plugin>
  2.     <artifactId>maven-assembly-plugin</artifactId>
  3.     <configuration>
  4.         <appendAssemblyId>false</appendAssemblyId>
  5.         <descriptorRefs>
  6.             <descriptorRef>jar-with-dependencies</descriptorRef>
  7.         </descriptorRefs>
  8.     </configuration>
  9.     <executions>
  10.         <execution>
  11.             <id>make-assembly</id>
  12.             <phase>package</phase>
  13.             <goals>
  14.                 <goal>assembly</goal>
  15.             </goals>
  16.         </execution>
  17.     </executions>
  18. </plugin>

经历到了这里，还差最后一步，如何将Tomcat到配置叫给SpringBoot进行管理呢，如果不能进行管理上边做的事跟没做一样的.

一开始想到到是直接用@Bean进行注入,但是并没有用 因为等到你注入这个的时候，Tomcat流程都跑完了，黄花菜都凉了. 

  1. @Bean
  2. public Object tomcatContext(){
  3.      if (boot1){
  4.         return Boot1.object;
  5.     } else {
  6.         return AgentObject.object;
  7.     }
  8. }

不断的Google发现只能在BeanFactoryPostProcessor中进行注入了，最终实现如下 

  1. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  3.     private volatile boolean tomcat;
  5.     public MyBeanFactoryPostProcessor(boolean tomcat) {
  6.         this.tomcat = tomcat;
  7.     }
  9.     @Override
  10.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
  11.         if (tomcat) {
  12.             System.out.println("tomcat+SpringBoot项目不初始化");
  13.             return;
  14.         }
  15.         if (!init) {
  16.             init = true;
  17.             System.out.println("==========init MyBeanFactoryPostProcessor=========");
  18.             DefaultListableBeanFactory re = (DefaultListableBeanFactory) configurableListableBeanFactory;
  19.             try {
  20.                 re.registerSingleton("ffEmbeddedServletContainerCustomizer", ff);
  21.             } catch (Exception e) {
  22.                 e.printStackTrace();
  23.             }
  24.         }
  25.     }
  27.     private volatile boolean init = false;
  28.     private static Object ff;
  30.     static {
  31.         try {
  32.             if (Constant.springBoot1_5) {
  33.                 ff = Boot1.object;
  34.             }
  35.         } catch (Throwable ignored) {
  37.         }
  39.         try {
  40.             if (Constant.springBoot2_0) {
  41.                 ff = AgentObject.object;
  42.             }
  43.         } catch (Throwable ignored) {
  45.         }
  46.     }
  47. }

各个module如下图

image.png

分这么多主要是解决1.x 和 2.x 不兼容的问题，最后打包通过 maven-assembly-plugin 插件打包到一次就可以了

总结

世界是科学的