MyBatis详解

最新推荐文章于 2024-08-12 23:31:59 发布

paterl

最新推荐文章于 2024-08-12 23:31:59 发布

阅读量857

点赞数 1

分类专栏： Java 文章标签： mybatis java spring sql

本文链接：https://blog.csdn.net/paterl/article/details/127828593

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

MyBaties

介绍

MyBatis是一个支持普通SQL查询、存储过程以及高级映射的持久层框架，它消除了几乎所有的JDBC代码和参数的手动设置以及对结果集的检索，使用简单的XML或注解进行配置和原始映射，将接口和Java的POJO映射成数据库中的记录，使得Java开发人员可以使用面向对象的编程思想来操作数据库。

ORM框架工作原理

MyBatis框架是一个ORM (Object/Relation Mapping,即对象关系映射)框架。所谓的ORM就是一种为了解决面向对象与关系型数据库中据类型不匹配的技术，它通过描述Java对象与数据库表之间的映射关系，自动将Java应用程序中的对象持久化到关系型数据库的表中。ORM框架的工作原理可以通过一-张图来展示。

请添加图片描述

Mybatis下载

下载网址：https://github.com/mybatis/mybatis-3

创建Mybatis的核心文件

习惯上命名为mybatis-config.xml,这个文件名仅仅只是建议,并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家作时可以直接复制、粘贴。

核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息
核心配置文件存放的位置是src/main/resources目录下

<?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>
<!--    配置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
<!--            数据原-->
            <dataSource type="POOLED">
<!--                驱动类-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<!--                链接数据库的地址-->
                <property name="url" value="jdbc:mysql://localhost:3306/SSM?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="ljh011215"/>
            </dataSource>
        </environment>
    </environments>
<!--    引入mybatis的映射文件-->
    <mappers>
        <mapper resource=""/>
    </mappers>
</configuration>

创建mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于, mapper仅仅是接口，我们不需要提供实现类。

创建mybatis的映射文件

相关概念: ORM (Object Relationship Mapping)对象关系映射。
●对象:Java的实体类对象
●关系:关系型数据库上
●映射:二者之间的对应关系
请添加图片描述

1、映射文件的命名规则:
表所对应的实体类的类名+Mapper.xml
例如:表t _user, 映射的实体类为User,所对应的映射文件为UserMapper.xml
因此一个映射文件对应一个实体类, 对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据
MyBatis映射文件存放的位置是src/main/resources/mappers目录下
2、MyBatis中可以面向接口操作数据，要保证两个一致:
a>mapper接口的全类名和映射文件的命名空间(namespace) 保持-致
b>mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

resultType:设置结果类型，即查询的数据要转换为的java类型
resultMap:自定义映射，处理多对- -或一对多的映射关系

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>
    mybatis的核心配置文件中的标签必须按照指定的顺序配置：
	properties?,settings?,typeAliases?,typeHandlers?,
    objectFactory?,objectWrapperFactory?,reflectorFactory?,
    plugins?,environments?,databaseIdProvider?,mappers
    
    
    typeAliases：设置类型别名，即为某个具体的类型设置一个别名
    在mybatis的范围中，就可以使用别名表示一个具体的类型
    <typeAliases>
        type：设置需要起别名的类型
        alias：设置某个类型的别名，可省略
    <typeAlias type="" alias=""></typeAlias>
</typeAliases>

<!--    配置连接数据库的环境-->default指当前要使用的环境
    <environments default="development">
    environment中的id属性是唯一的不能重复
        <environment id="development">
        事务管理器 
            type属性，设置事务管理的方式
            type=“JDBC/MANAGED”
            JDBC：表示使用JDBC原生的事务管理方式
            MANAGED：被管理
            <transactionManager type="JDBC"/>
<!--            数据原-->
            type：设置数据源的类型
            type：“POOLED/UNPOOLED/JNDI”
            POOLEED：使用数据库连接池
            UNPOOLED：不使用数据库连接池
            JNDI：使用上下文中的数据源
            <dataSource type="POOLED">
<!--                驱动类-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<!--                链接数据库的地址-->
                <property name="url" value="jdbc:mysql://localhost:3306/SSM?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="ljh011215"/>
            </dataSource>
        </environment>
    </environments>
   <!--    引入mybatis的映射文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
<!--        以包的方式来引入映射文件，但是必须满足两个条件：
            1、mapper接口和映射文件所在的包必须一致
            2、mapper接口的名字和映射文件的名字必须一致
-->
<!--        <package name="com.mybatis.mapper"/>-->
    </mappers>
</configuration>

MyBatis获取参数值的两种方式

MyBatis获取参数的两种方式${}和#{}

${的本质就是字符串拼接，#{}的本质就是占位符赋值
${使用字符串拼接的方式拼接sql,若为字符串类型或日期类型的字段进行赋值时，需要手动加单引
号;但是#{}使用占位符赋值的方式拼接sq|,此时为字符串类型或日期类型的字段进行赋值时，可以自
动添加单引号.

单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型
此时可以使用 $KaTeX parse error: Expected 'EOF', got '#' at position 4: {}和#̲{以任意的名称获取参数的值，注\dots$ {}需要手动加单引号

多个字面量类型的参数

此时MyBatis会将参数放在map集合中，以两种方式存储数据
a>以arg0, arg1…为键，以参数为值
b>以Xparam1, param2…为键，以参数为值

因此，只需要通过#{}和${}访问map集合的键，就可以获取相对应的值

一定要注意${}的单引号问题

参数为map集合类型的参数

只需要通过#{}获取${}访问map集合的键，就可以获得相对应的值，

一定要注意${}的单引号问题

参数为实体类类型的参数

只需要通过#{}或${}访问实体类中的属性名，就可以获取相对应的属性值

一定要注意${}的单引号问题

使用@Param注解设置参数

此时MyBatis会将这些参数放在map中，以两种方式进行存储
a>以@Param注解的value属性值为键，以参数为值
b>以param1, param2…为键，以必参数为值
只需要通过#{}和 ${}访问map集合的键，就可以获取相对应的值,- -定要注意$ {}的单引号问题

MyBatis的各种查询功能

查询一个实体类对象

若sql语句查询的结果为多条时，一定不能以实体类类型作为方法的返回值
否则会抛出异常TooManyResul tsException

若sql语句查询的结果为1条时，此时可以使用实体类类型或list集合类型作为方法的返回值

查询所有的用户信息为map集合

若查询的数据有多条时，并且要将每条数据转换为map集合

此时有两种解决方案:

1、将mapper接口方法的返回值设置为泛型是map的list集合

list<Map<string, object>> getAllUserToMab();

2、可以将每条数据转换的map集合放在一个大的map中，但是必须要通过@MapKey注解
将查询的某个字段的值作为大的map的键

特殊SQL的执行

模糊查询

select * from t_user where username like "%"#{mohu}"%"
select * from t_user where username like concat('%',#{mohu},'%')

批量删除

delete from t_user where id in(${id})

in里面只能使用${}

动态设置表名

select * from ${tableName}

动态设置表名的时候只能使用${}来取变量，

使用#{}会在表名上加上单引号，导致报错

添加功能获取自增的主键

请添加图片描述

自定义映射resultMap

字段名和属性名不一致的情况，如何处理映射关系
1.为查询的字段设置别名，和属性名保持一致

2、当字段符合MySQL的要求使用，而属性符合java的要求使用驼峰
此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰

    <settings>
<!--        自动将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

3.使用resultMap自定义映射处理

<!--    resultMap自定义映射-->
    <resultMap id="empresultMap" type="Emp">
<!--        里面处理字段与属性之间的关系-->
<!--        id处理主键和属性的映射关系-->
<!--        column:设置映射关系中的字段名，必须是sql查询出的字段-->
<!--        empName：设置映射关系中的属性的属性名，必须是处理的实体类类型中的属性名-->
        <id column="emp_id" property="empId"></id>
<!--        result处理普通字段与属性的映射关系-->
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
    </resultMap>
    <select id="getEmpByEmpId" resultMap="empresultMap">
        select * from t_emp where emp_id = #{id}
    </select>

处理多对一的映射关系

1、级联方式

<!--    type处理的是与查询出来的结果映射不了的数据-->
    <resultMap id="empAndDeptResultMap" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
<!--        把查出来的字段与实体类中的属性进行映射-->
        <result column="dept_id" property="dept.deptId"></result>
        <result column="dept_name" property="dept.deptName"></result>
    </resultMap>

    <!--    getEmpAndDeptByEmpId-->
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
<!--        使用左外链接进行连表查询-->
        select * from t_emp left join t_dept on t_emp.dept_id = t_dept.dept_id where t_emp.emp_id = #{empId}
    </select>

2、association:处理多对一-的映射关系（处理实体类类型的属性）

<!--    association:处理多对一-的映射关系-->
        <resultMap id="empAndDeptResultMap" type="Emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
<!--            property:实体类中要处理的属性-->
<!--            javaType:设置当前要处理的属性的类型-->
            <association property="dept" javaType="Dept" >
                <id column="dept_id" property="deptId"></id>
                <result column="dept_name" property="deptName"></result>
            </association>
        </resultMap>

    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
<!--        使用左外链接进行连表查询-->
        select * from t_emp left join t_dept on t_emp.dept_id = t_dept.dept_id where t_emp.emp_id = #{empId}
    </select>

3、分步查询（一步一步的查）（可以处理一对多，也可以处理多对一的关系）

    <resultMap id="empAndDeptResultMapOne" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
<!--        select:里面写下一步的sql的唯一标识-->
<!--        column:下一步条件-->
        <association property="dept"
                     select="com.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="emp_id" >
            <id column="dept_id" property="deptId"></id>
            <result column="dept_name" property="deptName"></result>
        </association>
    </resultMap>

    <select id="getEmpAndDeptByOne" resultMap="empAndDeptResultMapOne">
        select * from t_emp where emp_id = #{empId}
    </select>

延迟加载

分步查询的优点:可以实现延迟加载
但是必须在核心配置文件中设置全局配置信息: .
lazyLoadingEnabled:延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
aggressiveLazyLoading:当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加
载
此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql.此时可通过association和 collection
中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载)| eager(立即加载)”

<!--        针对与所有的分步查询，进行延迟加载-->
<!--        开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
<!--        按需加载 false按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>

    <resultMap id="empAndDeptResultMapOne" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
<!--     fetchType：在开启了延迟加载的环境中，通过该属性设置当前的分步查询是否使用延迟加载
		eager:立即加载
		lazy：延迟加载
-->
        
        <association property="dept"
                     fetchType="eager"
                     select="com.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="emp_id" >
            <id column="dept_id" property="deptId"></id>
            <result column="dept_name" property="deptName"></result>
        </association>
    </resultMap>

    <select id="getEmpAndDeptByOne" resultMap="empAndDeptResultMapOne">
        select * from t_emp where emp_id = #{empId}
    </select>

处理一对多的映射关系

1、collection

    <resultMap id="deptAndEmpResultMap" type="Dept">
        <id column="dept_id" property="deptId"></id>
        <result column="dept_name" property="deptName"></result>
<!--        collection:处理一对多的映射关系-->
<!--        ofType:设置当前集合中的类型-->
        <collection property="emps" ofType="Emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
        </collection>
    </resultMap>

    <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
        select * from t_dept left join t_emp  on t_dept.dept_id = t_emp.dept_id where t_dept.dept_id = #{deptId}
    </select>

2、分步查询

与多对一致

动态SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接
SQL语句字符串时的痛点问题。

if标签

 <select id="getEmpByCondition" resultType="Emp">
        select * from t_emp where
<!--        直接访问实体类中的属性-->
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age != ''">
           and age = #{age}
        </if>
        <if test="gender != null and gender != ''">
           and gender = #{gender}
        </if>

    </select>

where标签

如果where标签内有条件成立，就会自动生成关键字where

会自动将where标签中内容前多余的and去掉，但是其中内容后多余的and无法去掉

如果当前条件都不成立，where标签不会给我们生成关键字where

    <select id="getEmpByConditiontwo" resultType="Emp">
        select * from t_emp
        <where>
            <if test="empName != null and empName != ''">
                emp_name = #{empName}
            </if>
            <if test="age != null and age != ''">
                and age = #{age}
            </if>
            <if test="gender != null and gender != ''">
                and gender = #{gender}
            </if>
        </where>
<!--        直接访问实体类中的属性-->
    </select>

trim标签

prefix, suffix:在标签中内容前面或后面添加指定内容
prefixoverrides. suffixoverrides: 在标签中内容前面或后面去掉指定内容

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <trim prefix="where" prefixOverrides="and">
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age != ''">
            and age = #{age}
        </if>
        <if test="gender != null and gender != ''">
            and gender = #{gender}
        </if>
    </trim>
</select>

choose、when、otherwise标签

相当于java中的if…else if…else
when至少设置一个，otherwise 最多设置一个

foreach标签

collection:设置要循环的数组或集合
item:用一个字符串表示数组或集合中的每- -个数据
separator:设置每次循环的数据之间的分隔符
open:循环的所有内容以什么开始
close:循环的所有内容以什么结束

open和close仅限于删除时使用

批量添加

    <insert id="insertMoreEmp">
<!--        多个小括号实现批量添加-->
        insert into t_emp values
<!--        利用注解去访问list集合-->
<!--        如果不使用注解的方式，则mybatis会把list集合放到map里面，以list为键，此时访问list就可以访问到list集合-->
        <foreach collection="emps" item="emp" separator=",">
            (null,#{emp.empName},#{emp.age},#{emp.gender},null)
        </foreach>
    </insert>

批量删除

第一种方式：

<delete id="deleteMoreEmp">
    delete from t_emp where emp_id in
    (
    <foreach collection="empIds" item="empId" separator=",">
        #{empId}
    </foreach>
    )
</delete>

第二种方式：

<delete id="deleteMoreEmp">
    delete from t_emp where emp_id in
    <foreach collection="empIds" item="empId" separator="," open="(" close=")">
        #{empId}
    </foreach>
</delete>

第三种方式：

delete from t_emp where
    <foreach collection="empIds" item="empId" separator="or">
        emp_id = #{empId}
    </foreach>
</delete>

sql标签

可以记录一段sql，在需要用的地方使用include标签进行引用

<sqL id= "empColumns">
	emp_ id, emp_ name, age , gender, dept_ _id
</sql>
<include refid= "empColumns"></include>

MyBatis的缓存

mybatis一级缓存（默认开启）

MyBatis的一级缓存是SqlSession级别的，即通过同一个sqlSession 查询的数据会被缓存
再次使用同一个SqlSession查询同-条数据，会从缓存中获取

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

1)、不同的SqlSession对应不同的一级缓存
2)、同一个SqISession但是查询条件不同
3)、同一个SqISession两次查询期间执行了任何一次增删改操作
4)、同一个SqISession两次查询期间手动清空了缓存

mybatis的二级缓存

二级缓存是SqISessionFactory级别，通过同一个SqlSessionFactory创建的SqISession查询的结果会被缓存;此后
若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件:

a>在核心配置文件中，设置全局配置属性cacheEnabled=“true”,默认为true, 不需要设置
b>在映射文件中设置标签，直接在映射文件中加该标签即可
C>二级缓存必须在SqISession关闭或提交之后有效
d>查询的数据所转换的实体类类型必须实现序列化的接口
使二级缓存失效的情况:
两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置-些属性:
①eviction属性：缓存回收策略，默认的是LRU。
LRU (Least Recently Used) - 最近最少使用的:移除最长时间不被使用的对象。
FIFO (First in First out) - 先进先出:按对象进入缓存的顺序来移除它们。
SOFT — 软引用:移除基于垃圾回收器状态和软弓|用规则的对象。
WEAK — 弱引用:更积极地移除基于垃圾收集器状态和弱弓|用规则的对象。
②flushInterval属性:刷新间隔，单位毫秒

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

③size属性:引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

④readOnly属性:只读，true/false

true:只读缓存;会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势.

false:读写缓存;会返回缓存对象的拷贝(通过序列化)。这会慢一些,但是安全，因此默认是false。