Mybatis——使用步骤

ShareBeHappy_Qin

已于 2023-11-15 23:13:09 修改

阅读量741

点赞数

分类专栏：框架文章标签： mybatis

于 2022-12-03 22:21:04 首次发布

本文链接：https://blog.csdn.net/longool/article/details/128167451

版权

框架专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

Mybatis 使用步骤
Mybatis 日志配置
- 1、引入 Log4j 依赖
- 2、配置
Mybatis 获取参数的两种方式
分页插件使用步骤
Mybatis 逆向工程
SpringBoot 整合 Mybatis

mybatis 英文官网
 mybatis 中文官网

mybatis generator 官网

参考使用网址

Mybatis 使用步骤

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

总结起来就是：不要编写 JDBC 代码了，但是要自己编写 sql。使用 Mybatis 可以使得编写 Java 业务代码和编写映射文件中的 sql 语句独立解耦，Mybatis 会将接口映射到对应映射文件，实体类对象映射到对应的数据库表中的记录。

创建数据库表和实体类

表：tb_user

CREATE TABLE IF NOT EXISTS tb_user (
		id INT (5) NOT NULL PRIMARY KEY,
		NAME VARCHAR (45),
		age INT (3),sql
		sex CHAR
	)

实体类：User

public class User {
    private int id;
    private String name;
    private int age;
    private String sex;
}

1、引入依赖

<dependencies>
    <!-- Mybatis核心依赖包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!-- 因为是持久层框架，操作数据库，所以需要MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.3</version>
    </dependency>
</dependencies>

2、创建 mybatis 核心配置文件

核心配置文件存放的位置是 src/main/resources 目录下。

核心配置文件 mybatis-config.xml 用于配置 mybatis 相关的信息，主要用于配置连接数据库的环境以及MyBatis的全局配置信息。

核心配置文件中的标签按照需要配置，但之间有相对配置顺序，若配置时将它们之间的顺序颠倒，会提示报错： properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorF actory?,plugins?,environments?,databaseIdProvider?,mappers?

入门使用中一定要配置 environments 标签以操作数据库，配置 mappers 标签告诉 mybatis 去哪找映射文件，其他设置可以根据需要进行配置。

<?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文件，此时就可以通过 ${属性名} 的方式获取文件中的属性值，用来配置 mybatis 核心配置文件中参数-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <!--将表中含有下划线的字段自动转换为实体类中驼峰形式的属性-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!-- 设置全限定类名的别名，方便在 mapper 文件书写，避免每次都写全限定类名。
		为 type 设置一个名为 alias 的别名；
			若没有设置 alias 属性值，以该类名作为别名且不区分大小
			若设置 alias 属性值，以 alias 所设置的值作为别名 -->
    <typeAliases>
        <!-- 如：不指定别名，默认别名为类名User，不区分带小写 -->
        <typeAlias type="com.qgl.mybatis.pojo.User"></typeAlias>   
        <!-- 如：指定别名为 abcd -->
        <typeAlias type="com.qgl.mybatis.pojo.User" alias="abcd">   

        <!-- 以上是为一个类的全限定类名类设置别名，当类较多时，需要一个个设置，麻烦。
		于是可以以包为单位，设置该包下所有的全限定类名的默认别名为类名，且不区分大小写，一次性设置，方便 -->
        <package name="com.qgl.mybatis.pojo"/>
    </typeAliases>
    <!-- environments：设置多个连接数据库的环境。属性：default：设置默认使用的数据库环境-->
    <environments default="mysql_test">
        <!-- environment：设置具体的连接数据库的环境信息。属性：id：设置环境的唯一标识 -->
        <environment id="mysql_test">
            <!-- transactionManager：设置事务管理方式。属性：type：设置事务管理方式，type="JDBC|MANAGED"
      			type="JDBC"：设置当前环境的事务管理都必须手动处理
      			type="MANAGED"：设置事务被管理，例如spring中的AOP 
			    如果使用 Spring 整合 MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。-->
            <transactionManager type="JDBC"/>
            <!-- dataSource：设置数据源。属性：type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
     			type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建。
				type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
				type="JNDI"：调用上下文中的数据源 -->
            <dataSource type="POOLED">
                <!--设置驱动类的全类名，值从 jdbc.properties 中获取-->
                <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>
    <!--引入映射文件，这样MyBatis才知道去哪里找到映射文件，让接口中的方法映射到对应的sql语句。 -->
    <mappers>
        <!-- 设置一个 mapper 接口对应的映射文件。（资源是路径，不是包）-->
        <mapper resource="mappers/UserMapper.xml"/>s
        <!--以上是一个接口设置一个映射文件，需要一个个设置，麻烦。
		可以以包为单位，将包下所有的映射文件引入核心配置文件，
		注意：此方式必须保证mapper接口和mapper映射文件所在的包必须一致
 			 mapper接口的名字和mapper映射文件的名字必须一致-->
        <package name="com.qgl.mybatis.mappers"/>
    </mappers>
</configuration>

3、创建 mapper 接口

mapper 仅仅是一个接口，不需要提供实现类，会通过 MyBatis 的强大的映射功能，将接口中的方法映射到对应映射文件中的 sql 语句，然后去操作数据库。

public interface UserMapper {
    User selectById(int id);
}

4、创建 mapper 映射文件

mapper 映射文件和 mapper 接口是一一对应的，在映射文件中编写 sql。

<?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.qgl.mybatis.mappers.UserMapper">
    <select id="selectById" parameterType="int" resultType="com.qgl.mybatis.pojo.User">
        select * from tb_user where id = #{id}
    </select>
</mapper>

5、创建会话执行 sql

import org.apache.ibatis.io.Resources;

@Test
public void selectByIdTest() throws IOException {
    String resource = "mybatis-config.xml";
    //读取 MyBatis 核心配置文件
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //创建 SqlSessionFactory 工程
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //获取 SqlSession 会话
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //通过代理模式创建 UserMapper 接口的代理实现类对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //调用 UserMapper 接口中的方法，就可以根据 UserMapper 的全限定类名匹配映射文件，通过调用的方法名匹配映射文件中的 SQL 标签，并执行标签中的 SQL 语句。
    User user = mapper.selectById(1);
    System.out.println(user);
}

6、总结

映射关联关系：

通过核心配置文件中的 <mappers> 标签中的配置告诉 mybatis 去哪找映射文件；
根据映射文件中 <mapper namespace=“com.qgl.mybatis.mappers.UserMapper”> 的设置，使得 mapper 接口匹配到对应的映射文件；
sql 标签中的 id 属性值对应接口中的方法名，建立方法与 sql 语句之间的映射；
sql 标签中的 resultType 属性值指定接收查询结果的实体类。需要使用全限定类名，为了简化书写，可以在核心配置文件中通过 <typeAliases> 标签指定别名来表示全限定类名。

接口名和映射文件名可以不一样，因为他们之间通过 <mapper namespace=“com.qgl.mybatis.mappers.UserMapper”> 建立联系，但建议接口名和映射文件一样。

实体类名和数据库表名可以不一样，因为他们之间通过 sql 标签中的 resultType 属性指定哪个实体类来接收。但建议实体类名和表名一致。

resultType：自动映射，用于属性名和表中字段名一致的情况。resultType 属性值指定的实体类的属性名是要和表中字段名一致，否则对应不上，不会报错，但该属性不会接收对应数据。实体类中的属性个数不一定要和表中字段个数一致，不会报错，只是查询到的结果可能不能完全对应接收。

resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况。若实体类的属性名和表中字段名不一致，可以通过自定义映射关系来建立之间的联系。

Mybatis 日志配置

1、引入 Log4j 依赖

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2、配置

创建一个名为 log4j.properties 的配置文件进行配置

# 全局日志配置
log4j.rootLogger=ERROR, stdout
# MyBatis 日志配置
log4j.logger.com.qgl.mybatis.mappers.UserMapper=TRACE
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

也可以创建 log4j.xml 文件进行配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="com.qgl.mybatis.mappers.UserMapper">
        <level value="trace" />
    </logger>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

Mybatis 获取参数的两种方式

MyBatis 获取参数值的两种方式：${} 和 #{}

${} 的本质就是字符串拼接，#{} 的本质就是占位符赋值。

${} 使用字符串拼接的方式拼接 sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是 #{} 使用占位符赋值的方式拼接 sql，此时为字符串类型或日期类型的字段进行赋值时，它会自动添加单引号。

例：使用 ${} 拼接，即字符串拼接。存在 sql 注入的问题。

<select id="selectById" parameterType="int" resultType="com.qgl.mybatis.pojo.User">
    select * from tb_user where id = ${id}
</select>

输出的 sql 语句为：

DEBUG 12-04 10:52:32,230 ==>  Preparing: select * from tb_user where id = 1 (BaseJdbcLogger.java:137) 
DEBUG 12-04 10:52:32,254 ==> Parameters:  (BaseJdbcLogger.java:137)

例：使用 #{} 拼接，即占位符赋值。

<select id="selectById" parameterType="int" resultType="com.qgl.mybatis.pojo.User">
    select * from tb_user where id = ${id}
</select>

输出的 sql 语句为：

DEBUG 12-04 10:56:28,863 ==>  Preparing: select * from tb_user where id = ? (BaseJdbcLogger.java:137) 
DEBUG 12-04 10:56:28,885 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137)

如果拼接的是字符串或日期类型的字段。${} 需要加单引号。

<select id="selectByName" parameterType="String" resultType="com.qgl.mybatis.pojo.User">
    select * from tb_user where name = '${name}'
</select>

输出的 sql 语句为：

DEBUG 12-04 11:00:29,355 ==>  Preparing: select * from tb_user where name = '张三' (BaseJdbcLogger.java:137) 
DEBUG 12-04 11:00:29,381 ==> Parameters:  (BaseJdbcLogger.java:137)

${} 和 #{} 中的属性名和接口传参中的变量名一致，若两者不一致，使用 @Param 注解标识参数来作为属性名。

User selectById(@Param("name") String other);

分页插件使用步骤

PageHelper 官网

1、引入依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

2、配置分页插件

在 Mybatis 核心配置文件中注册分页插件

<plugins>
    <!--设置分页插件-->
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

3、使用

在查询功能之前使用 PageHelper.startPage(int pageNum, int pageSize) 开启分页功能。

在查询获取 list 集合之后，可以使用 PageInfo pageInfo = new PageInfo<>(List list, int navigatePages) 获取分页相关数据。

例：

public void selectByIdTest() throws IOException {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //开启分页功能
    PageHelper.startPage(1,2);
    List<User> users = mapper.selectList();
    for (User user : users) {
        System.out.println(user);
    }
    //获取分页相关的结果
    PageInfo<User> pageInfo = new PageInfo<>(users);
    System.out.println(pageInfo);
}

输出：

DEBUG 12-04 11:22:26,794 Cache Hit Ratio [SQL_CACHE]: 0.0 (LoggingCache.java:60) 
DEBUG 12-04 11:22:26,835 ==>  Preparing: SELECT count(0) FROM tb_user (BaseJdbcLogger.java:137) 
DEBUG 12-04 11:22:26,860 ==> Parameters:  (BaseJdbcLogger.java:137) 
TRACE 12-04 11:22:26,875 <==    Columns: count(0) (BaseJdbcLogger.java:143) 
TRACE 12-04 11:22:26,875 <==        Row: 4 (BaseJdbcLogger.java:143) 
DEBUG 12-04 11:22:26,877 <==      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 12-04 11:22:26,879 ==>  Preparing: select * from tb_user LIMIT ? (BaseJdbcLogger.java:137) 
DEBUG 12-04 11:22:26,880 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
TRACE 12-04 11:22:26,881 <==    Columns: id, name, age, sex (BaseJdbcLogger.java:143) 
TRACE 12-04 11:22:26,881 <==        Row: 1, 张三, 23, 男 (BaseJdbcLogger.java:143) 
TRACE 12-04 11:22:26,882 <==        Row: 3, 张三, 24, 男 (BaseJdbcLogger.java:143) 
DEBUG 12-04 11:22:26,883 <==      Total: 2 (BaseJdbcLogger.java:137) 
User(id=1, name=张三, age=23, sex=男, idCard=null)
User(id=3, name=张三, age=24, sex=男, idCard=null)
PageInfo{pageNum=1, pageSize=2, size=2, startRow=1, endRow=2, total=4, pages=2, list=Page{count=true, pageNum=1, pageSize=2, startRow=0, endRow=2, total=4, pages=2, reasonable=false, pageSizeZero=false}[User(id=1, name=张三, age=23, sex=男, idCard=null), User(id=3, name=张三, age=24, sex=男, idCard=null)], prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=8, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}

Process finished with exit code 0

分页相关数据：

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

Mybatis 逆向工程

MyBatis Generator 官网

MyBatis 的强大在于高级映射功能，但需要自己编写接口、实体类和 sql 语句。如果表太多的话，有大量的重复工作，麻烦。所以 MyBatis 官方提供了一个逆向工程，可以针对单表自动生成 MyBatis 执行所需要的代码（包括mapper.xml，mapper.java，pojo）。

正向工程：先创建 Java 实体类，由框架负责根据实体类生成数据库表。Hibernate 是支持正向工程的。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成代码（ Java实体类、Mapper接口、Mapper映射文件）。

通过 Maven 插件完成 Mybatis 逆向工程

1、pom.xml 中添加依赖和插件

<!-- 控制Maven在构建过程中相关配置 -->
<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                    <configuration>
	                    <verbose>true</verbose>
	                    <overwrite>true</overwrite>
	                    <!-- 指定配置文件地址 -->
                    	<configurationFile>etc/generatorConfig.xml</configurationFile>
                </configuration>
                </dependency>
                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.3</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

2、创建 MyBatis 的核心配置文件

同上。

3、创建逆向工程的核心配置文件

generatorConfig.xml

<?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
        targetRuntime="MyBatis3"：生成豪华版，包括复杂查询，动态映射等。生成 Example 类以及对应的 sql 语句来构造操作数据的条件 -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!-- jdbcConnection:如何连接到目标数据库 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>

        <!-- javaModelGenerator:指定 javaBean 的生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <javaModelGenerator targetPackage="com.qgl.mybatis.pojo" targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- sqlMapGenerator：sql映射生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <sqlMapGenerator targetPackage="com.qgl.mybatis.mappers"  targetProject="src/main/resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- javaClientGenerator：指定Mapper接口生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.qgl.mybatis.mappers"  targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- table：指定要逆向分析哪些表：根据表创建 javabean
            tableName；表名。tableName 设置为*号，可以对应所有表，此时不写 domainObjectName
            domainObjectName：domainObjectName 属性指定生成出来的实体类的类名 -->
        <table tableName="tb_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

4、运行 maven 命令

在这里插入图片描述

通过 Java 代码完成 Mybatis 逆向工程

1、pom.xml 中添加依赖

<!-- 逆向工程的核心依赖 -->
<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.2</version>
</dependency>
<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.3</version>
</dependency>

2、创建 MyBatis 的核心配置文件

同上。

3、创建逆向工程的核心配置文件

generatorConfig.xml

<?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
        targetRuntime="MyBatis3"：生成豪华版，包括复杂查询，动态映射等。生成 Example 类以及对应的 sql 语句来构造操作数据的条件 -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!-- jdbcConnection:如何连接到目标数据库 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>

        <!-- javaModelGenerator:指定 javaBean 的生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <javaModelGenerator targetPackage="com.qgl.mybatis.pojo" targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- sqlMapGenerator：sql映射生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <sqlMapGenerator targetPackage="com.qgl.mybatis.mappers"  targetProject="src/main/resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- javaClientGenerator：指定Mapper接口生成策略
            targetPackage：目标包名
            targetProject：目标工程 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.qgl.mybatis.mappers"  targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- table：指定要逆向分析哪些表：根据表创建 javabean
            tableName；表名。tableName 设置为*号，可以对应所有表，此时不写 domainObjectName
            domainObjectName：domainObjectName 属性指定生成出来的实体类的类名 -->
        <table tableName="tb_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

4、读取配置文件并执行

@Test
public void testMbg() throws Exception {
    List<String> warnings = new ArrayList<String>();
    boolean overwrite = true;
    File configFile = new File("src/main/resources/generatorConfig.xml");
    ConfigurationParser cp = new ConfigurationParser(warnings);
    Configuration config = cp.parseConfiguration(configFile);
    DefaultShellCallback callback = new DefaultShellCallback(overwrite);
    MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
    myBatisGenerator.generate(null);
}

SpringBoot 整合 Mybatis

官网

1、引入依赖

<!-- mybatis 启动器，mybatis 命字在前，这是 mybatis 迎合 spring boot 自己开发的启动器 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.3</version>
</dependency>
<!-- 数据库连接池（数据源） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

2、在 application.properties 配置 Mybatis 参数

#数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

#整合mybatis
#映射文件位置配置
mybatis.mapper-locations=classpath:com/qgl/mybatis/mappers/*.xml 
#给pojo实体类起别名
mybatis.type-aliases-package=com.qgl.mybatis.pojo