复习持久层框架Mybatis

最新推荐文章于 2022-04-24 16:42:00 发布

原创最新推荐文章于 2022-04-24 16:42:00 发布 · 275 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #mybatis #mysql

mybatis&mybatis-plus 专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了MyBatis框架的特性和使用方法，包括其历史背景、持久化概念、核心配置、CRUD操作、动态SQL、缓存机制等关键知识点，旨在帮助读者掌握MyBatis的高效数据库操作技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

1、MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

如何获取Mybatis？

maven仓库

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

1.2、持久化
数据持久化：持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（jdbc），io文件持久化。
生活eg：冷藏，罐头
为什么需要持久化？
内存断电即失，有一些对象不能让他丢掉。
内存太贵

1.3、持久层
Dao层、service层、Controller层
完成持久化工作的代码块
层界限十分明显。

1.4、为什么需要Mybatis？
帮助程序员将数据存入到数据库中。
传统的JDBC代码太复杂了，简化。框架。自动化
不用Mybatis也可以，更容易上手，技术没有高低之分。

Mybatis特性：
简单易学，灵活，不会对应程序产生影响，解除Sql和代码的分离，提供映射标签，提供对象关系映射标签，提供xml标签。

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

2、第一个Mybatis程序

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

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,'kiki','123456'),
(2,'张三','123456'),
(3,'李四','123456')

SELECT * FROM USER

2.1、新建项目

2.2、创建一个模块
编写mybatis核心配置文件
参考官网：https://mybatis.org/mybatis-3/zh/getting-started.html

<?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.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="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
    <!--每一个mapper.xml需要在mybatis核心配置文件中注册-->
        <mapper resource="com/kiki/dao/UserMapper.xml"/>
    </mappers>
</configuration>

定义mybatisUtils工具类

package com.kiki.utils;
/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 17:51
 */

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 {
            //1、获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

}

2.3、编写代码
实体类

package com.kiki.pojo;
/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 18:03
 */
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接口

package com.kiki.dao;

import com.kiki.pojo.User;

import java.util.List;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 18:06
 */
public interface UserDao {
    List<User> getUserList();

}

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

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kiki.dao.UserDao">
    <!--id与dao中方法名一致
        resultType返回值类型，全限定类名
    -->
    <select id="getUserList" resultType="com.kiki.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4、测试

package com.kiki.dao;
import com.kiki.pojo.User;
import com.kiki.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 18:40
 */
public class UserDaoTest {

    @Test
    public void test(){
        //1、获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //2、执行sql
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }


        sqlSession.close();
    }
}

3、CRUD

3.1、namespace
namespace中的包名要和Dao/Mapper接口的包名一致
3.2、select
id：就是对应的namespace中的方法名
resultType：sql语句执行的返回值
parameterType：参数类型

package com.kiki.dao;

import com.kiki.pojo.User;

import java.util.List;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 18:06
 */
public interface UserMapper {
    //获取全部用户
    List<User> getUserList();

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

    //insert一个用户
    int addUser(User user);

    //修改用户
    int updateUserById(User user);

    //删除用户
    int deleteUserById(int id);
}

<?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.kiki.dao.UserMapper">
    <!--id与dao中方法名一致
        resultType返回值类型，全限定类名
    -->
    <select id="getUserList" resultType="com.kiki.pojo.User">
        select * from mybatis.user
    </select>

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

    <insert id="addUser" parameterType="com.kiki.pojo.User" >
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>

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

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

package com.kiki.dao;

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

import java.util.List;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/7/3 18:40
 */
public class UserDaoTest {

    @Test
    public void test(){
        //1、获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //2、方式1执行sql
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        //方式2
       // List<User> userList = sqlSession.selectList("com.kiki.dao.UserDao.getUserList");


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


        sqlSession.close();
    }


    @Test
    public void test2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

    @Test
    public void test3(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int count = mapper.addUser(new User(4, "kiki4", "123456"));

        //必须提交事务，增删改
        sqlSession.commit();
        sqlSession.close();
    }


    @Test
    public void test4(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       mapper.updateUserById(new User(4,"小灰灰","123123"));

        //必须提交事务，增删改
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test5(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       mapper.deleteUserById(4);

        //必须提交事务，增删改
        sqlSession.commit();
        sqlSession.close();
    }
}

注意点：增删改需要提交事务

7、万能Map
假设我们的实体类，或者数据库中的表，字段或者参数过多
我们可以考虑使用map

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

<insert id="addUser" parameterType="com.kiki.pojo.User" >
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>

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

 @Test
    public void test31(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<String, Object>();

        map.put("userId",5);
        map.put("userName","Hello");
        map.put("password","2222222");

        //必须提交事务，增删改
        sqlSession.commit();
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可！[parameterType=“map”]
对象传递参数，直接在sql中取对象的属性即可！[]
只有一个基本类型参数的情况下，可以直接在sql中取到!

8、思考业务中出现的问题
1、模糊查询

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

确保用户能传的值是一个固定的，防止sql注入

4、配置解析

1、mybatis核心配置文件

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

2、环境配置（environments）
注意：尽管可以配置多个环境，但是每个SqlSessionFactory实例只能选择一种环境

<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="123456"/>
            </dataSource>
        </environment>

        <environment id="test">
            <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="123456"/>
            </dataSource>
        </environment>
    </environments>

3、属性（properties）
一般通过properties属性来实现引用配置文件
编写配置文件db.properties

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

在这里插入图片描述
4、类型别名（typeAliases）
类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。

 	<typeAliases>
        <!--可以给实体类起别名 ，这样在mapper.xml文件中就可以直接使用别名，简便-->
        <!--<typeAlias type="com.kiki.pojo.User" alias="User"/>-->

        <!--也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean
            每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。
        -->
        <package name="com.kiki.pojo"/>
    </typeAliases>

建议：
当实体类较少的时候建议使用第一种反之建议使用第二种
第一种可以自定义别名，而第二种则需要加注解才能自定义别名

5、设置（settings）
6、plugins
7、映射器（mappers）

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

如果使用class，或者package：则需要注意接口和它的mapper配置文件必须同名
还需要接口和它的mapper配置文件必须在同一个包下

注意：建议使用resource

8、生命周期和作用域

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

1、resultMap
结果集映射

id name pwd
id name password

<!--&lt;!&ndash;结果集映射&ndash;&gt;
    <resultMap id="UserMap" type="User">
        &lt;!&ndash;column数据库中的列
            property实体类中的属性
        &ndash;&gt;
        <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>-->

6、日志

6.1、如果一个数据库操作，出现了异常，我们需要排错，日志就是我们最好的帮手
在mybatis核心配置文件（mybatis-config）中配置日志

	<settings>
		标准的日志工厂实现
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

6.2、Log4j
1、先导入Log4j的包

 <!--日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

src/main/resource/log4j.properties

 @Test
    public void testLog4j(){
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }

7、分页

1、使用mybatis完成分页

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

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

        sqlSession.close();
    }

2、RowBounds
不再使用SQL实现分页

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

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

        RowBounds rowBounds = new RowBounds(1, 2);

        List<User> userList = sqlSession.selectList("com.kiki.dao.UserMapper.getUserByRowBounds",null,rowBounds);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

3、分页插件
mybatis PageHelper

4、注解开发
4.1面向接口编程：解耦，上层不用管具体的实现
4.2、使用注解开发
使用java注解
本质：反射机制，底层使用的动态代理

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

mybatis-config.xml

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

5、debug调试查看mybatis执行流程
在这里插入图片描述
@Param（）注解

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

    //方法存在多个参数，所有参数前面加@param注解
    @Select("select * from user where id=#{id}")
    User getUserById(@Param("id") int id);

    @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{pwd})")
    int addUser(User user);

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

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

9、Lombok

1、安装lombok插件
2、项目导入jar

10、多对一、一对多

按照查询嵌套处理

<?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.kiki.dao.StudentMapper">
    <!--
         SELECT s.`id`,s.`name`,t.`name` FROM student s,teacher t where s.`tid`=t.`id`
         思路：
            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>
</mapper>

按照结果嵌套处理

 <!--按照结果嵌套处理
        1、
   -->
    <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>

11、一对多处理

eg：一个老师拥有多个学生
按结果嵌套查询

<!--按结果嵌套查询-->
    <select id="getTeacher1" resultMap="TeacherStudent" parameterType="int">
        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"/>
        <!--
            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 teacher where id = #{tid}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId">
        </collection>
    </resultMap>
    <select id="getStudentByTeacherId" resultType="student">
        select * from student where tid=#{tid}
    </select>

总结：
1、关联association多对一（多个属于一个）
2、集合collection 一对多（一个包含多个）
3、javaType和ofType
1、javaType用来指定实体类中属性的类型
2、ofType用来指定映射到List或者集合中的pojo类型，也即是泛型中约束类型

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

12、动态SQL

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

    //查询博客
    List<Blog> queryBlogIF(Map map);

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

 @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        map.put("title","java基础");
        List<Blog> blogs = mapper.queryBlogIF(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        sqlSession.close();
    }

choose（when，otherwise）
如果条件都满足，则只会取第一个，若when中的都不满足，则必须要指定otherwise中的

<select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from blog
        <where>
            <choose>
                <when test="title != null">
                    title=#{title}
                </when>
                <when test="author != null">
                    and author=#{author}
                </when>
                <otherwise>
                    and views=#{views}
                </otherwise>
            </choose>
        </where>
    </select>

trim（where，set）

<select id="queryBlogIF" parameterType="map" resultType="blog">
        select *
        from 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 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

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

SELECT *

FROM POST P
WHERE ID in （1，2，3）

//查询id为1,2,3的信息
    List<Blog> queryBlogForeach(Map map);

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

    </select>

 @Test
    public void queryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        ArrayList<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        map.put("ids",ids);
        mapper.queryBlogForeach(map);
        sqlSession.close();
    }

SQL片段
有的时候可能会将一些公共的部分抽取出来，方便复用！

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

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

注意事项：
最好基于单表来定义SQL片段
不要存在where标签
动态SQL就是在拼接SQL语句，我们只需要保证SQL的正确性，按照SQL的格式，进行排列组合就可以了
步骤：
1、先在MySQL中写出完整的sql，再去对应的去修改成为我们的动态sql去实现通用就可以了

13、缓存

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

@Test
    public void testCache(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.queryUserById(1);
        System.out.println(user);
        System.out.println("=============================");

        User user1 = mapper.queryUserById(1);
        System.out.println(user1);
        System.out.println(user==user1);
        
        sqlSession.close();
    }

在这里插入图片描述

一级缓存失效的四种情况

1.sqlSession不同
每个sqlSession中的缓存相互独立
2、增删操作
3、查询不同的Mapper.xml
4、手动清理缓存，sqlSession.clearCache(); 清除缓存
一级缓存是默认开启的，只在一次SqlSession中有效，也就是在拿到连接到关闭连接这个区间段

一级缓存就是一个Map

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

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

2、在*Mapper.xml文件中
使用二级缓存

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

测试

 @Test
    public void testCache2(){
        SqlSession sqlSession1 = MybatisUtils.getSqlSession();
        SqlSession sqlSession2 = MybatisUtils.getSqlSession();
        UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
        User user1 = mapper1.queryUserById(1);
        System.out.println(user1);
        sqlSession1.close();



        System.out.println("=============================");



        User user2 = mapper2.queryUserById(1);
        System.out.println(user2);
        System.out.println(user1==user2);
        sqlSession2.close();
    }

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

13.5缓存原理
在这里插入图片描述

ehcache

Ehcache是一个纯Java进程内缓存框架，具有快速、精干等特点，是Hibernate默认的CacheProvider，主要面向通用缓存。

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