【01-02】Mybatis的配置文件与基于XML的使用

46 阅读 0 评论 0 点赞

1、引入日志

在这里我们引入SLF4J的日志门面，使用logback的具体日志实现；
引入相关依赖：

		<!--日志的依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

添加logback的配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true">

    <!--追加器：日志以哪种方式输出，name：自定义追加器的名称，class：追加器实现类的全限定名（不同实现类输出的方式不同，下面是以控制台方式输出）-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!--设置日志输出格式-->
            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} ---> %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--设置全局日志级别-->
    <root level="INFO">
        <!--设置当前日志级别输出到哪个追加器上-->
        <appender-ref ref="CONSOLE" />
    </root>

    <!--设置某个包或者某个类的局部日志级别-->
    <logger name="org.example.mapper" level="debug" />
    <logger name="org.apache.ibatis.transaction" level="debug" />

</configuration>

测试结果：

2、全局配置文件

在mybatis的项目中，有一个mybatis-config.xml的配置文件，这个配置文件是mybatis的全局配置文件，用来进行相关的全局配置。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"></properties>
    <settings> </settings>
    <typeAliases> </typeAliases>
    <environments></environments>
    <mappers></mappers>
</configuration>

1、propertis（属性）

  <!--配置外部属性资源文件，通过 ${} 来进行引用-->
    <properties resource="db.properties">
        <!--也可以在内部自定义属性-->
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/trs-db?useUnicode=true&amp;characterEncoding=utf8&amp;tinyInt1isBit=false&amp;useSSL=false&amp;serverTimezone=GMT%2B8&amp;allowMultiQueries=true&amp;zeroDateTimeBehavior=convertToNull"/>
        <property name="username" value="root"/>
        <property name="password" value="rootxq"/>
    </properties>

2、setting（设置）

 	<settings>
        <!--	设置默认执行器：SIMPLE(普通执行器)、REUSE(可重复使用执行器，会重用预处理语句)、BATCH(批量执行器，不仅重用预处理语句，而且可以批量更新)-->
        <setting name="defaultExecutorType" value="SIMPLE"/>
        <!--    开启驼峰命名自动映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--	在懒加载下，哪些方法会触发立即加载，默认：equals、toString、hashCode-->
        <!--<setting name="lazyLoadTriggerMethods" value=""/>-->
        <!--    开启全局的延迟加载：true 所有的嵌套查询都是懒加载，false 所有嵌套查询都会被立即加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--    设置加载的数据是否按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
        <!--    开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

3、typeAliases（类型别名）

	<!--设置类的别名，可以降低冗余的全局限定名的书写-->
    <typeAliases>
        <!--1、可以设置包下所有类的别名：会使用类名作为别名（是忽略大小写的）-->
            <!--<package name="org.example.pojo"/>-->
        <!--2、可以自定义设置某个类的别名-->
            <typeAlias type="org.example.pojo.Emp" alias="emp"/>
            <typeAlias type="org.example.pojo.Dept" alias="dept"/>
    </typeAliases>

4、environments（环境配置）

 <!--配置数据源连接信息-->
    <!--可以配置多个数据源（environment），例如：测试环境、生产环境各配置一个数据源，default：设置默认使用哪个数据源-->
    <environments default="development">
        <environment id="development">
            <!--事务管理器：type 设置事务管理类型
                         	（1）JDBC：使用JDBC的事务管理方式
                            （2）MANAGED：不运用事务 -->
            <transactionManager type="JDBC"/>
            <!--数据源：type 设置数据源类型
                            （1）UNPOOLED：不使用连接池
                            （2）POOLED：使用Mybatis的连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>

5、mappers（映射器）

 <!--映射器：有4种配置方式-->
    <mappers>
        <!--1、设置MapperXML的方式，适用于根据statementId进行操作-->
            <mapper resource="mapper/DeptMapper.xml"/>
            <mapper resource="mapper/EmpMapper.xml"/>
        <!--2、设置Mapper接口的方式，适用于接口绑定的方式-->
            <!--<mapper class="org.example.mapper.EmpMapper"/>-->
            <!--<mapper class="org.example.mapper.DeptMapper"/>-->
        <!--3、使用磁盘的绝对路径（基本不用）-->
        <!--4、根据包路径设置该包下的所有Mapper接口，适用于接口绑定和注解的方式（应用最多的方式）-->
            <!--<package name="org.example.mapper"/>-->
    </mappers>

3、SQL映射文件

MyBatis 的真正强大之处在于它的语句映射。由于它的异常强大，映射器的XML 文件就显得相对简单。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。
映射文件中极其重要的几大标签：
- select：映射查询语句
- insert：映射插入语句
- update：映射更新语句
- delete：映射删除语句
- sql：定义可重用的sql语句；
- cache：设置当前命名空间下的缓存配置；
- cache-ref：引用其他命名空间下的缓存配置；
- resultMap：描述如何从数据库的结果集中加载对象；
每个顶级元素标签中可以添加很多个属性，下面介绍相关属性的作用
- （1）id：设置当前命名空间中各个映射标签的唯一标识符（同一个命名空间中的id不允许重复，对应mapper接口中的方法名称）；
- （2）paramType：设置SQL的参数类型（mybatis会根据接口方法的参数自动读取参数的类型，所以不强制要求设置）；
- （3）statementType：设置当前的Statement类型（默认为PREPARED）:
  - STATEMENT：代表JDBC的Statement，不支持参数预解析;
  - PREPARED：代表JDBC的PreparedStatement，支持参数预解析;
  - CALLABLE：代表JDBC的CallableStatement，支持存储过程调用;
- （4）useGeneratedKeys：启用主键生成策略，设置是否获取插入后的自增长主键的值，默认是false，设置为true时，才会获取自增长主键的值；
- （5）keyProperty：设置将获取到的自增长主键值映射到实体类的哪个属性上；
- （6）keyColumn：如果存在组合主键的情况，指定获取哪个主键的字段名;
例如：

	<insert id="insertEmp" useGeneratedKeys="true" keyProperty="eId" >
        <!--
        如果数据库不支持列值自增长的话，可以使用下面的方法：
	        selectKey：可以在增删改操作之前或者之后执行
	            相关属性：
	                order：设置执行时机（BEFORE表示之前，AFTER表示之后）
	                keyProperty：设置将当前查询结果放到哪个POJO的属性上
	                resultType：设置返回值的类型-->
		<selectKey order="BEFORE" keyProperty="eId" resultType="int">
		 	SELECT MAX(eid)+1 FROM emp
		</selectKey>
        INSERT INTO emp (eid,e_name,e_mail,salary,did) values (#{eId},#{eName},#{eMail},#{salary},#{did})
    </insert>

4、基于XML的详细使用

POJO实体类

public class Emp{
    private Integer eId;
    private String eName;
    private String eMail;
    private Double salary;
    private Integer did;
}

public class Dept{
    private Integer did;
    private String dName;
}

1、参数的获取方式

#{} ==> sql = “SELECT * FROM emp WHERE eid = ?”
- a、会经过JDBC中的PreparedStatement对象进行预编译处理，会根据不同的数据类型来编译成对应数据库所对应的数据类型;
  例如：String id = “100010”，#{id} ==> sql = "SELECT * FROM emp WHERE eid = ‘100010’;
  例如：Integer id = 100010，#{id} ==> sql = "SELECT * FROM emp WHERE eid = 100010;
- b、能够有效的防止SQL注入;
${} ==> sql = “SELECT * FROM emp WHERE eid =” + id;
- a、不会进行预编译，会直接将获取到的的参数直接拼接在sql中;
- b、存在SQL注入的风险；
- 特殊用法：
  （1）调试时可以临时使用，这样可以直接将携带参数的完整sql语句打印在控制台；
  （2）需要动态拼接的时候，可以使用${}，但是要在保证数据的安全性的前提下操作;

2、参数的传递方式

单个参数的传递：

（1）参数类型是普通数据类型时：使用#{参数名称}来获取参数，即：#{id}；

  public interface EmpMapper {
      Emp selectEmpById(Integer id);
}

  <select id="selectEmpById"  resultMap="empResultSet">
      select * from emp where eid = #{id}
  </select>

（2）参数类型是javaBean时：使用#{属性名}来获取参数，emp.eId ==> #{eId}, emp.eName ==> #{eName}

  public interface EmpMapper {
	 Emp selectEmpInfo(Emp emp);
 }

 <select id="selectEmpInfo" resultType="org.example.pojo.Emp">
     select * from emp where eid = #{eId} and e_name = #{eName}
 </select>

（3）参数类型是数组或者list集合时：mybatis会自动封装成map
- 数组：{key:array,value:array}，获取方式：#{arg0.下标} 或者 #{array.下标}
- 集合：{key:list,value:list}，获取方式：#{arg0.下标} 或者 #{list.下标}
- 如果方法中使用了@Param()注解来指定别名，则获取方式为：#{别名.下标}
```
  public interface EmpMapper {
	List<Emp> selectEmpByNames(List<String> names);
 }
```
```
<select id="selectEmpByNames" resultType="org.example.pojo.Emp">
    select * from emp where e_name in (#{arg0.0}, #{list.1}, #{arg0.2})
</select>
```

（4）参数类型是map集合时：与javaBean的参数传递情况一样；

 public interface EmpMapper {
	Emp selectEmpByMap(Map<String,Object> paramMap);
}
 
 	Map<String, Object> paramMap = new HashMap<>();
        paramMap .put("id",1);
        paramMap .put("ename","lq");

 <select id="selectEmpByMap" resultType="org.example.pojo.Emp">
    select * from emp where eid = #{id} and e_name = #{ename}
 </select>

多个参数的传递

mybatis会对参数按顺序进行封装，将参数封装成map集合；
```
 public interface EmpMapper {
    Emp selectEmpByIdAndName( Integer id, String ename);
}
```
- id ==> {key : arg0，value : id的值} 或者 {key : param1，value : id的值}
- ename ==> {key : arg1，value : ename的值} 或者 {key : param2，value : ename的值}
- 可以使用#{key}来获取对应的值，
```
<select id="selectEmpByIdAndName" resultType="org.example.pojo.Emp">
    select * from emp where eid = #{arg0} and e_name = #{param2}
</select>
```

可以给每个参数设置别名，使其具有参数意义：

语法：使用注解：@Param("参数别名")

public interface EmpMapper {
	Emp selectEmpByIdAndName( @Param("id")Integer id, @Param("ename")String ename);
}

id ==> #{id} 或者 #{param1}
ename ==> #{ename} 或者 #{param2}
可以使用#{参数别名}来获取对应的值

 <select id="selectEmpByIdAndName" resultType="org.example.pojo.Emp">
    select * from emp where eid = #{id} and e_name = #{ename}
 </select>

如果是参数类型既有普通数据类型又有javaBean时：

public interface EmpMapper {
	Emp selectEmpInfoByDid(Integer did,@Param("emp") Emp emp);
}

id ==> #{param1} 或者 @Param(“did”)
emp.eName ==> #{param2.eName} 或者 emp.eName
注意：多个参数时，获取JavaBean中的属性时，使用#{参数别名.属性名}；

 <select id="selectEmpInfoByDid" resultType="org.example.pojo.Emp">
    select * from emp where did = #{param1} and e_name = #{emp.eName}
 </select>

3、处理返回结果

返回类型设置：
- 如果返回单行数据，可是使用Java基础数据类型或者POJO或者Map接收；
- 如果返回多行数据，可以使用List< POJO>或者List< Map >接收，需要在resultType中指定List中的泛型类型;

当返回结果是集合的时候，返回值的类型依然写的是集合中具体的类型

 <select id="selectAllEmp" resultType="org.example.pojo.Emp">
  		select * from emp
 </select>

在查询时可以设置返回值的类型为map，当mybatis查询完成之后会把列的名称作为key，列的值作为value，转换到map中；
```
<select id="selectEmpByEmpReturnMap" resultType="map">
	select * from emp where empno = #{empno}
</select>
```

4、自定义结果集

如果数据库表的字段与POJO的属性名不一致时，除了可使用'AS'来设置别名，还可以使用resultMap来设置自定义结果集，注意：resultType与resultMap二者只能使用其一。

相关属性：

id：唯一标识，需要与select标签中的resultMap进行关联；
type：需要映射的Pojo类型；
autoMapping：是否自动映射，默认为false，只要字段名与属性名遵循映射规则就可以自动映射；
extends：如果同一命名空间内，如果有多个resultMap有重复的映射，可以声明父resultMap，将公共的映射提取出来，可以减少子resultMap的映射冗余；

 <resultMap id="empResultSet" type="org.example.pojo.Emp">
    <!--
      <id>：用来指定主键字段的映射关系
      <result>：用来指定普通字段的映射关系
      column：需要映射的数据库表中字段的名称
      property：需要映射的POJO中的属性名称
    -->
      <id column="eid" property="eId"/>
      <result column="e_name" property="eName"/>
      <result column="e_mail" property="eMail"/>
      <result column="salary" property="salary"/>
      <result column="did" property="did"/>
 </resultMap>
 
  <select id="selectEmp" resultMap="empResultSet">
    select * from emp where did = #{dept_id}
  </select>

5、高级结果映射

1、联合查询

public class EmpDeptDto extends Emp{

    private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return super.toString() + "EmpDeptDto{" +
                "dept=" + dept +
                '}';
    }
}

1、多对一映射

查询所有员工的信息以及对应的部门（多员工同属一个部门）

<resultMap id="empAndDeptMap" extends="empResultSet" type="org.example.pojo.EmpDeptDto">
        <!--普通方式：对象属性名.属性-->
		<!--<result property="dept.dName" column="d_name"/>-->
		<!--<result property="dept.did" column="did"/>-->

        <!--association方式：
            会强行使我们的结果映射为多对一
            property：指定的“一”
            javaType：“一“的类型（自定义映射的时候才需要指定，与resultType二者使用其一）
            resultMap：调用已经存在的映射关系（重用resultMap）
            columnPrefix： 如果出现两张表的字段有重复时，则需要使用as来起别名，可以给字段加上前缀，在映射的时候，可以使用columnPrefix自动将前缀去掉，这样就能映射成功
        -->
        <association property="dept" columnPrefix="dept_" javaType="org.example.pojo.Dept" resultMap="org.example.mapper.DeptMapper.baseDeptMap">
		<!--<id property="did" column="did"/>-->
		<!--<result property="dName" column="d_name"/>-->
        </association>
 </resultMap>

 <select id="selectEmpAndDept" resultMap="empAndDeptMap">
        SELECT
        e.*,
        d.did AS dept_did,
        d.d_name AS dept_d_name
        FROM
        emp AS e
        LEFT JOIN dept AS d ON e.did = d.did
 </select>

2、一对多映射

查询部门信息以及所属的员工信息（一个部门包含多个员工）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.example.mapper.DeptMapper">

    <resultMap id="baseDeptMap" type="org.example.pojo.Dept">
        <id column="did" property="did"/>
        <result column="d_name" property="dName"/>
    </resultMap>

    <!--一对多映射关系
        property：指定的“多”
        ofType：“多”的类型（自定义映射的时候才需要指定，与resultType二者使用其一）
        resultMap：调用已经存在的映射关系（重用resultMap）
        无论是association还是collection，都需要查询主键值
    -->
    <resultMap id="deptAndEmpMap" extends="baseDeptMap" type="org.example.pojo.DeptEmpDto">
        <collection property="emps" ofType="org.example.pojo.Emp" resultMap="org.example.mapper.EmpMapper.empResultSet">
		        <!--也可以自定义映射关系-->
				<!--<id column="eid" property="eId"/>-->
				<!--<result column="e_name" property="eName"/>-->
				<!--<result column="e_mail" property="eMail"/>-->
				<!--<result column="salary" property="salary"/>-->
				<!--<result column="did" property="did"/>-->
        </collection>
  </resultMap>

    <select id="getDeptAndEmp" resultMap="deptAndEmpMap">
        SELECT
            d.*,
            e.*
        FROM dept d LEFT JOIN emp e
        ON d.did = e.did
    </select>
</mapper>

2、嵌套查询

<!--嵌套查询：分步查询
        select：查询关联对象的sql语句
        column：需要传递的参数值的字段
        fetchType：懒加载（延迟查询）：嵌套查询的对象用到的时候才回去查询数据-->
    <resultMap id="queryDeptAndEmpMap" type="org.example.pojo.DeptEmpDto" extends="baseDeptMap">
        <collection property="emps" fetchType="lazy" select="org.example.mapper.EmpMapper.selectEmp" column="did"/>
    </resultMap>

    <select id="queryDeptAndEmp" resultMap="queryDeptAndEmpMap">
        select * from dept
    </select>

3、延迟查询

当我们在进行表关联的时候，有可能在查询结果的时候不需要关联对象的属性值，那么此时可以通过延迟加载来实现功能。在全局配置文件中添加如下属性：

	<!‐‐ 开启延迟加载，所有分步查询都是懒加载 （默认是立即加载）‐‐>
		<setting name="lazyLoadingEnabled" value="true"/>
	<!‐‐当开启式， 使用pojo中任意属性都会加载延迟查询 ,默认是false
		<setting name="aggressiveLazyLoading" value="false"/>‐‐>
	<!‐‐设置对象的哪些方法调用会加载延迟查询 默认：equals,clone,hashCode,toString‐‐>
		<setting name="lazyLoadTriggerMethods" value=""/>

如果设置了全局加载，但是希望在某一个sql语句查询的时候不使用延时策略，可以添加fetchType下属性;

 <association property="dept" column="dept_id" fetchType="eager" resultMap="org.example.mapper.DeptMapper.baseDeptMap">
 </association>

6、动态SQL

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

如果出现SQL语句中因特殊字符报错的话，可以使用转义字符或者<![CDATA[]]>来解决

1、动态SQL之if

语法：< if test="条件表达式可以是OGNL表达式">< /if>
作用：完成简单的条件判断，加载动态条件

问题：如果无法确定第一个条件是否成立，导致无法确定是否拼接 and或者or 的拼接

（1）可以设置 1=1 避免报错
（2）可以使用< where>标签，它会自动拼接或者删除and或者or
（3）可以使用< trim>标签

	 <select id="queryEmps" resultType="org.example.pojo.Emp">
		 select * from emp where 1=1
		 <if test="salary != null and salary != ''">
		       AND salary <![CDATA[<=]]> #{salary}
		 </if>
		 <if test="eName != null and salary != ''">
		       AND e_name = #{eName}
		 </if>
		 <if test="eId != null and salary != ''">
		       AND eid = #{eId}
		 </if>	       
	 </select>

2、动态SQL之where

语法：< where>< /where>

作用：如果存在条件则自动拼接where关键字，也可以动态的删除条件语句中的and或者or

 	<select id="queryEmps" resultType="org.example.pojo.Emp">
		select * from emp 
		<where>
			<if test="salary != null and salary != ''">
				  AND salary <![CDATA[<=]]> #{salary}
			</if>
		    <if test="eName != null and salary != ''">
		          AND e_name = #{eName}
		    </if>
		    <if test="eId != null and salary != ''">
		          AND eid = #{eId}
		    </if>
	    </where>
  </select>

3、动态SQL之trim

语法：< trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">< /trim>
作用：它的功能比较灵活、广泛，可以在条件判断完的SQL语句前后添加或者去掉指定的字符
相关属性：
- prefix：前缀，需要添加的前缀
- prefixOverrides：需要去掉的前缀，例如：and|or
- suffix：后缀，需要添加的后缀
- suffixOverrides：需要去掉的后缀，例如：,

 	<select id="queryEmps" resultType="org.example.pojo.Emp">
		 select * from emp 
		<trim prefix="where" prefixOverrides="and|or" suffix="" suffixOverrides="">
            <if test="salary != null and salary != ''">
                  AND salary <![CDATA[<=]]> #{salary}
            </if>
            <if test="eName != null and salary != ''">
                  AND e_name = #{eName}
            </if>
            <if test="eId != null and salary != ''">
                  AND eid = #{eId}
            </if>
       </trim>
	</select>

4、动态SQL之choose、when、otherwise

作用：它有着类似于if、elseif、else的作用。

	<select id="queryEmps2" resultMap="empResultSet">
		select * from emp
        <where>
            <choose>
                <when test="eName == 'lv'">
                    eid = 1
                </when>
                <when test="eName == 'zlq'">
                    eid = 2
                </when>
                <otherwise>
                    eid = 3
                </otherwise>
            </choose>
        </where>
    </select>

5、动态SQL之set

作用：主要用于解决修改操作中SET关键字以及SQL语句中可能多出的逗号问题

	<update id="updateEmp">
        update emp
	        <set>
	            <if test="eName != null and eName != ''">
	                e_name = #{eName},
	            </if>
	            <if test="eMail != null and eMail != ''">
	                e_mail = #{eMail},
	            </if>
	            <if test="salary != null and salary != ''">
	                salary = #{salary},
	            </if>
	            <if test="did != null and did != ''">
	                did = #{did},
	           </if>
	        </set>
        	where eid = #{eId}
    </update>

6、动态SQL之foreach

作用：循环遍历集合或者数组

7、动态SQL之sql片段

作用：提取重复冗余的sql语句，使其可以被共用

8、常用的OGNL表达式

（1）e1 or e2：逻辑或
（2）e1 and e2：逻辑与
（3）e1 != e2 或者 e1 neq e2：判断两个对象是否不相等
（4）e1 == e2 或者 e1 eq e2：判断两个对象是否相等
（5）e1 > e2 或者 e1 gt e2：判断e1是否大于e2
（6）e1 >= e2 或者 e1 gte e2：判断e1是否大于等于e2
（7）e1 < e2 或者 e1 lt e2：判断e1是否小于e2
（8）e1 <= e2 或者 e1 lte e2：判断e1是否小于等于e2
（9）e1 instanceof e2：判断e1是否是e2的实例
（10）e1.method(e2)：调用e1对象的method方法，并将e2作为参数传递给method方
（11）e1 in e2：判断e1是否在e2中
（12）e1 not in e2：判断e1是否不在e2中（13）e1 like e2：判断e1是否和e2匹配
（13）e1 not like e2：判断e1是否和e2不匹配
（14）e1 between e2 and e3：判断e1是否在e2和e3之间
（15）e1 not between e2 and e3：判断e1是否不在e2和e3之间
（16）e1 is null：判断e1是否为null
（17）e1 is not null：判断e1是否不为null
（18）!e1：逻辑非
（19）e1+e2,e1-e2,e1*e2,e1/e2：加减乘除

7、缓存

MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。
在进行配置的时候还会分为一级缓存和二级缓存：
- 一级缓存：线程级别的缓存，是本地缓存，sqlSession级别的缓存；
- 二级缓存：全局范围的缓存，不仅局限于当前会话；

1、一级缓存

特性：
- 1、默认开启，也可以关闭一级缓存，localCacheScope=STATENENT
- 2、作用域默认是基于sqlSession的，就是一次数据库操作会话
- 3、缓存默认的实现类是：PerpetualCache，使用map进行存储，key ==> hashcode + sqlid + sql + hashcode + environment的id
- 4、查询完就会进行数据的缓存
失效情况：
- 1、不同的sqlSession会使一级缓存失效
- 2、同一个sqlSession，但是查询语句不同，也会使一级缓存失效
- 3、同一个sqlSession，查询语句相同，但在中间过程中执行了增删改操作，也会使一级缓存失效
- 4、同一个sqlSession，查询语句相同，执行手动清除缓存，会使一级缓存失效
例如：

2、二级缓存

特性：
- 1、默认开启，但没有实现
- 2、作用域，是全局范围的，存储到Java进程当中的，如果线程过多，会出现OOM
- 3、缓存默认的实现类也是PerpetualCache，使用map进行存储，但是，使用map存储的是二级缓存根据不同的mapper命名空间多包了一层的map。即：key：mapper的命名空间，value：Map<k,PerpetualCache.map>；
- 4、提交事务时或者sqlSession关闭的时候进行数据缓存
实现：
- 1、在全局配置文件中开启二级缓存，< setting name="cacheEnabled" value="true"/>
- 2、在需要用到二级缓存的mapper映射文件中加入，< cache>< /cache>，它是基于Mapper映射文件来实现存储的.
查询顺序：
- 先从二级缓存中获取，再从一级缓存中获取，如果都没有，则查询数据库
失效情况：
- 1、同一个命名空间下进行增删改操作，会使二级缓存失效
- 2、如果不想增删改操作后缓存被清空，则可以给对应的增删改sql设置flushCache="false"，但是设置要慎重，因为会造成数据脏读问题。
- 3、让查询到的数据不缓存到二级缓存中：设置useCache=“false” 即：<select id="getDeptById" useCache="false">
- 4、如果希望其他mapper映射文件的命名空间执行了增删改也清空另外的命名空间的缓存，可以在某个命名空间下使用：< cache-ref namespace=""/>
例如

8、分页插件

Mybatis通过提供插件机制，让我们可以根据自己的需要去增强Mybatis的功能。Mybatis的插件可以在不修改原来代码的情况下，通过拦截的方式，改变四大核心对象的行为，例如：处理参数、处理SQL、处理结果等等；
Mybatis的分页默认是基于内存分页的（查出所有，再截取），在数据量大的情况下效率较低，不过使用mybatis插件可以改变该行为，只需要拦截StatementHandler类的prepare方法，改变要执行的SQL语句为分页语句即可；

1、应用过程

1、添加依赖

 	<!--mybatis分页插件依赖-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.11</version>
       </dependency>

2、插件注册

在mybatis-config.xml配置文件中进行注册：

 	<plugins>
        <!--注册分页插件-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!--设置当前数据库的方言（默认会自动检查当前数据库环境实用的数据库）-->
            <property name="helperDialect" value="mysql"/>
            <!--自动合理化设置分页参数-->
            <property name="reasonable" value="true"/>
            <!--支持通过Mapper接口的参数来传递分页参数，默认值为false,分页参数名称为：pageNum、pageSize-->
            <property name="supportMethodsArguments" value="true"/>
        </plugin>
    </plugins>

3、调用

	<select id="queryEmpList" resultType="org.example.pojo.Emp">
        select * from emp
    </select>

 @Test
    public void testMybatis9(){
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        PageHelper.startPage(1,2);
        List<Emp> emps = mapper.queryEmpList();
        System.out.println(emps);
        //PageInfo对象中包含了很多分页相关的属性，例如，当前页，总页数，总记录数，是否有上/下一页等等
        PageInfo<Emp> pageInfo = new PageInfo<>(emps);
        pageInfo.getList().forEach(System.out::println);
        System.out.println(pageInfo.getTotal());
        System.out.println(Arrays.toString(pageInfo.getNavigatepageNums()));
    }

2、代理和拦截的实现

四大对象什么时候被代理
- Executor 是openSession()的时候创建的；
- StatementHandler 是SimpleExecutor.doQuery()创建的，里面包含了处理参数的ParameterHandler 和处理结果集的ResultSetHandler 的创建，创建之后即调用InterceptorChain.pluginAll()，返回层层代理后的对象。
- 代理是由Plugin 类创建。在我们重写的plugin() 方法里面可以直接调用returnPlugin.wrap(target, this);返回代理对象。
- 因为代理类是Plugin，所以最后调用的是Plugin 的invoke()方法。它先调用了定义的拦截器的intercept()方法。可以通过invocation.proceed()调用到被代理对象被拦截的方法。
调用流程时序图

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » 【01-02】Mybatis的配置文件与基于XML的使用

点赞(0) 打赏

本文分类：文章资讯
本文标签：【01-02】Mybatis的配置文件与基于XML的使用
浏览次数：46 次浏览
本文链接：https://freeymw.com/article/14993.html

上一篇 > 艺术家电gorenje x 设计上海丨用设计诠释“生活的艺术”
下一篇 > 优化Java中XML和JSON序列化

评论列表共有 0 条评论

暂无评论