SpringBoot integra los pasos detallados de JSP, Thymeleaf y Freemarker

1. SpringBoot integra JSP

1. Introducir la dependencia jsp

SpringBoot no admite JSP de forma predeterminada, si lo usa, debe introducir las siguientes dependencias

     <!-- 添加servlet依赖模块 -->
     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
     </dependency>
     <!-- 添加jstl标签库依赖模块-->
     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>jstl</artifactId>
     </dependency>
     <!-- 使用jsp引擎，springboot内置tomcat没有此依赖加上即可 -->
     <dependency>
         <groupId>org.apache.tomcat.embed</groupId>
         <artifactId>tomcat-embed-jasper</artifactId>
     </dependency>

2. Agregar directorio de aplicaciones web

SpringBoot establece de forma predeterminada los recursos del sitio web en el directorio de la aplicación web . Si no es necesario crear este directorio manualmente, tenga en cuenta que el nivel del directorio está en java.

Al realizar la prueba, al hacer clic derecho en la aplicación web, se descubrió que no había ninguna opción para crear un JSP, como se muestra a continuación:

En este momento, puede presionar command+;para ingresar a la siguiente interfaz, como se muestra a continuación:

Después de la configuración, haga clic en el directorio de archivos de la aplicación web, haga clic derecho para ver que puede crear un archivo JSP y luego cree un directorio WEB-INF (directorio de seguridad) en el directorio de archivos de la aplicación web , como se muestra a continuación:

De lo anterior, puede encontrar que el estilo de la carpeta ha cambiado, lo que significa que se pueden crear archivos JSP.

3. Crea archivos JSP

Cree un nuevo archivo abc2.jsp en el directorio de la aplicación web y abc3.jsp en la carpeta WEB-INF . El código es el siguiente:

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<h1>name===>${name}我是 abc2.jsp 测试页面hello jsp dispatcher.forward(path) Spring 只是告诉<br>
    Tomcat 它一个 path 路径，Tomcat 需要自己去动态编译 jsp 存储到 work 目录</h1>

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<h1>name===>${name}我是 abc3.jsp 测试页面hello jsp dispatcher.forward(path) Spring 只是告诉<br>
    Tomcat 它一个 path 路径，Tomcat 需要自己去动态编译 jsp 存储到 work 目录</h1>

4. Acceda directamente a archivos JSP

El archivo ha sido creado, así que ahora veamos si se puede acceder directamente a él. Dirección de acceso:http://localhost:9292/abc2.jspEl efecto es el siguiente:

durante la visitahttp://localhost:9292/abc3.jspEl efecto es el siguiente:

La razón por la que no se puede acceder a abc3.jsp es porque existe una restricción en Tomcat de que los recursos bajo WEB-INF son recursos seguros y solo se puede acceder a ellos a través de Servlet o Controlador, por lo que se define un ToJspController para el acceso.

Cabe señalar aquí que si se configuran las configuraciones anteriores, la página de acceso seguirá siendo 404. Por ejemplo, si es un proyecto de varios módulos, puede realizar las siguientes configuraciones:

Si también desea mostrar y guardar el archivo de código fuente JSP compilado por Tomcat, puede configurarlo de la siguiente manera:

server:
  port: 9292
  tomcat:
    basedir: /Users/gongweiming/IdeaProjects/springcloud2022/cloud-redis-service9292

baseDir es el directorio de trabajo de Tomcat, es decir, los archivos de código fuente Java compilados y los archivos compilados de la página JSP se guardan en este directorio.

5. Acceda a la página JSP a través del Controlador

Generalmente, el acceso a la página JSP necesita transportar datos, por lo que es mejor definir un Controlador para acceder a la página, y no se puede acceder a los recursos en WEB-INF directamente y se debe acceder a través de un salto del Controlador. El código es el siguiente

@Controller
public class ToJspController {
    
    

    @RequestMapping("/toJsp")
    public ModelAndView toJsp(String cx) {
    
    
        ModelAndView view = new ModelAndView();
        System.out.println(">>>>>>toJsp...");
        System.out.println("hnhds");
        view.addObject("name", "gwm");
        view.setViewName(cx);
        return view;
    }
}

Luego acceda a abc2.jsp a través del Controlador, la ruta es:http://localhost:9292/toJsp?cx=abc2, el efecto es el siguiente:

Esto se debe a que no existe SpringBoot y el analizador predeterminado InternalResourceViewResolver no lee el prefijo y el sufijo de configuración.

Esta configuración solo necesita agregarse en el archivo application.yml y la configuración es la siguiente:

server:
  port: 9292

spring:
  mvc:
    view:
      suffix: .jsp
      prefix: /

Luego puede acceder a la página abc2.jsp. Si necesita acceder a abc3.jsp, debe modificar el archivo yml, como se muestra a continuación:

server:
  port: 9292

spring:
  mvc:
    view:
      suffix: .jsp
      prefix: /WEB-INF/

Luego accede a la direcciónhttp://localhost:9292/toJsp?cx=abc3, el efecto es el siguiente:

6. SpringBoot accede a recursos estáticos

SpringBoot almacena páginas estáticas en el directorio estático de forma predeterminada y páginas dinámicas en plantillas. Los recursos estáticos se muestran a continuación:

También puede modificar la ubicación a través de la ubicación yml. La página a.html a continuación no está en la carpeta estática, sino en la carpeta html. La configuración es la siguiente:

spring:
  mvc:
    view:
      suffix: .jsp
      prefix: /WEB-INF/
    # 访问静态资源时需要加上前缀 /boot 
    static-path-pattern: /boot/**
  resources:
  	# 访问的静态资源在以下文件夹仲可以找到
    static-locations: classpath:/META-INF/resources/,classpath:/resources/, classpath:/static/, classpath:/public/, classpath:/html/

/bota/**Indica que debe traer este prefijo /boot al acceder a recursos estáticos.

Por ejemplo, si accede a abc2.html en modo estático, el nombre de la ruta de acceso eshttp://localhost:9292/boot/abc2.html
Por ejemplo, si accede a text.txt en modo estático, el nombre de la ruta de acceso eshttp://localhost:9292/boot/text.txt
Por ejemplo, si accede a un.html debajo de html, el nombre de la ruta de acceso eshttp://localhost:9292/boot/a.html

/Representa la ruta de clase de classpath, que representa la ubicación de almacenamiento de la ruta compilada.classes es igual a la ruta raíz de classpath, por lo que para acceder a los recursos estáticos en html, puede configurar/html/Acceder a, no configurar/recursos/html/, la ruta compilada es como se muestra a continuación:

Entonces agrega la configuración.ruta de clase:/html/Puede acceder al recurso estático a.html en la carpeta html y la ruta de acceso eshttp://localhost:9292/boot/a.html

7. Habilite manualmente la anotación @EnableWebMvc (según sus necesidades)

Si desea habilitar la anotación @EnableWebMvc en el marco SpringBoot , significa que desea asumir completamente la función SpringMVC. SpringBoot no administrará SpringMVC. El código fuente es el siguiente:

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({
    
     Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({
    
     DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
    
    

}

Se puede ver al cargar SpringBoot la clase automática WebMvcAutoConfiguration que está restringida condicionalmente. Una de las condiciones es@ConditionalOnMissingBean(WebMvcConfigurationSupport.clase)Indica que la clase WebMvcConfigurationSupport no debe existir en el contenedor Spring para cargar esta clase de configuración.

Mirando hacia atrás, vi la anotación @EnableWebMvc activada manualmente . El código fuente es el siguiente:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
    
    
}

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    
    
}

Se descubre que la clase WebMvcConfigurationSupport se importa a través de la anotación @Import aquí . Esto hará que exista un bean de instancia WebMvcConfigurationSupport en el contenedor Spring, lo que hará que WebMvcAutoConfiguration no se ensamble automáticamente. Así que tenga cuidado al abrir esta anotación en SpringBoot.

@EnableWebMvcTenga en cuenta que algunos componentes spring-webmvctienen configuraciones predeterminadas en el módulo, como el solucionador de vistas InternalResourceViewResolver . El código fuente es el siguiente:

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    
    

	@Bean
	public ViewResolver mvcViewResolver(
			@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
    
    
		ViewResolverRegistry registry =
				new ViewResolverRegistry(contentNegotiationManager, this.applicationContext);
		configureViewResolvers(registry);

		if (registry.getViewResolvers().isEmpty() && this.applicationContext != null) {
    
    
			String[] names = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
					this.applicationContext, ViewResolver.class, true, false);
			if (names.length == 1) {
    
    
				registry.getViewResolvers().add(new InternalResourceViewResolver());
			}
		}
		return composite;
	}
}

Como se puede ver en el código fuente anterior, el solucionador de vistas InternalResourceViewResolver se cargará de forma predeterminada solo si hay una implementación de interfaz ViewResolver en el contenedor Spring. Si hay dos, no se cargará. Resulta que hay un solucionador de vistas para manejar páginas de error en Spring Boot, por lo que InternalResourceViewResolver no se cargará. Aquí puede desactivar este procesador de página de error y configurarlo a través de yml, la configuración es la siguiente:

server:
  error:
    whitelabel:
      enabled: false

Pero este es solo el analizador de vistas cargado y no se especifica ningún prefijo ni sufijo . Entonces, al acceder, debe traer usted mismo el formato de prefijo y sufijo.

Por ejemplo, para acceder a la página abc2.jsp mencionada anteriormente, la ruta de acceso es:http://localhost:9292/toJsp?cx=abc2.jspLos sufijos y sufijos son respectivamente / .jsp, para acceder a la página abc3.jsp, la ruta de acceso es:http://localhost:9292/toJsp?cx=/WEB-INF/abc3.jspLos sufijos y sufijos son respectivamente /WEB-INF/ .jsp. Generalmente, el acceso no se realiza de esta manera, por lo que debe personalizar la configuración y especificar el prefijo y el sufijo del analizador de vistas usted mismo .

7.1 Implemente la interfaz WebMvcConfigurer para agregar configuración para implementar una configuración personalizada (depende de sus necesidades)

La versión anterior implementó la clase WebMvcConfigurerAdapter, pero ahora ha caducado. Se recomienda utilizar la interfaz WebMvcConfigurer . Si le faltan algunas funciones, simplemente agregue las funciones correspondientes.

MvcConfigLas clases de configuración son las siguientes:

@Configuration
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {
    
    
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
    
    
        registry.jsp().suffix(".jsp").prefix("/");
    }
    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
    
    
            "classpath:/META-INF/resources/", "classpath:/resources/",
            "classpath:/static/", "classpath:/public/","classpath:/html/" };

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    

        registry.addResourceHandler("/**").addResourceLocations(CLASSPATH_RESOURCE_LOCATIONS);
    }
}

Aquí se personalizan dos componentes, uno es el componente del analizador de vistas y el otro es el componente de análisis de recursos estáticos. @EnableWebMvcLa anotación no activa el análisis de recursos estáticos de forma predeterminada, debe activarse manualmente y los recursos estáticos que deben analizarse se agregan mediante el método addResourceHandlers ().

Lo que /**significa que al acceder a recursos estáticos, el acceso a directorios jerárquicos no está restringido. Generalmente, la configuración es la siguiente y los archivos de recursos están separados por rutas de acceso, de la siguiente manera:

El acceso predeterminado de Spring Boot a /** es acceder directamente a los archivos en los cuatro directorios de recursos estáticos bajo el classpath:

• ruta de clase:/público/
• ruta de clases:/recursos/
• ruta de clase:/estática/
• ruta de clase:/META-INFO/recursos/

	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
	
		registry.addResourceHandler("/dist/**").addResourceLocations("classpath:/static/dist/");
		registry.addResourceHandler("/theme/**").addResourceLocations("classpath:/static/theme/");
		registry.addResourceHandler("/boot/*").addResourceLocations("classpath:/static/");
		// registry.addResourceHandler("/boot/**").addResourceLocations("classpath:/static/");
		// registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
	}

2. SpringBoot integra Thymeleaf

Se puede abrir directamente en el navegador un motor de plantillas liviano (no recomendado para los responsables de la lógica empresarial, el análisis de DOM o XML ocupará mucha memoria) y la página de la plantilla se mostrará correctamente y terminará directamente con html.

1. Introducir dependencias

       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
       </dependency>

2. Configurar el archivo yml

spring:
  freemarker:
    suffix: .ftlh
    enabled: true
    prefix: /

3. Cree una nueva página html en plantillas.

Cree una nueva página html en la carpeta de plantillas y declare que la resolución del nombre de dominio eshttp://www.thymeleaf.orgth:, para que la etiqueta Thymeleaf se pueda utilizar en la página para que surta efecto. La etiqueta más utilizada es

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"> </meta>
    <title>Thymeleaf project</title>
</head>
<body>
<h1>thymeleaf 页面</h1><h1 th:text="${name}"></h1>
</body>
</html>

4. Acceso a través del Controlador

@Controller
public class ToJspController {
    
    

    @RequestMapping("/toJsp")
    public ModelAndView toJsp(String cx) {
    
    
        ModelAndView view = new ModelAndView();
        System.out.println(">>>>>>toJsp...");
        System.out.println("hnhds");
        view.addObject("name", "gwm");
        view.setViewName(cx);
        return view;
    }
}

La ruta de acceso es:http://localhost:9292/toJsp?cx=abc3El efecto de la página es el siguiente:

Puede encontrar el valor del nombre del modelo encapsulado por el controlador. th:Esto es lo que pueden hacer las etiquetas proporcionadas por Thymeleaf .

Luego intente acceder a él como un recurso estático, la ruta es:http://localhost:9292/boot/abc3.htmlEl efecto es el siguiente:

Se puede encontrar abc3.htmlque se write()carga directamente en el navegador, es decir, se imprime como un recurso estático.

3. SpringBoot integra Freemarker

Los archivos de FreeMarker Template Language generalmente se guardan como xxx.ftlh o xxx.ftl, se basan estrictamente en el modo MVC y no dependen de las funciones integradas del contenedor Servlet (no ocupan memoria JVM).

1. Introducir dependencias

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>

        <dependency>
            <groupId>net.sourceforge.nekohtml</groupId>
            <artifactId>nekohtml</artifactId>
            <version>1.9.22</version>
        </dependency>

2. Escribir archivos de plantilla

Generalmente, los valores predeterminados de thymeleaf.html y freemarker.ftl son el directorio de plantillas en recursos (ruta de acceso predeterminada)

3. Escriba el código de la capa del controlador

public class Users {
    
    
    private String username;
    private String usersex;
    private String userage;

    public Users(String username, String usersex, String userage) {
    
    
        this.username = username;
        this.usersex = usersex;
        this.userage = userage;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getUsersex() {
    
    
        return usersex;
    }

    public void setUsersex(String usersex) {
    
    
        this.usersex = usersex;
    }

    public String getUserage() {
    
    
        return userage;
    }

    public void setUserage(String userage) {
    
    
        this.userage = userage;
    }
}

@Controller
public class TestController {
    
    

    @RequestMapping("/myfreemarker")
    public String showUsers(Model model) {
    
    
        List<Users> list = new ArrayList<>();
        list.add(new Users("aa", "F", "21"));
        list.add(new Users("bb", "M", "20"));
        list.add(new Users("cc", "F", "22"));
        model.addAttribute("list", list);

        return "myfreemarker";
    }
}

4. Visualización de efectos

DIRECCIÓN:http://localhost:9292/myfreemarker

4. Resumen

1. Cuando coexisten los JSP, Thymeleaf y Freemarker anteriores, SpringBoot los ordena de forma predeterminada, dando prioridad a los recursos de archivos estáticos y, finalmente, a los recursos JSP. Porque JSP en Spring en realidad no juzgará si el archivo existe, sino que dejará que Tomcat maneje el juicio por sí mismo. Los dos motores de plantillas de back-end, Thymeleaf y Freemarker, determinarán directamente primero la ubicación de almacenamiento del archivo. Sus prioridades se pueden ver en el código fuente, como se muestra a continuación:

2. JSP rara vez se usa hoy en día. Ahora veamos cuál es mejor, ¿Thymeleaf o Freemarker?

Si eliges Thymeleaf, es muy desafortunado que Thymeleaf no se haya actualizado desde hace dos años. Me pregunto si Velocity habrá dejado de actualizarse durante 7 años. Hace muchos años, alguien preguntó cuál elegir entre Velocity y Freemarker. Velocity cuenta con el respaldo de Apache. Pero el tiempo ha demostrado que Freemarker siempre ha sido una buena elección. En los últimos 20 años, Freemarker ha pasado por 4 reconstrucciones e iteraciones de actualización a largo plazo, manteniendo la compatibilidad con versiones anteriores tanto como sea posible. Tiene buen soporte para etiquetas JSP y formato JSON. datos y XML. El formato de datos puede permitirle implementar fácilmente extensiones de Java. Tiene métodos completos de procesamiento de datos, como cadenas, números, secuencias, tablas hash, etc., y puede escapar de forma segura de html, url, js, json, etc. Se puede utilizar en cualquier plantilla El motor se puede aplicar a escenarios con soluciones internacionales integradas. El registro de excepciones claro (que incluye la causa del error, la ubicación del error, el mensaje de error, la pila de plantillas y la pila de Java) le permite encontrar el error en La plantilla inmediatamente. Es muy poderosa. Es completamente posible crear un nuevo lenguaje dinámico, pero se adhiere estrictamente a los límites del motor de plantillas. Su potencia, integridad y seguridad pueden superar cualquier motor de plantillas que no se limite a Java. idioma.