mybatis

<!--单个引用类型,{}中写的使用对象的属性名-->
<select id="findByDeptnoAndSal3" resultType="emp" parameterType="emp" >
    select * from emp where deptno =#{deptno} and sal >= #{sal}
</select>


<!--
多个引用类型作为方法参数
 List<Emp> findByDeptnoAndSal4(@Param("empa") Emp empa,@Param("empb") Emp empb);
 如果用@Param定义了别名,那么就不能使用arg*.属性名,但是可以使用param*.属性名和别名.属性名
-->
<select id="findByDeptnoAndSal4" resultType="emp"  >
    <!-- select * from emp where deptno =#{arg0.deptno} and sal >= #{arg1.sal} -->
     select * from emp where deptno =#{param1.deptno} and sal >= #{param2.sal}
     <!-- select * from emp where deptno =#{empa.deptno} and sal >= #{empb.sal}-->
</select>

<a name="i7alW"></a>
### 模糊查询
在映射文件中可以使用concat()函数来连接参数和通配符。另外注意对于特殊字符，比如<，不能直接书写，应该使用字符实体替换。
```xml
<select id="findByEname"  resultType="emp" >
  select * from emp where ename like concat('%',#{name},'%')
</select>

<select id="testMohu" resultType="User">
   select * from emp where ename like "%"#{name}"%"
</select>

主键自增回填.

方式1
useGeneratedKeys：表示要使用自增的主键
keyProperty：表示把自增的主键赋给JavaBean的哪个成员变量。
以添加Dept对象为例，添加前Dept对象的deptno是空的，添加完毕后可以通过getDeptno() 获取自增的主键。
方式2
order：取值AFTER|BEFORE，表示在新增之后|之前执行中的SQL命令
keyProperty：执行select @@identity后结果填充到哪个属性中
resultType：结果类型。

<mapper namespace="com.msb.mapper.DeptMapper">
  <!--方式1-->
    <insert id="addDept" parameterType="dept" useGeneratedKeys="true" keyProperty="deptno">
        insert into dept values(null,#{dname},#{loc})
    </insert>
    <!--方式2-->
    <insert id="addDept2" parameterType="dept">
        <selectKey order="AFTER" keyProperty="deptno"  resultType="int">
            select @@identity
        </selectKey>
        insert into dept values(null,#{dname},#{loc})
    </insert>
</mapper>

在很多应用场景中需要新增数据后获取到新增数据的主键值，针对这样的需求一般由三种解决方式：

1. 主键自定义，用户通过UUID或时间戳等方式生成唯一主键，当做主键值。在分布式场景中应用较多。
2. 查询后通过select max(主键) from 表获取主键最大值。这种方式在多线程访问情况下可能出现问题。
3. 查询后通过select @@identity获取最新生成主键。要求这条SQL必须在insert操作之后，且数据库连接没有关闭。

   动态SQL

   if标签

   if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中
   的内容不会执行 ```xml <?xml version=”1.0” encoding=”UTF-8” ?> <!DOCTYPE mapper

    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   

   select * from emp where 1=1 and empno =#{empno} and ename like concat(‘%’,#{ename},’%’)

<a name="ydVTr"></a>
### where标签
where和if一般结合使用：

- 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
- 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的<br />and去掉

注意：where标签不能去掉条件最后多余的and
```xml
<select id="findEmpByCondition" resultType="emp">
    select * from emp
    <where>
        <if test="empno != null">
            and empno= #{empno}
        </if>
        <if test="ename != null and ename != ''">
            and ename= #{ename}
        </if>
    </where>
</select>

choose标签

choose、when、otherwise相当于if…else if..else

<select id="findEmpByCondition2" resultType="emp">
    select * from emp
    <where>
        <choose>
            <when test="empno != null">
                and empno= #{empno}
            </when>
            <when test="ename != null and ename != ''">
                and ename= #{ename}
            </when>
        </choose>
    </where>
</select>

set标签

set和if一般结合使用：

• 若set标签中的if条件都不满足，则set标签没有任何功能，即不会添加set关键字
• 若set标签中的if条件满足，则set标签会自动添加set关键字，并将条件最前方多余的 , 去掉

注意：where标签不能去掉条件最后多余的and

<!--int updateEmpByCondtion(Emp emp);-->
<update id="updateEmpByCondtion" >
    update emp
    <set>
        <if test="ename != null and ename != '' ">
            , ename =#{ename}
        </if>
        <if test="job != null and ename != '' ">
            , job =#{job}
        </if>
    </set>
    where empno =#{empno}
</update>

trim标签

trim用于去掉或添加标签中的内容
trim标签常用属性：
prefix：在trim标签中的内容的前面添加某些内容
prefixOverrides：在trim标签中的内容的前面去掉某些内容
suffix：在trim标签中的内容的后面添加某些内容
suffixOverrides：在trim标签中的内容的后面去掉某些内容

bind标签

一般用于处理模糊查询的模板

<select id="findEmp" resultType="emp">
  <bind name ="likePatten" value="'%'+param1+'%'" />
  select * from emp where ename like #{likepattrn}
</select>

foreach标签

foreach标签属性：

• collection：设置要循环的数组或集合：
  • 参数是数组，collection中名字指定为array；
  • 参数是List集合，collection中名字指定为list
• item：表示集合或数组中的每一个数据
• separator：设置循环体之间的分隔符
• open：设置foreach标签中的内容的开始符
• close：设置foreach标签中的内容的结束 ```xml select * from emp where empno in #{deptno}

select * from emp where empno in #{deptno} </foreach>

<a name="UVei1"></a>
### sql标签
sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
```xml
<sql id="empColumn">empno,ename,job,mgr,hiredate,sal,comm,deptno</sql>

<select id="findByCondition" resultType="emp">
   select  <include refid="empColumn" /> from emp
    <trim prefix="where" prefixOverrides="and">
        <if test="empno != null">
            and empno =#{empno}
        </if>
        <if test="ename != null and ename != ''">
            <bind name="likePattern" value="'%'+ename+'%'"/>
            and ename like #{likePattern}
        </if>
    </trim>

</select>

自定义结果映射ResultMap

resultMap标签属性：

• id：表示自定义映射的唯一标识
• type：查询的数据要映射的实体类的类型

子标签：

• id：设置主键的映射关系
• result：设置普通字段的映射关系
• association：设置多对一的映射关系
• collection：设置一对多的映射关系

属性：

• property：设置映射关系中实体类中的属性名
• column：设置映射关系中表中的字段名

  <mapper namespace="com.msb.mapper.EmpMapper">
  <!--手动处理数据库查询字段和封装实体类属性之间的映射关系
  1 主键一般使用id属性
  2 当属性名和查询出的数据表字段名相同 可以不写映射关系
  -->
  <resultMap id="empMap" type="emp">
     <id property="empno" column="empno"></id>
     <result property="name" column="ename"></result>
     <result property="job" column="job"></result>
     <result property="sal" column="sal"></result>
     <result property="hiredate" column="hiredate"></result>
     <result property="mgr" column="mgr"></result>
     <result property="comm" column="comm"></result>
     <result property="deptno" column="deptno"></result>
  </resultMap>
  <select id="findByEmpno" resultMap="empMap" >
     select * from emp where empno =#{empno}
  </select>
  </mapper>
  

  一对一关系

  一对一关系查询，ReselutMap使用association标签，property为属性名，javaType为用哪个类的对象给属性赋值

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.msb.mapper.EmpMapper">
  <!--Emp findEmpJoinDeptByEmpno(int empno);-->
  <resultMap id="empJoinDept" type="emp">
     <!--设置emp本身的八个属性的映射关系-->
     <id property="empno" column="empno"></id>
     <result property="ename" column="ename"></result>
     <result property="job" column="job"></result>
     <result property="sal" column="sal"></result>
     <result property="hiredate" column="hiredate"></result>
     <result property="mgr" column="mgr"></result>
     <result property="comm" column="comm"></result>
     <result property="deptno" column="deptno"></result>
     <!--
     association 处理一对一
     封装一对一信息关系的标签
     property  emp类的属性名
     javaType  用哪个类的对象给属性赋值
     -->
     <association property="dept" javaType="dept">
         <id column="deptno" property="deptno"></id>
         <result column="dname" property="dname"></result>
         <result column="loc" property="loc"></result>
     </association>
  </resultMap>
  <select id="findEmpJoinDeptByEmpno" resultMap="empJoinDept" >
     select * from
     emp e
     left join dept  d
     on e.deptno =d.deptno
     where empno = #{empno}
  </select>
  </mapper>
  

  一对多关系

  一对多关系，使用conllection标签，property为属性名，ofType为用那个类本来填充属性

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.msb.mapper.DeptMapper">
  <!--Dept findDeptJoinEmpsByDeptno(int deptno);-->
  <resultMap id="deptJoinEmps" type="dept">
     <id column="deptno" property="deptno"></id>
     <result column="dname" property="dname"></result>
     <result column="loc" property="loc"></result>
     <!--处理一对多关系的标签-->
     <collection property="empList" ofType="emp" >
         <!--设置emp本身的八个属性的映射关系-->
         <id property="empno" column="empno"></id>
         <result property="ename" column="ename"></result>
         <result property="job" column="job"></result>
         <result property="sal" column="sal"></result>
         <result property="hiredate" column="hiredate"></result>
         <result property="mgr" column="mgr"></result>
         <result property="comm" column="comm"></result>
         <result property="deptno" column="deptno"></result>
     </collection>
  </resultMap>
  <select id="findDeptJoinEmpsByDeptno" resultMap="deptJoinEmps">
     select * from dept d left join emp e on d.deptno =e.deptno where d.deptno =#{deptno}
  </select>
  </mapper>
  

  多对多关系

  多对多关系，拆分成1对1和1对多，结合使用association，collection标签

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.msb.mapper.ProjectMapper">
  <!--Project findProjectJoinEmpsByPid(int pid);-->
  <resultMap id="projectJoinEmps" type="project">
     <id column="pid" property="pid"></id>
     <result column="pname" property="pname"></result>
     <result column="money" property="money"></result>
     <!--一对多 集合属性 collection-->
     <collection property="projectRecords" ofType="projectRecord">
         <id column="empno" property="empno"></id>
         <id column="pid" property="pid"></id>
         <!--一对一 -->
         <association property="emp" javaType="emp">
             <id property="empno" column="empno"></id>
             <result property="ename" column="ename"></result>
             <result property="job" column="job"></result>
             <result property="sal" column="sal"></result>
             <result property="hiredate" column="hiredate"></result>
             <result property="mgr" column="mgr"></result>
             <result property="comm" column="comm"></result>
             <result property="deptno" column="deptno"></result>
         </association>
     </collection>
  </resultMap>
  <select id="findProjectJoinEmpsByPid"  resultMap="projectJoinEmps">
     select * from
     project p
     left join projectrecord pr
     on p.pid = pr.pid
     left join emp e
     on e.empno = pr.empno
     where p.pid= #{pid}
  </select>
  </mapper>
  

  级联查询

  就是利于数据库表间的外键关联关系进行自动的级联查询操作。
  使用MyBatis实现级联查询，除了实体类增加关联属性外，还需要在映射文件中进行配置。

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.msb.mapper.DeptMapper">
  <!--Dept findDeptByDeptno(int deptno);
  select="com.msb.mapper.EmpMapper.findEmpsByDeptno" 调用的另一个SQL语句
  javaType="list"  实体类的属性数据类型
  column="deptno"  给另一个SQL语句传入的参数列
  jdbcType="INTEGER" 参数对应JDBC的数据类型
  fetchType="eager"  加载方式 eager 积极加载  lazy延迟加载-->
  <resultMap id="deptJoinEmps" type="dept">
     <id property="deptno" column="deptno"></id>
     <result property="dname" column="dname"></result>
     <result property="loc" column="loc"></result>
     <collection property="empList"
                 select="com.msb.mapper.EmpMapper.findEmpsByDeptno"
                 javaType="list"
                 column="deptno"
                 jdbcType="INTEGER"
                 fetchType="eager"
     >
     </collection>
  </resultMap>
  <select id="findDeptByDeptno" resultMap="deptJoinEmps">
     select * from dept where deptno =#{deptno}
  </select>
  </mapper>
  

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.msb.mapper.EmpMapper">
  <select id="findEmpsByDeptno" resultType="emp">
     select * from emp where deptno =#{deptno}
  </select>
  </mapper>
  

  级联查询可以设置延迟加载，采用延迟加载步骤：
  第一步：全局开关：在sqlMapConfig.xml中打开延迟加载的开关。配置完成后所有的association和collection元素都生效
  lazyLoadingEnabled:是否开启延迟加载。是Mybatis是否启用懒加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态
  aggressiveLazyLoading：当开启时，任何方法的调用都会懒加载对象的所有属性。否则，每个属性会按需加载,
  第二步：分开关：指定的association和collection元素中配置fetchType属性。eager：表示立刻加载；lazy：表示延迟加载。将覆盖全局延迟设置。

  Mybatis缓存

  MyBatis的一级缓存

  
  一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。一级存储默认开启，是一种内存型缓存,不要求实体类对象实现Serializable接口。缓存中的数据使用键值对形式存储数据namespace+sqlid+args+offset >>> hash值作为键，查询出的结果作为值

  使一级缓存失效的四种情况

1. 不同的SqlSession对应不同的一级缓存
2. 同一个SqlSession但是查询条件不同
3. 同一个SqlSession两次查询期间执行了任何一次增删改操作

4. 同一个SqlSession两次查询期间手动清空了缓存

   MyBatis的二级缓存

   
   级缓存是SqlSessionFactory级别，是以namespace为标记的缓存，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取。默认并不开启。二级缓存开启的条件：

5. 在核心配置文件中，设置全局配置属性cacheEnabled=”true”，默认为true。

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

6. 在映射文件中设置标签

   <mapper namespace="com.msb.mapper.EmpMapper">
    <cache/>
    <select id="findByEmpno" resultType="emp" useCache="true" flushCache="false">
        select * from emp where empno =#{empno}
    </select>
   </mapper>
   

7. 二级缓存必须在SqlSession关闭或提交之后有效

8. 查询的数据所转换的实体类类型必须实现序列化的接口

   使二级缓存失效的情况：

   两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

   二级缓存的相关配置

   在mapper配置文件中添加的cache标签可以设置一些属性：

9. eviction属性：缓存回收策略

• LRU（Least Recently Used）：最近最少使用的，移除最长时间不被使用的对象。
• FIFO（First in First out）：先进先出，按对象进入缓存的顺序来移除它们。
• SOFT ：软引用，移除基于垃圾回收器状态和软引用规则的对象。
• WEAK ：弱引用，更积极地移除基于垃圾收集器状态和弱引用规则的对象。

默认的是LRU。

1. flushInterval属性：刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

1. size属性：引用数目，正整数代表缓存最多可以存储多少个对象，太大容易导致内存溢出
2. readOnly属性：只读，true/false

• true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
• false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。

  MyBatis缓存查询的顺序

1. 先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
2. 如果二级缓存没有命中，再查询一级缓存
3. 如果一级缓存也没有命中，则查询数据库

4. SqlSession关闭之后，一级缓存中的数据会写入二级缓存

   整合第三方缓存EHCache

5. 添加依赖

   <dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.0.2</version>
   </dependency>
   <dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.1</version>
   </dependency>
   <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-nop</artifactId>
    <version>1.7.2</version>
   </dependency>
   

6. 创建EHCache的配置文件ehcache.xml ```xml <?xml version=”1.0” encoding=”UTF-8”?> <ehcache xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“

     xsi:noNamespaceSchemaLocation="ehcache.xsd"
     updateCheck="true" monitoring="autodetect"
     dynamicConfig="true">
   

   <defaultCache

        maxElementsInMemory="1000"
        maxElementsOnDisk="10000000"
        eternal="false"
        overflowToDisk="true"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU">
   

3.  设置二级缓存的类型

去各自的sql映射文件里,开启二级缓存,并把缓存类型指定为EhcacheCache
```xml
 <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

Mybatis逆向工程

<dependencies>
    <!-- mysql驱动包 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <!-- 日志包，方便查看执行信息-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.6.1</version>
    </dependency>
    <!-- 代码生成工具jar -->
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.3.2</version>
    </dependency>
</dependencies>

<?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>
   <context id="testTables" targetRuntime="MyBatis3">
      <commentGenerator>
         <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
         <property name="suppressAllComments" value="true" />
      </commentGenerator>
      <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
      <!-- <jdbcConnection driverClass="com.mysql.jdbc.Driver"
         connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
         password="123">
      </jdbcConnection> -->
       <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
         connectionURL="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"
         userId="root"
         password="root">
      </jdbcConnection> 
      <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 
         NUMERIC 类型解析为java.math.BigDecimal -->
      <javaTypeResolver>
         <property name="forceBigDecimals" value="false" />
      </javaTypeResolver>
      <!-- targetProject:生成PO类的位置 -->
      <javaModelGenerator targetPackage="com.msb.pojo"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
         <!-- 从数据库返回的值被清理前后的空格 -->
         <property name="trimStrings" value="true" />
      </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
      <sqlMapGenerator targetPackage="com.msb.mapper"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
      </sqlMapGenerator>
      <!-- targetPackage：mapper接口生成的位置 -->
      <javaClientGenerator type="XMLMAPPER"
         targetPackage="com.msb.mapper"
         targetProject=".\src">
         <!-- enableSubPackages:是否让schema作为包的后缀 -->
         <property name="enableSubPackages" value="false" />
      </javaClientGenerator>
      <!-- 指定数据库表 -->

      <table tableName="dept" domainObjectName="Dept"
       enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false"    
               enableSelectByExample="false" selectByExampleQueryId="false" >
               <columnOverride column="id" javaType="Integer" />
         </table>
   </context>
</generatorConfiguration>

public class GeneratorSqlmap {
    public void generator() throws Exception{
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("D:\\ideaProjects\\reverse\\target\\classes\\generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                                                                 callback, warnings);
        myBatisGenerator.generate(null);
    }
    public static void main(String[] args) throws Exception {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

补充一点：

<build>
  <!--告诉maven将项目源码中的xml文件也进行编译，并放到编译目录中-->
  <resources>
    <resource>
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.xml</include>
      </includes>
      <filtering>true</filtering>
    </resource>
    <resource>
      <directory>src/main/resources</directory>
      <filtering>true</filtering>
    </resource>
  </resources>
</build>