Mybatis框架的基本使用

最新推荐文章于 2023-04-23 17:46:57 发布

@frist

最新推荐文章于 2023-04-23 17:46:57 发布

阅读量198

点赞数

分类专栏：框架文章标签： mybatis

本文链接：https://blog.csdn.net/m0_46515170/article/details/118087868

版权

框架专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Mybatis框架的基本使用

一，一个简单的测试代码

1.1，搭建环境

创建一个普通的maven项目
删除src目录（就可以把此工程当做父工程了，然后创建子工程）
导入maven依赖

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

1.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核心配置文件-->
<configuration>
	<!--environments 环境配置-->
    <environments default="development">
    	<!--environment 某一个环境-->
        <environment id="development">
        	<!--transactionManager 事物管理器-->
            <transactionManager type="JDBC"/>
            <!--dataSource 数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

编写mybatis工具类(方便我们直接获取sqlSession)

//sqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;
    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();
    }
}

1.3 ,编写代码

1.3.1，实体类

public class User {
	
	private int id;
	private String name;
	private int age;
		
	public User() {}
	public User(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}
	
	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 getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
}

1.3.2，Dao接口

public interface UserDao {
	//获取所有用户
    public List<User> getUserList();
    //通过id找到一个用户
    public User getUserById(int id);
}

1.3.3，Dao接口实现类（由原来的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.swkj.dao.UserDao">
    <select id="getUserList" resultType="com.swkj.pojo.User">
    	select * from USER
  	</select>
  	<select id="getUserById" resultType="com.swkj.pojo.User">
    	select * from USER where id = #{id}
  	</select>
</mapper>

1.4，开始测试

通过junit测试
这里用Test类去代表servlet

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

	 @Test
    public void getUserByIdTest(){
        //1.获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //2.执行SQL
        // 方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        //想要获取的学生id，从客户手中获取，我们这里手动赋值
        int id = 10;
        User user = userDao.getUserById(id);
        //打印出该用户的信息
        System.out.println(user);      
        //关闭sqlSession
        sqlSession.close();
    }

可能会遇到的问题：

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

二，简单的增删改查（CURD）

2.1 编写接口

public interface UserMapper {
	//增加用户
    public void addUser(User user);
    //删除用户
    public void deleteUser(int id);
    //修改用户
    public void updateUser(int id,User user);
    //通过id查询到某一个用户
    public User getUserById(int id);
    //查询所有用户
    public List<User> getUserList();   
}

2.2 编写Mapper文件中的sql语句

<!--增加用户-->
<insert id="addUser" parameterType="com.kuang.pojo.User">
    insert into user (id,name,age) values (#{id}, #{name}, #{age})
</insert>

<!--删除用户-->
<insert id="deleteUser" parameterType="java.lang.Integer">
    delete from user where id = #{id}
</insert>

<!--修改用户-->
<insert id="updateUser" parameterType="java.util.Map">
    update user set (id=#{befoerId},name=#{name},age=#{age}) where id=#{afterId}
</insert>

<!--查找所有用户-->
<select id="getUserList" resultType="com.swkj.pojo.User">
    	select * from USER
</select>

<!--通过id找到某一个用户-->
<select id="getUserById" resultType="com.swkj.pojo.User">
    	select * from USER where id = #{id}
</select>

2.3 开始测试

@Test
public void test() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    //增加用户
    User user1  = new User(3,"黑子",19);
    mapper.addUser(user1);
    
    //删除用户
    int id = 2;
    mapper.deleteUser(id);

	//修改用户 
	//先创建一个map，用来保存要存入的数据
    HashMap<String, Object> map = new HashMap<String, Object>();
    //将要保存的数据存入map当中
    map.put("beforeId",5);
    map.put("afterId",6);
    map.put("username","六六");
    map.put("userage",20);
    
	mapper.updateUser(maper);
    //增删改一定要提交事务
    sqlSession.commit();
	
	//由于查询的操作在上面实例当中已经展现，这里不再进行编写
	
    //关闭sqlSession
    sqlSession.close();
}

注意：增删改查一定要提交事务：

sqlSession.commit();

2.4 万能Map

如果实体类，或者数据库中的表，字段或者参数过多，应该使用Map!

2.4.1 编写接口

public interface UserMapper {
	//用万能Map插入用户
	public void addUser2(Map<String,Object> map);
}

2.4.2 编写Mapper文件

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

2.4.3 测试

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //先创建一个map，用来保存要存入的数据
        HashMap<String, Object> map = new HashMap<String, Object>();
        //将要保存的数据存入map当中
        map.put("userid",5);
        map.put("username","王虎");
        map.put("userage",20);
		//添加用户
        mapper.addUser2(map);
        //提交事务
        sqlSession.commit();
        //关闭资源
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可!【parameter=“map”】
对象传递参数，直接在sql中取出对象的属性即可【parameter=“Object”】
只有一个基本类型参数的情况下，可以直接在sql中取到多个参数用Map , 或者注解！

2.5 模糊查询

编写接口当中的模糊查询方法

public interface UserMapper {
	//模糊查询出用户
	//这里的参数str指的是查询的时候需要传入的通配符,tager指的是按照什么字段模糊
	public List<User> getUserLike(String str,String tager);  
}

编写Mapper文件

<!--模糊查询用户-->
<!--方式一-->
<select id="getUserLike1" resultType="com.swkj.pojo.User">
    	select * from user where #{tager} like #{str}
</select>

<!--方式二-->
<select id="getUserLike2" resultType="com.swkj.pojo.User">
		<!--直接在sql拼接中使用通配符-->
		select * from user where #{tager} like "%"#{str}"%"
</select>

测试

@Test
    public void getUserLikeTest1(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //先创建一个map，用来保存要存入的数据
        HashMap<String, Object> map = new HashMap<String, Object>();
        //将要保存的数据存入map当中
        String str = "%李%";
        map.put("str",str);
        //这里通过用户的名字去模糊查询
        map.put("tager","name");
		//模糊查询用户
        mapper.getUserLike1(map);
        //关闭资源
        sqlSession.close();
    }
 
 @Test
    public void getUserLikeTest2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //先创建一个map，用来保存要存入的数据
        HashMap<String, Object> map = new HashMap<String, Object>();
        //将要保存的数据存入map当中
        String str = "李";
        map.put("str",str);
        //这里通过用户的名字去模糊查询
        map.put("tager","name");
		//模糊查询用户
        mapper.getUserLike2(map);
        //关闭资源
        sqlSession.close();
    }

三，配置解析

1. 核心配置文件

mybatis-config.xml
Mybatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息。

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

2. 环境配置 environments

MyBatis 可以配置成适应多种环境

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

学会使用配置多套运行环境！

MyBatis默认的事务管理器就是JDBC ，连接池：POOLED

3. 属性 properties

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

1.编写一个配置文件(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=123456

2.在核心配置文件中引入

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

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

4.类型别名 typeAliases

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

<!--可以给实体类起别名-->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>
<!--
也可以指定一个包，每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author,；若有注解，则别名为其注解值。-->
<typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

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

@Alias("author") // 等同于 <typeAlias type="com.kuang.pojo.Author" alias="author "/a>
public class Author {
    ...
}

5. 映射器 mappers

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

方式一：【推荐使用】

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

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

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

注意点：
接口和他的Mapper配置文件必须同名
接口和他的Mapper配置文件必须在同一个包下

<mappers>
	<!--直接扫描整个包下面的类-->
    <package name="com.kuang.dao"/>
</mappers>

6.作用域和生命周期

SqlSessionFactoryBuilder:

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

SqlSessionFactory:

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

SqlSession：

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

7.日志

7.1 日志工厂

如果一个数据库操作，出现了异常，我们需要排错，日志就是最好的助手！
曾经：sout、debug
现在：日志工厂

SLF4J LOG4J 【掌握】
LOG4J2 JDK_
LOGGING
COMMONS_LOGGING
STDOUT_LOGGING【掌握】
NO_LOGGING
在MyBatis中具体使用哪一个日志实现，在mybatis-config配置文件中设置中设定
STDOUT_LOGGING

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

7.2 Log4j

什么是Log4j？

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

先导入log4j的包

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

编写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/rzp.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

配置settings为log4j实现

测试运行

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

//日志对象，参数为当前类的class对象
Logger logger = Logger.getLogger(UserDaoTest.class);

//日志级别
logger.info("info: 测试log4j");
logger.debug("debug: 测试log4j");
logger.error("error:测试log4j");

四，分页

4.1 使用Limit分页

4.1.1 编写接口

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

4.1.2 编写Mapper文件

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

4.1.3 开始测试

    @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",1);//从第几个索引开始（从0开始，不是从1开始）
        map.put("pageSize",2); // 取出多少条数据
        List<User> list = mapper.getUserByLimit(map);
        for (User user : list) {
            System.out.println(user);
        }
    }

4.2 RowBounds分页

4.2.2 编写接口

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

4.2.3 编写Mapper文件

<!--分页查询2-->
<select id="getUserByRowBounds" parameterType="map" resultType="com.swkj.pojo.User">
    select * from user limit #{startIndex},#{pageSize}
</select>

4.2.4 测试

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

4.3 分页插件

在这里插入图片描述

五，使用注解开发

5.1注解在接口的方法上实现

就相当于把sql语句直接写在了接口里面，不需要再去Mapper文件当中去配置了

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

//通过id找到一个用户
@Select("select * from USER where id = #{id}")
public User getUserById(int id);

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

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

5.3测试

@Test
    public void test(){
        //1.获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //2.执行SQL
        // 方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUsers();
        for (User user : userList) {
            System.out.println(user);
        }
		
		int id = 10;
		User user = userDao.getUserById(id);
        system.out.println(user);
        	
        //关闭sqlSession
        sqlSession.close();
    }

5.4 注解CURD

//方法存在多个参数，所有的参数前面必须加上@Param("id")注解
@Delete("delete from user where id = ${uid}")
int deleteUser(@Param("uid") int id);

关于@Param( )注解

基本类型的参数或者String类型，需要加上
引用类型不需要加
如果只有一个基本类型的话，可以忽略，但是建议大家都加上
我们在SQL中引用的就是我们这里的@Param()中设定的属性名

本质：反射机制实现
底层：动态代理

MyBatis详细执行流程

在这里插入图片描述

六，动态SQL

什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句
所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

6.1 IF

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

标签就是说：如果前端没有传一个title，或者author属性过来，那标签里面的if语句就一个都不成立，所以就不会将后面的sql语句拼接到一起
但凡里面有一个if语句是成立的，标签会自动将相对应if语句里面的sql拼接到前面的sql语句后面，并且会自动删除多余的and 和 or 关键字

6.2choose, when, otherwise

有时我们不想应用到所有的条件语句，而只想从中择其一项。针对这种情况，MyBatis提供了choose元素，它有点像Java 中的 switch语句。
还是上面的例子，但是这次变为提供了"title 就按’title '查找，提供’author’就按 ‘author’ 查找的情形.
若两者都没有提供，就返回所有符合条件的Blog(实际情况可能是由管理员按一定策略选出Blog列表，而不是返回大量无意义的随机结果)。

<select id="findActiveBlogLike"
resultType="com.swkj.pojo.Blog">
	select * FROM blog where state = 'ACTIVE'
	<choose>
		<when test="title != nul1">
			AND title like #ititle
		</when>
		<when test="author != null and author. name != nul1">
			AND author_name like mKauthor.name
		</when>
		<otherwise>
			AND featured = 1
		</otherwise>
	</choose>
</select>

标签代表是选中其中的某一个选项
标签是可拼接语句当中的某一个语句，如果成立，就会将该sql拼接过去
标签代表如果一个标签都不符合，那就会默认选中该标签当中的sql拼接过去

6.3 SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便服用！

使用SQL标签抽取公共部分可

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

在需要使用的地方使用Include标签引用即可

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

注意事项：

最好基于单标来定义SQL片段
不要存在where标签
先在Mysql中写出完整的SQL，再对应的去修改成我们的动态SQL实现通用即可

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

七，缓存

7.1 简介

查询 ： 连接数据库，耗资源
 一次查询的结果，给他暂存一个可以直接取到的地方 --> 内存：缓存
我们再次查询的相同数据的时候，直接走缓存，不走数据库了

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

7.2 MyBatis缓存

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

7.3 一级缓存

一级缓存也叫本地缓存：SqlSession
与数据库同一次会话期间查询到的数据会放在本地缓存中
以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

测试

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

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

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

        User user2 =  mapper.getUserById(1);
        System.out.println(user2 == user);
    }

测试打印的结果

在这里插入图片描述
说明是同一个结果集，并且只执行了一次sql语句

缓存失效的情况：

查询不同的东西
增删改操作，可能会改变原来的数据，所以必定会刷新缓存
查询不同的Mapper.xml
手动清理缓存，如下

@Test
    public void test1() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        //在这里加入手动清理缓存
		sqlSession.clearCache();
        System.out.println("=====================================");
        User user2 =  mapper.getUserById(1);
        System.out.println(user2 == user);
    }

不言而喻，结果肯定是 false

7.4 二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
1. 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
  如果会话关闭了，这个会员对应的一级缓存就没了；
2. 但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
  新的会话查询信息，就可以从二级缓存中获取内容
3. 不同的mapper查询出的数据会放在自己对应的缓存（map）中
一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
1. 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
2. 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

具体步骤：

先在配置文件中开启全局缓存

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

2.在Mapper文件中使用缓存

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

注意：如果我们mapper文件中没有使用二级缓存，那就需要将实体类序列化，否则就会报错（实现序列化接口）

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

只有查询才有缓存，根据数据是否需要缓存（修改是否频繁选择是否开启）useCache=“true”

    <select id="getUserById" resultType="user" useCache="true">
        select * from user where id = #{id}
    </select>

7.4缓存原理图

在这里插入图片描述

@frist

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Mybatis框架的基本使用

Mybatis框架的基本使用一，一个简单的测试代码1.1，搭建环境创建一个普通的maven项目删除src目录（就可以把此工程当做父工程了，然后创建子工程）导入maven依赖<dependencies>  <dependency> <groupId>mysql</groupId> <artifactId
复制链接

扫一扫