Mybatis和MP

 MyBatis

概念：Mybatis是一个优秀的持久层框架,基于ORM(对象关系映射)设计思想，实现了以对象的方式操作数据库。

mybatis和mp都会动态回显

官网：mybatis – MyBatis 3 | 入门

一、springboot整合mybatis

1、添加依赖

<!--mybatis依赖包 -->  
<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>2.2.0</version>
 </dependency>

<!-- jdbc依赖包     -->  
 <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
   </dependency>

2、配置application.yml 

server:
  port: 8092

#整合1.数据源
spring:
  datasource:
    # mysql高版本加cj
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    #如果password开头为0，则整个密码需要使用引号引起  password: "0123456"
    password: root

url各参数类型：
1. serverTimezone=GMT%2B8  指定时区 东八区
2. useUnicode=true&characterEncoding=utf8   开启使用Unicode编码,并且指定字符集utf-8
3. autoReconnect=true   断线是否重新链接.
4. &allowMultiQueries=true   是否允许批量操作

    # 连接池
    hikari:
      # 连接池name
      pool-name: seckill-system
      # 最小空闲连接
      minimum-idle: 5
      # 空闲连接最大时间  默认10分钟
      idle-timeout: 180000
      # 最大连接数， 默认10
      maximum-pool-size: 10
      # 从连接池返回的连接自动提交
      auto-commit: true
      # 连接最大存活时间 0表示永久存货， 默认半小时
      max-lifetime: 180000
      # 连接超时时间，m默认30秒
      connection-timeout: 30000
      # 测试连接是否是可用的查询语句
      connection-test-query: SELECT 1
    

#SpringBoot整合MP
mybatis-plus:
  #指定别名包
  type-aliases-package: com.jt.pojo
  #加载指定的xml映射文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true

#Sql日志文件打印
logging:
  level:
    com.jt.mapper: debug

3、dao层添加注解

3.1 @Mapper

@Mapper注解是由Mybatis框架中定义的一个描述数据层接口的注解，即dao层开发。注解往往起到的都是一个描述性作用，用于告诉sprigng框架此接口的实现类由Mybatis负责创建，并将其实现类对象存储到spring容器中。

3.2 @MapperScan

在SpringBoot启动类上面添加@MapperScan注解

作用：指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类

@SpringBootApplication
@MapperScan("com.example.mapper")
public class SpringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

使用@MapperScan注解多个包

@SpringBootApplication  
@MapperScan({"com.example.mapper1","com.example.mapper2"})  
public class SpringbootApplication {  
    public static void main(String[] args) {  
       SpringApplication.run(SpringbootApplication.class, args);  
    }  
} 

二、MyBatis 编程步骤

准备dept表

实现步骤

（1）配置mybatis-config.xml。在官网里面找到核心配置文件(mybatis-config.xml)的内容复制下来做修改

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <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://13.118.127.27:3306/cun_chu_guo_cheng?serverTimezone=GMT%2B8&amp;useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;allowMultiQueries=true"/>
                <property name="username" value="root"/>
                <property name="password" value="111min"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 指定xml文件路径-->
        <mapper resource="mapping/CunchuguochengMapper.xml"/>
    </mappers>
</configuration>

  @Test
  public void mybatis() throws IOException {
    //（2）读取指定的核心配置文件.
    String resource = "mybatis/mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //（3）通过SelSessionFactoryBuilder.buid方法创建SqlSessionFactory.
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //（4）获取SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //（5）获取Mapper的接口
    CunchuguochengMapper cunchuguochengMapper = sqlSession.getMapper(CunchuguochengMapper.class);
    //（6）执行mapper接口中的方法，获取业务数据   （7）调用xml文件的Sql语句实现数据获取   （8）mybatis自动封装为对象返回交给用户处理
    List<HashMap<String, Object>> list = cunchuguochengMapper.selectDept();
    // 遍历数据
    for (HashMap<String, Object> hashMap : list) {
      System.out.println(hashMap);
    }
    // 关闭
    sqlSession.close();
  }
}

mapper接口

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

xml文件

<select id="selectDept" resultType="java.util.HashMap">
     select * from dept
</select>

po

import lombok.Data;

/**
 * @Description
 * @ClassName Dept2
 * @Author syh
 * @Date 2023/4/20 14:44
 */
@Data
public class Dept2 {
    private Integer deptNo;
    private String dName;
    private String loc;
}

代码结构

运行结果

三、Mapper接口中方法的参数封装： 

1、Mapper层参数封装

（1）将参数封装为实体对象，如果传递的参数是一个对象，则直接调用属性  #{属性名}

（2）将参数封装为Map集合，如果传入的参数是一个Map集合，则直接调用集合中key   #{key值}

（3）删除多条数据的sql语法，将参数封装为数组或list或map，删除多条数据的sql语法，在xml中使用foreach标签

（4）如果传入多个参数，在接口方法中使用注解@Param               List<DemoUser> findAll1(@Param("age") int age, @Param("sex") String sex);

  2、post/put接收参数为一个变量外加一个数组

 

四、sql语句的标签中常用属性

<select id="selectUserInfoById" parameterType="String" resultMap="BaseResultMap">
    select * from userinfos where UserInfoID = #{id}
</select>

1、id ：与mapper接口中的方法相对应

2、resultType：返回值类型。增删改不需要。 当结果集中的字段名与属性的名称一致时,才会实现自动的数据封装

3、resultMap：当结果集中的字段名称,与对象中的属性不一致时,可以使用resultMap实现自定义的封装

4、parameterType：表示传入的参数类型，程序会自动识别，建议省略不写

5、statementType：标记操作SQL的对象。取值说明：

STATEMENT:直接操作sql，不进行预编译。获取数据：

<update id="update4" statementType="STATEMENT">
    update tb_car set price=${price} where id=${id}
</update>

PREPARED:预处理，参数，进行预编译，默认。获取数据：

<update id="update5" statementType="PREPARED">
    update tb_car set xh=#{xh} where id=#{id}
</update>

CALLABLE:执行存储过程。获取数据：

<select id="jzajqkdb_tjdetails"statementType="CALLABLE"resultMap="getCaseCount_details_resultMap">
     call jzajqkdb_tjdetails(#{starttime,mode=IN},#{endtime,mode=IN},#{type,mode=IN})
</select>

五、动态sql

1、foreach标签

将传入参数(1，2，3，4，5)封装为①数组 ②List集合 ③Map

集合套入List集合。然后使用foreach标签遍历 

 <delete id="adddelete">
    delete from demo_user where id in
    <foreach collection="array" item="id" open="(" close=")" separator=","> 
       #{id}              
    </foreach>
</delete>

foreach标签中各个属性的作用：
1.collection：（1）类型为数组或者list集合时，数组为array，集合为list。（2）封装到map集合中的list key。（3）封装在对象中的list集合 属性名 
2.item 每次遍历的数据的形参
3.open 循环的开始标签     
4.close 循环的结束标签       
5.index 循环遍历下标 一般不用
6.separator 循环遍历的分割符 //设坡瑞特

 2、Sql-where

动态拼接where，避免传入条件为空，自动去除为空条件的and

<select id="selectByUser" parameterType="Demouser" >
     select * from demo_user
     <where>
          <if test="id !=null"> id= #{id}</if>
          <if test="name !=null">  and name = #{name}</if>
          <if test="age !=null">  and age = #{age}</if>
      </where>
</select>

3、动态Sql-set条件

动态拼接更新语句，自动去除末尾逗号

<update id="updateUserSet" parameterType="user">
     update demo_user
          <set>
              <if test="name !=null">name = #{name},</if>
              <if test="age != null"> age = #{age},</if>
          </set>
          where id = #{id}
</update>  

  

 4、动态Sql-choose、when、otherwise

该放法类似于if  else-if   else

<select id="selectChoose" resultType="User">
     select * from demo_user
     <where>
         <choose>    
              <when test='name !=null'> name = #{name} </when> 
              <when test='birthday != null '> u.birthday = #{birthday} </when> 
              <otherwise> sex = #{sex} </otherwise>    
         </choose>
     </where>
</select>

 六、sql语句简化操作

1、xml中sql语句复用

<!--该标签用户重复sql的封装，一般用于封装字段-->
<sql id="aa">  select * from demo_user</sql> 


<select id="addSelect" resultType="DemoUser">
    <include refid="aa"> </include>  where name = #{name}
</select>

2、SQL 语句映射

@Select、@Insert、@Update、@Delete，简化xml配置

@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);

3、简化resultType返回值为全类名的情况

当返回的类型为pojo对象，需要写入全类名，简化方法

（1）给resuType的值起别名

（2）当pojo中有多个类中，引入了别名包概念

（3）使用注解,直接在pojo包中类上使用注解@Alias(“别名”)

（4）建议写全路径，方便维护

七、其他标签使用

 1、if标签使用

<select id="getCaseNumTwo" resultType="java.lang.Integer" parameterType="com.hssmartcity.model.CaseDeadline">
        select
         count(*)
        FROM
        casedeadline
        <if test="mark == 1">
            RIGHT JOIN (
            SELECT
            *
            FROM
            casetypes
            WHERE
            CategoryCode IN ( SELECT CaseTypeID FROM casetypes WHERE CategoryCode = #{forCaseTypeId,jdbcType=VARCHAR} )) AS casetypes ON casedeadline.ForCaseTypeId = casetypes.CasetypeID
        </if>
        <if test="mark == 2">
            RIGHT JOIN ( SELECT * FROM casetypes WHERE CategoryCode = #{forCaseTypeId,jdbcType=VARCHAR} ) AS casetypes ON casedeadline.ForCaseTypeId = casetypes.CasetypeID
        </if>
    </select>

2、trim标签

一般用户insert操作，作用为去除sql语句中多余的and关键字，逗号，或者给sql语句前拼接 “where“、“set“以及“values(“ 等前缀，或者添加“)“等后缀。

<trim prefix="WHERE" prefixOverrides="AND">  </trim>
prefix	给sql语句拼接的前缀
suffix	给sql语句拼接的后缀
prefixOverrides	去除sql语句前面的关键字或者字符，该关键字或者字符由prefixOverrides属性指定，假设该属性指定为"AND"，当sql语句的开头为"AND"，trim标签将会去除该"AND"
suffixOverrides	去除sql语句后面的关键字或者字符，该关键字或者字符由suffixOverrides属性指定

<!--查询操作，去除where条件中多余and-->
<select id="findActiveBlogLike" resultType="Blog">
    SELECT * FROM BLOG 
    <trim prefix="WHERE" prefixOverrides="AND">
	    <if test="state != null">
	      state = #{state}
	    </if> 
	    <if test="title != null">
	      AND title like #{title}
	    </if>
	    <if test="author != null and author.name != null">
	      AND author_name like #{author.name}
	    </if>
    </trim>
</select》

     

八、xml文件注意事项

1、#{} 和 ${} 的区别

（1）#{}是占位符，会进行预编译处理，mybatis会将sql中的#{}换为？号，在sql执行前会使用PreparedStatement给sql的   ？号占位符设置参数值，能够避免SQL注入。

（2）$是变量拼接符，属于静态文本替换，不能避免sql注入。当传入参数为字段名称的时候，使用${column}获取参数值，但有sql注入的风险。

2、xml转义字符

'<'在sql语句中出现会报错，原因：xml文档将<符号认成标头，当有大量转义字符的时候，使用：<![CDAT[...内容]]>  将里  面内容变成普通字符串.

3、mybatis使用模糊查询

   1、传入的参数自带%

   2、传入时不带参数，需要在sql中name like '%${name}%'

   3、

<if test="groupname != null  and groupname != ''"> and GroupName like concat('%', #{groupname}, '%')</if>

4、sql语句中包含关键字处理

order是sql语句的关键字，添加反引号进行处理

5、sql语句条件判断

对于String类型，需要先判null，在判''
<if test="userName!=null and userName != ''">
       and UserName like '%${userName}%'
</if>

九、结果集封装

1、resultType

pojo类中的属性名和sql查询出的结果集中字段名保持一致，将查询结果自动封装到pojo中

或者是sql语句查询出来的内容可以使用普通类型接收（String  Integer  等等）

2、resultMap映射 

当结果集中的字段名称与对象中的属性不一致时，使用resultMap实现自定义的封装.     

<select id="findAll" resultMap="deptRM">
         select * from dept
</select>

<!--自定义映射关系-->
<resultMap id="deptRM" type="com.jt.Dept">
        <id column="dept_id" property="deptId"/>
        <result column="dept_name" property="deptName"/>
</resultMap>


1.id标签代表主键 (每张表中都会有一个主键)
      1.1.column: 代表sql语句查询出的结果集中的字段.
      1.2.property: pojo对象中的属性
2.result 主键之外其他字段映射关系

3、resultMap标签内容继承

<resultMap id="BaseResultMap" type="com.hssmartcity.model.StandardSpecification">
    <id column="LawId" jdbcType="VARCHAR" property="lawId" />
    <result column="LawName" jdbcType="VARCHAR" property="lawName" />
    <result column="ArticleContent" jdbcType="VARCHAR" property="articleContent" />
</resultMap>

继承上面的resultMap
<resultMap id="ExtBaseResultMap" type="com.hssmartcity.model.StandardSpecification" extends="BaseResultMap">
    <result column="UserName" jdbcType="VARCHAR" property="userName" />
    <result column="ParentLawName" jdbcType="VARCHAR" property="parentLawName" />
</resultMap>

4、不使用映射

表

mapper

List<HashMap<String, String>> selectProblemSource();

xml

    <select id="selectProblemSource" resultType="java.util.HashMap">
        select * from problem_source
    </select>

结果集

集合中 k 对应字段，v 对应值

 十、 关联查询

1、一对一表关系

pojo封装一对一数据

（1）关联查询

<!-- 一个emp员工表中对应一个dept部门信息 -->
<select  id="allSelect"  resultMap="empRM">
    select emp.id,emp.name,emp.age,dept.dept_id,dept.dept_name  from emp left join dept on emp.dept_id=dept.dept_id
</select>


<!-- 如果映射的字段与对象的属性一致,则可以直接autoMapping=true，省略手动映射,
     当映射字段和对象属性不一致，开启自动映射驼峰规则（dept_id自动变为deptId）,
     继而autoMapping省略手动映射。实际开发中推荐手写映射 -->
<resultMap id="empRM" type= "com.jt.pojo.Emp" autoMapping="true">
    <id column="id" property="id"></id>
    <!-- property本表对应的实体类属性 javaType属性表示该类的全路径 /əˌsəʊ siˈeɪʃn/ -->
    <association property="deptPojo" javaType="com.jt.pojo.Dept">   
        <!-- id标签表示主键的字段映射，当然主键字段映射也可以使用result，实际开发中不使用id标签 -->
        <id column="dept_id" property="deptId"></id>
        <result property="deptName" column="dept_name"/>
    </association>
</resultMap>

<!--
association标签是MyBatis中用来定义一对一或多对一关联关系的标签。在ResultMap中使用。其属性如下：
1、property：指定Java Bean中需要映射的属性名。
2、javaType：指定Java Bean的类型。
-->

（2）子查询

<!-- 员工表 一个emp员工表中对应一个dept部门信息 -->
<select id="allSelect1" resultMap="empRM1">
    select * from emp
</select>

<resultMap id="empRM1"  type="com.jt.pojo.Emp">
    <result column="id"  property="id"></result>
    <!-- property:本表对应的实体类属性  
         javaType:另一张表对应的实体类  
         column:本表字段（相关联字段） 
         select:对应的子查询mapper层方法名字，可以跨包调用--> 
    <association property="deptPojo"  javaType="com.jt.pojo.Dept" 
                 column="dept_id" select="com.hssmartcity.mapper.deptSelect"> 
    </association>  
</resultMap>

<!--dept部门表查询-->
<select id="deptSelect" resultMap="deptRM">
     select * from dept where dept_id = #{dept_id}
</select>
<resultMap id="deptRM" type="com.jt.pojo.Dept">
    <result column="dept_id" property="deptId"></result>
    <result column="dept_name" property="deptName"></result>
</resultMap>

<!--
association标签是MyBatis中用来定义一对一或多对一关联关系的标签。在ResultMap中使用。其属性如下：
1、property：指定Java Bean中需要映射的属性名。
2、javaType：指定Java Bean的类型。
3、column：关联字段。
4、select：指定关联查询所使用的Statement ID。
其中，property和javaType两个属性必须设置，其他属性可根据不同情况灵活选择。
-->

2、一对多表关系

pojo封装一对多数据：

（1）关联查询

<!-- 一个部门对应多个员工 -->
<select id="findDept" resultMap="listRM">
      SELECT d.dept_id,d.dept_name,e.id,e.name,e.age FROM
      dept d  LEFT JOIN  emp e  ON   d.dept_id = e.dept_id
</select>


<resultMap id="listRM" type="Dept">
    <id column="dept_id" property="deptId"/>
    <result column="dept_name" property="deptName"/>
    <!-- collection: 封装集合的固定写法.  property:指定属性 ofType:封装List集合的泛型对象 -->
    <collection property="emps" ofType="Emp">
        <id column="id" property="id"/>
    </collection>
</resultMap>

（2）一对多子查询

<!-- 部门表 一个部门对应多个员工 -->
<select id="allSelect3" resultMap="dept">
        select * from dept
</select>
<resultMapid="dept" type="com.jt.pojo.Dept" autoMapping="true">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <!-- property:本表实体类属性  
         ofType:另一张表的实体类  
         column:本表字段（相关联字段）
         select:对应的子查询mapper层方法名字，可以跨包调用--> 
    <collection property="empList" 
                ofType="com.jt.pojo.Emp" 
                column="dept_id" 
                select = "com.hssmartcity.mapper.SiBaoInfosMapper.empRm">   
    </collection>
</resultMap>
<!-- 
collection标签是MyBatis中用来定义一对多或多对多关联关系的标签，在ResultMap中使用。其属性如下：
1、property：指定Java Bean中需要映射的集合属性名。
2、ofType：指定Java Bean集合中对象的类型。
3、column：本表关联的字段。
4、select：指定关联查询所使用的Statement ID。
其中，property和ofType两个属性必须设置，其他属性可根据不同情况灵活选择。
 -->


<!-- 员工表 -->
<select id="empRM" resultMap="emp">
      select * from emp where dept_id = #{dept_id}
</select>
<resultMap id="emp" type="com.jt.pojo.Emp"  autoMapping="true">
      <id column="id"  property="id"></id>
</resultMap>

十一、缓存机制

引入缓存可以有效降低用户访问物理设备的频次.提高用户响应速度.

1、默认情况下，只有一级缓存( SqlSession级别的缓存也称为本地缓存)开启。一级缓存默认开启，SqlSession内共享数据

2、二级缓存需要手动开启和配置，他是基于namespace级别的缓存。二级缓存 默认开启，需要标识 SqlSessionFactory内共享数据。在映射XML文件中写入cache标签可以使用二级缓存。

1、一级缓存

开启log4j，可以看到试验效果，项目中添加log4j依赖。

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

配置日志打印配置

<setting name="logImpl" value="STDOUT_LOGGING"/>

测试

测试结果一级缓存生效 

假如清除了缓存，看下图效果 

 

一级缓存总结 

前提条件：同一个会话中

1、SQLsession 相同，执行同一个sql（完全相同，查询条件等等），会命中缓存

2、SQLsession 相同，两次查询间执行了增删改操作，不会命中缓存

3、SQLsession 相同，但是手动清除了缓存，不会命中缓存

2、二级缓存（全局缓存）

基于namespace级别的缓存，一个namespace（也就是一个Mapper.xml文件）对应一个二级缓存

工作机制

一个会话，查询一条数据，这个数据会被放在当前会话的一级缓存中；如果会话关闭：如果会话关闭; 一级缓存中的数据会被保存到二级缓存中;新的会话查询信息，就可以参照二级缓存；不同的namespace查出的数据会放在自己对应的缓存map中。

效果:数据会从二级缓存中获取查出的数据都会被默认先放在一级缓存中。只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中

开启二级缓存

第一步：修改mybatis-config.xml

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

如果是springboot集成的mybatis，在配置文件中修改

第二步：配置mapper.xml

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="false"/>


属性：
1、eviction :缓存的回收策略:
    LRU（默认） -最近最少使用的:移除最长时间不被使用的对象。
    FIFO -先进先出:按对象进入缓存的顺序来移除它们。
    SOFT -软引用:移除基于垃圾回收器状态和软引用规则的对象。
    WEAK 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

2、flushInterval:缓存刷新间隔缓存多长时间清空一次，默认不清空，设置一个毫秒值

3、readOnly :是否只读:
        true:只读; mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
        false非只读: mybati s觉得获取的数据可能会被修改。mybatis会利用序列化&反序列的技术克隆一份新的数据给你。非常安全，但是速度慢

4、size存放多少元素

5、type：指定自定义缓存的全类名（默认即可）

 第三步：对应的实体类要实现序列化接口

import lombok.Data;

import java.io.Serializable;

/**
 * @Description
 * @ClassName Dept2
 * @Author syh
 * @Date 2023/4/20 14:44
 */
@Data
public class Dept2 implements Serializable {
    private Integer deptNo;
    private String dName;
    private String loc;
}

测试

 

 修改readOnly 为true，再次测试

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

xml文件中关于缓存的其他设置

设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。所以：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

 <select id="selectByPrimaryKey" resultMap="BaseResultMap" useCache="true">
    select 
    <include refid="Base_Column_List" />
    from t_dm_cust
    where id = #{id,jdbcType=BIGINT}
  </select>

清空缓存，一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。但是如果你不想刷新缓存只需要这么做：

 <update id="updateByPrimaryKey" flushCache="false">
    update t_dm_cust
    set create_time = #{createTime,jdbcType=TIMESTAMP}
 where id = #{id,jdbcType=BIGINT}
  </update>

mybatis有缓存，为什么还要用redis

1、mybatis一级缓存作用域是session,session在commit之后缓存就消失了。

2、mybatis二级缓存作用域是sessionfactory,该缓存是以namespace为单位的（也就是一个Mapper.xml文件），不同namespace下操作互不影响。　　
　　
3、所有对数据表的改变操作都会刷新缓存，但是一般不要用二级缓存，例如，在UserMapper.xml中有大多数针对User表的操作，但是在另一个XXXManpper.xml中，还有针对user单表的操作，这会导致user在两个命名空间下的数据不一致。

4、如果在UserMapper.xml中做了刷新缓存的操作，在XXXMapper.xml中缓存仍然有效，如果有针对user的单标查询，使用缓存的结果可能会不正确，读到脏数据。

5、redis很好的解决了这个问题，而且比之一、二级缓存的更好，redis可以搭建在其它服务器上，缓存容量可扩展，redis可以灵活的使用在需要的缓存的数据上，比如一些热点数据，统计点赞啊。

十二、PageHelper分页插件（适用于mybatis和mp）

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper-spring-boot-starter</artifactId>
	<version>1.4.1</version>
</dependency>

#pagehelper分页插件配置
pagehelper:
  helper-dialect: mysql
  reasonable: false
  support-methods-arguments: true
  params: count=countSql

public PageInfo PageInfogetPunchingCardRecordInfor(Integer pageNum, Integer pageSize, Integer type, DateVO dateVO) {
    // 传入页码和每页条数，只针对最近的一条sql语句
    if (pageNum != null && pageSize!= null) {
         PageHelper.startPage(pageNum, pageSize);
    }
    // 在数据库获得数据
    List<WorkRecord> workRecordList = workRecordDao.getPunchingCardRecordInfor(hashMap);
    // 将获得的数据传入
    PageInfo<WorkRecord> pageInfo = new PageInfo<>(workRecordList);
    // 最后返回前端数据，getTotal是数据总量
    return pageInfo;

    /*   分页插件源码
    @Data
    public class PageList {
        private long totalNum;
        private Object Data;
        public PageList(long totalNum, Object data) {
            this.totalNum = totalNum;
            Data = data;
        }
    }
    */
}

遇到过获取总条数失效情况

1、分页代码与slq语句不相邻

2、new一个PageInfo之后，继续操作，比如将do转为vo就会造成总条数失效

十三、调用储存过程返回多个结果集

创建一个dept表

定义一个存储过程

CREATE DEFINER=`root`@`%` PROCEDURE `hello_procedure`(IN deptName VARCHAR(20))
begin
	SELECT deptName;
	SELECT * FROM dept;
end

controller

  @Autowired
  public CunchuguochengMapper cunchuguochengMapper;

  @GetMapping("/cunchuguocheng")
  public List<List<?>> cunchuguocheng() {
    List<List<?>> list = cunchuguochengMapper.cunchuguocheng("阿里巴巴");
    return list;
  }

mapper

List<List<?>> cunchuguocheng(String deptName);

xml

1、statementType取值说明：
STATEMENT：直接操作sql，不进行预编译，获取数据：$ >> Statement
PREPARED：预处理，参数，进行预编译，获取数据：# >> PreparedStatement（默认）
CALLABLE：执行存储过程————CallableStatement
2、mode=IN：
存储过程有三种类型的参数，分别为 IN(输入参数)，OUT(输出参数)，INOUT(输入输出参数)。
一个存储过程，可以有多个 IN 参数，至多有一个 OUT 或 INOUT 参数。mode=IN 表示该参数类型为IN。
3、当有多个结果集，就使用多个映射

    <resultMap id="tept1" type="com.syh.demo.Pojo.Dept1">
        <result property="deptName" column="deptname"></result>
    </resultMap>

    <resultMap id="tept2" type="com.syh.demo.Pojo.Dept2">
        <result property="deptNo" column="deptno"></result>
        <result property="deptName" column="deptname"></result>
        <result property="loc" column="loc"></result>
    </resultMap>

    <select id="cunchuguocheng" statementType="CALLABLE" resultMap="tept1, tept2">
        call hello_procedure(#{deptName,mode=IN,jdbcType=VARCHAR})
    </select>

浏览器测试

总结：

当有一个结果集，正常映射。当有多个结果集，手动创建多个映射

xml中的映射可以不用对象，例如

    <resultMap id="map1" type="java.util.HashMap">
        <result property="siBaoType" column="siBaoType" />
        <result property="total" column="total" />
        <result property="weiGuiNum" column="weiGuiNum" />
        <result property="weiWeiGuiNum" column="weiWeiGuiNum" />
        <result property="senHeLv" column="senHeLv" />
    </resultMap>

    <select id="selectProblemNum" statementType="CALLABLE" resultMap="map1, map1, map1, map1">
        call selectProblemNum(#{startTime,mode=IN,jdbcType=VARCHAR}, #{endTime,mode=IN,jdbcType=VARCHAR})
    </select>

十四、动态回显

insert语句插入数据，动态回显id

如果传入对象，那么将自动生成的主键映射到对象的id属性上；如果传入Map，那么将自动生成的主键映射到Map的id key上。

<!-- 
useGeneratedKeys="true"，以启用自动生成主键，并将生成的主键列名指定为 id，
将自动生成的主键值映射到 Java 对象的 id 属性上

keyColumn: 这个属性指定了数据库表中用于存储自动生成的主键值的列名。在你的例子中，
keyColumn="id" 表示自动生成的主键值将会存储在表中名为 id 的列中。

keyProperty: 这个属性指定了将自动生成的主键值映射到哪个 Java 对象的属性上。
在你的例子中，keyProperty="id" 表示自动生成的主键值将会映射到 Java 对象的 id 属性上。
 -->
<insert id="addKunjing" useGeneratedKeys="true" keyColumn="id" keyProperty="id">
        insert into big_difficulty_child
        (
            id,
            type
        )
        values
        (
            null,
            #{type}
        )
</insert>

MyBatis-Plus

全自动的ORM，可以做大部分的单表的CRUD。是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

官网：MyBatis-Plus (baomidou.com)

一、springboot整合mybatis

 1、修改pom文件和yml文件

<dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.4.3</version>
</dependency>

mybatis-plus:
    # 指定别名包
    type-aliases-package:com.jt.pojo

2、编辑POJO对象

核心: 实现对象关系映射->对象与数据库中表的映射关系

1. 对象名称与表名一一映射.
2. 对象的属性与表中的字段一一映射.

@TableName("demo_user")  //对象与表名映射   注意：当类名和包名一样时，可以省略括号及其内容
public class User implements Serializable {

    @TableId(type = IdType.AUTO)//标记这是主键自增
    private Integer id;

    private String name;

    @TableField("age")  //实现属性与字段映射  注意：当字段名与属性名一样，TableField注解可以省略
    private Integer age;

    private String sex;

    @TableField(exist = false) //表示该属性不是数据库里面的字段，默认true
    private List<ItemCat> children;  //业务属性

}

3、编辑Mapper对象

继承BaseMapper<> 接口

 

二、MP动态Sql实现原理

1. 用户调用接口方法 userMapper.insert(User)方法

2. 根据UserMapper的接口找到父级接口BaseMapper<T>

3. 根据父级接口动态获取当前接口的泛型对象T

4. 根据泛型T 获取指定的注解@TableName("demo_user"),之后获取表名demo_user

5. 根据泛型对象T,获取其中的属性,之后再找到属性的注解@TableField("id"),之后再次获取注解的值, 即字段名称.

6. 根据字段名称,获取对应属性的值.

7. 根据Sql拼接 形成最终的可以执行的Sql.

8. MP将生成的Sql交给Mybatis执行入库操作.

三、MP的crud

1、增加操作

（1）insert()

@Test
void updateUser() {
    User user = new User();
    user.setAge(12).setName("mybatis-plus").setSex("男").setId(null);
    //insert根据传入对象中不为空的属性进行sql语句书写
    userMapper.insert(user);
}

（2）insertList() 批量插入

@Service
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users> implements UsersService {
    @Override
    public void insertList() {
        List<Users> list = new ArrayList<>();
        for (int i = 0; i < 5000; i++) {
            Users users = new Users();
            users.setUserName("yy" + i);
            users.setAge(18);
            users.setEmail("123@qq.com");
            users.setAddress("临汾" + i);
            users.setAccount("1" + i);
            users.setPassword("pw" + i);
            list.add(users);
        }
        long start = System.currentTimeMillis();
        baseMapper.insertList(list);
        long end = System.currentTimeMillis();
        System.out.println("5000条数据插入，耗时：" + (end - start));
    }
}

2、查询操作

（1）selectById()，参数为主键列的值

Integer id =1;
User user =  userMapper.selectById(id);

（2）selectList()，拼接where条件

// QueryWrapper条件查询
@Test
public void selectLIst2(){
     String name = "黑熊精";
     Integer age =   null;
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();
     // 参数一为传入条件判断，boolean类型，true放行   参数二为数据库字段    参数三传入的数据
     // 条件之间默认连接符是and,省略不写。如果是or，条件之间需要.or()
     // 连接符:  eq =      gt >      lt <      ge >=    le <=       ne <>
     queryWrapper.eq(StringUtils.hasLength(name), "name", name).or().eq(age != null, "age", age);
     List<User> list = userMapper.selectList(queryWrapper);
     System.out.println(list);
     // 条件构造器实现复用
     queryWrapper.clean  
}

（3）selectObjs()只获取主键列的数据，关联查询时使用

@Test

public void selectObjs(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("sex","女");
    List<Object> list = userMapper.selectObjs(queryWrapper);
    System.out.println(list);
}

（4）selectOne 获取详情

@Override
public UserInfos findUserByUserAccount(String userAccount) {
   // 查询条件
   QueryWrapper<UserInfos> queryWrapper = new QueryWrapper<>();
   queryWrapper.eq("UserAccount", userAccount);
   UserInfos userInfos = userInfosDao.selectOne(queryWrapper);
   return userInfos;
}

（5）模糊查询

queryWrapper.likeLeft("name", "君").eq("sex", "女");
like：%君%    likjeLeft：%君  likeRight：君%

（6）in和order的使用

@Test

public void selectInOrder(){
    Integer[] integers = {1,2,3,4,5,6,7,8};
    //不能传入int[]
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //orderByDesc：降序    orderByAsc：升序
    queryWrapper.in("id", integers).orderByDesc("age", "sex");
    List<User> list = userMapper.selectList(queryWrapper);
    System.out.println(list);
}

（7）查询部分字段

方法一：查询id和username字段

@RequestMapping("/selectByWrapper1")
public List<SysUser> selectByWrapper1(){
   QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
   queryWrapper.select("id", "username");//指定查询某字段
   List<SysUser> sysUsers=sysUserService.list(queryWrapper);
   return sysUsers;
}

方法二：查询除了id和email字段除外的其他字段

@RequestMapping("/selectByWrapper2")
public List<SysUser> selectByWrapper2(){
   QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>();
   queryWrapper.select(SysUser.class, info ->!info.getColumn().equals("id") && !info.getColumn().equals("email"));//查询指定某字段以外的数据
   List<SysUser> sysUsers=sysUserService.list(queryWrapper);
   return sysUsers;
}

（8）selectCount根据某个字段获取条数

QueryWrapper<CommunityActivity> communityActivityQueryWrapper = new QueryWrapper<>();
communityActivityQueryWrapper.eq("CommunityName", communityActivityDTO.getCommunityName());
Integer integer = communityActivityMapper.selectCount(communityActivityQueryWrapper);

（9）分组查询

QueryWrapper<User> lqw = new QueryWrapper<User>();
lqw.select("count(*) as count, tel");
lqw.groupBy("tel");
List<Map<String, Object>> userList = userDao.selectMaps(lqw);
System.out.println(userList);

3、更新操作方式

（1）updateById的方式

这种方式需要传入实体类，生成的Sql，根据主键更新所有字段。所以更推荐第二种。

User user = new User();
user.setUserId(1);
user.setAge(23);
userMapper.updateById(user);

（2）UpdateWrapper构造修改条件

这种方式可以只更新指定的几个字段。

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper
.set("age", 23);   //set实现的是sql语句的update set age = 18的部分
.eq("name","张三")   //eq实现的是sql 的where 后面的部分。
userMapper.update(null, updateWrapper);   //第一个参数一定是null，才只会更新Wrapper里的指定字段。

4、删除操作

（1）根据Id删除

@Test
public void testDeleteById(){
    int result = userMapper.deleteById(5L);
    system.out.println(result);
}

（2）批量删除

@Test
public void testDeleteBatchIds(String[] ids) {
    int result = enterpriseMapper.deleteBatchIds(Arrays.asList(ids));
    system.out.println(result);
}

@Override
public int deleteResidentiaInfoByIds(String[] ids) {
    List<String> collect = Arrays.stream(ids).collect(Collectors.toList());
    return residentiaInfoMapper.deleteBatchIds(collect);
}

（3）deleteByMap条件删除

@Test
public void testDeleteByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Helen");
    map.put("age", 18);
    int result = userMapper.deleteByMap(map);
    system.out.println(result);
}

（4）QueryWrapper条件删除

@Test
public void deleteByWrapper2(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("age",23).eq("name","向中");
    int delete = userMapper.delete(queryWrapper);
}

（5）LambdaQueryWrapper删除

// LambdaQueryWrapper条件删除
@Test
public void deleteByWrappersLamdba(){
    LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.<User>lambdaQuery();
    lambdaQueryWrapper.eq(User::getAge,33).eq(User::getEmail,"xn@baomidou.com");
    int delete = userMapper.delete(lambdaQueryWrapper);
    System.out.println("删除记录："+delete);
}

四、MP分页查询

selectPage()方法，分页查询为方言，使用MP可以实现代码跨数据库使用，需要手动指定是哪款数据库

1、分页查询实现步骤

（1）在config包中新建MybatisPlusConfig类，类上面加注解：@Configuration  ，标记这是一个配置类，相当于早期的xml文件

（2）引入官网中的方法

/**
 * @Description
 * @ClassName MybatisPlusConfig
 * @Author syh
 * @Date 2022/11/10 15:05
 */
@Component
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

（3）配置Service层代码

   /**
     * @MethodName getBusinessAdministration11
     * @Description  mybatis-plus分页测试  可分页可不分页版本
     * @param pageNum   页码
     * @param pageSize   每页条数
     * @return com.hssmart.vo.PaginationVO
     *
     * @Author syh
     * @Date 2022/11/10 16:25
     */
    @Override
    public PaginationVO getBusinessAdministration11(Integer pageNum, Integer pageSize) {

        Page<EnterprisePartyBuilding> page;
        if (pageNum == null || pageSize == null) {
            /*
             * 如果想不分页，两个参数就传入负值
             * 参数一为开始索引  参数二为条数。实际应用中会传入页码和条数
             * */
            page = new Page<>(-1, -1);
        } else {
            page = new Page<>((long) (pageNum - 1) * pageSize, pageSize);
        }
        LambdaQueryWrapper<EnterprisePartyBuilding> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        // 分页查询方法：参数一page<>接口类型   参数二为传入的其他where条件
        page = enterprisePartyBuildingMapper.selectPage(page, lambdaQueryWrapper);
        // 获取总条数
        long total = page.getTotal();
        // 获取分页后的数据
        List<EnterprisePartyBuilding> records = page.getRecords();
        PaginationVO paginationVO = new PaginationVO();
        paginationVO.setTotalNum(total);
        paginationVO.setData(records);
        return paginationVO;
    }

/**
 * @Description 分页信息封装
 * @ClassName PaginationVO
 * @Author syh
 * @Date 2022/11/10 16:10
 */
@Data
public class PaginationVO {

    private Long totalNum;

    private Object data;
}

五、自动填充功能

1、编辑pojo层，添加注解

@Data
@Accessors(chain=true)
public class BasePojo implements Serializable{

    //表示入库时需要自动赋值
    @TableField(fill = FieldFill.INSERT)
    private Date created;  

    //表示入库/更新时自动赋值.
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updated;  
}

2、实现元对象处理器接口

创建一个config包，创建MyMetaObjectHandler类实现接口

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        Date date =new Date();
        this.setFieldValByName("created",date,metaObject);
        this.setFieldValByName("updated",date, metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        Date date =new Date();
        this.setFieldValByName("updated",date,metaObject);
    }
}