Inicio rápido de Springboot2.0 (Capítulo 1)

1. Introducción a SpringBoot

1.1, revisa qué es Spring

Spring es un marco de código abierto, un marco de desarrollo Java liviano que surgió en 2003, autor: Rod Johnson.
Spring se creó para resolver la complejidad del desarrollo de aplicaciones a nivel empresarial y simplificar el desarrollo.

1.2, Cómo Spring simplifica el desarrollo de Java

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

1. Programación ligera y mínimamente invasiva basada en POJO, todo es un bean;
2. El acoplamiento flexible se logra mediante IOC, inyección de dependencia (DI) y orientado a interfaz;
3. Programación declarativa basada en aspectos (AOP) y convenciones;
4. Reducir códigos de estilo mediante facetas y plantillas, RedisTemplate, xxxTemplate;

1.3, ¿qué es SpringBoot?

Spring Boot es un marco basado en Spring proporcionado por el equipo de Pivotal, que utiliza una forma específica de configuración, de modo que los desarrolladores ya no necesitan definir una configuración repetitiva. Spring Boot integra la mayoría de los marcos de desarrollo más populares actualmente, al igual que Maven integra todos los paquetes JAR, Spring Boot integra casi todos los marcos, lo que permite a los desarrolladores crear rápidamente proyectos Spring.

Ventajas clave de Spring Boot:
为所有Spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化Web项目
没有冗余代码生成和XML配置的要求

Dos, hola mundo

2.1, trabajo de preparación

Aprenderemos cómo crear rápidamente una aplicación Spring Boot e implementar un procesamiento de solicitud Http simple. Obtenga una comprensión preliminar de Spring Boot a través de este ejemplo y experimente su estructura simple y su rápido desarrollo.

Mi entorno está preparado:
依赖版本jdk1.8以上
Maven-3.2以上
SpringBoot 2.x

herramientas de desarrollo:
IDEA

2.2, crear una descripción básica del proyecto

1. Primero cree un proyecto maven
2. Agregue el proyecto principal de Springboot y las dependencias correspondientes en el archivo maven pom

¡Se crea un proyecto tan maven!
Luego agregue el proyecto principal de Springboot y las dependencias correspondientes al archivo pom

    <!--  继承默认值为Spring Boot  -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>

    <dependencies>
        <!--    导入Springweb的依赖    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

2.3, cree el primer programa Hola, SpringBoot

1. Coloque la clase de inicio en el directorio de nivel superior
2. Anotaciones de uso común
La anotación de clase de inicio
@SpringBootApplication es una anotación compuesta. @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan
@Configuration: @Configuration está marcado en la clase, lo que equivale a usar esta clase como un archivo de configuración xml de Spring (beans), y su función es configurar el contenedor de Spring (aplicación). contexto)
@EnableAutoConfiguration: activa la configuración automática. Algunas clases de configuración automática de spring.facotries en MATA-INF
@ComponentScan: anotaciones de escaneo. Si no configura el paquete base, todas las clases de la misma clase y subdirectorios de la clase de anotación @ComponentScan se escanearán de forma predeterminada. Entonces coloque la clase de inicio en el directorio de nivel superior.
Las anotaciones de la capa de control
@RestController y @RequestMapping son anotaciones de SpringMVC, no específicas de Springboot
@RestController = @Controller + @ResponseBody

HelloController类

package com.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // 控制类
public class HelloController {
    
    

    @RequestMapping("/")
    public String sayHello(){
    
    
        return "hello,SpringBoot!!";
    }
}

在外面创建一个springboot的启动类

DemoApplication启动类

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// @SpringBootApplication是一个复合型注解，通常情况下，我们会把启动类放到项目的顶级目录
// 注意：SpringBootApplication中的 @ComponentScan 会默认扫描本类所在包以下的子包
@SpringBootApplication 
public class DemoApplication {
    
    

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

La operación es exitosa, de la siguiente manera:

Tres, solicitud de obtención de interfaz HTTP

3.1, protocolo de descanso, obtenga parámetros @PathVariable de la ruta

    /**
     * 功能描述: restful 协议。从路径中获取参数
     * 1.接口中的参数定义，建议使用下划线隔开，不再使用驼峰
     * 2.path="/{cityid}/{userid}" 标识路径中那些是参数
     * 3.method=RequestMethod.GET 只处理get请求
     * 4.@PathVariable("cityid") 从路径中取出参数值
     * @return
     * */

    @RequestMapping("/{cityid}/{userid}")
    public Object test1(
            @PathVariable("cityid") String cityId,
            @PathVariable("userid") String userId){
    
    
        return cityId + "--" + userId;
    }

3.2, configuración predeterminada del parámetro @RequestParam

    /**
     *
     * 参数的默认值设置
     * 添加@RequestParam 默认此参数是必填项
     * @return
     * **/
    @RequestMapping("/test2")
    public Object test2(@RequestParam(required = false,defaultValue = "1") Integer pageNo){
    
    
        return pageNo;
    }

Lo anterior muestra el valor predeterminado. Si le asigna un valor, el valor asignado reemplazará el valor predeterminado, de la siguiente manera:

3.3, pase el objeto bean por valor (los datos se obtienen del cuerpo) @RequestBody

    /**
     *
     * 测试@RequestBody。要从请求体中获取数据
     * 有如下结果
     * 1.数据要在请求体中。
     * 2.数据的格式为JSON。content-type 的值是application/json
     * 3.只有post请求才允许在body中设置数据
     * **/
    @RequestMapping("/test3")
    public Object test3(@RequestBody Person person){
    
    
        return person.getUserId() + "-----" + person.getAge();
    }

3.4, obtenga información del encabezado de la solicitud http, por ejemplo, obtenga el token @RequestHeader

    /**
     * 从请求头获取数据
     * 一般请求头中获取一些认证信息，例如token
     * **/
    @RequestMapping("/test4")
    public Object test4(@RequestHeader String access_token){
    
    
        return access_token;
    }

Cuarto, la introducción del marco json de uso común y el procesamiento de los resultados de retorno de jackson.

简介：介绍常用json框架和注解的使用，自定义返回json结构和格式

1. Marcos de trabajo comunes como Ali fastjson, Google gosn, etc.
   Serialización de JavaBean en json Rendimiento: Jackson > FastJson > Gson > Json-lib La misma estructura
   Las bibliotecas Jackson, FastJson y Gson tienen sus propias ventajas y especialidades
   Espacio para el tiempo, el tiempo por el espacio

2. Jackson maneja los
campos especificados automáticos relacionados para que no regresen: @JsonIgnore
especifica el formato de fecha: @JsonFormat(pattern="yyyy-MM-dd hh:mm:ss", locale="zh", timezone="GMT+8" )
vacía La cadena no se devuelve: @JsonInclude(JsonInclude.Include.NON_NULL)
especifica el alias: @JsonProperty Nota: Después de usar el alias, la clave en la solicitud también debe usar el alias

4.1, paquete de devolución unificado springboot

创建一个util包

然后创建一个ResultUtil工具类

package com.demo.util;

import lombok.Data;

import java.io.Serializable;

@Data
public class ResultUtil<T> implements Serializable {
    
    

    public static final Integer SUCCESS_CODE = 2000;
    public static final Integer FAIL_CODE = 4000;
    public static final String SUCCESS_MESSAGE = "success";
    public static final String FAIL_MESSAGE = "fail";
    /**
     * 返回状态码
     */
    private Integer code;
    /**
     * 返回信息
     */
    private String message;

    /**
     * 返回数据
     */
    private T data;

    private ResultUtil() {
    
    
    }

    public static <T> ResultUtil<T> success() {
    
    
        ResultUtil<T> resultUtil = new ResultUtil<>();
        resultUtil.setCode(SUCCESS_CODE);
        resultUtil.setMessage(SUCCESS_MESSAGE);
        return resultUtil;
    }

    public static <T> ResultUtil<T> success(T data) {
    
    
        ResultUtil<T> resultUtil = success();
        resultUtil.setData(data);
        return resultUtil;
    }

    public static <T> ResultUtil<T> success(String message, T data) {
    
    
        ResultUtil<T> resultUtil = success();
        resultUtil.setMessage(message);
        resultUtil.setData(data);
        return resultUtil;
    }

    public static <T> ResultUtil<T> success(Integer code, String message, T data) {
    
    
        ResultUtil<T> resultUtil = new ResultUtil<>();
        resultUtil.setCode(code);
        resultUtil.setMessage(message);
        resultUtil.setData(data);
        return resultUtil;
    }

    public static <T> ResultUtil<T> fail() {
    
    
        ResultUtil<T> resultUtil = new ResultUtil<>();
        resultUtil.setCode(FAIL_CODE);
        resultUtil.setMessage(FAIL_MESSAGE);
        return resultUtil;
    }

    public static <T> ResultUtil<T> fail(T data) {
    
    
        ResultUtil<T> resultUtil = fail();
        resultUtil.setData(data);
        return resultUtil;
    }

    public static <T> ResultUtil<T> fail(String message, T data) {
    
    
        ResultUtil<T> resultUtil = fail();
        resultUtil.setMessage(message);
        resultUtil.setData(data);
        return resultUtil;
    }

    public static <T> ResultUtil<T> fail(Integer code, String message) {
    
    
        ResultUtil<T> resultUtil = fail();
        resultUtil.setCode(code);
        resultUtil.setMessage(message);
        return resultUtil;
    }

    public static <T> ResultUtil<T> fail(Integer code, String message, T data) {
    
    
        ResultUtil<T> resultUtil = new ResultUtil<>();
        resultUtil.setCode(code);
        resultUtil.setMessage(message);
        resultUtil.setData(data);
        return resultUtil;
    }

}

Este formato incluye principalmente 3 partes:
1.código: código de estado, el código de estado de varios resultados devueltos lo define uniformemente el backend para juzgar el éxito o el fracaso
2.mensaje: información de descripción, información de solicitud
3.datos: datos devueltos, como una lista de datos

Person.java实体类修改一下不在需要get,set方法，但是得加上@Data

package com.demo.bean;

import com.fasterxml.jackson.annotation.*;
import lombok.Data;

import java.io.Serializable;
import java.util.regex.Pattern;

@Data
public class Person implements Serializable {
    
    


    private String userId;

    private int age;

}

    /**
     *
     * 测试@RequestBody。要从请求体中获取数据
     * 有如下结果
     * 1.数据要在请求体中。
     * 2.数据的格式为JSON。content-type 的值是application/json
     * 3.只有post请求才允许在body中设置数据
     * **/
    @RequestMapping("/test3")
    public Object test3(@RequestBody Person person){
    
    
        return ResultUtil.success(person);
    }

El resultado es el siguiente:

Bajo la premisa de escribir así, agregue una dependencia al pom

por fin

送大家一句话：你大好青春，怕什么，只管向前跑