整合Log4j

通过日志信息，可以阅读mybatis执行情况，观察mybatis实际执行sql语句以及SQL中的参数和返回结果。

常见日志有这些：SLF4J 、Apache Commons Logging、Log4j2、Log4j 、JDK logging。这里我们使用Log4j。

第一步是导入jar包。mybatis.zip文件中的lib目录下有log4j的jar包，如果没有的可以自行去下载。

第二步是在conf中开启日志。在settings标签中开启：

 <settings>
<!--        开启日志，并指定使用的日志-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

value属性指定了使用的日志类型，如果不指定，MyBatis就会按照以下的顺序去寻找：

SLF4J →Apache Commons Logging→Log4j2→Log4j → JDK logging

尤其要注意name属性的内容严格区分大小写。

第三步编写配置日志输出文件log4j.properties

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

第一行表示日志输出debug类型的信息，且输出到标准输出流中，日志级别DEBUG< INFO<WARN<ERROR；第二行表明日志显示的方式是追加显示到控制台中；第三行表示日志显示的样式，可以是平铺的也可以是竖列的；最后一行表示日志信息的输出格式。后面三行不重要。

log4j.properties文件名必须和使用的日志的jar包类型一致，因为在setting中指定了value之后MyBatis会自动寻找这个log4j.properties文件。

延迟加载

延迟加载是指在一对一、一对多、多对一、多对多等设计多个表的查询时，首先查询指定的表的结果，延时查询所关联的表的结果。只有当需要用到关联表的结果时（在java中使用到了所关联表的实体类对象），MyBatis才会根据指定查询的表的外键去查询所关联表的结果。意思是原本查询结果涉及两个表，需要用一个sql语句执行完，查询的范围也是两张表的所有元组，现在延时加载后将一个sql语句分为两个分别查询两张表的语句，首先只执行一个，当需要用到第二个表的结果时再去查询第二个。

首先需要开启延迟加载。延迟加载需要手动开启，在conf.xml文件中要先关闭立即加载，再开启延迟加载：

<settings>
...
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

先以一对一为例

在Mapper文件中，原来的查询是这样的：

<!--    使用MyBatis提供的resultMap来实现一对一-->
    <select id="queryStudentWithHashMapForFk" parameterType="int" resultMap="person_idCard_map">
        select  p.*,c.*
        from person p inner join personidcard c on p.cardid =c.cardid
        where p.id=#{id}
    </select>
    
    <resultMap id="person_idCard_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
<!--        对象成员时，如果是一对一映射，就用association;javaType指定改属性的类型-->
        <association property="personIdCard" javaType="PersonIdCard">
            <id property="cardid" column="cardid"/>
            <result property="cardinfo" column="cardinfo"/>
        </association>
    </resultMap>

延迟加载的语句如下：

 <!--    利用延时加载来实现一对一-->
    <select id="queryStudentWithLazyloading" resultMap="person_idCard_lazyload_map">
        select * from person
    </select>

    <resultMap id="person_idCard_lazyload_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <!-- 这里采用延迟加载：在查询人时，并不立即加载身份证-->
        <association property="personIdCard" javaType="PersonIdCard" select="shopkeeper.mapper.personIdCardMapper.queryCardById" column="cardid">
        </association>
    </resultMap>

改变的地方有两处，一是sql语句，现在只需要先查询person表的信息了；二是在resultMap中的association标签，personIdCard这张表并不是直接写出要查询的元素，而是多了select和column两个属性：select表示延时加载时执行的查询语句在mapper文件中的id值，column是这两张表的关联，即外键，作为参数传入select中的查询语句里（column写入的是select标签中查询的表的外键，这里的cardid在两张表中名字是相同的，在一对多的例子中就不相同了）。select引用的语句如下：

<select id="queryCardById" parameterType="int" resultType="personIdCard">
   select * from personidcard where cardid =#{cardid}
</select>

也就是说，一开始我们只得到了person表的查询结果，只有当我们要用到personIdCard的结果时，MyBatis才会动用延时加载来根据外键来找到personIdCard的结果。

可以发现的时select中的语句在另外一个Mapper中，其实写在一个Mapper里也是可以的，但是要遵循一个实体类对应一个Mapper文件的开发习惯。新建了一个mapper文件后一定要记得去conf.xml文件中建立映射。

在测试类中检测延时加载的效果：

public static void queryStudentWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);


    List<Person> pers=personMapper.queryStudentWithLazyloading();

    for (Person person:pers)
    {
        System.out.println(person.getId()+", "+person.getName());
    }

    for (Person person:pers)
    {

        PersonIdCard card=person.getPersonIdCard();

        System.out.println(card.getCardid()+", "+card.getCardinfo());
    }

    sqlSession.close();
    reader.close();
}

我是先得到了所有的person表的查询结果，再根据每一个person来获取其idcard的信息。日志输出如下：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 359922172.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - ==>  Preparing: select * from person
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 4
1, 刘茜元
2, 陈曦
3, 刘闹闹
13, 刘咯咯
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
1, 刘茜元 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 1
2, 陈曦 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 3(Integer)
DEBUG [main] - <==      Total: 1
3, 刘闹闹 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 13(Integer)
DEBUG [main] - <==      Total: 1
13, 刘咯咯 info
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - Returned connection 359922172 to pool.

可以很明显地看出查询身份证的操作分了多次进行，且完全在查询人的操作之后。

一对多

和一对一的延迟加载配置方法相同。

在personClassMapper中建立延时加载的查询：

<select id="queryClassAndPersonsWithLazyloading" resultMap="class_person_Lazyload_map">
    select c.* from personclass c
</select>

<resultMap id="class_person_Lazyload_map" type="personclass">
    <id property="classid" column="classid"/>
    <result property="classname" column="classname"/>
    <collection property="persons" ofType="person" column="classid" select="shopkeeper.mapper.personMapper.queryPersonByClassId" >

    </collection>
</resultMap>

select中引用的查询语句：

<select id="queryPersonByClassId" parameterType="int" resultType="person">
    select * from person where class= #{class}
</select>

这里可以发现column中传入的是外键名，classid在personClass表中的名称是classid，但是在person表中的名称只是class。原因是在resultMap中传入参数给延时加载的sql的。

测试类：

public static void queryClassAndPersonsWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personClassMapper personClassMapper =sqlSession.getMapper(personClassMapper.class);


    List<PersonClass> classes=personClassMapper.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession.close();
    reader.close();
}

日志输出和一对一的差不多。但是这里是使用了personClassMapper中的查询语句，所以要先实现一个接口。

查询缓存

一级缓存

作用范围是同一个sqlsession对象。

MyBatis默认开启一级缓存，当某个查询第一次执行时，会从DB中查询，结果缓存在sqlsession中。之后这一个sqlsession执行同一个语句的所有查询都会直接去sqlSession中取出结果（不会重新去数据库中再进行一次查询）。

每当进行一次commit之后sqlSession就会自动清空所有缓存的结果。

二级缓存

MyBatis自带二级缓存，也有第三方提供的二级缓存。

Mybatis自带二级缓存， 作用范围是同一个namespace生成的mapper对象。默认不打开，需要手动打开：

第一步在conf中开启：

<settings>
...
<!--        开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

二级缓存就算打开了，也不是所有的Mapper都会使用；如果要使用二级缓存，还需要再Mapper文件中声明开启二级缓存，实现方式是加一个<cache/>标签。

此时如果直接运行测试类，会报以下错错误：

Exception in thread "main" org.apache.ibatis.cache.CacheException: Error serializing object.  Cause: java.io.NotSerializableException: shopkeeper.entity.Person

说明二级缓存是在硬盘中进行的，准备缓存的对象必须实现了序列化接口。需要序列化的对象就是开启了二级缓存的mapper对应的对象（personMapper->person）。这同时也说明了为什么二级缓存的使用需要在每一个Mapper文件中要手动添加一个cache标签：向磁盘io操作很占用系统资源且实体类一般在创建时也不会实现Serializable接口。

此外由可序列化的知识可知：级联和父类都要序列化。

namespace的值就是接口的全类名(包名.类名)，通过接口可以产生代理对象（personMapper等）；而namespace决定了studentMapper对象的产生所以只要产生的Mapper对象来自于同一个namespace，则这些对象共享二级缓存。

如果是同一个SqlSession对象进行多次相同的查询，则直接进入一级缓存查询；当一个SqlSession被close时，就会触发将 一级缓存的内容存入到二级缓存中（貌似commit也会触发，存疑）；如果不是同一个SqlSession对象进行多次相同的查询(但是均来自同一个namespace),则进入二级缓存查询。

测试类方法：

public static void queryClassAndPersonsWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personClassMapper personClassMapper =sqlSession.getMapper(personClassMapper.class);


    List<PersonClass> classes=personClassMapper.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession.close();

    SqlSession sqlSession2=sqlSessionFactory.openSession();

    personClassMapper personClassMapper2 =sqlSession2.getMapper(personClassMapper.class);


    List<PersonClass> classes2=personClassMapper2.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes2)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes2)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession2.close();
    reader.close();
}

运行测试类的日志如下：

DEBUG [main] - ==>  Preparing: select c.* from personclass c
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 2
2, c2
6, c6
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personMapper]: 0.0
DEBUG [main] - ==>  Preparing: select * from person where class= ?
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 1
[Person{age=20, name='陈曦', id=2}]
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personMapper]: 0.0
DEBUG [main] - ==>  Preparing: select * from person where class= ?
DEBUG [main] - ==> Parameters: 6(Integer)
DEBUG [main] - <==      Total: 3
[Person{age=19, name='刘茜元', id=1}, Person{age=19, name='刘闹闹', id=3}, Person{age=19, name='刘咯咯', id=13}]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3eb738bb]
DEBUG [main] - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3eb738bb]
DEBUG [main] - Returned connection 1052195003 to pool.
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personClassMapper]: 0.5
2, c2
6, c6
[Person{age=20, name='陈曦', id=2}]
[Person{age=19, name='刘茜元', id=1}, Person{age=19, name='刘闹闹', id=3}, Person{age=19, name='刘咯咯', id=13}]

可以看见当第一次查询时，命中率为0，第二次查询时命中率为0.5，说明第二次用到时二级缓存中的结果。

关联查询

一对一映射

先创建第二张表personidcard和其实体类，然后再给表person添加外码：

alter table person add constraint fk_person_idcard_cardid foreign key (cardid) references personidcard(cardid);

我们需要根据传入的id值来查询一个人的全部信息（person表和personidcard表），sql语句是：

select  p.*,c.*
from person p inner join personidcard c on p.cardid =c.cardid
where p.id=#{id}

但是返回值现在不好处理了，因为这涉及到了两个类中的属性。MyBatis有业务拓展类和resultMap类两种实现方式。

业务拓展类

需要新建一个业务拓展类，使其继承成员变量多的类（person），然后直接代码创建变量少的类的属性：

public class PersonBussiness extends Person{
    private int cardid;
    private String cardinfo;

    public int getCardid() {
        return cardid;
    }

    public void setCardid(int cardid) {
        this.cardid = cardid;
    }

    public String getCardinfo() {
        return cardinfo;
    }

    public void setCardinfo(String cardinfo) {
        this.cardinfo = cardinfo;
    }

    @Override
    public String toString() {
        return super.toString()+", "+this.cardid+", "+this.cardinfo;
    }
}

这样就可以在resultType中写入返回值类型是PersonBussiness了：

<select id="queryStudentWithBussiness" parameterType="int" resultType="personbussiness">
    select  p.*,c.*
    from person p inner join personidcard c on p.cardid =c.cardid
    where p.id=#{id}
</select>

用业务拓展类的核心是用resultType指定类的属性包含多表查询的所有字段。但是这个方法有些弊端，如果有很多张表都有关联，业务拓展类实现起来就很麻烦了。

ResultMap

之前已经多次出现这个resultMap了，给人的感觉是，实现简单的东西比较繁杂，但是可以去做一些特定的任务，给人一种吃力不讨好的感觉。果不其然用resultMap来实现关联查询就十分的方便。

在数据库中通过外键将两个表关联起来，那么在java中将两个类关联起来可以通过将一个类作为另外一个类的成员变量来实现（在person类中增加成员PersonIdCard）。

将PersonIdCard类关联到person类中之后resultMap的返回值就可以直接写Person了：

<select id="queryStudentWithHashMapForFk" parameterType="int" resultMap="person_idCard_map">
        select  p.*,c.*
        from person p inner join personidcard c on p.cardid =c.cardid
        where p.id=#{id}
    </select>
    
    <resultMap id="person_idCard_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
<!--        对象成员时，如果是一对一映射，就用association;javaType指定改属性的类型-->
        <association property="personIdCard" javaType="PersonIdCard">
            <id property="cardid" column="cardid"/>
            <result property="cardinfo" column="cardinfo"/>
        </association>
    </resultMap>

resultMap中的id和result字段和之前的处理方式一样，现在主要针对于对象类型，即关联的personidcard类的处理。如果是一对一映射就用association标签；如果是一对多就是collection标签。在association标签中还需要加上这个成员变量的名称property和类型javaType。

这个关联类中也有自己的成员变量，其本身也对应了一张表，所以也要写上自身的变量，同样是用id和result。

一对多映射

新建另一张表personClass和其实体类，给person添加外码class。然后说一个题外话：Mysql不允许同时更新（删除）和查询同一张表，是我在尝试以多此一举的方式更新表的时候发现的这个问题。

由于还是用ResultMap来实现，所以要将personClass和person这两个类关联起来。现在是一对多的联系，只能在personClass类中增加person的list。

在resultMap中，其它的写法全都一样，唯一不同的是，现在关联的类是一对多关联，要写collection（一对一写association），并且描述类型的时候不能再用javatype了（因为javaType不用写list，而单写一个person不能正确表示personClass当中的成员的类型，也不能体现其是一对多关联），而是特有的ofType，然后ofType里面写person，表明这个集合的元素类型是person：

<select id="queryClassAndPersons" parameterType="int" resultMap="class_person_map">
        select c.*,p.*
        from person p
        inner join personclass c on c.classid=p.class
        where p.class=#{class}
    </select>

    <resultMap id="class_person_map" type="personclass">
        <id property="classid" column="classid"/>
        <result property="classname" column="classname"/>
<!-- 描述属性类型javaType
 描述属性的元素类型是oftype-->
        <collection property="persons" ofType="person">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="age" column="age"/>

        </collection>
    </resultMap>

然后collection标签内依旧要配置person的成员属性。

动态SQL

动态SQL能够根据输入的参数而确定最终提交给数据库的SQL语句。当传入的参数满足一定的条件时，MyBatis就会相应地拼接对应的语句，且能够自动地处理空格、逗号和语句头部的连词。

动态SQL需要用到if、where、foreach等标签来实现。

if标签

if标签时动态SQL的灵魂，分支条件全都要if标签的test属性来实现。如果test当中的语句结果为真，就将这个if标签中的sql语句拼接到总的sql语句中：

<select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
        select id,name,age from person where 
        <if test="name!=null and name!=''">
            name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>

    </select>

Person person=new Person();
        person.setName("刘咯咯");
        person.setAge(19);
        Person pers=personMapper.queryPerosnByNameOrAgeWithSQLTag(person);

where标签

if标签是按照代码的顺序执行的，如果第一个条件不成立，且有第二个条件成立的话，由于第二个if标签中的sql语句首部必然有连接词and或or，那么将其与原sql语句拼接之后必然会导致sql语句解析错误。

可以巧妙地在where后面加一句1=1，就可以暂时解决这个问题了：

    <select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
        select id,name,age from person where 1=1
        <if test="name!=null and name!=''">
            and name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>

    </select>

但是还是有一个问题，1=1对于or来讲就是恒真了，会屏蔽所有or后i按的语句，你说加一句1<>1吧，又防不了and语句，所以MyBatis推出了更加灵活的where标签来处理这问题：

<select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
    select id,name,age from person
    <where>
        <if test="name!=null and name!=''">
            and name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>
    </where>
</select>

将所有的if标签都写入where标签内，where语句会处理第一个成立的if标签中的and（或者or）。这个时候哪怕第一个if中写上了and或test不通过，也能够拼接成正确的语句。不过where只会处理第一个成立的if标签，如果之后的标签中缺少连接词的话研究会报错。

foreach标签

foreach标签是为了让动态SQL能够处理in语句中的内容，例如查询编号为1、2、13的人的信息：

select id, name from person where id in(1,2,13)

我们想让in后面的那个集合能用动态SQL的方式动态传入。显然多个元素的话需要遍历每一个元素来查询，如果企图直接通过读取属性的方式是行不通的，例如定义一个Country类，其中有一个成员变量list为ids，在下面的语句中，会报无法识别ids的错误：

<select id="queryPersonWithIdInCountry" parameterType="Country" resultType="person">
        select * from person
        <where>
            <if test="ids!=null and ids.size>0">
                and id in(ids)
            </if>
        </where>

</select>

foreach看名字就知道是实现迭代的功能。foreach可以迭代的类型有：属性、数组（包括对象数组）、集合等。

属性

还是以上面的那个country中的属性ids为例，想要用foreach处理它，实现起来就和java中的增强for差不多：

<select id="queryPersonWithIdInCountry" parameterType="Country" resultType="person">
    select * from person
    <where>
        <if test="ids!=null and ids.size>0">
        <foreach collection="ids" open=" and id in(" close=")" item="id" separator=",">
            #{id}
        </foreach>

        </if>
    </where>
</select>

collection中写属性名，item中写入每一次遍历取出的值（相当于for (String name: [names])中的name）；由于一个sql语句中不止要遍历的集合，还包括语句中的其它部分，所以用open写入要迭代的元素的前面的内容，用close写入后面的内容。最后还需要定义分隔符，用separator来写。

foreach标签内写入展位符，表示要迭代的部分的取值。所以整个sql语句就被拆成了这样：

select * from person【open】and id in(【item】#{id}【separator】，【item】#{id}【close】）

简单类型的数组

当传入的是简单类型的数组时，不仅输入参数的类型要改为对应的数组类型，而且在使用时需要用array来代替所有的数组名。原因时数组名时作为形参传入进来的，无法写成映射。

<select id="queryPersonWithArray" parameterType="int[]" resultType="person">
    select * from person
    <where>
        <if test="array!=null and array.length>0">
            <foreach collection="array" open=" and id in(" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </if>
    </where>
</select>

集合类型（list）

和传入简单类型的数组差不多，将传入的参数写为list，且将所有集合名写为list：

<select id="queryPersonWithList" parameterType="list" resultType="person">
    select * from person
    <where>
        <if test="list!=null and list.size>0">
            <foreach collection="list" open=" and id in(" close=")" item="id" separator=",">
                #{id}
            </foreach>

        </if>
    </where>
</select>

对象数组

假设要传入一个person类的数组：

Person per1=new Person();
per1.setId(1);
Person per2=new Person();
per2.setId(2);
Person per13=new Person();
per13.setId(13);

Person persons[]=new Person[]{per1,per2,per13};

现在传入的类型并不能写Person[]了，会报错无法识别这个别名，只能传入Object[]（我觉得挺迷的，为什么parameterType写单个Person类就可以写Person数组就不行了）。

<select id="queryPersonWithObjectArray" parameterType="Object[]" resultType="person">
    select * from person
    <where>
      <if test="array!=null and array.length>0">
          <foreach collection="array" open=" and id in(" close=")" item="person" separator=",">
             #{person.id}
          </foreach>
      </if>
    </where>
</select>

现在每一次迭代取出的都是一个person实例，真正要用的其实时person实例中的id变量，所以在占位符中要写item中的临时变量（person）点id。

SQL片段

对于需要重复出现很多次的代码，在java中可以将其写入一个方法中，在SQL里可以写入存储过程或存储函数中。那么在MyBatis中，可以使用SQL片段处理可能需要多次出现的SQL语句。

第一步要提取相似代码。 在Mapper.xml文件中的namespace标签下写sql标签（与增删改查的标签同级），在sql标签中写入需要提取的代码：

<sql id="queryWithObjectArray">
    <where>
        <if test="array!=null and array.length>0">
            <foreach collection="array" open=" and id in(" close=")" item="person" separator=",">
                #{person.id}
            </foreach>
        </if>
    </where>
</sql>

sql标签的id属性作用与增删改查的id相同，唯一标识这个SQL片段。

第二步引用。在需要引用的地方写入refield标签，补充完id值之后就可以引用完成了：

<select id="queryPersonWithObjectArray" parameterType="Object[]" resultType="person">
    select * from person
    <include refid="queryWithObjectArray"></include>
</select>

如果引用的地方不在SQL片段同一个文件，需要在引用时加上namespace。

详解ResultType

简单类型

八个基本类型+String。举例：

<select id="queryPersonCount" resultType="int">
    select count(*) from person
</select>

接口方法：

int queryPersonCount();

输出参数为实体对象类型

举例：

<select id="queryPersonById" resultType="person" parameterType="int">
    select * from person where id=#{id}
</select>

接口方法：

Person queryPersonById(int id);

输出参数为实体对象类型的集合

有多个查询结果的情况。举例：

<select id="queryAll" resultType="person">
    select * from person
</select>

接口方法：

List<Person> queryAll();

虽然输出类型为集合，但是resultType依然写集合的元素类型(resyltType=”person”)，接口中的方法返回值要写集合类型list。

输出参数类型是HashMap

若返回值为HashMap，就需要有键值对。MyBatis实现的方式是在sql语句中给要查询的列名起一个别名，让别名作为key，查询的结果作为对应的value。举例：

<select id="queryPersonOutByHashMap" resultType="HashMap">
    select id "mId", name "mName" from person where id=1
</select>

接口方法：

HashMap<String,Object> queryPersonOutByHashMap();

测试类中获取结果：

//查询人，返回值为HashMap
public static void queryPersonOutByHashMap() throws IOException {
    ...
    HashMap<String,Object> personMap=personMapper.queryPersonOutByHashMap();

    System.out.println(personMap);
    ...
}

以上是查询只有一个返回的结果，如果有多个结果，那么xml文件中的resultType依旧是HashMap，但是接口方法需要用list（同第三种）。举例：

<select id="queryAllPersonOutByHashMap" resultType="HashMap">
    select id "mId", name "mName" from person
</select>

接口方法：

List<HashMap<String,Object>> queryAllPersonOutByHashMap();

测试类中获取结果：

//查询人，返回值为HashMap的集合
public static void queryAllPersonOutByHashMap() throws IOException {
    ...
    List<HashMap<String,Object>> personMaps=personMapper.queryAllPersonOutByHashMap();

    System.out.println(personMaps);
    ...
}

当属性名和字段名不一致时

之前是使用ressultMap来实现的：

<select id="queryPersonByIdWithConverter" resultMap="resultPerson" parameterType="int">
    select * from person where id=#{id}
</select>
<resultMap id="resultPerson" type="person">
    <id property="num" column="id"/>
    <result property="name"  column="name"/>
    <result property="age" column="age"/>
    <result property="sex" column="sex" javaType="boolean" jdbcType="INTEGER"/>
</resultMap>

接口方法：

Person queryPersonByIdWithConverter(int id);

实际上还可以用resultType+HashMap的方式解决（前提是将实体类person中的id和name变量暂时改为mId和mName：

<select id="queryAllPersonOutByHashMap" resultType="person">
        select id "mId", name "mName" from person
</select>

这么做的原理是，MyBatis根据sql语句中起的别名，将别名自动与person进行映射（原先是将实体类的属性和列名映射）。相当于MyBatis在自动映射时多了应该选择。

上面的当返回值时为HashMap的情况也用到了别名，但是这个别名是MyBatis拿过来作为HashMap的key值的，实现的道理不一样。

我们可以发现当属性名和字段名不一致时，使用resultType+HashMap比使用resultMap要简洁很多。我认为一般写resultMap主要是为了使用类型转换器。

详解parameterType

Mapper.xml的每一个sql标签的parameterType属性表示输入参数，并且在sql语句中，用#{}或${}来从parameterType中取得对应的值。当输入参数的类型不同时，#{}和${}的用法有很大的区别。

基本类型

当输入参数时八个基本类型或string类型时，#{}和${}既有相似之处，又有不同的用法：

不同

第一、基本类型中#{}中的内容可以写任意值，如# {xxx}；而${}中必须写value，如$ {value}（但是在新的jar包中取消了这一限制，所以这一点没有什么区别了）。

第二、对于String类型，#{}会自动给里面的参数套上单引号’ ‘，然而${}会进行原样输出，那么以下这个语句：

<select id="queryPersonByName" resultType="person" parameterType="string">
    select * from person where name= ${values} 
</select>

实际上提交给数据库的是

select * from person where name= 刘咯咯 ;

这个语句显然在sql中是不成立的，原因是数据库的字符串要加上单引号。需要改写成以下的样子：

<select id="queryPersonByName" resultType="person" parameterType="string">
    select * from person where name='${value}'
</select>

但是${}在动态排序里面就有很大的作用。一个根据输入的列名的排序语句如果用#{}写是这样的：

<select id="queryPersonOrderedByColumn" resultType="person" parameterType="string">
    select * from person order by ${column } desc
</select>

将列名带入后实际上的sql语句是：

<select id="queryPersonOrderedByColumn" resultType="person" parameterType="string">
    select * from person order by 'name' desc
</select>

‘name’是一个常量，比较无结果，所以这个时候不能用#{}自动生成单引号。

第三、#{}可以防止SQL注入而${}不防止。sql注入是什么我现在也不知道，等以后要用到再说吧，参考资料。

相同

都可以获取对象的值(嵌套类型对象)

第一、在模糊查询中，这两种方式虽然写法稍有不同，但是都能实现：

#{}

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
    select * from person where name like #{name} or age=#{age}
</select>

Person person=new Person();
person.setAge(19);
person.setName("%刘%");

${}

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
    select * from person where name like '%${name}%' or age=#{age}
</select>

Person person=new Person();
person.setAge(19);
person.setName("刘");

第二、获取对象的值的方式相同

原来直接传入的是person类的实例，现在新建一个类address，根据address的值来查询。可以直接将address作为输入参数传入：

<select id="queryPersonByAddress" resultType="person" parameterType="address">
    select * from person where homeaddress=#{homeAddress} or schooladdress='${schoolAddress}'
</select>

也可以直接获取嵌套对象的值（传入person获取其address）：

<select id="queryPersonByAddress" resultType="person" parameterType="person">
    select * from person where homeaddress=#{address.homeAddress} or schooladdress='${address.schoolAddress}'
</select>

对象类型

当parameterType的取值是对象类型时，使用#{}和${}都必须写属性名：

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
        select * from person where name like '%${name}%' or age=#{age}
    </select>

如果输入的值为多个，还可以用HashMap来作为parameterType的取值：

<select id="queryPersonByNameOrAgeWithHashMap" resultType="person" parameterType="HashMap">
    select * from person where name like '%${mName}%' or age=#{mAge}
</select>

传入的HashMap，key的值去匹配占位符，如果名称相同就用value去替换掉占位符：

Map<String,Object> personMap=new HashMap<>();
personMap.put("mName","刘");
personMap.put("mAge",20);
List<Person> persons=personMapper.queryPersonByNameOrAgeWithHashMap(personMap);

parameterType用HashMap来作为输入参数的一个重要用途是调用存储过程。这一点是仅仅传入一个实体类对象是无法实现的。

parameterType为HashMap时调用存储过程

存储过程无论输入参数是什么值，语法上都需要用map来传递该值.

首先在数据库中先创建两个存储过程：

1.查询某个年龄的总人数

DELIMITER //
create PROCEDURE queryCountByAgeWithProcedure (IN mAge int, OUT pNum int)
begin
select count(1) into pNum from person where age=mAge;
end
//
DELIMITER ;

2.根据id值来删除一个人的信息

DELIMITER //
Create procedure deletePersonByIdWithProcedure(In mId int)
Begin 
Delete from person where id =mId;
End
//
DELIMITER ;

mysql中创建存储过程要先将分隔符改成别的东西。参考资料

Mapper.xml

除了parameterType为HashMap之外，还需要写上一个statementType=CALLABLE以表示这个语句是执行的存储过程。之前所有的sql标签都没有写是因为statementType默认值是PREPARED；此外statementType还有一个类型是STATEMENT，表示直接操作sql，不进行预编译：

<select id="queryCountByAgeWithProcedure" statementType="CALLABLE" parameterType="HashMap">
    ...
</select>

通过关键字CALL来调取存储过程，调用的存储过程还需要写明参数的名称、类型、模式，CALL需要在大括号中调用：

<select id="queryCountByAgeWithProcedure" statementType="CALLABLE" parameterType="HashMap">
    {
        CALL queryCountByAgeWithProcedure(
            #{mAge,jdbcType=INTEGER,mode=IN},
            #{pNum,jdbcType=INTEGER,mode=OUT}
        )
    }
</select>

测试类方法

在测试类中，输入的参数还是和上面的一样用HashMap的put方法，同样也是要让key值和占位符匹配。不过在MyBatis中所有的存储过程的方法都没有返回值——返回值存储在HashMap中，所以接口中的方法返回值是void类型:

public interface personMapper {

    ...

    void queryCountByAgeWithProcedure(Map<String,Object> para);
    void deletePersonByIdWithProcedure(Map<String,Object>para);

}

从HashMap中取出存储过程的返回值的方式：

//用存储过程来查询年龄总人数
public static void queryCountByAgeWithProcedure() throws IOException {
    ...

    Map<String,Object> map=new HashMap<>();
    map.put("mAge",19);
    personMapper.queryCountByAgeWithProcedure(map);

    Object pNum=map.get("pNum");
    System.out.println("查询到"+pNum+"人");
    
    ...
}

存储过程的增删改也都需要在最后commit()一下：

//用存储过程来根据id删人
public static void deletePersonByIdWithProcedure() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("mId",4);
    personMapper.deletePersonByIdWithProcedure(map);
    sqlSession.commit();

    sqlSession.close();
    reader.close();
}

jdbcType

jdbcType这个东西是MyBatis独有的，对应还有一个是javaType。虽然说java的类型能直接和数据库的类型映射，但是当java的一个变量的值是null时，数据库可能只知道其为空值，但是不知道它的具体类型是什么。

例如当parameterType为HashMap的时候，我们定义的HashMap的value类型是Object，此时如果value=null，那么数据库就无法将这个null和自己的类型进行匹配。所以Mybatis在实现可能存在未知类型的空值时要求用上jdbcType，以告诉数据库这是一个什么样的空值。

但是一般情况下数据的类型时可以确定的（例如直接写明parameterType的类型），myBatis可以直接将类型告诉给数据库，此时就不是一定要加上jdbcType了。

jdbcType和javaType的对应关系

一些优化

优化数据库配置信息

可以将配置信息单独放入（要手动新建的）db. properties文件中， 然后再从conf.xml动态引入。

db. properties文件内容是由key-value组成的：

driver:com.mysql.cj.jdbc.Driver
url:jdbc:mysql://localhost:3306/person?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
username:root
password:password

conf引用方式，是在最外层configuration下添加properties标签：

<properties resource="db.properties"/>

有一个小小问题是，最开始的配置信息是直接写在conf.xml文件中的，我将配置信息直接从eclipse的jdbc项目中抄写过来的，idea自动帮我在url的每一个“&”号处添加了“amp；”，但是写在db. properties文件中要删除。

MyBatis全局参数

MyBatis全局参数就是一些MyBatis具体运行时候的参数设置，一般要慎用，有以下这些参数：

如果有需要，在conf.xml文件中设置：

<settings>
    <setting name="" value=""/>
</settings>

例如：

<settings>
   <setting name= "cacheEnabled" value= "false" />
   <setting name= "LazyLoadingEnabled" value="false" />
</settings>

设置别名

别名就是给一些很长很复杂的值起一个简单的别名。别名是忽略大小写的，有以下两种方式：

设置单个别名：

    <typeAliases>
       <typeAlias type="shopkeeper.entity.Person" alias="person"/>
    </typeAliases>

批量设置别名

    <typeAliases>
        <package name="shopkeeper.entity"/>
    </typeAliases>

除了我们可以自定义别名之外，MyBatis还有一些内置的别名：

类型转换器

java类型和数据库（如MySQL）的类型并不是完全匹配，例如String和varchar，但是MyBatis可以自动将其相互转化，这里就是用到了类型转换器。

MyBatis自带一些常见的类型处理器：

我们还可以自定义一些MyBatis类型处理器（虽然设计数据库时就应该好好考虑让类型匹配）：

例如我们要将java的Boolean对应到数据库中的Integer，其中true=1，false=0，步骤如下：

创建转换器

需要实现TypeHandler接口，但是通过阅读源码发现，此接口有一个实现类BaseTypeHandler，因此要实现转换器有2种选择:

1.实现接口TypeHandler接口

2.继承BaseTypeHandler

继承接口的实现类要做的工作量肯定比直接实现接口要简单些，所以需要新建一个转换器类继承BaseTypeHandler：

public class BooleanAndIntConverter extends BaseTypeHandler<Boolean> {
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, Boolean aBoolean, JdbcType jdbcType) throws SQLException {

        if (aBoolean)
        {
            preparedStatement.setInt(i,1);
        }
        else
        {
            preparedStatement.setInt(i,0);
        }
    }

    @Override
    public Boolean getNullableResult(ResultSet resultSet, String s) throws SQLException {
        int sexNum=resultSet.getInt(s);
        return sexNum==1?true:false;
    }

    @Override
    public Boolean getNullableResult(ResultSet resultSet, int i) throws SQLException {
        int sexNum=resultSet.getInt(i);
        return sexNum==1?true:false;
    }

    @Override
    public Boolean getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        int sexNum=callableStatement.getInt(i);
        return sexNum==1?true:false;
    }


}

首先继承的BaseTypeHandler类有一个泛型，这个泛型是java的类型。继承写明了泛型之后，需要实现的方法的java那一段的参数就会自动根据泛型进行格式转化。例如这四个方法中的Boolean。

如果不写明泛型，那么这些值的类型就是object：

@Override
public void setNonNullParameter(PreparedStatement preparedStatement, int i, Object o, JdbcType jdbcType) throws SQLException {
    
}

@Override
public Object getNullableResult(ResultSet resultSet, String s) throws SQLException {
    return null;
}

@Override
public Object getNullableResult(ResultSet resultSet, int i) throws SQLException {
    return null;
}

@Override
public Object getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
    return null;
}

四个方法由set由get，其中数据的方向是：

get: DB-> java
set:java-> DB

在唯一的一个set方法中，参数PreparedStatement preparedStatement可以理解为数据库中的一个元组；int i是PreparedStatement的操作参数位置（一个元组某个属性的列号）；Object o是java那一端的值的对象；JdbcType jdbcType是JDBC中对应的类型，其应该是由preparedStatement的set方法来决定的，例如：

@Override
public void setNonNullParameter(PreparedStatement preparedStatement, int i, Boolean aBoolean, JdbcType jdbcType) throws SQLException {

    if (aBoolean)
    {
        preparedStatement.setInt(i,1);
    }
    else
    {
        preparedStatement.setInt(i,0);
    }
}

三个get方法是三种从数据库取出值的方式，取出值之后再经过自定义的类型的转化作为返回值传给java：

@Override
public Boolean getNullableResult(ResultSet resultSet, String s) throws SQLException {
    int sexNum=resultSet.getInt(s);
    return sexNum==1?true:false;
}

@Override
public Boolean getNullableResult(ResultSet resultSet, int i) throws SQLException {
    int sexNum=resultSet.getInt(i);
    return sexNum==1?true:false;
}

@Override
public Boolean getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
    int sexNum=callableStatement.getInt(i);
    return sexNum==1?true:false;
}

在conf.xml文件中配置

在typeHandlers标签下配置：

<typeHandlers>
        <typeHandler handler="shopkeeper.converter.BooleanAndIntConverter" javaType="boolean" jdbcType="INTEGER"/>
    </typeHandlers>

typehandler的handler属性要写全类名，之后还要加上javaType和jdbcTypc属性，注意不知道为什么觉得不错Type要全大写。

测试

在Mapper.xml中增加使用了类型转化器的语句：

<select id="queryPersonByIdWithConverter" resultMap="resultPerson" parameterType="int">
    select * from person where id=#{id}
</select>

此时返回值不再是resultType，而是resultMap了。如果类中属性和表中的字段类型能够合理识别(String-varchar) ，则可以使用resultType，否则使用resultMap；如果类中属性名和表中的字段名能够合理识别，则可以使用resultType，否则使用resultMap。

resultMap是需要自己定义的，目的是将java和数据库的值用类型转换器一一映射过去：

<resultMap id="resultPerson" type="person">
    <id property="id" column="id"/>
    <result property="name"  column="name"/>
    <result property="age" column="age"/>
    <result property="sex" column="sex" javaType="boolean" jdbcType="INTEGER"/>
</resultMap>

resultMap的id属性值就是标识它的东西，type是返回值在java当中的类型，这里已经用了别名了所以只写了person。resultMap下的子标签根据主键和非主键由分为id和result，其中property是java当中的成员变量名，column是数据库的列名。如果某一个元素需要使用自定义的类型转换器，还需要再这个标签内加上javaType和jdbcType。

测试类中用到是接口代理的方式，没什么区别。

上面这个例子是返回值需要使用类型转换器，下面这个例子是当输入的参数需要使用类型转换器的情况：

<insert id="addPersonWithConverter" parameterType="person">
    insert into person (age,name,id,sex) values (#{age},#{name},#{id},#{sex,javaType=boolean,jdbcType=INTEGER})
</insert>

可以看见需要转换类型的sex，后面加上了javaType和jdbcType。

resultMap的功能

在使用类型转换器的时候已经发现了使用resultMap可以实现类型转换，但是还提到当“如果类中属性名和表中的字段名能够合理识别，则可以使用resultType，否则使用resultMap”时也需要使用resultMap。

在定义java当中的实体类时，所有成员变量都必须和数据库的列名能够一一对应（数据库不区分大小写），否则将会无法匹配，例如这个语句：

<select id="queryPersonById" resultType="person" parameterType="int">
    select * from person where id=#{id}
</select>

现在Java中有一个成员变量是id，数据库列名中也有id，那么它们是可以匹配的。但是如果将Java中的id改为num，那么就无法匹配了（返回默认值）。

在resultMap中需要修改property：

<resultMap id="resultPerson" type="person">
    <id property="num" column="id"/>
    <result property="name"  column="name"/>
    <result property="age" column="age"/>
    <result property="sex" column="sex" javaType="boolean" jdbcType="INTEGER"/>
</resultMap>

但是这个情况简直多次一举，因为java的实体类明显是按照数据库来设计的，只有没事找事想增加项目工程量的人才会乱写实体类的成员变量。

Mybatis进行CRUD

之前已经配置了MyBatis的使用环境以及其它一切所需要的基础文件，但是一直没说这个东西究竟时怎么样来操作数据库的。上一次的总结最后的Test类就是干这件事情的。

基础方式

在测试类的方法中，显然是要读取conf.xml文件的，然后用这个IO流创建一个SqlSessionFactory（SqlSessionFactoryBuilder().build(reader)，build的第二个参数可以指定数据库环境，默认使用environments的default指定的）；用SqlSessionFactory的openSession方法还能构造一个SqlSession实例。

Reader reader=Resources.getResourceAsReader("conf.xml");
SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
SqlSession sqlSession=sqlSessionFactory.openSession();

讲了这么多，其实这个SqlSession实例就相当于JDBC的Connection，不过干的事情更多些：SqlSession不止是声明了数据库信息，它的创建所依据的那个conf.xml文件中还声明了映射文件，所以所有即将用到的sql语句都是SqlSession实例所直接能够使用的；而JDBC中所有的sql语句都要自己现场手写，不易管理、修改起来很不方便。

在Mapper.xml中，每一个sql语句都是由namespace和id来唯一标识。而这里增删改查的方式就是直接定位到每一个Mapper.xml中的语句来实现数据库操作，定位方法是直接将这两个东西弄成一个String：

String statement="shopkeeper.personMapper."+"queryAll";

增删改查是调用SqlSession实例的对应的方法，其中第一个参数必须是唯一标识statement，后继的参数如同Mapper.xml文件中的一样如果没有就不写，要有的话只能有一个（多个就封装成对象）；返回值稍作改变，Mapper.xml中无论返回值有多少个，都只写一个的情况，但是Java语言不能这样，要视情况改变（其实全写List也行，反正原理都是从游标读，然后返回值的多少其实是取决于你调用的SqlSession的方法，例如selectOne和selectLst）：

Person person=sqlSession.selectOne(statement,1);
List<Person> persons=sqlSession.selectList(statement);
int count=sqlSession.insert(statement,person);
int count=sqlSession.delete(statement,3);
int count=sqlSession.update(statement,person);

由于我使用的事务方式是JDBC，增删改操作还是要commit的，做法为调用SqlSession.commit()方法。

完整的方法如下：

public static void queryPersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();
    String statement="shopkeeper.personMapper.queryPersonById";

    Person person=sqlSession.selectOne(statement,1);

    System.out.println(person);
    sqlSession.close();
    reader.close();
}

public static void queryAllPerson() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();
    String statement="shopkeeper.personMapper."+"queryAll";

    List<Person> persons=sqlSession.selectList(statement);

    System.out.println(persons);
    sqlSession.close();
    reader.close();
}

public static void addPerson() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();
    String statement="shopkeeper.personMapper."+"addPerson";

    Person person=new Person(19,"刘茜元",3);
    int count=sqlSession.insert(statement,person);
    sqlSession.commit();

    System.out.println("增加了"+count+"个人");
    sqlSession.close();
    reader.close();
}

public static void deletePersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();
    String statement="shopkeeper.personMapper."+"detelePersonById";

    int count=sqlSession.delete(statement,3);
    sqlSession.commit();

    System.out.println("删除了"+count+"个人");
    sqlSession.close();
    reader.close();
}

public static void updatePersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();
    String statement="shopkeeper.personMapper."+"updatePerson";

    Person person=new Person();
    person.setId(3);
    person.setName("刘闹闹");
    person.setAge(19);
    int count=sqlSession.update(statement,person);
    sqlSession.commit();

    System.out.println("更新了"+count+"个人");
    sqlSession.close();
    reader.close();
}

mapper动态代理方式CRUD

也叫接口开发。

在基础方式中说JDBC不好时，点名批评了JDBC每一个sql语句都要手写，但是其实基础方式里面也是要手写每一个statement的，只不过是将sql语句简化为了namespace+id了。

但是我们要严于律己，仅仅做到这方面是远远不够的，最好能够达到直接调用方法就能指哪打哪。mapper动态代理就是干的这件事。

总的来说，Mapper动态代理的思路就是将Mapper.xml中的sql语句变成接口中的方法，约定之前的namespace成为接口名称，每一个id变成方法名，具体是怎么实现的就是MyBatis底层的事情了。

那么，这些接口就需要满足以下几个要求：

接口名为namespace；

方法名为id值；

输入的参数和mapper.xml的parameterType一致；

返回值如果是查询就必须和resultType一致，如果你想要得到增删改操作成功的结果数量，就可以写成int，如果不想要就写void。

有多个Mapper.xml文件就实现多个接口。匹配的过程是根据接口名找到mapper. xml文件，根据接口的方法名找到mapper. xml文件中的SQL标签。（那么问题来了，如果两个不同的mapper.xml中有id相同的sql语句怎么办？对应到java就是两个不同的接口有同名的方法）。

还有一个习惯是： SQL映射文件(mapper. xml)和接口放在同一个包中(注意修改conf. xml中加载mapper. xml文件的路径）。

执行

先得到接口的实例化对象：

personMapper personMapper =sqlSession.getMapper(personMapper.class);

再通过接口的实例化对象来调用其方法（返回值自取）：

int count=personMapper.addPerson(person);

最后增删改别忘了commit。

完整的方法如下：

public static void queryPersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    Person person=personMapper.queryPersonById(1);


    System.out.println(person);
    sqlSession.close();
    reader.close();
}

public static void queryPersonByIdWithConverter() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    Person person=personMapper.queryPersonByIdWithConverter(1);


    System.out.println(person);
    sqlSession.close();
    reader.close();
}


public static void queryAllPerson() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    List<Person> persons=personMapper.queryAll();

    System.out.println(persons);
    sqlSession.close();
    reader.close();
}

public static void addPerson() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    Person person=new Person(19,"刘茜元",13);
    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    int count=personMapper.addPerson(person);
    sqlSession.commit();

    System.out.println("增加了"+count+"个人");
    sqlSession.close();
    reader.close();
}

public static void addPersonWithConverter() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    Person person=new Person(19,"刘茜元",13);
    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    int count=personMapper.addPersonWithConverter(person);
    sqlSession.commit();

    System.out.println("增加了"+count+"个人");
    sqlSession.close();
    reader.close();
}

public static void deletePersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    int count=personMapper.detelePersonById(13);
    sqlSession.commit();

    System.out.println("删除了"+count+"个人");
    sqlSession.close();
    reader.close();
}

public static void updatePersonById() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);
    Person person=new Person();
    person.setId(13);
    person.setName("刘咯咯");
    person.setAge(19);
    int count=personMapper.updatePerson(person);
    sqlSession.commit();

    System.out.println("更新了"+count+"个人");
    sqlSession.close();
    reader.close();
}

MyBatis 可以简化 JDBC 操作，实现数据的持久化。

MyBatis 是一种ORM 产品, ORM的实现。ORM： Objective Relational Mapping （ORM即可以将一个person对象和一个person表对应起来）。

MyBatis 下载与安装

先进入MyBatis官网 https://mybatis.org/mybatis-3/zh/index.html

进入官网 点击 “ 简体中文 ”

进入这个界面 ,点击  mybatis-x.x.x.jar

点击下载 mybatis-3.5.5.zip 即可。

下载之后，解压，解压之后，会得到以下文件

PDF文件介绍了MyBatis怎么使用，是文档说明书。可直接从中赋值所用的代码。

有关MyBatis起步

一个可以基本实现运行的工程的目录结构如下：

需要依赖数据库jar包和mybatisjar包：

conf.xml文件

conf.xml可以简化JDBC操作，实现数据的持久化。其配置数据库信息和需要加载的映射文件。这个文件完成的工作是访问数据库、创建数据库操作语句等等。本来这些东西在JDBC当中要写很多遍，但是每次写的无非就那几句，所以这个conf不仅是必要的，也是充分的。

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/person?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="shopkeeper\mapper\personMapper.xml"/>
    </mappers>
</configuration>

conf文件规定了：

一、数据库信息

MyBatis运行时的数据库环境。通过environments标签即其下属的environment标签可以声明可用的数据库环境，通过environments的default属性来指定运行时默认的数据库环境。

事务的提交方式和数据源类型。每一个environment都有一个transactionManager标签，其Type属性规定了事务提交方式。可取值有，JDBC :利用JDBC方式处理事务(commit rollback close)；MANAGED:将事务交由其他组件去托管(spring， jboss）。environment的另一个标签是dataSource，其Type属性规定了数据源类型。可取值为，UNPOOLED:传统的JDBC模式(每次访问数据库，均需要打开、关闭等数据库操作，但是打开、关闭数据库是比较消耗性能的）；POOLED:使用数据库连接池；JNDI:从tomcat中获取一个内置的数据库连接池(数据库连接池-数据源）,默认会关闭连接。

dataSource下的标签声明了打开某个数据库的操作，从驱动到数据库位置到账户密码都和JDBC如出一辙。

conf.xml

<dataSource type="POOLED">
    <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/person?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</dataSource>

JDBC

try
{
Class.forName(“com.mysql.cj.jdbc.Driver”);
Connection conn=DriverManager.getConnection(“jdbc:mysql://localhost:3306/STUDB?serverTimezone=UTC”, “root”, “password”);
…
conn.close();
}
catch(Exception e)
{
System.err.println(“异常”+e);
}

二、映射文件

conf.xml还规定了绑定的映射文件Mapper.xml，这样我们在读取conf.xml时还能连带着读取到Mapper.xml的路径，这样就可以访问它了。所以这个Mapper时什么东西，我将在下下个标题总结。

实体类

实体类将数据库的一张表映射成为一个对象，这样我们可以如同操作一个实体对象一般操作数据库的一张表。

public class Person {

    private int age;
    private String name;
    private int id;

    public Person() {
    }

    public Person(int age, String name, int id) {
        this.age = age;
        this.name = name;
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

Mapper.xml

直截了当的来讲，Mapper就是写了MyBatis下操作数据库时的数据操作语句。

<mapper namespace="shopkeeper.mapper.personMapper">
    <!--parameterType :输入参数的类型
    resultType:查询返回结果值的类型，返回类型-->
    <select id="queryPersonById" resultType="shopkeeper.entity.Person" parameterType="int">
        select * from person where id=#{id}
    </select>
    
    <insert id="addPerson" parameterType="shopkeeper.entity.Person">
        insert into person (age,name,id) values (#{age},#{name},#{id})
    </insert>
    
    <update id="updatePerson" parameterType="shopkeeper.entity.Person">
        update person set age=#{age},name =#{name} where id=#{id}
    </update>

    <delete id="detelePersonById" parameterType="int">
        delete from person where id=#{id}
    </delete>

    <select id="queryAll" resultType="shopkeeper.entity.Person">
        select * from person
    </select>
</mapper>

因为conf.xml中可能会映射多个Mapper文件，所以需要能唯一标识每一个Mapper。mapper标签的namespace就是干的这件事情。

在mapper标签里面就可以写这些sql语句了，同样的，也需要唯一标识一个mapper的一条sql语句，其属性id就是干的这件事。

后续我们就会使用namespace+id来确定究竟使用哪条语句。

此外，每一条sql，parameterType是输入参数的类型，resultType是查询返回结果值的类型并且有以下约定：

输入参数parameterType 和输出参数resultType 在形式上都只能有一个；

如果输入/输出参数:是简单类型(8个基本类型+String) 的话，可以使用任何占位符# {xxxx}；如果是对象类型，则必须是对象的属性#属性名；

输出参数: 如果返回值类型是一个对象(如Person) ,则无论返回一个还是多个，在resultType都写成一个。

Test类

在test类中将会真正使用Mybatis来访问数据库并进行操作，有两种操作方式，将在下一次总结中进行记录。

一级缓存

Mybatis的一级缓存是指Session缓存。一级缓存的作用域默认是一个SqlSession。Mybatis默认开启一级缓存。 也就是在同一个SqlSession中，执行相同的查询SQL，第一次会去数据库进行查询，并写到缓存中； 第二次以后是直接去缓存中取。 当执行SQL查询中间发生了增删改的操作，MyBatis会把SqlSession的缓存清空。

二级缓存

二级缓存
Mybatis的二级缓存是指mapper映射文件。二级缓存的作用域是同一个namespace下的mapper映射文件内容，多个SqlSession共享。Mybatis需要手动设置启动二级缓存。

二级缓存是默认启用的(要生效需要对每个Mapper进行配置)，如想取消，则可以通过Mybatis配置文件中的元素下的子元素来指定cacheEnabled为false。

<settings>
  <setting name="cacheEnabled" value="false" />
</settings>

由于是根据namespace来调整的，所以在使用二级缓存时需要修改mapper.xml，开启缓存

在二级缓存中，mybatis是将类的信息序列化保存在硬盘上，所以映射的类（包括属性类）需要继承序列化。

效果：

Cache Hit Ratio 表示缓存命中率。

开启二级缓存后，每执行一次查询，系统都会计算一次二级缓存的命中率。
第一次查询也是先从缓存中查询，只不过缓存中一定是没有的。
所以会再从DB中查询。由于二级缓存中不存在该数据，所以命中率为0.但第二次查询是从二级缓存中读取的，所以这一次的命中率为1/2=0.5。
当然，若有第三次查询，则命中率为1/3=0.66 。

注意:

增删改操作，无论是否进行提交sqlSession.commit()，均会清空一级、二级缓存，使查询再次从DB中select。

二级缓存的使用原则

只能在一个命名空间下使用二级缓存，由于二级缓存中的数据是基于namespace的，即不同namespace中的数据互不干扰。在多个namespace中若均存在对同一个表的操作，那么这多个namespace中的数据可能就会出现不一致现象。

在单表上使用二级缓存

如果一个表与其它表有关联关系，那么非常有可能存在多个namespace对同一数据的操作。而不同namespace中的数据互补干扰，所以就有可能出现多个namespace中的数据不一致现象。

查询多于修改时使用二级缓存

在查询操作远远多于增删改操作的情况下可以使用二级缓存。因为任何增删改操作都将刷新二级缓存，对二级缓存的频繁刷新将降低系统性能。