mybatis笔记

1.简介

1.1 什么是 MyBatis

• MyBatis 是一款优秀的持久层框架
• 它支持自定义 SQL、存储过程以及高级映射
• MyBatis免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
• MyBatis可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录

1.2 如何获得mabatis

• mybatis中文文档地址：https://mybatis.org/mybatis-3/zh/getting-started.html

• Github官网

• maven仓库：

  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>x.x.x</version>
  </dependency>
  

1.3 什么是持久化

数据持久化

• 持久化就是将程序得数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库（jdbc）,io文件持久化

1.4 持久层

Dao层，Service层，Controlter层…

• 完成持久化工作的得代码块
• 层界限十分明显

1.5 为什么需要mybatis

• 方便
• 传统得JDBC代码太复杂了，简单，框架，自动化
• 帮程序员将数据存入到数据库中
• 不用mybatis也可以，更容易上手，技术没有高低之分
• 使用的人多

---

2. 第一个mabatis程序

思路：搭建环境->导入mybatis->编写代码-> 测试

2.1 搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user`(
	`id` INT(20) NOT NULL PRIMARY KEY,
	`name` VARCHAR(30) DEFAULT NULL,
	`pwd` VARCHAR(30) DEFAULT NULL	
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'狂神','123456'),
(2,'张三','123456'),
(3,'李四','123456')

新建项目

• 新建一个普通的maven项目

• 删除src目录

• 导入maven依赖

  <!--导入依赖-->
      <dependencies>
  
          <!--mysql驱动包-->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>5.1.35</version>
          </dependency>
  
          <!--mybatis-->
          <dependency>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
              <version>3.5.2</version>
          </dependency>
  
          <!--junit-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
          </dependency>
  
      </dependencies>
  

  <!--防止资源导出失败-->
      <build>
          <resources>
              <resource>
                  <directory>src/main/resources</directory>
                  <includes>
                      <include>**/*.properties</include>
                      <include>**/*.xml</include>
                  </includes>
                  <filtering>true</filtering>
              </resource>
              <resource>
                  <directory>src/main/java</directory>
                  <includes>
                      <include>**/*.properties</include>
                      <include>**/*.xml</include>
                  </includes>
                  <filtering>true</filtering>
              </resource>
          </resources>
      </build>
  

2.2 创建一个模块

• 编写mybatis的核心配置文件

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE configuration
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-config.dtd">
  
  <!--configuration核心配置文件-->
  <configuration>
      <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?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                  <property name="username" value="root"/>
                  <property name="password" value="root"/>
              </dataSource>
          </environment>
      </environments>
      
       <mappers>
          <mapper resource="org/mybatis/example/BlogMapper.xml"/>
      </mappers>
  
  </configuration>
  

• 编写mybatis工具类

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fZ7ajNRH-1618478143667)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1618204455573.png)]

  import org.apache.ibatis.io.Resources;
  import org.apache.ibatis.session.SqlSession;
  import org.apache.ibatis.session.SqlSessionFactory;
  import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  
  import java.io.InputStream;
  import java.io.*;
  
  public class MybatisUtils {
      private static SqlSessionFactory sqlSessionFactory;
  
      static {
          try{
              //获取SqlSessionFactory对象
              String resource = "mybatis-config.xml";
              InputStream inputStream = Resources.getResourceAsStream(resource);
              sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          }catch (Exception e){
              e.printStackTrace();
          }
      }
      //既然有了 SqlSessionFactory，可以从中获得 SqlSession 的实例。
      // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
      // 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句
      public static SqlSession getSqlSession(){
          return sqlSessionFactory.openSession();
      }
  }
  

2.3 编写代码

• 实体类

  public class user {
      private int id;
      private String name;
      private String pwd;
  
      public int getId() {
          return id;
      }
      public void setId(int id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public String getPwd() {
          return pwd;
      }
      public void setPwd(String pwd) {
          this.pwd = pwd;
      }
  
      public user() {
      }
      public user(int id, String name, String pwd) {
          this.id = id;
          this.name = name;
          this.pwd = pwd;
      }
  
  }
  

• Dao接口

  import com.kuang.pojo.User;
  
  import java.util.List;
  
  public interface UserDao {
      List<User> getUserList();
  }
  

• 接口实现类

• 由原来的实现类UserDaoImpl转变为Mapper配置文件

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <!--namespace绑定一个对应的Mapper接口-->
  <mapper namespace="com.kuang.dao.UserDao">
      <!--相当于用jdbc实现了这个接口 : getUserList-->
      <!--用标签相当于连接数据库等语句-->
     <select id="getUserList" resultType="com.kuang.pojo.User">
         SELECT * FROM user;
     </select>
  </mapper>
  
  

2.4 测试

• 在项目开发过程中，项目开发的包一般与测试的包一一对应

• 注意点：

  org.apache.ibatis.binding.BindingException: Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.

  <!--每一个Mapper.xml都需要mybatis核心配置文件注册-->
  <mappers>
          <mapper resource="com/kuang/dao/UserDao/UserMapper.xml"/>
      </mappers>
  
  

• 测试代码

   @Test
  public void test(){
          //第一步：获得sqlSession对象
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          
          try {
              //第二步：执行SQL(方式一)
              UserDao userDao = sqlSession.getMapper(UserDao.class);
              List<User> userList = userDao.getUserList();
  
              for (User user : userList) {
                  System.out.println(user.toString());
              }
          }catch(Exception e){
              e.printStackTrace();
          }finally {
  
              //关闭sqlSession
              sqlSession.close();
          }
      }
  
  
  

可能会遇到的问题：

• 配置文件没有注册

• 绑定接口错误

• 方法名不对

• 返回类型不对

• 路径书写不对

• maven导出资源问题

• 建立一个mybatis项目的所有文件

2.5 了解

命名解析：

• 为了减少输入量，MyBatis 对所有具有名称的配置元素（包括语句，结果映射，缓存等）使用了如下的命名解析规则。
• 全限定名（比如 “com.mypackage.MyMapper.selectAllThings）将被直接用于查找及使用 。
• 短名称（比如 “selectAllThings”）如果全局唯一也可以作为一个单独的引用。

对象生命周期和依赖注入框架 ：

• 依赖注入框架可以创建线程安全的、基于事务的 SqlSession 和映射器，并将它们直接注入到你的 bean 中，因此可以直接忽略它们的生命周期。

mybatis三个重要的对象：

• SqlSessionFactoryBuilder

  • 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了

• SqlSessionFactory

  • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。

• SqlSession

  • 每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
  • 每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。

---

3.CRUD

3.1 一些问题

namespace

• namespace中的包名要和Dao/mapper接口的包名一致

3.2 select

• 选择，查询语句
• id：就是对应的namespace中的方法名
• resultType：Sql语句执行的返回值
• paramterType：参数类型

​ 1.编写接口

//根据id查询用户
    User getUserById(int id);

​ 2.编写对应的mapper中的sql语句

 <!--方法名，参数类型，返回值类型-->
    <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
        SELECT * FROM user WHERE id=#{id}
    </select>

​ 3.测试

 @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User userById = userDao.getUserById(1);
        System.out.println(userById);

        sqlSession.close();
    }

3.2 分析错误

• 标签不要匹配错
• resource绑定mapper，需要使用路径
• 数据库连接错误
• 程序配置文件必须符合规范
• 空指针异常
• 中文乱码问题，可能和环境问题有关
• maven资源没有导出问题

3.3 万能Map

• 假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map

//利用map 
int addUser2(Map<String,Object>map);

<insert id="addUser2" parameterType="map">
        INSERT INTO USER (id,name,pwd) VALUES {#{userid},#{username},#{userpwd}}
    </insert>

  @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        Map<String, Object> stringObjectHashMap = (Map)new HashMap<String, Object>();
        stringObjectHashMap.put("userid",5);
        stringObjectHashMap.put("username",5);
        stringObjectHashMap.put("passWord",5);

        userDao.addUser2(stringObjectHashMap);
        System.out.println();

        sqlSession.close();

Map传递参数，直接在sql中取出key即可

对象传递参数，直接在SQL中取对象的属性即可

只有一个基本数据类型参数的情况下，可以直接在sql中取出

多个参数用Map或者注解

3.4 模糊查询怎么写

• java在执行代码的时候，传递通配符%
• 在sql拼接中使用通配符

---

4. 配置解析

4.1 核心配置文件

4.2 环境变量（environments）

• MyBatis 可以配置成适应多种环境
• 尽管可以配置多个环境，但每个 SqlSessionFactory实例只能选择一种环境
• MyBatis 中默认的事务管理器是jdbc，连接池是POOLED
• 学会使用配置多套运行环境

4.3 属性（properties）

• 我们可以通过properties属性来实现引用配置文件

• 这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。 【db.properties】

• 编写一个数据库配置文件

  db.properties

  driver=com.mysql.jdbc.Driver
  url=jdbc:mysql://localhost:3306/mybatis
  useSSL=true&useUnicode=true&characterEncoding=UTF-8
  username=root
  password=root
  
  

• 在核心配置文件中引入

  • 在配置文件中引入配置是有可能有顺序的
  • 两个文件有同一个字段，优先使用外部配置文件
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置

  <properties resource="org/mybatis/example/config.properties">
    <property name="username" value="dev_user"/>
    <property name="password" value="F2Fa3!33TYyg"/>
  </properties>
  
  

• 引入配置

   <environments default="development">
          <environment id="development">
              <transactionManager type="JDBC"/>
              <dataSource type="POOLED">
                  <property name="driver" value="${driver}"/>
                  <property name="url" value="${url}"/>
                  <property name="username" value="${username}"/>
                  <property name="password" value="${password}"/>
              </dataSource>
          </environment>
      </environments>
  
  

4.4 类型别名（typeAliases）

• 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置

• 意在降低冗余的全限定类名书写

  <!--可以给实体类起别名--><typeAliases>    <typeAlias type="com.kuang.pojo.User" alias="User"/></typeAliases>
  
  

• 也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

• 类名的小写为别名

  <!--可以给实体类起别名--><typeAliases>    <package name="com.kuang.pojo"/></typeAliases>
  
  

• 在实体类比较少的时候，使用第一种

• 在实体类比较多的时候，使用第二种

• 第一种可以起DIY别名，第二种只能用默认名，但是可以通过注解起别名

  @Alias("user")
  public class user(){}
  
  

4.5 设置（settings）

• 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为

4.6 映射器

• MapperRegistry：注册绑定我们的Mapper文件
• 方式一（推荐）：

<!--每一个Mapper.xml文件都需要在mybatis核心配置文件中注册-->
<mappers>    <mapper resource="com/kuang/dao/UserMapper.xml"/></mappers>

• 方式二：使用class文件绑定注册
• mybatis-config.xml必须要注册在resources下

<!--每一个Mapper.xml文件都需要在mybatis核心配置文件中注册-->
<mappers>    <mapper class="com.kuang.dao.UserMapper"/></mappers>

• 注意点：

  • 接口和他的Mapper配置文件必须同名
  • 接口和他的Mapper配置文件必须在同一包下

• 方式三：

• <!--每一个Mapper.xml文件都需要在mybatis核心配置文件中注册-->
  <mappers>    <mapper class="com.kuang.dao.UserMapper"/></mappers>
  
  

• 注意点：

  • 接口和他的Mapper配置文件必须同名
  • 接口和他的Mapper配置文件必须在同一包下

4.7 生命周期和作用域

• 生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题

SqlSessionFactoryBuilder：

• 一旦创建了 SqlSessionFactory，就不再需要它了。
• 局部变量

SqlSessionFactory：

• 说白了就是数据库连接池
• 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• SqlSessionFactory 的最佳作用域是应用作用域
• 最简单的就是使用单例模式或者静态单例模式

SqlSession：

• 连接到连接池的一个请求

• SqlSession的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域

• 用完之后要关闭，否则资源被占用

• 每一个Mapper代表一个业务

---

5. 解决属性名和字段名不一致的问题

5.1 解决方法

• 实体类的属性名和mybatis中表明中的属性名不一致

• 方法：

  • 起别名

5.2 resultMap

• 结果集映射(UserMapper.xml)

id name pwd //mybatis中表明中的属性名不一致
id name password//实体类的属性名

<!--结果集映射-->
<resultMap id="UserMap" type="User">
	<result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap">
	select * from user where id = #{id}
</select>

• resultMap元素是mybatis中最重要最强大的元素
• ResultMap的设计思想是，对于简单的语句根本不需要配置显示的结果映射，而对于复杂一点的语句只要描述他们之间的关系就行了
• 可以不显示的用他们
• 也可以之映射不一样的地方，一样的地方并不需要改变

---

6. 日志

6.1 日志工厂

• 如果数据库操作出现了异常，我们需要排错，日志就是最好的助手

• 曾经：sout，debug

• 现在日志工厂

• SLF4J

• LOG4J 【掌握】

• LOG4J2

• JDK_LOGGING

• COMMONS_LOGGING

• STDOUT_LOGGING 【掌握】

• NO_LOGGING

在mybatis中的具体使用哪一个日志实现，在设置中设定！

STDOUT_LOGGING 标准日志输出

• 在mybatis核心配置文件中，配置我们的日志

   <!--设置日志文件-->
      <settings>
          <setting name="logImpl" value="STDOUT_LOGGING"/>
      </settings>
  
  

6.2 LOG4J

• LOG4J 是Apach的一个开源项目，通过使用LOG4J ，我们可以控制日志输出信息输出到控制台，文件，GUI组件

• 我们也可以控制输出格式

• 可以设置每一条日志信息的级别

• 通过配置文件来进行配置，不需要修改代码

• 先导入LOG4J 的包

      <dependencies>
          <dependency>
              <groupId>log4j</groupId>
              <artifactId>log4j</artifactId>
              <version>1.2.17</version>
          </dependency>
      </dependencies>
  
  

• log4j.properties

### set log levels ###
log4j.rootLogger=DEBUG,console,file,INFO, stdout, log, error
log4j.Logger=search,Test  

### console ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [qh_cloud][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### log file ###
log4j.appender.log = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.log.File = ${catalina.base}/logs/qh_cloud_info.log  
log4j.appender.log.Append = true  
log4j.appender.log.Threshold = INFO  
log4j.appender.log.DatePattern='.'yyyy-MM-dd  
log4j.appender.log.layout = org.apache.log4j.PatternLayout  
log4j.appender.log.layout.ConversionPattern = [qh_cloud][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### exception ###
log4j.appender.error = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.error.File = ${catalina.base}/logs/qh_cloud_error.log  
log4j.appender.error.Append = true  
log4j.appender.error.Threshold = ERROR   
log4j.appender.error.DatePattern='.'yyyy-MM-dd  
log4j.appender.error.layout = org.apache.log4j.PatternLayout  
log4j.appender.error.layout.ConversionPattern = [qh_cloud][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

• 配置log4j的日志文件的实现

<!--设置日志文件-->
    <settings>
        <!--<setting name="logImpl" value="STDOUT_LOGGING"/>-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

• log4j的测试查询

• 简单使用

  • 导包

    import org.apache.log4j.Logger;
    
    

  • 创建Logger的对象

    static Logger logger = Logger.getLogger(UserDaoTest.class);
    
    

  • 测试

    @Test
    public void test1(){
        	//日志级别
            logger.info("info:进入了方法");
            logger.debug("Dubge");
            logger.error("error");
        }
    
    

  • 输出到控制台

7.分页

7.1 使用Limit分页

• 分页会使数据的处理量减少

• 使用Limit分页

  语法：
  SELECT * FROM user LIMIT startIndex,pageSize;
  
  

• 使用Mybatis实现分页，核心就是Sql

  • 接口

      //分页
        List<User> getUserByLimit(Map<String,Integer> map);
    
    

  • Mapper.xml

       <!--分页查询-->
        <select id="getUserByLimit" parameterType="map" resultType="user">
            SELECT * FROM user limit #{startIndex},#{pageSize}
        </select>
    
    
    

  • 测试

     @Test
        public void test2(){
    
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            UserMapperDao mapper = sqlSession.getMapper(UserMapperDao.class);
    
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            map.put("startIndex",0);
            map.put("pageSize",2);
    
            List<User> userByLimit = mapper.getUserByLimit(map);
            for (User user : userByLimit) {
                System.out.println(user);
            }
            sqlSession.close();
        }
    
    

7.2 RowBounds分页

• 使用面向对象的思想去实现分页

• 不建议使用，没有sql语句实现的快

• 接口

    //分页
      List<User> getUserByRowBounds(Map<String,Integer> map);
  
  

• mapper.xml

   <!--分页查询-->
      <select id="getUserByRowBounds"  resultType="user">
          SELECT * FROM user
      </select>
  
  

• 测试

  @Test
      public void test2(){
  
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          
         //RowBounds实现
          RowBounds rowBounds = new RowBounds(1,2);
  
          //通过java代码层面实现分页
     List<User> user = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);
          
          for (User user : userByLimit) {
              System.out.println(user);
          }
          
          sqlSession.close();
      }
  
  

7.3 分页插件

8. 使用注解开发

8.1面向接口编程

• 在企业开发的时候，多是面向接口编程
• 很大原因是为了解耦，可扩展，提高复用，在分层开发中上层不管用什么具体的实现，大家都遵守共同的标准，是的更加的简单，规范性更好

关于接口的理解

• 接口从更深层次的理解，应是定义（规范约束）与实现的分离

• 反应系统设计人员对系统抽象的理解

  接口有两个方面：

  • 抽象体
  • 抽象面

8.2 使用注解开发

• 注解在接口上实现

   //查询
      @Select("select * from user")
      List<User> getUserList();
  
  

• 需要在配置文件中绑定接口

  <!--绑定接口-->
  <mappers>
          <mapper class="com.kuang.dao.UserMapperDao"/>
      </mappers>
  
  
  

• 测试（像原来的代码一样就行了）

  本质：反射机制实现

  底层：动态代理

8.3 mybatis详细的执行流程

​

8.4 CRUD

• 在工具类创建的时候实现自动提交事务

  public static sqlSession getSqlSession(){
      return sqlSessionFactory.openSession(true);
  }
  
  

• 编写接口，增加注解

• 测试

  • 我们必须要将接口注册绑定到我们的核心配置文件中

关于@Parameter()注解

• 基本数据类型的参数或者String类型都要加上
• 引用类型不需要加
• 如果只有一个基本类型，可以不写，但是建议写
• 我们在sql中引用的就是我们这里的@Parameter()中设定的属性名

#{}，${}

• #{}很大程度上可以防止sql注入，安全
• #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
• $将传入的数据直接显示生成在sql中
• $方式无法防止Sql注入
• 一般能用#的就别用$

---

9. Lombok

不需要在实体类中写get(),set()等方法

• 在idea中安装Lombok插件

• 在项目中导入Lombok的jar包

  <dependency>
      <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <version>1.18.10</version>
  </dependency>
  
  

• 在实体类上面增加注解

  @Data：无参构造，get，set。tostring,hashcode,equals 
  @AllArgsConstructor
  @NoArgsConstructor
  @EqualsAndHashCode
  @toString
  @getter
  @setter
  
  

---

10. 多对一处理

多对一【关联】

一对多【集合】

10.1 测试环境搭建

• 导入lombok
• 新建实体类Teacher，Student
• 建立Mapper接口
• 建立Mapper.xml文件（相当于Mapper接口的实现类）
• 在核心配置文件中绑定注册Mapper接口或者文件
• 测试

10.2 按照查询嵌套处理

<!--
思路：
	查询所有的学生信息
	根据查询出来的学生的tid，寻找对应的老师 子查询
-->

<select id="getStudent" resultMap="StudnetTeacher">
        SELECT * FROM student
    </select>

<!--重点-->
<resultMap id="studentTeacher" type="Student">
    <result property="id" column="id"/>
	<result property="name" column="name"/>
    <!--复杂的属性我们需要单独处理  对象：association  集合：collection-->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
    
<select id="getTeacher" resultType="Teacher">
        SELECT * FROM teacher where id = #{id}
    </select>

10.3 按照结果嵌套处理

<!--按照结果嵌套处理-->
<select id="getStudnet" resultType="Student">
        SELECT s.id sid,s.name sname,t.name tname
    	from student s,teacher t
    	where s.tid = t.id;
    </select>

<resultMap id="studentTeacher2" type="Student">
    <result property="id" column="sid"/>
	<result property="name" column="sname"/>
	<association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association> 
</resultMap>

回顾Mysql多对一查询方式：

• 子查询
• 联表查询

11.一对多处理

11.1 环境搭建

• 实体类

  @Data
  public class Student{
      private int id;
      private String name;
      private int tid;
  }
  
  

  @Data
  public class Teacher{
      private int id;
      private String name;
      //一个老师有多个学生
      private List<Student> students;
  }
  
  

11.2 按照结果嵌套处理

<!--按照结果嵌套处理-->
<select id="getTeacher" resultType="TeacherStudent">
        SELECT s.id sid,s.name sname,t.name tname
    	from student s,teacher t
    	where s.tid = t.id and t.id = #{tid};
    </select>

<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
	<result property="name" column="tname"/>
    
    <!--复杂的属性我们需要单独处理  对象：association  集合：collection

javaType="" 指定的属性类型
集合中的泛型信息，我们使用ofType获取
-->
	<collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection> 
</resultMap>

11.3 按照查询嵌套处理

<!--
思路：
	查询所有的老师信息
	根据查询出来的老师的tid，寻找对应的学生 子查询
-->

<select id="getTeacher2" resultMap="TeacherStudnet">
        SELECT * FROM teacher where id=#{tid}
    </select>

<!--重点-->
<resultMap id="TeacherStudent" type="Teacher">
   <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>
    
<select id="getStudentByTeacherId" resultType="Student">
        SELECT * FROM student where id = #{tid}
    </select>

11.4 小结

• javaType&ofType

  • javaType用来指定实体类中属性的类型
  • ofType用来指定映射到List或者集合中的pojo类型，就是泛型中的约束类型

• 多对一【关联】 assocation

  一对多【集合】 collection

• 注意点：

  • 保证Sql的可读性
  • 注意一对多和多对一中，属性名和字段名的问题
  • 建议使用log4j进行排错

---

12 动态SQL

12.1 动态SQL

• 什么是动态SQL：根据不同的条件生成不同的SQL语句

用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

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

### 12.2 搭建环境

```sql
CREATE TABLE `blog` (
  `id` varchar(50) NOT NULL COMMENT '博客id',
  `title` varchar(100) NOT NULL COMMENT '博客标题',
  `author` varchar(30) NOT NULL COMMENT '博客作者',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8

创建一个基础工程

• 导包

• 编写配置文件

  <insert id="addBlog" parameterType="blog">
      insert into blog (id, title, author, create_time, views)
      values (#{id},#{title},#{author},#{createTime},#{views});
  </insert>
  
  

• 编写实体类

  import java.util.Date;
   
  public class Blog {
   
      private String id;
      private String title;
      private String author;
      private Date createTime;
      private int views;
      //set，get....
  }
  
  

• 编写实体类对应的Mapper接口和Mapper。xml文件

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.kuang.mapper.BlogMapper">
   
  </mapper>
  
  

  public interface BlogMapper {
  }
  
  

• 初始化

  @Test
  public void addInitBlog(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      Blog blog = new Blog();
      blog.setId(IDUtil.genId());
      blog.setTitle("Mybatis如此简单");
      blog.setAuthor("狂神说");
      blog.setCreateTime(new Date());
      blog.setViews(9999);
   
      mapper.addBlog(blog);
   
      blog.setId(IDUtil.genId());
      blog.setTitle("Java如此简单");
      mapper.addBlog(blog);
   
      blog.setId(IDUtil.genId());
      blog.setTitle("Spring如此简单");
      mapper.addBlog(blog);
   
      blog.setId(IDUtil.genId());
      blog.setTitle("微服务如此简单");
      mapper.addBlog(blog);
   
      session.close();
  }
  
  

• 编写接口类

  //需求1
  List<Blog> queryBlogIf(Map map);
  
  

• 编写SQL语句

  <!--需求1：
  根据作者名字和博客名字来查询博客！
  如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
  select * from blog where title = #{title} and author = #{author}
  -->
  <select id="queryBlogIf" parameterType="map" resultType="blog">
      select * from blog where
      
      <!--动态SQL的if判断语句-->
      <if test="title != null">
          title = #{title}
      </if>
      <if test="author != null">
          and author = #{author}
      </if>
  </select>
  
  

• 测试

  @Test
  public void testQueryBlogIf(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      HashMap<String, String> map = new HashMap<String, String>();
      map.put("title","Mybatis如此简单");
      map.put("author","狂神说");
      List<Blog> blogs = mapper.queryBlogIf(map);
   
      System.out.println(blogs);
   
      session.close();
  }
  
  

12.3 if语句（模糊查询）

• select * from blog where
   
   <!--动态SQL的if判断语句-->
   <if test="title != null">
       title = #{title}
   </if>
   <if test="author != null">
       and author = #{author}
   </if>
  </select>
  
  

12.4 choose (when, otherwise)

• <!--choose相当于java中的switch语句-->
  
  <select id="queryBlogChoose" parameterType="map" resultType="blog">
      select * from blog
      <where>
          
          
          <choose>
              <when test="title != null">
                   title = #{title}
              </when>
              <when test="author != null">
                  and author = #{author}
              </when>
              <otherwise>
                  and views = #{views}
              </otherwise>
          </choose>
          
          
      </where>
  </select>
  
  

• 测试

• @Test
  public void testQueryBlogChoose(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      HashMap<String, Object> map = new HashMap<String, Object>();
      map.put("title","Java如此简单");
      map.put("author","狂神说");
      map.put("views",9999);
      List<Blog> blogs = mapper.queryBlogChoose(map);
   
      System.out.println(blogs);
   
      session.close();
  }
  
  

12.5 where

• select * from blog 
  <!--有where的时候可以选择性的插入第一个if或第二个if，并且能够把and去掉-->
      <where>
      <!--动态SQL的if判断语句-->
      <if test="title != null">
          title = #{title}
      </if>
      <if test="author != null">
          and author = #{author}
      </if>
      <where>   
  </select>
  
  

12.6 set

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

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

• <!--注意set是用的逗号隔开-->
  <update id="updateBlog" parameterType="map">
      update blog
        <set>
            <if test="title != null">
                title = #{title}  ,
                <!--, 不要忘记-->
            </if>
            <if test="author != null">
                author = #{author}
            </if>
        </set>
      where id = #{id};
  </update>
  
  

• 测试

• @Test
  public void testUpdateBlog(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      HashMap<String, String> map = new HashMap<String, String>();
      map.put("title","动态SQL");
      map.put("author","秦疆");
      map.put("id","9d6a763f5e1347cebda43e2a32687a77");
   
      mapper.updateBlog(map);
   
   
      session.close();
  }
  
  

• 所谓动态SQL，本质上就是SQL语句，只不过在SQL语句上加了逻辑代码

12.7 foreach

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

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

• 编写SQL语句

• <select id="queryBlogForeach" parameterType="map" resultType="blog">
      select * from blog
      <where>
          <!--
          collection:指定输入对象中的集合属性
          item:每次遍历生成的对象
          open:开始遍历时的拼接字符串
          close:结束时拼接的字符串
          separator:遍历对象之间需要拼接的字符串
          select * from blog where 1=1 and (id=1 or id=2 or id=3)
        -->
          <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
              id=#{id}
          </foreach>
      </where>
  </select>
  
  

• 测试

• @Test
  public void testQueryBlogForeach(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      HashMap map = new HashMap();
      List<Integer> ids = new ArrayList<Integer>();
      ids.add(1);
      ids.add(2);
      ids.add(3);
      map.put("ids",ids);
   
      List<Blog> blogs = mapper.queryBlogForeach(map);
   
      System.out.println(blogs);
   
      session.close();
  }
  
  

12.8 SQL片段

• 有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用

• <!--, 抽取SQL片段-->
    
  <sql id="if-title-author">
      <if test="title != null">
          title = #{title}
      </if>
      <if test="author != null">
          and author = #{author}
      </if>
  </sql>
  
  

• <!--, 抽取SQL片段-->
    
  <select id="queryBlogIf" parameterType="map" resultType="blog">
      select * from blog
      <where>
          
          <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
          <include refid="if-title-author"></include>
          <!-- 在这里还可以引用其他的 sql 片段 -->
          
      </where>
  </select>
  
  

• 注意：

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

12.9 小结

• 其实动态 sql 语句的编写往往就是一个拼接的问题
• 为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错
• 动态SQL在开发中大量的使用，一定要熟练掌握！

---

13. 缓存

13.1 简介

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

13.2 Mybatis缓存

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

13.3 一级缓存

• 一级缓存也叫本地缓存：

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

• 测试

• 在mybatis中加入日志，方便测试结果

• 编写接口方法

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

• 接口对应的Mapper文件

  <select id="queryUserById" resultType="user">
      select * from user where id = #{id}
  </select>
  
  

• 测试

  @Test
  public void testQueryUserById(){
      SqlSession session = MybatisUtils.getSession();
      UserMapper mapper = session.getMapper(UserMapper.class);
   
      User user = mapper.queryUserById(1);
      System.out.println(user);
      User user2 = mapper.queryUserById(1);
      System.out.println(user2);
      System.out.println(user==user2);
   
      session.close();
  }
  
  

• 结果分析

• 

一级缓存失效的四种情况

• 一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；
• 一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

sqlSession不同

• @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);
      User user2 = mapper2.queryUserById(1);
      System.out.println(user2);
      System.out.println(user==user2);
   
      session.close();
      session2.close();
  }
  
  

• 观察结果：发现发送了两条SQL语句！

• 结论：每个sqlSession中的缓存相互独立

sqlSession相同，查询条件不同

• @Test
  public void testQueryUserById(){
      SqlSession session = MybatisUtils.getSession();
      UserMapper mapper = session.getMapper(UserMapper.class);
      UserMapper mapper2 = session.getMapper(UserMapper.class);
   
      User user = mapper.queryUserById(1);
      System.out.println(user);
      User user2 = mapper2.queryUserById(2);
      System.out.println(user2);
      System.out.println(user==user2);
   
      session.close();
  }
  
  

• 观察结果：发现发送了两条SQL语句！很正常的理解

• 结论：当前缓存中，不存在这个数据

sqlSession相同，两次查询之间执行了增删改操作！

• 增加方法

• //修改用户
  int updateUser(Map map);
  
  

• 编写SQL

• <update id="updateUser" parameterType="map">
      update user set name = #{name} where id = #{id}
  </update>
  
  

• 测试

• @Test
  public void testQueryUserById(){
      SqlSession session = MybatisUtils.getSession();
      UserMapper mapper = session.getMapper(UserMapper.class);
   
      User user = mapper.queryUserById(1);
      System.out.println(user);
   
      HashMap map = new HashMap();
      map.put("name","kuangshen");
      map.put("id",4);
      mapper.updateUser(map);
   
      User user2 = mapper.queryUserById(1);
      System.out.println(user2);
   
      System.out.println(user==user2);
   
      session.close();
  }
  
  

• 观察结果：查询在中间执行了增删改操作后，重新执行了

• 结论：因为增删改操作可能会对当前数据产生影响

sqlSession相同，手动清除一级缓存

• @Test
  public void testQueryUserById(){
      SqlSession session = MybatisUtils.getSession();
      UserMapper mapper = session.getMapper(UserMapper.class);
   
      User user = mapper.queryUserById(1);
      System.out.println(user);
   
      session.clearCache();//手动清除缓存
   
      User user2 = mapper.queryUserById(1);
      System.out.println(user2);
   
      System.out.println(user==user2);
   
      session.close();
  }
  
  

• 一级缓存就是一个map

• 一级缓存是默认开始的，只在一次SqlSession中有效

13.4 二级缓存

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

使用步骤

• 开启全局缓存 【mybatis-config.xml】

• cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false

• <setting name="cacheEnabled" value="true"/>
  
  

• 去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】

•  
  <!--官方示例=====>查看官方文档-->
  <cache
    eviction="FIFO"
    flushInterval="60000"
    size="512"
    readOnly="true"/>
  
  这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。
  
  

• 代码测试

  • 所有的实体类先实现序列化接口

  • 所有的实体类先实现序列化接口

• 测试代码

• @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中的查询，可以在二级缓存中拿到数据
• 查出的数据都会被默认先放在一级缓存中
• 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

13.5 缓存原理

• 缓存原理图
• 

13.6 自定义缓存 EhCache

• 第三方缓存实现–EhCache: 查看百度百科

• Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；

• 要在应用程序中使用Ehcache，需要引入依赖的jar包

• <!-- 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.xml中使用对应的缓存即可

• <mapper namespace = “org.acme.FooMapper” > 
      <cache type = “org.mybatis.caches.ehcache.EhcacheCache” /> 
  </mapper>
  
  

• 编写ehcache.xml文件，如果在加载时未找到/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>
  
  

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

• redis缓存