从JSP开始谈模板引擎

最新推荐文章于 2024-04-11 00:11:37 发布
最新推荐文章于 2024-04-11 00:11:37 发布
阅读量2k 收藏 8
点赞数 3
分类专栏： Java学习 文章标签： servlet tomcat web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj1561435010/article/details/104362703
版权

JSP即Java Server Page，本质是Servlet。要讲JSP还是要先说Servlet，要说Servlet则离不开Tomcat，要谈Tomcat还是要从HTTP协议说起。

一、HTTP协议

1、简述与特点

       HTTP协议是基于TCP/IP的应用层协议。

       HTTP协议是无状态协议，协议本身并不保留之前一切的请求或响应报文的信息，为了保存一些信息，引入了Cookie。

       HTTP协议是无连接协议。无连接又分为两种，HTTP/1.0和HTTP/1.1。1.0的时候，每一次请求都会建立一个连接，传完就关闭，下次重新开启个新的连接。现在的HTTP/1.1版本不是直接就断开了，而是等几秒钟，如果用户在这几秒钟之内有新的请求，那么还是通过之前的连接通道来收发消息，如果过了这几秒钟用户没有发送新的请求，那么就会断开连接。其实一般的web网站都是短连接，实时视频这种肯定是长连接了。

2、流程梳理

       用户在浏览器上输入URL，进而DNS域名解析器会工作，将域名解析成对应的IP地址，客户端与Web服务器建立TCP的套接字连接(三次握手)。服务端接收并建立连接后，客户端生成HTTP格式的数据包作为请求报文发给服务端，请求报文包含请求的方法、URL、协议版本、请求头部和请求数据等，服务端解析HTTP格式的数据包。之后在Servlet容器中找到对应的Servlet并执行业务方法，执行完后生成为HTTP格式的数据传回给客户端浏览器，浏览器再去解析HTTP格式的数据，之后浏览器再去渲染页面呈现给用户。
Alt

3、HTTP状态码

       状态代码的第一个数字代表当前响应的类型：
              1xx消息——请求已被服务器接收，继续处理
              2xx成功——请求已成功被服务器接收、理解、并接受
              3xx重定向——需要后续操作才能完成这一请求
              4xx客户端请求错误——客户端请求错误或者无法被执行
              5xx服务器错误——服务器在处理某个正确请求时发生错误



二、Tomcat详解

1、流程梳理

       HTTP请求进来不是直接调业务方法，而是先从Servlet容器中找是否有请求所对应的Servlet，没找到就反射new一个出来加到容器中，然后再调用此Servlet的业务方法。和Spring容器一样，这样搞最大的好处就是解耦！
Alt

tomcat的主启动类是BootStrap的main方法。


2、整体结构

       连接器即Coyoto封装了最底层的网络通信(Socket)，还负责网络字节流传输，并将Request对象转化为ServletRequest对象后发给容器即Catalina。

Alt
Alt

       Engine：一个service最多只有一个引擎
       Host：对应于一个主机
       Context：对应一个应用
       Wrapper：对应一个Servlet
Alt

       看了上图再看tomcat的配置文件server.xml就豁然开朗了。

	<Server port="8005" shutdown="SHUTDOWN">
		<Service name="Catalina">
			<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
               
            <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
               maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
               keystoreFile="E:\apache-tomcat_key\tomcat.keystore" keystorePass="123456"
               clientAuth="false" sslProtocol="TLS" />
               
            <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
            
				<Engine name="Catalina" defaultHost="localhost">
					<Host name="localhost"  appBase="webapps"
           				unpackWARs="true" autoDeploy="true">
            		</Host>
    			</Engine>
  		</Service>
	</Server>

       另外上面的容器结构图中Host下面还可以配置Context。看到tomcat的conf文件夹下面还有context.xml配置文件。
Alt

<Context>

    <!-- Default set of monitored resources. If one of these changes, the    -->
    <!-- web application will be reloaded.                                   -->
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>

    <!-- Uncomment this to disable session persistence across Tomcat restarts -->
    <!--
    <Manager pathname="" />
    -->
</Context>

       其实可以看出所有发布的应用都会归当前应用下的WEB-INF/web.xml和E:\apache-tomcat-8.5.41\conf\web.xml管理？

       通常一个Catalina容器可以有多个服务，可以在Host标签中的appBase属性中设置发布路径。

       IDEA这种IDE上配置的端口其实只是暂时让我能通过这个IP地址+端口号访问我们的应用，最后打成的war包还是要放到linux服务器上面的，最后还是要靠最终服务器上的配置文件来进行管理。war包放到webapps下面会自动解压缩，而且一旦删除war包连带的文件夹也会被删除掉。



三、JSP

1、原理分析

       jsp本质就是Servlet。

       tomcat下的web.xml中配置了映射关系，只要是.jsp以及.jspx结尾的URL都会交给JspServlet处理该请求。

	<servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>

	<servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- The mappings for the JSP servlet -->
    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
        <url-pattern>*.jspx</url-pattern>
    </servlet-mapping>


2、看下源码咯

       JspServlet的service方法：

	public void service (HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // jspFile may be configured as an init-param for this servlet instance
        String jspUri = jspFile;

        if (jspUri == null) {
            /*
             * Check to see if the requested JSP has been the target of a
             * RequestDispatcher.include()
             */
            jspUri = (String) request.getAttribute(
                    RequestDispatcher.INCLUDE_SERVLET_PATH);
            if (jspUri != null) {
                /*
                 * Requested JSP has been target of
                 * RequestDispatcher.include(). Its path is assembled from the
                 * relevant javax.servlet.include.* request attributes
                 */
                String pathInfo = (String) request.getAttribute(
                        RequestDispatcher.INCLUDE_PATH_INFO);
                if (pathInfo != null) {
                    jspUri += pathInfo;
                }
            } else {
                /*
                 * Requested JSP has not been the target of a
                 * RequestDispatcher.include(). Reconstruct its path from the
                 * request's getServletPath() and getPathInfo()
                 */
                jspUri = request.getServletPath();
                String pathInfo = request.getPathInfo();
                if (pathInfo != null) {
                    jspUri += pathInfo;
                }
            }
        }

        if (log.isDebugEnabled()) {
            log.debug("JspEngine --> " + jspUri);
            log.debug("\t     ServletPath: " + request.getServletPath());
            log.debug("\t        PathInfo: " + request.getPathInfo());
            log.debug("\t        RealPath: " + context.getRealPath(jspUri));
            log.debug("\t      RequestURI: " + request.getRequestURI());
            log.debug("\t     QueryString: " + request.getQueryString());
        }

        try {
            boolean precompile = preCompile(request);	//只是预编译
            //主要是这个方法
            serviceJspFile(request, response, jspUri, precompile);
        } catch (RuntimeException e) {
            throw e;
        } catch (ServletException e) {
            throw e;
        } catch (IOException e) {
            throw e;
        } catch (Throwable e) {
            ExceptionUtils.handleThrowable(e);
            throw new ServletException(e);
        }
    }

       JspServlet的serviceJspFile方法：

	private void serviceJspFile(HttpServletRequest request,
                                HttpServletResponse response, String jspUri,
                                boolean precompile)
        throws ServletException, IOException {

        JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
        if (wrapper == null) {
            synchronized(this) {
                wrapper = rctxt.getWrapper(jspUri);
                if (wrapper == null) {
                    // Check if the requested JSP page exists, to avoid
                    // creating unnecessary directories and files.
                    if (null == context.getResource(jspUri)) {
                        handleMissingResource(request, response, jspUri);
                        return;
                    }
                    wrapper = new JspServletWrapper(config, options, jspUri,
                                                    rctxt);
                    rctxt.addWrapper(jspUri,wrapper);
                }
            }
        }

        try {
        	//主要是这个方法
            wrapper.service(request, response, precompile);
        } catch (FileNotFoundException fnfe) {
            handleMissingResource(request, response, jspUri);
        }

    }

       JspServletWrapper的service方法：

	public void service(HttpServletRequest request,
                        HttpServletResponse response,
                        boolean precompile)
            throws ServletException, IOException, FileNotFoundException {

        Servlet servlet;
        ...
        try {
			if (options.getDevelopment() || mustCompile) {
                synchronized (this) {
                    if (options.getDevelopment() || mustCompile) {
                        // The following sets reload to true, if necessary
                        ctxt.compile();		//生成对应的java文件和字节码文件
                        mustCompile = false;
                    }
                }
            } else {
                if (compileException != null) {
                    // Throw cached compilation exception
                    throw compileException;
                }
            }

            /*
             * (2) (Re)load servlet class file
             */
            servlet = getServlet();		//重新加载路径下编译好的字节码文件
            ...
            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);	//最终用PrintOut对象输出到浏览器
                }
            } else {
                servlet.service(request, response);
            }
		} catch(Eeception e) {
			...
		}

       虽然很绕，但问题不是很大，快要绕出来了！

       JspCompilationContext的compile方法：

	public void compile() throws JasperException, FileNotFoundException {
        createCompiler();
        if (jspCompiler.isOutDated()) {
            if (isRemoved()) {
                throw new FileNotFoundException(jspUri);
            }
            try {
                jspCompiler.removeGeneratedFiles();
                jspLoader = null;
                jspCompiler.compile();
                jsw.setReload(true);
                jsw.setCompilationException(null);
            } catch (JasperException ex) {
                // Cache compilation exception
                jsw.setCompilationException(ex);
                if (options.getDevelopment() && options.getRecompileOnFail()) {
                    // Force a recompilation attempt on next access
                    jsw.setLastModificationTest(-1);
                }
                throw ex;
            } catch (FileNotFoundException fnfe) {
                // Re-throw to let caller handle this - will result in a 404
                throw fnfe;
            } catch (Exception ex) {
                JasperException je = new JasperException(
                        Localizer.getMessage("jsp.error.unable.compile"),
                        ex);
                // Cache compilation exception
                jsw.setCompilationException(je);
                throw je;
            }
        }
    }

       Compiler的compile方法：

	public void compile(boolean compileClass, boolean jspcMode)
            throws FileNotFoundException, JasperException, Exception {
        if (errDispatcher == null) {
            this.errDispatcher = new ErrorDispatcher(jspcMode);
        }

        try {
            final Long jspLastModified = ctxt.getLastModified(ctxt.getJspFile());
            //生成java文件
            String[] smap = generateJava();		
            File javaFile = new File(ctxt.getServletJavaFileName());
            if (!javaFile.setLastModified(jspLastModified.longValue())) {
                throw new JasperException(Localizer.getMessage("jsp.error.setLastModified", javaFile));
            }
            if (compileClass) {
            	//生成字节码文件
                generateClass(smap);
                // Fix for bugzilla 41606
                // Set JspServletWrapper.servletClassLastModifiedTime after successful compile
                File targetFile = new File(ctxt.getClassFileName());
                if (targetFile.exists()) {
                    if (!targetFile.setLastModified(jspLastModified.longValue())) {
                        throw new JasperException(
                                Localizer.getMessage("jsp.error.setLastModified", targetFile));
                    }
                    if (jsw != null) {
                        jsw.setServletClassLastModifiedTime(
                                jspLastModified.longValue());
                    }
                }
            }
        } finally {
            if (tfp != null && ctxt.isPrototypeMode()) {
                tfp.removeProtoTypeFiles(null);
            }
            // Make sure these object which are only used during the
            // generation and compilation of the JSP page get
            // dereferenced so that they can be GC'd and reduce the
            // memory footprint.
            tfp = null;
            errDispatcher = null;
            pageInfo = null;

            // Only get rid of the pageNodes if in production.
            // In development mode, they are used for detailed
            // error messages.
            // http://bz.apache.org/bugzilla/show_bug.cgi?id=37062
            if (!this.options.getDevelopment()) {
                pageNodes = null;
            }

            if (ctxt.getWriter() != null) {
                ctxt.getWriter().close();
                ctxt.setWriter(null);
            }
        }
    }

       找到IDEA对于对应路径下面的文件打开查看。果然是PrintOut对象调用write()方法直接写到浏览器上。
Alt
       index_jsp的__jspService方法：

	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");
	      //看源码终于明白了为啥SpringMVC的Rest风格会在tomcat7以上报错, 需要在头部加上isErrorPage="true"
	      return;
	    }
		...
		out.write("\n");
	    out.write("\n");
	    out.write("<html>\n");
	    out.write("  <head>\n");
	    out.write("    <title>$Title$</title>\n");
	    out.write("  </head>\n");
	    out.write("  <body>\n");
	    out.write("  $END$\n");
	    out.write("  </body>\n");
	    out.write("</html>\n");
	    ...
	    //说到底最后就是PrintOut对象输出



3、JSP的九大内置对象
内置对象作用
request传递数据, 作用域为一次请求
response传递数据, 作用域仅在JSP页面
session服务器为每个用户都生成一个对象(默认过期时间为30分钟)
application服务器为每个应用都生成一个对象
out用于在Web浏览器内输出信息
pageContext初始化由容器完成, JSP页面可直接用该对象。通过它可以获取 JSP页面的out、request、reponse、session、application 等对象
config取得服务器的配置信息, 通过pageConext.getServletConfig()可以获取该对象
pagepage 对象代表JSP本身, 类似于this指针
exception用于显示异常信息, 包含 isErrorPage=“true” 的页面中才可以被使用



四、Thymeleaf模板引擎

1、简介

       就是jsp的升级版，是一个模板引擎(java语言编写)，可以处理html、xml、js、css等等，特别是html5。既可以展示静态数据也可以用后端传的数据直接展示，也可以实现前后端分离。不过也有缺点，Thymeleaf都是后端渲染的数据，渲染整个html文档，服务器压力大，Vue的只需要ajax请求数据，后端只需要渲染json数据就好了，服务器压力小很多。

       这种模板引擎底层绝对逃不开Servlet。

       需要引入名称空间：<html lang="en" xmlns:th="http://www.thymeleaf.org">。



2、源码(只看前后缀)
	public class ThymeleafProperties {
	    private static final Charset DEFAULT_ENCODING;
	    public static final String DEFAULT_PREFIX = "classpath:/templates/";	//前缀
	    public static final String DEFAULT_SUFFIX = ".html";	//后缀
	    private boolean checkTemplate = true;
	    private boolean checkTemplateLocation = true;
	    private String prefix = "classpath:/templates/";	//前缀
	    private String suffix = ".html";	//后缀
	    private String mode = "HTML";
	    private Charset encoding;
	    private boolean cache;
	    private Integer templateResolverOrder;
	    private String[] viewNames;
	    private String[] excludedViewNames;
	    private boolean enableSpringElCompiler;
	    private boolean renderHiddenMarkersBeforeCheckboxes;
	    private boolean enabled;
	    private final ThymeleafProperties.Servlet servlet;
	    private final ThymeleafProperties.Reactive reactive;
	    ...
}



3、基本语法及内置对象

       基本语法：

语法描述作用
${...}变量表达式取出上下文变量的值
*{...}选择变量表达式取出选择对象的属性值
#{...}消息表达式取出国际化消息
@{...}链接表达式表示超链接地址
       内置的对象：
对象描述
#ctx上下文对象
#var上下文变量
#locale上下文地理区域对象
#requestHttpServletRequest对象
#responseHttpServletResponse 对象
#sessionHttpSession 对象
#servletContextServletContext 对象


3、简单demo

       html界面：

	<!DOCTYPE html>
	<html lang="en" xmlns:th="http://www.thymeleaf.org">
	<head>
	    <meta charset="UTF-8">
	    <title>Hello</title>
	</head>
	<body>
	    <div th:text="${msg}"></div>
	    <div>[(${msg})]</div>
	    <hr>
	
	    <h2 th:each="user:${users}">[(${user})]</h2>
	    <hr>
	
	    <h2>
	        <span th:each="user:${users}">[[${user}]]</span>
	    </h2>
	    <hr>
	
	    <div th:object="${person}">
	        <h2 th:text="*{name}"></h2>
	        <h2>[[*{age}]]</h2>
	    </div>
	    <hr>
	
	    <div th:text="${#request.getAttribute('msg')}"></div>
	</body>
	</html>

       controller：

	@RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("msg", "<h2>哈哈哈</h2>");
        List<String> users = new CopyOnWriteArrayList<String>();
        users.add("张三");
        users.add("李四");
        users.add("王五");
        model.addAttribute("users", users);
        Person p = new Person();
        p.setAge(18);
        p.setName("xxx");
        model.addAttribute("person", p);
        return "hello";
    }

运行结果：
Alt
       都是用th作为前缀，text表示对特殊字符转译并写入文本(转译后可以原样输出)，utext是不对特殊字符进行转译并写入文本。

       属性上的th:text等价于行内写法[[${...}]]。属性上的th:utext等价于行内写法[(${...})]。

SpringBoot可以集成Thymeleaf、Freemaker等等，但不支持JSP。

cj1561435010
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
模板引擎一 JSP
路穆里奇
06-25 531
一、了解模板引擎 数据+模板文件-->模板引擎-->HTML文档 模板引擎分类： 置换型模板引擎：就是将规定好的文本标记替换为目标内容。置换型模板引擎的思想是整个模板引擎界的基础。 解释型模板引擎：原理还是标记替换。只不过有了解释器的存在，可以支持更加复杂的标记和语法。 编译型模板引擎：通过解析引擎和一系列的算法将我们定义的模板转换为页面文件，然后直接访问页面文件即可。（常用） 常见模板引擎：jsp、freemarker、thymeleaf、velo...
模板引擎总结(Thymeleaf，FreeMarker，Enjoy，Velocity，JSP等)，性能对比
JBIB ENGINE
12-03 2855
比如一些网站的公用设置信息，这些信息基本都是可以通过后台来管理并存储在数据库中，这些信息其实会大量的被前台程序调用，每一次调用都会去查询一次数据库，但是这些信息的更新频率又会很小，因此也可以考虑将这部分内容进行后台更新的时候进行静态化，这样就避免了大量的数据库访问请求，提高了网站的性能。：使用了模板缓冲，在模板缓冲机制的作用下，模板不再是每次出现请求的时候从磁盘读取，而是以最理想的方式在内存中保存和解析。在开发期间，模板缓冲通常处于禁用状态，因为这时请求数量较少，而且要求对页面的修改立即产生效果。
SpringBoot系列：Spring Boot使用模板引擎JSP，2024年最新阿里的面试问题
最新发布
2401_84138968的博客
04-11 869
虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。一个人可以走的很快，但一群人才能走的更远。
java三种模板引擎的区别(jsp、freemarker、velocity)
xiziwen_code
07-23 1794
在java领域，表现层技术主要有三种：jsp、freemarker、velocity。 jsp是大家最熟悉的技术 优点： 1、功能强大，可以写java代码 2、支持jsp标签（jsp tag） 3、支持表达式语言（el） 4、官方标准，用户群广，丰富的第三方jsp标签库 5、性能良好。jsp编译成class文件执行，有很好的性能表现 缺点： jsp没有明显缺点，非要挑点骨头那就是，由于可以编写ja...
页面静态化（模板引擎Freemarker）
weixin_44973527的博客
08-12 603
1、浏览器请求web服务器2、服务器渲染页面，渲染的过程就是向jsp页面(模板)内填充数据(模型)。3、服务器将渲染生成的页面返回给浏览器。所以模板引擎就是：模板+数据=输出，Jsp页面就是模板，页面中嵌入的jsp标签就是数据，两者相结合输出html网页。
模板引擎的一些介绍
weixin_42588032的博客
07-10 404
Thymeleaf的一点介绍
浅谈Java模板引擎性能对比
08-29
本文将对JSP、Thymeleaf 3、Velocity 1.7、Freemarker 2.3.23等四种主流Java模板引擎的性能进行对比，以帮助开发者选择合适的模板引擎。 JSP模板引擎 JSP（JavaServer Pages）是Java Servlet技术的扩展，用于生成...
Spring Boot使用模板引擎JSP实例解析
10-16
主要介绍了Spring Boot使用模板引擎JSP实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Beetl模板引擎-其他
06-12
关于性能：通过与主流模板引擎Freemarker，Velocity以及JSP对比，Beetl均远高于前面三个，这是因为宏观上，通过了优化的渲染引擎，IO的二进制输出，字节码属性访问增强，微观上，通过一维数组保存上下文，合并静态...
springboot整合jsp使用jsp模板引擎（IDEA2022.2）
12-29
在Spring Boot项目中整合JSP模板引擎，可以让开发者在Web应用开发中利用JSP的便捷性。Spring Boot本身推荐使用视图技术如Thymeleaf、Freemarker或Groovy Templates，但通过一定的配置，我们同样可以使用传统的JSP。...
JSP网页模板JSP网页模板JSP网页模板
09-18
JSP网页模板则是预先设计好的页面布局，开发者可以基于这些模板快速构建网站前端页面，节省时间和提高效率。 在JSP网页模板中，通常包括以下几个核心组成部分： 1. **HTML结构**：这是模板的基础，定义了页面的...
jsp与模板引擎性能
xuesong123的专栏
01-12 6300
在讨论模板引擎的性能之前必须先明确几个问题： 1. 在同等优化条件下，java原生代码最快。 2. jsp在只采用java脚本编写的情况下，可以认为与java原生代码的性能相当，仍然是在同等优化条件下。 3. 编译性能可以不考虑，因为都是编译一次，多次运行，对运行期没有影响。 有些模板引擎的性能优于jsp，这个只是由于对比的jsp容器做的优化较少，而模板引擎做了大量优化。 例如t
常见的模板引擎(JSP，Velocity，FreeMarker，Thymeleaf)
lklalmq的博客
07-17 1624
模板引擎模板引擎是为了解决用户界面（显示）与业务数据（内容）分离而产生的。他可以生成特定格式的文档，常用的如格式如HTML、xml以及其他格式的文本格式。
Tomcat源码阅读之Jasper(JSP解释器)详解
five-five
05-30 731
Jasper JSP解释器 详解 JSP编译方式运行时编译编译过程JspServlet 处理流程图：编译结果预编译(Apache Ant)JSP编译原理代码分析 本文构建好的Tomcat(含注释)gitee地址：点击 主要核心一定要是自己去debug源码 对于基于JSP 的web应用来说，我们可以直接在JSP页面中编写 Java代码，添加第三方的标签库，以及使用EL表达式。但是无论经过何种形式的处理，最终输出到客户端的都是标准的HTML页面（包含js ，css…），并不包含任何的java相关的语法。 也
springboot使用jsp模板引擎
m0_45209551的博客
05-11 189
导入依赖 <!-- 引入jsp依赖--> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency> 编写接口 配置视图解析器 ..
SpringBoot系列之集成jsp模板引擎
Nicky's blog
12-08 4646
SpringBoot系列之集成jsp模板引擎 文章目录1、模板引擎简介2、环境准备3、外部Servlet容器4、源码原理简介 1、模板引擎简介 引用百度百科的模板引擎解释： 模板引擎（这里特指用于Web开发的模板引擎）是为了使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，用于网站的模板引擎就会生成一个标准的HTML文档。 在JavaEE领域有几中比较常用的模板引擎，分别是J...
SpringBoot-web开发(三): 模板引擎Thymeleaf
欢迎来到 Baret~H 的博客
09-23 7777
目录1. 引入2. 什么是模板引擎？3. Thymeleaf1. 简介2. 导入Thymeleaf3. 使用Thymeleaf4. 简单测试5. thymeleaf语法1、th属性2、标准表达式语法 本文主要介绍SpringBoot给我们推荐的Thymeleaf模板引擎，这是一个高级语言的模板引擎，语法更简单且功能更强大 参考：https://www.jianshu.com/p/7c27c50f24ec 1. 引入 在以前，我们通常将前端交给我们的html页面转成jsp页面，通过jsp轻松实现数据.
JSP等模板引擎已死，大前端为趋势
weixin_30675967的博客
04-22 244
　　我们先来看一下tomcat版本数据： 　　我们可以看到，从tomcat8之后JSP就再没有新的支持了，tomcat8大概是2013年发布的，也就是说，从2013年开始jsp技术已经实质上不被官方继续维护了。 　　再从java框架springboot来看，默认就是不支持jsp的，后台模板引擎默认是themleaf，但这并不能代表themleaf是未来趋势，因为前端技术在后端技术...
不用jsp用什么模板引擎好
07-17
对于替代 JSP 的模板引擎，有很多选择。以下是几个流行的选择： 1. Thymeleaf：Thymeleaf 是一个现代化的服务器端 Java 模板引擎，可以与 Spring 框架无缝集成。它具有强大的功能，包括模板布局、条件判断、循环等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值