Mybatis 狂神说笔记

Mybatis-9.28

环境:

• JDK 1.8
• Mysql 5.7
• maven 3.6.1

SSM框架:配置文件,最好的方式:看官方文档

简介

1.1 什么是Mybatis

• MyBatis 是一款优秀的持久层框架
• 它支持自定义 SQL、存储过程以及高级映射。
• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
• MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。2013年11月迁移到Github
• iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）

如何获得Mybatis

• maven 仓库:

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

• github;GitHub - mybatis/mybatis-3: MyBatis SQL mapper framework for Java

• 中文文档:mybatis – MyBatis 3 | 简介

1.2 持久化

数据持久化

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

• 内存:断电即失

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

为什么需要持久化?

• 因为内存太贵了

• 有一些对象,不能让他丢掉.

1.3 持久层

Dao层,Service层,Controller层…

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

1.4 为什么需要Mybatis?

• 方便
• 帮助程序员将数据存入到数据库中.
• 传统的JDBC代码太复杂了.简化.框架.自动化
• 不用Mybatis也可以.更容易上手.
• 优点:sql和代码分离等等

最重要一点:使用的人多!

2 第一个Mybatis 程序

思路:搭建环境–>导入Mybatis–>编写代码–>测试!

2.1 搭建环境

搭建数据库

CREATE DATABASE `mybatis`;
USE `mybatis`;

CREATE TABLE `user` (
   `id` INT(20) NOT NULL AUTO_INCREMENT,
   `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,'kuang','123456')
,(2,'kuang2','123456'),(3,'kuang3','123456')

新建项目

1. 新建一个maven项目
2. 删除src 新建一个副工程
3. 导入maven依赖
4. 创建一个module

2.2 编写mybatis 核心配置文件

• mybatis 核心配置文件

  mybatis-config.xml

  <?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>
  <!--    加个s复数就能配置多个环境-->
      <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&amp;?serverTimezone=UTC"/>
                  <property name="username" value="root"/>
                  <property name="password" value="123456"/>
              </dataSource>
          </environment>
      </environments>
  
  </configuration>
  

• 编写mybatis工具类

  每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。

  package com.huang.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 {
              String resource = "mybatis-config.xml"; 
              // 获取sqlSessionFactory对象 使用Mybatis第一步
              InputStream inputStream= Resources.getResourceAsStream(resource);
              sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          } catch (IOException e) {
              e.printStackTrace();
          }
  
      }
      //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例
      //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
      public static SqlSession getSqlSession(){
          return sqlSessionFactory.openSession();
      }
  }
  
  

2.3 编写代码

• 实体类

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

• Dao接口

  public class UserDaoImpl implements UserDao {
      List<User> getUserList();
  }
  

• 接口实现类由原来的UserDaoImpl 转变为一个Mappe配置r文件

  <?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 = 绑定一个对应的Dao/Mapper接口-->
  <mapper namespace="com.huang.dao.UserDao">
  
      <!--    select 查询语句 绑定接口 重写了方法-->
      <select id="getUserList" resultType="com.huang.pojo.User">
          select * from mybatis.user;
      </select>
  
  </mapper>
  

2.4 测试

package com.huang.dao;

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

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //第一步 获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行SQL
        //方式一：getMapper
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

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

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

可能遇到的问题：

1. 配置文件没有注册；
2. 绑定接口错误；
3. 方法名不对；
4. 返回类型不对；
5. Maven导出资源问题。

我的报错:

Could not find resource mybatis-config.xml

解决博客:

[(30条消息) idea 中Could not find resource mybatis-config.xml的错误_橙子的胖胖的博客-CSDN博客](https://blog.csdn.net/qq_52211542/article/details/119248458?ops_request_misc=&request_id=&biz_id=102&utm_term=Could not find resource mybati&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-7-.first_rank_v2_pc_rank_v29&spm=1018.2226.3001.4187)

3 CRUD

3.1 namespace

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

3.2 select

选择，查询语句；

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

1.编写接口

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

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

	<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
        select * from mybatis.user where id = #{id}
	</select>

3.测试

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

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);

        //关闭SqlSession
        // sqlSession.commit();
        sqlSession.close();
    }

注意点：

• 增删改需要提交事务！

3.3 分析错误

xml文件中注释不能出现中文报错，查看自己的是UTF-8还是GBK编码，改成为相应的就行。

<?xml version="1.0" encoding="UTF-8" ?>
<?xml version="1.0" encoding="GBK" ?>

即可成功测试。

1. 标签不要匹配错！
2. resource绑定mapper，需要使用路径！
3. 程序配置文件必须符合规范！
4. NullPointerException，没有注册到资源！
5. 输出的xml文件中存在中文乱码问题！
6. maven资源没有导出问题！
7. 1 字节的 UTF-8 序列的字节 1 无效：
   错误提示：java.lang.ExceptionInInitializerError；### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: org.apache.ibatis.builder.BuilderException: Error creating document instance. Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException: 1 字节的 UTF-8 序列的字节 1 无效。
   原因：是在UserMapper.xml中添加中文注释了。
   解决办法也是有两种：
   1 直接把中文注释去掉，运行就可以了。
   2 不想去掉中文注释的话，把第一行中的encoding="UTF-8"改成encoding=“UTF8”。就是把 - 去了。

3.4 万能的Map

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

• UserDao接口：

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

• UserMapper.xml：

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

• 测试类：

@Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("userid",5);
        map.put("userName","hello");
        map.put("password","2233");
        mapper.addUser2(map);
        sqlSession.close();

• Map传递参数，直接在sql中取出map里的key即可！
• 对象传递参数，直接在sql中取出对象的属性即可！
• 只有一个基本类型参数的情况下，可以直接在sql中取到
• 多个参数用Map（一个表参数太多，更新时就用到一两个字段，这时候用map比较方便） , 或者注解！

3.8 模糊查询

模糊查询怎么写

1. Java代码执行的时候，传递通配符%

   List<User> userList = mapper.getUserLike("k%");
   List<User> userList = mapper.getUserLike("%k%");
   

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

   select * from mybatis.user where name like #{value}"%"
   

4 配置解析

4.1 核心配置文件

• mybatis-config.xml（习惯用这个名字，当然也可以不叫这个名字）
• Mybatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息。
  

4.2 环境配置 environments

• MyBatis 可以配置成适应多种环境
• 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境
• 学会使用配置多套运行环境！用哪一套环境就把那套设成default。
  
  MyBatis默认的事务管理器就是JDBC ，连接池：POOLED
  

4.3 属性 properties

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

编写一个配置文件

db.properties

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

4.3.1 在核心配置文件中引入

<!--    引入外部配置文件-->
    <properties resource="dp.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>

第二种方式 还有优先级的问题 还是外部的dp.properties 优先

<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="password" value="111111"/>
</properties>

4.3.2 总结

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

4.4 类型别名 typeAliases

• 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置.
• 意在降低冗余的全限定类名书写。
• 在核心配置文件添加的代码如下，注意添加的位置：

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

<select id="getUserList" resultType="user">
        select * from mybatis.user
    </select>

这里的UserMapper.xml类名可以简写

• 也可以指定一个包，每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：

    <typeAliases>
        <package name="pojo"/>
    </typeAliases>

• 在实体类比较少的时候，使用第一种方式。
• 如果实体类十分多，建议用第二种扫描包的方式。
• 第一种可以DIY别名，第二种不行，如果非要改，需要在实体上增加注解。

注解起别名例子@Alias("author")这种写法实测时报空指针，原因未明

4.5 设置

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

4.6 其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins 插件
  • mybatis-generator-core 根据数据库自动生成增删改查
  • mybatis-plus
  • 通用mapper

4.7 映射器 mappers

• MapperRegistry：注册绑定我们的Mapper文件；
• 方式一：【推荐使用

<!--a Mapper.xml need regist in Mybatis core configuration file-->
<mappers>
    <mapper resource="com/huang/dao/UserMapper.xml"/>
</mappers>

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

    <mappers>
        <mapper class="dao.UserMapper"/>
    </mappers>

• 注意点：

  • 接口和他的Mapper配置文件必须同名
  • 接口和他的Mapper配置文件必须在同一个包下
  • 使用class时分割符是“.”，使用resource时分隔符是“/”。如果使用class时分隔符写成了"/"会报空指针异常。

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

    <mappers>
<!--        <mapper resource="com/huang/dao/UserMapper.xml"/>-->
<!--        <mapper class="com.huang.dao.UserMapper"/>-->
        <package name="com.huang.dao"/>

注意点：同上

4.8 作用域和生命周期

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

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

• SqlSessionFactory:
  • 说白了就可以想象为：数据库连接池
  • SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建一个实例。
  • 因此SqlSessionFactory的最佳作用域是应用作用域（ApplocationContext）（全局：程序开始就开始，程序结束就结束）。
  • 最简单的就是使用单例模式或静态单例模式。

SqlSession：

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

这里面的每一个Mapper，就代表一个具体的业务！

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

5.1 问题

• 当数据库里的列名和实体类的属性不同名时，会出现以下问题：
  
  password=“null”
  
  找不到pwd

5.2 解决方法

5.2.1 sql起别名

select id, name, pwd as password from mybatis.user where id=#{id}

5.2.2 使用resultMap结果集映射

结果集映射

id name pwd
id name password

说明

• column数据库中的字段，property实体类中的属性
• type是整体映射而成的类型。
• 原来select标签里的parameterType=“User”,现在改成了resultMap=“UserMap”。而resultMap=“UserMap” 和 id=“UserMap” type=“User” 合并，相当于中间多了个"UserMap"中转，结果还是"User"，所以resultMap的type还是"User"。
• 映射只需要写需要映射的字段。像表里列名和实体属性名都是id的，就可写可不写。

<!--    结果集映射-->
<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" parameterType="int">
    select * from mybatis.user where id=#{id}
</select>

6，日志

步骤

新建项目

建立配置文件

工具类 读取配置文件 获取工厂

实体类

接口 和 实现的sql

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是什么

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

1. 先导入LOG4J

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

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/mybatistest.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.sq1.PreparedStatement=DEBUG
   

3. 配置settings为log4j实现

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

4. .测试运行

简单使用

• 在要使用Log4j的类中，导入包 import org.apache.log4j.Logger

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

  static Logger logger = Logger.getLogger(UserMapperTest.class);
  
      @Test
      public void testGetByID(){
          SqlSession sqlSession=MybatisUtils.getSqlSession();
          logger.info("测试：进入getUser方法成功");
          UserMapper mapper = sqlSession.getMapper(UserMapper.class);
          User user = mapper.getUserById(1);
          System.out.println(user);
  
          sqlSession.close();
      }
  

• 日志级别

  • info
  • debug
  • error

7, 分页

思考：为什么要分页？

• 减少数据的处理量

7.1 使用Limit分页

语法: 每页显示多少个，从第几个开始查

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

使用MyBatis实现分页，核心是SQL

1. 接口

   //分页的参数至少需要两个，map
       List<User> getUserByLimit(Map map);
   

2. XML

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

3. 测试

   @Test
       public void getUserByLimit(){
           SqlSession sqlSession = null;
           try {
               //1.获取SqlSession对象
               sqlSession = MybatisUtils.getSqlSession();
   
               //2.执行SQL
               // 方式一：getMapper
               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);
               }
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               //关闭sqlSession
               sqlSession.close();
           }
       }
   

经验：Could not find parameter map com.kuang.dao.UserMapper.map

经过仔细检查，出错问题是 mybatis-config.xml中相应的关键字写错了：将parameterType写错成parameterMap。这才会出错。

7.2 RowBounds分页（不推荐）

• 核心：不再使用SQL实现分页

• 1.接口

  public List<User> getUserByRowBounds();
  

• 2.mapper.xml

  <select id="getUserByRowBounds" resultMap="UserMap">
      select * from user
  </select>
  

• 3.测试

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

7.3 mybatis 插件

8 使用注解开发

8.1 面向接口开发

三个面向区别

• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性和方法；
• 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现；
• 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多的体现就是对系统整体的架构；

8.2 使用注解开发

• 注解在接口上实现

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

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

      <mappers>
          <mapper class="com.kuang.dao.UserMapper"/>
      </mappers>
  

• 测试

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

8.3 本质

• 本质：反射机制实现

• 底层：动态代理

• 例子：房产中介，租房的人
  

• MyBatis详细执行流程
  

8.3 注解CRUD

我们可以在工具类创建的时候实现自动提交事务

自动提交

sqlSessionFactory.openSession(true);

编写接口，增加注解

// @Param("name") String name 方法存在多个参数。所有的参数前面必须加上@Param("name")
    @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);

// 实参以@Param中为主
    @Delete("delete from user where id=#{uid}")
    int deleteUser(@Param("uid") int id);

测试类

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

多个接口，可以使用通配符注册

<!--        <mapper resource="com/kuang/dao/*Mapper.xml"/>??-->

关于@Param( )注解

• 基本类型的参数或者String类型，需要加上

• 引用类型不需要加

• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上

• 我们在SQL中引用的就是我们这里的@Param()中设定的属性名

  #{} 和 ${}

• #{}可以防止SQL注入

• ${}不能防止SQL注入

9，Lombok

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

• java library
• plugs
• build tools

Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，Lombok- 提供了一组有用的注释，用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净，简洁且易于维护的Java类。

9.1 使用步骤：

1. 在IDEA中安装Lombok插件
2. 在项目中导入lombok的jar包

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

只有2021版本以后的idea才内置了lombok，其它版本需要手动安装lombok??

• 可用注解

  @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
  

• 示例

  package pojo;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.ToString;
  
  @Data
  @ToString
  @AllArgsConstructor
  public class User {
      private int id;
      private String name;
      private String password;
  }
  

  @Data： 无参构造，get,set,toString,hashcode,equals
  @NoArgsConstructor
  @AllArgsConstructor
  @ToString
  @EqualsAndHashCode
  

10,多对一

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

SQL

CREATE TABLE IF NOT EXISTS `teacher`(
   `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT'学号',
   `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
   `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
   PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8


CREATE TABLE `student`(
   `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT'学号',
   `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
   `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 teacher(`id`,`name`) VALUES(1,'秦疆')

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');

物理外键实现多对一

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration core file-->
<mapper namespace="com.kuang.dao.StudentMapper">

</mapper>

测试环境搭建

1. 导入lombok

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

2. 新建实体类 Teacher,Student

   package com.kuang.pojo;
   
   import lombok.Data;
   
   @Data
   public class Student {
       private int id;
       private String name;
       // 学生需要关联一个老师
       // 组合
       private Teacher teacher;
   
   }
   

   package com.kuang.pojo;
   
   import lombok.Data;
   
   @Data
   public class Teacher {
       private int id;
       private String name;
   }
   

3. 建立Mapper接口

   package com.kuang.dao;
   
   import com.kuang.pojo.Student;
   
   import java.util.List;
   
   public interface StudentMapper {
       // 查询所有的学生信息，以及对应的老师的信息！
       public List<Student> getStudent();
       public List<Student> getStudent2();
   }
   

   package com.kuang.dao;
   
   import com.kuang.pojo.Teacher;
   import org.apache.ibatis.annotations.Param;
   import org.apache.ibatis.annotations.Select;
   
   public interface TeacherMapper {
       public Teacher getTeacher(int id);
   }
   

4. 建立Mapper.xml

   <?xml version="1.0" encoding="UTF8" ?>
   <!--修改doctype 变成mapper-->
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.kuang.dao.StudentMapper">
   
   <!--    按照结果嵌套处理-->
           <select id="getStudent2" resultMap="StudentTeacher2">
               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>
   
   
   <!--    思路：
              1。查询所有的学生信息
              2. 根据查询出来的学生的tid,寻找对应的老师！
   -->
       <select id="getStudent" resultMap="StudentTeacher">
           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>
   
   <!--    <select id="getStudent" resultType="Student">-->
   <!--        select s.id,s.name,t.name from student s,teacher t where s.tid=t.id-->
   <!--    </select>-->
   </mapper>
   

   <?xml version="1.0" encoding="UTF8" ?>
   <!--修改doctype 变成mapper-->
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   
   <mapper namespace="com.kuang.dao.TeacherMapper">
   
   </mapper>
   

5. 在核心配置文件中绑定注册我们的Mapper接口或者文件

6. 测试查询是否能够成功

按照查询嵌套处理

<!--    思路：
           1。查询所有的学生信息
           2. 根据查询出来的学生的tid,寻找对应的老师！
-->
<select id="getStudent" resultMap="StudentTeacher">
    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
</select>

按照结果嵌套处理

<!--    按照结果嵌套处理-->
        <select id="getStudent2" resultMap="StudentTeacher2">
            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 一对多查询

环境搭建

实体类

package com.kuang.pojo;

import lombok.Data;

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

package com.kuang.pojo;

import lombok.Data;

import java.util.List;

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

按照结果嵌套处理

注意

• 按照查询嵌套处理时，Mapper.xml文件里用到两个select，一个是测试类里调用的，这个select的必须在接口里定义，否则会报错。另一个为了关联查询而生的select则可以不在接口里定义。

<!--    按结果嵌套查询-->
    <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"/>
        </collection>
    </resultMap>

按照查询嵌套处理

<!--    子查询，先查询，再查询-->
<!--    先查询老师 一个老师有多个学生 学生说空的-->
    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from 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 student where id=#{tid}
    </select>

小结

1. 关联-association 【多对一】
2. 集合-collection 【一对多】
3. javaType & ofType
   1. javaType 用来指定实体类中的类型
   2. ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

11.2 注意点

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

11. 1 面试高频

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

12 动态SQL

什么是动态SQL：

• 动态SQL就是根据不同的条件生成不同的SQL语句
• 所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码
• 动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

搭建环境

sql

CREATE TABLE `blog`  (
    `id` VARCHAR(100) NOT NULL 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`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

• 1.导包

• 2.编写配置文件

• 3.编写实体类

  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Blog {
      private String id;
      private String title;
      private String author;
      private Date createTime;// 属性名和字段名不一致 可以在下面配置中解决
      private int views;
  }
  

<setting name="mapUnderscoreToCamelCase" value="true"/>

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

• 5.编写测试类

IF

• 接口

  public interface BlogMapper {
      // 插入数据
      int addBlog(Blog blog);
  
      List<Blog> selectBlogIf(Map map);
  }
  
  

• Mapper.xml

  <?xml version="1.0" encoding="UTF8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.kuang.dao.BlogMapper">
  
      <insert id="addBlog" parameterType="blog">
          insert into blog (id,title,author,create_time,views)
          values (#{id},#{title},#{author},#{createTime},#{views})
      </insert>
  
      <select id="selectBlogIf" resultType="blog" parameterType="map">
          select * from blog
          <where>
              <if test="title!=null">
                  and title =#{title}
              </if>
              <if test="author != null">
                  and author = #{author}
              </if>
          </where>
      </select>
  
  </mapper>
  

• 测试类

    @Test
    public void selectBlogIfTest(){
        SqlSession sqlSession = null;
        try {
            sqlSession = MybatisUtils.getSqlSession();
            BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("author","dog");
            for (Blog blog : blogMapper.selectBlogIf(map)) {
                System.out.println(blog);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭sqlSession
            sqlSession.close();
        }
    }

choose,when,otherwise

    <select id="selectBlogIf" resultType="Blog" parameterType="map">
        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>

trim(where,set)

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

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

SQL片段

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

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

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

2. 在需要使用的地方使用include标签引用即可

   <update id="updateBlog" parameterType="map">
       update blog
       <set>
           <include refid="if-title-author"></include>
       </set>
       where id=#{id}
   </update>
   

3. 注意事项：

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

Foreach

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

但是 in() 怎么使用 里面还没有

小结

注意事项：

• 最好基于单标来定义SQL片段
• 不要存在where标签
• 动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了
• 建议：先在Mysql中写出完整的SQL，再对应的去修改成我们的动态SQL实现通用即可。

13，缓存

13.1 简介

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

一次查询的结果，给他暂存一个可以直接取到的地方 --> 内存：缓存(放在内存查询的数据)

我们再次查询的相同数据的时候，直接走缓存，不走数据库了`

1. 什么是缓存[Cache]

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

2. 为什么使用缓存？

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

3. 什么样的数据可以使用缓存？

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

读写问题（并发：多台客户机，多台服务器，同时读写）

加了一台缓存服务器

主从复制，读写分离，分布式缓存，

13.2 MyBatis缓存

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

13.3 一级缓存

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

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中

  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MATK4E61-1630561085170)(E:/%E5%AD%A6%E4%B9%A0/%E5%BC%80%E5%8F%91%E5%AD%A6%E4%B9%A0/MyBatis/Mybatis.assets/image-20210901161322733.png)]

13.3.1 测试

• 开启日志
• 测试在一个Session中查询两次记录

缓存一样，在一次SqlSession 会话中查询

• 查看日志输出

缓存失效的情况：

• 查询不同的东西
• 增删改操作，可能会改变原来的数据，所以必定会刷新缓存
• 查询不同的Mapper.xml
• 手动清理缓存
  
  小结：一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接-关闭连接这个区间

13.4 二级缓存

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存

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

• 工作机制

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

• 一级缓存开启（SqlSession级别的缓存，也称为本地缓存）

• 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。

• 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。
  
  步骤：

1. 开启缓存
   

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

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

   可以自已定义参数
   

   <!--在当前Mapper.xml中使用二级缓存开启二级缓存-->
       <cache
               eviction="FIFO"
               flushInterval="60000"
               size="512"
               readOnly="true"/>
   
       <select id="queryUserById"  resultType="user" useCache="true">
               select * from user where id=#{id}
       </select>
   

3. 测试

   1. 问题：我们需要讲实体类序列化！否则就会报错!
      

4. 小结

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

13.5 缓存原理

不同的mapper 如果namespace一样 那么缓存是一样的

注意：

• 只有查询才有缓存，根据数据是否需要缓存（修改是否频繁选择是否开启）useCache=“true”。只能关闭二级缓存，不能关闭一级缓存。
• 

13.6 自定义缓存-ehcache

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

• 1.导包

  <dependency>
      <groupId>org.mybatis.caches</groupId>
      <artifactId>mybatis-ehcache</artifactId>
      <version>1.2.1</version>
  </dependency>
  

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

  <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
  

项目

码云上有

下载仓库 · 霸波儿奔/订单管理系统 smbms 狂神说Java - Gitee.com