Mybatis学习

Mybatis学习

1、简介

1.1、什么是Mybatis

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

1.2、什么是持久化

• 数据持久化，即将程序的数据在持久状态和瞬时状态转化的过程。
• 可以理解为把数据长时间保存在存储设备中。
• 把操作存储设备的工作封装起来，有利于代码的重用。

1.3、如何获取Mybatis

• Maven仓库

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

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

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

2、第一个Mybatis程序

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

2.1、搭建环境

• 创建数据库

  CREATE DATABASE mybatis CHARSET utf8;
  USE mybatis;
  CREATE TABLE USER(
  id INT(10) NOT NULL PRIMARY KEY,
  username VARBINARY(15) DEFAULT NULL,
  pwd VARBINARY(15) DEFAULT NULL
  );
  

• 创建Maven项目

• 删除src文件夹，构建父工程

• 导入依赖 ：jdbc、mybatis、junit

  <!--导入依赖-->
  <dependencies>
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.23</version>
      </dependency>
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.9</version>
      </dependency>
      <!--单元测试 -->
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
      </dependency>
  </dependencies>
  

2.2、创建一个子模板

• 编写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>
      <environments default="development">
          <environment id="development">
              <transactionManager type="JDBC"/>
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://192.168.1.173:3306/mybatis?useSSL=true&amp;useUnicode=ture &amp; characterEncoding=utf8 &amp; useSSL=true"/>
                  <property name="username" value="root"/>
                  <property name="password" value="123456"/>
              </dataSource>
          </environment>
      </environments>
      
      <!--每一个mapper.xml都需要在Mybatis核心配置文件中注册-->
      <mappers>
          <mapper resource="com/sanmu/mapper/UserMapper.xml"/>
      </mappers>
  </configuration>
  

• 编写Mybatis工具类

  package com.sanmu.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;
  
  /**
   * Author：三木
   * Date：2022-05-16 14:43
   * Description：<Mybatis工具类>
   */
  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 的实例。
      // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
      public static SqlSession getSqlSession(){
          return  sqlSessionFactory.openSession();
      }
  }
  

2.3、编写代码

• 实体类

  package com.sanmu.pojo;
  
  /**
   * Author：三木
   * Date：2022-05-16 15:00
   * Description：<描述>
   */
  public class User {
      private Integer id;
      private String username;
      private String pwd;
  
      public User(Integer id, String username, String pwd) {
          this.id = id;
          this.username = username;
          this.pwd = pwd;
      }
  
      public User() {
      }
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getUsername() {
          return username;
      }
  
      public void setUsername(String username) {
          this.username = username;
      }
  
      public String getPwd() {
          return pwd;
      }
  
      public void setPwd(String pwd) {
          this.pwd = pwd;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", username='" + username + '\'' +
                  ", pwd='" + pwd + '\'' +
                  '}';
      }
  }
  

• mapper接口

  package com.sanmu.mapper;
  
  import com.sanmu.pojo.User;
  
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-16 15:03
   * Description：<描述>
   */
  public interface UserMapper {
      List<User> getUserList();
  }
  

• 接口实现类，即UserMapper.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">
  <!--namespace：绑定一个mapper接口-->
  <mapper namespace="com.sanmu.mapper.UserMapper">
      <select id="getUserList" resultType="com.sanmu.pojo.User">
          select * from mybatis.user
      </select>
  </mapper>
  

2.4、测试

注意报错：org.apache.ibatis.binding.BindingException: Type interface com.sanmu.mapper.UserMapper is not known to the MapperRegistry.

原因：没有在Mybatis核心配置文件中注册mapper.xml

package com.sanmu.mapper;

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

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-16 15:15
 * Description：<描述>
 */
public class UserMapperTest {
    @Test
    public void test(){
        //第一步，获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //第二部，执行sql
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //第三步，获取结果
        List<User> userList = mapper.getUserList();
        for (User user:userList){
            System.out.println(user);
        }
        //关闭sqlSession
        sqlSession.close();
    }
}

3、增删改查

3.1、属性解释

<?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.sanmu.mapper.UserMapper">
    <select id="getUserList" resultType="com.sanmu.pojo.User" parameterType="int">
        select * from mybatis.user
    </select>
</mapper>

• namespace：中的包名要和Mapper接口的包名一致
• id：对应接口的方法名
• resultType：Sql语句执行的返回值
• parameterType：参数类型

3.2、查询

public interface UserMapper {
    //根据id查找
    List<User> getIdUser(int id);
}

<mapper namespace="com.sanmu.mapper.UserMapper">
    <select id="getIdUser" parameterType="int" resultType="com.sanmu.pojo.User">
        select * from mybatis.user where id =#{id};
    </select>
</mapper>

//根据id查找
@Test
public void idtest(){
    //第一步，获取sqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //第二部，执行sql
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //第三步，获取结果
    List<User> userList = mapper.getIdUser(2);
    System.out.println(userList);
    //关闭sqlSession
    sqlSession.close();
}

3.3、增加

public interface UserMapper {
   //增加
    int addUser(User user);
}

<!--增加，使用#{}将对象中的属性取出-->
<insert id="addUser" parameterType="com.sanmu.pojo.User">
    insert into mybatis.user(id,username,pwd) values(#{id},#{username},#{pwd});
</insert>

//增加
@Test
public void addtest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int cout = mapper.addUser(new User(3, "小米", "123232"));
    if(cout>0){
        System.out.println("插入成功");
    }
    //提交事务
    sqlSession.commit();
    sqlSession.close();
}

3.4、删除

public interface UserMapper {
   //根据id删除用户
    int deleteUser(int id);
}

<!--根据id删除用户-->
<delete id="deleteUser" parameterType="int" >
    delete from user where id=#{id};
</delete>

//删除
@Test
public void deletetest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int cout =mapper.deleteUser(2);
    if(cout>0){
        System.out.println("删除成功");
    }
    //提交事务
    sqlSession.commit();
    sqlSession.close();
}

3.5、修改

public interface UserMapper {
   //根据id修改用户
    int createUser(User user);
}

<!-- 修改用户 -->
<update id="createUser" parameterType="com.sanmu.pojo.User" >
    update user set username=#{username},pwd=#{pwd} where id=#{id};
</update>

//修改
@Test
public void updatetest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int cout =mapper.createUser(new User(1,"莉莉","909080"));
    if(cout>0){
        System.out.println("修改成功");
    }
    //提交事务
    sqlSession.commit();
    sqlSession.close();
}

3.6、使用Map集合传递参数

当实体类或者数据库中的表、字段或者参数过多时，我们应该考虑使用Map。Map传递参数，直接在sql中取出key

public interface UserMapper {
   //使用Map集合传递参数
    //增加
    int addUser1(Map<String ,Object> map);
}

<!--使用Map集合传递参数-->
<!--增加-->
<insert id="addUser1" parameterType="map">
    insert into mybatis.user(id,username,pwd) values(#{userid},#{name},#{pwd});
</insert>

//使用Map集合传递参数
//增加
@Test
public void addtest1(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String , Object> map = new HashMap<>();
    map.put("userid",2);
    map.put("name","木马");
    map.put("pwd","908908");
    int i = mapper.addUser1(map);
    if(i>0){
        System.out.println("成功");
    }
    sqlSession.commit();
    sqlSession.close();
}

3.7、模糊查询

在进行模糊查询时，可以在Java代码执行的时候传递通配符%

public interface UserMapper {
   //模糊查询
    List<User> userlike(String name);
}

<!--模糊查询-->
<select id="userlike" resultType="com.sanmu.pojo.User">
    select * from user where username like #{name};
</select>

//模糊查询
@Test
public void userlike(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> user = mapper.userlike("%木%");
    for(User user1:user){
        System.out.println(user1);
    }
    sqlSession.close();
}

4、配置解析

4.1、核心配置文件-mybatis-config.xml

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-stMzndGd-1664443549525)(D:\studys\笔记\资料\Mybatis\配置.png)]

4.2、环境配置（environments）

Mybatis可以配置成适应多种环境。

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

<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>
    <environment id="test">
        <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>

• 事务管理器（transactionManager）：JDBC（默认）、MANAGED（一般不用）
• 数据源（dataSource）：UNPOOLED（没有池）、POOLED（有池）、JNDI

4.3、属性（properties）

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

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

#db.properties
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://192.168.171.3:3306/mybatis?useSSL=true&useUnicode=ture&characterEncoding=utf8&useSSL=true
username=root
password=123456

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.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>
    <mappers>
        <mapper resource="com/sanmu/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

4.4、类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

方法一

<typeAliases>
    <typeAlias type="com.sanmu.pojo.User" alias="User"/>
</typeAliases>

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

方法二：指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean。若有注解，则别名为其注解值。默认别名为这个类的小写类名。

<typeAliases>
    <package name="com.sanmu.pojo"/>
</typeAliases>

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

@Alias("User")
public class User {
    ....
}

在实体类较少时使用方法一，较多时使用方法二。方法一可以DIY(自定义)别名，方法二不行

4.5、设置（settings）

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

一个配置完整的 settings 元素:

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.6、映射器（mappers）

告诉 MyBatis 到哪里去找映射文件

方式一

<!-- 使用相对于类路径的资源引用 -->
<mappers>
    <mapper resource="com/sanmu/mapper/UserMapper.xml"/>
</mappers>

方式二：接口和他的Mapper配置文件必须同名；接口和他的Mapper配置文件必须在同一个包下

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="com.sanmu.mapper.UserMapper"/>
</mappers>

方式三：接口和他的Mapper配置文件必须同名；接口和他的Mapper配置文件必须在同一个包下

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="com.sanmu.mapper"/>
</mappers>

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

5.1、问题

Java实体类的变量与数据库的字段名不一致，查询出来的结果会为空。

解决方法：

• 编写sql语句时，为字段名起别名，使之与实体类一致。

  <select id="getUserList" resultType="User" parameterType="int">
      select id,username,pwd as possward from mybatis.user
  </select>
  

• 使用resultMap结果集映射

5.2、resultMap

resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

<mapper namespace="com.sanmu.mapper.UserMapper">
    <!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <!--column数据库中的字段，property实体类中的属性-->
        <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserList" resultMap="UserMap" parameterType="int">
        select * from mybatis.user
    </select>
</mapper>

package com.sanmu.pojo;

import org.apache.ibatis.type.Alias;

/**
 * Author：三木
 * Date：2022-05-16 15:00
 * Description：<描述>
 */
@Alias("User")
public class User {
    private Integer id;
    private String username;
    private String password;

    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPwd() {
        return password;
    }

    public void setPwd(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", pwd='" + password + '\'' +
                '}';
    }
}

6、日志

6.1、日志工厂

**logImpl：指定 MyBatis 所用日志的具体实现，未指定时将自动查找。**如下：

• SLF4J
• LOG4J(deprecated since 3.5.9) （掌握）
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING（掌握）
• NO_LOGGING

STDOUT_LOGGING标准日志输出，在mybatis核心配置文件中设置；注意空格

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

6.2、LOG4J

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；可以通过一个配置文件来灵活地进行配置。

• 导入log4j包

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

• 编写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.DailyRollingFileAppender
  log4j.appender.file.File=./log/sanmu.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
  

• 配置日志

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

• 测试

  import org.apache.log4j.Logger;
  import org.junit.Test;
  
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-16 15:15
   * Description：<描述>
   */
  public class UserMapperTest {
      static Logger logger=Logger.getLogger(UserMapperTest.class);
      @Test
      public void testlog4j(){
          logger.info("info：进入测试");
          logger.debug("debug：进入测试");
          logger.error("error：进入测试");
      }
  }
  

7、分页

使用mybatis实现分页

• 编写接口

  package com.sanmu.mapper;
  
  import com.sanmu.pojo.User;
  
  import java.util.List;
  import java.util.Map;
  
  /**
   * Author：三木
   * Date：2022-05-16 15:03
   * Description：<描述>
   */
  public interface UserMapper {
      //分页
      List<User> getLimit(Map<String,Integer> map);
  }
  

• 编写sql

  <?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.sanmu.mapper.UserMapper">
  
      <!--结果集映射-->
      <resultMap id="UserMap" type="User">
          <!--column数据库中的字段，property实体类中的属性-->
          <result column="pwd" property="password"/>
      </resultMap>
      <!-- 分页 -->
      <select id="getLimit" parameterType="map" resultMap="UserMap">
          select * from user limit #{startIndex},#{pageSize};
      </select>
  
  </mapper>
  

• 测试

  import com.sanmu.mapper.UserMapper;
  import com.sanmu.pojo.User;
  import com.sanmu.utils.MybatisUtils;
  import org.apache.ibatis.session.SqlSession;
  import org.junit.Test;
  
  import java.util.HashMap;
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-16 15:15
   * Description：<描述>
   */
  public class UserMapperTest {
      @Test
      public void getLimit(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          UserMapper mapper = sqlSession.getMapper(UserMapper.class);
          HashMap<String, Integer> map = new HashMap<>();
          map.put("startIndex",0);
          map.put("pageSize",2);
          List<User> limit = mapper.getLimit(map);
          System.out.println(limit);
          sqlSession.close();
      }
  }
  

7.1、分页插件—PageHelper

8、使用注解开发

package com.sanmu.mapper;

import com.sanmu.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-16 15:03
 * Description：<使用注解开发>
 */
public interface UserMapper {
    //查询
    @Select("select * from user")
    List<User> getUserList();
    //根据id查找,方法存在多个参数，所有的参数前面必须加上@Param("id")注解
    @Select("select * from user where id= #{id}")
    List<User> getIdUser(@Param("id") int id);
    //增加
    @Insert("insert into user(id,username,pwd) values(#{id},#{username},#{pwd})")
    int add(User user);
    //修改
    @Update("update user set username=#{username},pwd=#{pwd} where id=#{id}")
    int update(User user);
    //删除
    @Delete("delete from user where id=#{id}")
    int delete(@Param("id") int id);

}

<!--mybatis-config.xml-->
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"/>
    <typeAliases>
        <typeAlias type="com.sanmu.pojo.User" alias="User"/>
    </typeAliases>
    <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>
    <!-- 绑定接口 -->
    <mappers>
       <mapper class="com.sanmu.mapper.UserMapper"/>
    </mappers>
</configuration>

import com.sanmu.mapper.UserMapper;
import com.sanmu.pojo.User;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

/**
 * Author：三木
 * Date：2022-05-16 15:15
 * Description：<测试>
 */
public class UserMapperTest {
    @Test
    public void getUserList(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> idUser = mapper.getIdUser(1);
        for(User user:idUser){
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void add(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.add(new User(4, "哦啊", "09034"));
        System.out.println("插入成功");
        sqlSession.close();
    }
    @Test
    public void update(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.update(new User(4, "ooi", "09034"));
        System.out.println("修改成功");
        sqlSession.close();
    }
    @Test
    public void delete(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int delete = mapper.delete(4);
        System.out.println("删除成功");
        sqlSession.close();
    }
}

关于@Param()注解

• 基本数据类型的参数或者String类型，需要加上
• 引用类型不需要
• 在SQL中引用的是@Param(“id")中的属性名

9、lombok

Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码。使用注解可以减少实体类源码的编写。

10、多对一处理

多个学生对应一个老师

• 创建数据库

USE mybatis;
CREATE TABLE teacher(
 id INT(10) NOT NULL,
 NAME VARBINARY(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 VARBINARY(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);

• 编写实体类

package com.sanmu.pojo;

/**
 * Author：三木
 * Date：2022-05-23 16:58
 * Description：<描述>
 */
public class Student {
    private int id;
    private String name;
    private Teacher teacher;

    public Student() {
    }

    public Student(int id, String name, Teacher teacher) {
        this.id = id;
        this.name = name;
        this.teacher = teacher;
    }

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }
}

package com.sanmu.pojo;

/**
 * Author：三木
 * Date：2022-05-23 16:55
 * Description：<描述>
 */
public class Teacher {
    private int id;
    private String name;
    private int tid;

    public Teacher() {
    }

    public Teacher(int id, String name) {
        this.id = id;
        this.name = name;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

• 编写映射文件–StudentMapper.xml、TeacherMapper.xml

• 绑定接口–mybatis-config.xml

<!-- 绑定接口 -->
<mappers>
    <mapper class="com.sanmu.mapper.TeacherMapper"/>
    <mapper class="com.sanmu.mapper.StudentMapper"/>
</mappers>

• 测试

import com.sanmu.mapper.TeacherMapper;
import com.sanmu.pojo.Teacher;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/**
 * Author：三木
 * Date：2022-05-23 17:02
 * Description：<描述>
 */
public class TeacherTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
        sqlSession.close();
    }
}

10.1、按照查询嵌套处理

package com.sanmu.mapper;

import com.sanmu.pojo.Student;

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-23 16:59
 * Description：<描述>
 */
public interface StudentMapper {
    //查询所有学生的信息，以及对应的老师的信息
    public List<Student> getStudent();
}

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sanmu.mapper.StudentMapper">
    <!--按照查询嵌套处理
    思路：
        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=#{tid}
    </select>
</mapper>

import com.sanmu.mapper.StudentMapper;
import com.sanmu.mapper.TeacherMapper;
import com.sanmu.pojo.Student;
import com.sanmu.pojo.Teacher;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-23 17:02
 * Description：<描述>
 */
public class TeacherTest {
    @Test
    public void getStudent(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.getStudent();
        for(Student student:studentList){
            System.out.println(student);
        }
        sqlSession.close();
    }
}

10.2、按照结果嵌套处理

package com.sanmu.mapper;

import com.sanmu.pojo.Student;

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-23 16:59
 * Description：<描述>
 */
public interface StudentMapper {
    //查询所有学生的信息，以及对应的老师的信息
    public List<Student> getStudent2();
}

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sanmu.mapper.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>
</mapper>

import com.sanmu.mapper.StudentMapper;
import com.sanmu.mapper.TeacherMapper;
import com.sanmu.pojo.Student;
import com.sanmu.pojo.Teacher;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

/**
 * Author：三木
 * Date：2022-05-23 17:02
 * Description：<描述>
 */
public class TeacherTest {
    @Test
    public void getStudent2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.getStudent2();
        for(Student student:studentList){
            System.out.println(student);
        }
        sqlSession.close();
    }
}

11、一对多处理

一个老师对应多个学生

• 编写实体类

  package com.sanmu.pojo;
  
  /**
   * Author：三木
   * Date：2022-05-23 16:58
   * Description：<描述>
   */
  public class Student {
      private int id;
      private String name;
      private int tid;
  
      public Student() {
      }
  
      public Student(int id, String name, int tid) {
          this.id = id;
          this.name = name;
          this.tid = tid;
      }
  
      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 int getTid() {
          return tid;
      }
  
      public void setTid(int tid) {
          this.tid = tid;
      }
  
      @Override
      public String toString() {
          return "Student{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", tid=" + tid +
                  '}';
      }
  }
  

  package com.sanmu.pojo;
  
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-23 16:55
   * Description：<描述>
   */
  public class Teacher {
      private int id;
      private String name;
      private List<Student> students;
  
      public Teacher() {
      }
  
      public Teacher(int id, String name, List<Student> students) {
          this.id = id;
          this.name = name;
          this.students = students;
      }
  
      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 List<Student> getStudents() {
          return students;
      }
  
      public void setStudents(List<Student> students) {
          this.students = students;
      }
  
      @Override
      public String toString() {
          return "Teacher{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", students=" + students +
                  '}';
      }
  }
  

• 编写mapper接口

  package com.sanmu.mapper;
  
  import com.sanmu.pojo.Teacher;
  import org.apache.ibatis.annotations.Param;
  import org.apache.ibatis.annotations.Select;
  
  /**
   * Author：三木
   * Date：2022-05-23 16:59
   * Description：<描述>
   */
  public interface TeacherMapper {
  
      //获取指定老师下的所有学学生以及老师的信息
      Teacher getTeacher(@Param("tid") int id);
      Teacher getTeacher2(@Param("tid") int id);
  }
  

• 编写映射文件

  <?xml version="1.0" encoding="UTF8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.sanmu.mapper.TeacherMapper">
  
      <!--按照结果嵌套处理-->
      <select id="getTeacher" resultMap="TeacherStudent">
          select s.id sid,s.name sname,t.id tid,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"/>
          <!-- 集合使用collection，集合中的泛型使用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 teacher where id=#{tid}
      </select>
      <resultMap id="TeacherStudent2" type="Teacher">
          <collection property="students" javaType="ArrayList" ofType="Student" select="getStudent" column="id"/>
      </resultMap>
      <select id="getStudent" resultType="Student">
          select * from student where tid=#{tid}
      </select>
  </mapper>
  

• 注册接口

• 测试

  import com.sanmu.mapper.StudentMapper;
  import com.sanmu.mapper.TeacherMapper;
  import com.sanmu.pojo.Student;
  import com.sanmu.pojo.Teacher;
  import com.sanmu.utils.MybatisUtils;
  import org.apache.ibatis.session.SqlSession;
  import org.junit.Test;
  
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-23 17:02
   * Description：<描述>
   */
  public class TeacherTest {
      @Test
      public void getTeacher(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
          Teacher teacher = mapper.getTeacher(1);
          System.out.println(teacher);
          sqlSession.close();
      }
      @Test
      public void getTeacher2(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
          Teacher teacher = mapper.getTeacher2(1);
          System.out.println(teacher);
          sqlSession.close();
      }
  }
  

11.1、小结

• 关联：association【多对一】
• 集合：collection【一对多】
• javaType：用来指定实体类中属性的类型
• ofType：用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

12、动态SQL

12.1、简介

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

动态sql使用：

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

12.2、环境搭建

• 创建数据库

  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 '浏览量',
   PRIMARY KEY(id)
  )ENGINE = INNODB DEFAULT CHARSET=utf8
  

• 导包

  <dependencies>
      <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.18.22</version>
      </dependency>
      <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter</artifactId>
          <version>RELEASE</version>
          <scope>compile</scope>
      </dependency>
  </dependencies>
  

• 编写实体类

  package com.sanmu.pojo;
  
  import lombok.Data;
  
  import java.util.Date;
  
  /**
   * Author：三木
   * Date：2022-05-25 16:04
   * Description：<blog实体类，并使用lombok注解>
   */
  @Data
  public class Blog {
      private String id;
      private String title;
      private String author;
      private Date createTime;//属性名与字段名不一致，使用驼峰命名规则
      private int views;
  }
  

• 编写工具类IDutils.java，用于生成唯一标识码id

  package com.sanmu.utils;
  
  import org.junit.jupiter.api.Test;
  
  import java.util.UUID;
  
  /**
   * Author：三木
   * Date：2022-05-25 16:11
   * Description：<id使用UUID，生成唯一标识码>
   */
  public class IDutils {
      public static String getId(){
          return UUID.randomUUID().toString().replace("-","");
      }
      @Test
      public void MyTest(){
          System.out.println(IDutils.getId());
      }
  
  }
  

• 编写实体类对应的接口及mapper.xml

  package com.sanmu.mapper;
  
  import com.sanmu.pojo.Blog;
  
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-25 16:09
   * Description：<描述>
   */
  public interface BlogMapper {
      //插入
      int addBlog(Blog blog);
  }
  

  <?xml version="1.0" encoding="UTF8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.sanmu.mapper.BlogMapper">
      <insert id="addBlog" parameterType="blog">
          insert into blog(id,title,author,create_time,views) values
          (#{id},#{title},#{author},#{createTime},#{views})
      </insert>
  </mapper>
  

• 编写核心配置文件

  <?xml version="1.0" encoding="UTF8" ?>
  <!DOCTYPE configuration
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-config.dtd">
  <configuration>
      <properties resource="db.properties"/>
      <!-- 开启驼峰命名自动映射-->
      <settings>
          <setting name="mapUnderscoreToCamelCase" value="true"/>
      </settings>
      <typeAliases>
          <typeAlias type="com.sanmu.pojo.Blog" alias="Blog"/>
      </typeAliases>
      <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>
      <!-- 绑定接口 -->
      <mappers>
          <mapper class="com.sanmu.mapper.BlogMapper"/>
      </mappers>
  </configuration>
  

• 测试

  import com.sanmu.mapper.BlogMapper;
  import com.sanmu.pojo.Blog;
  import com.sanmu.utils.IDutils;
  import com.sanmu.utils.MybatisUtils;
  import org.apache.ibatis.session.SqlSession;
  import org.junit.Test;
  
  import java.util.Date;
  import java.util.List;
  
  /**
   * Author：三木
   * Date：2022-05-25 16:22
   * Description：<描述>
   */
  public class MyTest {
      @Test
      public void add(){
          SqlSession sqlSession = MybatisUtils.getSqlSession();
          BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
          Blog blog=new Blog();
          blog.setId(IDutils.getId());
          blog.setTitle("Mybatis学习");
          blog.setAuthor("sanmu");
          blog.setCreateTime(new Date());
          blog.setViews(999);
          mapper.addBlog(blog);
  
          blog.setId(IDutils.getId());
          blog.setTitle("IDEA使用");
          mapper.addBlog(blog);
  
          blog.setId(IDutils.getId());
          blog.setTitle("Java基础教程");
          mapper.addBlog(blog);
  
          sqlSession.close();
      }
  }
  

12.3、if、where

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

package com.sanmu.mapper;

import com.sanmu.pojo.Blog;

import java.util.List;
import java.util.Map;

/**
 * Author：三木
 * Date：2022-05-25 16:09
 * Description：<描述>
 */
public interface BlogMapper {
    //查询
    List<Blog> getBlog(Map map);
}

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sanmu.mapper.BlogMapper">
    <select id="getBlog" 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>

import com.sanmu.mapper.BlogMapper;
import com.sanmu.pojo.Blog;
import com.sanmu.utils.IDutils;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * Author：三木
 * Date：2022-05-25 16:22
 * Description：<描述>
 */
public class MyTest {
    @Test
    public void getBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        //map.put("title","Mybatis学习");
        map.put("author","sanmu");
        List<Blog> blogList = mapper.getBlog(map);
        for (Blog blog : blogList) {
            System.out.println(blog);
        }
        sqlSession.close();
    }
}

12.4、choose 、when,、otherwise

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

<select id="getBlog2" 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>
                views=#{views}
            </otherwise>
        </choose>
    </where>
</select>

12.5、set

set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号。

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

12.6、SQL片段

将一些公共的部分抽取出来，方便复用

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

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

• 在需要使用的地方用include标签引用

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

12.7、foreach

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。

可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

package com.sanmu.mapper;

import com.sanmu.pojo.Blog;

import java.util.List;
import java.util.Map;

/**
 * Author：三木
 * Date：2022-05-25 16:09
 * Description：<描述>
 */
public interface BlogMapper {
    //查询第1，2，3号记录的博客
    List<Blog> getBlogForeach(Map map);
}

<select id="getBlogForeach" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <foreach collection="ids" item="id" open="(" close=")" separator="or">
            id = #{id}
        </foreach>
    </where>
</select>

import com.sanmu.mapper.BlogMapper;
import com.sanmu.pojo.Blog;
import com.sanmu.utils.IDutils;
import com.sanmu.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * Author：三木
 * Date：2022-05-25 16:22
 * Description：<描述>
 */
public class MyTest {
    @Test
    public void getBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        List<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        HashMap map = new HashMap();
        map.put("ids",ids);
        List<Blog> blogList = mapper.getBlogForeach(map);
        for (Blog blog : blogList) {
            System.out.println(blog);
        }
        sqlSession.close();
    }
}

13、缓存

13.1、简介

什么是缓存

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

为什么使用缓存

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

什么样的数据能使用缓存

• 经常需要查询并且不经常改变的数据

13.2、Mybatis缓存

MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。

Mybatis系统定义了两个缓存：一级缓存和二级缓存

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

13.3、一级缓存

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

缓存失效的情况

• 查询不同的东西
• 增删改操作，可能会改变原来的数据，所以必定会刷新缓存
• 查询不同的Mapprt.xml
• 手动清理缓存：sqlSession.clearCache();

13.4、二级缓存

工作机制

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

要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：

步骤：

• 开启全局缓存

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

  **cacheEnabled：**全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。默认值true

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

  <?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.sanmu.mapper.UserMapper">
      <cache/>
  </mapper>
  

  自定义属性

  <?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.sanmu.mapper.UserMapper">
      <cache
          eviction="FIFO"
          flushInterval="60000"
          size="512"
          readOnly="true"/>
  </mapper>
  

  创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的。

  用的清除策略有：

  LRU – 最近最少使用：移除最长时间不被使用的对象。
  FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
  SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
  WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。
  

  默认的清除策略是 LRU。

二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。

**问题：**使用，会报错Error serializing object.，我们需要将实体类序列化

public class User implements Serializable{
    
}

总结：

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

13.5、缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DJ8V2weO-1664443549526)(D:\studys\笔记\资料\Mybatis\mybatis缓存原理.jpg)]

13.6、自定义缓存-ehcache

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

• 导包

  <dependencies>
      <!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
      <dependency>
          <groupId>org.mybatis.caches</groupId>
          <artifactId>mybatis-ehcache</artifactId>
          <version>1.2.1</version>
      </dependency>
  </dependencies>
  

• 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 path="java.io.tmpdir/ehcache"/>
  
      <!-- 默认缓存 -->
      <!--
         name:缓存名称。
         maxElementsInMemory：缓存最大个数。
         eternal:对象是否永久有效，一但设置了，timeout将不起作用。
         timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。
                               仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
         timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。
                               仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
         overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
         diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
         maxElementsOnDisk：硬盘最大缓存个数。
         diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
         diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
         memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
           默认策略是LRU（最近最少使用）。
           你可以设置为FIFO（先进先出）
           或是LFU（较少使用）。
         clearOnFlush：内存数量最大时是否清除。
      -->
      <defaultCache
              maxElementsInMemory="10"
              eternal="false"
              timeToIdleSeconds="3600"
              timeToLiveSeconds="3600"
              overflowToDisk="true"
              memoryStoreEvictionPolicy="LRU"/>
      <!-- deptrole缓存 -->
      <cache name="deptrole"
             maxElementsInMemory="10"
             eternal="false"
             timeToIdleSeconds="86400"
             timeToLiveSeconds="86400"
             overflowToDisk="true"
             memoryStoreEvictionPolicy="LRU"/>
  </ehcache>
  

• 使用

  <?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.sanmu.mapper.UserMapper">
      <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
      <select id="getUserList" resultType="User" parameterType="_int" useCache="true">
          select * from user where id=#{id}
      </select>
  </mapper>
  

  xsi:noNamespaceSchemaLocation=“http://ehcache.org/ehcache.xsd”
  updateCheck=“false”>
  
  

  <!-- 默认缓存 -->
  <!--
     name:缓存名称。
     maxElementsInMemory：缓存最大个数。
     eternal:对象是否永久有效，一但设置了，timeout将不起作用。
     timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。
                           仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
     timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。
                           仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
     overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
     diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
     maxElementsOnDisk：硬盘最大缓存个数。
     diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
     diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
     memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
       默认策略是LRU（最近最少使用）。
       你可以设置为FIFO（先进先出）
       或是LFU（较少使用）。
     clearOnFlush：内存数量最大时是否清除。
  -->
  <defaultCache
          maxElementsInMemory="10"
          eternal="false"
          timeToIdleSeconds="3600"
          timeToLiveSeconds="3600"
          overflowToDisk="true"
          memoryStoreEvictionPolicy="LRU"/>
  <!-- deptrole缓存 -->
  <cache name="deptrole"
         maxElementsInMemory="10"
         eternal="false"
         timeToIdleSeconds="86400"
         timeToLiveSeconds="86400"
         overflowToDisk="true"
         memoryStoreEvictionPolicy="LRU"/>
  

  ```

• 使用

  <?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.sanmu.mapper.UserMapper">
      <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
      <select id="getUserList" resultType="User" parameterType="_int" useCache="true">
          select * from user where id=#{id}
      </select>
  </mapper>