SpringBoot base zéro pour maîtriser la génération de code MyBatis-plus intégrée

1. Introduction à Spring Boot

1. Exécution indépendante du projet Spring Spring Boot peut s'exécuter indépendamment sous la forme d'un package jar, et le projet Spring Boot ne peut être exécuté que via la commande "java–jar xx.jar".
2. Conteneur de servlets intégré Spring Boot utilise un conteneur de servlets intégré (tel que Tomcat, Jetty ou Undertow, etc.) et l'application n'a pas besoin d'être packagée en tant que package WAR.
3. Fournir des démarreurs pour simplifier la configuration de Maven Spring Boot fournit une série de modèles d'objet de projet (POMS) « de démarrage » pour simplifier la configuration de Maven.
4. Fournit un grand nombre de configurations automatiques Spring Boot fournit un grand nombre de configurations automatiques par défaut pour simplifier le développement de projets, et les développeurs modifient également les configurations par défaut via des fichiers de configuration.
5. Surveillance des applications autonomes Spring Boot peut assurer la surveillance des projets en cours d'exécution. 6. Aucune génération de code ni configuration XML. Spring Boot ne nécessite aucune configuration XML pour implémenter toutes les configurations de Spring.

2. Construire Spring Boot

SpringBoot utilise un conteneur intégré (le conteneur par défaut Tomcat) pour le déploiement, il n'est donc pas nécessaire de configurer Tomcat dans l'idée, exécutez simplement la méthode principale de la classe de démarrage directement

effet de démarrage

Recherchez cette ligne, qui signifie que le démarrage est réussi ! Par défaut, il fonctionne sur le port 8080

Écrire un cas

1. Le contrôleur renvoie 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. Fichier de configuration SpringBoot - YAML

5. Liaison de configuration Spring Boot

Ce qu'on appelle la « liaison de configuration » consiste à lier la valeur du fichier de configuration avec la propriété correspondante dans le JavaBean. Habituellement, nous mettrons certaines informations de configuration (par exemple, la configuration de la base de données) dans le fichier de configuration, puis lirons le fichier de configuration via le code Java et encapsulerons la configuration spécifiée dans le fichier de configuration dans JavaBean (classe d'entité).

1. Utilisez l'annotation @ConfigurationProperties

fichier yml

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

classe 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. Utilisez l'annotation @Value pour obtenir la configuration

@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. Chargez le contenu du fichier de configuration à l'exception du fichier de configuration de l'application

Utilisez @PropertySource

Créez un fichier de configuration aabbcc.properties et écrivez le contenu

cxk.name: giao哥

méthode de chargement

@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 charge le fichier de configuration Spring

1. @ImportResourceannotation

Créez un fichier de configuration XML dans le répertoire des ressources

<?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>

Ajoutez l'annotation @ImportResource à la tête de la classe de démarrage

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

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

}

test d'utilisation

@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;
    }

Imprimer

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

2. Utilisation de l'annotation Spring pour importer la méthode de configuration

classe de configuration

@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. Configuration multi-environnement SpringBoot

Configuration de l'environnement esclave + configuration de l'environnement principal = configuration complète du projet de démarrage

1. Créez des fichiers de configuration dans différents environnements

Règles créées :

Environnement de développement : application-dev.yml

Environnement de test : application-test.yml

Environnement de production : application-prod.yml

application-dev.yml

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

application-test.yml

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

application-prod.yml

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

Fichier de configuration principal - application.yml

Le fichier de configuration de l'environnement principal peut écrire certains éléments de configuration qui ne changeront pas

# 主配置文件

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

2. Définir la méthode pour activer la configuration de l'environnement

1. Défini par paramètre de commande lors de l'exécution du package jar

2. Les paramètres des outils peuvent être utilisés pendant le développement d'idées

3. Utiliser les paramètres jvm lors de l'empaquetage et de l'exécution

8. Priorité de chargement du fichier de configuration par défaut de SpringBoot

Fichiers de configuration dans le répertoire racine > fichiers de configuration dans le dossier config dans le répertoire classpath > fichiers de configuration dans le répertoire classpath

Priorité de toutes les écritures : (plus le numéro de série est petit, plus la priorité est élevée)

1. fichier:./config/
2. fichier:./config/*/
3. déposer:./
4. chemin de classe :/config/
5. chemin de classe :/

Remarque : file : fait référence au répertoire racine du projet en cours ; classpath : fait référence au classpath du projet en cours, à savoir le répertoire des ressources.

1. Lorsque la configuration des annotations et l'introduction de la configuration externe sont mélangées, la priorité du chargement complet

1. Paramètres de ligne de commande
2. Propriétés JNDI de java:comp/env
3. Propriétés du système Java (System.getProperties())
4. variables d'environnement du système d'exploitation
5. Valeurs de propriété Random.* configurées par RandomValuePropertySource
6. Fichiers de configuration (fichiers YAML, fichiers de propriétés)
7. Le fichier de configuration spécifié par @PropertySource sur la classe d'annotation @Configuration
8. Propriétés par défaut spécifiées par SpringApplication.setDefaultProperties

9. Journal d'utilisation de SpringBoot

1. Journal de configuration : ajoutez le contenu suivant au fichier de configuration 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. Intercepteur Spring Boot

1. Définir l'intercepteur

C'est exactement la même chose que l'écriture 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. Enregistrer l'intercepteur

Créez une classe de configuration qui implémente l'interface WebMvcConfigurer (une classe annotée avec @Configuration), remplacez la méthode addInterceptors() et appelez la méthode Registry.addInterceptor() dans cette méthode pour enregistrer l'intercepteur personnalisé dans le conteneur.

InterceptorRegistration configure les règles d'intercepteur :

addPathPatterns : définir les règles de saisie de l'intercepteur

includePathPatterns : définir des règles qui n'entrent pas dans l'intercepteur

Remarque : Si le chemin n'existe pas, s'il est 404, il entrera définitivement dans l'intercepteur

// 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 intègre le pool de connexions Druid

1. Introduire des dépendances

<!-- 和数据源相关操作必须引入 -->
        <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. Configurez le fichier de configuration 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 intègre MyBatis

1. Introduire des dépendances

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

2. Modifier le fichier de configuration 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. Ajoutez une annotation pour analyser l'interface du mappeur sur la classe de démarrage

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

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

}

4. Écrivez normalement l'interface et le fichier XML de mybatis

Utilisez le générateur de code pour le faire, en ignorant

5. Configurer l'empaquetage des ressources statiques Maven

Étant donné que le fichier XML existe dans le répertoire du code source Java, Maven ne conditionnera que le fichier Java par défaut.

Configuration dans 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. Testez

Ce cas consiste à introduire l'interface du mappeur dans le contrôleur, qui doit être superposée pendant le développement.

@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 intègre l'outil de pagination Mybatis

PageHepler

1. Introduire des dépendances

<!-- 分页插件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. Créez un objet de jeu de résultats paginé

/**
 * 模块名称：接收分页的结果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. Créez une entité qui reçoit les paramètres de requête de pagination

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

4. S'il y a un problème de dépendance circulaire

Si le jdk que vous utilisez est la version 8~10, vous ne pouvez réduire la version springBoot qu'à 2.5.5

5. Testez

@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 intègre MyBatis-plus

Tout est né pour la simplicité

1. Remplacer les dépendances

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

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

2. Modifier le fichier de configuration 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. Définir l'entité de table de base de données 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. Utilisez MyBatis-plus pour définir la méthode d'interface du mappeur (modifié)

1. Créer une interface mybatismapper pour intégrer l'interface BaseMapper de mybatis-plus
2. Définir des génériques à l'interface : les génériques sont les types d'entités de base de données correspondant aux opérations actuelles de l'interface du mappeur.

baseMapper a préparé à l'avance toutes les méthodes d'interface courantes (ajout, suppression, modification, requête, requête page par page)

Le contenu qui doit être implémenté manuellement par vous-même est défini dans l'interface et le fichier XML

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

5. Définissez un fichier XML vide avec le même nom que l'interface du mappeur

<?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>

Tant que les deux étapes 3 et 4 ci-dessus sont terminées, mybatis-plus a terminé l'injection automatique de la génération de code

6. Testez

@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 : A propos de la méthode de définition de la classe d'entité DO (il doit y avoir une classe en Java correspondant à la table dans la base de données)
2. mybatis-plus : fichier de mappage du mappeur et écriture de l'interface
3. MyBatis-plus : réalisez l'ajout, la suppression, la modification et l'interrogation de code zéro SQL (en utilisant la méthode dans baseMapper)
4. Configuration du générateur de code Mybatis-plus

1. Règles de définition de l'entité MyBatis-plus-DO

1. @TableName (nom de la table) - doit écrire

Implémenter le mappage un-à-un des classes et des tables

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

2. @TableId - décrit le champ de clé primaire - doit écrire

paramètre value : spécifie le nom du champ de clé primaire dans la table mappée

paramètre type : utilisé pour définir le type de la clé primaire (la stratégie de clé primaire utilise IdType pour définir)

​ IdType.AUTO : utilisez le mode de clé d'incrémentation automatique de la base de données pour réaliser la génération d'identifiants. N'oubliez pas que la base de données doit être définie sur l'incrémentation automatique pour être efficace.

​ IdType.NONE : N'implémente pas la génération automatique de clés primaires, aucune contrainte

​IdType.INPUT : N'implémente pas la génération automatique de clé primaire, contraint cet attribut à avoir une valeur et permet aux développeurs de le définir eux-mêmes

​ IdType.ASSIGN_ID : Générer une valeur entière auto-incrémentée via le mécanisme mybatis

​IdType.ASSIGN_UUID : Générer la valeur -UUID via le mécanisme 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- Description de la définition des champs ordinaires - non obligatoire

paramètre value : spécifie le nom du champ qui lui est mappé dans la table mappée

paramètre existant : (booléen)

​ false : Ce champ peut ne pas exister dans la table correspondante de l'entité courante, pour empêcher mybatis de générer les codes d'ajout, de suppression et de modification de ce champ

​ true : Ce champ existe dans la table correspondante de l'entité actuelle, et true est la valeur par défaut

paramètre fill : fonction de remplissage (les nœuds supprimés déclencheront également la stratégie de modification UPDATE)

​ FieldFill.INSERT : Déclenche la stratégie de remplissage lors de l'insertion

​ FieldFill.UPDATE : Déclenche la stratégie de remplissage lorsqu'elle est modifiée

​ FieldFill.INSERT_UPDATE : Déclenche la stratégie de remplissage lorsqu'elle est modifiée ou ajoutée

@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;

}

Lorsque la stratégie de remplissage est définie, la manière de remplir doit être définie et mise en œuvre manuellement

/**
 * 模块名称：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);
    }
}

code d'essai

@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:fichier de mappage du mappeur et écriture de l'interface

Fichier d'interface (XXXMapper.java)

Implémenter l'interface BaseMapper

BaseMapper fournit des méthodes pour ajouter, supprimer, modifier, vérifier et paginer en fonction de définitions génériques.

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);
}

fichier de mappage SQL XML (XXXXMapper.xml)

Il n'y a aucune différence avec mybatis, tant que l'attribut namespace dans la balise mapper définit le nom complet de l'interface mapper avec le même nom

<?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 : réalisez l'ajout, la suppression, la modification et l'interrogation de code SQL nul (en utilisant la méthode dans baseMapper)

1. Ajout de -insérer

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

        int insert = goodsMapper.insert(tGoods);

2. Modifier

méthode de mise à jour :

​ Paramètre 1 : L'objet entité à mettre à jour

​ Paramètre 2 : condition de mise à jour

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);

mise à jourParId

Paramètre 1 : l'objet d'entité qui doit être mis à jour, la valeur du champ de clé primaire des données à mettre à jour doit être transmise

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

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

3. Supprimer l'opération

deleteById(Serializing keyid) : transmettre directement la valeur de la clé primaire

Paramètre 1 : La valeur du champ clé primaire des données à supprimer doit être transmise

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

deleteById (paramètre d'entité) : l'attribut de clé primaire dans l'objet entité doit avoir une valeur

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

int insert = goodsMapper.deleteById(tGoods);

supprimer:

Paramètre 1 : objet de condition de réussite

//删除价格在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 : suppression par lots en fonction de la valeur de la clé primaire

Paramètre 1 : transmettre la collection contenant la valeur de clé primaire à supprimer

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

        int insert = goodsMapper.deleteBatchIds(ids);

4. Requête

1. selectList - interrogez l'ensemble de résultats en fonction de la condition

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

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

        result.setData(tGoods);

2. selectMap - interrogez l'ensemble de résultats en fonction de la condition - l'ensemble de résultats est une liste

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

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

3. selectCount- le nombre de lignes dans l'ensemble de résultats statistiques de la requête conditionnelle

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

        Long aLong = goodsMapper.selectCount(tGoodsQueryWrapper);

4. selectOne - les résultats de la requête conditionnelle ne reçoivent qu'une seule ligne de données

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

5. selectById - requête basée sur le champ de clé primaire

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

6. Requête de pagination mybatis-plus

Pour implémenter la pagination, vous devez d'abord configurer le composant de pagination

Ajoutez le code suivant dans la classe de démarrage

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

1.selectPage-méthode de pagination conditionnelle - utilisez la méthode de pagination dans l'interface 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. Comment parcourir les méthodes d'interface personnalisées spéciales

définition de l'interface du mappeur

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

définition 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>

mise en œuvre des tests

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. Générateur de code MyBatis-plus

générer:

classe de contrôleur, interface de service, classe d'implémentation de service, classe d'entité de mappage de base de données, interface de mappeur et fichier de mappage mapper.xmlsql

1. Introduire la dépendance du framework freemarker

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

2. Présentez la boîte à outils de génération de code mybatis-plus

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

3. Écrivez un générateur de code

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. Utilisation complète

1. Copiez le code généré dans le package racine

2. Modifier le chemin des règles de mappage mybatis-plus-mapper et 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. Modifier le chemin de MapperSacn sur la classe de démarrage

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

4. Vérifiez la structure de votre package

5. Écrire le code - Le contrôleur est écrit pour l'entrée

@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;

    }


}