MyBatis 笔记

MyBatis 是基于 Java 语言的开源的持久层框架，利用实体类和数据表之间产生了关联，通过映射文件中的 sql 语句对数据库进行操作

使用 maven 创建工程需要导入 mybatis 的依赖：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

简单实例演示

mybatis的持久层开发有两种方式，一种是原始的 dao 开发，比较繁琐，还有一种是基于接口的 JDK 动态代理开发，也是最普遍的一种开发模式

原始dao开发模式

使用原始 dao 开发模式，首先第一步： 创建 mybatis 的核心配置文件，一般取名为 mybatis-config.xml

在dataSource标签中配置数据库连接，在mapper标签中配置xml映射文件目录，然后去书写xml映射文件

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///test"/>
                <property name="username" value="root"/>
                <property name="password" value="zhang"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/beanMapper.xml"/>
    </mappers>
</configuration>

第二步：在上面的映射文件目录对应的位置创建文件

mapper 标签的 namespace 属性自定义书写，select 标签的 id 不能与其他 id 重复，resultType 是和数据库表对应的实体类的全限定路径名，实体类仅仅只有和表中字段对应的属性及 get set toString 方法而已

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test1">
    <select id="findAll" resultType="club.hanzhe.bean.Bean">
        select * from test1
    </select>
</mapper>

第三步：创建dao类，通过dao接口类来操作 mapper 文件中的增删改查

dao类想要操作mapper文件需要使用工厂对象，工厂对象暂时就不在这里创建了，由调用者给他对象让他使用就行

操作mapper文件需要使用mapper文件的 ==namespace.标签id==，例如 ==test1.findAll==

public class BeanDao {
    private SqlSessionFactory factory ;
    public BeanDao( SqlSessionFactory factory ){
        this.factory = factory;
    }
    public List<Bean> findAll(){
        SqlSession sqlSession = factory.openSession();
        List<Bean> list = sqlSession.selectList("test1.findAll");
        return list;
    }
}

第四步：创建测试类，对写好的代码进行测试

因为调用一个dao都会使用一个工厂对象，所以这里就直接创建一个供所有dao使用，节省资源

public class AppTest {
    private static InputStream is = null;
    private static SqlSessionFactory factory = null;
    @Before
    public void before(){
        try {
            is = Resources.getResourceAsStream("mybatis-config.xml");
        } catch (Exception e) {
            System.out.println("获取配置文件失败！");
        }
        factory = new SqlSessionFactoryBuilder().build(is);
    }
    @Test
    public void tes1(){
        BeanDao dao = new BeanDao(factory);
        List<Bean> list = dao.findAll();
        for (Bean bean : list)
            System.out.println(bean);
    }
}

基于接口的动态代理开发

使用动态代理开发模式，首先第一步： 创建 mybatis 的核心配置文件，一般取名为 mybatis-config.xml

这里和 dao 开发的配置文件一模一样，可以去上面 copy

第二步：在上面的映射文件目录对应的位置创建映射文件

这里和上面几乎一模一样，但是动态代理的 mapper 的 namespace 指向的必须是接口的全限定名称

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="club.hanzhe.dao.BeanDao">
    <select id="findAll" resultType="club.hanzhe.bean.Bean">
        select * from test1
    </select>
</mapper>

第三步：按照上面映射文件目录创建接口

这里和上面不同的是不需要太多繁琐的结构，只需要创建一个方法即可对应mapper中的增删改查，但是需要注意一点：==接口方法名必须和mapper的CRUD标签id一致，否则会报错==

public interface BeanDao {
    List<Bean> findAll();
}

第四步：创建测试类，对写好的代码进行测试

public class TestDemo {
    private SqlSessionFactory factory = null;
    @Before
    public void before(){
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("mybatis-config.xml");
        }catch (Exception e){
            System.out.println("加载核心配置文件失败");
            System.exit(0);
        }
        this.factory = new SqlSessionFactoryBuilder().build(is);
    }
    @Test
    public void test1(){
        SqlSession session = factory.openSession();
        BeanDao mapper = session.getMapper(BeanDao.class);
        List<Bean> list = mapper.findAll();
        for (Bean bean : list)
            System.out.println(bean);
    }
}

注意：在 openSession 的时候是可以传入一个 boolean 参数的，如果不传参数默认为 false，如果要执行 DML 语句进行增删改的话，一定要传入 true 做为参数，否则他不会自动提交 ( 你可以手动提交 )，查询无需提交所以不需要设置

Mybatis 的核心配置文件

mybatis 的核心配置文件，一般都起名为 mybatis-config.xml 或者是 sqlMapConfig.xml ，在核心配置文件中可以通过某些标签对 mybatis 进行一些配置

==注意：mybatis 的核心配置文件内不可以书写中文注释 (英文或数字可以)，否则报错==

mybatis 提供了很多标签进行配置，但是这些标签也有着先后顺序，如果标签不按顺序书写也是会报错的

• configuration（配置文件的根标签）
  • properties（属性)
  • settings（设置)
  • typeAliases（类型别名)
  • typeHandlers（类型处理器)
  • objectFactory（对象工厂)
  • plugins（插件)
  • environments（环境配置）
    • environment（环境变量）
      • transactionManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识)
  • mappers（映射器）

上面来自 mybatis 官方文档，这里会挑常用的标签进行笔记

Environments 环境配置

1. 环境的选择

在 mybatis 配置文件中使用 environments 标签配置环境，在他下面可以有一个或多个 environment 子标签，每个都代表一个环境，然后在 environments 标签中使用 default 属性对环境进行选择

这里使用 default 对环境进行选择，目前选择的是MySQL的环境

<environments default="mysql">
    <environment id="mysql">
        这是MySQL的环境
    </environment>
    <environment id="oracle">
        这是oracle的环境
    </environment>
</environments>

除开配置文件内的默认环境，也可以在打开打开会话工厂的时候传入指定环境的id进行选择环境

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is, "mysql");

注意： 尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

2. 事务管理器

在每个 environment 子标签环境中有 transactionManager 标签的 type 属性可以对 SQL 进行事务控制管理，管理事务的管理器有两种：【 JDBC 】【 MANAGED 】

事务管理器	说明
JDBC	直接使用了 JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
MANAGED	什么都不做，让容器来管理事务的整个生命周期，不建议使用

建议使用 JDBC 来管理事务

<environment id="mysql">
    <transactionManager type="JDBC"/>
</environment>

3. 数据源

数据源是配置 mybatis 和数据库进行连接的相关配置，他由 environment 标签下的 dataSource 标签进行设置

通过 dataSource 标签的 type 属性可以选择数据源类型：

类型	说明
UNPOOLED	只是每次被请求时打开和关闭连接，反应较慢，适用于简单小型项目
POOLED	相对于UNPOOLED相比使用了 数据库连接池 的感念
JNDI	能在如 EJB 或应用服务器这类容器中使用

数据源最基本的四个属性：

• 【driver】 数据库连接驱动类
• 【url】 数据库链接地址
• 【username】 用户名
• 【password】 密码

最常见的 environments 标签配置

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///test"/>
            <property name="username" value="root"/>
            <property name="password" value="******"/>
        </dataSource>
    </environment>
</environments>

Mappers 映射标签

书写的 mapper 文件需要被映射到核心配置文件中，映射的标签就是 mappers ，他下面有两个子标签，分别是 mapper 和 package 映射方法如下：

1. 映射的文件在resources目录下

<mappers>
    <!-- 映射单个文件 -->
    <mapper resource="beanMapper.xml"/>>
    <!-- 使用 * 通配符映射多个文件 -->
    <mapper resource="*Mapper.xml"/>
</mappers>

2. 映射的文件在dao包下

当 mapper 文件在 dao 包下的时，mapper 和接口必须是同名的，或者在 resources 目录下有着同级的目录

<mappers>
    <!-- 映射单个文件 -->
    <mapper class="club.hanzhe.dao.BeanDao" />
    <!-- 映射多个文件 -->
    <package name="club.hanzhe.dao"/>
</mappers>

3. 接口注解开发

<mappers>
    <package name="club.hanzhe.dao"/>
</mappers>

注意！当mapper文件在dao包下的时候，需要在maven的pom文件中添加如下代码，否则xml文件可能不会被打包发布

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

Properties 属性

我们在使用传统 JDBC 的时候都会把 driver，url 等等放在一个 propertis 后缀的文件中，这样可以降低代码的耦合性，方便环境切换，mybatis 中也支持这种做法，使用 properties 标签就可以实现

1. 手写 properties 配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1/库名
username=root
password=*****

2. 使用 properties 标签将配置文件引入进来

<!-- 使用该标签将配置文件引入进来，然后就可以使用 ${} 符号来调用配置文件内的值了 -->
<properties resource="db.properties" />
<!-- 例如： -->
<property name="driver" value="${driver}">

TypeAliases 别名

在我们的 mapper 映射文件中，CRUD 标签中的参数，返回结果 resultType 通常都是全限定名，例如：

<select id="findAll" resultType="club.hanzhe.bean.Bean"></select>

这个时候我们就可以使用 typeAliases 标签下的 typeAlias 子标签==配置类别名==，可以简化全限定名书写格式

abc就是这个类的类别名，就可以在映射文件中使用了

<typeAliases>
    <typeAlias type="club.hanzhe.bean.Bean" alias="abc" />
</typeAliases>

<select id="findAll" resultType="abc"></select>

typeAlias 标签中的 alias 属性也可以忽略不写，默认已类名作为别名 (别名首字母小写即可)

<typeAliases>
    <typeAlias type="club.hanzhe.bean.Bean" />
</typeAliases>

<select id="findAll" resultType="bean"></select>

但如果是个较大的项目，表和实体类比较多，如果逐个实体类配置的话会很麻烦，这时可以使用 package 子标签

将指定包下的所有类全部配置别名，别名为类本身名字 (首字母小写)

<typeAliases>
    <package name="club.hanzhe.bean" />
</typeAliases>

<select id="findAll" resultType="bean"></select>

Settings 全局设置

在 mybatis 中可以对全局进行一些设置，设置需要用 settings 下的 setting 子标签实现，格式体现为：

<settings>
  <setting name="设置名称" value="对应参数值"/>
</settings>

常用的设置有：

设置名	作用描述	参数
cacheEnabled	设置全局缓存的开启和关闭	boolean
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数。	任意正整数
mapUnderscoreToCamelCase	是否开启驼峰命名规则	boolean
logImpl	配置日志信息，个人推荐使用 STDOUT_LOGGING 日志	@官方文档

Mapper 映射文件

mapper 映射文件，用来负责和数据库交互的 sql 代码，主要是增删改查四个标签为主：

增删改标签

增删改标签是用来书写插入 sql 的标签，比较常用的几个属性如下：

<insert
 id="addBean"
 parameterType="club.hanzhe.bean"
 flushCache="true"
 timeout="20">

属性	作用
id	用来作为标签的标识符，使用id可以直接找到当前标签调用
parameterType	接受的参数的类型，如果参数类型是集合，那么就填集合内元素的类型
flushCache	增删改标签默认设置为true，只要语句被调用，就会清空本地和二级缓存
timeout	抛出异常之前，驱动程序等待响应的时间，默认为空值

查询标签

select 标签是用来专门书写查询语句的标签，比较常用的几个属性如下：

<select
    id="selectPerson"
    parameterType="int"
    resultType="hashmap"
    resultMap="personResultMap"
    flushCache="false"
    useCache="true"
    timeout="10"
    fetchSize="256"
    statementType="PREPARED"
    resultSetType="FORWARD_ONLY">

除开增删改相同的属性之外，查询有着自己的属性

属性	作用
resultType	用来设置查询返回的数据对应的实体类
resultMap	属于高级的parameterType，他可以手动配置实体类属性和数据库字段的映射
useCache	select 默认为 true，执行查询后将查询结果缓存在二级缓存中

添加时返回 ID

这里记一个十分好用的小功能，当我们执行 insert 之后，想要立刻操作这行记录，但是他的主键是自增的，我们想要操作他需要获取他的 ID，这个时候我们可以通过属性设置回显 ID

假设当前有一个 bean，属性为 userid，username，password

<!-- useGeneratedKeys="true" 取出数据库内自动生成的主键 -->
<!-- keyProperty="userid" 将主键设置在 bean 中的某个属性上 -->
<insert id="addUser" parameterType="user" useGeneratedKeys="true"keyProperty="userid">
 insert into t_user values(#{username}, #{password})
</insert>

@Test
public void test(){
    User user = new User();
    user.setUsername("张");
    user.setPassword("123");
    userDao.addUser(user);
    // 当我们执行插入语句后，如果正常运行，那么userid就会成功赋值
    System.out.println(user.getUserid());
}

SQL 代码片段

可以被用来定义可重用的 SQL 代码段，例如：

定义了 id 为 t_user 的 sql 代码片段，在下面的增删改查中就可以使用 include 来调用了

<sql id="t_user">userid, username, usersex, usertel</sql>

<select id="selectAll" resultType="user">
    SELECT <include refid="t_user" /> FROM t_user
</select>

${ } 和 #{ } 的区别

${ }和#{ }他们都是用来接收传入参数的，只不过有些细节需要留意，假设现在有一行SQL语句：

select * from t_user where userid = 1;

其中作为查询条件的 1 是需要接收传入参数的，那么获取到传入参数有两种方法：

• ${ }，拼接SQL字符串
• #{ }，作为SQL占位符

如果使用 ${} 的话，通过日志可以看到，它以拼接字符串的方式执行，这样的话就很容易收到SQL注入的攻击

select * from t_user where userid = 1;

但是如果使用 #{} 的话，他是将 SQL 代码预处理之后在执行之前进行参数替换，传入的参数都将作为普通参数对待，通过执行日志就可以看到：

select * from t_user where userid = ? ;

这是二者最明显的差距，通过占位符可以有效防止SQL注入攻击，推荐使用#{ }

ResultMap 标签

一般使用 resultType 返回对象的时候，是数据库自动检测实体类中和字段匹配的属性进行封装，但是如果实体类中的属性和表中的字段截然不同的话，就需要手动配置他们之间的映射关系了

<!-- 
  id：为当前标签的命名，会在select标签中的返回类型中用到
  type：为返回的主类的类型，Student中包含Score类型的变量，所以Sutdent是主类
  extends：继承，将指定的resultMap的id作为值放在这里，会继承之前书写的映射
  autoMapper：为其他属性自动匹配的开关，默认为false关闭状态
   为false时，只有手动配置的映射会匹配成功，未设置的为null值
   为true时，将按照手动配置的进行匹配，没有手动配置的会自动按照变量名匹配
-->
<resultMap id="map1" type="club.hanzhe.pojo.U_T">
    <!--
       id标签为设置当前主类与数据表中对应表的主键的匹配
       column：数据表中的字段
       property：与该字段对应的本类中的属性
     -->
    <id column="rowNo" property="rowNo" />
    <!--
   result标签为设置当前主类与数据表中对应表的其他字段的匹配
   column：数据表中的字段
   property：与该字段对应的本类中的属性
  -->
    <result column="u_id" property="userid" />
    <!--
   association标签为设置当前主类中映射的其他类
   property：类中的属性
   javaType：属性所对应的那个类的全限定名，可以使用别名
   autoMapping：自动匹配表中的其他字段和类中的属性
  -->
    <association property="tel" javaType="club.hanzhe.pojo.Tel">
        <id column="t_id" property="telid" />
    </association>
    <!--
   collection用来映射集合，多用于一对多查询 
   与association的唯一差别就是javaType变成了ofType 
  -->
    <collection property="tel" ofType="club.hanzhe.pojo.Tel">
        <id column="t_id" property="telid" />
    </collection>
</resultMap>

动态 SQL

通过传入的参数对 sql 进行灵活化使用，类似 Java 一样，通过 判断循环 来控制 SQL 的最终执行

if 判断标签

如果接收的username参数不为空的话，就追加当前标签内的sql语句

<select id="findBean" resultType="bean">
    select * from test
    <if test="id != null and id != ''">
        where id = #{id}
    </if>
</select>

where 过滤标签

使用 where 标签之后，如果 where 内有符合 if 条件的会自动添加 where 关键字，如果没有符合的就不添加

如果有多个 if 符合条件，需要在前面加上 and 或者 or 等判断条件，如果是第一个成立的条件会默认省略前面的 and 或 or，后续的会添加

<select id="findUser" resultType="user">
    select * from t_user
    <where>
        <if test="userid != null">
            and userid = #{userid }
        </if>
        <if test="username != null">
            and username like #{username }
        </if>
        <if test="usersex != null">
            and usersex = #{usersex }
        </if>
        <if test="usertel!= null">
            and usertel = #{usertel }
        </if>
    </where>
</select>

choose 标签

choose 标签有着和 switch 类似的功能，他要求当前判断至少成立一个才可以结束，如果没有成立的会执行otherwise

<choose>
    <when test=""></when>
    <when test=""></when>
    <otherwise></otherwise>
</choose>

set 标签

使用 set 标签之后，如果 set 内有符合 if 条件的会自动添加 set 关键字，如果没有符合的就不添加，需要注意一点的是，==set → if 内的 sql 结尾一定要带上逗号==，系统会自动省略但不会自动追加。

<update id="updateUser" parameterType="user" >
    update t_user
    <set>
        <if test="username != null and username != ''">
            username = #{username },
        </if>
        <if test="usersex != null and usersex != ''">
            usersex = #{usersex },
        </if>
        <if test="usertel != null and usertel != ''">
            usertel = #{usertel },
        </if>
    </set>
    where userid = #{userid }
</update>

foreach 标签

foreach 标签用来遍历传进来的集合或数组容器，多用于批量删除操作，里面的属性解释如下：

<delete id="find1">
 delete from bean where id in
 <foreach collection="list" open="(" close=")" separator=", " item="i">
  #{ i }
 </foreach>
</delete>

• collection：传进来被遍历的那个容器的名字，可以是数组或集合
• open：循环开始前需要添加的前缀
• close：循环结束后需要添加的后置
• separator：每循环一次时需要在中间添加的分隔符
• item：被循环出来的每个字段，在标签内直接使用即可

cache 缓存标签

一级缓存

在 mybatis 中一级缓存是默认开启的，在进行 openSession 的时候就自动打开了一级缓存，且对于一级缓存的操作，只能清空，不能禁用，一级缓存的作用范围是当前的 SqlSession 实例

在同一个 SqlSession 实例中，两次同样的查询返回的结果是一致的，但是如果是两个SqlSession那么进行相同的查询结果就会不同，这里就不写了

public void test4(){
    SqlSession session = this.factory.openSession(true);
    BeanDao mapper = session.getMapper(BeanDao.class);
    Bean bean1 = mapper.findById(7844);
    Bean bean2 = mapper.findById(7844);
    System.out.println(bean1 == bean2);
}

二级缓存

二级缓存的范围是基于当前的 mapper.xml 配置文件的 mapper 标签，也就是当前的 namespace 下，一个二级缓存可以横跨多个一级缓存，而二级缓存默认是关闭的，开启二级缓存的方法就是==使用 cache标签==

没错，只要在 mapper 下面加上这么一句代码，二级缓存就开启完成了，简单粗暴

<cache />

在开启二级缓存后还不能立刻使用，会报错，==需要让该 mapper 相关的所有 bean 实现 Serializable 序列化接口==

Mybatis 注解开发

CRUD 注解

在 mybatis 中也可以不使用 mapper 映射文件，改为使用注解开发，分别相对着增删改查四个注解

@Insert("insert into t_user values(null,#{name},#{sex},#{address})")
public int saveUser(User user);

@Delete("DELETE FROM t_user WHERE u_id = #{abc}")
public int removeUser(Integer id);

@Update("update t_user set u_address=#{address} where u_name = #{name}")
public int updateUser(User user);

@Select("select * from t_user where u_id = #{abc}")
public User findUserById( Integer id );

注意！使用 mapper 文件的时候需要扫描 mapper 文件所在位置，然后才可以使用，使用注解开发也需要扫描：

将所有带有注解的接口都扫描

<mappers>
    <package name="club.hanzhe.dao"/>
</mappers>

Result 注解

使用 xml 开发时，会遇到字段与实体类属性名不匹配造成封装失败的情况，起别名解决是一种方法，但是一般都使用 resultMap 结果映射，将字段与属性匹配，注解开发也可以使用 resultMap，对应的注解是 @Results

使用注解的方式匹配字段与属性查询

@Results(
    id = "r1", // id：给当前results起名字，像resultMap一样继承使用
    value = { // value：配置多个映射
  /*
   *  @Result中的属性：
   *   id：表中的id列是否为主键，是为true，不写默认为false
   *   column：表中的字段
   *   property：表中字段对应的pojo中的属性
   *   只需要将不匹配的字段属性配上即可，匹配的可以省略不写
   */
        @Result( column = "u_id" , property = "id" ),
        @Result( column = "u_name" , property = "name" ),
        @Result( column = "u_sex" , property = "sex" ),
        @Result( column = "u_address" , property = "address" )
    }
)
public User findUserById( Integer id );

如果有另一个查询与他的规则相同，那么可以引用之前写的Results的id属性

@Select("select * from t_user where u_name = #{abc}")
@ResultMap("r1")
public User findUserByName( String name );

扩展功能

Mybatis 逆向工程

逆向工程是根据数据库中表的信息进行自动创建实体类，接口，映射文件的技术

1. 环境配置

使用逆向工程必须引入他的依赖或jar包

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.5</version>
</dependency>

2. 逆向工程配置文件

你可以在任意位置 ( 包括项目外 ) 创建逆向工程所需要的配置文件，需要手动配置的地方有以下几点：

• properties 标签中的配置文件需要自己书写，也可以书写该标签及文件
• jdbcConnection 标签需要修改，修改需参考上面的 properties 配置文件
• javaModelGenerator 标签需要修改，他是实体类生成的目标包路径
• sqlMapGenerator 标签需要修改，他是 mapper 映射文件生成的目标路径
• javaClientGenerator 标签需要修改，他是接口生成的目标包路径
• table 标签的 tableName 属性需要修改，他是逆向工程所参考的数据表
  • 如有多个表被参考就书写多个 table 标签，可以直接复制修改 tableName 属性

<?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>
    <properties resource="db.properties"></properties>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!--是否去除自动生成的注释 true是：false 否-->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!--数据库连接-->
        <jdbcConnection driverClass="${driver}" connectionURL="${url}" userId="${username}" password="${password}"></jdbcConnection>
        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL和NUMERIC类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!--生成的实体类存放的位置-->
        <javaModelGenerator targetProject="src/main/java" targetPackage="club.hanzhe.bean">
            <!--enableSubPackages,是否让schema作为包的后缀-->
            <property name="enableSubPackages" value="false"/>
            <!--从数据库返回的值被清除前后空格-->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!--mapper映射文件存放的位置-->
        <sqlMapGenerator targetProject="src/main/resources" targetPackage="mappers">
            <property name="enableSubPackages" value="false"></property>
        </sqlMapGenerator>
        <!--targetPackage:mapper接口生成的位置-->
        <javaClientGenerator type="XMLMAPPER" targetProject="src/main/java" targetPackage="club.hanzhe.dao">
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>
        <!--tableName为逆向工程针对的表的表名，可以通配符匹配所有表，剩下的属性统统false-->
        <table tableName="%"
               enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"></table>
    </context>
</generatorConfiguration>

3. 使用逆向工程

在环境配置完成后使用下面这段模板代码，运行后就会将实体类，接口，mapper文件自动生成

需要在改代码中手动设置配置文件的文件名及位置

import org.junit.Test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class Generator {
    @Test
    public void create(){
        try {
            List<String> warnings = new ArrayList();
            boolean overWriter = true;
            // 这里加载刚刚创建的逆向工程配置文件
            File configFile = new File("文件位于磁盘的绝对路径");
            ConfigurationParser cp = new ConfigurationParser(warnings);
            Configuration config = cp.parseConfiguration(configFile);
            DefaultShellCallback callback = new DefaultShellCallback(overWriter);
            MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
            myBatisGenerator.generate(null);
        }catch (Exception e){
            System.out.println("操作失败！");
            System.out.println("==================================================");
            System.out.println(e);
            e.printStackTrace();
        }
    }
}

PageHelper 分页插件

pageHelper 插件是针对 mybatis 设计的一款分页插件，通过拦截器对 sql 进行操作，使其拥有分页的能力

1. 环境配置

使用 pageHelper 分页插件需要导入他的 maven 依赖或者导入他的 jar 包

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <!-- 可以官网查询最新版 -->
    <version>5.0.0</version>
</dependency>

在 maven 依赖添加完成后，还需要在 mybatis 的核心配置文件中使用 plugins 标签注册 pageHelper 插件

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

2. 使用PageHelper

PageHelper 依赖引入后，在程序中就有了 PageHelper 类，调用它的 startPage 静态方法，后紧跟的第一条查询语句就是分页查询

startPage 的静态方法需要两个参数，第一个是查询的页码，第二个是每页的查询数量

public void test1(){
    // 查询第二页，每页5条记录
    PageHelper.startPage(2, 5);
    List<Bean> list = mapper.findAll();
    for (Bean bean : list)
        System.out.println(bean);
    System.out.println(list);
}

分页除了 PageHelper 类，还有一个 PageInfo 可以使用，将查询的结果封装到 PageInfo 中，可以查询一些和分页相关的信息

public void test1(){
    SqlSession session = factory.openSession();
    BeanDao mapper = session.getMapper(BeanDao.class);
    PageHelper.startPage(2, 5, true);
    PageInfo info = new PageInfo(mapper.findAll());
    System.out.println("总页码：" + info.getPages());
    System.out.println("总记录数：" + info.getTotal());
    System.out.println("结果集：");
    List<Bean> list = info.getList();
    for (Bean bean : list)
        System.out.println(bean);
}

3. PageInfo常用参数

在将结果集封装到 PageInfo 中的时候，可以可选性的传入一个导航页码的参数，可以获取到和当前页相邻的页码

public void test1(){
    SqlSession session = factory.openSession();
    BeanDao mapper = session.getMapper(BeanDao.class);
    PageHelper.startPage(201, 5, true);
    // 在创建info对象的时候可以跟随一个int类型，这个值是当前页附近的页码的数量
    PageInfo info = new PageInfo(mapper.findAll(), 7);
    System.out.println("当前页：" + info.getPageNum());
    System.out.println("每页显示数量：" + info.getPageSize());
    System.out.println("当前页信息：");
    for (Object obj : info.getList())
        System.out.println(obj);
    System.out.println("总页码：" + info.getPages());
    System.out.println("总记录数：" + info.getTotal());
    System.out.println("上一页：" + info.getPrePage());
    System.out.println("下一页：" + info.getNextPage());
    System.out.println("是否首页：" + info.isIsFirstPage());
    System.out.println("是否尾页：" + info.isIsLastPage());
    System.out.println("导航条页码:");
    for (int page : info.getNavigatepageNums() )
        System.out.print( page + "  " );
    System.out.println("\n导航条中首页" + info.getNavigateFirstPage());
    System.out.println("导航条中尾页" + info.getNavigateLastPage());
}

• 这里需要注意！==每页显示数量是指分页是设置的数量==，例如设置每页只显示5条，获取到的就是5，而不是最后一页只显示三条就返回三，这是错误的

合理化查询

在网页中往往有些人会钻空子乱改数据，例如只有20页数据，他修改了参数请求到了第50页，这种情况经常会发生，所以在注册 pageHelper 的时候可以添加一个参数使数据变得合理化

<plugin interceptor="com.github.pagehelper.PageInterceptor">
    <property name="reasonable" value="true" />
</plugin>

Lombok 插件

在我们进行查询的时候，需要将查询的结果封装到指定的实体类中，而对应的实例类需要书写响应的 get set 方法，构造方法及 toString 方法，这样比较麻烦，这是可以使用 lombok 插件进行自动生成功能

1. 环境配置

使用 lombok 需要引入他的 maven 依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
</dependency>

在依赖引入后还需要在编辑器中安装 lombok 的插件 ( IDEA 编辑器为例 ) File → settings → plugins → install JetBrains plugin... 在里面搜索 lombok 下载安装，而后在 file → settings → build,Exe.. → Compiler → Annotation Pro... 里面选中当前项目，在右面的 Enable annotation processing 选项打勾

2. 使用 Lombok 插件

在目标实体类上，只需要书写好属性即可，无需书写其他多余方法，使用 lombok 提供的注解用来一键生成：

注解	作用
@Getter	一键生成所有 get 方法
@Setter	一键生成所有 set 方法
@ToString	一键生成 toString 方法
@Data	一键生成 get set toString 等方法
@NoArgsConstructor	生成无参构造方法
@AllArgsConstructor	生成有参构造方法