Mybatis

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量76 收藏
点赞数
分类专栏： Java 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59864324/article/details/128013392
版权

1. 简介

1.1 什么是Mybatis

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

如何获得Mybatis

Maven

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

1.2 持久化

数据持久化：

  • 持久化就是将程序的数据在持久装填和瞬时状态转化的过程
  • 内存：断电即失
  • 例子：数据库（jdbc），io文件持久化

为什么需要持久化？

  • 有一些对象不能让他丢失
  • 内存太贵了

1.3 持久层

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

1.4 为什么需要Mybatis?

  • 传统的jdbc代码太复杂了。简化
  • 帮助程序员将数据存入到数据库中

2. 第一个Mybatis程序

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

2.1 搭建环境

新建项目：

1.新建一个普通的Maven项目

2.删除src目录

3.导入maven依赖

<!--    导入依赖-->
    <dependencies>
<!--        mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
<!--        mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <!--       junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

2.2 创建一个模块

  • 编写mybatis的核心配置文件

    <!--configuration核心配置文件-->
<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>

</configuration>

  • 编写mybatis工具类

    public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用Mybatis第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream  inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        } catch (IOException e) {
            e.printStackTrace();
        }

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

2.3 编写代码

  • 实体类

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

  • Dao接口

    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="dao.UserDao">
<!--  id为重写方法的名字 -->
    <select id="getUserList" resultType="entity.User">
        select * from mybatis.user ;
    </select>

</mapper>

2.4 测试

核心配置文件中注册mappers

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

配置文件不生效解决方法

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

  • Junit测试

    package dao;

import entity.User;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import utils.MybatisUtils;

import java.util.List;

public class UserDaoTest {
  @Test
    public void test(){
      //第一步：获取sqlSession对象
      SqlSession sqlSession = MybatisUtils.getSqlSession();

      //方式一：getMapper
      UserDao mapper = sqlSession.getMapper(UserDao.class);
      List<User> userList = mapper.getUserList();
      for (User user:userList){
          System.out.println(user);
      }
      //关闭sqlSession
      sqlSession.close();

  }
}

3. CRUD

1. namespace

namespace中的包名要和DaoMapper接口的包名一致

2. select

选择，查询语句：

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

1、编写接口

//查询全部用户
    List<User> getUserList();

2、编写实现的xml

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

3、测试(增删改需要提交事务)

 @Test
    public void test(){
      //第一步：获取sqlSession对象
      SqlSession sqlSession = MybatisUtils.getSqlSession();

      //方式一：getMapper
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      List<User> userList = mapper.getUserList();
      for (User user:userList){
          System.out.println(user);
      }

注意，@Test不要带参数

public void getUserById(int id)     错误
public void getUserById()			正确

3. insert

<!--插入一个用户  对象中的属性可以直接取出来-->
    <insert id="addUser" parameterType="entity.User">
        insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

4. update

<update id="updateUser" parameterType="entity.User">
        update mybatis.user set name=#{name },pwd=#{pwd}  where id=#{id}
    </update>

5.delete

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

6. 万能Map

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

<!--传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user(id,name,pwd) values (#{userid},#{username},#{password});
    </insert>

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

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map map = new HashMap<String, Object>();
        map.put("userid",5);
        map.put("username","five");
        map.put("password","123");

        mapper.addUser2(map);
        //手动提交事务
        sqlSession.commit();
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可

对象传递参数就，直接在sql中取对象的属性即可

只有一个基本类型参数的情况下，可以直接在sql中取到

多个参数用map或者注解

7. 模糊查询

做法：

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

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

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

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

4. 配置解析

1. 核心配置文件

2. 环境配置（environments）

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

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

Mybatis默认的事务处理器是JDBC, 连接池：POOLED

3. 属性（properties）

我们可以通过properties属性来实现配置文件

  1. 编写一个数据库配置文件
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8
name=root
password=123456

  1. 在核心配置文件中引入properties（放在第一）

      <properties resource="db.properties"/>
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置
  • 如果两个问价有同一个字段，优先使用外部配置文件

4. 类型别名（typeAliases）

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

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

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，

扫描实体类的包，它的默认别名就是实体类的名字，首字母小写。

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

建议第二种

5.设置

6.其他配置

  • plugins（插件）
    • mybatis-generator-core
    • mybatis-plus
    • 通用mapper

7. 映射器（mappers）

Mapper-Registry: 注册绑定我们的Mapper文件；

方式一：

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

方式二：

<!-- 使用class文件绑定注册 -->
<mappers>
	<mapper class="dao.UserMapper"/>
</mappers>

方式三：

<!-- 使用扫描包进行注册 -->
<mappers>
	 <package name="dao"/>
</mappers>

方式二方式三注意点：

  • 接口和它的Mapper配置文件必须同名
  • 接口和它的Mapper配置文件必须在同一个包下

8.生命周期和作用域

生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder：

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

SqlSessionFactory:

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

SqlSession

  • 连接池的一个请求
  • 它的最佳的作用域是请求或方法作用域
  • 用完后需要关闭，否则资源被占用

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

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

1. 问题

不一致，导致结果为空

  • 起别名

    <select id="getUserById" parameterType="int" resultType="entity.User" >
        select id,name,pwd as password from mybatis.user where id =#{id};
    </select>

2.resultMap

结果集映射

id name pwd
id name password

<mapper namespace="dao.UserMapper">
<!--    结果集映射-->
<resultMap id="UserMap" type="entity.User">
<!--    column数据库中的字段，property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<!--    根据id查用户-->
    <select id="getUserById" resultMap="UserMap" >
        select * from mybatis.user where id =#{id};
    </select>
</mapper>
  • resultMap 元素是 MyBatis 中最重要最强大的元素。
  • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
  • ResultMap 的优秀之处——你完全可以不用显式地配置它们。

6.日志

6.1 日志工厂

如果一个数据库操作出现了异常，我们需要排错，日志就是最好的助手

曾经：sout、debug

现在：日志工厂

在这里插入图片描述

  • SLF4J

  • LOG4J【出现重大漏洞】

  • LOG4J2

  • JDK_LOGGING

  • COMMONS_LOGGING

  • STDOUT_LOGGING 【掌握】

  • NO_LOGGING

在MyBatis中具体使用哪个日志实现，在设置中设定

6.1 STDOUT_LOGGING 标准日志输出

在核心配置文件中设置日志

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-85MSERBK-1669257095514)(C:\Users\X\AppData\Roaming\Typora\typora-user-images\image-20221004151545095.png)]

7. 分页

分页原因：减少数据的处理量

7.1 使用Limit分页

语法：select * from user limit startIndex,pageSize
	 select * from user limit 2,3

mybatis中的使用

  1. 接口

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

  2. Mapper.xml

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

  3. 测试

    @Test
    public void getUserByLimit(){
        //第一步：获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //方式一：getMapper
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Integer> map=new HashMap<String, Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);
      List<User> user= mapper.getUserByLimit(map);
        sqlSession.close();

    }

7.2 使用NewBounds分页（简单了解）

java代码方式实现

7.3 分页插件

8. 使用注解开发

8.1 面向接口编程

目的：解耦

关于接口的理解

  • 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离
  • 接口的本身反映了系统设计人员对系统的抽象理解
  • 接口应有两类：
    • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）
    • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
  • 一个个体可能有多个抽象面，抽象体与抽象面是有区别的。

8.2 使用注解开发

  1. 注解在接口上实现

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

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

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

  3. 测试

本质：反射机制实现

底层：动态代理

8.3 注解的增删改查

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

    public static SqlSession getSqlSession(){
         return sqlSessionFactory.openSession(true);

    }

编写接口，增加注解：

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

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

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

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

【注意】我们要将接口注册绑定到核心配置文件

**关于@Param（）注解

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

9. Lombok

使用步骤：

1.在IDEA中安装Lombok插件

2.在项目中导入Lombok的jar包

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

3.使用注解

@Getter and @Setter //get  set 方法
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data	//无参构造，get、set、toString、hashCode、equals
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
@ExtensionMethod (Experimental, activate manually in plugin settings)

10. 多对一处理

测试环境搭建

1.导入lombok

2.新建实体类Teacher Student

3.建立Mapper接口

4.建立Mapper.xml文件

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

6.测试查询是否成功

10.1 按照查询嵌套处理


<!--    思路：
        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>

10.2 按照结果嵌套查询(更易于理解)

<!--    按照结果嵌套查询  内查询-->

    <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. 一对多处理

例：一个老师拥有多个学生

按照结果嵌套查询

实体类

public class Student {
    private int id;
    private String name;
    private int tid;

}

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

}

  //获取指定老师的信息及学生信息
    Teacher getTeacher(@Param("tid") int id);

 <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"/>
<!--javaType:指定属性的类型
    集合中的泛型信息，我们使用ofType获取-->
        <collection property="students"  ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

@Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
    }

小结

1.关联 association【多对一】

2.集合 collection【一对多】

3.JavaType && ofType

  • JavaType 用来指定实体类中属性的类型
  • ofType 用来指定映射到List或者集合中的实体类类型，泛型中的约束类型

注意点：

  • 保证SQL的可读性，尽量保证通俗易懂
  • 注意一对多和多对一中，属性名和字段的问题

12. 动态SQL

什么是动态SQL?

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

12.1 搭建环境

创建一个基础工程：

  1. 导包

  2. 编写配置文件

  3. 编写实体类

    @Data
public class Blog {

  private String id;
  private String title;
  private String author;
  private Date create_time;
  private int views;

}

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

if

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


    </select>

choose、when、otherwise

 <select id="queryBlogChoose" 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>

trim、where、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>

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

SQL片段

有的时候，我们可能会将一些片段抽取出来，方便复用！

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

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

 <sql id="blog-if" >
        <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 mybatis.blog
        <where>
            <include refid="blog-if"></include>
        </where>

    </select>

注意事项：

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

foreach

<select id="queryBlogForeach" parameterType="Map" resultType="Blog">
        select * from mybatis.blog
        <where>
            <foreach collection="ids" 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(3);
        map.put("ids",ids);
        List<Blog> list = mapper.queryBlogForeach(map);
        for (Blog blog : list) {
            System.out.println(blog);
        }

    }

13. 缓存

13.1 简介

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

13.2 Mybatis缓存

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

13.3 一级缓存

一级缓存也叫本地缓存：

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

测试步骤：

  1. 开启日志

  2. 测试在一个Session中查询两次相同记录

  3. 查看日志输出

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zK6teOxj-1669257095515)(C:\Users\X\Pictures\Java\QQ截图20221011195722.jpg)]

缓存失效的情况：

  • 查询不同东西

  • 增删改操作，可能会改变原来的数据，所以必定会刷新缓存

  • 查询不同的Mapper.xml

  • 手动清理缓存

    sqlSession.clearCache()

    小结

    一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段

13.4 二级缓存

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

步骤：

  1. 在核心配置文件中开启全局缓存

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

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

    <cache/>

    也可以自定义参数

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

  3. 测试

13.5 缓存原理

二级缓存–>一级缓存–>数据库

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

13.3 一级缓存

一级缓存也叫本地缓存：

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

测试步骤：

  1. 开启日志

  2. 测试在一个Session中查询两次相同记录

  3. 查看日志输出

    [外链图片转存中…(img-zK6teOxj-1669257095515)]

缓存失效的情况：

  • 查询不同东西

  • 增删改操作，可能会改变原来的数据，所以必定会刷新缓存

  • 查询不同的Mapper.xml

  • 手动清理缓存

    sqlSession.clearCache()

    小结

    一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段

13.4 二级缓存

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

步骤：

  1. 在核心配置文件中开启全局缓存

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

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

    <cache/>

    也可以自定义参数

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

  3. 测试

13.5 缓存原理

二级缓存–>一级缓存–>数据库

容与0801
关注
专栏目录
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis3.5.6
11-04
学习mybatis 不创建maven 需要下载jar包 但是在GitHub上下载实在是太慢了，有时还可能下载不了。分享一下
Mybatis增强版MyBatis-Flex介绍
沉淀、分享、成长，让自己和他人都能有所收获！
08-14 3万+
本文介绍了 Mybatis-Flex，一个用于增强 MyBatis 的框架。相对于 MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。文章概述了 MyBatis-Flex 的功能特点，并深入介绍了联表查询的不同方案。
MyBatis
weixin_45984258的博客
12-25 3193
MyBatisMyBatis快速入门Mapper代理开发MyBatis核心配置文件配置文件完成增删改查注解完成增删改查动态SQL MyBatis快速入门 MyBatis： Mybatis 是一款优秀的持久层框架，用于简化JDBC开发 JDBC的缺点： 1、硬编码： 注册驱动 SQL与君 2、操作繁琐 手动设置参数 手动封装结果集 MyBatis本是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到google code，并改名
mybatis中大于等于小于等于的写法
热门推荐
chenxingde的博客
03-04 29万+
标准写法如下：大于等于 = ]]> 小于等于 sql如下： create_date_time = ]]> #{startTime} and create_date_time #{endTime}
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflec
05-15 7万+
org.mybatis.spring.MyBatisSystemException是MyBatis与Spring集成时可能出现的异常，主要原因是在MyBatis的配置或使用过程中出现了问题。解决此异常的方法包括以下步骤：
Mybatis 返回Map数据
菜鸟记录
03-30 3万+
⏹Mybatis 返回Map数据
MyBatis最经典的20道面试题，你都会了吗？
weixin_44976692的博客
01-18 2万+
MyBatis是一款优秀的持久层框架，在Java开发中广受欢迎。下面是一些常见的MyBatis面试题，以及相应的案例分析，希望对你的学习和面试有所帮助。MyBatis是一款基于Java的持久层框架，它通过XML描述符或注解将对象与存储过程或SQL语句进行映射，实现了面向对象编程与关系数据库的映射。动态SQL是MyBatis中的一项强大功能，它可以根据条件判断动态拼接SQL语句，避免硬编码。例如，动态SQL可以在条件成立时插入WHERE子句：
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.Per
05-14 7万+
org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException: Error querying database. Cause: java.sql.SQLSyntaxErrorException: ORA-00942: table or view does not exist 这个异常通常是因为 MyBatis 无法找到指定的表或视图而引起的。
mybatisx.zip
11-08
这个压缩包文件“mybatisx.zip”包含了多个版本的MybatisX插件，包括MybatisX-1.4.16.zip、MybatisX-1.4.8.zip、MybatisX-1.4.6.zip以及MybatisX-1.1.2.zip。这些版本的差异可能体现在功能增强、性能优化或者修复...
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
mybatis demo
01-25
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。在本示例中，"mybatis demo" 是一个基于Dubbo的MyBatis演示项目，旨在帮助开发者理解和实践如何在分布式环境中使用MyBatis进行数据访问...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 545
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 765
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 201
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 668
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 240
maven配置使用nexus仓库
Mybatis学习笔记大全.docx
09-24
"Mybatis学习笔记大全.docx" MyBatis是一个强大的Java持久层框架，源自Apache的iBatis项目，并在2010年后在Google Code和后来的Github上进行了发展。MyBatis的主要目标是对SQL操作进行优化，提供比传统JDBC更简洁的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

容与0801

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值