MyBatis进阶（三）

• MyBatis进阶（三）
• • 声明：本博客参考微信公众号：狂神说
  • 1、多对一处理
  • • 1.1 测试环境搭建
    • 1.2 按照查询嵌套处理
    • 1.3 按照结果嵌套处理
  • 2、一对多处理
  • • 2.1 环境搭建
    • 2.2 按照结果嵌套嵌套处理
    • 2.3 小结
  • 3、动态SQL
  • • 3.1 搭建环境
    • 3.2 MyBatis常用的SQL标签
    • • IF标签
      • Where标签
      • Set标签
      • trim标签
      • choose标签（和switch语句差不多）
      • Foreach标签
    • 3.3 SQL片段
    • 3.4 动态SQL小结
  • 4、缓存
  • • 4.1 简介
    • 4.2 MyBatis缓存
    • 4.3 MyBatis一级缓存
    • 4.4 MyBatis二级缓存
    • 4.5 缓存原理
    • 4.6 第三方缓存 -- Ehcache（自定义缓存）

多个学生一个老师

alter table student ADD CONSTRAINT fk_tid foreign key (tid) references teacher(id)

1. 导入Lombok
2. 新建实体类Teacher,Student
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册Mapper接口或者文件 【方式很多，随意选】
6. 测试查询是否能够成功

    select * from student



    
    
    
    
    



    select * from teacher where id = #{id}

 
1.3 按照结果嵌套处理 


    select s.id sid , s.name sname, t.name tname
    from student s,teacher t
    where s.tid=t.id




    
    
    
        
    

回顾Mysql多对一查询方式：

• 子查询 （按照查询嵌套）
• 联表查询 （按照结果嵌套）

一个老师多个学生；

对于老师而言，就是一对多的关系；

实体类

@Data //get、set
public class Student {
    private int id;
    private String name;
    private int tid;
}

@Data
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生
    private List students;
}

    SELECT s.id sid, s.name sname,t.name tname,t.id tid FROM student s, teacher t
    WHERe s.tid = t.id AND tid = #{tid}


    
    
    
    
        
        
        
    

 
2.3 小结 
关联 - association 【多对一】
集合 - collection 【一对多】
javaType & ofType 
  
JavaType用来指定实体类中的类型
ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型
 
 
注意点：
 
保证SQL的可读性，尽量保证通俗易懂
注意一对多和多对一，属性名和字段的映射问题
如果问题不好排查错误，可以使用日志，建议使用Log4j
 
面试高频：
 
Mysql引擎
InnoDB底层原理
索引
索引优化
 
 
-- 连接查询
select * from tb_user tu
left join tb_role tr on tu.role_id = tr.id
where tu.id = 1

select tu.*,tr.id as role_id,tr.name as role_name from tb_user tu
left join tb_role tr on tu.role_id = tr.id
where tu.id = 1

select tr.id as role_id,
tr.name as role_name,
tp.id as permission_id,
tp.name as permission_name
from tb_role tr
left join tb_role_permission trp on tr.id = trp.role_id
left join tb_permission tp on tp.id = trp.permission_id
where tr.id = 1

select * from tb_permission 
 
3、动态SQL 
什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句
 
所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码
 
 
 
动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。
 
 
3.1 搭建环境 
数据库环境
 
CREATE TABLE `mybatis`.`blog`  (
  `id` int(10) NOT NULL AUTO_INCREMENT COMMENT '博客id',
  `title` varchar(30) NOT NULL COMMENT '博客标题',
  `author` varchar(30) NOT NULL COMMENT '博客作者',
  `create_time` datetime(0) NOT NULL COMMENT '创建时间',
  `views` int(30) NOT NULL COMMENT '浏览量',
  PRIMARY KEY (`id`)
)
 
 
创建一个基础工程
 
  
 
导包
 
 
编写配置文件
 

    
    



    

 
 
编写实体类
 
@Data
public class Blog {
    private int id;
    private String title;
    private String author;

    private Date createTime;// 属性名和字段名不一致
    private int views;
}
 
 
编写实体类对应Mapper接口和Mapper.xml文件
 
 
 
3.2 MyBatis常用的SQL标签 
IF标签 
 
 
需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
 
 
 
编写接口类
 
//需求1
List queryBlogIf(Map map);
 
 
编写接口对应的 Mapper.xml 映射文件
 


    select * from blog where
    
        title = #{title}
    
    
        and author = #{author}
    

 
 
测试
 
@Test
public void testQueryBlogIf() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    map.put("title","Mybatis如此简单");
    map.put("author","狂神说");
    List blogs = mapper.queryBlogIf(map);

    System.out.println(blogs);

    session.close();
}
 
 
小结：
 
  
 
   
这样写我们可以看到，如果 author 等于 null，那么查询语句为 select * from user where title=#{title},但是如果title为空呢？那么查询语句为 select * from user where and author=#{author}，这是错误的 SQL 语句，如何解决呢？请看下面的 where 语句！
 
  
 
 
Where标签 
 
 
它会智能处理AND 或OR 开头的SQL
 
 
修改上面Mapper.xml中的SQL语句；
 

    select * from blog
    
        
            title = #{title}
        
        
            and author = #{author}
        
    

 
 
小结：
 
  
 
   
这个 “where” 标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
 
  
 
 
Set标签 
 
 
同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，后面如果有多余的逗号，我们怎么处理呢？
 
 
 
编写接口方法
 
int updateBlog(Map map);
 
 
编写接口对应的 Mapper.xml 映射文件
 


    update blog
    
        
            title = #{title},
        
        
            author = #{author}
        
    
    where id = #{id};

 
 
测试
 
@Test
public void testUpdateBlog() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    map.put("title","动态SQL");
    map.put("author","秦疆");
    map.put("id","9d6a763f5e1347cebda43e2a32687a77");

    mapper.updateBlog(map);

    session.close();
}
 
 
trim标签 
 
 
可以替代Where标签和Set标签。
 
 
prefix ：要插入的标签
 
 
prefixOverrides ：要去除的多余的前缀
 
 
suffixOverrides：要去除的多余的后缀
 
 
prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。
 
 


  ...

 


  ...

 
choose标签（和switch语句差不多） 
 
 
有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句
 
 
 
编写接口方法
 
List queryBlogChoose(Map map);
 
 
编写接口对应的 Mapper.xml 映射文件
 

    select * from blog
    
        
            
                title = #{title}
            
            
                and author = #{author}
            
            
                and views = #{views}
            
        
    

@Test
public void testQueryBlogChoose(){
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    HashMap map = new HashMap();
    map.put("title","Java如此简单");
    map.put("author","狂神说");
    map.put("views",9999);
    List blogs = mapper.queryBlogChoose(map);

    System.out.println(blogs);

    session.close();
}

将数据库中前三个数据的id修改为1,2,3；

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

1. 编写接口

   List queryBlogForeach(Map map);
   

2. 编写接口对应的 Mapper.xml 映射文件

   
       select * from blog
       
           
           
               id=#{id}
           
       
   
    
    
   测试
    
   @Test
   public void testQueryBlogForeach(){
       SqlSession session = MybatisUtils.getSession();
       BlogMapper mapper = session.getMapper(BlogMapper.class);
   
       HashMap map = new HashMap();
       List ids = new ArrayList();
       ids.add(1);
       ids.add(2);
       ids.add(3);
       map.put("ids",ids);
   
       List blogs = mapper.queryBlogForeach(map);
   
       System.out.println(blogs);
   
       session.close();
   }
    
    
   3.3 SQL片段 
    
    
   有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。（类似于函数、方法，SQL中的存储过程）
    
    
    
   使用 sql 标签抽取公共部分可
    
   
       
           title = #{title}
       
       
           and author = #{author}
       
   
    
    
   在需要使用的地方使用 include 标签引用即可
    
   
       select * from blog
       
           
       
   
   

3. 注意事项：

   • 最好基于 单表来定义 sql 片段，提高片段的可重用性
   • 在 sql 片段中不要包括 where

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

2、为了保证拼接准确，最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。

3、动态SQL的本质还是SQL。

4、动态SQL在开发中大量的使用，一定要熟练掌握！

查询 ： 连接数据库，耗资源。

一次查询的结果，给他暂存一个可以直接取到的地方 --> 内存：缓存。

我们再次查询的相同数据的时候，直接走缓存，不走数据库了，减少和数据库交互的次数，提高效率。

1. 什么是缓存（Cache）？
   • 存在内存中的临时数据
   • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题
2. 为什么使用缓存？
   • 减少和数据库的交互次数，减少系统开销，提高系统效率
3. 什么样的数据可以使用缓存？
   • 经常查询并且不经常改变的数据 【可以使用缓存】

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便的定制和配置缓存，缓存可以极大的提高查询效率。

• MyBatis系统中默认定义了（自带）两级缓存：

  • 一级缓存 和 二级缓存。
  • 默认情况下，只有一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，他是基于namespace（接口）级别的缓存。
  • 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

一级缓存也叫本地缓存：SqlSession 级别的

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

步骤：

1. 开启日志，方便查看测试结果

2. 编写接口方法

   //根据id查询用户
   User queryUserById(@Param("id") int id);
   

3. 接口对应的Mapper.xml 文件

   
       select * from user where id = #{id}
   
    
    
   测试在一个Session中查询两次记录
    
   @Test
   public void test1() {
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       User user = mapper.getUserById(1);
       System.out.println(user);
   
       System.out.println("=====================================");
   
       User user2 =  mapper.getUserById(1);
       System.out.println(user2 == user);
   }
    
    
   查看日志输出
    
    
    
   缓存失效的情况：
    
    
   查询不同的东西。
    
    
   增删改操作，可能会改变原来的数据，所以必定会刷新缓存。
    
    
   查询不同的Mapper.xml。
    
    
   手动清理缓存。
    
   sqlSession.clearCache(); //手动清理一级缓存中的数据
    
    
   注意事项：
    
   一级缓存是SqlSession级别的，只有在一个SqlSession的创建完成，到归还SqlSession到连接池，这之间有效。
   两个SqlSession如果相同，则它们共享SqlSession中的数据。
   一级缓存其实就是一个map，用 K-V 对来存储数据。
    
   4.4 MyBatis二级缓存 
   二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存。
   基于namespace级别的缓存，一个名称空间，对应一个二级缓存。
   工作机制 
     
   一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中。
   如果会话（SqlSession）关闭了，这个会话对应的一级缓存就没了；一级缓存中的数据被保存到二级缓存中。
   新的会话（新的SqlSession）查询信息，就可以从二级缓存中获取内容。
   不同的mapper查询出的数据会放在自己对应的缓存（map）中。
    
    
   步骤：
    
    
   在 mybatis-config.xml 中开启全局（二级）缓存
    
   
   
    
    
   在Mapper.xml中使用缓存
    
   
   
   
   
    
    
   测试
    
     
   所有的实体类（包括属性中的自定义对象类型、直接父类）先实现序列化接口
    
   @Test
   public void testQueryUserById(){
       SqlSession session = MybatisUtils.getSession();
       SqlSession session2 = MybatisUtils.getSession();
   
       UserMapper mapper = session.getMapper(UserMapper.class);
       UserMapper mapper2 = session2.getMapper(UserMapper.class);
   
       User user = mapper.queryUserById(1);
       System.out.println(user);
       session.close();
   
       User user2 = mapper2.queryUserById(1);
       System.out.println(user2);
       System.out.println(user==user2);
   
       session2.close();
   }
    
    
   注意事项：
    
    
   只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据；
    
    
   查出的数据都会被默认【先放在一级缓存中】；
    
    
   只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中；
    
    
   先查二级缓存，再查一级缓存，再查数据库；
    
    
   即使在一个sqlSession中，也会先查二级缓存；一个namespace中的查询更是如此；
    
   二级缓存的数据是从一级缓存中获取的。
   如果二级缓存开启，先判断二级缓存有没有数据，如果有就直接返回；如果没有，就查询一级缓存，如果有就返回，没有就查询数据库。
   如果二级缓存关闭，直接判断一级缓存是否有数据，如果没有就查数据库。
    
    
   注意事项：只有查询才有缓存，根据数据是否需要缓存（修改是否频繁选择是否开启）useCache=“true”
    
   
       select * from user where id = #{id}
   
   

   4.5 缓存原理

   1、MyBatis自带缓存原理图

   2、MyBatis结合第三方缓存原理图

   4.6 第三方缓存 – Ehcache（自定义缓存）

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

   使用第三方缓存，更加灵活，可以用配置文件配置各项参数，更加 专业。

   合理的使用缓存，可以让我们程序的 性能 大大提升！

   1. 导包（pom.xml）

      
      
          org.mybatis.caches
          mybatis-ehcache
          1.1.0
      
      

   2. 在 mapper.xml 中指定使用我们的 ehcache 缓存实现

   3. 编写 ehcache.xml 文件，如果在加载时未找到/ehcache.xml资源或出现问题，则将使用默认配置。

   声明：本博客参考微信公众号：狂神说。
   不喜勿喷，谢谢，本博客只是希望给大家一个参考，希望能帮助到需要的人。