MyBatis框架问题总结

r囧r小猫 2023-10-08 12:37 68阅读 0赞

### 一，概念 ###

MyBatis是一个对象关系映射框架，简称ORM框架。RM框架提供了持久化类与表的映射关系，在运行时参照映射文件的信息，把对象持久化到数据库中。  
**目前常见的ORM框架有mybatis和hibernate，两者的区别主要是：**  
**1，sql方面**  
Hibernate 自动生成sql,部分语句较为繁琐，会多消耗性能；适用于传统管理类项目。  
Mybatis 手动编写sql，可避免不必要的查询，自主优化，提高系统性能；适用于注重性能的互联网项目。

**2，开发方面**  
hibernate开发中，完全面向对象封装，sql语句已经被封装，直接可以使用，加快系统开发，但开发者不容易理解底层实现。  
Mybatis开发中，自行管理映射关系， 属于半自动化，sql需要手工完成，稍微繁琐，但容易让开发者理解底层实现。  
**3，缓存方面**  
Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置，然后再在具体的表-对象映射中配置是哪种缓存。

MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，针对不同的表可自定义不同缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。  
**4，数据库的移植性**  
MyBatis不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。  
Hibernate具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。以后,mysql数据迁移到oracle，只需要改方言配置

### 二，MyBatis的sql参数绑定 ###

**1，序号（原生）参数绑定**  
参数顺序对应sql语句参数顺序

//id对应arg0，pwd对应arg1
     public User selectUserByIdAndPwd(Integer id , String pwd);
    SELECT * FROM t_users
        WHERE id = #{
        arg0} AND password = #{
        arg1}

**2，注解（原生）参数绑定**  
注解别名对应sql参数名

public User selectUserByIdAndPwd(@Param("id")Integer aaa, 
     @Param("pwd")String bbb);
     SELECT * FROM t_users
        WHERE id = #{
        id} AND password = #{
        pwd}

**3，Map参数绑定**  
键值对应sql参数名

Map values = new HashMap(); //测试类创建Map
    values.put("myId",1); //自定义key，绑定参数
    values.put("myPwd","123456");
    User user = userDao.selectUserByIdAndPwd_map(values);
     SELECT * FROM t_users 
      	WHERE id = #{
        myId} AND password = #{
        myPwd}

**4，对象参数绑定**  
对象属性名对应sql参数名

public User selectUserByUserInfo(User user);
    SELECT * FROM t_users
        WHERE id = #{
        id} AND password = #{
        password}

**5，$符号参数绑定**  
$\{attribute\} 属于字符串拼接SQL，而非预编译占位符，会有注入攻击问题，不建议在常规SQL中使用，常用于可解决动态生降序问题

User user = new User(....);
    List<User> ulist1 = userDAO.selectAllUsers1(user); //调用时传入user对象
    List<User> ulist2 = userDao.selectAllUsers2("desc"); //调用时传入asc | desc
    
    <select id="selectAllUsers1" resultType="user">
    	SELECT * FROM t_users 
        WHERE name = '${name}' or id = ${id} 
    </select>
    <select id="selectAllUsers2" resultType="user">
    	SELECT * FROM t_users 
      	ORDER BY id ${rule} 
    </select>

**6，模糊查询**  
keyword是传入的关键字参数

SELECT * FROM t_users 
      		WHERE name LIKE concat('%',#{
        keyword},'%')

### 三，主键回传两种方式 ###

**1， 通过last\_insert\_id()查询主键**

<insert id="insertProduct" parameterType="product">
    		 
            <selectKey keyProperty="id" resultType="int" order="AFTER">
             
                SELECT LAST_INSERT_ID()
            </selectKey>
            INSERT INTO t_product(id,name) VALUES(#{id},#{name})
    </insert>

**2，通过uuid()查询主键**

<insert id="insertOrder" parameterType="order">
     		
            <selectKey keyProperty="id" resultType="String" order="BEFORE">
            
                SELECT REPLACE(UUID(),'-','') 
            </selectKey>
            INSERT INTO t_order(id,name) VALUES(#{id},#{name})
        </insert>

**注意：两种主键的回传方式都是回传到了传递的参数——类的对象的主键属性中，可通过主键get方法得到。**

### 三，ORM映射 ###

**1，列的别名**  
在SQL中使用 as 为查询字段添加列别名，以匹配属性名

SELECT mgr_id AS id , mgr_name AS username , mgr_pwd AS password
            FROM t_managers
            WHERE mgr_id = #{id} AND mgr_pwd = #{pwd}

**2，结果映射（ResultMap - 查询结果的封装规则）**

<resultMap id="managerResultMap" type="com.qf.mybatis.part2.orm.Manager">
          	
            <id property="id" column="mgr_id" />
          	
            <result property="username" column="mgr_name" />
            <result property="password" column="mgr_pwd" />
        </resultMap>
         
        <select id="selectAllManagers" resultMap="managerResultMap">
            SELECT mgr_id , mgr_name , mgr_pwd
            FROM t_managers
        </select>

**3，驼峰式映射**  
mybatis配置文件中添加，注意：只适用于驼峰式映射

### 四，MyBatis处理关联关系-多表连接 ###

**1，一对一关系**  
典型一对一关系：一个订单详情对应一种商品  
使用association 标签，javaType属性表示关联的类

<resultMap id="passengerResultMap" type="com.qf.mybatis.part2.one2one.Passenger">
            <id property="id" column="id"/>
            <result property="name" column="name" />
            <result property="sex" column="sex" />
            <result property="birthday" column="birthday" />
          		 
            <association property="passport" javaType="com.qf.mybatis.part2.one2one.Passport">
                <id property="id" column="passport_id" />
                <result property="nationality" column="nationality" />
                <result property="expire" column="expire" />
              	<result property="passenger_id" column="passenger_id" />
            </association>
        </resultMap>
      						  	
        <select id="selectPassengerById" resultMap="passengerResultMap">
            
            SELECT p1.id , p1.name , p1.sex , p1.birthday , p2.id as passport_id , p2.nationality , p2.expire 			, p2.passenger_id
            FROM t_passengers p1 LEFT JOIN t_passports p2
            ON p1.id = p2.passenger_id
            WHERE p1.id = #{id}
        </select>

**2，一对多关系**  
典型一对多关系: 一张订单对应多个订单详情  
使用collection标签，ofType属性表示关联的类

<resultMap id="departmentResultMap" type="com.qf.mybatis.part2.one2many.Department">
            <id property="id" column="id" />
            <result property="name" column="name" />
            <result property="location" column="location" />
          			
            <collection property="emps" ofType="com.qf.mybatis.part2.one2many.Employee">
                <id property="id" column="emp_id" />
                <result property="name" column="emp_name" />
                <result property="salary" column="salary" />
                <result property="dept_id" column="dept_id" />
            </collection>
        </resultMap>
      				      
        <select id="selectDepartmentById" resultMap="departmentResultMap" >
          	
            SELECT d.id , d.name , d.location , e.id AS emp_id , e.name emp_name , e.salary , e.dept_id
            FROM t_departments d LEFT JOIN t_employees e
            ON d.id = e.dept_id
            WHERE d.id = #{id}
        </select>

**3，多对多关系**  
典型多对多关系：一个学生有多种课程，一种课程有多个学生  
建立第三张表存放两表外键，两个外键为联合主键

<resultMap id="allMap" type="com.qf.mybatis.part2.many2many.Student">
            <id property="id" column="id" />
            <result property="name" column="name" />
            <result property="sex" column="sex" />
            <collection property="subjects" ofType="com.qf.mybatis.part2.many2many.Subject">
                <id property="id" column="sid" />
                <result property="name" column="sname" />
                <result property="grade" column="grade" />
            </collection>
        </resultMap>
      	
        <select id="selectAllStudents" resultMap="allMap">
            SELECT s1.* , ss.* , s2.id as sid , s2.name as sname , s2.grade
            FROM t_students s1 LEFT JOIN t_stu_sub ss
            ON s1.id = ss.student_id 
            LEFT JOIN t_subjects s2
            ON ss.subject_id = s2.id
        </select>

### 五，动态sql ###

**1，include引用sql片段**

<sql id="BOOKS_FIELD"> 
            SELECT id,name,author,publish,sort
    </sql>
    <select id="selectBookByCondition" resultType="com.qf.mybatis.part2.dynamic.Book">
        
    	<include refid="BOOKS_FIELD" /> FROM t_books
    </select>

**2，where 和 if**

<select id="selectBookByCondition" resultType="com.qf.mybatis.part2.dynamic.Book">
        SELECT id , name , author , publish , sort
        FROM t_books
        <where> 
            <if test="id != null"> id = #{id}</if>
            <if test="name != null">and name = #{name}</if>
            <if test="author != null">and author = #{author}</if>
            <if test="publish != null"> and publish = #{publish}</if>
            <if test="sort != null">and sort = #{sort}</if>
        </where>
    </select>

**3，set**

<update id="updateBookByCondition">
        UPDATE t_books
        <set>
            <if test="name != null">name = #{name} ,</if>
            <if test="author != null">author = #{author} ,</if>
    		<if test="publish != null">publish = #{publish} ,</if>
    		<if test="sort != null">sort = #{sort} ,</if>
        </set>
        WHERE id = #{id}
    </update>

**4，trim**  
< trim prefix=“” suffix=“” prefixOverrides=“” suffixOverrides=“” >代替< where > 、< set >

<select id="selectBookByCondition" resultType="com.qf.mybatis.day2.dynamic.Book">
    SELECT id,name,author,publish,sort
        FROM t_books
        <trim prefix="WHERE" prefixOverrides="AND|OR"> 
            <if test="id != null"> and id = #{id}</if>
            <if test="name != null">and name = #{name}</if>
            <if test="author != null">and author = #{author}</if>
            <if test="publish != null">and publish = #{publish}</if>
            <if test="sort != null">and sort = #{sort}</if>
    	</trim></select>

<update id="updateBookByCondition">
    		UPDATE t_books
    		<trim prefix="SET" suffixOverrides=","> 
    				<if test="name != null">name = #{name} ,</if>
    				<if test="author != null">author = #{author} ,</if>
    				<if test="publish != null">publish = #{publish} </if>
    				<if test="sort != null">sort = #{sort}</if>
        </trim>
    		WHERE id = #{id}
    </update>

**5，foreach**

<delete id="deleteBookByIds">
    		DELETE FROM t_books
    		WHERE id IN
    		<foreach collection="list" open="(" separator="," close=")"  item="id" index="i">
    				#{id}
    		</foreach>
    </delete>
     <insert id="insertOrdersDetail">
            insert into orders_detail (pid,oid,num,money) values
            <foreach collection="ordersDetails" item="ordersDetail" separator=",">
            (#{ordersDetail.pId},#{ordersDetail.oId},#{ordersDetail.num},#{ordersDetail.money})
            </foreach>
        </insert>

### 六，缓存 ###

##### 概念 #####

内存中的一块存储空间，服务于某个应用程序，旨在将频繁读取的数据临时保存在内存中，便于二次快速访问。  
**无缓存**：用户在访问相同数据时，需要发起多次对数据库的直接访问，导致产生大量IO、读写硬盘的操作，效率低下  
**有缓存**：首次访问时，查询数据库，将数据存储到缓存中；再次访问时，直接访问缓存，减少IO、硬盘读写次数、提高效率

**1 ，一级缓存**  
SqlSession级别的缓存，同一个SqlSession的发起多次同构查询，会将数据保存在一级缓存中。  
注意：无需任何配置，默认开启一级缓存。  
**2 ，二级缓存**  
SqlSessionFactory级别的缓存，同一个SqlSessionFactory构建的SqlSession发起的多次同构查询，会将数据保存在二级缓存中。  
注意：在sqlSession.commit()或者sqlSession.close()之后生效。  
**3， 指定Mapper缓存**  
在指定表对应的mapper文件的sql语句前添加

**4，全局缓存**  
mabatis配置文件中

### 七，Mybatis延迟加载的实现方式 ###

**1、概念：**

MyBatis中的延迟加载，也叫懒加载，是指在进行表的关联查询时，按照设置的延迟规则推迟对关联对象的select查询。例如在进行一对多查询的时候，只查询出一方，当程序中需要多方的数据时，mybatis再发出sql语句进行查询，这样子延迟加载就可以的减少数据库压力。MyBatis 的延迟加载只是对关联对象的查询有迟延设置，对于主加载对象都是直接执行查询语句的。

**2、加载时机：**

**直接加载**：执行完对主加载对象的 select 语句，马上执行对关联对象的 select 查询。  
**侵入式延迟**： 执行对主加载对象的查询时，不会执行对关联对象的查询。但当要访问主加载对象的详情属性时，就会马上执行关联对象的select查询。  
**深度延迟**： 执行对主加载对象的查询时，不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时，才会执行对关联对象的 select 查询。

注意：延迟加载的应用要求：关联对象的查询与主加载对象的查询必须是分别进行的select语句，不能是使用多表连接所进行的select查询。因为，多表连接查询，实质是对一张表的查询，对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。  
**侵入式延迟加载：**  
不调用主加载对象时只有一条SQL  
调用主加载对象的信息时会产生两条SQL

<setting name="lazyLoadingEnabled" value="true"/>
        
        <setting name="aggressiveLazyLoading" value="true"/>

**深入式延迟加载：**  
调用主加载对象时不会执行第二条加载SQL  
调用关联对象详细信息时会执行第二次查询