Entrada de base cero de SpringBoot para dominar la generación de código integrado MyBatis-plus

1. Introducción a Spring Boot

1. Ejecución independiente del proyecto Spring Spring Boot se puede ejecutar de forma independiente en forma de un paquete jar, y el proyecto Spring Boot solo se puede ejecutar mediante el comando "java–jar xx.jar".
2. Contenedor de servlet integrado Spring Boot utiliza un contenedor de servlet integrado (como Tomcat, Jetty o Undertow, etc.) y no es necesario empaquetar la aplicación como un paquete WAR.
3. Proporcionar elementos iniciales para simplificar la configuración de Maven Spring Boot proporciona una serie de modelos de objetos de proyecto (POMS) "iniciales" para simplificar la configuración de Maven.
4. Proporciona una gran cantidad de configuraciones automáticas Spring Boot proporciona una gran cantidad de configuraciones automáticas predeterminadas para simplificar el desarrollo del proyecto, y los desarrolladores también modifican las configuraciones predeterminadas a través de archivos de configuración.
5. Monitoreo de aplicaciones autónomo Spring Boot puede proporcionar monitoreo para proyectos en ejecución. 6. Sin generación de código ni configuración xml Spring Boot no requiere ninguna configuración xml para implementar todas las configuraciones de Spring.

2. Construya Spring Boot

SpringBoot utiliza un contenedor integrado (el contenedor predeterminado Tomcat) para la implementación, por lo que no es necesario configurar Tomcat en la idea, simplemente ejecute el método principal de la clase de inicio directamente.

efecto de inicio

Busque esta línea, lo que significa que la puesta en marcha fue exitosa. Por defecto se ejecuta en el puerto 8080

escribir un caso

1. El controlador devuelve json

@RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
public Map<String,Object> test(){
    
    

        Map<String,Object> map = new HashMap<>();
        map.put("msg","测试成功！");

        return map;
    }

4. Archivo de configuración SpringBoot - YAML

5. Enlace de configuración de Spring Boot

El llamado "vinculación de configuración" consiste en vincular el valor en el archivo de configuración con la propiedad correspondiente en JavaBean. Por lo general, colocaremos cierta información de configuración (por ejemplo, configuración de la base de datos) en el archivo de configuración, luego leeremos el archivo de configuración a través del código Java y encapsularemos la configuración especificada en el archivo de configuración en JavaBean (clase de entidad).

1. Utilice la anotación @ConfigurationProperties

archivo yml

# 测试配置
person:
  name: 蔡徐坤
  age: 180
  birth: 1994/11/12
  list:
    - a
    - b
    - c
  map:
   name: 宇将军
   age: 90
  son:
   name: 阿耶夫
   age: 18

clase java

@Data
@Component
@ConfigurationProperties(prefix = "person")
public class Person implements Serializable {
    
    

    private String name;
    private int age;
    private Date birth;
    private List<String> list;
    private Map<String,Object> map;
    private Person son;

}

2. Utilice la anotación @Value para obtener la configuración.

@Data
@Component
public class Person implements Serializable {
    
    

    @Value("${person.map.name}")
    private String name;
    private int age;
    private Date birth;
    private List<String> list;
    private Map<String,Object> map;
    private Person son;

}

3. Cargue el contenido del archivo de configuración excepto el archivo de configuración de la aplicación.

Utilice @PropertySource

Cree un archivo de configuración aabbcc.properties y escriba el contenido

cxk.name: giao哥

método de carga

@Data
@Component
@PropertySource(value= "classpath:aabbcc.properties")
public class Person implements Serializable {
    
    

    @Value("${cxk.name}")
    private String name;
    private int age;
    private Date birth;
    private List<String> list;
    private Map<String,Object> map;
    private Person son;

}

6. SpringBoot carga el archivo de configuración de Spring

1. Anotación @ImportResource

Cree un archivo de configuración xml en el directorio de recursos

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 注册一个person的实例 -->
    <bean id="person" class="com.example.springbootdemo2023.core.dto.Person" />

</beans>

Agregue la anotación @ImportResource al encabezado de la clase de inicio

@ImportResource(locations = "classpath:spring.xml")//导入spring配置文件
@SpringBootApplication
public class SpringBootDemo2023Application {
    
    

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

}

prueba de uso

@Controller
@RequestMapping("/login")
public class LoginController {
    
    

    @Autowired
    private Person person;


    @RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
    public Map<String,Object> test(){
    
    

        Map<String,Object> map = new HashMap<>();
        map.put("msg","测试成功！");

        System.out.println(person);

        return map;
    }

Imprimir

Person(name=null, age=0, birth=null, list=null, map=null, son=null)

2. Uso de la anotación Spring para importar el método de configuración

clase de configuración

@Configuration
public class MyConfig {
    
    

    //等同于 <bean id="getPerson" class="com.example.springbootdemo2023.core.dto.Person" />
    @Bean
    public Person getPerson(){
    
    
        Person person = new Person();
        person.setName("gaojingbo");
        return person;
    }

}

7. Configuración multientorno SpringBoot

Configuración del entorno esclavo + configuración del entorno principal = configuración completa del proyecto de arranque

1. Crear archivos de configuración en diferentes entornos.

Reglas creadas:

Entorno de desarrollo: application-dev.yml

Entorno de prueba: aplicación-test.yml

Entorno de producción: application-prod.yml

aplicación-dev.yml

# 开发环境配置
server:
  port: 8090

prueba-aplicación.yml

# 测试环境配置
server:
  port: 8100

aplicación-prod.yml

# 生产环境配置
server:
  port: 9010

Archivo de configuración principal: application.yml

El archivo de configuración del entorno principal puede escribir algunos elementos de configuración que no cambiarán

# 主配置文件

# 激活环境配置
spring:
  profiles:
    active: test

2. Definir el método para activar la configuración del entorno.

1. Establecer por parámetro de comando al ejecutar el paquete jar

2. La configuración de herramientas se puede utilizar durante el desarrollo de ideas.

3. Utilice la configuración de parámetros de jvm al empaquetar y ejecutar

8. Prioridad de carga del archivo de configuración predeterminado de SpringBoot

Archivos de configuración en el directorio raíz > archivos de configuración en la carpeta de configuración en el directorio classpath > archivos de configuración en el directorio classpath

Toda la prioridad de escritura: (cuanto menor sea el número de serie, mayor será la prioridad)

1. ​ archivo:./config/
2. archivo:./config/*/
3. archivo:./
4. ruta de clase:/config/
5. ruta de clases:/

Nota: archivo: se refiere al directorio raíz del proyecto actual; classpath: se refiere al classpath del proyecto actual, es decir, el directorio de recursos.

1. Cuando se mezclan la configuración de anotaciones y la introducción de la configuración externa, la prioridad de carga completa

1. parámetros de línea de comando
2. Propiedades JNDI de java:comp/env
3. Propiedades del sistema Java (System.getProperties())
4. variables de entorno del sistema operativo
5. Valores de propiedad Random.* configurados por RandomValuePropertySource
6. Archivos de configuración (archivos YAML, archivos de propiedades)
7. El archivo de configuración especificado por @PropertySource en la clase de anotación @Configuration
8. Propiedades predeterminadas especificadas por SpringApplication.setDefaultProperties

9. Registro de uso de SpringBoot

1. Registro de configuración: agregue el siguiente contenido al archivo de configuración de springboot

# 日志配置
logging:
  level:
    com.example.springbootdemo2023: debug # 描述根包下所有的类都要进行日志记录
  file:
    path: F:\idea_logs\SpringBootDemo2023 # 离线生成的日志文件位置
  pattern:
    # 控制台日志的模板效果
    console: "%red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %yellow(%-5level) %logger{50} - %m%n" 
    # 保存到文件中的日志效果
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} - %m%n"

10. Interceptor de arranque de primavera

1. Definir el interceptor

Es exactamente lo mismo que escribir SpringMVC.

/**
 * 模块名称：登录会话验证拦截器
 * 模块类型：
 * 编码人：高靖博
 * 创建时间：2023/3/1
 * 联系电话：18587388612
 */
public class LoginInterceptor implements HandlerInterceptor {
    
    

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    

        System.out.println("登录拦截器被调用！");
        return true;
    }
}

2. Registrar interceptor

Cree una clase de configuración que implemente la interfaz WebMvcConfigurer (una clase anotada con @Configuration), anule el método addInterceptors() y llame al método registro.addInterceptor() en este método para registrar el interceptor personalizado en el contenedor.

InterceptorRegistration configura las reglas del interceptor:

addPathPatterns: establece las reglas para ingresar al interceptor

excluirPathPatterns: establece reglas que no ingresan al interceptor

Nota: Si la ruta no existe, si es 404, definitivamente ingresará al interceptor.

// 1. 实现WebMvcConfigurer 接口
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    
    

    //2.重写addInterceptors方法
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    
        //3. 注册自定义编写的拦截器
        // 调用addInterceptor，参数传递拦截器实例
        InterceptorRegistration ic = registry.addInterceptor(new LoginInterceptor());
        //设置拦截器的拦截规则
        ic.addPathPatterns("/**");
        //放行拦截器（登录页面、登录请求、静态资源（js、css、img、video、font（字体文件））、阿里druid连接池监控中心、swaggerui）
        ic.excludePathPatterns(
                "/login/test2",
                "/sys/user/doLogin",
                "/js/**",
                "/css/**",
                "/imgs/**",
                "/druid/**",
                "/swagger-ui.html",
                "/v2/**",
                "/webjars/**",
                "/swagger-resources/**",
                "/sys/user/captcha",
                "/sys/platform/**",
                "/sys/files/**");
    }
}

11. SpringBoot integra el grupo de conexiones Druid

1. Introducir dependencias

<!-- 和数据源相关操作必须引入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
<!-- 数据源依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

2. Configure el archivo de configuración springboot

# spring数据源配置
spring:
  datasource:
    # druid连接池
    type: com.alibaba.druid.pool.DruidDataSource
    # mysql驱动
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库连接地址
    url: jdbc:mysql://localhost:3306/javatest?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    # 用户名、密码
    username: root
    password: cxk666
    # druid连接池配置
    # 初始化连接池最大值，连接中活跃数量最大值
    initial-size: 10
    max-active: 8
    # 获取连接等待的最长时间（毫秒）
    max-wait: 60000
    # 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
    test-while-idle: true
    # 既作为检测的间隔时间又作为testWhileIdel执行的依据
    time-between-eviction-runs-millis: 60000
    # 销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接(配置连接在池中的最小生存时间)
    min-evictable-idle-time-millis: 30000
    # 用来检测数据库连接是否有效的sql 必须是一个查询语句(oracle中为 select 1 from dual)
    validation-query: select 1 from dual
    # 申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
    test-on-borrow: false
    # 归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
    test-on-return: false
    # 是否缓存preparedStatement, 也就是PSCache,PSCache对支持游标的数据库性能提升巨大，比如说oracle,在mysql下建议关闭。
    pool-prepared-statements: false
    # 置监控统计拦截的filters，去掉后监控界面sql无法统计，stat: 监控统计、Slf4j:日志记录、waLL: 防御sqL注入
    filters: stat,wall,slf4j
    # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
    max-pool-prepared-statement-per-connection-size: -1
    # 合并多个DruidDataSource的监控数据
    use-global-data-source-stat: true
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connect-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    web-stat-filter:
      # 是否启用StatFilter默认值true
      enabled: true
      # 添加过滤规则
      url-pattern: /*
      # 忽略过滤的格式
      exclusions: /druid/*,*.js,*.gif,*.jpg,*.png,*.css,*.ico
    stat-view-servlet:
      # 是否启用StatViewServlet默认值true
      enabled: true
      # 访问路径为/druid时，跳转到StatViewServlet
      url-pattern: /druid/*
      # 是否能够重置数据
      reset-enable: false
      # 需要账号密码才能访问控制台，默认为root
      login-username: admin
      login-password: 123456
      # IP白名单
      allow: 127.0.0.1
      # IP黑名单（共同存在时，deny优先于allow）
      deny:

12. SpringBoot integra MyBatis

1. Introducir dependencias

<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

2. Modifique el archivo de configuración SpringBoot

mybatis:
  #xml文件路径映射（xml文件要和接口文件同名）
  mapper-locations: com/huawei/bootdemo2/mybatis/dao/*.xml
  #dto别名映射
  type-aliases-package: com.huawei.bootdemo2.mybatis.domain
  configuration:
    map-underscore-to-camel-case: true #驼峰映射规则   
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #mybatis默认日志

3. Agregue una anotación para escanear la interfaz del asignador en la clase de inicio.

@MapperScan("com.example.springbootdemo2023.mybatis.dao")// mapper接口所在的包
@SpringBootApplication
public class SpringBootDemo2023Application {
    
    

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

}

4. Escriba la interfaz y el archivo xml de mybatis normalmente.

Utilice el generador de código para hacerlo, ignorando

5. Configurar el empaquetado de recursos estáticos de maven

Debido a que el archivo xml existe en el directorio del código fuente de Java, maven solo empaquetará el archivo java de forma predeterminada.

Configuración en pom.xml

<build>
		...
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.yml</include>
                    <include>**/*.yaml</include>
                    <include>**/banner.txt</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

5. Prueba

Este caso es para introducir la interfaz del mapeador en el controlador, que debe superponerse en capas durante el desarrollo.

@Controller
@RequestMapping("/login")
public class LoginController {
    
    

    @Autowired
    private TGoodsMapper goodsMapper;

    @RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
    public TGoods test(){
    
    

        TGoods tGoods = goodsMapper.selectByPrimaryKey("101");

        return tGoods;
    }


}

6. SpringBoot integra la herramienta de paginación Mybatis

PáginaHepler

1. Introducir dependencias

<!-- 分页插件pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.3.0</version>
<!-- 排除依赖，因为pageHelper是和Mybatis天然集成所以强依赖mybatis，但是我们项目中已经有了mybatis依赖就去掉 -->
            <exclusions>
                <exclusion>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <groupId>org.mybatis.spring.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>

2. Cree un objeto de conjunto de resultados paginado

/**
 * 模块名称：接收分页的结果DTO
 * 模块类型：
 * 编码人：高靖博
 * 创建时间：2023/3/1
 * 联系电话：18587388612
 */
@Data
public class MyPager<T> implements Serializable {
    
    

    private int page;//结果的页码
    private int pageSize;//每页显示行数
    private List<T> rows;//分页当前页的结果集
    private long total;//不分页所有数据总和（用于页码生成）
    
}

3. Cree una entidad que reciba parámetros de consulta de paginación.

/**
 * 模块名称：用于接收分页查询参数
 * 模块类型：
 * 编码人：高靖博
 * 创建时间：2023/3/1
 * 联系电话：18587388612
 */
@Data
public class MyPageBand implements Serializable {
    
    
    
    private int page;
    private int size;
    
}

4. Si hay un problema de dependencia circular

Si el jdk que utiliza es la versión 8 ~ 10, solo puede reducir la versión de springBoot a 2.5.5

5. Prueba

@Autowired
    private TGoodsMapper goodsMapper;

    @RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
    public MyPager test(MyPageBand page){
    
    

        //创建条件对象
        TGoodsExample example = new TGoodsExample();

        //创建mybatis条件对象
        TGoodsExample.Criteria criteria = example.createCriteria();

//        criteria.andNameLike("%六个核弹%");
//        criteria.andPriceBetween(new BigDecimal(20),new BigDecimal(30));

        //1.创建分页对象
        MyPager<TGoods> myPager = new MyPager<TGoods>();
        //2.调用分页工具设置分页参数(页码,每页显示多少行数据)
        Page<TGoods> goodsPage = PageHelper.startPage(page.getPage(), page.getSize());

        //3.执行mapper的查询接口操作
        goodsMapper.selectByExample(example);// !!!!!!!

        List<TGoods> result = goodsPage.getResult();
        long total = goodsPage.getTotal();//数据查询的所有行数值

        myPager.setTotal(total);
        myPager.setRows(result);
        myPager.setPage(page.getPage());
        myPager.setPageSize(page.getSize());

        return myPager;
    }

13. SpringBoot integra MyBatis-plus

Todo nace de la sencillez.

1. Reemplazar dependencias

<!-- 删除mybati、pagehepler依赖 -->

<!-- 新：版本升级 mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>

2. Modifique el archivo de configuración SpringBoot

#mybatis-plus配置
mybatis-plus:
  #dto别名映射
  type-aliases-package: com.example.springbootdemo2023.mybatis.domain
  #xml文件路径映射（xml文件要和接口文件同名）
  mapper-locations: com/example/springbootdemo2023/mybatis/dao/**/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启日志
    map-underscore-to-camel-case: false
  # 全局变量配置
  # 逻辑删除-如：每个表中都有一个通用的字段isDelete描述当前数据是否被删除，1：已删除 0：未删除
  global-config:
    db-config:
      # 当逻辑删除应该设置什么值：1
      logic-delete-value: 1
      logic-not-delete-value: 0
      logic-delete-field: isDelete

3. Defina la entidad de la tabla de la base de datos myBatis-plus

@Data
@TableName("t_goods")
public class TGoods implements Serializable {
    
    
    
    // id一定要标注，也就表明：每个表都必须有主键
    @TableId(value = "goodsID",type = IdType.NONE)
    private String goodsID;
    private String name;
    private BigDecimal price;
    private String typeName;
}

4. Utilice MyBatis-plus para definir el método de la interfaz del mapeador (modificado)

1. Cree una interfaz mybatismapper para integrar la interfaz BaseMapper de mybatis-plus
2. Defina genéricos en la interfaz: los genéricos son los tipos de entidades de base de datos correspondientes a las operaciones actuales de la interfaz del asignador.

baseMapper ha preparado todos los métodos de interfaz comunes de antemano (adición, eliminación, modificación, consulta, consulta página por página)

El contenido que usted mismo debe implementar manualmente se define en la interfaz y el archivo xml.

@Mapper
public interface TGoodsMapper extends BaseMapper<TGoods> {
    
    
    
    
    
}

5. Defina un archivo xml vacío con el mismo nombre que la interfaz del asignador.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.springbootdemo2023.mybatis.dao.goods.TGoodsMapper">

</mapper>

Siempre que se completen los dos pasos 3 y 4 anteriores, mybatis-plus ha completado la inyección automática de generación de código.

6. Prueba

@Autowired
    private TGoodsMapper goodsMapper;

    @RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
    public MyResult test(MyPageBand page){
    
    

        MyResult result = new MyResult();

        TGoods tGoods = goodsMapper.selectById("101");

        result.setData(tGoods);

        return result;
    }

14. MyBatis-Plus

1. mybatis-plus: Acerca del método de definición de la clase de entidad DO (debe haber una clase en Java correspondiente a la tabla en la base de datos)
2. mybatis-plus: archivo de mapeo del mapeador y escritura de interfaz
3. MyBatis-plus: Realice la adición, eliminación, modificación y consulta de código SQL cero (utilizando el método en baseMapper)
4. Configuración del generador de códigos Mybatis-plus

1. Reglas de definición de la entidad MyBatis-plus-DO

1. @TableName (nombre de la tabla): debe escribirse

Implementar mapeo uno a uno de clases y tablas

@Data
@TableName("t_goods")
public class TGoods implements Serializable {
    
    
   ...   
}

2. @TableId: describe el campo de clave principal; debe escribirse

parámetro de valor: especifica el nombre del campo de clave principal en la tabla asignada

parámetro de tipo: se utiliza para definir el tipo de clave principal (la estrategia de clave principal usa IdType para definir)

IdType.AUTO: utilice el modo de clave de incremento automático propio de la base de datos para realizar la generación de identificación. Asegúrese de recordar que la base de datos debe configurarse en incremento automático para que sea efectiva

​ IdType.NONE: No implementa la generación automática de claves primarias, sin restricciones

IdType.INPUT : no implementa la generación automática de clave primaria, restringe este atributo para que tenga un valor y permite a los desarrolladores definirlo ellos mismos.

​ IdType.ASSIGN_ID: genera un valor entero incrementado automáticamente a través del mecanismo mybatis

​IdType.ASSIGN_UUID : genera valor -UUID a través del mecanismo mybatis

@Data
@TableName("t_goods")
public class TGoods implements Serializable {
    
    

    // id一定要标注，也就表明：每个表都必须有主键
    @TableId(value = "goodsID",type = IdType.ASSIGN_UUID)
    private String goodsID;
    private String name;
    private BigDecimal price;
    private String typeName;
}

3. @TableField: descripción de la definición de campos ordinarios; no es obligatorio

parámetro de valor: especifica el nombre del campo asignado a él en la tabla asignada

existe parámetro: (booleano)

​ falso: este campo puede no existir en la tabla correspondiente de la entidad actual, para evitar que mybatis genere los códigos de adición, eliminación y modificación de este campo.

verdadero: este campo existe en la tabla correspondiente de la entidad actual y verdadero es el valor predeterminado

parámetro de relleno: función de relleno (los nodos eliminados también activarán la estrategia de modificación ACTUALIZAR)

​ FieldFill.INSERT: Activa la estrategia de llenado al insertar

​ FieldFill.UPDATE: Activa la estrategia de llenado cuando se modifica

​ FieldFill.INSERT_UPDATE: activa la estrategia de llenado cuando se modifica o agrega

@Data
@TableName("t_goods")
public class TGoods implements Serializable {
    
    

    // id一定要标注，也就表明：每个表都必须有主键
    @TableId(value = "goodsID",type = IdType.ASSIGN_UUID)
    private String goodsID;
    private String name;
    private BigDecimal price;
    private String typeName;

    //当操作新增时，该字段自动填写当前时间
    @TableField(value = "insertTime",fill = FieldFill.INSERT)// 在什么时候要做某个事情
    private Date insertTime;

    @TableField(value = "updateTime",fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

}

Cuando se define la estrategia de llenado, la forma de llenar debe definirse e implementarse manualmente.

/**
 * 模块名称：mybatis-plus字段自动填充策略实现
 * 模块类型：
 * 编码人：高靖博
 * 创建时间：2023/3/2
 * 联系电话：18587388612
 */
@Component
public class MyBatisPlusFillHandler implements MetaObjectHandler {
    
    

    //当触发新增填充策略时会调用的方法
    @Override
    public void insertFill(MetaObject metaObject) {
    
    
        //要给表中的insertTime字段设置一个当前系统时间
        setFieldValByName("inserTime",new Date(),metaObject);

    }

    //当触发修改填充策略时会调用的方法
    @Override
    public void updateFill(MetaObject metaObject) {
    
    
        //要给表中的insertTime字段设置一个当前系统时间
        setFieldValByName("updateTime",new Date(),metaObject);
    }
}

código de prueba

@Autowired
    private TGoodsMapper goodsMapper;

    @RequestMapping(value = "/test",method = RequestMethod.GET)
    @ResponseBody
    public MyResult test(MyPageBand page){
    
    

        MyResult result = new MyResult();

        TGoods tGoods = new TGoods();
        tGoods.setName("iPhone1000");
        tGoods.setPrice(new BigDecimal("50"));
        tGoods.setTypeName("手机");

        int insert = goodsMapper.insert(tGoods);

        result.setData(insert);

        return result;
    }

    @RequestMapping(value = "/test2",method = RequestMethod.GET)
    @ResponseBody
    public MyResult test2(MyPageBand page){
    
    

        MyResult result = new MyResult();

        TGoods tGoods = new TGoods();
        tGoods.setGoodsID("101");
        tGoods.setName("switch");
        tGoods.setPrice(new BigDecimal("2"));

        int insert = goodsMapper.updateById(tGoods);

        result.setData(insert);

        return result;
    }

    @RequestMapping(value = "/test3",method = RequestMethod.GET)
    @ResponseBody
    public MyResult test3(MyPageBand page){
    
    

        MyResult result = new MyResult();

        int insert = goodsMapper.deleteById("101");

        result.setData(insert);

        return result;
    }

2. mybatis-plus: archivo de mapeo del mapeador y escritura de interfaz

Archivo de interfaz (XXXMapper.java)

Implementar la interfaz BaseMapper

BaseMapper proporciona métodos para agregar, eliminar, modificar, verificar y paginar según definiciones genéricas.

BaseMapper源码
    public interface BaseMapper<T> extends Mapper<T> {
    
    
    int insert(T entity);

    int deleteById(Serializable id);

    int deleteById(T entity);

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    int delete(@Param("ew") Wrapper<T> queryWrapper);

    int deleteBatchIds(@Param("coll") Collection<?> idList);

    int updateById(@Param("et") T entity);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectById(Serializable id);

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    default T selectOne(@Param("ew") Wrapper<T> queryWrapper) {
    
    
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
    
    
            if (ts.size() != 1) {
    
    
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records", new Object[0]);
            } else {
    
    
                return ts.get(0);
            }
        } else {
    
    
            return null;
        }
    }

    default boolean exists(Wrapper<T> queryWrapper) {
    
    
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0L;
    }

    Long selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);

    <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param("ew") Wrapper<T> queryWrapper);
}

archivo de mapeo SQL xml (XXXXMapper.xml)

No hay diferencia con mybatis, siempre que el atributo de espacio de nombres en la etiqueta del asignador defina el nombre completo de la interfaz del asignador con el mismo nombre.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.springbootdemo2023.mybatis.dao.goods.TGoodsMapper">
  ...
</mapper>

3. MyBatis-plus: Realice la adición, eliminación, modificación y consulta de código SQL cero (utilizando el método en baseMapper)

1. Añadido -insertar

 TGoods tGoods = new TGoods();
        tGoods.setName("iPhone1000");
        tGoods.setPrice(new BigDecimal("50"));
        tGoods.setTypeName("手机");

        int insert = goodsMapper.insert(tGoods);

2. Modificar

método de actualización:

​ Parámetro 1: El objeto de entidad a actualizar

Parámetro 2: condición de actualización

TGoods tGoods = new TGoods();
        tGoods.setName("掌中宝");

        //更新条件
        QueryWrapper<TGoods> updateWrapper = new QueryWrapper<>();

        // 修改goodsID为101的数据
        // where goodsID = '101'
        updateWrapper.eq("goodsID","101");

        int insert = goodsMapper.update((tGoods),updateWrapper);

actualizarPorId

Parámetro 1: el objeto de entidad que debe actualizarse, se debe pasar el valor del campo de clave principal de los datos que se actualizarán

TGoods tGoods = new TGoods();
        tGoods.setGoodsID("101");
        tGoods.setName("掌中宝12312312312");

        // where 主键字段名=101
        int insert = goodsMapper.updateById(tGoods);// 主键字段必须有值

3. Eliminar operación

deleteById (keyid serializable): pasa directamente el valor de la clave principal

Parámetro 1: se debe pasar el valor del campo de clave principal de los datos que se van a eliminar

int insert = goodsMapper.deleteById("101");

deleteById (parámetro de entidad): el atributo de clave principal en el objeto de entidad debe tener un valor

TGoods tGoods = new TGoods();
        tGoods.setGoodsID("101");

int insert = goodsMapper.deleteById(tGoods);

borrar:

Parámetro 1: pasar objeto de condición

//删除价格在10元以及10元以上，30元以下的数据
        QueryWrapper<TGoods> deleteWarapper = new QueryWrapper<>();

        /**
         * ge:双参数写法==》   >=
         * ge:三参数写法：第一个参数描述是否使用等于
         *    如： ge(true,"price",10);   ===》   price>=10
         *         ge(false,"price",10);   ===》   price>10
         */
        deleteWarapper.ge(true,"price",10);
        deleteWarapper.le(false,"price",30);

        int insert = goodsMapper.delete(deleteWarapper);

deleteBatchIds: eliminación por lotes según el valor de la clave principal

Parámetro 1: pasar la colección que contiene el valor de la clave principal que se eliminará

List<String> ids = new ArrayList<>();
        ids.add("101");
        ids.add("3552f64ba1f71fb41b2a612d636ce186");

        int insert = goodsMapper.deleteBatchIds(ids);

4. Consulta

1. selectList: consulta el conjunto de resultados según la condición

//查询未被删除的数据
        QueryWrapper<TGoods> tGoodsQueryWrapper = new QueryWrapper<>();

        List<TGoods> tGoods = goodsMapper.selectList(tGoodsQueryWrapper);

        result.setData(tGoods);

2. selectMap: consulta el conjunto de resultados según la condición: el conjunto de resultados es Lista

//查询未被删除的数据
        QueryWrapper<TGoods> tGoodsQueryWrapper = new QueryWrapper<>();

        List<Map<String, Object>> maps = goodsMapper.selectMaps(tGoodsQueryWrapper);

3. selectCount: el número de filas en el conjunto de resultados estadísticos de la consulta condicional

//查询未被删除的数据
        QueryWrapper<TGoods> tGoodsQueryWrapper = new QueryWrapper<>();

        Long aLong = goodsMapper.selectCount(tGoodsQueryWrapper);

4. selectOne: los resultados de la consulta condicional solo reciben una fila de datos

//查询未被删除的数据
        QueryWrapper<TGoods> tGoodsQueryWrapper = new QueryWrapper<>();
        
        // 查询结果只有一行数据时可以使用该方法，
        //如果有多行数据就会抛出：One record is expected, but the query result is multiple records
        TGoods tGoods = goodsMapper.selectOne(tGoodsQueryWrapper);

5. selectById: consulta basada en el campo de clave principal

TGoods tGoods = goodsMapper.selectById("101");

6. consulta de paginación mybatis-plus

Para implementar la paginación, primero debe configurar el componente de paginación.

Agregue el siguiente código en la clase de inicio.

//分页配置
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));// 分页的方法-以mysql分页方式实现
        return interceptor;
    }

1.selectPage: método de paginación condicional: utilice el método de paginación en la interfaz baseMapper

 page.setPage(1);//第一页
        page.setSize(2);//每页显示2行

        MyPager<TGoods> pager = new MyPager<>();

        //查询商品名字中有"P"的商品
        QueryWrapper<TGoods> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name","P");

        Page<TGoods> tGoodsPage = goodsMapper.selectPage(PageDTO.of(page.getPage(), page.getSize()), queryWrapper);

        List<TGoods> records = tGoodsPage.getRecords();//分页的结果
        long total = tGoodsPage.getTotal();//不分页所有数据的行数

        pager.setPageSize(page.getSize());
        pager.setRows(records);
        pager.setTotal(total);
        pager.setPage(page.getPage());

2. Cómo navegar a través de métodos de interfaz personalizados especiales

definición de interfaz del mapeador

/**
     * 自定义分页写法
     * @param of mp 的分页参数
     * @param goods 自己条件实体
     * @return IPage<TGoods>
     */
    IPage<TGoods> selectGoodsPages(Page of, @Param("goods") TGoods goods);

definición xml

<!-- 虽然传入了分页参数，但是不需要用参数写limit语句，mp会自动拼接生成 -->
    <!-- 自定义查询sql语句，就不会拼接逻辑删除字段条件了，需要手动添加 -->
    <select id="selectGoodsPages" resultType="com.example.springbootdemo2023.mybatis.domain.goods.TGoods">
        select * from t_goods
        <where>
            <if test="goods.name!=null and goods.name!=''">
                and name like '%${
    
    goods.name}%'
            </if>
        </where>
                 
    </select>

implementación de prueba

page.setPage(1);//第一页
        page.setSize(2);//每页显示2行

        MyPager<TGoods> pager = new MyPager<>();

        TGoods tGoods = new TGoods();
        tGoods.setName("P");// 查询name中包含P的商品条件

        IPage<TGoods> tGoodsIPage = goodsMapper.selectGoodsPages(PageDTO.of(page.getPage(), page.getSize()), tGoods);

        List<TGoods> records = tGoodsIPage.getRecords();//分页的结果
        long total = tGoodsIPage.getTotal();//不分页所有数据的行数

        pager.setPageSize(page.getSize());
        pager.setRows(records);
        pager.setTotal(total);
        pager.setPage(page.getPage());

15. Generador de código MyBatis-plus

generar:

clase de controlador, interfaz de servicio, clase de implementación de servicio, clase de entidad de mapeo de base de datos, interfaz de mapeador y archivo de mapeo mapper.xmlsql

1. Introducir la dependencia del marco Freemarker

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

2. Presente el kit de herramientas de generación de código mybatis-plus

<!-- mp代码生成器 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>

3. Escribe un generador de código.

private final static String URL = "jdbc:mysql://localhost:3306/familydb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai";
    private final static String USER_NAME = "root";
    private final static String PWD = "cxk666";
    private final static String AUTHOR = "GaoJingBo";
    private final static String OUT_PUT_DIR = "D://mybatis";
    private final static String PARENT_PACKAGE_NAME = "com.gdones.fmbase.business";
    private final static String PARENT_MODEL_NAME = "ckt";
    private final static String TABLE_NAME = "t_ckt_designes";
    private final static String PREFIX = "t_";


    public static void main(String[] args) {
    
    

        FastAutoGenerator.create(URL, USER_NAME, PWD)
                .globalConfig(builder -> {
    
    
                    builder.author(AUTHOR) // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .dateType(DateType.ONLY_DATE)// 日期类型
                            .commentDate("yyyy-MM-dd") //公共默认日期格式
                            .outputDir(OUT_PUT_DIR); // 指定输出目录
                })
                .packageConfig(builder -> {
    
    
                    builder.parent(PARENT_PACKAGE_NAME) //设置父路径根包
                            .moduleName(PARENT_MODEL_NAME) //设置模块名称
                            .entity("dto") //dto实体
                            .service("service") //业务接口
                            .serviceImpl("service.impl") //业务实现
                            .mapper("mapper") //mybatis-plus-mapper接口
                            .xml("mapper.xml") mybatis-plus-mapper接口映射xml
                            .controller("controller") //控制器
                            .other("other");
                })
                .strategyConfig(builder -> {
    
    
                    builder.controllerBuilder()
                           .enableHyphenStyle()
                           .enableRestStyle();
                    builder.mapperBuilder()
                            .enableMapperAnnotation();
                    builder.entityBuilder()
                            .enableLombok()
                            .logicDeleteColumnName("isDelete")// 逻辑删除表字段名
                            .logicDeletePropertyName("isDelete")// 逻辑删除实体属性名
                            // 添加填充规则
                            .addTableFills(new Column("insertTime", FieldFill.INSERT))
                            .addTableFills(new Column("updateTime", FieldFill.INSERT_UPDATE))
                            .idType(IdType.NONE);
                    builder.addInclude(TABLE_NAME) // 设置需要生成的表名
                            .enableSkipView()//跳过视图
                            .addTablePrefix(PREFIX); // 设置过滤表前缀

                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();

4. Uso completo

1. Copie el código generado al paquete raíz.

2. Modifique la ruta de la regla de mapeo mybatis-plus-mapper y xml

#mybatis-plus配置
mybatis-plus:
  #dto别名映射 !!!!!!!!!
  type-aliases-package: com.example.springbootdemo2023.bus.**.dto
  #xml文件路径映射（xml文件要和接口文件同名） !!!!!!!
  mapper-locations: classpath*:com/example/springbootdemo2023/bus/dao/**/mapper/*.xml

3. Modifique la ruta de MapperSacn en la clase de inicio.

@MapperScan("com.example.springbootdemo2023.bus.**.mapper") !!!!!
@SpringBootApplication
public class SpringBootDemo2023Application {
    
    
    。。。

4. Verifique la estructura de su paquete

5. Escribir código: el controlador se escribe para la entrada.

@RestController
@RequestMapping("/goods/goods")
public class GoodsController {
    
    

    @Resource(name = "goodsServiceImpl")
    private IGoodsService goodsService;

    @GetMapping("/getGoodsByID")
    public MyResult getGoodDataByGoodID(String id){
    
    

        MyResult result = new MyResult();
		
        // 调用代码生成器生成的方法，业务层零代码直接可以实现增删改查
        Goods byId = goodsService.getById(id);

        result.setData(byId);

        return result;

    }


}