MyBatis从入门到入土1.0

最新推荐文章于 2024-06-21 15:34:27 发布

星空辰梦

最新推荐文章于 2024-06-21 15:34:27 发布

阅读量139

点赞数

分类专栏： SSM 文章标签：数据库 mysql mybatis

本文链接：https://blog.csdn.net/dream_start_/article/details/115820697

版权

SSM 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

新建项目：
一
1.新建一个maven项目
2.删除src
3.在pom.xml中导入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<!--父工程-->
    <groupId>org.example</groupId>
    <artifactId>MyBatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>MyBatis_01</module>
        <module>Mybatis_2</module>
    </modules>
    <dependencies>
<!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
<!--    mybatis-->
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.2</version>
    </dependency>
</dependencies>


    <!--在build中配置resources，来防止我们资源导出失败-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>


</project>

二创建模块
1.编写MyBatis核心配置文件
将文件存放在在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
    <!--环境，可以配置多套-->
    <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?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="159357"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在MyBatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/ly/dao/UserMapper.xml"/>
    </mappers>

</configuration>

编写mybatis工具类：

package com.ly.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;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //获取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;
    }
}

三：
原本使用JDBC的步骤：
1.建立User实体
2.建立UserDao接口，并在接口中编写方法
3.建立UserDaoImpl接口实现类

在原本的jdbc中编写了实体类以及Dao后，需要编写相应的impl重写Dao中的方法，但是在使用了MyBatis后，只需要编写一个 .xml文件就可以

使用MyBatis后：
接口实现类由原来的UserDaoImpl转变为Mapper.xml：

UserDao

package com.ly.dao;

import com.ly.pojo.User;

import java.util.List;

public interface UserDao {

    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绑定一个对应的Dao/Mapper接口-->
<mapper namespace="dao.UserDao">
    <!--selete查询语句
    id对应原本impl中重写的方法
    -->
    <select id="getUserlist" resultType="pojo.User">
        select * from mybatis.user
    </select>
</mapper>

test测试文件：

package com.ly.dao;

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

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一：调用SqlSession对象的getMapper方法，获取UserDao
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userlist = userDao.getUserlist();

        for (User user : userlist) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

查询
UserMapper文件中的：

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

UserMapper.XML文件中：
resultType：查询的结果的类型
parameterType：形参的类型

parameterTypr：参数类型
    <select id="getUserById" resultType="com.ly.pojo.User" parameterType="int">
        select * from mybatis.user where id=#{id}
    </select>

UserDaoTest：

@Test
//根据ID查询用户
public void test2(){
    //获取SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //方式一：调用SqlSession对象的getMapper方法，获取UserDao
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User userById = userMapper.getUserById(2);
    System.out.println(userById);

}

增：

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

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

 @Test
    public void test3(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int addUser = mapper.addUser(new User(4,"小蓝","123456789"));
        //添加完成后需要提交
        sqlSession.commit();
        sqlSession.close();
    }

改：

//修改用户信息，根据ID
int updateUserById(User user);

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

//修改用户信息，根据ID
@Test
public void tets4(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    mapper.updateUserById(new User(4,"大蓝","524163"));
    sqlSession.commit();
    sqlSession.close();
}

删：

//删除用户
int deleteUser(int id);

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

public void tets5(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    mapper.deleteUser(4);
    sqlSession.commit();
    sqlSession.close();
}

重要：--------------------一定要记得提交事务 sqlSession.commit();--------------------------------

使用Map集合：

//添加用户
int uaddUser2(Map<String ,Object> map);

<insert id="uaddUser2" parameterType="map">
    insert into mybatis.user(id,name,pwd) values (#{userid},#{username},#{password})
</insert>

//添加
public void test6(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("userid",5);
    map.put("username","大白");
    map.put("password","123456");
    mapper.uaddUser2(map);

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

为什么使用Map：如果一个表，有几十个属性，那么在使用的时候就非常麻烦，例如进行修改操作，使用Map的话我只需要添加我需要修改的key-value，但是使用构造器的话却需要输入全部。

        <transactionManager type="JDBC"/>
        MyBatis默认的事务管理器是JDBC
        <dataSource type="POOLED">
        ，连接池为POOLED

 <!--引入外部配置文件-->
    <properties resource="dp.properties"/>

    <environments default="development">

        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--引入外部配置文件前-->
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!--引入外部配置文件后-->
                <property name="driver" value="${driver}"/>

                <!--引入外部配置文件前-->
<!--                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false"/>-->
                <!--引入外部配置文件后-->
                <property name="url" value="${url}"/>

                <!--引入外部配置文件前-->
<!--                <property name="username" value="root"/>-->
                <!--引入外部配置文件后-->
                <property name="username" value="${username}"/>

                <!--引入外部配置文件前-->
<!--                <property name="password" value="159357"/>-->
                <!--引入外部配置文件后-->
                <property name="password" value="${password}"/>

            </dataSource>
        </environment>
    </environments>

当外部配置文件和内部设置同时存在时，优先使用外部配置文件

类型别名：

类型别名是为了java类型设置一个短的名字
存在的意义仅在于用来减少类完全限定名的冗余
方式一直接给每个实体类起别名，适用于实体类数量较少的情况

<!--写别名-->
    <typeAliases>
<typeAlias type="com.pojo.User" alias="User"/>
    </typeAliases>

方式二扫描实体类的包，他的默认别名就是这个类的类名，首字母小写

<package name="com.pojo"/>

<!--写别名之前-->
<select id="getlist" resultType="com.pojo.User">
<!--写别名之后-->
<select id="getlist" resultType="User">

第一种可以自定义别名，第二种不行但是若第二种方法在使用时，实体类有注解，则使用注解作为别名

@Alias("user")
public class User {

映射器（mappers）

MapperRegistry:注册绑定我们的Mapper文件：
方式一：使用相对于类路径的资源引用

<mappers>
    <mapper resource="com/Dao/UserMapper.xml"/>
</mappers>

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

    <mappers>
<!--        <mapper resource="com/Dao/UserMapper.xml"/>-->
    <mapper class="com.Dao.UserDao"/>
    </mappers>

注意：
1.接口与Mapper配置文件必须同名
2.接口与Mapper配置文件必须在一个文件夹下

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

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

注意点与方式二相同

在这里插入图片描述
SqlSessionFactoryBuilder：
一旦创建了SqlSessionFactoryBuilder，就不再需要他了
局部变量

SqlSessionFactory：
可以想象为数据库连接池，没有任何理由丢弃它或重新创建数据库连接池
因此SqlSessionFactory的作用域应当是全局

SqlSession：
连接到连接池的请求
因此SqlSessionFactory的作用域应当是在一个方法中，使用完就要关闭

为什么要关闭：SqlSession可以理解为线程池中的一个线程，在调用完之后自然要关闭，避免浪费

在这里插入图片描述
当实体类中的属性名与数据库中的属性名不一致时，可以使用映射

<!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <!--column代表的是数据库中的一列(每一列代表一个属性)
            propery代表实体类中的属性
            result要做的就是将数据库中的属性名与实体类中的属性名一一映射
        -->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from mybatis.user where id=#{id}
    </select>

日志：

1.日志工厂
当一个数据库操作出现错误，需要进行排查，日志就是一个帮手
SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING

在Mybatis具体使用哪一个日志实现，在设置中设定
STDOUT_LOGGING标准日志输出

在Mybatis-config.xml中进行配置

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

什么是LOG4J：
Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等
1.在pom.xml中导入log4j依赖：


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

2log4j配置文件：

在这里插入图片描述

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/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3配置log4j为日志地实现：

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

在测试类中进行测试：

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

public void testLog4j(){
    logger.info("info:进入了TestLog4j方法");
    logger.debug("debug:进入了TestLog4j方法");
    logger.error("error:进入了TestLog4j方法");
}

分页：

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

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

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

使用注释的方法进行增删改查：
在这里插入图片描述
此时不再需要.xml文件，但是注释的方法只适用于简单的查询，例如我的实体类中的属性名与数据库中的不相同，那么就只能显示为null

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

//方法存在多个参数时所有的参数前必须加上@Param()
@Select("select * from user where id=#{newid} ")
User getUserById(@Param("newid") int id);

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

    }

多对一查询：

实体类：

package com.pojo;

import lombok.Data;
import org.junit.Test;

@Data
public class Student {
    private int id;
    private String name;
    //学生需要关联一个老师
    //private int tid;
    private Teacher teacher;

}

package com.pojo;

import lombok.Data;

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

文件结构：
在这里插入图片描述

    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--对于复杂的属性，需要单独处理
        association:对象，在多对一的时候使用，如多个学生一个老师，现在要查询学生的信息
        -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacherById"/>
    </resultMap>
<select id="getStudent" resultMap="StudentTeacher" >
    select * from student
</select>
    <select id="getTeacherById" resultType="Teacher">
        select * from teacher where id=#{id}
    </select>

@Test
public void test2(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> student = mapper.getStudent();
    for (Student student1 : student) {
        System.out.println(student1);
    }
    sqlSession.close();
}

<!--多对一查询方式二：嵌套查询-->

<select id="getStudent" resultMap="StudentTeacher">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid=t.id
</select>
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

一对多处理：

实体类：

package com.pojo;
import lombok.Data;
import java.util.List;
@Data
public class Teacher {
    private int id;
    private String name;
    private List<Student> student;
}

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

}

    <!--按结果嵌套查询-->
<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from student s,teacher t
    where s.tid=t.id and t.id=#{tid};
</select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--javaType="" 指定属性的类型
			集合中的泛型信息，我们可以使用ofType获取
		-->
        <collection property="student" javaType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

动态SQL:

动态sql，本质还是sql语句，只不过是加了一些逻辑判断符

注意：标签：
举个栗子：如果IF成立，自动添加 where，如果第一个IF不成立，第二个成立，会直接去掉and,
如果语句的开头为AND,OR，会直接去掉，如果是其他的可以通过trim元素来定制

IF:

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

@Test
public void test(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map map = new HashMap();
    //map.put("title","Java");
    map.put("author","狂神说");

    List<Blog> blogs = mapper.queryBlogIF(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
}

choose：
类似于java中的switch

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

set
set元素会动态前置SET关键字，同时也会动态删掉无关的逗号

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

@Test
public void test4(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map map = new HashMap();
    map.put("title","JavaScript");
    map.put("author","狂神说1");
    map.put("id" ,"6b8c606f38e24b9298b35e7eea10c777");
    mapper.updateBlog(map);
    sqlSession.commit();
    sqlSession.close();
}

where，set的爸爸：trim
重点trim：

<trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">

前缀：比如 AND title=“JAVA” AND就是前缀
后缀：比如 set title=“jsp” , '，'就是后缀
prefix：
prefixOverrides：前缀覆盖的东西
suffix：
suffixOverrides：后缀覆盖的东西

例如：

<trim prefix="where" prefixOverrides="AND | OR " >

如果where不存在，但是AND或OR存在，就将其移除并插入where

<trim prefix="where" prefixOverrides="AND | OR " >

sql片段：
有时候会有一些sql语句重复，我们可以提取出这些重复的sql语句片段，方便调用

使用sql后：

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

注意事项：
最好基于单表定义SQL片段
不要存在where标签

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>

foreach 元素的功能非常强大，它允许你指定一个集合（list），声明可以在元素体内使用的集合项（item）和索引（index）变量【可以取出集合中的一个值，将index理解为下标】。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符。

缓存：

查询，连接数据库，耗费资源
将查询的结果，暂存在一个可以直接取到的地方—》内存：缓存
再次查询相同数据的时候，直接走缓存，就不需要走数据库了

缓存解决高并发的系统问题

@Test
public void test(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();①
    ...
    sqlSession.close();②
}

一级缓存的有效期：①和②之间
查询一次：在一次SqlSession会话中完成

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

在这里插入图片描述
查询两次：
查询相同的ID

 @Test
    public void test(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user1 = mapper.queryUserById(1);
        System.out.println(user1);
        System.out.println("==========================");
        User user2= mapper.queryUserById(1);
        System.out.println(user2);
        System.out.println("==========================");
        System.out.println(user1 == user2);
        sqlSession.close();
    }

在这里插入图片描述

查询两次：
查询不同的ID

在这里插入图片描述

映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

刷新缓存：

@Test
public void test(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user1 = mapper.queryUserById(1);
    System.out.println(user1);
    System.out.println("==========================");
    Map map = new HashMap();
    map.put("name","aahsshhs");
    map.put("id",2);
    mapper.updatemap(map);
    System.out.println("==========================");
    User user2= mapper.queryUserById(1);
    System.out.println(user2);
    System.out.println("==========================");
    System.out.println(user1 == user2);
    sqlSession.close();
}

在这里插入图片描述
缓存失效：
查询不同的东西
增删改操作
调用不同的Mapper.xml
手动关闭

//手动清理缓存
sqlSession.clearCache();

一级缓存默认开启，只在一次SqlSession中有效，无法关闭

二级缓存
一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;

如果当前会话关闭了，这个会话对应的一级缓存就没了;但是我们想要的是，会话被关闭后，一级缓存中的数据被保存到二级缓存中;

新的会话查询信息，就可以从二级缓存中获取内容;

不同的mapper查出的数据会放在自己对应的缓存(map) 中; .

1.开启缓存

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

2.在当前Mapper.xml中使用二级缓存

    <!--
    创建了一个 FIFO 缓存，
    每隔 60 秒刷新，
    最多可以存储结果对象或列表的 512 个引用，
    而且返回的对象被认为是只读的-->
<cache eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"
/>

参数可以自定义

不使用二级缓存时的代码和结果

@Test
public void test3(){
    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);
    System.out.println("======================");
    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    sqlSession1.close();
    sqlSession2.close();
}

在这里插入图片描述

使用二级缓存之后的结果：

@Test
public void test3(){
    SqlSession sqlSession1 = MyBatisUtils.getSqlSession();
    SqlSession sqlSession2 = MyBatisUtils.getSqlSession();
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 = mapper1.queryUserById(1);
    System.out.println(user1);
    //当SqlSession1执行完后就关闭，当一级缓存关闭后，二级缓存才能启动
    sqlSession1.close();
    System.out.println("======================");
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    //此时新的会话在查询时可以从二级缓存中获取内容
    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    sqlSession2.close();
}

在这里插入图片描述
注意：
1.需要将实体类序列化，否则会报错:

@Data
public class User implements Serializable {
    private int id;
    private String name;
    private String pwd;
}

原理：
在这里插入图片描述
注意：
只有查询有缓存，其它的sql语句不需要
useCache=“true”：手动开启

<select id="queryUserById" parameterType="int" resultType="user" useCache="true">
    select * from mybatis.user where id=#{id};
</select>

Ehcache：
1.导包：
pom.xml

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

Mapper.xml中：

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

星空辰梦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis从入门到入土1.0

新建项目：一1.新建一个maven项目2.删除src3.在pom.xml中导入依赖：<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apach
复制链接

扫一扫