浅谈JSP是如何编译成servlet并提供服务的

目录
  • 概述
  • 源码分析

概述

服务端对外提供JSP请求服务的是JspServlet,继承自HttpServlet。核心服务入口在service方法,大体流程如下:

  • 首先获取请求的jspUri,如果客户端发起请求:https://xxx.xx.com/jsp/test.jsp,那么获取到的jspUri为:/jsp/test.jsp
  • 然后查看缓存(Map结构)中是否包含该jspUri的JspServletWrapper,如果没有就需要创建一个JspServletWrapper并且缓存起来,并调用JspServletWrapper的service方法
  • 如果为development模式,或者首次请求,那么就需要执行JspCompilationContext.compile() 方法
  • 在JspCompilationContext.compile方法中,会根据jsp文件的lastModified判断文件是否已经被更新(out dated),如果被更新过了,就需要删除之前生成的相关文件,然后将jspLoader置空(后面需要加载的时候如果jspLoader为空,就会创建一个新的jspLoader),调用Compiler.compile方法生成servlet,设置reload为true(默认为true),后面会根据reload参数判断是否需要重新加载该servlet
  • 调用JspServletWrapper.getServlet方法获取最终提供服务的servlet,这个过程会根据reload参数看是否需要重载servlet,如果需要重载,那么就会获取jspLoader实例化一个新的servlet(如果前面发现jsp文件过期,那么此时获取的jspLoader为空,则会创建一个新的jspLoader),并且设置reload为false
  • 调用servlet的service方法提供服务,如果servlet实现了SingleThreadModel接口,那么会用synchronized做同步控制

源码分析

首先看JspServlet的核心逻辑,主要是获取jspUri和获取JspServletWrapper,分别是入口service方法和serviceJspFile方法,代码如下(部分):

/**
 * 获取jspUri,然后调用serviceJspFile方法
 */
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String jspUri = this.jspFile;
        String pathInfo;
        if (jspUri == null) {
            pathInfo = (String)request.getAttribute(Constants.JSP_FILE);
            if (pathInfo != null) {
                jspUri = pathInfo;
                request.removeAttribute(Constants.JSP_FILE);
            }
        }

        if (jspUri == null) {
            jspUri = (String)request.getAttribute("javax.servlet.include.servlet_path");
            if (jspUri != null) {
                pathInfo = (String)request.getAttribute("javax.servlet.include.path_info");
                if (pathInfo != null) {
                    jspUri = jspUri + pathInfo;
                }
            } else {
                jspUri = request.getServletPath();
                pathInfo = request.getPathInfo();
                if (pathInfo != null) {
                    jspUri = jspUri + pathInfo;
                }
            }
        }

        boolean precompile = this.preCompile(request);
        this.serviceJspFile(request, response, jspUri, precompile);
    }

/**
 * 主要获取JspServletWrapper,然后调用JspServletWrapper.service方法
 */
private void serviceJspFile(HttpServletRequest request, HttpServletResponse response, String jspUri, boolean precompile) throws ServletException, IOException {
        JspServletWrapper wrapper = this.rctxt.getWrapper(jspUri);
        if (wrapper == null) {
            synchronized(this) {
                wrapper = this.rctxt.getWrapper(jspUri);
                if (wrapper == null) {
                    if (null == this.context.getResource(jspUri)) {
                        this.handleMissingResource(request, response, jspUri);
                        return;
                    }

                    wrapper = new JspServletWrapper(this.config, this.options, jspUri, this.rctxt);
                    this.rctxt.addWrapper(jspUri, wrapper);
                }
            }
        }

        try {
            //核心服务方法
            wrapper.service(request, response, precompile);
        } catch (FileNotFoundException var8) {
            this.handleMissingResource(request, response, jspUri);
        }

    }

然后进入JspServletWrapper.service方法(部分代码):

//注意这个reload是volatile修饰的
private volatile boolean reload = true;

public void service(HttpServletRequest request, HttpServletResponse response, boolean precompile) throws ServletException, IOException, FileNotFoundException {
        Servlet servlet;
        try {
            if (this.ctxt.isRemoved()) {
                throw new FileNotFoundException(this.jspUri);
            }
            //判断development模式和firstTime(首次请求)
            if (!this.options.getDevelopment() && !this.firstTime) {
                if (this.compileException != null) {
                    throw this.compileException;
                }
            } else {
                synchronized (this) {
                    this.firstTime = false;
                    //调用JspCompilationContext.compile方法
                    this.ctxt.compile();
                }
            }
            //获取最终提供服务的servlet
            servlet = this.getServlet();
            if (precompile) {
                return;
            }
        }
        try {
            //根据是否实现SingleThreadModel决定是否需要做同步控制
            if (servlet instanceof SingleThreadModel) {
                synchronized (this) {
                    servlet.service(request, response);
                }
            } else {
                servlet.service(request, response);
            }
        }
    }

这里主要看JspCompilationContext.complie方法:

public void compile() throws JasperException, FileNotFoundException {
        this.createCompiler();
        if (this.jspCompiler.isOutDated()) {
            if (this.isRemoved()) {
                throw new FileNotFoundException(this.jspUri);
            }
            try {
                //清楚文件数据
                this.jspCompiler.removeGeneratedFiles();
                //置空jspLoader,现在置null,后面就会创建一个新的JspLoader
                this.jspLoader = null;
                //根据jsp生成servlet的逻辑,实现主要有AntCompiler和JDTCompiler,默认JDTCompiler
                this.jspCompiler.compile();
                //设置reload为true,后面根据reload参数判断是否需要重新加载
                this.jsw.setReload(true);
                this.jsw.setCompilationException((JasperException) null);
            }
        }
    }

要注意对于isOutDated方法的判断,并不是简单地每次请求都检查jsp文件是否更新,而是有一个间隔时间,如果此次检查更新的时间在上一次检查更新+间隔时间之内,也就是没有超过间隔时间,那么就不会去检查jsp文件的更新。这就是我们说的jsp热更新延时生效,isOutDated是Compiler的方法,如下(部分代码):

    public boolean isOutDated(boolean checkClass) {
        if (this.jsw != null && this.ctxt.getOptions().getModificationTestInterval() > 0) {
            //getModificationTestInterval就是检查最短间隔时间,单位为秒
            if (this.jsw.getLastModificationTest() + (long)(this.ctxt.getOptions().getModificationTestInterval() * 1000) > System.currentTimeMillis()) {
                return false;
            }

            this.jsw.setLastModificationTest(System.currentTimeMillis());
        }

        Long jspRealLastModified = this.ctxt.getLastModified(this.ctxt.getJspFile());
        if (jspRealLastModified < 0L) {
            return true;
        } else {
            long targetLastModified = 0L;
            File targetFile;
            if (checkClass) {
                targetFile = new File(this.ctxt.getClassFileName());
            } else {
                targetFile = new File(this.ctxt.getServletJavaFileName());
            }

            if (!targetFile.exists()) {
                return true;
            } else {
                targetLastModified = targetFile.lastModified();
                if (checkClass && this.jsw != null) {
                    this.jsw.setServletClassLastModifiedTime(targetLastModified);
                }

                if (targetLastModified != jspRealLastModified) {
                    if (this.log.isDebugEnabled()) {
                        this.log.debug("Compiler: outdated: " + targetFile + " " + targetLastModified);
                    }

                    return true;
                } else if (this.jsw == null) {
                    return false;
                }
            }
        }

另外,这里还涉及到JSP的编译工作,编译工作主要由org.apache.jasper.compiler.Compiler编译器负责,Compiler是一个抽象类,apache-jsp中提供了两种实现:AntCompilerJDTCompiler,默认使用的编译器为JDTCompiler。

最后回到JspServletWrapper.getServlet方法:

private volatile boolean reload = true;
public Servlet getServlet() throws ServletException {
        //reload是被volatile修饰的一个boolean变量
        //这里进行双重检测
        if (this.reload) {
            synchronized (this) {
                if (this.reload) {
                    //需要重载
                    this.destroy();
                    Servlet servlet;
                    try {
                        InstanceManager instanceManager = InstanceManagerFactory.getInstanceManager(this.config);
                        //创建一个新的serlvet实例对象,注意这里的getJspLoader方法
                        servlet = (Servlet) instanceManager.newInstance(this.ctxt.getFQCN(), this.ctxt.getJspLoader());
                    } catch (Exception var6) {
                        Throwable t = ExceptionUtils.unwrapInvocationTargetException(var6);
                        ExceptionUtils.handleThrowable(t);
                        throw new JasperException(t);
                    }

                    servlet.init(this.config);
                    if (!this.firstTime) {
                        this.ctxt.getRuntimeContext().incrementJspReloadCount();
                    }
                    this.theServlet = servlet;
                    this.reload = false;
                }
            }
        }
        return this.theServlet;
    }

可以看到,方法中使用了双重检测机制判断是否需要重载,reload参数由volatile修饰保证可见性。在创建新的servlet实例的时候,classLoader是通过JspCompilationContext.getJspLoader方法获取的,看看这个方法的逻辑:

public ClassLoader getJspLoader() {
        if (this.jspLoader == null) {
            this.jspLoader = new JasperLoader(new URL[]{this.baseUrl}, this.getClassLoader(), this.rctxt.getPermissionCollection());
        }

        return this.jspLoader;
    }

在前面JspCompilationContext.complie的逻辑中,如果检测到jsp文件被更新过(过期),那么jspLoader会被设置为null,此时就会创建一个新的jspLoader(JasperLoader),然后使用新的loader加载新的servlet,以完成jsp的热更新,老的classloader在之后会被GC直接回收。

到此这篇关于浅谈JSP是如何编译成servlet并提供服务的的文章就介绍到这了,更多相关JSP编译成servlet内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 快速建立Servlet和JSP的运行、调试和编译环境

    相信很多刚开始学习Servlet和JSP的朋友都有一个困扰,就是如何快速方便的建立一个Servlet和JSP的运行.调试和编译环境.本人现在正在国外攻读MIT(Master of Information Technology),现在选修的这一科是WBIS(Web Based Information Systems),其包含了许多种技术,如Java,Perl,CGI,Servlet,ASP,Java Script,JSP,OO,UML等等.下面的这篇文章是学校所提供的相关软件的下载地址.安装方法以

  • 浅谈JSP是如何编译成servlet并提供服务的

    目录 概述 源码分析 概述 服务端对外提供JSP请求服务的是JspServlet,继承自HttpServlet.核心服务入口在service方法,大体流程如下: 首先获取请求的jspUri,如果客户端发起请求:https://xxx.xx.com/jsp/test.jsp,那么获取到的jspUri为:/jsp/test.jsp 然后查看缓存(Map结构)中是否包含该jspUri的JspServletWrapper,如果没有就需要创建一个JspServletWrapper并且缓存起来,并调用Jsp

  • 浅谈JSP与Servlet传值及对比(总结)

    JSP是Servlet技术的扩展,本质上是Servlet的简易方式,更强调应用的外表表达. JSP编译后是"类servlet". Servlet和JSP最主要的不同点在于,Servlet的应用逻辑是在Java文件中,并且完全从表示层中的HTML里分离开来. 而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件.JSP侧重于视图,Servlet主要用于控制逻辑. 本篇从以下四个方面探讨下JSP与Servlet的传值问题: 一.JSP传值给Servlet JSP传值给Se

  • 浅谈jsp的C标签一般使用方法以及js接收servlet中的对象及对象数组

    由于现流行的javaWeb框架提倡前后端分离,比如在SpringMvc中已经很少写servlet的一些东西:目前 前端jsp中大多是一些纯html和js,很少用到jstl的一堆东西,后端也仅仅处理一些前端的post.get请求或页面跳转,无须以往繁琐的xml路径映射和filter过滤. 不过有时也会用到servlet作用域中的一些东西,比如某个固定的值.上下文路径等等~,不过这些东西大多数也仅限于取值而不是设置值(或对象),所以sun给了一个非常简洁的取值方式:C标签! 下面将简述下C标签的一些

  • 浅谈JSP serverlet的区别与联系

    jsp是html包含java servlet是java包含html jsp请求到tomcat---tomcat封装了jsp到servlet实现. 所以jsp请求时候,会自动创建session 而不用在servlet中request.getSession(true) servlet是服务器端的程序,动态生成html页面发到客户端,但是这样 程序里有许多out.println(),java和html语言混在一起很乱.所以 后来推出了jsp.其实jsp就是servlet,每一个jsp在第一次运行时被

  • 浅谈jsp中的9个隐含对象

    在JSP中一共有9个隐含对象,这个9个对象我可以在JSP中直接使用. 因为在service方法已经对这个九个隐含对象进行声明及赋值,所以可以在JSP中直接使用. - pageContext 类型:PageContext 代表:当前页面的上下文 作用:可以获取到页面中的其他隐含对象,同时它还是一个域对象. - request 类型:HttpServletRequest 代表:请求 作用:可以获取用户发送的请求信息,它也是一个域对象. - session 类型:HttpSession 代表:当前会话

  • 浅谈jsp九大内置对象及四个作用域

    request           请求对象             类型 javax.servlet.ServletRequest        作用域 Request response          响应对象              类型 javax.servlet.SrvletResponse        作用域 Page pageContext       页面上下文对象        类型 javax.servlet.jsp.PageContext       作用域 Page

  • 浅谈jsp文件和HTML互相引入的乱码问题

    1.在jsp中用include指令引入HTML文件时遇到的问题: jsp.html都可以正确的显示,当jsp引入html时访问jsp页面HTML出现乱码,jsp原有的输出无乱码,解决方法: 在HTML第一行加入:<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> jsp的编码格式为:<%@ page language="java&qu

  • 浅谈异常结构图、编译期异常和运行期异常的区别

    异常处理一般有2种方式,要么捕获异常try-catch,要么抛出异常throws 如果一个方法后面抛出一个运行时期异常(throws RuntimeException),调用者无须处理 如果一个方法后面抛出一个编译时期异常,调用者必须处理,或者抛出或者try-catch: 运行时期的异常一般都不处理,一般是程序逻辑上的错误,比如分母为0作为除数了... 注意如果在try里面出现了异常后,try下面的语句就不会执行,回去寻找catch匹配异常处理会,接下来的语句会处理的(也就是在try-catch

  • 浅谈jsp EL表达式取值过程、page和pagecontext的区别

    1.EL表达式解析过程 JSP中,我们经常会写为${obj.name}字样,但你有没有想过,它的取值过程是什么,属性值从哪取得? ${obj}相当于 request.getAttribute("obj"),这句话严格来说不严谨,依次的请求范围是page.request.session.application 也就是说,如果在page.getAttribute()找不到,再去request.getAttribute,如果request找不到,再去session里找,session里找不到

  • 浅谈VC中预编译的头文件放那里的问题分析

    用C++写程序,肯定要用预编译头文件,就是那个stdafx.h.不过我一直以为只要在.cpp文件中包含stdafx.h 就使用了预编译头文件,其实不对.在VC++中,预编译头文件是指放到stdafx.h中的头文件才会有效果.如下: file: stdafx.h 复制代码 代码如下: // stdafx.h : include file for standard system include files,// or project specific include files that are u

随机推荐