1<select id="findAll" resultMap="teacherMapper">
2    select * from teacher
3</select>

2.sql、include

用来定义可重用的Sql片段，通过引入该片段。如：Sql语句的查询字段起与POJO属性相同的别名，该Sql片段就可以重用

<sql id="selectAllField">
    select tid as id,tname as teacherName
</sql>
<select id="findAll" resultType="com.package.pojo.Teacher">
    <include refid="selectAllField"></include>
    from teacher;
</select>
<select id="findById" resultType="com.package.pojo.Teacher">
    <include refid="selectAllField"></include>
    from teacher where tid = #{id}
</select>

3.特殊字符处理

在Mybatis映射文件中尽量不要使用一些特殊字符，如：<，>等。

我们可以使用符号的实体来表示：

1<select id="findById2" resultType="com.package.pojo.Teacher">
2    <include refid="selectAllField"></include>
3    from teacher where tid &gt; #{id}
4</select>

六、MyBatis动态Sql

一个查询的方法的Sql语句不一定是固定的。比如电商网站的查询商品，用户使用不同条件查询，Sql语句就会添加不同的查询条件。此时就需要在方法中使用动态Sql语句。

1.if

标签内的Sql片段在满足条件后才会添加，用法为：。例如：根据不同条件查询用户：

1.持久层接口添加方法

1// 用户通用查询
2List<User> findByCondition(User user);

2.映射文件添加标签

1<select id="findByCondition" parameterType="com.package.pojo.User" resultType="com.package.pojo.User">
2    select * from user where 1 = 1
3    <if test="username != null and username.length() != 0">
4        and username like #{username}
5    </if>
6    <if test="sex != null and sex.length() != 0">
7        and sex = #{sex}
8    </if>
9    <if test="address != null and address.length() != 0">
10        and address = #{address}
11    </if>
12</select>

3.编写测试方法

1@Test
2public void testFindByCondition(){
3    User user = new User();
4    List<User> users1 = userMapper2.findByCondition(user);
5    //users1.forEach(System.out::println);
6
7    user.setUsername("%JSON%");
8    List<User> users2 = userMapper2.findByCondition(user);
9    users2.forEach(System.out::println);
10
11    user.setAddress("earth");
12    List<User> users3 = userMapper2.findByCondition(user);
13    users3.forEach(System.out::println);
14}

1.if中的条件不能使用&&/||，而应该使用and/or

2.if中的条件可以直接通过属性名获取参数POJO的属性值，并且该值可以调用方法。

3.where后为什么要加1=1？
任意条件都可能拼接到Sql中。如果有多个条件，从第二个条件开始前都需要加And关键字。加上1=1这个永久成立的条件，就不需要考虑后面的条件哪个是第一个条件，后面的条件前都加And关键字即可。

2.where

可以代替sql中的where 1=1 和第一个and，更符合程序员的开发习惯，使用后的映射文件如下：

1<select id="findByCondition" resultType="com.package.user.User" parameterType="com.package.user.User">
2    select * from user
3    <where>
4        <if test="username != null and username.length() != 0">
5            username like #{username}
6        </if>
7        <if test="sex != null and sex.length() != 0">
8            and sex = #{sex}
9        </if>
10    </where>
11</select>

3.set

标签用在update语句中。借助，可以只对有具体值的字段进行更新。会自动添加set关键字，并去掉最后一个if语句中多余的逗号。

1<update id="update" parameterType="com.package.user.User">
2    update user
3    <set>
4        <if test="username != null and username.length() > 0">
5            username = #{username},
6        </if>
7        <if test="sex != null and sex.length() > 0">
8            sex = #{sex},
9        </if>
10    </set>
11    <where>
12        id = #{id}
13    </where>
14</update>

4.when、choose、otherwise

这些标签表示多条件分支，类似JAVA中的switch...case。类似switch，类似case，类似default，用法如下：

1<select id="findByCondition" resultType="com.package.user.User" parameterType="com.package.user.User">
2    select * from user
3    <where>
4        <choose>
5            <when test="username.length() < 5">
6                username like #{username}
7            </when>
8            <when test="username.length() < 10">
9                username = #{username}
10            </when>
11            <otherwise>
12                id = 1
13            </otherwise>
14        </choose>
15    </where>
16</select>

这段代码的含义为：用户名<5时使用模糊查询，用户名>=5并且<10时使用精确查询，否则查询id为1的用户

5.foreach

类似JAVA中的for循环，可以遍历集合或数组。有如下属性：

collection：遍历的对象类型
open：开始的sql语句
close：结束的sql语句
separator：遍历每项间的分隔符
item：表示本次遍历获取的元素，遍历List、Set、数组时表示每项元素，遍历map时表示键值对的值。
index：遍历List、数组时表示遍历的索引，遍历map时表示键值对的键。

遍历数组
我们使用遍历数组进行批量删除。

1.持久层接口添加方法

1void deleteBatch(int[] ids);

2.映射文件添加标签

1<delete id="deleteBatch" parameterType="int">
2    delete from user
3    <where>
4        <foreach open="id in(" close=")" separator="," collection="array" item="id" >
5            #{id}
6        </foreach>
7    </where>
8</delete>

3.编写测试方法

1@Test
2public void testDeleteBatch(){
3    int[] ids = {9,11};
4    userMapper.deleteBatch(ids);
5    session.commit();
6}

遍历Collection
遍历List和Set的方法是一样的，我们使用遍历List进行批量添加。

1.持久层接口添加方法

1void insertBatch(List<User> users);

2.映射文件添加标签

1<insert id="insertBatch" parameterType="com.package.user.User">
2    insert into user values
3    <foreach collection="list" item="user" separator=",">
4        (null ,#{user.username},#{user.birthday},#{user.sex},#{user.address})
5    </foreach>
6</insert>

3.编写测试方法

1@Test
2public void testDeleteBatch(){
3    int[] ids = {1,2,3};
4    userMapper.deleteBatch(ids);
5    session.commit();
6}

遍历Map
我们使用遍历Map进行多条件查询。

1.持久层接口添加方法

1/**
2     * 多条件查询
3     * @param map 查询的条件键值对 键：属性名 值：属性值
4     * @return
5     */
6List<User> findUser(@Param("queryMap") Map<String,Object> map);

2.映射文件添加标签

1<select id="findUser" parameterType="map" resultType="com.package.pojo.User">
2    select * from user
3    <where>
4        <foreach collection="queryMap" separator="and" index="key" item="value">
5            ${key} = #{value}
6        </foreach>
7    </where>
8</select>

3.编写测试方法

1@Test
2public void testFindUser(){
3    Map<String,Object> queryMap = new HashMap();
4    queryMap.put("sex","女");
5    queryMap.put("address","Mars");
6    List<User> users = userMapper2.findUser(queryMap);
7    users.forEach(System.out::println);
8}

七、MyBatis缓存

1.缓存介绍

缓存是内存当中一块存储数据的区域，目的是提高查询效率。MyBatis会将查询结果存储在缓存当中，当下次执行相同的SQL时不访问数据库，而是直接从缓存中获取结果，从而减少服务器的压力。

什么是缓存？
存在于内存中的一块数据。

缓存有什么作用？
减少程序和数据库的交互，提高查询效率，降低服务器和数据库的压力。

什么样的数据使用缓存？
经常查询但不常改变的，改变后对结果影响不大的数据。

MyBatis缓存分为哪几类？
一级缓存和二级缓存

如何判断两次Sql是相同的？
1.查询的Sql语句相同
2.传递的参数值相同
3.对结果集的要求相同
4.预编译的模板Id相同

2.MyBatis一级缓存

MyBatis一级缓存也叫本地缓存。SqlSession对象中包含一个Executor对象，Executor对象中包含一个PerpetualCache对象，在该对象存放一级缓存数据。

由于一级缓存是在SqlSession对象中，所以只有使用同一个SqlSession对象操作数据库时才能共享一级缓存。

MyBatis的一级缓存是默认开启的，不需要任何的配置。

测试一级缓存

1@Test
2public void testCache1() throws IOException {
3    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
4    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
5    SqlSessionFactory factory = builder.build(is);
6    SqlSession session = factory.openSession();
7
8    // 使用同一个SqlSession查询
9    UserMapper mapper1 = session.getMapper(UserMapper.class);
10    UserMapper mapper2 = session.getMapper(UserMapper.class);
11
12    User user1 = mapper1.findById(1);
13    System.out.println(user1.hashCode());
14    System.out.println("-------------------------------------------");
15    User user2 = mapper2.findById(1);
16    System.out.println(user2.hashCode());
17}
18
19@Test
20public void testCache2() throws IOException {
21    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
22    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
23    SqlSessionFactory factory = builder.build(is);
24    SqlSession session1 = factory.openSession();
25    SqlSession session2 = factory.openSession();
26
27    // 使用不同的SqlSession查询
28    UserMapper mapper1 = session1.getMapper(UserMapper.class);
29    UserMapper mapper2 = session2.getMapper(UserMapper.class);
30
31    User user1 = mapper1.findById(1);
32    System.out.println(user1.hashCode());
33    System.out.println("-------------------------------------------");
34    User user2 = mapper2.findById(1);
35    System.out.println(user2.hashCode());
36}

3.清空一级缓存

进行以下操作可以清空MyBatis一级缓存：

1.SqlSession调用close()：操作后SqlSession对象不可用，该对象的缓存数据也不可用。
2.SqlSession调用clearCache()/commit()：操作会清空一级缓存数据。
3.SqlSession调用增删改方法：操作会清空一级缓存数据，因为增删改后数据库发生改变，缓存数据将不准确。

1@Test
2public void testCache3() throws IOException {
3    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
4    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
5    SqlSessionFactory factory = builder.build(is);
6    SqlSession session = factory.openSession();
7
8    UserMapper mapper1 = session.getMapper(UserMapper.class);
9    UserMapper mapper2 = session.getMapper(UserMapper.class);
10
11    User user1 = mapper1.findById(1);
12    System.out.println(user1.hashCode());
13    //        session.close();
14    //        session.clearCache();
15    //        session.commit();
16    mapper1.delete(2);
17    System.out.println("-------------------------------------------");
18    User user2 = mapper2.findById(1);
19    System.out.println(user2.hashCode());
20}

4.MyBatis二级缓存

MyBatis二级缓存也叫全局缓存。数据存放在SqlSessionFactory中，只要是同一个工厂对象创建的SqlSession，在进行查询时都能共享数据。一般在项目中只有一个SqlSessionFactory对象，所以二级缓存的数据是全项目共享的。

MyBatis一级缓存存放的是对象，二级缓存存放的是对象的数据。所以要求二级缓存存放的POJO必须是可序列化的，也就是要实现Serializable接口。

MyBatis二级缓存默认不开启，手动开启后数据先存放在一级缓存中，只有一级缓存数据清空后，数据才会存到二级缓存中。

SqlSession调用clearCache()无法将数据存到二级缓存中。

开启二级缓存
1.POJO类实现Serializable接口。

1public class User implements Serializable {
2    private int id;
3    private String username;
4    private String sex;
5    private String address;
6}

2.在MyBatis配置文件添加如下设置：

1<settings>
2    <setting name="cacheEnabled" value="true"/>
3</settings>

由于cacheEnabled默认值是true，所以该设置可以省略。

3.在映射文件添加标签，该映射文件下的所有方法都支持二级缓存。

如果查询到的集合中对象过多，二级缓存只能缓存1024个对象引用。可以通过标签的size属性修改该数量。

1<cache size="2048"/>

4.测试二级缓存

1@Test
2public void testCache4() throws IOException {
3    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
4    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
5    SqlSessionFactory factory = builder.build(is);
6    SqlSession session1 = factory.openSession();
7    SqlSession session2 = factory.openSession();
8
9    UserMapper mapper1 = session1.getMapper(UserMapper.class);
10    UserMapper mapper2 = session2.getMapper(UserMapper.class);
11
12    User user1 = mapper1.findById(1);
13    System.out.println(user1);
14    System.out.println(user1.hashCode());
15    // 让一级缓存失效
16    session1.commit();
17    System.out.println("-------------------------------------------");
18
19    User user2 = mapper2.findById(1);
20    System.out.println(user2);
21    System.out.println(user2.hashCode());
22}

八、MyBatis关联查询

MyBatis的关联查询分为一对一关联查询和一对多关联查询。

查询对象时，将关联的另一个对象查询出来，就是一对一关联查询。
查询对象时，将关联的另一个对象的集合查询出来，就是一对多关联查询。

例如有学生类和班级类：

一个学生对应一个班级，也就是学生类中有一个班级属性，这就是一对一关系。

一个班级对应多个学生，也就是班级类中有一个学生集合属性，这就是一对多关系。

实体类设计如下：

1public class Student {
2    private int sid;
3    private String name;
4    private int age;
5    private String sex;
6    private Classes classes;
7    // 省略getter/setter/toString
8}
9
10public class Classes {
11    private int cid;
12    private String className;
13    private List<Student> studentList;
14    // 省略getter/setter/toString
15}

数据库设计如下：

1.一对一关联查询

查询学生时，将关联的一个班级对象查询出来，就是一对一关联查询。

创建持久层接口

1public interface StudentMapper {
2    List<Student> findAll();
3}

创建映射文件

1<resultMap id="studentMapper" type="com.package.pojo.Student">
2    <!-- 主键列 -->
3    <id property="sid" column="sid"></id>
4    <!-- 普通列 -->
5    <result property="name" column="name"></result>
6    <result property="age" column="age"></result>
7    <result property="sex" column="sex"></result>
8    <!-- 一对一对象列 property:属性名  column:关联列名 javaType：对象类型-->
9    <association property="classes" column="classId" javaType="com.package.pojo.Classes">
10        <!-- 关联对象主键列 -->
11        <id property="cid" column="cid"></id>
12        <!-- 关联对象普通列 -->
13        <result property="className" column="className"></result>
14    </association>
15</resultMap>
16
17<!-- 多表查询，级联查询学生和其班级 -->
18<select id="findAll" resultMap="studentMapper">
19    select * from student left join classes on student.classId = classes.cid;
20</select>

配置文件注册映射文件

1<mappers>
2    <package name="com.package.mapper"/>
3</mappers>

测试一对一关联查询

1InputStream is = null;
2SqlSession session = null;
3
4@Before
5public void before() throws IOException {
6    is = Resources.getResourceAsStream("SqlMapConfig.xml");
7    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
8    SqlSessionFactory factory = builder.build(is);
9    session = factory.openSession();
10}
11
12@After
13public void after() throws IOException {
14    session.close();
15    is.close();
16}
17
18@Test
19public void testFindAllStudent(){
20    StudentMapper studentMapper = session.getMapper(StudentMapper.class);
21    List<Student> all = studentMapper.findAll();
22    all.forEach(System.out::println);
23}

2.一对多关联查询

查询班级时，将关联的学生集合查询出来，就是一对多关联查询。

创建持久层接口

1public interface ClassesMapper {
2    List<Classes> findAll();
3}

创建映射文件

1<resultMap id="classesMapper" type="com.package.pojo.Classes">
2    <id property="cid" column="cid"></id>
3    <result property="className" column="className"></result>
4    <!-- 集合列  property：属性名  column：关联列名 ofType：集合的泛型 -->
5    <collection property="studentList" column="classId" ofType="com.package.pojo.Student">
6        <id property="sid" column="sid"></id>
7        <result property="name" column="name"></result>
8        <result property="age" column="age"></result>
9        <result property="sex" column="sex"></result>
10    </collection>
11</resultMap>
12
13<!-- 多表查询，级联查询班级和它的学生 -->
14<select id="findAll" resultMap="classesMapper">
15    select * from classes left join student  on classes.cid = student.classId;
16</select>

测试一对多关联查询

1@Test
2public void testFindAllClasses() {
3    ClassesMapper classesMapper = session.getMapper(ClassesMapper.class);
4    List<Classes> all = classesMapper.findAll();
5    all.forEach(System.out::println);
6}

3.多对多关联查询

MyBatis多对多关联查询本质就是两个一对多关联查询。

例如有老师类和班级类：

一个老师对应多个班级，也就是老师类中有一个班级集合属性。

一个班级对应多个老师，也就是班级类中有一个老师集合属性。

实体类设计如下：

1public class Teacher {
2    private Integer tid;
3    private String tname;
4    private List<Classes> classes;
5    // 省略getter/setter/toString
6}
7
8public class Classes {
9    private Integer cid;
10    private String className;
11    private List<Student> studentList;
12    private List<Teacher> teacherList;
13    // 省略getter/setter/toString
14}

在数据库设计中，需要建立中间表，双方与中间表均为一对多关系。

接下来测试查询老师时，将关联的班级集合查询出来。

创建持久层接口

1public interface TeacherMapper {
2    List<Teacher> findAll();
3}

创建映射文件

1<resultMap id="teacherMapper" type="com.package.pojo.Teacher">
2    <id column="tid" property="tid"></id>
3    <result column="tname" property="tname"></result>
4    <collection property="classes" column="tid" ofType="com.package.pojo.Classes">
5        <id column="cid" property="cid"></id>
6        <result column="className" property="className"></result>
7    </collection>
8</resultMap>
9
10<select id="findAll" resultMap="teacherMapper">
11    select *
12    from teacher
13    left join classes_teacher
14    on teacher.tid = classes_teacher.tid
15    left join classes
16    on classes_teacher.cid = classes.cid
17</select>

测试多对多关联查询

1@Test
2public void testFindAllTeacher() {
3    TeacherMapper teacherMapper = session.getMapper(TeacherMapper.class);
4    List<Teacher> all = teacherMapper.findAll();
5    all.forEach(System.out::println);
6}

如果想查询班级时，将关联的老师集合查询出来，只需要修改班级映射文件的Sql语句和即可：

1<resultMap id="classesMapper" type="com.package.pojo.Classes">
2    <id property="cid" column="cid"></id>
3    <result property="className" column="className"></result>
4    <!-- 集合列  property：属性名  column：关联列名 ofType：集合的泛型 -->
5    <collection property="studentList" column="classId" ofType="com.package.pojo.Student">
6        <id property="sid" column="sid"></id>
7        <result property="name" column="name"></result>
8        <result property="age" column="age"></result>
9        <result property="sex" column="sex"></result>
10    </collection>
11    <collection property="teacherList" column="cid" ofType="com.package.pojo.Teacher">
12        <id property="tid" column="tid"></id>
13        <result property="tname" column="tname"></result>
14    </collection>
15</resultMap>
16
17<select id="findAll" resultMap="classesMapper">
18    select *
19    from classes
20    left join student
21    on classes.cid = student.classId
22    left join classes_teacher
23    on classes.cid = classes_teacher.cid
24    left join teacher
25    on classes_teacher.tid = teacher.tid;
26</select>

4.一对一分解式查询

查询学生时关联查询出班级也可以使用分解式查询，首先将查询语句分开：

1select * from student;
2select * from classes where cid = ?;

创建每个查询语句的持久层方法

1public interface StudentMapper {
2     // 查询所有学生
3    List<Student> findAll();
4}
5
6public interface ClassesMapper {
7    // 根据ID查询班级
8    Classes findByCid(int cid);
9}

在映射文件中进行配置

1<select id="findAll" resultType="com.package.pojo.Student">
2    select *
3    from student
4</select>
5
6<select id="findByCid" resultType="com.package.pojo.Classes" parameterType="int">
7    select * from classes where cid = ${cid}
8</select>

修改主表映射文件中的查询方法

1<resultMap id="MyStudentMapper" type="com.package.pojo.Student">
2    <id property="sid" column="sid"></id>
3    <result property="name" column="name"></result>
4    <result property="age" column="age"></result>
5    <result property="sex" column="sex"></result>
6    <association property="classes"
7                 javaType="com.package.pojo.Classes"
8                 select="com.package.mapper2.ClassesMapper2.findByCid"
9                 column="classId">
10    </association>
11</resultMap>
12
13<select id="findAll" resultMap="MyStudentMapper">
14    select *
15    from student
16</select>

测试查询方法

1@Test
2public void testFindAllStudent2(){
3    StudentMapper2 studentMapper2 = session.getMapper(StudentMapper2.class);
4    List<Student> all = studentMapper2.findAll();
5    all.forEach(System.out::println);
6}

5.一对多分解式查询

在MyBatis多表查询中，使用连接查询时一个Sql语句就可以查询出所有的数据。如：

1# 查询班级时关联查询出学生
2select *
3    from classes
4    left join student
5    on student.classId = classes.cid

也可以使用分解式查询，即将一个连接Sql语句分解为多条Sql语句，如：

1# 查询班级时关联查询出学生
2select * from classes;
3select * from student where classId = 1;
4select * from student where classId = 2;  

这种写法也叫N+1查询。

连接查询：
优点：降低查询次数，从而提高查询效率。
缺点：如果查询返回的结果集较多会消耗内存空间。

N+1查询：
优点：结果集分步获取，节省内存空间。
缺点：由于需要执行多次查询，相比连接查询效率低。

我们以查询班级时关联查询出学生为例，使用N+1查询：

创建每个查询语句的持久层方法

1public interface ClassesMapper {
2    // 查询所有班级
3    List<Classes> findAll();
4}
5
6public interface StudentMapper {
7    // 根据班级Id查询学生
8    List<Student> findByClassId(int classId);
9}

在映射文件中进行配置

1<select id="findAll" resultType="com.package.pojo.Classes">
2    select * from classes
3</select>
4
5<select id="findByClassId" resultType="com.package.pojo.Student" parameterType="int">
6    select * from student where classId = ${classId}
7</select>

修改主表映射文件中的查询方法

1<!-- 自定义映射关系   -->
2<resultMap id="MyClassesMapper" type="com.package.pojo.Classes">
3    <id property="cid" column="cid"></id>
4    <result property="className" column="className"></result>
5    <!-- select：从表查询调用的方法  column：调用方法时传入的参数字段    -->
6    <collection property="studentList"
7                ofType="com.package.pojo.Student"             select="com.package.mapper2.StudentMapper2.findByClassId"
8                column="cid">
9    </collection>
10</resultMap>
11
12<select id="findAll" resultMap="MyClassesMapper">
13    select * from classes
14</select>

测试查询方法

1@Test
2public void testFindAllClasses2(){
3    ClassesMapper2 classesMapper2 = session.getMapper(ClassesMapper2.class);
4    List<Classes> all = classesMapper2.findAll();
5    all.forEach(System.out::println);
6}

6.延迟加载

分解式查询又分为两种加载方式：

立即加载：在查询主表时就执行所有的Sql语句。
延迟加载：又叫懒加载，首先执行主表的查询语句，使用从表数据时才触发从表的查询语句。

延迟加载在获取关联数据时速度较慢，但可以节约资源，即用即取。

开启延迟加载
设置所有的N+1查询都为延迟加载：

1<settings>
2    <setting name="lazyLoadingEnabled" value="true"/>
3</settings>

设置某个方法为延迟加载：

在、中添加fetchType属性设置加载方式。lazy：延迟加载；eager：立即加载。

测试延迟加载

1@Test
2public void testFindAllClasses2(){
3    ClassesMapper2 classesMapper2 = session.getMapper(ClassesMapper2.class);
4    List<Classes> all = classesMapper2.findAll();
5    all.forEach(System.out::println);
6    System.out.println("-------------------------");
7    System.out.println(all.get(0).getStudentList());
8}

由于打印对象时会调用对象的toString方法，toString方法默认会触发延迟加载的查询，所以我们无法测试出延迟加载的效果。
解决方法：
我们在配置文件设置lazyLoadTriggerMethods属性，该属性指定对象的什么方法触发延迟加载，设置为空字符串即可。

1<settings>
2    <setting name="lazyLoadTriggerMethods" value=""/>
3</settings>

什么时候使用延迟加载？
一般情况下，一对多查询使用延迟加载，一对一查询使用立即加载。

九、MyBatis注解开发

MyBatis可以使用注解替代映射文件。映射文件的作用就是定义Sql语句，可以在持久层接口上使用@Select/@Delete/@Insert/@Update定义Sql语句，这样就不需要使用映射文件了。

1.环境搭建

1.创建maven工程，引入依赖

2.创建mybatis核心配置文件SqlMapConfig.xml

3.将log4j.properties文件放入resources中，让控制台打印SQL语句。

4.创建实体类

5.创建持久层接口，并在接口方法上定义Sql语句

1public interface UserMapper {
2    @Select("select * from user")
3    List<User> findAll();
4}

由于注解在方法上方，而方法中就有参数类型和返回值类型，所以使用注解开发不需要定义参数类型和返回值类型

6.在核心配置文件注册持久层接口，由于没有映射文件，所以只能采用注册接口或注册包的方法。

1<mappers>
2    <package name="com.package.mapper"/>
3</mappers>

7.测试方法

1InputStream is = null;
2SqlSession session = null;
3UserMapper userMapper = null;
4
5@Before
6public void before() throws IOException {
7    is = Resources.getResourceAsStream("SqlMapConfig.xml");
8    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
9    SqlSessionFactory factory = builder.build(is);
10    session = factory.openSession();
11    userMapper = session.getMapper(UserMapper.class);
12}
13
14@After
15public void after() throws IOException {
16    session.close();
17    is.close();
18}
19
20
21@Test
22public void testFindAll(){
23    List<User> all = userMapper.findAll();
24    all.forEach(System.out::println);
25}

2.增删改查

接下来写一套基于MyBatis注解的增删改查方法：

1@SelectKey(keyColumn = "id", keyProperty = "id", resultType = int.class,before = false, statement = "SELECT LAST_INSERT_ID()")
2@Insert("insert into user(username,sex,address) values(#{username},#{sex},#{address})")
3void add(User user);
4
5@Update("update user set username = #{username},sex=#{sex},address=#{address} where id = #{id}")
6void update(User user);
7
8@Delete("delete from user where id = #{id}")
9void delete(int id);
10
11@Select("select * from user where username like #{username}")
12List<User> findByUsernameLike(String username);

3.动态sql

MyBatis注解开发中有两种方式构建动态Sql：

使用脚本标签
将Sql嵌套在") 16List<User> findByCondition(User user);

在方法中构建动态Sql
在MyBatis中有@SelectProvider、@UpdateProvider、@DeleteProvider、@InsertProvider注解。当使用这些注解时将不在注解中直接编写SQL，而是调用某个类的方法来生成SQL。

1// 生成根据任意条件查询的Sql语句
2public String findByConditionSql(User user){
3    StringBuffer sb = new StringBuffer("select * from user where 1=1 ");
4    if (user.getUsername() != null && user.getUsername().length() != 0){
5        sb.append(" and username like #{username} ");
6    }
7    if (user.getSex() != null && user.getSex().length() != 0){
8        sb.append(" and sex = #{sex} ");
9    }
10    if (user.getAddress() != null && user.getAddress().length() != 0){
11        sb.append(" and address = #{address} ");
12    }
13    return sb.toString();
14}

4.自定义映射关系

当POJO属性名与数据库列名不一致时，需要自定义实体类和结果集的映射关系，在MyBatis注解开发中，使用@Results定义并使用自定义映射，使用@ResultMap使用自定义映射，用法如下：

1// 查询所有用户
2@Results(id = "userDiyMapper" ,value = {
3    @Result(id = true,property = "id",column = "id"),
4    @Result(property = "username",column = "username1"),
5    @Result(property = "sex",column = "sex1"),
6    @Result(property = "address",column = "address1"),
7})
8@Select("select * from user")
9List<User> findAll();
10
11// 根据id查询
12@ResultMap("userDiyMapper")
13@Select("select * from user where id = #{id}")
14User findById(int id);

5.二级缓存

MyBatis默认开启一级缓存，接下来我们学习如何在注解开发时使用二级缓存：

1.POJO类实现Serializable接口。

2.在MyBatis配置文件添加如下设置：

1<settings>
2    <setting name="cacheEnabled" value="true"/>
3</settings>

3.在持久层接口上方加注解@CacheNamespace(blocking=true)，该接口的所有方法都支持二级缓存。

4.测试二级缓存

1@Test
2public void testCache() throws IOException {
3    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
4    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
5    SqlSessionFactory factory = builder.build(is);
6    SqlSession session1 = factory.openSession();
7    SqlSession session2 = factory.openSession();
8
9    User user1 = session1.getMapper(UserMapper.class).findById(1);
10    System.out.println(user1);
11    System.out.println(user1.hashCode());
12    session1.commit(); // 清空一次缓存，将数据存到二级缓存
13    User user2 = session2.getMapper(UserMapper.class).findById(1);
14    System.out.println(user2);
15    System.out.println(user2.hashCode());
16
17}

6.一对一关联查询

在MyBatis的注解开发中对于多表查询只支持分解查询，不支持连接查询。

1.创建实体类

1public class Student {
2    private int sid;
3    private String name;
4    private int age;
5    private String sex;
6    private Classes classes;
7    // 省略getter/setter/toString
8}
9
10public class Classes {
11    private int cid;
12    private String className;
13    private List<Student> students;
14    // 省略getter/setter/toString
15}

2.创建分解后的查询方法

1public interface StudentMapper {
2    @Select("select * from student")
3    List<Student> findAll();
4}
5
6public interface ClassesMapper {
7    // 根据id查询班级
8    @Select("select * from classes where cid = #{cid}")
9    Classes findByCid(Integer cid);
10}

3.主表的查询配置自定义映射关系

1@Select("select * from student")
2// 自定义映射关系
3@Results(id = "studentMapper",value = {
4    @Result(id = true,property = "sid",column = "sid"),
5    @Result(property = "name",column = "name"),
6    @Result(property = "age",column = "age"),
7    @Result(property = "sex",column = "sex"),
8    /**
9             * property:属性名
10             * column:调用从表方法时传入的参数列
11             * one:表示该属性是一个对象
12             * select：调用的从表方法
13             * fetchType：加载方式
14             */
15    @Result(property = "classes",column = "classId",
16            one = @One(select = "com.package.mapper.ClassesMapper.findByCid",
17                       fetchType = FetchType.EAGER))
18})
19List<Student> findAll();

4.测试

1@Test
2public void findAllStudent(){
3    StudentMapper studentMapper = session.getMapper(StudentMapper.class);
4    List<Student> all = studentMapper.findAll();
5    all.forEach(System.out::println);
6}

7.一对多关联查询

创建分解后的查询方法

1public interface ClassesMapper {
2    // 查询所有班级
3    @Select("select * from classes")
4    List<Classes> findAll();
5}
6
7public interface StudentMapper {
8    // 根据班级id查询学生
9    @Select("select * from student where classId = #{classId}")
10    List<Student> findByClassId(int classId);
11}

主表的查询配置自定义映射关系

1// 查询所有班级
2@Select("select * from classes")
3@Results(id = "classMapper", value = {
4    @Result(id = true, property = "cid", column = "cid"),
5    @Result(property = "className", column = "className"),
6    // many：表示该属性是一个集合
7    @Result(property = "studentList", column = "cid",
8            many = @Many(select = "com.package.mapper.StudentMapper.findByClassId",
9                         fetchType = FetchType.LAZY))
10})
11List<Classes> findAll();

测试

1@Test
2public void findAllClasses(){
3    ClassesMapper classesMapper = session.getMapper(ClassesMapper.class);
4    List<Classes> all = classesMapper.findAll();
5    all.forEach(System.out::println);
6}

8.注解开发与映射文件开发的对比

MyBatis中更推荐使用映射文件开发，Spring、SpringBoot更推荐注解方式。具体使用要视项目情况而定。它们的优点对比如下：

映射文件：

代码与Sql语句是解耦的，修改时只需修改配置文件，无需修改源码。
Sql语句集中，利于快速了解和维护项目。
级联查询支持连接查询和分解查询两种方式，注解开发只支持分解查询。

注解：

配置简单，开发效率高。
类型安全，在编译期即可进行校验，不用等到运行时才发现错误。

十、PageHelper分页插件

开发过程中如果要进行分页查询，需要传入页数和每页条数。返回页面数据，总条数，总页数，当前页面，每页条数等数据。此时使用PageHelper插件可以快速帮助我们获取这些数据。

PageHelper是开源免费的Mybatis第三方分页插件。使用该插件时，只要传入分页参数，即可自动生成页面对象。我们使用该插件分页查询所有用户：

1.引入依赖

1<!-- PageHelper -->
2<dependency>
3    <groupId>com.github.pagehelper</groupId>
4    <artifactId>pagehelper</artifactId>
5    <version>5.3.0</version>
6</dependency>

2.Mybatis配置文件中配置PageHelper插件

1<plugins>
2    <plugin interceptor="com.github.pagehelper.PageInterceptor">
3        <!-- 设置数据库类型-->
4        <property name="helperDialect" value="mysql"/>
5    </plugin>
6</plugins>

3.使用PageHelper插件

1@Test
2public void testFindPage() {
3    // (1)查询前设置分页参数，参数一：页数，从1开始。参数二：每页条数
4    PageHelper.startPage(1, 3);
5    // (2)正常查询
6    List<User> all = userMapper.findAll();
7    // (3)创建页面对象，创建时将查询结果传入构造方法
8    PageInfo pageInfo = new PageInfo(all);
9    // (4)打印页面对象的属性
10    System.out.println("结果集："+pageInfo.getList());
11    System.out.println("总条数："+pageInfo.getTotal());
12    System.out.println("总页数"+pageInfo.getPages());
13    System.out.println("当前页"+pageInfo.getPageNum());
14    System.out.println("每页条数"+pageInfo.getSize());
15}

十一、MyBatis Generator

1.工具引入

MyBatis Generator（MBG）是MyBatis官方提供的代码生成器。它可以根据数据库的表结构自动生成POJO类、持久层接口与映射文件，极大减少了代码的编写量，提高开发效率。

MBG可以作为项目引入使用，也可以作为Maven插件使用，其中作为Maven插件使用更加方便快捷。

1.准备数据库表

2.在pom文件中配置MBG插件

1<build>
2    <plugins>
3        <plugin>
4            <groupId>org.mybatis.generator</groupId>
5            <artifactId>mybatis-generator-maven-plugin</artifactId>
6            <version>1.3.7</version>
7            <configuration>
8                <!-- MBG配置文件位置 -->
9                        <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
10                <!-- 运行显示详情 -->
11                <verbose>true</verbose>
12                <!-- 允许覆盖文件 -->
13                <overwrite>true</overwrite>
14            </configuration>
15        </plugin>
16    </plugins>
17</build>

3.编写MBG配置文件

1<?xml version="1.0" encoding="UTF-8"?>
2<!DOCTYPE generatorConfiguration
3        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
4        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
5
6<generatorConfiguration>
7    <!-- jdbc的jar包位置，插件需要连接数据库 -->   
8    <classPathEntry location="F:\repository\mysql\mysql-connector-java\8.0.26\mysql-connector-java-8.0.26.jar"/>
9    
10    <context id="default" targetRuntime="MyBatis3">
11        <!-- 是否去除自动生成的注释-->
12        <commentGenerator>
13            <property name="suppressAllComments" value="true"/>
14        </commentGenerator>
15        
16        <!--数据库连接参数-->
17        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
18                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
19                        userId="root"
20                        password="root"></jdbcConnection>
21
22        <!-- 类型处理器，在数据库类型和java类型之间的转换控制-->
23        <javaTypeResolver>
24            <property name="forceBigDecimals" value="false"/>
25        </javaTypeResolver>
26
27        <!-- targetProject:JAVA类路径  targetProject:生成的POJO类的包-->
28        <javaModelGenerator targetProject="src/main/java" targetPackage="com.package.pojo">
29            <!-- 是否生成子包 -->
30            <property name="enableSubPackages" value="false"/>
31            <!-- 设置是否在getter方法中，对String类型字段调用trim()方法 -->
32            <property name="trimStrings" value="true"/>
33        </javaModelGenerator>
34
35        <!-- targetProject:配置文件路径 targetPackage:生成映射文件的位置 -->
36        <sqlMapGenerator targetProject="src/main/resources" targetPackage="com.package.mapper">
37            <!-- 是否生成子包 -->
38            <property name="enableSubPackages" value="false"/>
39        </sqlMapGenerator>
40
41        <!-- targetPackage：JAVA类路径 targetProject:生成的持久层接口包 -->
42        <javaClientGenerator targetProject="src/main/java" targetPackage="com.package.mapper" type="XMLMAPPER">
43            <!-- 是否生成子包 -->
44            <property name="enableSubPackages" value="false"/>
45        </javaClientGenerator>
46
47        <!-- 数据库表，表名不要和其他库中的表名一样 -->
48        <table tableName="product"></table>
49    </context>
50</generatorConfiguration>

4.运行插件，自动生成POJO，持久层接口，映射文件：

Product.java：POJO类

ProductMapper.java：持久层接口

ProductMapper.xml：映射文件

ProductExample.java：查询扩展类，该类可以构造复杂的查询条件。

Criterion：代表一个字段。
GeneratedCriteria：抽象类，生成查询条件的工具。
Criteria：GeneratedCriteria的子类，生成查询条件的工具。

5.在配置文件中注册生成的映射文件

1<mappers>
2    <mapper class="com.package.mapper.ProductMapper">         </mapper>
3</mappers>

2.增删改方法

1public class TestMBG {
2    InputStream is = null;
3    SqlSession session = null;
4    ProductMapper productMapper = null;
5
6    @Before
7    public void before() throws IOException {
8        is = Resources.getResourceAsStream("SqlMapConfig.xml");
9        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
10        SqlSessionFactory factory = builder.build(is);
11        session = factory.openSession();
12        productMapper = session.getMapper(ProductMapper.class);
13    }
14
15    @After
16    public void after() throws IOException {
17        session.close();
18        is.close();
19    }
20
21    // 新增
22    @Test
23    public void testAdd(){
24        Product product = new Product("包子", 1.0);
25        productMapper.insert(product);
26        session.commit();
27    }
28    // 修改
29    @Test
30    public void testUpdate(){
31        Product product = new Product(4,"馒头", 0.8);
32        productMapper.updateByPrimaryKey(product);
33        session.commit();
34    }
35    // 删除
36    @Test
37    public void testDelete(){
38        productMapper.deleteByPrimaryKey(4);
39        session.commit();
40    }
41
42}