MyBatis(5) 插件, 逆向工程
2023-10-30 15:00:05 # Backend # MyBatis

1. 插件

1.1 插件机制

MyBatis 对插件进行了标准化的设计，并提供了一套可扩展的插件机制。插件可以在用于语句执行过程中进行拦截，并允许通过自定义处理程序来拦截和修改 SQL 语句、映射语句的结果等。

具体来说，MyBatis 的插件机制包括以下三个组件：

  1. Interceptor（拦截器）：定义一个拦截方法 intercept，该方法在执行 SQL 语句、执行查询、查询结果的映射时会被调用。
  2. Invocation（调用）：实际上是对被拦截的方法的封装，封装了 Object target、Method method 和 Object[] args 这三个字段。
  3. InterceptorChain（拦截器链）：对所有的拦截器进行管理，包括将所有的 Interceptor 链接成一条链，并在执行 SQL 语句时按顺序调用。

插件的开发非常简单，只需要实现 Interceptor 接口，并使用注解 @Intercepts 来标注需要拦截的对象和方法，然后在 MyBatis 的配置文件中添加插件即可。

1.2 PageHelper

PageHelper 是 MyBatis 中比较著名的分页插件，它提供了多种分页方式（例如 MySQL 和 Oracle 分页方式），支持多种数据库，并且使用非常简单。

使用说明：https://github.com/pagehelper/Mybatis-PageHelper/blob/master/wikis/zh/HowToUse.md

使用示例：

  1. pom.xml引入依赖
1
2
3
4
5
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.3.3</version>
</dependency>
  1. mybatis-config.xml配置分页插件
1
2
3
4
5
<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
        <property name="helperDialect" value="mysql"/>
    </plugin>
</plugins>
  • 其中，com.github.pagehelper.PageInterceptor 是 PageHelper 插件的名称，dialect 属性用于指定数据库类型（支持多种数据库）
  1. 页插件使用

在查询方法中使用分页：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test
public void testTeacherRelationshipToMulti() {
    OrderMapper orderMapper = session.getMapper(OrderMapper.class);
	// 开启分页功能 startPage(int pageNum, int pageSize)
    PageHelper.startPage(1,2);
    // 这里查出来的是就是分页后的结果了
    List<Order> allOrders = orderMapper.selectAllOrders();
    allOrders.forEach(System.out::println);

    PageInfo<Order> pageInfo = new PageInfo<>(allOrders);

    System.out.println("pageInfo = " + pageInfo);
    long total = pageInfo.getTotal(); // 获取总记录数
    System.out.println("total = " + total);
    int pages = pageInfo.getPages();  // 获取总页数
    System.out.println("pages = " + pages);
    int pageNum = pageInfo.getPageNum(); // 获取当前页码
    System.out.println("pageNum = " + pageNum);
    int pageSize = pageInfo.getPageSize(); // 获取每页显示记录数
    System.out.println("pageSize = " + pageSize);
    List<Order> orders = pageInfo.getList(); //获取查询页的数据集合
    System.out.println("orders = " + orders);
    orders.forEach(System.out::println);
}

测试结果

image-20231029005818987

常用数据

  • pageNum：当前页的页码
  • pageSize：每页显示的条数
  • size：当前页显示的真实条数
  • total：总记录数
  • pages：总页数
  • prePage：上一页的页码
  • nextPage：下一页的页码
  • isFirstPage/isLastPage：是否为第一页/最后一页
  • hasPreviousPage/hasNextPage：是否存在上一页/下一页
  • navigatePages：导航分页的页码数
  • navigatepageNums：导航分页的页码，[1,2,3,4,5]

2. 逆向工程

MyBatis 的逆向工程是一种自动化生成持久层代码和映射文件的工具，它可以根据数据库表结构和设置的参数生成对应的实体类、Mapper.xml 文件、Mapper 接口等代码文件

MyBatis 的逆向工程有两种方式：通过 MyBatis Generator 插件实现和通过 Maven 插件实现。无论是哪种方式，逆向工程一般需要指定一些配置参数，例如数据库连接 URL、用户名、密码、要生成的表名、生成的文件路径等等。

2.1 MyBatisX

MyBatisX 是一个 MyBatis 的代码生成插件，可以通过简单的配置和操作快速生成 MyBatis Mapper、pojo 类和 Mapper.xml 文件。下面是使用 MyBatisX 插件实现逆向工程的步骤：

  1. IDEA连接数据库后，选择要使用的表，右键使用插件

image-20231030134544045

  1. 填写实体类生成的位置

image-20231030134825882

  1. 配置mapper模式

image-20231030135156612

  1. 生成结果

image-20231030135338311

2.2 MyBatis Generator

  1. 添加依赖和插件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<!-- 控制Maven在构建过程中相关配置 -->
<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.4.1</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.4.1</version>
                </dependency>
                <!-- 数据库连接池 -->
                <dependency>
                    <groupId>com.mchange</groupId>
                    <artifactId>c3p0</artifactId>
                    <version>0.9.5.5</version>
                </dependency>
                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.33</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>
  1. 创建MyBatis配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties" />
    <typeAliases>
        <package name="com.whale.mybatis.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.whale.mybatis.mapper"/>
    </mappers>
</configuration>
  1. 创建逆向工程的配置文件
  • 文件名必须是 generatorConfig.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
        <!--
        targetRuntime: 执行生成的逆向工程的版本
        MyBatis3Simple: 生成基本的CRUD
        MyBatis3: 生成带条件的CRUD
        -->
        <context id="DB2Tables" targetRuntime="MyBatis3">
                <!-- 数据库的连接信息 -->
                <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                                connectionURL="jdbc:mysql://localhost:3306/ssmdb"
                                userId="..."
                                password="...">
                </jdbcConnection>
                <!-- javaBean的生成策略-->
                <javaModelGenerator targetPackage="com.whale.mybatis.pojo"
                                    targetProject=".\src\main\java">
                        <property name="enableSubPackages" value="true" />
                        <property name="trimStrings" value="true" />
                </javaModelGenerator>
                <!-- SQL映射文件的生成策略 -->
                <sqlMapGenerator targetPackage="com.whale.mybatis.mapper"
                                 targetProject=".\src\main\resources">
                        <property name="enableSubPackages" value="true" />
                </sqlMapGenerator>
                <!-- Mapper接口的生成策略 -->
                <javaClientGenerator type="XMLMAPPER"
                                     targetPackage="com.whale.mybatis.mapper"
                                     targetProject=".\src\main\java">
                        <property name="enableSubPackages" value="true" />
                </javaClientGenerator>
                <!-- 逆向分析的表 -->
                <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
                <!-- domainObjectName属性指定生成出来的实体类的类名 -->
                <table tableName="t_order" domainObjectName="Order"/>
                <table tableName="t_customer" domainObjectName="Customer"/>
        </context>
</generatorConfiguration>
  1. 执行插件

image-20231030143409994

  1. 查看结果

image-20231030143529990

使用说明

查询

  • selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
  • example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
  • example.or().xxx：将之前添加的条件通过or拼接其他条件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Test
public void testMBG() {
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);

        //查询所有数据
        List<Order> list1 = mapper.selectByExample(null);
        list1.forEach(System.out::println);

        //根据条件查询
        OrderExample example = new OrderExample();
        example.createCriteria().andCustomerIdEqualTo(1).andOrderIdGreaterThanOrEqualTo(4);
        example.or().andOrderIdEqualTo(1);
        List<Order> list2 = mapper.selectByExample(example);
        list2.forEach(System.out::println);
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

增删改

  • updateByPrimaryKey()：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null

  • updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段

  • insert()

  • insertSelective()
  • deleteByExample()
  • deleteByPrimaryKey()
1
2
3
//根据主键更改
mapper.updateByPrimaryKey(new Order(1, "admin", null));
mapper.updateByPrimaryKeySelective(new Order(1, "admin",  null));
Prev
2023-10-30 15:00:05 # Backend # MyBatis
Next