spring-mybatisplus整合内容

最新推荐文章于 2024-09-30 10:53:04 发布

DDHuao

最新推荐文章于 2024-09-30 10:53:04 发布

阅读量146

点赞数

文章标签： spring spring boot java

本文链接：https://blog.csdn.net/DDHuao/article/details/130098012

版权

文章详细介绍了SpringBoot的自动装配原理，包括包扫描和自动配置机制。接着，文章探讨了MyBatis-Plus的特性，如无侵入、高性能以及丰富的CRUD操作，并展示了如何在SpringBoot项目中集成MyBatis-Plus，包括创建实体类、配置数据源、创建DAO接口以及进行CRUD和条件查询的操作。

摘要由CSDN通过智能技术生成

1. springboot自动装配原理---

1.1 springboot包扫描原理

包建议大家放在主类所在包或者子包。默认包扫描的是主类所在的包以及子包。

主函数在运行时会加载一个使用@SpringBootApplication标记的类。而该注解是一个复合注解，包含@EnableAutoConfiguration，这个注解开启了自动配置功能。该注解也是一个复合注解，包含@AutoConfigurationPackage。该注解中包含@Import({Registrar.class})，这个注解引入Registrar类。该类中存在registerBeanDefinitions，可以获取扫描的包名。

如果需要人为修改扫描包的名称则需要在主类上@ComponentScan(basepackage={"包名"})

1.2springboot自动装配原理

自动装配是指在不需要显式配置的情况下，Spring Boot能够自动完成组件之间的依赖注入。这种方式通过分析应用程序中的类路径，找到可以提供所需服务的Bean，并将它们自动地注入到目标Bean中，从而消除了手动配置的麻烦。

主函数在运行会执行一个使用@SpringbootApplication注解的类，该注解是一个复合注解，包含@EnableAutoConfiguration, 该注解开启自动配置功能，该注解也是一个复合注解，包含@Import() 该注解需要导入AutoConfigurationImportSelector类。该类会加载很多自动装配类，而这些自动装配类完成相应的自动装配原理。

2. springboot整合mbatis-plus

2.1 mybatis-plus概述

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

不能替代mybatis ,以后对于单表操作的所有功能，都可以使用mp完成。但是链表操作的功能还得要校验mybatis.

mybatis-plus 特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

框架结构

2.2 mybatis-plu使用

(1)创建表并加入数据

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

(2)创建一个springboot工程并引入相关的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>qy163-springboot03</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy163-springboot03</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

(3)配置数据源

spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql://localhost:3306/aaa?serverTimezone=Asia/Shanghai
spring.datasource.druid.username=root
spring.datasource.druid.password=abc123

(4)创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}

(5)创建一个dao接口

(6)为接口生成代理实现类

@MapperScan(basePackages ="com.dxh.mybatis_plus.dao")
@SpringBootApplication
//@ComponentScan  人为指定扫描的包
public class MybatisPlusApplication {

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

}

(7)测试

/**
     * 查id
     */
    @Test
    void selectById() {
        User user = userMapper.selectById (3);

        System.out.println (user);
    }

2.3 mybatis-plu完成crud

@SpringBootTest
class MybatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;


    /**
     * 查id
     */
    @Test
    void selectById() {
        User user = userMapper.selectById (3);

        System.out.println (user);
    }

    /**
     * 增加
     */

    @Test
    void insert (){
        User user = new User ("sedfr", 15, "test4@baomidou.com");
        int insert = userMapper.insert (user);
        System.out.println (insert);
    }

    /**
     * 删除
     */
    @Test
    void deleteById(){
        int i = userMapper.deleteById (2);
        System.out.println (i);
    }

    /**
     * 多行删除
     */

    @Test
    void tests(){
        ArrayList<Integer> list = new ArrayList<> ();
        list.add (1);
        list.add (2);
        userMapper.deleteBatchIds (list);

    }

    /**
     * 修改
     */

    @Test
    void update(){
        User user = new User ();
        user.setId (3L);
        user.setName ("fff");
        user.setAge (55);
        user.setEmail ("110");

        int i = userMapper.updateById (user);
        System.out.println (i);

    }

    /**
     * 查找
     */
    @Test
    void query(){
        //Wrapper<T> query QueryWrapper  :查询对象，条件接口 queryWrapper :查询条件类，
        // updateWrapper  ：更新条件类  lambdaWrapper lambda ：表达式
        QueryWrapper<User> wrapper = new QueryWrapper<> ();
        wrapper.ge ("id",2);

        List<User> users = userMapper.selectList (wrapper);
        for (User user : users) {
            System.out.println (user);
        }
    }

    /**
     * 分页
     */
    @Test
    public void page(){
        Page<User> page = new Page<> ();
        userMapper.selectPage (page,null);

        System.out.println (page.getTotal ());
    }

}

2.4 mybatis-plu完成条件查询

/**
     * 查找
     */
    @Test
    void query(){
        //Wrapper<T> query QueryWrapper  :查询对象，条件接口 queryWrapper :查询条件类，
        // updateWrapper  ：更新条件类  lambdaWrapper lambda ：表达式
        QueryWrapper<User> wrapper = new QueryWrapper<> ();
        wrapper.ge ("id",2);

        List<User> users = userMapper.selectList (wrapper);
        for (User user : users) {
            System.out.println (user);
        }
    }

2.4 mybatis-plu完成分页查询

创建分页拦截器类

//分 页 拦 截 器
@Configuration
@MapperScan("scan.your.mapper.package")
class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor (DbType.H2));
        return interceptor;
    }
}

 /**
     * 分页
     */
    @Test
    public void page(){
        Page<User> page = new Page<> ();
        userMapper.selectPage (page,null);

        System.out.println("当前页的记录"+page.getRecords());//获取当前页的记录
        System.out.println("获取总页数"+page.getPages());//获取当前页的记录
        System.out.println("获取总条数"+page.getTotal());//获取当前页的记录
    }
    }

2.4 借助mybatis-plus完成联表查询

1.定义xml文件

<?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.dxh.mybatis_plus.dao.StudentMapper">

    <resultMap id="BaseResultMap" type="com.dxh.mybatis_plus.pojo.Student">
            <id property="sid" column="sid" jdbcType="INTEGER"/>
            <result property="sname" column="sname" jdbcType="VARCHAR"/>
            <result property="age" column="age" jdbcType="INTEGER"/>
            <result property="cid" column="cid" jdbcType="INTEGER"/>
        <association property="c1" javaType="com.dxh.mybatis_plus.pojo.Class01" autoMapping="true">
            <id property="cid" column="cid"></id>
        </association>
    </resultMap>
    <select id="findPage" resultMap="BaseResultMap">
        select s.sid, s.sname, s.age,c.cid from student s left join class01 c on s.cid = c.cid
        <if test="ew != null">
            <where>
                and ${ew.sqlSegment}
            </where>
        </if>
    </select>

2.定义dao层

/**
* @author 50351
* @description 针对表【student】的数据库操作Mapper
* @createDate 2023-04-11 19:48:01
* @Entity com.aaa.pojo.Student
*/
@Mapper
public interface StudentMapper extends BaseMapper<Student> {

    IPage<Student> findPage (IPage<Student> iPage ,@Param ("ew") Wrapper<Student> wrapper);


}

3. 测试

/**
 * @program: mybatis_plus
 * @author: ♥丁新华
 * @create: 2023-04-11 20:02
 **/
@SpringBootTest
public class test02 {

    @Autowired
    private StudentMapper studentMapper;

    /**
     * 分页
     */
    @Test
    void page(){
        Page<Student> iPage = new Page<> (1,3);

        QueryWrapper<Student> page = new QueryWrapper<> ();

        page.between ("sid",1,3);
        studentMapper.findPage (iPage,page);
        System.out.println (iPage.getRecords ());
        System.out.println (iPage.getPages ());
        System.out.println (iPage.getTotal ());

    }


    /**
     * 查询根据ID
     */

    @Test
    void queryById(){
        Student student = studentMapper.selectById (1);
        System.out.println (student);
    }



    /**
     * 查询全部
     */

    @Test
    void queryAll(){

        QueryWrapper<Student> wrapper = new QueryWrapper<> ();
        List<Student> students = studentMapper.selectList (wrapper);
        for (Student student : students) {
            System.out.println (student);
        }

    }



    /**
     * 增加数据
     */

    @Test
    void insert(){
    Student student = new Student ("ss",15,2);

    studentMapper.insert (student);
    }

    /**
     * 根据ID删除
     */

    @Test
    void delete(){
        int i = studentMapper.deleteById (7);
        System.out.println (i);
    }



    /**
     * 修改
     */
    @Test
    void update(){
        Student student = new Student ();
        student.setSname ("ssss");
        student.setSid (6);
        student.setAge (888);
        student.setCid (6);

        int i = studentMapper.updateById (student);
        System.out.println (i);
    }


}