本文详细介绍了Mybatis的优点，如半自动化持久层、sql与Java分离，以及如何通过xml映射、注解和动态SQL进行配置。重点讲解了自动映射、自定义resultMap、通过注解的SQL映射和MyBatis插件开发的实战应用，涵盖了分页、批量操作和Log4j配置等内容。
提示：
目录
Mybatis的优点：
• MyBatis是一个半自动化的持久化层框架。
• sql和java编码分开，功能边界清晰，一个专注业务、 一个专注数据。
- MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
• MyBatis可以使用简单的XML或注解用于配置和原 始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录.
sql映射文件
EmployeeMapper.xml：
接口式编程，namesapce直接和接口名相匹配。在这里面实现接口的抽象函数。通过id和函数名称相匹配。
Mapper ====> xxMapper.xml 代替传统编程的实现类。
一个mapper对应一个映射的接口。DAO的接口实现类由原来的Impl转变成一个Mapper配置文件。
在mybatis的全局配置文件中指定所用的数据库。
注意点：
- 接口和它的Mapper配置文件必须同名！
- 接口和它的Mapper配置文件必须在同一个包下!
常用要素：
- cache –命名空间的二级缓存配置
- cache-ref – 其他命名空间缓存配置的引用。
- resultMap – 自定义结果集映射
- parameterMap – 已废弃！老式风格的参数映射
- sql –抽取可重用语句块。
- insert – 映射插入语句
- update – 映射更新语句
- delete – 映射删除语句
- select – 映射查询语句
insert、update、delete的元素：
参数传递问题：
#{key}：获取参数的值，预编译到SQL中。 安全：建议使用
${key}：获取参数的值，拼接到SQL中。
select元素：
一些重要属性：
示范：
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapper">
<!--
namespace:名称空间;指定为接口的全类名
id：唯一标识：和接口中的函数名称相匹配
resultType：返回值类型
– 别名或者全类名，如果返回的是集合，是定义集合中元素的类型。不能和resultMap同时使用
#{id}：从传递过来的参数中取出id值
• parameterType：参数类型。
– 可以不传，MyBatis会根据TypeHandler自动推断
public Employee getEmpById(Integer id);
-->
<select id="getEmpById" resultType="com.atguigu.mybatis.bean.Employee" 【databaseId="mysql"数据库id可以省略】>
select id,last_name lastName,email,gender from tbl_employee where id = #{id}
</select>
<!--这个映射要求的是select后的变量名字（即：数据表中的名字）和resultType中类的数据成员名称一致。-->
</mapper>自动映射
法一：
- 全局setting设置
- 数据库字段命名规范，POJO属性符合驼峰命名法，如A_COLUMNàaColumn，我们可以开启自动驼峰命名规则映射功能，mapUnderscoreToCamelCase=true。
- 如果autoMappingBehavior设置为null则会取消自动映射
- autoMappingBehavior默认是PARTIAL（partial），开启自动映射的功能。唯一的要求是列名和javaBean属性名一致
参数类型处理：
普通类型：
<delete id="deleteUser" parameterType="int">
delete from mybatis.user where id = #{id}
</delete>Map类型： int addUser2(Map<String,Object> map);
<!--对象中的属性，可以直接取出来 传递map的key-->
<insert id="addUser2" parameterType="map">
insert into mybatis.user (id,pwd) values (#{userid},#{password})
</insert>
法二：自定义resultMap
resultMap（结果的一个形式，用于代替resultType），改变映射规则：类数据成员名称不用和数据表中列名字一致。多用于连接查询等查询结果无法和单个类进行对应的情况，column不做限制，可以为任意表的字段。
- id 和 result 映射一个单独列的值到简单数据类型(字符串,整型,双精度浮点数,日期等)的属性或字段
- association：对象属性映射（可以嵌套查查询，也可以分段查询（调用别的方法id，将列值作为参数传入，返回值是对应的java属性值））
- collection-集合属性的映射
- discriminator – 使用结果值来决定使用哪个结果映射
<!--column不做限制，可以为任意表的字段，而property须为type 定义的pojo属性-->
<resultMap id="唯一的标识" type="映射的pojo对象">
• id 和 result 映射一个单独列的值到简单数据类型(字符串,整型,双精度浮点数,日期等)的属性或字段
id和result的区别：id是主键，result是区其余类型的键。
<id column="表的主键字段，或者可以为查询语句中的别名字段" jdbcType="字段类型" property="映射pojo对象的主键属性" />
<result column="表的一个字段（可以为任意表的一个字段）" jdbcType="字段类型" property="映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）"/>
<association property="pojo的一个对象属性" javaType="pojo关联的pojo对象">
<id column="关联pojo对象对应表的主键字段" jdbcType="字段类型" property="关联pojo对象的主席属性"/>
<result column="任意表的字段" jdbcType="字段类型" property="关联pojo对象的属性"/>
</association>
<!-- 集合中的property须为oftype定义的pojo对象的属性-->
<collection property="pojo的集合属性" ofType="集合中的pojo对象">
<id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" />
<result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" />
</collection>
如果collection标签是使用嵌套查询，格式如下：
<collection column="传递给嵌套查询语句的字段参数" property="pojo对象中集合属性" ofType="集合属性中的pojo对象" select="嵌套的查询语句" >
</collection>
</resultMap><mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
<!--
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
did dept_name || eid last_name email gender
-->
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
<id column="did" property="id"/>
<!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
<result column="email" property="email"/>
<result column="dept_name" property="departmentName"/>
<!--
collection定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
-->
<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<!-- column： -->
<id column="eid" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</collection>
<!-- association可以指定联合的javaBean对象
property="dept"：指定哪个属性是联合的对象
javaType:指定这个属性对象的类型[不能省略]
-->
<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
</association>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id); 这里select里面要指定别名，进行映射 -->
<select id="getDeptByIdPlus" resultMap="MyDept">
SELECT d.id did,d.dept_name dept_name,
e.id eid,e.last_name last_name,e.email email,e.gender gender
FROM tbl_dept d
LEFT JOIN tbl_employee e
ON d.id=e.d_id
WHERE d.id=#{id}
</select>
<!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<!--column：数据表的列名， property：映射到结果集的字段-->
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy"></collection>
<!--column="{deptId=id}"代表使用deptID来映射查询语句中的id-->
<!--别的地方的：
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where d_id=#{deptId}
</select>
-->
<!-- association定义关联对象的封装规则
select:表明当前属性是调用select指定的方法查出的结果
column:指定将哪一列的值传给这个方法
流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
-->
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select id,dept_name from tbl_dept where id=#{id}
</select>
<!-- 扩展：多列的值传递过去：
将多列的值封装map传递；
column="{key1=column1,key2=column2}"
fetchType="lazy"：表示使用延迟加载；
- lazy：延迟
- eager：立即
-->
<!-- public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from tbl_employee where id=#{id}
<if test="_parameter!=null">
and 1=1
</if>
</select>
</mapper>- 主键相关：
插入一行元素，并获取主键，将其封装在keyProperty中，这里既是addEmp对象的返回值：Long类型。（mysql支持自动生成主键）
<!-- public Long addEmp(Employee employee); -->
<!-- parameterType：参数类型，可以省略，
获取自增主键的值：
mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
useGeneratedKeys="true"；使用自增主键获取主键值策略
keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
-->
<insert id="addEmp" parameterType="com.atguigu.mybatis.bean.Employee"
useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
insert into tbl_employee(last_name,email,gender)
values(#{lastName},#{email},#{gender})
</insert>//多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
@MapKey("lastName")
public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
- discriminator鉴别器：
判断某一列的值，然后改变封装行为。
<!-- <discriminator javaType=""></discriminator>
鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
封装Employee：
如果查出的是女生：就把部门信息查询出来，否则不查询；
如果是男生，把last_name这一列的值赋值给email;
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!--
column：指定判定的列名
javaType：列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!--女生 resultType:指定封装的结果类型；不能缺少。/resultMap-->
<case value="0" resultType="com.atguigu.mybatis.bean.Employee">
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</case>
<!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
<case value="1" resultType="com.atguigu.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="last_name" property="email"/>
<result column="gender" property="gender"/>
</case>
</discriminator>
</resultMap>通过注解进行sql映射：
需要将接口注册进全局配置文件中，之后获取的时候自动生成接口的代理类来获取。
public interface EmployeeMapperAnnotation {
@Select("select * from tbl_employee where id=#{id}")//id默认是什么-》默认还是方法名
public Employee getEmpById(Integer id);
}动态SQL
基于OGNL的表达式：
- if
- choose (when, otherwise)
- trim (where, set)
- foreach（常是在构建 IN 条件语句的时候）
- if:判断-if-where组合
这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个AND 或OR 。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
<!-- 查询员工，要求，携带了哪个字段查询条件就带上这个字段的值 -->
<!-- public List<Employee> getEmpsByConditionIf(Employee employee); -->
<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- where -->
<where>
<!-- test：判断表达式（OGNL）
OGNL参照PPT或者官方文档。
c:if test
从参数中取值进行判断
遇见特殊符号应该去写转义字符：
&&：
-->
<if test="id!=null">
id=#{id}
</if>
<if test="email!=null and email.trim()!=""">
and email=#{email}
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
and gender=#{gender}
</if>
</where>
</select>
- if-trim组合
trim标记是一个格式化的标记，可以完成set或者是where标记的功能。
prefix="":前缀：trim标签体中是整个字符串拼串后的结果。
prefix给拼串后的整个字符串加一个前缀
prefixOverrides="":
前缀覆盖： 去掉整个字符串前面多余的字符
suffix="":后缀
suffix给拼串后的整个字符串加一个后缀
suffixOverrides=""
后缀覆盖：去掉整个字符串后面多余的字符
<!--public List<Employee> getEmpsByConditionTrim(Employee employee); -->
<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- 后面多出的and或者or where标签不能解决
prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
prefix给拼串后的整个字符串加一个前缀
prefixOverrides="":
前缀覆盖： 去掉整个字符串前面多余的字符
suffix="":后缀
suffix给拼串后的整个字符串加一个后缀
suffixOverrides=""
后缀覆盖：去掉整个字符串后面多余的字符
-->
<!-- 自定义字符串的截取规则 -->
<trim prefix="where" suffixOverrides="and">
<if test="id!=null">
id=#{id} and
</if>
<if test="lastName!=null && lastName!=""">
last_name like #{lastName} and
</if>
<if test="email!=null and email.trim()!=""">
email=#{email} and
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
gender=#{gender}
</if>
</trim>
</select>- if-set组合
用于update
<!--public void updateEmp(Employee employee); -->
<update id="updateEmp">
<!-- Set标签的使用 -->
update tbl_employee
<set>
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</set>
where id=#{id}
<!--
Trim：更新拼串
update tbl_employee
<trim prefix="set" suffixOverrides=",">
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</trim>
where id=#{id} -->
</update>
- choose (when, otherwise):分支选择；带了break的swtich-case
<!-- public List<Employee> getEmpsByConditionChoose(Employee employee); -->
<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<where>
<!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
<choose>
<when test="id!=null">
id=#{id}
</when>
<when test="lastName!=null">
last_name like #{lastName}
</when>
<when test="email!=null">
email = #{email}
</when>
<otherwise>
gender = 0
</otherwise>
</choose>
</where>
</select>- •foreach 遍历集合
当形参是集合类型的时候使用。
<!--public List<Employee> getEmpsByConditionForeach(List<Integer> ids); -->
<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!--
collection：指定要遍历的集合：
list类型的参数会特殊处理封装在map中，map的key就叫list
item：将当前遍历出的元素赋值给指定的变量
separator:每个元素之间的分隔符
open：遍历出所有结果拼接一个开始的字符
close:遍历出所有结果拼接一个结束的字符
index:索引。遍历list的时候是index就是索引，item就是当前值
遍历map的时候index表示的就是map的key，item就是map的值
#{变量名}就能取出变量的值也就是当前遍历出的元素
-->
<foreach collection="ids" item="item_id" separator=","
open="where id in(" close=")">
#{item_id}
</foreach>
</select>可以实现批量保存，批量删除，批量修改。
以及抽取可重用的sql语句：
bind以及_parameter参数：bind 元素可以从 OGNL 表达式中创建一个变量并将其绑定到上下文
<!-- 批量保存 -->
<!--public void addEmps(@Param("emps")List<Employee> emps); -->
<!--MySQL下批量保存：可以foreach遍历 mysql支持values(),(),()语法-->
<insert id="addEmps">
insert into tbl_employee(
<include refid="insertColumn"></include>
)
values
<foreach collection="emps" item="emp" separator=",">
(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
</foreach>
</insert><!-- -->
<!--
抽取可重用的sql片段。方便后面引用
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
include-property：取值的正确方式${prop},
#{不能使用这种方式}
-->
<sql id="insertColumn">
<if test="_databaseId=='oracle'">
employee_id,last_name,email
</if>
<if test="_databaseId=='mysql'">
last_name,email,gender,d_id
</if>
</sql><!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
单个参数：_parameter就是这个参数
多个参数：参数会被封装为一个map；_parameter就是代表这个map
_databaseId:如果配置了databaseIdProvider标签。
_databaseId就是代表当前数据库的别名oracle
-->
<!--public List<Employee> getEmpsTestInnerParameter(Employee employee); -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- bind：可以将OGNL表达式（一种表达式语言）的值绑定到一个变量中，方便后来引用这个变量的值 -->
<bind name="_lastName" value="'%'+lastName+'%'"/>
<if test="_databaseId=='mysql'">
select * from tbl_employee
<if test="_parameter!=null">
where last_name like #{lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employees
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>注解开发的使用：
- 注解在UserMapper接口上实现，并删除UserMapper.xml文件
@Select("select * from user")
List<User> getUsers();
//方法存在多个参数，所有参数前面必须加上@Param("id")注解
@Select("select * from user where id=#{id}")
User getUserById(@Param("id") int id);
@Insert("insert into user (id,name,pwd) values(#{id},#{name},#{password})")
int addUser(User user);
@Update("update user set name=#{name},pwd=#{password} where id=#{id}")
int updateUser(User user);
@Delete("delete from user where id = #{uid}")
int deleteUser(@Param("uid") int id);
- 需要在mybatis-config.xml核心配置文件中绑定接口 <!--绑定接口！-->
<!--绑定接口！--> <mappers> <mapper class="com.kuang.dao.UserMapper" /> </mappers>
使用：
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.getUsers();本质：反射机制实现
底层：动态代理！（对接口产生代理对象）
全局配置文件：
1、数据库的配置以及事务管理器信息。
2、给类起别名（默认类名小写），也可以使用@Alias注解为某个类型指定新的别名。
3、系统运行环境信息。
4、把所有sql映射文件汇总进来，一个mapper注册一个sql映射，也可以通过mappers实现批量注册。
configuration 配置信息：
• properties 属性
• settings 设置
是否开启二级缓存、懒加载等
• typeAliases 类型命名
• typeHandlers 类型处理器
无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。也可以自定义类型处理器在这里注册。
• objectFactory 对象工厂
• plugins 插件
插件通过动态代理机制，可以介入四大对象（Executor、ParameterHandler、ResultSetHandler、StatementHandler ）的任何一个方法的执行。
• environments 环境
• environment 环境变量
实际开发中我们使用Spring管理数据源，并进行事务控制的配置来覆盖上述配置
• transactionManager 事务管理器
• dataSource 数据源
• databaseIdProvider 数据库厂商标识
- mappers 映射器
mappers注册接口方法：
1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下。（每一个接口都要单独写一个映射文件。）<mappers> <mapper resource="com/kuang/dao/UserMapper.xml"/> </mappers>
2、没有sql映射文件，所有的sql都是利用注解写在接口上。->利用注解实现映射的，也要进行全局注册。<mappers> <mapper class="com.kuang.dao.UserMapper"/> </mappers>
3、使用扫描包进行注入绑定（包里面的所有接口都绑定）<mappers> <package name="com.kuang.dao"/> </mappers>
注册接口和注册配置文件，只要一个就行。
<configuration>
<!--
1、mybatis可以使用properties来引入外部properties配置文件的内容；
resource：引入类路径下的资源
url：引入网络路径或者磁盘路径下的资源
-->
<properties resource="dbconfig.properties"></properties>
<!--
transactionManager：事务管理器；
type：事务管理器的类型;JDBC(JdbcTransactionFactory)|MANAGED(ManagedTransactionFactory)
自定义事务管理器：实现TransactionFactory接口.type指定为全类名
dataSource：数据源;
type:数据源类型;UNPOOLED(UnpooledDataSourceFactory)
|POOLED(PooledDataSourceFactory)
|JNDI(JndiDataSourceFactory)
自定义数据源：实现DataSourceFactory接口，type是全类名
-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />【事务管理器】
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
<property name="username" value="root" />
<property name="password" value="123456" />
</dataSource>
</environment>
</environments>
<!-- 3、typeAliases：别名处理器：可以为我们的java类型起别名
别名不区分大小写
-->
<typeAliases>
<!-- 1、typeAlias:为某个java类型起别名
type:指定要起别名的类型全类名;默认别名就是类名小写；employee
alias:指定新的别名
-->
<!-- <typeAlias type="com.atguigu.mybatis.bean.Employee" alias="emp"/> -->
<!-- 2、package:为某个包下的所有类批量起别名
name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写），）
-->
<package name="com.atguigu.mybatis.bean"/>
<!-- 3、批量起别名的情况下，使用@Alias注解为某个类型指定新的别名 -->
</typeAliases>
<!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
<mappers>
<!--
mapper:注册一个sql映射
注册配置文件
resource：引用类路径下的sql映射文件
mybatis/mapper/EmployeeMapper.xml
url：引用网路路径或者磁盘路径下的sql映射文件
file:///var/mappers/AuthorMapper.xml
注册接口
class：引用（注册）接口，
1、有sql映射文件，映射文件名必须和接口同名，并且放在与接口同一目录下；
2、没有sql映射文件，所有的sql都是利用注解写在接口上;
推荐：
比较重要的，复杂的Dao接口我们来写sql映射文件
不重要，简单的Dao接口为了开发快速可以使用注解；
-->
<!-- <mapper resource="mybatis/mapper/EmployeeMapper.xml"/> -->
<!-- <mapper class="com.atguigu.mybatis.dao.EmployeeMapperAnnotation"/> --><!--注解也要注册！-->
<!-- 批量注册：这种方式要求SQL映射文件名必须和接口名相同并且在同一目录下 -->
<package name="com.atguigu.mybatis.dao"/>
<mappers/>
</configuration>缓存
参考： 你真的会用Mybatis的缓存么，不知道原理的话，容易踩坑哦 - 简书
- MappedStatement: 代表要发往数据库执行的指令，可以理解为是Sql的抽象表示。
- Executor: 具体用来和数据库交互的执行器，接受MappedStatement作为参数。
在Mybatis初始化的时候，每一个语句都会使用对应的MappedStatement代表，使用namespace（mapper中的namespace：即一个接口对应一个namespace）+语句本身的id来代表这个语句。如下代码所示，使用mapper.StudentMapper.getStudentById代表其对应的Sql。
SELECT id,name,age FROM student WHERE id = #{id}在Mybatis执行时，会进入对应接口的方法，通过类名加上方法名的组合生成id，找到需要的MappedStatement，交给执行器使用。
实际上适用于缓存的数据：经常查询并且不经常改变的，并且的数据的正确与否对最终结果影响不大的、不适用于缓存的数据：经常改变的数据，数据的正确与否对最终结果影响很大的。
注：通过全局配置文件->构建SqlSessionFactory->建立一个 SqlSession，之后通过 SqlSession的方法id来调用。
一级缓存是SqlSession级别的缓存，一级缓存缓存的是对象，当SqlSession提交、关闭、qing以及其他的更新、删除、增加的操作发生后，一级缓存就会清空（默认的）。该区域的结构是一个Map。
每一个SqlSession中都持有了自己的缓存，一种是SESSION级别，即在一个Mybatis会话中执行的所有语句，都会共享这一个缓存。一种是STATEMENT级别，可以理解为缓存只对当前执行的这一个statement有效。
一级缓存默认开启。
原理：
每一个SqlSession中持有了自己的Executor，每一个Executor中有一个Local Cache。当用户发起查询时，Mybatis会根据当前执行的MappedStatement生成一个key，去Local Cache中查询，如果缓存命中的话，返回。如果缓存没有命中的话，则写入Local Cache，最后返回结果给用户
配置：
<setting name="localCacheScope" value="SESSION"/>步骤：
- 对于某个Select Statement，根据该Statement生成key（key:hashCode+查询的SqlId+编写的sql查询语句+参数）。
- 判断在Local Cache中,该key是否用对应的数据存在。
- 如果命中，则跳过查询数据库，继续往下走。
- 如果没命中：
去数据库中查询数据，得到查询结果；
将key和查询到的结果作为key和value，放入Local Cache中。
将查询结果返回；- 判断缓存级别是否为STATEMENT级别，如果是的话，清空本地缓存。
问题：
Mybatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下（两个表有关联，一个session中操作一个相关的表，另一个session查询这个表，就会有问题），有操作数据库写的话，会引起脏数据，建议是把一级缓存的默认级别设定Statement，即不使用一级缓存。
- 一级缓存失效的四种情况
- 1、不同的SqlSession对应不同的一级缓存
- 2、同一个SqlSession但是查询条件不同
- 3、同一个SqlSession两次查询期间执行了任何一次增
删改操作（）
- 4、同一个SqlSession两次查询期间手动清空了缓存
二级缓存是SqlSessionFactory级别的缓存，同一个SqlSessionFactory产生的SqlSession都共享一个二级缓存，二级缓存中存储的是数据，当命中二级缓存时，通过存储的数据构造对象返回。
（全局缓存）：基于namespace级别的缓存：一个namespace对应一个二级缓存：同一个命名空间(namespace) 所有的操作语句，都影响着一个共同的 cache，也就是二级缓存被多个 SqlSession 共享，是一个全局的变量。
查询数据的时候，查询的流程是二级缓存>一级缓存>数据库。
其中缓存的是数据而不是对象，所以从二级缓存再次查询出得结果的对象与第一次存入的对象是不一样的。
二级缓存：1. 采用 mybatis 内置的 cache 机制；2. 采用三方 cache 框架， 比如ehcache, oscache 等等.
工作机制： * 1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中； * 2、如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容； * 3、sqlSession===EmployeeMapper==>Employee * DepartmentMapper===>Department * 不同namespace查出的数据会放在自己对应的缓存中（map） * 效果：数据会从二级缓存中获取 * 查出的数据都会被默认先放在一级缓存中。 * 只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中二级缓存开启步骤：
1）让Mybatis框架支持二级缓存（在Mybatis的主配置文件中配置）
<setting name="cacheEnabled" value="true"/>2）让当前的映射文件支持二级缓存（在Dao.xml映射文件中配置）
在Mybatis的映射XML中配置cache或者 cache-ref 。
<cache/>cache标签用于声明这个namespace使用二级缓存，并且可以自定义配置。
- type: cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过。
- eviction: 定义回收的策略，常见的有FIFO，LRU。
- flushInterval: 配置一定时间自动刷新缓存，单位是毫秒
- size: 最多缓存对象的个数
- readOnly: 是否只读，若配置可读写，则需要对应的实体类能够序列化。
- blocking: 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。
<cache-ref namespace="mapper.StudentMapper"/>cache-ref代表引用别的命名空间的Cache配置，两个命名空间的操作使用的是同一个Cache（是指本地吗）？
3）让当前的方法支持二级缓存（在标签中配置）
<select id="findById" resultType="com.example.domain.User" parameterType="INT" useCache="true"> SELECT * FROM USER WHERE ID = #{ID} </select>4）我们的POJO需要实现序列化接口
- 当sqlsession没有调用commit()方法时，二级缓存并没有起到作用，（sqlsession要commit的时候才会影响到全局缓存，否则只影响一级本地缓存）.
- update操作提交后，会刷新该namespace下的二级缓存（不是所有的二级缓存）。（namespace相同的会操作查询共同的cache）
eg：
DeptDao dao = sqlSession.getMapper(DeptDao.class); Dept dept = dao.findByDeptNo(1); System.out.println("第一次查询得到部门对象 = "+dept); //触发MyBatis框架从当前一级缓存中将Dept对象保存到二级缓存 sqlSession.commit(); // 改成 sqlSession.close(); 效果相同 SqlSession session2 = factory.openSession(); DeptDao dao2 = session2.getMapper(DeptDao.class); Dept dept2 = dao2.findByDeptNo(1); System.out.println("第二次查询得到部门对象 = "+dept2);
- 多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行了修改，引发脏数据问题。->解决：
- Cache ref，让ClassMapper引用StudenMapper命名空间，这样两个映射文件对应的Sql操作都使用的是同一块缓存了（一级缓存？）->后果：缓存的粒度变粗了，多个Mapper namespace下的所有操作都会对缓存使用造成影响，其实这个缓存存在的意义已经不大了
eg：
// 第一个mapper 先执行联查操作 ，没有提交，影响一级缓存。 SqlSession sqlSession = factory.openSession(); DeptDao deptDao = sqlSession.getMapper(DeptDao.class); DeptVo deptVo = deptDao.selectByDeptVo("ali"); System.out.println("deptVo = " + deptVo); // 第二个mapper 执行更新操作 并提交，影响二级缓存。 SqlSession sqlSession2 = factory.openSession(); DeptDao deptDao2 = sqlSession2.getMapper(DeptDao.class); deptDao2.updateDeptVoNum(new DeptVo("ali",1000)); sqlSession2.commit(); sqlSession2.close(); // 第一个mapper 再次进行查询,观察查询结果。二级缓存查不到，去一级缓存查，会得到错误结果，脏读 deptVo = deptDao.selectByDeptVo("ali"); System.out.println("deptVo = " + deptVo);//存放在共享缓存中数据进行序列化操作和反序列化操作 //因此数据对应实体类必须实现【序列化接口】
* 和缓存有关的设置/属性： * 1）、cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的) * 2）、每个select标签都有useCache="true"： * false：不使用缓存（一级缓存依然使用，二级缓存不使用） * 3）、【每个增删改标签的：flushCache="true"：（一级二级都会清除）】 * 增删改执行完成后就会清楚缓存； * 测试：flushCache="true"：一级缓存就清空了；二级也会被清除； * 查询标签：flushCache="false"： * 如果flushCache=true;每次查询之后都会清空缓存；缓存是没有被使用的； * 4）、sqlSession.clearCache();只是清楚当前session的一级缓存； * 5）、localCacheScope：本地缓存作用域：（一级缓存SESSION）；当前会话的所有数据保存在会话缓存中； * STATEMENT：可以禁用一级缓存；
*第三方缓存整合： * 1）、导入第三方缓存包即可； * 2）、导入与第三方缓存整合的适配包；官方有； * 3）、mapper.xml中使用自定义缓存 * <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>
采用 mybatis 内置的 cache 机制。
在 sql 语句映射文件中加入 <cache /> 语句 , 并且相应的 model 类要实现 java Serializable 接口，因为缓存说白了就是序列化与反序列化的过程，所以需要实现这个接口. 单纯的 <cache /> 表示如下意思:
cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache> <!-- <cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024"></cache> --> <!-- eviction:缓存的回收策略： • LRU – 最近最少使用的：移除最长时间不被使用的对象。 • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。 • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。 • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。 • 默认的是 LRU。 flushInterval：缓存刷新间隔 缓存多长时间清空一次，默认不清空，设置一个毫秒值 readOnly:是否只读： true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。 mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快 false：非只读：mybatis觉得获取的数据可能会被修改。 mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢 size：缓存存放多少元素； type=""：指定自定义缓存的全类名； 实现Cache接口即可；-->
测试文件：
SqlSession代表和数据库的一次会话；用完必须关闭； SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。 mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。（将接口和xml进行绑定）两种调用接口函数的方法： 1、通过获取的SqlSession对象.“id”()调用具体的实现方法。 2、通过getMapper()获取sql映射文件创建的接口代理对象来调用。* 1、mybatis允许增删改直接定义以下类型返回值。 ？？？在语句里面定义返回值吗 delete这些语句好像也没有返回值的定义？ * Integer、Long、Boolean、void * 2、我们需要手动提交数据 * sqlSessionFactory.openSession();===》手动提交 commit * sqlSessionFactory.openSession(true);===》自动提交
步骤：
通过全局配置文件->构建SqlSessionFactory->建立一个 SqlSession
//调用方法一：通过获取的SqlSession对象.“id”调用具体的实现方法。
//调用方法二：通过获取sql映射文件创建的接口代理对象，代理对象.方法 调用
//方法三：根据openSession类中定义好的函数实现。
String resource = "mybatis-config.xml";//全局的配置文件->之后在全局配置文件中配置过的sql映射文件中的id都可以使用
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession openSession = sqlSessionFactory.openSession();
//调用方法一：通过获取的SqlSession对象.“id”调用具体的实现方法。
try {
Employee employee = openSession.selectOne(
"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
System.out.println(employee);
} finally {
openSession.close();
}
//调用方法二：通过获取sql映射文件创建的接口代理对象来调用。
try {
// 3、获取接口的实现类对象
//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);【xml映射中的接口.class】
EmployeeMapperAnnotation mapper = openSession.getMapper(EmployeeMapperAnnotation.class);【注解形式进行映射的接口.class】
Employee employee = mapper.getEmpById(1);//代理对象的方法的实现，还是在mapper文件。
System.out.println(mapper.getClass());
System.out.println(employee);
} finally {
openSession.close();
}
//方法三：根据openSession类中定义好的函数实现。
try {
Employee employee = openSession.selectOne(//openSession里面自定义了一些函数，包括：selectOne
"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
System.out.println(employee);
} finally {
openSession.close();
}Mybatis原理
生命周期：
SqlSessionFactoryBuilder：
- 一旦创建了 SqlSessionFactory，就不再需要它了。
- 局部变量
SqlSessionFactory：
- SqlSessionFactory 的最佳作用域是应用作用域。
- 最简单的就是使用单例模式或者静态单例模式。
SqlSession：
- 连接到连接池的一个请求！
- SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
- 用完后需要赶紧关闭，否则资源被占用！
MyBatis-插件开发
- MyBatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。
- 默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
- Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
- ParameterHandler (getParameterObject, setParameters)
- ResultSetHandler (handleResultSets, handleOutputParameters)
- StatementHandler (prepare, parameterize, batch, update, query)
插件开发步骤：
1）编写插件实现Interceptor接口，并使用@Intercepts注解完成插件签名
2）在全局配置文件中注册插件
插件原理：
1）、按照插件注解声明，按照插件配置顺序调用插件plugin方法，生成被拦截对象的动态代理
- 2）、多个插件依次生成目标对象的代理对象，层层包裹，先声 明的先包裹；形成代理
- 3）、目标方法执行时依次从外到内执行插件的intercept方法。
Interceptor接口：
-
- Intercept（）：拦截目标方法执行
- plugin（）：生成动态代理对象，可以使用MyBatis提 供的Plugin类的wrap方法
- setProperties（）：注入插件配置时设置的属性
MyBatis实用场景
提供PageHelper插件进行分页
（在全局配置文件中引入插件即可使用）
批量操作
批量操作我们是使用MyBatis提供的BatchExecutor进行的， 他的底层就是通过jdbc攒sql的方式进行的。我们可以让他攒够一定数量后发给数据库一次。
SqlSession openSession = build.openSession(ExecutorType.BATCH);
默认：sqlSessionFactory.openSession(true);//自动提交事务
openSession.commit();//提交之后执行
openSession.close();
sqlSession.flushStatements() //让其直接冲刷到数据库进行执行，不必等到提交
Log4j配置
log4j.properties文件中配置日志的输出级别、日志的输出路径；
mybatis-config.xml核心配置文件中setting中加入：
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
使用：
Logger logger = Logger.getLogger(UserDaoTest.class);
logger.info("info:进入了testLog4j");
扫一扫
9952
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
