JSP的编译流程

发表于 分类于 阅读次数： 本文字数： 2.2k 阅读时长 ≈ 8 分钟

情景还原

用Spring Boot简单搭建环境, 建一个Controller以及两个JSP页面。
发现/test1页面404不能访问, 而/test2可以访问。

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class TestController {
    @GetMapping("test1")
    public String test1() {
        return "/WEB-INF/views/IE10+.jsp";
    }
    @GetMapping("test2")
    public String test2() {
        return "/WEB-INF/views/IE10.jsp";
    }
}

问题所在

JSP是本质一个Java文件, 所以命名也需要遵循Java命名规则, +加号对Java命名规则来说是一个非法字符。
所以IE10+.jsp对应的java文件是不存在的, 自然也就404了。
我在$CATALINA_BASE/work/Catalina/localhost/web/org/apache/jsp/WEB_002dINF/views/下只看到了IE10_jsp.java和IE10_jsp.class这两个文件。

JSP编译流程

  1. 客户端请求JSP文件.
  2. Servlet容器将请求交给org.apache.jasper.servlet.JspServlet处理, 具体配置在Tomcat的conf/web.xml中.
  3. JspServlet生成java文件, 编译为class文件, 加载到ClassLoader, 加入缓存中.
  4. 调用生成的Servlet的service方法处理请求.

基于Tomcat 8.5.35的源码分析

![继承树](https://yuml.me/diagram/nofunky/class/[<>;interface]^-[JspServlet], [HttpServlet]^-[JspServlet])
JspServlet继承了HttpServlet, 并实现了PeriodicEventListener接口, 这个接口暂时不管它, HttpServlet在我另一篇文章中有做源码解析。

重写了继承树上GenericServlet的方法

JspServlet重写了GenericServlet的两个方法.
默认情况下, 只做了一件事, 对JspRuntimeContext的实例进行初始化和销毁.

  1. public void init(ServletConfig config); 初始化方法, 默认只初始化JspRuntimeContext的实例
  2. public void destroy(); 销毁方法, 销毁JspRuntimeContext的实例
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // org.apache.jasper.servlet.JspServlet
    public class JspServlet extends HttpServlet implements PeriodicEventListener {
        private transient ServletContext context;
        private ServletConfig config;
        private transient Options options;
        private transient JspRuntimeContext rctxt;
        private String jspFile;
        @Override
        public void init(ServletConfig config) throws ServletException {
            super.init(config);
            this.config = config;
            this.context = config.getServletContext();

            // 省略部分代码, 默认不执行的代码
            options = new EmbeddedServletOptions(config, context);
            rctxt = new JspRuntimeContext(context, options);
        }

        @Override
        public void destroy() {
            rctxt.destroy();
        }
    }

重写了HttpServlet的service方法

service方法是实际处理请求的逻辑方法。这里不对include等特殊情况做分析.
首先会判断请求参数是否携带jsp_precompile参数, 如果有的话就标记成预编译, 交给后面的核心代码使用.
然后再从缓存中获取JspServletWrapper实例, 没有则创建.
最后交给JspServletWrapper的service去执行核心代码.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// org.apache.jasper.servlet.JspServlet
public class JspServlet extends HttpServlet implements PeriodicEventListener {
    private transient ServletContext context;
    private ServletConfig config;
    private transient Options options;
    private transient JspRuntimeContext rctxt;
    private String jspFile;
    @Override
    public void service (HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // jspFile may be configured as an init-param for this servlet instance
        String jspUri = request.getServletPath();
        String pathInfo = request.getPathInfo();
        if (pathInfo != null) {
            jspUri += pathInfo;
        }
        // 根据 jsp_precompile 参数是否存在, 判断是否需要进行预编译
        boolean precompile = preCompile(request);
        // 处理请求
        serviceJspFile(request, response, jspUri, precompile);
    }
    
    private void serviceJspFile(HttpServletRequest request, HttpServletResponse response, String jspUri, boolean precompile)
        throws ServletException, IOException {

        // 1. 从 JspRuntimeContext 缓存中获取 JspServlet包装类, 双重锁避免高并发问题
        JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
        if (wrapper == null) {
            synchronized(this) {
                wrapper = rctxt.getWrapper(jspUri);
                if (wrapper == null) {
                    // 判断请求的JSP是否存在, 避免创建无用的JspServletWwrapper
                    if (null == context.getResource(jspUri)) {
                        handleMissingResource(request, response, jspUri);
                        return;
                    }
                    wrapper = new JspServletWrapper(config, options, jspUri, rctxt);
                    // 加入 JspRuntimeContext 缓存
                    rctxt.addWrapper(jspUri,wrapper);
                }
            }
        }

        try {
            // 2. 核心处理代码
            wrapper.service(request, response, precompile);
        } catch (FileNotFoundException fnfe) {
            handleMissingResource(request, response, jspUri);
        }
    }
}

生成Java文件并编译

options.getDevelopment()这个变量是写在web.xml的JspServlet里, 通过ServletConfig的getInitParameter("development")方法获取. web.xml中没有进行配置, 所以默认为true.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// org.apache.jasper.servlet.JspServletWrapper
public class JspServletWrapper {
    private final JspCompilationContext ctxt;
    private volatile boolean mustCompile = true;
    private final Options options;

    public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile)
            throws ServletException, IOException, FileNotFoundException {
        // =========================================
        // (1) 编译, mustCompile默认为true, options.getDevelopment()默认为true
        // =========================================
        if (options.getDevelopment() || mustCompile) {
            synchronized (this) {
                if (options.getDevelopment() || mustCompile) {
                    // The following sets reload to true, if necessary
                    ctxt.compile();
                    mustCompile = false;
                }
            }
        }
        // ==================省略部分代码==================
    }
}

JspServletWrapper的service调用了JspCompilationContext的compile方法.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// org.apache.jasper.JspCompilationContext
public class JspCompilationContext {
    public void compile() throws JasperException, FileNotFoundException {
        // 1. 获取编译器
        createCompiler();
        // 2. 判断是否需要重新将 JSP 转为 java 文件, 并编译为 class 文件
        if (jspCompiler.isOutDated()) {
            if (isRemoved()) {
                throw new FileNotFoundException(jspUri);
            }
            // 3. 先删除上次生成的 class 文件, 后删除 java 文件
            jspCompiler.removeGeneratedFiles();
            jspLoader = null; // 清空 ClassLoader, 为了进行 JSP 热部署
            // 4. 重新生成 java 文件, 后编译为 class 文件
            jspCompiler.compile();
            jsw.setReload(true); // 设置重新加载 Servlet 的标识
            jsw.setCompilationException(null);
        }
        // 省略部分捕获异常的代码
    }
}

第一步, createCompiler();先获取编译器

  1. 判断web.xml里的JspServlet有没有定义编译器的类名compilerClassName, 有则创建
  2. 判断web.xml里的JspServlet有没有定义compiler, 有则先创建JDTCompiler编译器, 否则先创建AntCompiler. 创建失败则尝试创建两者的另一个编译器.
  3. 都创建失败, 则抛出异常

第二步, jspCompiler.isOutDated()比较JSP的最后修改时间和对应的class文件
最后修改时间, 过时则重新编译. 可以在web.xml里的JspServlet配置modificationTestInterval参数, 指定一定秒数内return false, 不进行重新编译.

第三步, 先删除上次生成的class文件, 后删除java文件。
第四步, 调用之前获取到的编译器的compile方法生成java文件, 并编译为class文件.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// org.apache.jasper.compiler.Compiler
public abstract class Compiler {
    public void compile() throws FileNotFoundException, JasperException, Exception {
        compile(true);
    }

    public void compile(boolean compileClass) throws FileNotFoundException, JasperException, Exception {
        compile(compileClass, false);
    }

    public void compile(boolean compileClass, boolean jspcMode) throws FileNotFoundException, JasperException, Exception {
        // 1. 生成 java 文件
        String[] smap = generateJava();
        File javaFile = new File(ctxt.getServletJavaFileName());
        Long jspLastModified = ctxt.getLastModified(ctxt.getJspFile());
        javaFile.setLastModified(jspLastModified.longValue());
        if (compileClass) {
            // 2. 编译为 class 文件, 交给子类实现, 如 AntCompiler、JDTCompiler
            generateClass(smap);
            // Fix for bugzilla 41606
            // Set JspServletWrapper.servletClassLastModifiedTime after successful compile
            File targetFile = new File(ctxt.getClassFileName());
            if (targetFile.exists()) {
                targetFile.setLastModified(jspLastModified.longValue());
                if (jsw != null) {
                    jsw.setServletClassLastModifiedTime(
                            jspLastModified.longValue());
                }
            }
        }
    }
}

获取 Servlet

同样是JspServletWrapper的service方法, 在编译出了class文件后, 就应该要将class加载到ClassLoader里了。
在之前提到的JspCompilationContext的compile方法里, 将JSP的ClassLoader变量jspLoader设置为了null. 因为一个ClassLoader不能加载两个相同的类, 所以要一个新的ClassLoader进行热部署JSP.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// org.apache.jasper.servlet.JspServletWrapper
public class JspServletWrapper {
    private Servlet theServlet;

    public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile)
            throws ServletException, IOException, FileNotFoundException {
        // =========================================
        // (2) (重新)加载 servlet class 文件
        // =========================================
        Servlet servlet = getServlet();
        // 如果请求参数 jsp_precompile 存在, 则不执行之后的代码
        if (precompile) {
            return;
        }
        // =========================================
    }

    public Servlet getServlet() throws ServletException {
        if (getReloadInternal() || theServlet == null) {
            synchronized (this) {
                // Synchronizing on jsw enables simultaneous loading
                // of different pages, but not the same page.
                if (getReloadInternal() || theServlet == null) {
                    // 1. 先销毁旧的 Servlet
                    destroy();
                    // 2. 加载 class 并反射创建 Servlet, 这里的 JspLoader 在之前设置为 null, 所以这里会 new 一个 JspLoader
                    InstanceManager instanceManager = InstanceManagerFactory.getInstanceManager(config);
                    // fqcn 是  Full Qualified Class Name 的缩写
                    Servlet servlet = (Servlet) instanceManager.newInstance(ctxt.getFQCN(), ctxt.getJspLoader());
                    // 3. 初始化 Servlet
                    servlet.init(config);

                    // 4. JSP 重载数量+1
                    if (theServlet != null) {
                        ctxt.getRuntimeContext().incrementJspReloadCount();
                    }

                    theServlet = servlet;
                    reload = false; // 编译时会重新设置为 true, 用于进入此 if
                    // Volatile 'reload' forces in order write of 'theServlet' and new servlet object
                }
            }
        }
        return theServlet;
    }
}

限制 JSP 加载数量(选读)

默认不执行这段代码, 属于程序优化部分, 比较简单, 就是对一个队列进行先进先出的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// org.apache.jasper.servlet.JspServletWrapper
public class JspServletWrapper {
    private final boolean unloadAllowed; // web.xml 的 JspServlet 的 maxLoadedJsps  参数配置, 大于0则为true
    private final boolean unloadByIdle;  // web.xml 的 JspServlet 的 jspIdleTimeout 参数配置, 大于0则为true
    private final boolean unloadByCount; // 值为 unloadAllowed || unloadByIdle

    public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile)
            throws ServletException, IOException, FileNotFoundException {
        // =========================================
        // (3) 限制 JSP 数量, 先进先出的队列
        // =========================================
        if (unloadAllowed) {
            synchronized (this) {
                if (unloadByCount) {
                    if (unloadHandle == null) {
                        unloadHandle = ctxt.getRuntimeContext().push(this);
                    } else if (lastUsageTime < ctxt.getRuntimeContext().getLastJspQueueUpdate()) {
                        // 核心代码, 移除队列中的 JSP 缓存
                        ctxt.getRuntimeContext().makeYoungest(unloadHandle);
                        lastUsageTime = System.currentTimeMillis();
                    }
                } else {
                    if (lastUsageTime < ctxt.getRuntimeContext().getLastJspQueueUpdate()) {
                        lastUsageTime = System.currentTimeMillis();
                    }
                }
            }
        }
        // =========================================
    }
}

JSP 生成的 Servlet 进行处理请求

终于到了我们熟悉的环节, 调用创建的Servlet的service方法, 处理请求.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// org.apache.jasper.servlet.JspServletWrapper
public class JspServletWrapper {
    private final boolean unloadAllowed; // web.xml 的 JspServlet 的 maxLoadedJsps  参数配置, 大于0则为true
    private final boolean unloadByIdle;  // web.xml 的 JspServlet 的 jspIdleTimeout 参数配置, 大于0则为true
    private final boolean unloadByCount; // 值为 unloadAllowed || unloadByIdle

    public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile)
            throws ServletException, IOException, FileNotFoundException {
        // =========================================
        // (4) 执行创建的 Servlet 的 service 方法
        // =========================================
        if (servlet instanceof SingleThreadModel) {
            // sync on the wrapper so that the freshness
            // of the page is determined right before servicing
            synchronized (this) {
                servlet.service(request, response);
            }
        } else {
            servlet.service(request, response);
        }
        // =========================================
    }
}

一个简单的Hello world

1
2
3
4
5
6
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <body>
        Hello world
    </body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package org.apache.jsp.WEB_002dINF.views.upload;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class IE10_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    final java.lang.String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
      return;
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
            null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      // =========================== 输出代码 =====================================
      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("<body>\r\n");
      out.write("Hello world\r\n");
      out.write("</body>\r\n");
      out.write("</html>\r\n");
      // =========================== 输出代码 =====================================
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

参考资料