Serie llena de pozos | Comenzando con Springboot [×]

arranque de primavera

Vídeo de aprendizaje

Capítulo 1 Configuración de Java

¿Por qué utilizar Spring Boot?

Debido a Spring, SpringMVC requiere una gran cantidad de archivos de configuración (archivos xml)

También debe configurar varios objetos y colocar los objetos usados en el contenedor de resorte antes de poder usarlos.

Es necesario comprender reglas adicionales de configuración del marco.
SpringBoot es equivalente a Spring+SpringMVC sin archivos de configuración. Se han configurado marcos de uso común y bibliotecas de terceros. Sólo tráelo y úsalo.
SpringBoot tiene una alta eficiencia de desarrollo y es mucho más fácil de usar.

1.1 JavaConfig（@Configuración、@Bean）

JavaConfig: el uso de clases java como alternativa a los archivos de configuración xml es una forma puramente java de configurar el contenedor Spring. En esta clase de Java, puede crear un objeto Java y colocar el objeto en el contenedor Spring (inyectarlo en el contenedor).

Utilice dos anotaciones:

1) @Configuration: se coloca encima de una clase, lo que indica que esta clase se utiliza como archivo de configuración.

2) @Bean: declara el objeto e inyecta el objeto en el contenedor.

例子：
package com.bjpowernode.config;

import com.bjpowernode.vo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * Configuration:表示当前类是作为配置文件使用的。 就是用来配置容器的
 *       位置：在类的上面
 *
 *  SpringConfig这个类就相当于beans.xml
 */
@Configuration
public class SpringConfig {
    
    
    /**
     * 创建方法，方法的返回值是对象。 在方法的上面加入@Bean
     * 方法的返回值对象就注入到容器中。
     *
     * @Bean: 把对象注入到spring容器中。 作用相当于<bean>
     *
     *     位置：方法的上面
     *
     *     说明：@Bean,不指定对象的名称，默认是方法名是 id
     *
     */
    @Bean
    public Student createStudent(){
    
    
        Student s1  = new Student();
        s1.setName("张三");
        s1.setAge(26);
        s1.setSex("男");
        return s1;
    }


    /***
     * 指定对象在容器中的名称（指定<bean>的id属性）
     * @Bean的name属性，指定对象的名称（id）
     */
    @Bean(name = "lisiStudent")
    public Student makeStudent(){
    
    
        Student s2  = new Student();
        s2.setName("李四");
        s2.setAge(22);
        s2.setSex("男");
        return s2;
    }
}

1.2 @ImporResource

@ImportResource funciona para importar otros archivos de configuración xml, lo que equivale a xml

<import resources="其他配置文件"/>

Por ejemplo:

@Configuration
@ImportResource(value ={
    
     "classpath:applicationContext.xml","classpath:beans.xml"})
public class SpringConfig {
    
    
}

1.3 @PropertyResource

@PropertyResource: lea el archivo de configuración de propiedades de propiedades. El uso de archivos de configuración de propiedades permite la configuración externalizada, proporcionando datos fuera del código del programa.

paso:

En el directorio de recursos, cree un archivo de propiedades y proporcione datos en el formato k=v
Especifique la ubicación del archivo de propiedades en PropertyResource
Utilice @Value(valor="${clave}")

@Configuration
@ImportResource(value ={
    
     "classpath:applicationContext.xml","classpath:beans.xml"})
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages = "com.bjpowernode.vo")
public class SpringConfig {
    
    
}

Capítulo 2 Bota de primavera

2.1 Introducción

SpringBoot es un miembro de Spring que puede simplificar el uso de Spring y SpringMVC. Su núcleo sigue siendo el contenedor del COI.

Características:

Cree aplicaciones Spring independientes

Crear aplicación de primavera
Incruste Tomcat, Jetty o Undertow directamente (no es necesario implementar archivos WAR)

Gato integrado, embarcadero, resaca
Proporcione dependencias 'iniciales' obstinadas para simplificar la configuración de su compilación

Proporciona dependencias iniciales para simplificar la configuración de la aplicación.

Por ejemplo, cuando se utiliza el marco MyBatis, es necesario configurar el objeto MyBatis SqlSessionFactory y el objeto proxy Dao en el proyecto Spring.

En el proyecto SpringBoot, en pom.xml, agregue una dependencia mybatis-spring-boot-starter
Configure automáticamente bibliotecas Spring y de terceros siempre que sea posible

Configure las bibliotecas de Spring y de terceros tanto como sea posible. Se llama configuración automática (es decir, crear objetos en bibliotecas Spring y de terceros y colocarlos en contenedores para que los desarrolladores puedan usarlos directamente).
Proporcionar funciones listas para producción, como métricas, comprobaciones de estado y configuración externalizada.

Proporciona controles de estado, estadísticas y configuraciones externalizadas.
Absolutamente sin generación de código y sin necesidad de configuración XML

No es necesario generar código, no es necesario utilizar xml para la configuración

2.2 Crear proyecto Spring Boot

2.2.1 La primera forma es utilizar el inicializador proporcionado por Spring, que es un asistente para crear una aplicación SpringBoot.

Dirección utilizada: https://start.spring.io

Estructura del proyecto SpringBoot:
$[La transferencia de la imagen del enlace externo falló. El sitio de origen puede tener un mecanismo anti-leeching. Se recomienda guardar la imagen y cargarla directamente (img-RsEWlnrG-1676099201708) (D:\course\25-SpringBoot\notes\images \image-20210115152427829.png) ]$

2.2.1 El segundo método es utilizar una dirección nacional.

https://start.springboot.io
$[La transferencia de la imagen del enlace externo falló. El sitio de origen puede tener un mecanismo anti-leeching. Se recomienda guardar la imagen y cargarla directamente (img-mE0zVSXx-1676099201714) (D:\course\25-SpringBoot\notes\images \image-20210115155556662.png) ]$

2.3 Uso de anotaciones

@SpringBootApplication es una anotación compuesta: compuesta por

@SpringBootConfiguración
@EnableAutoConfiguración
@ComponentScan

1.@Configuración de SpringBoot

@Configuration
public @interface SpringBootConfiguration {
    
    
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用的，
    可以使用Bean声明对象，注入到容器

2.@Habilitar configuración automática

启用自动配置， 把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中

3.@Escaneo de componentes

@ComponentScan 扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。
默认扫描的包： @ComponentScan所在的类所在的包和子包。

2.4 Archivo de configuración SpringBoot

Nombre del archivo de configuración:
extensión de la aplicación: propiedades (k = v); yml (k: v)

Utilice aplicación.properties, aplicación.yml

Ejemplo 1: application.properties establece el puerto y el contexto

#设置端口号
server.port=8082
#设置访问应用上下文路径，contextpath
server.servlet.context-path=/myboot

Ejemplo 2: aplicación.yml

server:
  port: 8083
  servlet:
    context-path: /myboot2

2.5 Configuración multientorno

Hay entornos de desarrollo, entornos de prueba y entornos en línea.

Cada entorno tiene información de configuración diferente, como puerto, software de contexto, URL de la base de datos, nombre de usuario, contraseña, etc.

Al utilizar archivos de configuración multientorno, puede cambiar fácilmente entre diferentes configuraciones.

Uso: cree varios archivos de configuración, reglas de nombres: nombre del entorno de aplicación.properties (yml)

Cree un archivo de configuración para el entorno de desarrollo: application-dev.properties( application-dev.yml )

Cree la configuración utilizada por los evaluadores: application-test.properties

application.properties文件中进行激活：
spring.profiles.active=test

2.6 @Propiedades de configuración

@ConfigurationProperties: asigna los datos del archivo de configuración a objetos Java.

Atributo: prefijo El contenido al principio de ciertas claves en el archivo de configuración.

@Component
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {
    
    

    private String name;
    private String website;
    private String address;


    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public String getWebsite() {
    
    
        return website;
    }

    public void setWebsite(String website) {
    
    
        this.website = website;
    }

    public String getAddress() {
    
    
        return address;
    }

    public void setAddress(String address) {
    
    
        this.address = address;
    }

    @Override
    public String toString() {
    
    
        return "SchoolInfo{" +
                "name='" + name + '\'' +
                ", website='" + website + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

propiedades.de.aplicación

#配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot

#自定义key=value
school.name=动力节点
school.website=www.bjpowernode.com
school.address=北京的大兴区

site=www.bjpowernode.com

2.7 Usando jsp

SpringBoot no recomienda usar jsp, pero usa tecnología de plantilla en lugar de jsp

Se requiere configuración para usar jsp:
1) Agregue una dependencia para procesar jsp. Responsable de compilar archivos jsp.

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

Si necesita utilizar funciones servlet, jsp, jstl

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>jstl</artifactId>
</dependency>

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
</dependency>

<dependency>
<groupId>javax.servlet.jsp</groupId>
	<artifactId>javax.servlet.jsp-api</artifactId>
	<version>2.3.1</version>
</dependency>

Cree un directorio para almacenar jsp, generalmente llamado webapp
index.jsp
Debe especificar el directorio de almacenamiento para los archivos jsp compilados en pom.xml.
META-INF/recursos

5) Crear controlador y acceder a jsp

6) Configure el solucionador de vistas en el archivo application.propertis

2.8 Usando contenedores

Quiere obtener el objeto del contenedor a través del código.

Obtenga el contenedor a través del valor de retorno de SpringApplication.run(Application.class, args);

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    
    
        return run(new Class[]{
    
    primarySource}, args);
}

ConfigurableApplicationContext : 接口，是ApplicationContext的子接口
public interface ConfigurableApplicationContext extends ApplicationContext

2.9 Interfaz CommandLineRunner, interfaz ApplicationRunner

Ambas interfaces tienen un método de ejecución. El tiempo de ejecución es después de que se crea el objeto contenedor y el método run() se ejecuta automáticamente.

Puede completar algunas operaciones personalizadas creadas en el objeto contenedor.

@FunctionalInterface
public interface CommandLineRunner {
    
    
    void run(String... args) throws Exception;
}

@FunctionalInterface
public interface ApplicationRunner {
    
    
    void run(ApplicationArguments args) throws Exception;
}

Capítulo 3 Componentes web 【×】

Hable sobre tres contenidos: interceptor, servlet, filtro

3.1 Interceptor

Un interceptor es un objeto en SpringMVC que puede interceptar solicitudes al Controlador.

Hay interceptores del sistema en el marco del interceptor y también puede personalizar los interceptores. Implementar preprocesamiento de solicitudes.

Implementar un interceptor personalizado:

Cree una clase que implemente la interfaz HandlerInterceptor del marco SpringMVC

public interface HandlerInterceptor {
    
    
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    
    
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    
    
    }
}

2. El interceptor debe declararse en el archivo de configuración SpringMVC.

<mvc:interceptors>
	<mvc:interceptor>
    	<mvc:path="url" />
        <bean class="拦截器类全限定名称"/>
    </mvc:interceptor>
</mvc:interceptors>

Registrar interceptor en SpringBoot:

@Configuration
public class MyAppConfig implements WebMvcConfigurer {
    
    

    //添加拦截器对象， 注入到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    

        //创建拦截器对象
        HandlerInterceptor interceptor = new LoginInterceptor();

        //指定拦截的请求uri地址
        String path []= {
    
    "/user/**"};
        //指定不拦截的地址
        String excludePath  [] = {
    
    "/user/login"};
        registry.addInterceptor(interceptor)
                .addPathPatterns(path)
                .excludePathPatterns(excludePath);
    }
}

3.2 Servlet

Utilice objetos Servlet en el marco SpringBoot.

Pasos de uso:

Crear clase de servlet. Crea una clase que hereda HttpServlet
Registre el servlet para que el marco pueda encontrar el servlet

ejemplo:

1. Cree un servlet personalizado

//创建Servlet类
public class MyServlet extends HttpServlet {
    
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
       //使用HttpServletResponse输出数据，应答结果
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out  = resp.getWriter();
        out.println("===执行的是Servlet==");
        out.flush();
        out.close();

    }
}

Registrar servlet

@Configuration
public class WebApplictionConfig {
    
    

    //定义方法， 注册Servlet对象
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
    
    

        //public ServletRegistrationBean(T servlet, String... urlMappings)
        //第一个参数是 Servlet对象， 第二个是url地址

        //ServletRegistrationBean bean =
                //new ServletRegistrationBean( new MyServlet(),"/myservlet");


        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet( new MyServlet());
        bean.addUrlMappings("/login","/test"); // <url-pattern>


        return bean;
    }
}

3.3 Filtro Filtro

El filtro es un filtro en la especificación de Servlet, que puede procesar solicitudes y ajustar los parámetros y atributos de las solicitudes. Las codificaciones de caracteres a menudo se manejan en filtros.

Utilice filtros en marcos:

Crear una clase de filtro personalizada
Registrar objeto de filtro

ejemplo:

// 自定义过滤器
public class MyFilter implements Filter {
    
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    
    
        System.out.println("执行了MyFilter，doFilter ");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

RegistrarseFiltro

@Configuration
public class WebApplicationConfig {
    
    

    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
    
    
        FilterRegistrationBean bean  = new FilterRegistrationBean();
        bean.setFilter( new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

3.4 Filtro de juego de caracteres

CharacterEncodingFilter: resuelve el problema de los caracteres confusos en las solicitudes de publicación

En el marco SpringMVC, registre filtros en web.xml. Configura sus propiedades.

Primera forma:

Pasos de uso:

Configurar el filtro de juego de caracteres

@Configuration
public class WebSystemConfig {
      
      

    //注册Servlet
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
      
      
        MyServlet myServlet = new MyServlet();
        ServletRegistrationBean reg = new ServletRegistrationBean(myServlet,"/myservlet");
        return reg;
    }


    //注册Filter
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
      
      
        FilterRegistrationBean reg = new FilterRegistrationBean();

        //使用框架中的过滤器类
        CharacterEncodingFilter filter  = new CharacterEncodingFilter();
        //指定使用的编码方式
        filter.setEncoding("utf-8");
        //指定request ， response都使用encoding的值
        filter.setForceEncoding(true);

        reg.setFilter(filter);
        //指定 过滤的url地址
        reg.addUrlPatterns("/*");


        return reg;
    }
}

Modifique el archivo application.properties para permitir que los filtros personalizados surtan efecto

#SpringBoot中默认已经配置了CharacterEncodingFilter。 编码默认ISO-8859-1
#设置enabled=false 作用是关闭系统中配置好的过滤器， 使用自定义的CharacterEncodingFilter
server.servlet.encoding.enabled=false

Segunda manera

Modificar el archivo application.properties

server.port=9001
server.servlet.context-path=/myboot

#让系统的CharacterEncdoingFilter生效
server.servlet.encoding.enabled=true
#指定使用的编码方式
server.servlet.encoding.charset=utf-8
#强制request，response都使用charset属性的值
server.servlet.encoding.force=true

Capítulo 4 Operación ORM MySQL

Utilice el marco MyBatis para operar datos e integrar MyBatis en el marco SpringBoot.

Pasos de uso:

Dependencia inicial de Mybatis: complete la configuración automática de los objetos mybatis y coloque los objetos en el contenedor
pom.xml especifica incluir el archivo xml en el directorio src/main/java en el classpath

<resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
</resources>

Crear clase de entidad Estudiante
Cree la interfaz Dao StudentDao y cree un método para consultar a los estudiantes

@Mapper
public interface StudentDao {
    
    
    Student selectById(int id);
}

Cree archivos Mapper y archivos xml correspondientes a la interfaz Dao y escriba declaraciones sql
Cree el objeto de capa de Servicio, cree la interfaz StudentService y su clase de implementación. Obtenga el método del objeto dao. Operaciones completas de base de datos.
Cree un objeto Controlador y acceda al Servicio.
Escribir archivo application.properties

Configurar la información de conexión de la base de datos.

La primera forma: @Mapper

@Mapper: colocado encima de la interfaz dao, cada interfaz necesita usar esta anotación.

/**
 * @Mapper：告诉MyBatis这是dao接口，创建此接口的代理对象。
 *     位置：在类的上面
 */
@Mapper
public interface StudentDao {
    
    
    Student selectById(@Param("stuId") Integer id);
}

Segunda forma: @MapperScan

/**
 * @MapperScan: 找到Dao接口和Mapper文件
 *     basePackages：Dao接口所在的包名
 */
@SpringBootApplication
@MapperScan(basePackages = {
    
    "com.bjpowernode.dao","com.bjpowernode.mapper"})
public class Application {
    
    
}

La tercera forma: los archivos Mapper y las interfaces Dao se administran por separado

Ahora coloque el archivo Mapper en el directorio de recursos.

1) Cree un subdirectorio (personalizado) en el directorio de recursos, como mapper

2) Coloque el archivo del asignador en el directorio del asignador.

3) En el archivo application.properties, especifique el directorio del archivo asignador

#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml
#指定mybatis的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4) Especifique en pom.xml compilar los archivos del directorio de recursos en el directorio de destino.

<!--resources插件-->
<resources>
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

Soporte de transacciones

Transacciones en el marco Spring:

1) Objeto que gestiona transacciones: administrador de transacciones (interfaz, la interfaz tiene muchas clases de implementación)

Por ejemplo: use Jdbc o mybatis para acceder a la base de datos, use el administrador de transacciones: DataSourceTransactionManager

2) Transacción declarativa: describa el contenido del control de transacciones en el archivo de configuración xml o utilice anotaciones

Transacciones de control: nivel de aislamiento, comportamiento de propagación, período de tiempo de espera

3) Método de procesamiento de transacciones:

1) @Transactional en el marco Spring

2) El marco de aspectoj puede declarar el contenido del control de transacciones en el archivo de configuración xml

Uso de transacciones en SpringBoot: ambos métodos anteriores están disponibles.

1) Agregue @Transactional al método comercial. Después de agregar la anotación, el método tiene función de transacción.

2) Agregue explícitamente @EnableTransactionManager encima de la clase de inicio principal

ejemplo:

/**
 * @Transactional: 表示方法的有事务支持
 *       默认：使用库的隔离级别， REQUIRED 传播行为； 超时时间  -1
 *       抛出运行时异常，回滚事务
 */
@Transactional
@Override
public int addStudent(Student student) {
    
    
    System.out.println("业务方法addStudent");
    int rows  =  studentDao.insert(student);
    System.out.println("执行sql语句");

    //抛出一个运行时异常， 目的是回滚事务
    //int m   = 10 / 0 ;

    return rows;
}

Capítulo 5 Estilo de arquitectura de interfaz: RESTful [×]

Interfaz: API (Interfaz de programación de aplicaciones) son algunas interfaces predefinidas (como funciones, interfaz HTTP) o se refieren al acuerdo para conectar diferentes componentes del sistema de software . Un conjunto de rutinas utilizadas para proporcionar a las aplicaciones y a los desarrolladores acceso a una pieza de software o hardware sin tener que acceder al código fuente ni comprender los detalles del funcionamiento interno.

Interfaz (API): puede referirse al acceso a servlets, URL de controladores y llamadas a funciones de otros programas.

Estilo arquitectónico: estilo de organización API (apariencia)

Solo uno tradicional: http://localhost:9002/mytrans/addStudent?name=lisi&age=26

El nombre del recurso accedido addStudent se proporciona en la dirección y luego se utiliza el método get para pasar parámetros.

5.1 DESCANSO

Estilo arquitectónico RESTful

1)REST: (inglés: transferencia de estado representacional, chino: transferencia de estado de capa de presentación).

REST: Es un concepto de diseño y estilo arquitectónico de interfaz, no un estándar.

Ventajas: Más conciso y jerárquico

Transferencia de estado de la capa de presentación:

La capa de presentación es la capa de vista, que muestra recursos y muestra los resultados de los recursos operativos a través de páginas de vista, jsp, etc.

Estado: cambios de recursos

Transferencia: Los recursos pueden cambiar. El recurso se puede crear en el nuevo estado. Una vez creado, se puede consultar el recurso y se puede ver el contenido del recurso.

El contenido de este recurso se puede modificar, el recurso modificado será diferente al anterior.

2) Elementos en DESCANSO:

Utilice REST para representar recursos y operaciones sobre recursos. En Internet, representa un recurso o una operación.

Los recursos están representados por URL, en Internet las imágenes, videos, textos, páginas web, etc. utilizados son todos recursos.

Los recursos están representados por sustantivos.

Para recursos:

Consultar recursos: busque, busque recursos a través de URL.

Crear recursos: Agregar recursos

Actualizar recursos: actualizar recursos, editar

Eliminar recursos: Eliminar

Los recursos están representados por URL y los recursos están representados por sustantivos.

En la URL, utilice sustantivos para representar recursos e información sobre el acceso a los recursos. En la URL, utilice "/" para separar la información sobre los recursos.

http://localhost:8080/myboot/student/1001

Utilice acciones en http (método de solicitud) para representar operaciones en recursos (CURD)

OBTENER: Consultar recursos – selección sql

Manejar un solo recurso: usar su forma singular

http://localhost:8080/myboot/student/1001

http://localhost:8080/myboot/student/1001/1

Manejo de múltiples recursos: use la forma plural

http://localhost:8080/myboot/students/1001/1002

POST: Crear recurso – inserción sql

http://localhost:8080/miarranque/estudiante

Pasar datos en la solicitud de publicación

<form action="http://localhost:8080/myboot/student" method="post">
	姓名：<input type="text" name="name" />
    年龄：<input type="text" name="age" />
</form>

PUT: recurso de actualización – actualización de sql

<form action="http://localhost:8080/myboot/student/1" method="post">
 姓名：<input type="text" name="name" />
 年龄：<input type="text" name="age" />
      <input type="hidden" name="_method" value="PUT" />
</form>

ELIMINAR: Eliminar recursos – eliminación sql

<a href="http://localhost:8080/myboot/student/1">删除1的数据</a>

La paginación requerida, la clasificación y otros parámetros aún se colocan después de la URL, por ejemplo
http://localhost:8080/myboot/students?page=1&pageSize=20

3) Explique REST en una oración:

Utilice URL para representar recursos y utilice acciones http para operar recursos.

anotación

@PathVariable: obtener datos de la URL

@GetMapping: método de solicitud de obtención admitido, equivalente a @RequestMapping(method=RequestMethod.GET)

@PostMapping: admite el método de solicitud de publicación, equivalente a @RequestMapping(method=RequestMethod.POST)

@PutMapping: admite el método de solicitud de colocación, equivalente a @RequestMapping(method=RequestMethod.PUT)

@DeleteMapping: admite el método de solicitud de eliminación, equivalente a @RequestMapping(method=RequestMethod.DELETE)

@RestController: anotación compuesta, que es una combinación de @Controller y @ResponseBody.

Utilice @RestController en la clase para indicar que todos los métodos de la clase actual han agregado @ResponseBody

Cartero: herramienta de prueba

Usando Postman: puede probar obtener, publicar, colocar, eliminar y otras solicitudes

5.2 En la página o ajax, admite solicitudes de colocación y eliminación

Hay un filtro en SpringMVC que admite la conversión de solicitudes de publicación en colocar y eliminar

Filtro: org.springframework.web.filter.HiddenHttpMethodFilter

Función: Convertir la solicitud de publicación en la solicitud para colocar y eliminar

Pasos de implementación:

application.properties (yml): habilita el uso del filtro HiddenHttpMethodFilter
En la página de solicitud, se incluye el parámetro _method. Su valor es poner, eliminar y el método de publicación utilizado para iniciar esta solicitud.

Capítulo 6 Redis 【×】

Redis: una base de datos NoSQL, a menudo utilizada como caché (cache)

Tipos de datos de Redis: cadena, hash, set, zset, lista

Redis es un middleware: es un servidor independiente.

Clientes famosos en java: Jedis, lechuga, Redisson

Spring, hay un RedisTemplate (StringRedisTemplate) en SpringBoot, que maneja la interacción con redis

6.1 Configurar la versión de Windows de redis

Redis-x64-3.2.100.rar Descomprimir en un directorio que no sea chino

redis-server.exe: servidor, después de iniciarlo, no lo cierre

redis-cli.exe: cliente, accede a datos en redis

redisclient-win32.x86_64.2.0.jar: cliente de interfaz gráfica de Redis

Método de ejecución: en el directorio donde se encuentra este archivo, ejecute java -jar redisclient-win32.x86_64.2.0.jar

La biblioteca cliente de lechuga utilizada por RedisTemplate

<!--redis起步依赖： 直接在项目中使用RedisTemplate(StringRedisTemplate)-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
data-redis使用的   lettuce 客户端库

在程序中使用RedisTemplate类的方法 操作redis数据， 实际就是调用的lettuce 客户端的中的方法

6.2 Comparar StringRedisTemplate y RedisTemplate

StringRedisTemplate: trata k y v como cadenas, utiliza serialización de cadenas y tiene buena legibilidad

RedisTemplate: guarde k y v en redis después de la serialización. k, v son contenidos serializados y no pueden identificarse directamente.

La serialización jdk utilizada de forma predeterminada se puede modificar a la serialización de requisitos previos.

Serialización: el proceso de convertir un objeto en una secuencia de bytes transmisible se llama serialización.

Deserialización: el proceso de restaurar una secuencia de bytes en un objeto se llama deserialización.

Por qué es necesaria la serialización

El objetivo final de la serialización es permitir que los objetos se almacenen entre plataformas y se transmitan a través de la red. La forma en que realizamos el almacenamiento multiplataforma y la transmisión de red es IO, y el formato de datos admitido por nuestro IO es una matriz de bytes. Debemos formular una regla (serialización) al convertir el objeto en una matriz de bytes, y luego usar esta regla para restaurar el objeto (deserialización) cuando leemos los datos del flujo IO.

¿Cuándo se requiere la serialización?

De lo anterior, creo que ya sabes que cualquier dato que requiera "almacenamiento multiplataforma" y "transmisión de red" debe serializarse.

Esencialmente, tanto el almacenamiento como la transmisión de red requieren guardar el estado de un objeto en un formato de bytes reconocido multiplataforma, y luego otras plataformas pueden analizar y restaurar la información del objeto a través de información de bytes.

Método de serialización

La serialización es solo una regla para desmontar y ensamblar objetos, por lo que puede haber muchos tipos de reglas. Por ejemplo, los métodos de serialización comunes ahora incluyen:

JDK (sin compatibilidad con varios idiomas), JSON, XML, Hessian, Kryo (sin compatibilidad con varios idiomas), Thrift, Protofbuff,

Estudiante( nombre=zs, edad=20) ---- { “nombre”:“zs”, “edad”:20 }

Serialización de Java: convierte objetos Java en bytes [], datos binarios

Serialización json: la función de serialización json convierte objetos hacia y desde el formato JSON. Por ejemplo, convierta un objeto Estudiante en una cadena JSON {"name":"李思", "age":29}) y deserialice (convierta la cadena JSON {"name":"李思", "age": 29} convertido en objeto de Estudiante)

Establecer el método de serialización de clave o valor

// 使用RedisTemplate ，在存取值之前，设置序列化
// 设置 key 使用String的序列化
redisTemplate.setKeySerializer( new StringRedisSerializer());

// 设置 value 的序列化
redisTemplate.setValueSerializer( new StringRedisSerializer());

redisTemplate.opsForValue().set(k,v);

Capítulo 7 SpringBoot integra Dubbo 【×】

7.1 Ver la documentación de SpringBoot heredando Dubbo

https://github.com/apache/dubbo-spring-boot-project/blob/master/README_CN.md

7.2 Proyectos públicos

Proyecto maven independiente: interfaz y clase de datos definidas

public class Student implements Serializable {
    
    
    private static final long serialVersionUID = 1901229007746699151L;

    private Integer id;
    private String name;
    private Integer age;
}

public interface StudentService {
    
    

    Student queryStudent(Integer id);
}

7.3 Proveedor

Crear proyecto SpringBoot

1） pom.xml

<dependencies>

   <!--加入公共项目的gav-->
   <dependency>
      <groupId>com.bjpowernode</groupId>
      <artifactId>022-interface-api</artifactId>
      <version>1.0.0</version>
   </dependency>

   <!--dubbo依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
      <version>2.7.8</version>
   </dependency>


   <!--zookeeper依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>2.7.8</version>
      <type>pom</type>
      <exclusions>
         <!-- 排除log4j依赖 -->
         <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
         </exclusion>
      </exclusions>
   </dependency>
</dependencies>

2) Implementar la interfaz

/**
 * 使用dubbo中的注解暴露服务
 * @Component 可以不用加
 */
@DubboService(interfaceClass = StudentService.class,version = "1.0",timeout = 5000)
public class StudentServiceImpl implements StudentService {
    
    
    @Override
    public Student queryStudent(Integer id) {
    
    
        Student student  = new Student();
        if( 1001 == id){
    
    
            student.setId(1001);
            student.setName("------1001-张三");
            student.setAge(20);
        } else if(1002  == id){
    
    
            student.setId(1002);
            student.setName("#######1002-李四");
            student.setAge(22);
        }

        return student;
    }
}

3）propiedades de la aplicación

#配置服务名称 dubbo:application name="名称"
spring.application.name=studentservice-provider

#配置扫描的包， 扫描的@DubboService
dubbo.scan.base-packages=com.bjpowernode.service

#配置dubbo协议
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881

#注册中心
dubbo.registry.address=zookeeper://localhost:2181

4) Por encima de la clase de inicio

@SpringBootApplication
@EnableDubbo
public class ProviderApplication {
    
    

   public static void main(String[] args) {
    
    
      SpringApplication.run(ProviderApplication.class, args);
   }
}

7.4 Consumidores

Crear proyecto SpringBoot

1） pom.xml

<dependencies>

   <!--加入公共项目的gav-->
   <dependency>
      <groupId>com.bjpowernode</groupId>
      <artifactId>022-interface-api</artifactId>
      <version>1.0.0</version>
   </dependency>

   <!--dubbo依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
      <version>2.7.8</version>
   </dependency>


   <!--zookeeper依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>2.7.8</version>
      <type>pom</type>
      <exclusions>
         <!-- 排除log4j依赖 -->
         <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
         </exclusion>
      </exclusions>
   </dependency>
</dependencies>

Puede crear un Controlador o Servicio.

@RestController
public class DubboController {
    
    

    /**
     * 引用远程服务， 把创建好的代理对象，注入给studentService
     */
    //@DubboReference(interfaceClass = StudentService.class,version = "1.0")

    /**
     * 没有使用interfaceClass，默认的就是 引用类型的 数据类型
      */
    @DubboReference(version = "1.0")
    private StudentService studentService;

    @GetMapping("/query")
    public String queryStudent(Integer id){
    
    
        Student student   = studentService.queryStudent(id);
        return "调用远程接口，获取对象："+student;
    }
}

3）propiedades de la aplicación

#指定服务名称
spring.application.name=consumer-application
#指定注册中心
dubbo.registry.address=zookeeper://localhost:2181

7.5 Ejercicios

Tecnologías utilizadas: SpringBoot, Dubbo, Redis, MyBatis

Mesa de estudiantes:
$[La transferencia de la imagen del enlace externo falló. El sitio de origen puede tener un mecanismo anti-leeching. Se recomienda guardar la imagen y cargarla directamente (img-6JW1uuz2-1676099201716) (D:\course\25-SpringBoot\notes\images \image-20210119150418295.png) ]$

CREAR TABLA student(
idint(11) NOT NULL AUTO_INCREMENT,
namevarchar(255) COLLATE utf8_bin DEFAULT NULL,
phonevarchar(11) COLLATE utf8_bin DEFAULT NULL,
ageint(11) DEFAULT NULL,
PRIMARY KEY ( id)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET= utf8 COLLATE=utf8_bin;

Registrar un estudiante

El teléfono debe ser único. Si ya existe un número de teléfono móvil, el registro fallará.

int addStudent(Estudiante estudiante);

Valor de retorno: int

1: Registro exitoso

2: El número de teléfono móvil ya existe

el nombre debe tener al menos dos caracteres,

la edad debe ser mayor que 0

2) Consultar estudiantes, consultar a este estudiante según su identificación.

Primero vaya a redis para consultar al estudiante. Si no existe dicho estudiante en redis, consulte desde la base de datos y coloque al estudiante consultado en redis.

Si vuelves a consultar a este estudiante más tarde, deberías poder obtenerlo de redis.

Consulta de estudianteEstudiante(ID entero);

Utilizando el marco Dubbo, los proveedores de servicios implementan addStudent y queryStudent.

El consumidor puede ser un Controlador que llama a dos métodos del proveedor. Implementar registro y consulta.

4) La página utiliza html, ajax y jquery.

Proporcione un formulario en la página html para registrar estudiantes y proporcione un cuadro de texto para ingresar la identificación para la consulta.

Tanto el registro como la consulta utilizan tecnología ajax.

html, jquery.js se colocan en el directorio recursos/estático

Capítulo 8 Embalaje 【×】

8.1 Guerra de envases

1. Creó una aplicación jsp

2. Modificar pom.xml

1) Especifique el nombre del archivo empaquetado

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

2) Especifique el directorio de compilación jsp

<!--resources插件， 把jsp编译到指定的目录-->
<resources>
   <resource>
      <directory>src/main/webapp</directory>
      <targetPath>META-INF/resources</targetPath>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>

   <!--使用了mybatis ，而且mapper文件放在src/main/java目录-->
   <resource>
      <directory>src/main/java</directory>
      <includes>
         <include>**/*.xml</include>
      </includes>
   </resource>

   <!--把src/main/resources下面的所有文件，都包含到classes目录-->
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

3) Ejecutar el embalaje es la guerra

<!--打包类型-->
<packaging>war</packaging>

4) La clase de inicio principal hereda SpringBootServletInitializer

/**
 * SpringBootServletInitializer: 继承这个类， 才能使用独立tomcat服务器
 */
@SpringBootApplication
public class JspApplication  extends SpringBootServletInitializer  {
    
    

   public static void main(String[] args) {
    
    
      SpringApplication.run(JspApplication.class, args);
   }

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
    
    
      return builder.sources(JspApplication.class);
   }
}

5) Desplegar la guerra

Coloque la guerra en el directorio de lanzamiento de servidores como tomcat. Tome Tomcat como ejemplo y coloque myboot.war en el directorio tomcat/webapps.

8.2 Envasar como frasco

1. Creó un proyecto que contiene jsp.

2. Modificar pom.xml

1) Especifique el nombre del archivo empaquetado

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

Especifique la versión del complemento springboot-maven

<plugins>
   <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <!--打包jar， 有jsp文件时，必须指定maven-plugin插件的版本是 1.4.2.RELEASE-->
      <version>1.4.2.RELEASE</version>
   </plugin>
</plugins>

3) Finalmente ejecute el paquete maven clean

En el directorio de destino, genere un archivo jar, el ejemplo es myboot.jar

Ejecute el proyecto springboot independiente en cmd java -jar myboot.jar

Capítulo 9 Motor de plantillas Thymeleaf [×]

Thymeleaf: es una tecnología de plantilla desarrollada con Java y se ejecuta en el lado del servidor. Enviar los datos procesados al navegador.

Las plantillas funcionan en la capa de vista. Mostrar datos. Thymeleaf está basado en el lenguaje HTML. La sintaxis de Thymleaf se aplica en

etiqueta html. El marco SpringBoot integra Thymealeaf y usa Thymeleaf en lugar de jsp.

Sitio web oficial de Thymeleaf: http://www.thymeleaf.org
Manual oficial de Thymeleaf: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html

9.1 Expresiones

expresión de variable estándar

Sintaxis: ${clave}

Función: Obtenga los datos de texto de la clave. La clave es la clave en el alcance de la solicitud. Utilice request.setAttribute(), model.addAttribute()

En la etiqueta html de la página, utilice th:text="${key}"

<div style="margin-left: 400px">
    <h3>标准变量表达式:  ${key}</h3>
    <p th:text="${site}">key不存在</p>
    <br/>
    <p>获取SysUser对象 属性值</p>
    <p th:text="${myuser.id}">id</p>
    <p th:text="${myuser.name}">姓名</p>
    <p th:text="${myuser.sex}">姓名：m男</p>
    <p th:text="${myuser.age}">年龄</p>
    <p th:text="${myuser.getName()}">获取姓名使用getXXX</p>
</div>

Seleccionar expresión variable (expresión variable de asterisco)

Sintaxis: *{clave}

Función: Obtener los datos correspondientes a esta clave. *{key} debe usarse junto con el atributo th:object.

El propósito es simplemente obtener el valor del atributo del objeto.

<p>使用 *{} 获取SysUser的属性值</p>
<div th:object="${myuser}">
    <p th:text="*{id}"></p>
    <p th:text="*{name}"></p>
    <p th:text="*{sex}"></p>
    <p th:text="*{age}"></p>

</div>
<p>使用*{}完成的表示 对象的属性值</p>
<p th:text="*{myuser.name}" ></p>

expresión en cadena

Sintaxis: @{url}

Función: Representa un enlace, sí

 <script src="..."> , <link href="..."> <a href=".."> ,<form action="..."> <img src="...">

9.2 Propiedades de la hoja de tomillo

Los atributos se colocan en el elemento html, que es el atributo del elemento html, con el prefijo th agregado. La función de los atributos permanece sin cambios. Después de agregar th, el motor de plantillas procesa el valor del atributo. Se pueden utilizar expresiones variables en las propiedades.

Por ejemplo:

<form action="/loginServlet" method="post"></form>

<form th:action="/loginServlet" th:method="${methodAttr}"></form>

9,3 cada uno

Cada bucle puede recorrer List y Array

gramática:

En una etiqueta html, use th:each

<div th:each="集合循环成员,循环的状态变量:${key}">
    <p th:text="${集合循环成员}" ></p>
</div>

集合循环成员,循环的状态变量:两个名称都是自定义的。 “循环的状态变量”这个名称可以不定义，默认是"集合循环成员Stat"

cada bucleMapa

En una etiqueta html, use th:each

<div th:each="集合循环成员,循环的状态变量:${key}">
    <p th:text="${集合循环成员.key}" ></p>
    <p th:text="${集合循环成员.value}" ></p>
</div>

集合循环成员,循环的状态变量:两个名称都是自定义的。 “循环的状态变量”这个名称可以不定义，默认是"集合循环成员Stat"

key:map集合中的key
value：map集合key对应的value值

9.4º: si

"th:if": declaración de juicio. Cuando la condición es verdadera, se muestra el cuerpo de la etiqueta html. De lo contrario, no hay ninguna declaración más.

语法：
<div th:if=" 10 > 0 "> 显示文本内容 </div>

También existe un th:a menos que tenga el comportamiento opuesto a th:if

语法：
<div th:unless=" 10 < 0 "> 当条件为false显示标签体内容 </div>

Ejemplo: si

<div style="margin-left: 400px">
        <h3> if 使用</h3>
        <p th:if="${sex=='m'}">性别是男</p>
        <p th:if="${isLogin}">已经登录系统</p>
        <p th:if="${age > 20}">年龄大于20</p>
        <!--""空字符是true-->
        <p th:if="${name}">name是“”</p>
        <!--null是false-->
        <p th:if="${isOld}"> isOld是null</p>
 </div>

Ejemplo: a menos que

 <div style="margin-left: 400px">
        <h3>unless: 判断条件为false，显示标签体内容</h3>
        <p th:unless="${sex=='f'}">性别是男的</p>
        <p th:unless="${isLogin}">登录系统</p>
        <p th:unless="${isOld}"> isOld是null </p>
 </div>

9.5to: cambiar

th: el cambio es el mismo que el cambio en Java

语法：
<div th:switch="要比对的值">
    <p th:case="值1">
        结果1
    </p>
    <p th:case="值2">
        结果2
    </p>
    <p th:case="*">
        默认结果
    </p>
    以上的case只有一个语句执行
    
</div>

9.6º: en línea

Texto en línea: fuera de la etiqueta html, obtiene el valor de la expresión

gramática:

<p>显示姓名是：[[${key}]]</p>

 <div style="margin-left: 400px">
        <h3>内联 text, 使用内联表达式显示变量的值</h3>
        <div th:inline="text">
            <p>我是[[${name}]]，年龄是[[${age}]]</p>
            我是<span th:text="${name}"></span>,年龄是<span th:text="${age}"></span>
        </div>

        <div>
            <p>使用内联text</p>
            <p>我是[[${name}]],性别是[[${sex}]]</p>
        </div>
</div>

javascript en línea

例子：
 <script type="text/javascript" th:inline="javascript">
         var myname = [[${
      
      name}]];
         var myage = [[${
      
      age}]];

         //alert("获取的模板中数据 "+ myname + ","+myage)

        function fun(){
      
      
            alert("单击事件，获取数据 "+ myname + ","+ [[${
      
      sex}]])
        }
    </script>

9,7 literales

ejemplo:

 <div style="margin-left: 400px">
       <h3>文本字面量: 使用单引号括起来的字符串</h3>
       <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>

       <h3>数字字面量</h3>
        <p th:if="${20>5}"> 20大于 5</p>

        <h3>boolean字面量</h3>
        <p th:if="${isLogin == true}">用户已经登录系统</p>

        <h3>null字面量</h3>
        <p th:if="${myuser != null}">有myuser数据</p>
    </div>

9.8 Concatenación de cadenas

Hay dos sintaxis para conectar cadenas.

1) La sintaxis utiliza comillas simples para encerrar cadenas y + para conectar otras cadenas o expresiones.

  <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>

2) Sintaxis: Utilice barras verticales dobles, |cadenas y expresiones|

<p th:text="|我是${name},我所在城市${city|">
    显示数据
</p>

ejemplo:

    <div style="margin-left: 400px">
       <h3>字符串连接方式1：使用单引号括起来的字符串</h3>
       <p th:text="'我是'+${name}+',我所在的城市'+${city}">数据显示</p>
        <br/>
        <br/>
        <h3>字符串连接方式2：|字符串和表达式|</h3>
        <p th:text="|我是${name},所在城市${city},其他人${myuser.name}|"></p>
    </div>

9.9 Operadores

算术运 算： + , - - , * , / , %
关系比较 : > , < , >= , <= ( gt , lt , ge , le )
相等判断： == , != ( eq , ne )


<div style="margin-left: 400px">
        <h3>使用运算符</h3>
        <p th:text="${age > 10}">年龄大于 10 </p>
        <p th:text="${ 20 + 30 }">显示运算结果</p>
        <p th:if="${myuser == null}">myuser是null</p>
        <p th:if="${myuser eq null}">myuser是null</p>
        <p th:if="${myuser ne null}">myuser不是null</p>

        <p th:text="${isLogin == true ? '用户已经登录' : '用户需要登录'}"></p>
        <p th:text="${isLogin == true ? ( age > 10 ? '用户是大于10的' : '用户年龄比较小') : '用户需要登录'}"></p>

    </div>

三元运算符：
 表达式  ？ true的结果 : false的结果

三元运算符可以嵌套

9.10 Objetos incorporados

Dirección del documento: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#web-context-namespaces-for-requestsession-attributes-etc.

#request representa HttpServletRequest

#session representa el objeto HttpSession

session representa un objeto Map, que es una representación simple de #session y se utiliza para obtener el valor de la clave especificada en la sesión.

#session.getAttribute(“nombre de inicio de sesión”) == sesión.nombre de inicio de sesión

Estos son objetos integrados y se pueden usar directamente en archivos de plantilla.

例子：
 <div style="margin-left: 350px">
        <h3>内置对象#request,#session，session的使用</h3>
        <p>获取作用域中的数据</p>
        <p th:text="${#request.getAttribute('requestData')}"></p>
        <p th:text="${#session.getAttribute('sessionData')}"></p>
        <p th:text="${session.loginname}"></p>

        <br/>
        <br/>
        <h3>使用内置对象的方法</h3>
        getRequestURL=<span th:text="${#request.getRequestURL()}"></span><br/>
        getRequestURI=<span th:text="${#request.getRequestURI()}"></span><br/>
        getQueryString=<span th:text="${#request.getQueryString()}"></span><br/>
        getContextPath=<span th:text="${#request.getContextPath()}"></span><br/>
        getServerName=<span th:text="${#request.getServerName()}"></span><br/>
        getServerPort=<span th:text="${#request.getServerPort()}"></span><br/>
</div>

9.11 Herramientas integradas

Tipos de herramientas integradas: clases propias de Thymeleaf, que proporcionan algunos métodos de procesamiento para cadenas, fechas y colecciones.

#dates: clase de utilidad para procesar procesadores de fechas

#números: Procesamiento de números

#lists: Procesando colecciones de listas

<div style="margin-left: 350px">
      <h3>日期类对象 #dates</h3>
      <p th:text="${#dates.format(mydate )}"></p>
      <p th:text="${#dates.format(mydate,'yyyy-MM-dd')}"></p>
      <p th:text="${#dates.format(mydate,'yyyy-MM-dd HH:mm:ss')}"></p>
      <p th:text="${#dates.year(mydate)}"></p>
      <p th:text="${#dates.month(mydate)}"></p>
      <p th:text="${#dates.monthName(mydate)}"></p>
      <p th:text="${#dates.createNow()}"></p>
      <br/>

      <h3>内置工具类#numbers，操作数字的</h3>
      <p th:text="${#numbers.formatCurrency(mynum)}"></p>
      <p th:text="${#numbers.formatDecimal(mynum,5,2)}"></p>

      <br/>
      <h3>内置工具类#strings,操作字符串</h3>
      <p th:text="${#strings.toUpperCase(mystr)}"></p>
      <p th:text="${#strings.indexOf(mystr,'power')}"></p>
      <p th:text="${#strings.substring(mystr,2,5)}"></p>
      <p th:text="${#strings.substring(mystr,2)}"></p>
      <p th:text="${#strings.concat(mystr,'---java开发的黄埔军校---')}"></p>
      <p th:text="${#strings.length(mystr)}"></p>
      <p th:text="${#strings.length('hello')}"></p>
      <p th:unless="${#strings.isEmpty(mystr)}"> mystring 不是 空字符串  </p>

      <br/>
      <h3>内置工具类#lists,操作list集合</h3>
      <p th:text="${#lists.size(mylist)}"></p>
      <p th:if="${#lists.contains(mylist,'a')}">有成员a</p>
      <p th:if="!${#lists.isEmpty(mylist)}"> list 集合有多个成员</p>

      <br/>
      <h3>处理null</h3>
      <p th:text="${zoo?.dog?.name}"></p>

  </div>

9.12 Plantillas personalizadas

Las plantillas son contenido reutilizable, definido una vez y utilizado varias veces en otros archivos de plantilla.

Uso de plantilla:

1. Definir plantilla

2. Utilice plantillas

Sintaxis de definición de plantilla:

th:fragment="模板自定义名称"

例如：
<div th:fragment="head">
    <p>
        动力节点-java开发
    </p>
    <p>
        www.bjpowernode.com
    </p>
</div>

Sintaxis de plantilla de referencia:

1) ~{templatename :: selector}
   templatename:  文件名称
   selector： 自定义模板名称
2）templatename :: selector
   templatename:  文件名称
   selector： 自定义模板名称

对于使用模板：有包含模板（th:include）， 插入模板(th:insert)

Resumen del capítulo 10

10.1 Anotaciones

Primavera + PrimaveraMVC + SpringBoot

创建对象的：
@Controller: 放在类的上面，创建控制器对象，注入到容器中
@RestController: 放在类的上面，创建控制器对象，注入到容器中。
             作用：复合注解是@Controller , @ResponseBody, 使用这个注解类的，里面的控制器方法的返回值                   都是数据

@Service ： 放在业务层的实现类上面，创建service对象，注入到容器
@Repository : 放在dao层的实现类上面，创建dao对象，放入到容器。 没有使用这个注解，是因为现在使用MyBatis框               架，  dao对象是MyBatis通过代理生成的。 不需要使用@Repository、 所以没有使用。
@Component:  放在类的上面，创建此类的对象，放入到容器中。 

赋值的：
@Value ： 简单类型的赋值， 例如 在属性的上面使用@Value("李四") private String name
          还可以使用@Value,获取配置文件者的数据（properties或yml）。 
          @Value("${server.port}") private Integer port

@Autowired: 引用类型赋值自动注入的，支持byName, byType. 默认是byType 。 放在属性的上面，也可以放在构造             方法的上面。 推荐是放在构造方法的上面
@Qualifer:  给引用类型赋值，使用byName方式。   
            @Autowird, @Qualifer都是Spring框架提供的。

@Resource ： 来自jdk中的定义， javax.annotation。 实现引用类型的自动注入， 支持byName, byType.
             默认是byName, 如果byName失败， 再使用byType注入。 在属性上面使用


其他：
@Configuration ： 放在类的上面，表示这是个配置类，相当于xml配置文件

@Bean：放在方法的上面， 把方法的返回值对象，注入到spring容器中。

@ImportResource ： 加载其他的xml配置文件， 把文件中的对象注入到spring容器中

@PropertySource ： 读取其他的properties属性配置文件

@ComponentScan： 扫描器 ，指定包名，扫描注解的

@ResponseBody: 放在方法的上面，表示方法的返回值是数据， 不是视图
@RequestBody : 把请求体中的数据，读取出来， 转为java对象使用。

@ControllerAdvice:  控制器增强， 放在类的上面， 表示此类提供了方法，可以对controller增强功能。

@ExceptionHandler : 处理异常的，放在方法的上面

@Transcational :  处理事务的， 放在service实现类的public方法上面， 表示此方法有事务


SpringBoot中使用的注解
    
@SpringBootApplication ： 放在启动类上面， 包含了@SpringBootConfiguration
                          @EnableAutoConfiguration， @ComponentScan


    
MyBatis相关的注解

@Mapper ： 放在类的上面 ， 让MyBatis找到接口， 创建他的代理对象    
@MapperScan :放在主类的上面 ， 指定扫描的包， 把这个包中的所有接口都创建代理对象。 对象注入到容器中
@Param ： 放在dao接口的方法的形参前面， 作为命名参数使用的。
    
Dubbo注解
@DubboService: 在提供者端使用的，暴露服务的， 放在接口的实现类上面
@DubboReference:  在消费者端使用的， 引用远程服务， 放在属性上面使用。
@EnableDubbo : 放在主类上面， 表示当前引用启用Dubbo功能。