MyBatis笔记

• maven仓库：

  
  
      org.mybatis
      mybatis
      3.5.9
  
  

• Github:https://github.com/mybatis/mybatis-3/releases

• mybatis中文文档：https://mybatis.org/mybatis-3/zh/index.html

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程

• 内存：断电即失

• 数据库(jdbc),io文件持久化。

• 生活中例子：冷藏，罐头……

为什么需要数据持久化？

- 有一些对象，绝对不能让它丢失
- 内存太贵了，

Dao层，Service层，Controler层

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

• 传统的JDBC代码太复杂了——简化——框架——自动化
• 帮助程序员将数据存入到数据库中
• 不用mybatis也可以，当学了之后，更容易上手。技术没有高低之分
• 优点：

最重要的一点：使用的人多

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

• 搭建数据库

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,'张三','123121'),
(3,'李四','121216') 

• 新建项目

1. 新建一个普通的maven项目

2. 删除src目录，将其当作一个父工程

3. 导入maven依赖

   
       
   
           
               mysql
               mysql-connector-java
               8.0.28
           
   
           
               org.mybatis
               mybatis
               3.5.9
           
   
           
               junit
               junit
               4.12
           
       
   

• 编写mybatis的核心配置文件

• 编写mybatis的工具类

public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;
    static {
        //使用mybatis第一步获取sqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
       return sqlSessionFactory.openSession();
    }
}

• 实体类

public class User {
    private int id;
    private String name;
    private String pwd;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", pwd='" + 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(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public User() {
    }
}

• Dao接口

public interface UserDao {
    List getUserList();
}

• 接口实现类 — 由原来的UserDaoImpl改变为Mapper配置文件

    
        select * from mybatis.user
    

• junit测试

  public class UserDaoTest {
       @Test
      public void test(){
           //第一步：获得SqlSession的对象
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           //第二步：执行sql
           UserDao mapper = sqlSession.getMapper(UserDao.class);
           List userList = mapper.getUserList();
  
           for (User user : userList) {
               System.out.println(user);
           }
  
           //关闭sql
           sqlSession.close();
  
  
       }
  }
  

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

• MapperRegistry是什么

  在核心配置文件中注册mappers

• maven导出资源问题

  
      
          
              
                  src/main/resources
                  
                      ***.xml
                  
                  true
              
              
                  src/main/java
                  
                      ***.xml
                  
                  true
              
          
      
  

• 配置

  driver="com.mysql.cj.jdbc.Driver"
  url="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC"
  name="root"
  password="abc123"
  

• id：就是对应namespace 中的方法名
• resultType：sql语句执行的返回值
• parameterType：参数类型

1. 编写接口

   //查询全部用户
   List getUserList();
   

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

   
       select *
       from mybatis.user;
   
    
    
   测试
    
   @Test
   public void getUserList(){
        //第一步：获得SqlSession的对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //第二步：执行sql
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List userList = mapper.getUserList();
   
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sql
        sqlSession.close();
    }
    
    
   注意
    
   增删改需要提交事务：sqlSession.commit();
    
    
   3.1、分析错误 
   标签不要匹配错
   resource绑定mapper，需要使用路径
   程序配置文件必须使用规范
   NullPointerException,没有注册到资源
    
   3.2、万能的map 
   假设我们的实体类或者数据库中的表或字段，或者参数过多，我们应该考虑使用map
    
   int addUser2(Map map);
    
   
   
       insert into mybatis.user (id, pwd)
       values (#{userid},#{pwd});
   
    
   @Test
   public void addUser2(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
       Map map = new HashMap<>();
       map.put("userid",5);
       map.put("pwd","12121212");
   
       mapper.addUser2(map);
       //增删改需要提交事务
       //提交事务
       sqlSession.commit();
   
       sqlSession.close();
   }
    
   Map传递参数，直接在sql中取出key即可 【parameterType=“map”】
    
   **对象传递参数，直接在sql中取对象的属性即可 **【parameterType=“Object”】
    
   只有一个基本类型参数的情况下，可以直接在sql中渠道 【可以不写】
    
   多个参数用Map或者注解！
    
   3.3、思考题 
   模糊查询怎么写？
    
    
   Java代码执行的时候，传递通配符% %
    
   List userList = mapper.getUserLike("%李%");
    
    
   在sql拼接中使用通配符！
    
   select * from mybatis.user where name like"%"#{value}"%"
    
    
   4、配置解析 
   4.1、核心配置文件 
    
   mybatis-config.xml
    
    
   MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息
    
   configuration（配置）
   properties（属性）
   settings（设置）
   typeAliases（类型别名）
   typeHandlers（类型处理器）
   objectFactory（对象工厂）
   plugins（插件）
   environments（环境配置）
   environment（环境变量）
   transactionManager（事务管理器）
   dataSource（数据源）
   databaseIdProvider（数据库厂商标识）
   mappers（映射器）
    
    
   4.2、environments（环境配置） 
   MyBatis 可以配置成适应多种环境，不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
    
   学会使用配置多套运行环境
    
   MyBatis默认的事务管理器就是JDBC，连接池：POOLED
    
   4.3、properties（属性） 
   我们可以通过properties属性来实现引用配置文件
    
   这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】
    
    
    
   编写一个配置文件(注：配置文件中，应该使用&符号，不再需要分号)
    
   driver=com.mysql.cj.jdbc.Driver
   url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
   username=root
   password=abc123
    
    
   在核心配置文件中引入
    
   
   
       
       
   
    
    
   可以直接引入外部文件
   可以在其中增加一些属性配置
   如果两个文件有同一个字段，优先使用配置文件
    
   4.4、类型别名（typeAliases） 
   类型别名可为 Java 类型设置一个缩写名字。
   它仅用于 XML 配置，意在降低冗余的全限定类名书写。
    
   
   
       
   
    
   也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，
    
   扫描实体类的包，默认别名就为这个类的类名，首字母建议小写，这样就能看出是扫描包的！(大写也可以)
    
   
    
   在实体类比较少的时候使用第一种，反之使用第二种。
    
   第一种可以diy别名；第二种不行，如果非改不行，需要在实体类上增加注解
    
   @Alias("user")
   public class User {}
    
   4.5、settings（设置） 
   设置名
   描述
   有效值
   默认值
   cacheEnabled
   全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。
   true|false
   true
   lazyLoadingEnabled
   延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。
   true|false
   false
   4.6、其它配置 
   typeHandlers（类型处理器）
   objectFactory（对象工厂）
   plugins（插件） 
     
   mybatis-generator-core
   mybatis-plus
   通用mapper
    
    
   4.7、mappers（映射器） 
   MapperRegistry：注册绑定我们的mapper文件；
    
    
   方式一：推荐使用
    
   
   
       
   
    
   方式二：使用class文件绑定注册
    
   
   
       
   
    
   注意点：
    
   接口和它的Mapper配置文件必须同名
   接口和它的Mapper配置文件必须在同一个包下
    
   方式三：使用扫描包进行注入绑定
    
   
   
   	
   
    
   4.8、生命周期和作用域 
    
   生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。
    
   SqlSessionFactoryBuilder：
    
    
   一旦创建了 SqlSessionFactory，就不再需要它了
    
    
   局部变量
    
    
   SqlSessionFactory:
    
   说白了这个实际上就是数据库连接池
   SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
   因此 SqlSessionFactory 的最佳作用域是应用作用域
   最简单的就是使用单例模式或者静态单例模式。
    
   SqlSession：
    
   连接到数据库连接池的一个请求
   SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
   用完之后必须赶紧关闭，否则资源会被占用——相当于数据库连接池资源一直被它占用
    
    
   这里面的每一个Mapper，就代表一个具体的业务
    
   5、解决属性名和字段名不一致的问题 
   5.1、问题 
   数据库中的字段：
    
    
   新建一个项目，拷贝之前的，测试实体类字段不一致的情况：
    
   public class User {
       private int id;
       private String name;
       private String password;
   }
    
   测试出现问题
    
    
   select * from mybatis.user where id = #{id}
   //类型处理器
   select id,name,pwd from mybatis.user where id = #{id}
    
   解决方法：
    
    
   起别名：
    
   
       select *,pwd `password` from mybatis.user where id = #{id}
   
    
    
   5.2、resultMap 
   结果集映射
    
   
   
   
        
       
       
   
   
   
       select * from mybatis.user where id = #{id}
   
   

   • resultMap 元素是 MyBatis 中最重要最强大的元素。
   • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
   • 在学习了上面的知识后，你会发现上面的例子没有一个需要显式配置 ResultMap，这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。
   • 如果这个世界总是这么简单就好了。
   6、日志 6.1、日志工厂

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

   曾经：sout、debug

   现在：日志工厂

   设置名	描述	有效值	默认值
   logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置

   • SLF4J
   • **LOG4J **【掌握】
   • LOG4J2
   • JDK_LOGGING
   • COMMONS_LOGGING
   • **STDOUT_LOGGING ** 【掌握】
   • NO_LOGGING

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

   STDOUT_LOGGING标准日志输出

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

   6.2、LOG4J

   什么是Log4j

   • Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件;
   • 我们也可以控制每一条日志的输出格式；
   • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程;
   • 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

   1. 先导入LOG4J的包

      
      
          log4j
          log4j
          1.2.17
      
      

   2. log4j.properties

      #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
      log4j.rootLogger=DEBUG,console,file
      
      # 控制台输出的相关设置
      log4j.appender.console=org.apache.log4j.ConsoleAppender
      log4j.appender.console.Target=System.out
      log4j.appender.console.Threshold=DEBUG
      log4j.appender.console.layout=org.apache.log4j.PatternLayout
      log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
      
      # 文件输出的相关设置
      log4j.appender.file=org.apache.log4j.RollingFileAppender
      log4j.appender.file.File=./log/bei.log
      log4j.appender.file.MaxFileSize=10mb
      log4j.appender.file.Threshold=DEBUG
      log4j.appender.file.layout=org.apache.log4j.PatternLayout
      log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
      
      #日志输出级别
      log4j.logger.org.mybatis=DEBUG
      log4j.logger.java.sql=DEBUG
      log4j.logger.java.sql.Statement=DEBUG
      log4j.logger.java.sql.ResultSet=DEBUG
      log4j.logger.java.sql.PreparedStatement=DEBUG
      

   3. 配置log4j为日志的实现

   4. LOG4J的使用 — 直接测试运行刚才的查询

   简单使用

   1. 在要使用的log4j的类中，导入包org.apache.log4j.Logger;

   2. 日志对象，参数为当前类的class

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

   3. 日志级别

      logger.info("info:进入了testLog4j方法");
      logger.debug("debug:进入了testLog4j方法");
      logger.error("error:进入了testLog4j方法");
      

   7、分页

   思考：为什么需要分页？

   • 减少数据的处理量
   7.1、使用Limit分页

   语法

   select * from user limit startIndex,pageSize;
   select * from user limit 3;  #[0,,n]
   

   使用MyBatis实现分页，核心Sql

   1. 接口

      //分页
      List getUserByLimit(Map map);
      

   2. Mapper.xml

      
      
          
          
      
      
          select *
          from mybatis.user limit #{startIndex},#{pageSize};
      
      

   3. 测试

      @Test
      public void getUserByLimit(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          UserMapper mapper = sqlSession.getMapper(UserMapper.class);
          Map map = new HashMap<>();
          map.put("startIndex",1);
          map.put("pageSize",2);
      
          List userList = mapper.getUserByLimit(map);
          for (User user : userList) {
              System.out.println(user);
          }
          sqlSession.close();
      }
      

   7.2、RowBounds分页

   不再使用sql实现分页

   1. 接口

      //分页2
      List getUserByRowBounds();
      

   2. Mapper.xml

      
          select *
          from mybatis.user
      
       
       
      测试
       
      @Test
      public void getUserByRowBounds(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          //通过RoeBounds实现
          RowBounds rowBounds = new RowBounds(1, 2);
      
          //通过Java代码实现分页
          List userList = sqlSession.selectList("com.bei.dao.UserMapper.getUserByRowBounds",null,rowBounds);
          for (User user : userList) {
              System.out.println(user);
          }
      
          sqlSession.close();
      }
       
       
      7.3、分页插件 
      https://pagehelper.github.io/
       
       
      了解即可，万一以后公司的架构师说，要使用它，你需要知道它是什么东西！
       
      8、使用注解开发 
      8.1、面向接口编程 
      大家之前都学过面向对象编程，也学过接口，但在真正的开发中，很多时候我们都会选择面向接口编程
      根本原因：解耦；可拓展；提高复用；分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好
      在一个面向对象的系统中，系统的各种功能是由许多的不同对象协作完成的，在这种情况下，各个对象的内部是如何实现自己的，对系统设计人员来讲就不那么重要了；
      而各个对象之间的协作关系则成为系统设计的关键。笑道不同类之间的通信，达到各模块之间的交互，在系统设计之初都是要着重考虑的，这也还是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程
       
      关于接口的理解
       
      接口从更深层次的理解，应该是定义（规范、约束）与实现（名实分离的原则）的分离
      接口的本身反映了设计人员对系统的抽象理解。
      接口应有两类： 
        
      对一个个体的抽象，它可对应为一个抽象体（abstract class）；
      对一个个体某一方面的抽象，即形成一个抽象面（interface）；
       
      一个个体可能有多个抽象面。抽象体与抽象面是有区别的。
       
      三个面向区别
       
      面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。
      面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现。
      接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现在对系统整体的架构。
       
      8.2、使用注解开发 
       
      注解在接口上实现
       
      @Select("select * from user")
       
       
      需要在核心配置文件中绑定接口
       
      
      
          
      
       
       
      测试
       
       
      本质：反射机制实现
       
      底层：使用动态代理
       
      8.3、CRUD 
      我们可以在工具类创建的时候实现自动提交事务
       
      public static SqlSession getSqlSession(){
         return sqlSessionFactory.openSession(true);
      }
       
      编写接口
       
      public interface UserMapper {
      
          @Select("select * from user")
          List getUsers();
      
          //方法存在多个参数，所有的参数前面必须加上@Param("id")注解
          @Select("select * from user where id = #{id}")
          User getUserById(@Param("id") int id);
      
          @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")
          int insert(User user);
      
          @Update("update user set name = #{name},pwd = #{password} where id = #{id}")
          int update(User user);
      
          @Delete("delete from user where id = #{id}")
          int del(@Param("id") int qid);
      }
       
      测试类
       
      【注意：】我们必须要将接口注册绑定到我们的核心配置文件中
       
      
      
          
      
       
      关于@Param(“id”)注解
       
      基本类型的参数或者String类型，需要加上这个注解
      引用类型不用加
      如果只有一个基本类型，可以省去，但是建议大家都加上
      我们在SQL中引用的就是我们这里的@Param(“uid”)中设定的uid属性名
       
      mybatis执行流程
       
      //resource获取加载全局配置文件
      InputStream inputStream = Resources.getResourceAsStream(resource);
      //实例化SqlSessionFactoryBuilder构造器
      //解析配置文件流xmlConfigBuilder
      //Configuration所有的配置信息
      //sqlSessionFactory实例化
      //transactional事务管理
      //创建executor执行器
      //创建sqlSession
      //实现CRUD，查看是否执行成功
      // 成功则执行事务，并关闭
       
      #{} ${} 区别
       
      9、Lombok 
      Lombok项目是一个Java库；
      它会自动插入编辑器和构建工具中；
      Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码；
      仅五个字符(@Data)就可以替换数百行代码从而产生干净，简洁且易于维护的Java类。
       
      使用步骤：
       
       
      在idea中安装Lombok插件（idea2020年版本已经自安装）
       
       
      在项目中导入lombok的jar包
       
      
      
          org.projectlombok
          lombok
          1.18.24
      
       
       
      在实体类上加上注解
       
      @Data
      @AllArgsConstructor
      @NoArgsConstructor
       
       
      @Getter and @Setter
      @FieldNameConstants
      @ToString
      @EqualsAndHashCode
      @AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
      @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
      @Data
      @Builder
      @SuperBuilder
      @Singular
      @Delegate
      @Value
      @Accessors
      @Wither
      @With
      @SneakyThrows
      @val
      @var
      experimental @var
      @UtilityClass
       
      说明：
       
      @Data:无参构造、get&set、tostring、hashcode、equals
      @AllArgsConstructor
      @NoArgsConstructo
       
      10、多对一处理 
      多对一：
       
       
      多个学生对应一个老师
      对于学生，关联 多个学生关联一个老师【多对一】
      对于老师，集合 一个老师有很多学生 【一对多】
       
       
      sql：
       
      CREATE TABLE `teacher`(
      `id` INT(10)  NOT NULL,
      `name` VARCHAr(30) DEFAULT NULL,
      PRIMARY KEY(`id`)
      )ENGINE=INNODB DEFAULT CHARSET=utf8
      
      INSERT INTO teacher(`id`,`name`) VALUES(1,'一老师');
      
      CREATE TABLE `student`(
      `id` INT(10) NOT NULL,
      `name` VARCHAr(30) DEFAULT NULL,
      `tid` INT(10) DEFAULT NULL,
      PRIMARY KEY(`id`),
      KEY `fktid`(`tid`),
      CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher`(`id`)
      )ENGINE = INNODB DEFAULT CHARSET = utf8
      
      INSERT INTO `student` (`id`,`name`,`tid`) VALUES
      ('1','小明','1'),
      ('2','小红','1'),
      ('3','小张','1'),
      ('4','小李','1'),
      ('5','小王','1');
       
       
      测试环境搭建
       
       
      导入Lombok
       
       
      新建实体类Teacher，Student
       
       
      建立相应的Mapper接口
       
       
      建立相应的Mapper.xml文件
       
       
      在核心配置文件中绑定注册Mapper接口或者文件 【方式较多】
       
       
      测试查询你是否能够成功
       
       
      按照查询嵌套处理
       
       
      
          
              select *
              from student;
          
      
          
             
             
      
             
      
          
      
          
              select *
              from teacher where id=#{tid};
          
      

      3. 按照结果嵌套处理

      
      
          select s.id sid,s.name sname,t.name tname
          from student s,teacher t
          where s.tid=t.id;
      
      
      
          
          
      
          
              
          
      
       
      回顾MySQL 多对一查询方式：
       
      子查询
      联表查询【较简单】
       
      11、一对多处理 
      比如：一个老师拥有多个学生
       
      对于老师而言，就是一对多的关系
       
      环境搭建
       
      实体类：
       
      @Data
      public class Teacher {
          private int id;
          private String name;
      
          //一个老师拥有多个学生
          private List students;
      }
       
      @Data
      public class Student {
          private int id;
          private String name;
      
          private int tid;
      }
       
      按照结果嵌套处理
       
      
          select s.id sid,s.name sname,t.id tid,t.name tname
          from teacher t,student s
          where s.tid = t.id and t.id = #{tid};
      
      
          
          
          
          
              
              
              
          
      
      

      按照查询嵌套处理

      
          select *
          from teacher
          where id=#{tid};
      
      
      
          
          
      
      
      
          select *
          from student
          where tid=#{tid};
      
      

      小结：

      1. 关联（association）【多对一】

      2. 集合（collection）【一对多】

      3. javaType & ofType

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

      注意点：

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

      面试高频：

      • MySQL引擎
      • innodb底层原理
      • 索引
      • 索引优化
      12、动态sql

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

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

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

      搭建环境

      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
      

      创建一个基础工程

      1. 导包

      2. 编写配置文件

      3. 编写实体类

         @Data
         public class Blog {
             private int id;
             private String title;
             private String author;
             private Date createTime;
             private int views;
         }
         

      4. 编写实体类对应的Mapper接口和Mapper.xml文件

      IF

      
          select *
          from blog
          where 1=1
          
              and title=#{title}
          
          
              and author=#{author}
          
      
       
      choose、when、otherwise
       
      
          select *
          from blog
          
              
                  
                      title like #{title}
                  
                  
                      and author like %#{author}%
                  
                  
                      and views =#{views}
                  
              
          
      
      

      trim、where、set

      
          select *
          from blog
          
              
                  title=#{title}
              
              
                  and author=#{author}
              
          
      
       
      
          update blog
          
              
                  title = #{title},
              
              
                  author=#{author}
              
          
          where id=#{id}
      
       
      所谓的动态sql，本质还是sql语句，只是我们可以在sql层面，去执行一些逻辑代码
       
      if
       
      where 、set 、choose 、when
       
      foreach
       
      select * from blog where 1=1 and 
      
      
          #{id}
      
      
      (id = 1 or id = 2 or id = 3)
       
       
      
          select *
          from blog
          
              
                  id=#{id}
              
          
      
       
      SQL片段
       
      有的时候，我们可能会将一些公共的部分抽取出来，方便复用
       
       
      使用sql标签抽取公共的部分
       
      
          
              title = #{title}
          
          
              author=#{author}
          
      
       
       
      在需要使用的地方使用include标签引用即可
       
      
          select *
          from blog
          
              
          
      
      

   注意事项：

   • 最好基于单表来定义sql片段
   • 不要存在where标签
   • 尽量只包含if标签

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

   建议：

   • 先在MySQL中写出完整的sql，再对应去修改成我们的动态sql，实现通用
   13、缓存 13.1、简介

   查询   ：  连接数据库    ，   耗资源
   一次查询的结果，给他暂存到一个可以直接取到的地方  =》内存；即缓存
   我们再次查询相同数据的时候，直接去缓存中拿，就不用走数据库了
   

   读写分离、主从复制

   1. 什么是缓存【cache】？
      • 存在内存中的临时数据
      • 将用户经常查询的数据放在缓存（内存）中，用户去查询就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决高并发系统的性能问题
   2. 为什么使用缓存？
      • 减少和数据库的交互次数，减少系统开销，提高系统效率
   3. 什么样的数据该使用缓存？
      • 经常查询且不经常改变的数据
   13.2、MyBatis缓存
   • MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
   • MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
     • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称本地缓存）
     • 二级缓存需要手动开启和配置，它是基于namespace级别的缓存
     • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
   13.3、一级缓存
   • 一级缓存也叫本地缓存
     • 与数据库同一次会话期间查询到的数据会放在本地缓存中；
     • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库。

   测试步骤：

   1. 开启日志

   2. 测试在一个session中查询两次相同的记录

   3. 查看日志输出

   缓存失效的情况：

   1. 查询不同数据

   2. 增删改，可能会改变原来的数据，所以必定会刷新缓存

   3. 查询不同的Mapper.xml

   4. 手动清理缓存

      @Test
      public void test(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
      
          List users = sqlSession.getMapper(UserMapper.class).queryUserById(1);
          for (User user : users) {
              System.out.println(user);
          }
          
          System.out.println("******************************************");
          sqlSession.clearCache();//手动清理缓存
          List users2 = sqlSession.getMapper(UserMapper.class).queryUserById(1);
          for (User user : users2) {
              System.out.println(user);
          }
          System.out.println(users==users2);
          sqlSession.close();
      }
      

   小结:

   • 一级缓存默认是开启的，只在一次Sqlsession中有效，也就是拿到连接到关闭连接这个时间段

   • 一级缓存就是一个map

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

   步骤：

   1. 开启全局缓存

   2. 在要使用二级缓存的mapper中开启

      也可以自定义参数

   3. 测试

      1. 我们需要将实体类序列化，否则就会报错

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

   4. 小结：

      • 只要开启了二级缓存，在同一个mapper下就有效；
      • 所有的数据都会先放在一级缓存中；
      • 只有当会话提交或者会话关闭时，一级缓存才会提交到二级缓存中
   13.5、缓存原理

   缓存顺序：

   1. 先看二级缓存中有无
   2. 再看一级缓存中有无
   3. 最后无可奈何才查询数据库
   13.6、自定义缓存-ehcache 现已多用redis代替

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

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

   
   
       org.mybatis.caches
       mybatis-ehcache
       1.2.2
   
   

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

   ehcache.xml

   Redis数据库来做缓存