Mybatis（二）

最新推荐文章于 2023-12-21 11:05:28 发布

笨蛋悠米

最新推荐文章于 2023-12-21 11:05:28 发布

阅读量191

点赞数

分类专栏：框架

本文链接：https://blog.csdn.net/weixin_46744534/article/details/111874222

版权

框架专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Mybatis

多个学生，对应一个老师
对于学生这边而言，关联多个学生，关联一个老师【多对一】
对于老师而言，集合，一个老师，有很多学生【一对多】

多对一的处理（association）

查询嵌套处理类似于子查询
结果嵌套处理类似于联表查询

例如：查询一个关联，多个学生对应一个老师
在这里插入图片描述
一个student里面有一个对象

按查询嵌套处理

    <select id="selectByResult" resultMap="studentTeacher1">
        select * from student1
    </select>
<!--       下方的Student是我们实际查询的主类型-->
    <resultMap id="studentTeacher1" type="Student">
    <!-- association用于关联 property是在pojo类中的字段名 
    javaType是查询出来的类型  column是传过去给子查询的已查出的内容
    select是子查询的id-->
        <association property="teacher" javaType="Teacher" column="tid" select="selectTeacher"></association>
    </resultMap>
		<!--tid可以任意起名，因为会自动识别 -->
    <select id="selectTeacher" resultType="Teacher">
        select * from teacher where id = #{tid}
    </select>

按结果嵌套处理

    <select id="selectBySelect" resultMap="studentTeacher2">
        select s.id sid,s.name sname,t.name tname from student1 s,teacher t where s.tid=t.id
    </select>
	<!-- 下方的Student是我们实际查询的主类型-->
    <resultMap id="studentTeacher2" type="Student">
    <!-- property是pojo类中的字段名 column是查询出来的名字-->
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <!-- association用于关联 javaType是查询出来的类型-->
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>

一对多的处理（collection）

查询嵌套处理类似于子查询
结果嵌套处理类似于联表查询

例如：查询一个集合，一个老师包含多个学生
在这里插入图片描述
一个Teacher里面有一个集合

按查询嵌套处理

<!--    按照查询嵌套处理-->
    <select id="selectById2" resultMap="TeacherStudent2">
        select * from teacher where id = #{tid}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
    <!--   collection 是集合   javaType是-->
        <collection property="students" column="id" javaType="ArrayList"
                    ofType="Student" select="selectStudent"></collection>
    </resultMap>
    <select id="selectStudent" resultType="Student">
        select * from student1 where tid = #{id}
    </select>

按结果嵌套处理

<!--    按照结果嵌套处理-->
    <select id="selectById1" resultMap="TeacherStudent1">
        select s.id sid, s.name sname, t.name tname,t.id tid
        from student1 s,teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>
    <resultMap id="TeacherStudent1" type="Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <collection property="students" ofType="Student">
            <result property="id" column="sid"></result>
            <result property="name" column="sname"></result>
            <result property="tid" column="tid"></result>
        </collection>
    </resultMap>

小结

关联 - association 【多对一】（里面是对象）
集合 - collection 【一对多】（里面是集合）
javaType & ofType
1. JavaType 用来指定实体类中属性的类型
2. ofType 用来指定映射到List或者集合中的 pojo类型，泛型中的约束类型！

注意点：

保证SQL的可读性，尽量保证通俗易懂
注意一对多和多对一中，属性名和字段的问题！
如果问题不好排查错误，可以使用日志，建议使用 Log4j

动态SQL

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

if
choose (when, otherwise)
trim (where, set)
foreach

if

初识
if是我们常常用来判断的东西，常见在mybatis的格式如下：

在mapper中代码如下：

    <select id="selectBlog2" parameterType="map" resultType="Blog">
        select * from Blog where 1=1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>

在测试代码如下：

    @Test
    public void test2(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Map<String, Object> map=new HashMap<>();
//        map.put("title","Mybatis");
//        map.put("author","狂神说");
        List<Blog> blogs = mapper.selectBlog2(map);
        System.out.println(blogs);
        sqlSession.close();
    }

trim、where、set

1=1往往不安全，但是如果我们不用1=1，那么下面代码拼接的时候，会出现两种情况的错误
第一种错误：没了1=1，满足if条件，sql变成如下，会多出and，产生错误

select * from Blog where and title = #{title}

第二种错误：没了1=1，不满足if条件，sql变成如下，多出了where，产生错误

select * from Blog where

所以为了解决这个问题我们引进了where标签，代码如下：

    <select id="selectBlog3" parameterType="map" resultType="Blog">
        select * from Blog
        <where>
            <if test="title != null">
                and title = #{title}
            </if>
            <if test="author != null">
                and author = #{author}
            </if>
        </where>
    </select>

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除所有prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

用于动态更新语句的类似解决方案叫做 set。**set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。**比如：

   <update id="updateBlog1" parameterType="map">
        update Blog
        <set>
            <if test="title != null">
                title = #{title},
            </if>
            <if test="author != null">
                author = #{author}
            </if>
        </set>
        where id = #{id}
    </update>

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

choose(when、otherwise)

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就查找对应的id。
注意：是只选择一个！！！！

    <select id="selectBlog4" parameterType="map" resultType="Blog">
        select * from Blog
        <where>
            <choose>
                <when test="title != null">
                    and title = #{title}
                </when>
                <when test="author != null">
                    and author = #{author}
                </when>
                <otherwise>
                    and id = #{id}
                </otherwise>
            </choose>
        </where>
    </select>

sql标签

有的时候，我们可能会将一些功能的部分抽取出来，方便复用！

使用SQL标签抽取公共的部分

    <sql id="if-title-author">
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </sql>

在需要使用的地方使用Include标签引用即可

    <select id="selectBlog5" parameterType="map" resultType="Blog">
        select * from Blog
        <where>
            <include refid="if-title-author"></include>
        </where>
    </select>

注意事项：

最好基于单表来定义SQL片段！
不要存在where标签

foreach

看看官网怎么说：
在这里插入图片描述
如果我们想实现下面的sql，并采用之前所学的动态sql会感觉到很为难。

select * from Blog where 1=1 and (id=1 or id=2 or id=3)

我们尝试将上面的那个sql按照foreach的方式写出：
ids是我们传进来的数组的名字，open内的and因为在where中会自动去掉

    <select id="selectBlog6" parameterType="map" resultType="Blog">
        select * from Blog
        <where>
            <foreach collection="ids" open="and (" close=")" separator="or" item="id">
                id = #{id}
            </foreach>
        </where>
    </select>

测试代码如下：

    @Test
    public void test3(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Map<String, Object> map=new HashMap<>();
        ArrayList ids=new ArrayList();
        map.put("ids",ids);
        ids.add(1);
        ids.add(2);
        List<Blog> blogs = mapper.selectBlog6(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
        sqlSession.close();
    }

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

建议：

现在Mysql中写出完整的SQL,再对应的去修改成为我们的动态SQL实现通用即可！

缓存

查询  ：  连接数据库 ，耗资源！
一次查询的结果，给他暂存在一个可以直接取到的地方！--> 内存 ： 缓存
我们再次查询相同数据的时候，直接走缓存，就不用走数据库了

什么是缓存 [ Cache ]？

存在内存中的临时数据。
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

为什么使用缓存？

减少和数据库的交互次数，减少系统开销，提高系统效率。

什么样的数据能使用缓存？

经常查询并且不经常改变的数据。【可以使用缓存】

Mybatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
- 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
- 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

一级缓存

一级缓存也叫本地缓存： SqlSession
- 与数据库同一次会话期间查询到的数据会放在本地缓存中。
- 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

测试步骤：

开启日志！

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

测试在一个Sesion中查询两次相同记录

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.selectById(2);
        Teacher teacher1 = mapper.selectById(2);
        System.out.println(teacher==teacher1);   //true
        sqlSession.close();
    }

查看日志输出

在这里插入图片描述
说明一级缓存存在

缓存失效的情况：

查询不同的东西
增删改操作，可能会改变原来的数据，所以必定会刷新缓存！

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.selectById(2);
        mapper.updateById(new Teacher(1,"xml"));
        Teacher teacher1 = mapper.selectById(2);
        System.out.println(teacher==teacher1);
        sqlSession.close();
    }

在这里插入图片描述

查询不同的Mapper.xml
手动清理缓存

小结：一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段！
一级缓存就是一个Map。

二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
- 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
- 新的会话查询信息，就可以从二级缓存中获取内容；
- 不同的mapper查出的数据会放在自己对应的缓存（map）中；

步骤：

开启全局缓存

    <settings>
        <!--显示的开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

在要使用二级缓存的Mapper中开启

<!--在当前Mapper.xml中使用二级缓存-->
<cache/>

也可以自定义参数

<!--在当前Mapper.xml中使用二级缓存-->
<cache  eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>

可用的清除策略（eviction）有：

LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

提示二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。

测试：

    @Test
    public void test1(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        SqlSession sqlSession1 = MybatisCon.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        TeacherMapper mapper1 = sqlSession1.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.selectById(2);
        sqlSession.close();

        Teacher teacher1 = mapper1.selectById(2);
        System.out.println(teacher==teacher1);
        sqlSession1.close();
    }

在这里插入图片描述

问题出现了！
当我们只有一个<cache/>的时候，会报没有序列化的错误

Caused by: java.io.NotSerializableException: com.kuang.pojo.User

这是因为readOnly默认为false，可以进行读写操作需要序列化，改为true即只读，不需要序列化

小结：

只要开启了二级缓存，在同一个Mapper下就有效
所有的数据都会先放在一级缓存中；
只有当会话提交，或者关闭的时候，才会提交到二级缓冲中！

缓存原理

在这里插入图片描述
缓存顺序：

先看二级缓存中有没有
在看一次缓存中有没有
查询数据库

Cache Hit Ratio（缓存命中率）

    public void test2(){
        SqlSession sqlSession = MybatisCon.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        TeacherMapper mapper1 = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.selectById(2);
        Teacher teacher1 = mapper1.selectById(2);
        sqlSession.close();
        System.out.println(teacher==teacher1);
    }

在下上面的代码运行时，我们可以看到运行结果中出现了Cache Hit Ratio一词，这代表着缓存的命中率

在这里插入图片描述
缓存命中率（Cache Hit Ratio），指的是在缓存中查询到的次数/总共在缓存中查询的次数。

假设你将一段数据缓存至内存中
第一查询数据时:
由于你是在从数据库中查询的数据
缓存命中率为0.0，还没有进入缓存
关闭此数据库链接后

第二次再查询相同的数据时,假如你将数据缓存进内存中
第二次将会直接从内存中去取这条相同的数据
缓存将命中
所以此时的缓存命中率为0.5

第三次查询相同的数据，则命中率为0.66666

以此类推…

自定义缓存

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存

要在程序中使用ehcache，先要导包！

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

在mapper中指定使用我们的ehcache缓存实现！

<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

新建一个ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统+宕机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->

</ehcache>

Mybatis和Hibernate的区别

相同点

Hibernate与MyBatis都可以是通过SqlSessionFactoryBuider由XML配置文件生成SqlSessionFactory，然后由SqlSessionFactory 生成SqlSession，最后由SqlSession来开启执行事务和SQL语句。

其中SqlSessionFactoryBuider，SqlSessionFactory，SqlSession的生命周期都是差不多的。Hibernate和MyBatis都支持JDBC和JTA事务处理。

不同点

（1）hibernate是全自动，而mybatis是半自动

hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。

（2）hibernate数据库移植性远大于mybatis

hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（Oracle、MySQL等）的耦合性，而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。

（3）hibernate拥有完整的日志系统，mybatis则欠缺一些

hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；而mybatis则除了基本记录功能外，功能薄弱很多。

（4）mybatis相比hibernate需要关心很多细节

hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。

（5）sql直接优化上，mybatis要比hibernate方便很多

由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的，无法直接维护sql；虽有hql，但功能还是不及sql强大，见到报表等变态需求时，hql也歇菜，也就是说hql是有局限的；hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。总之写sql的灵活度上hibernate不及mybatis。

（6）缓存机制上，hibernate要比mybatis更好一些

MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。

而Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。

练习题

本地项目Mybatis的最后一个

笨蛋悠米

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis（二）

MybatisMybatis多对一的处理（association）按查询嵌套处理按结果嵌套处理一对多的处理（collection）按查询嵌套处理按结果嵌套处理小结Mybatis多个学生，对应一个老师对于学生这边而言，关联多个学生，关联一个老师【多对一】对于老师而言，集合，一个老师，有很多学生【一对多】多对一的处理（association）查询嵌套处理类似于子查询结果嵌套处理类似于联表查询例如：查询一个关联，多个学生对应一个老师按查询嵌套处理 <sel
复制链接

扫一扫