狂神说---Mybatis框架学习笔记

MyBatis框架

环境：

• JDK1.8
• Mysql5.7
• maven3.6.1
• IDEA

回顾：

• JDBC
• Mysql
• java基础
• Maven
• junit

框架：配置文件的。

1、MyBatis简介

1.1、什么是MyBatis

• MyBatis是一款优秀的持久层框架。
• 它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。
• 可以通过简单的xml或者注解来配置和映射原始类型、接口和java pojo为数据库中的记录。

如何获得MyBatis：

• Maven仓库：

  • <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    

• GitHub:https://github.com/mybatis/mybatis-3

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

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库（jdbc),io文件持久化
• 生活方面例子：冷藏、罐头

为什么需要持久化？

• 不想丢掉一些对象
• 内存太贵

1.3、持久层

Dao层、service层、Controller层…

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

1.4、为什么需要MyBatis

• 帮助程序员将数据存入到数据库中。
• 方便
• 传统的jdbc代码太复杂，简化–>框架–>自动化
• 优点：不用也可以，使用更容易上手。

2、第一个MyBatis程序

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

2.1、搭建环境

• 搭建数据库

  create database `mybatis`;
  
  use `mybatis`;
  
  create table `user`(
  `id` int(20) not null ,
  `name` varchar(30) default null ,
  `pwd`  varchar(30) DEFAULT null,
  primary key(`id`)
  )ENGINE = innodb default charset = utf8
  
  INSERT into `user` (`id`,`name`,`pwd`) 
  values(1,'小明','xiaoming123'),
  (2,'小花','xiaohua123'),
  (3,'小李','xiaoli123')
  

• 新建一个maven项目

• 删除src目录

• 导入maven依赖

  <!--import dependencies-->
      <dependencies>
          <!--mysql driver-->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>5.1.47</version>
          </dependency>
          <!--mybatis-->
          <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
          <dependency>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
              <version>3.5.6</version>
          </dependency>
          <!--junit-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
          </dependency>
              
      </dependencies>
  

2.2、创建一个module模块

• 编写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 core file-->
  <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>
  
  </configuration>
  

• 编写mybatis工具类

package com.kuang.utils;

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.IOException;
import java.io.InputStream;

//SqlSessionFactory--->SqlSession
public class MybatisUtils {

    private  static  SqlSessionFactory sqlSessionFactory;
    static {

        try {
            //使用mybatis的第一步：获取sqlsessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //从SqlSessionFactory中获取SqlSession实例,来操作SQL语句
public static SqlSession getSqlSession(){
        //     SqlSession sqlSession =  sqlSessionFactory.openSession();
//        return sqlSession;

    return sqlSessionFactory.openSession();
}
}

2.3、编写代码

• 编写代码

  • 实体类

    package com.kuang.pojo;
    
    public class User {
        private int id;
        private String name;
        private String pwd;
    
        public User() {
        }
    
        public User(int id, String name, String pwd) {
            this.id = id;
            this.name = name;
            this.pwd = pwd;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", pwd='" + pwd + '\'' +
                    '}';
        }
    }
    
    

  • Mapper接口

    package com.kuang.dao;
    import com.kuang.pojo.User;
    import java.util.List;
    
    public interface UserMapper {
        //获取所有的用户
       List<User> getUserList();
    }
    
    

  • 接口实现类：由原来的UserMapperImpl转变成一个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.dao.UserMapper">
    
        <select id="getUserList" resultType="com.kuang.pojo.User">
            select * from user where id = #{id}
        </select>
    </mapper>
    

2.4、测试

注意点

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

MapperRegistry是什么？

核心配置文件中注册Mappers

Junit测试

package com.kuang.dao;

import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MybatisTest {

    @Test
   public void test(){
       //获取SqlSession实例
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //根据接口，获取接口的方法
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        for (User user : userList) {
            System.out.println(user);

        }
        //关闭SqlSession实例
        sqlSession.close();
    }
}

可能出现的问题：

• 配置文件没有注册；
• 绑定接口错误
• 方法名不对
• 返回类型不对
• maven导出资源问题

3、CRUD

3.1、namespace

namespace中的包名要和Dao/Mapper接口的包名一致！！！

3.2、select

选择，查询语句；

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

1、编写接口

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

2、编写对应Mapper.xml文件中sql语句

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

3、测试

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

3.3、insert

    <insert id="insertUser" parameterType="com.kuang.pojo.User">
        insert into mybatis.user (id, name, pwd) VALUES (#{id},#{name},#{pwd})
    </insert>

3.3、update

    <update id="updateUser" parameterType="com.kuang.pojo.User" >
        update mybatis.user set name = #{name},pwd = #{pwd} where id = #{id}
    </update>

3.4、delete

    <delete id="deleteUser" parameterType="int" >
        delete from mybatis.user where id = #{id}
    </delete>

注意点：

增删改需要提交事务！！！

3.5、分析错误

1. xml文件中注释不能出现中文报错，查看自己的是UTF-8还是GBK编码，改成为相应的就行。
2. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2PGYt6nD-1639019236261)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\image-20211207133804932.png)]

即可成功测试。

1. 标签不要匹配错！
2. resource绑定mapper，需要使用路径！
3. 程序配置文件必须符合规范！
4. NullPointerException，没有注册到资源！
5. maven资源没有导出问题！

3.6、万能Map

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

//万能的Map
    int addUser2(Map<String,Object> map);

<!--对象中的属性，可以直接取出来  传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,pwd) values (#{userid},#{password})
    </insert>

@Test
     public void addUser2(){
         SqlSession sqlSession = MybatisUtils.getSqlSession();

         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         Map<String,Object> map = new HashMap<String, Object>();
         map.put("userid",4);
         map.put("password","123321");

         mapper.addUser2(map);


         sqlSession.commit();
         sqlSession.close();
     }

Map传递参数，直接在sql中取出key即可！【parameterType= “Map”】

对象传递参数，直接在sql中取对象的属性即可！【parameterType= “Object”】

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

多个参数用MAP，或者注解

3.7、思考题

模糊查询怎么写？

1、在java代码执行的时候，传递通配符% %

    @Test
    public void getUserLike(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserLike("%小%");
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

}

2、在sql拼接中使用通配符！

    <select id="getUserLike" resultType="com.kuang.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%"
    </select>

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】

编写一个配置文件

db.properties

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

在核心配置文件中映入

	<!--引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="pwd" value="123123"/>
    </properties>

• 可以直接引入外部文件
• 可以再其中增加一些属性配置
• 如果两个文件有同一个字段，优先使用外部配置文件的。

4.4、类型别名（typeAlises）

• 类型别名是为java类型设置一个短的名字。

• 存在的意义仅在于用来减少类完全限定名的冗余。

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

• 也可以指定一个包名，mybatis会在包下面搜索需要的Javabean，比如：扫描实体类的包，他的默认别名就位这个类的类名，首字母小写。

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

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

  • 如果实体类十分多，建议使用第二种。

  • 第一种可以diy别名，第二种不行，如果非要改别名，需要在实体类上增加注解

    @Alias("user")
    //实体类
    public class User {}
    

4.5、设置

这是mybatis中极为重要的调整设置，他们会该表mybatis的运行时行为。

4.6、其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
  1. mybatis-generator-core
  2. mybatis-plus
  3. 通用mapper

4.7、映射器（mappers)

MapperRegistry：注册绑定我们的Mapper文件；

方式一：【推荐使用】

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

方式二：使用class文件绑定注册

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

注意点：

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

方式三：使用扫描包进行注入绑定

   <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <package name="com.kuang.dao"/>
    </mappers>

练习：

• 将数据库配置文件外部引入
• 实体类别名
• 保证UserMapper接口和UserMapper.xml改为一致，并且在同一个包下

4.8、生命周期和作用域

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

SqlSessionFactoryBuilder：

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

SqlSessionFactory：

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

SqlSession：

• 连接到连接池的一个请求！
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 用完后需要赶紧关闭，否则资源被占用！

这里的每一个mapper，就代表一个具体业务

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

5.2、resultMap

结果集映射

id  name  pwd
id  name  password

<!--结果集映射-->
<resultMap id="UserMap" type="User">
    <!--column是数据库中的字段，property是实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

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

• resultMap 元素是 MyBatis 中最重要最强大的元素。
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
• ResultMap 的优秀之处——你完全可以不用显式地配置它们。
• 如果这个世界总是这么简单就好了。

6、日志

6.1、日志工工厂

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

曾经：sout、debug

现在：日志工厂

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

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

stdout_logging标准日志输出

在mybatis-config.xml核心配置文件，配置我们的日志。

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

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

6.2、Log4j

什么是Log4j？

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

1、在pom.xml文件中导入Log4j的依赖包

 <dependencies>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

2、在resources文件下下建立log4j.properties文件进行配置

#控制台输出的相关设置
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/kuang.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.在mybatis-config.xml核心配置文件中，配置log4j为日志的实现！

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

4.Log4j的使用，直接测试运行

简单使用

1. 在要使用Log4j的测试类中，导入包import org.apache.log4j.Logger;
2. 日志对象，参数为当前类的class

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

3.日志级别

    logger.info("info:进入了testLog4j");
        logger.debug("DEBUG:进入了testLog4j");
        logger.error("erro:进入了testLog4j");

4.之后可在log文件夹中查看日志文件信息

7、分页

思考：为什么要分页！

• 减少数据的处理量

7.1、使用Limit分页

语法：SELECT * from user limit startIndex,pageSize
SELECT  * from user limit 3 #[0,n]

使用mybatis实现分页，核心sql

• 1.接口

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

• 2.Mapper.xml

  <!--    分页-->
      <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
          select * from mybatis.user limit #{startIndex},#{pageSize}
      </select>
  

• 3.测试

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

  7.2、RowBound分页

  不再使用sql实现分页

  1、接口

      //分页2
      List<User> getUserByRowBounds();
  

  2、Mapper.xml

  <!--    分页2-->
      <select id="getUserByRowBounds" resultMap="UserMap">
          select * from mybatis.user
      </select>
  
  

  3、测试

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

7.3、分页插件

了解即可，使用时，需要知道是什么东西

8、使用注解开发

8.1、面向接口编程

• 之前学过面向对象编程，也学习过接口，但是在真正的开发中，很多时候会选择面向接口编程。
• 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好。
• 在一个面向对象的系统中，系统的各种功能是由许多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己地，对系统设计人员来讲就不那么重要了。
• 而各个对象之间的协作关系则称为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是按照这种思想来编程的。

8.2、使用注解开发

• 注解在UserMapper接口上实现，并删除UserMapper.xml文件

    @Select("select * from user")
      List<User> getUsers();
  

• 需要在mybatis-config.xml核心配置文件中绑定接口

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

• 测试

     @Test
      public void getUsers(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          UserMapper mapper = sqlSession.getMapper(UserMapper.class);
          List<User> users = mapper.getUsers();
  
          for (User user : users) {
              System.out.println(user);
          }
  
          sqlSession.close();
      }
  

  本质：反射机制实现

  底层：动态代理

Mybatis详细的执行流程！（之后应用的多了详细再走一遍）

8.3、CRUD

1、在MyBatisUtils工具类创建的时候实现自动提交事务！

    public static SqlSession getSqlSession(){
        //     SqlSession sqlSession =  sqlSessionFactory.openSession();
//        return sqlSession;

        return sqlSessionFactory.openSession(true);
    }

2、编写接口，增加注解

public interface UserMapper {

    @Select("select * from user")
    List<User> 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 addUser(User user);

    @Update("update user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);

    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
    
}

3、测试类

【注意：我们必须要将接口注册绑定到我们核心配置文件中！！！】

关于@Param()注解

• 基本类型的参数或者String类型的，需要加上。
• 引用类型不需要加
• 如果只有一个基本类型，可以省略，但是建议加上
• 我们在sql中引用的就是我们这里的@param（“ ”）中设定的属性名

#{}和${}的区别

9、Lombok（偷懒的话可以使用）、

使用步骤：

• 在IDEA中安装Lombok插件

• 在项目pom.xml文件中导入Lombok的jar包

          <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
          <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <version>1.18.10</version>
          </dependency>
  
  

• 在实体类中加注解即可

  @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
  

  说明：

  @Data:无参构造、get、set、toString、hashCode、equals
  @AllArgsConstructor
  @NoArgsConstructor
  @EqualsAndHashCode
  @ToString
  @Getter and @Setter
  

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');
INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('2','小红','1');
INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('3','小张','1');
INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('4','小李','1');
INSERT INTO `student`(`id`,`name`,`tid`) VALUES ('5','小王','1');

测试环境搭配

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

按照结果嵌套查询

    <!--按照结果嵌套处理    -->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname
        from mybatis.student s,mybatis.teacher t
        where s.tid = t.id
    </select>

    <resultMap id="StudentTeacher2" type="com.kuang.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

按照查询嵌套查询

    <!--
      思路：
          1.查询所有的学生信息
          2.根据查询出来的学生的tid，寻找对应的老师！ 子查询-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from mybatis.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 mybatis.teacher where id = #{id}
    </select>

回顾MySQL多对一查询方式：

• 子查询
• 联表查询

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;
}

按照结果嵌套处理

    <!--    按结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
            SELECT  s.id sid,s.name sname,t.name tname,t.id,tid
            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>

按照查询嵌套处理

    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from mybatis.teacher where id = #{tid}
    </select>

    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>

    <select id="getStudentByTeacherId" resultType="Student">
        select * from  mybatis.student where tid = #{tid}
    </select>

小结：

• 关联—association【多对一】
• 集合—collection【一对多】
• JavaType与ofType
  • JavaType是用来指定实体类中属性的类型
  • ofType是用来指定映射到Lis或者集合中的pojo类型，泛型中的约束类型。

注意点：

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

面试高频

• MySQL引擎
• InnoDB底层原理
• 索引
• 索引优化

12、动态SQL

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

利用动态SQL这一特性可以彻底摆脱这种痛苦。

在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

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

搭建环境

vCREATE 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`)
)

• 新建一个模块

• 导包

• 编写配置文件

• 编写实体类

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

• 在工具类下新建IDutils类，获取随机ID

  package com.kuang.utils;
  
  import org.junit.Test;
  
  import java.util.UUID;
  
  @SuppressWarnings("all")//抑制警告
  public class IDutils {
  
      public static String getId(){
          return UUID.randomUUID().toString().replace("-","");
      }
  
      @Test
      public void test(){
          System.out.println(IDutils.getId());
          System.out.println(IDutils.getId());
          System.out.println(IDutils.getId());
      }
  }
  
  

• 在Blog数据库中插入数据

• IF

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

• choose (when, otherwise)

      <select id="queryBlogChoose" parameterType="map" resultType="Blog">
          select * from mybatis.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>
  
  

• trim (where, set)

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

      <update id="updateBlog" parameterType="map">
          update mybatis.blog
          <set>
              <if test="title != null">
                  title = #{title},
              </if>
              <if test="author != null">
                  author = #{author}
              </if>
          </set>
          where id = #{id}
      </update>
  
  

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

Foreach

• 动态SQL的另一个常见使用场景就是对集合进行遍历（尤其是在构建in条件语句的时候）。
• foreach元素的功能非常强大，它允许你指定一个集合，声明可以再元素内使用的集合项（item)和索引（index）变量。它允许你指定开头和结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误的添加多余的分隔符，多么的智能。
• 提示你可以将任何可迭代对象（如list、set）、map对象或者数据对象作为集合参数传递给foreach。当使用可迭代对象或者数组时候，index是当前迭代的序号，item的值是本次迭代获取到的元素。当使用map对象（或者map。entry对象的集合）时候，index是键，item是值。

    <!--select * from blog where 1=1 and (id=1 or id=2 or id=3)
        我们现在传递一个万能的map，这map中可以存在一个集合！
        -->
    <select id="queryBlogForeach" parameterType="map" resultType="Blog">
        select * from mybatis.blog
        <where>
            <foreach collection="ids" item="id" open="and (" close=")" separator="or">
                id = #{id}
            </foreach>
        </where>
    </select>

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

建议：

• 现在Mysql中写出完整的sql，在对应的去修改成我们的动态sql实现通用即可。

SQL片段

• 有的时候，我们可能会将一些工鞥呢的部分抽取出来，方便复用。

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

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

  • 在需要使用的地方使用include标签引用即可。、

  •     <select id="queryBlogIF" parameterType="map" resultType="Blog">
            select * from mybatis.blog
            <where>
                <include refid="if-title-author"></include>
            </where>
        </select>
    
    

• 注意事项：

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

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、手动清理缓存

  • 

• 小结：

  • 一级缓存是默认开启的，只在一次Session中有效，也就是拿到连接到关闭连接这个区间段。
  • 一级缓存相当于一个Map

13.4、二级缓存

• 二级缓存就叫做全局缓存，一级缓存的缓存作用域太低了，也就诞生了二级缓存

• 基于namespace级别的缓存，一个名称空间，对应一个二级缓存。

• 工作机制

  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中。
  • 如果当前会话关闭了，这个会话对应的一级缓存就没有了，但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中。
  • 新的会话查询信息，就可以从二级缓存中获取内容
  • 不同的mapper查出的数据就会放在自己对应的缓存中。

• 测试步骤

  • 1、在MyBatis-config.xml文件中开启全局缓存

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

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

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

  • 也可以自定义参数

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

  • 测试

    • 问题：如果没有自定义参数，就会报错，我们需要将实体类序列化。

    • Cause: java.io.NotSerializableException: com.kuang.pojo.User
      
      

• 小结：

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

13.5、缓存原理

13.6、自定义缓存—ehcache（可以了解）

• Ehcache是一种广泛使用的开源java分布式缓存，主要面向通用缓存
• 要在程序中使用ehcache，先要导包
• 在mapper中指定我们的ehcache缓存实现
• 目的：Redis数据库用来做缓存。