java 中mybatisplus 乘法函数 java的mybatis

转载

gjnet 2024-06-14 10:12:25

文章标签 java maven intellij-idea Mybatis xml 文章分类 Java 后端开发

环境

JDK1.8
MySQL
Maven
IDEA

回顾

JDBC
MySQL
Java基础
Maven
Junit
SSM框架

Mybatis简介

什么是 MyBatis？

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

GitHub：https://github.com/mybatis/mybatis-3
中文文档：https://mybatis.org/mybatis-3/zh/index.html

持久化

数据持久化，持久状态和瞬时状态的转化
内存：断电即失
数据库（JDBC）,IO文件持久化

持久层

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

为什么使用Mybatis？

简化JDBC，自动化

第一个Mybatis项目

搭建环境

创建数据库和表
创建Maven项目
删除项目中的src目录（使之成为父级项目）
新建module（Maven类型）
导入依赖：mybatis、junit…

在resource目录创建Mybatis配置文件：mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 每一个Mapper.xml都要在Mybatis核心配置文件中注册！ -->
        <mapper resource="cn/cnyasin/dao/UserMapper.xml"/>
    </mappers>
</configuration>

创建自己的一个Mybatis工具类：package cn.cnyasin.utils;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    private static String resource = "mybatis-config.xml";
    private static InputStream inputStream = null;
    /**
     * 从 XML 中构建 SqlSessionFactory
     */
    static {
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != inputStream) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 从 SqlSessionFactory 中获取 SqlSession
     * @return SqlSession
     */
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

创建pojo

public class User {
    private int id;
    private String username;
    private String email;
    private String password;
    private long balance;
    private long created_at;
    // ...
}

在pom.xml中开启java目录资源过滤，Mybatis读取Mapper.xml需要该配置

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

注意：src/main/resources、src/main/java两个都要打开，resources如果不配置默认只开启src/main/resources目录，反之，如果配置了就会覆盖默认值。
注意：如果需要读取xml配置就开启**/*.xml，如果你需要读取properties配置就开启**/*.properties。

创建dao：package cn.cnyasin.dao;

public interface UserMapper {
    // 查询一个用户
    User getOne(@Param("id") int id);
    // 查询所有用户
    List<User> getAll();
    // 添加一个用户
    int addOne(User user);
    // 修改一个用户
    int updateOne(User user);
    // 删除一个用户
    int deleteOne(int id);
}

创建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对应一个Mapper类（原来的dao） -->
<mapper namespace="cn.cnyasin.dao.UserMapper">
    <!--
    id：一个id对应一个方法
    resultType：返回一个结果
    resultMap：返回多个结果
    -->
    <!-- 查询一个用户 -->
    <select id="getOne" resultType="cn.cnyasin.pojo.User">
        select * from user where id = #{id}
    </select>
    <!-- 查询所有用户 -->
    <select id="getAll" resultMap="userListMap">
        select * from user
    </select>
    <!-- 添加一个用户 -->
    <insert id="addOne" parameterType="cn.cnyasin.pojo.User">
        insert into user (`username`,`email`,`password`,`created_at`) values (#{username}, #{email}, #{password}, #{created_at})
    </insert>
    <!-- 修改一个用户 -->
    <update id="updateOne" parameterType="cn.cnyasin.pojo.User">
        update user set balance = #{balance} where id = #{id};
    </update>
    <!-- 删除一个用户 -->
    <delete id="deleteOne">
        delete from user where id = #{id}
    </delete>
    <resultMap id="userListMap" type="cn.cnyasin.pojo.User"/>
</mapper>

测试

@Test
public void getOneTest()
{
    // 获取SQLSession
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // getMapper
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.getOne(1);
    System.out.println(user);
    System.out.println("----------------------------");
    List<User> users = userMapper.getAll();
    for (User user1 : users) {
        System.out.println(user1);
    }
    // 关闭SQLSession
    sqlSession.close();
}
@Test
public void updateOneTest() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getOne(6);
    if (null == user) {
        System.out.println("用户不存在。。。");
        return;
    }
    user.setBalance(user.getBalance() + 100000);
    int updateOne = mapper.updateOne(user);
    if (updateOne > 0) {
        System.out.println("用户余额更新成功。。。");
    }
    sqlSession.commit();
    sqlSession.close();
}
// 增加、删除的测试方法省略。。。

遇到的问题

MySQL连接异常：The server time zone value '�й��׼ʱ��' is unrecognized or represents more than one time zone. ...

原因分析：如果mysql的jar包使用了8.*版本，该版本要求必须显式的指定serverTimezone
解决方案：

<property name="url" value="jdbc:mysql://localhost:3306/jdbc_test?useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai"/>

MySQL链接异常：org.xml.sax.SAXParseException; lineNumber: 11; columnNumber: 113; 对实体 "characterEncoding" 的引用必须以 ';' 分隔符结尾。...

原因分析：xml配置文件特殊符号必须转实体（&->&），properties配置文件则不需要（&）。
解决方案：xml配置中将url中的&改成&，properties配置中则相反。

启动报错，找不到XxxMapper.xml：The error may exist in cn/cnyasin/dao/UserMapper.xml...

原因分析：Maven资源过滤问题。Maven默认资源过滤文件目录为resources目录，java目录下的文件是不会被导出的，需要手动开启该目录的资源过滤。
解决方案：在pom.xml中添加如下代码：

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

注意：src/main/resources、src/main/java两个都要打开，resources如果不配置默认只开启src/main/resources目录，反之，如果配置了就会覆盖默认值。
注意：如果需要读取xml配置就开启**/*.xml，如果你需要读取properties配置就开启**/*.properties。

补充说明

如果参数比较多又不方便传一个pojo，可以考虑传一个Map，俗称“万能map”。
模糊查询怎么写？

方式一参数这么传：value=%张三%
方式二SQL这么写：select * from user where name like "%"#{value}"%"

配置解析

核心配置文件

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。配置文档的顶层结构如下：

configuration（配置）

properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）

environment（环境变量）

transactionManager（事务管理器）
dataSource（数据源）

databaseIdProvider（数据库厂商标识）
mappers（映射器）

具体参考官方文档：https://mybatis.org/mybatis-3/zh/configuration.html#

环境配置（environments）

Mybatis可以实现连接多个数据库
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。
事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"），默认JDBC。
JDBC：我理解是对事务友好。
MANAGED：我理解是适用于容器使用完连接后需要手动关闭的情况。
如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

数据源（dataSource）

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）
UNPOOLED：没有池子，适用于小型网站，慢点但节省资源。
POOLED：有池子，适用于大型高并发网站，响应速度更快。
JNDI：用的不多就不说了。

属性（properties）

优先级：.properties > property标签

类型别名（typeAliases）

作用：简化xml
用法一：

<typeAliases>
    <typeAlias type="cn.cnyasin.pojo.User" alias="user"/>
</typeAliases>

用法二：每一个在包cn.cnyasin.pojo中的JavaBean，在没有注解的情况下，会使用Bean的首字母小写的非限定类名来作为它的别名。若有注解，则别名为其注解值。

<typeAliases>
    <package name="cn.cnyasin.pojo"/>
</typeAliases>

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

设置（settings）
映射器（mappers）
其他配置。。。

生命周期

SqlSessionFactoryBuilder：创建SqlSessionFactory用的，一次性。
SqlSessionFactory：在应用的运行期间一直存在。
SqlSession：最佳的作用域是请求或方法中，方法调用结束后销毁。

结果映射（resultMap ）

主要用于处理复杂的SQL
其中重要的一个作用：解决类属性和字段名不一致

<!-- user读取的mybatis核心配置文件中定义的类型别名 -->
<resultMap id="userListMap" type="user">
    <!-- 结果集映射：解决类属性和字段名不一致 -->
    <result column="created_at" property="createdAt"/>
</resultMap>

日志

如果数据库操作异常我们需要拍错，就需要用到日志
日志工厂

指定 MyBatis 所用日志的具体实现，未指定时将自动查找。
在mybatis设置中进行设置：设置（settings） -> logImpl，默认未设置（不输出详细日志），支持的选项：

SLF4J
LOG4J（掌握）
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING（掌握）
NO_LOGGING

STDOUT_LOGGING：标准日志输出，mybatis内置，不用手动导包，设置了该选项后自动输出日志。

<settings>
    <!-- 开启日志 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

LOG4J：强大的日志工具，需要手动导包。

什么是log4j？

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

如何基本使用？

导入包

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

在mybatis核心配置文件将settings中的logImpl选项设置为LOG4J

<settings>
    <!-- 开启日志 -->
    <setting name="logImpl" value="LOG4J"/>
</settings>

在classpath（resources）目录创建log4j的配置文件：log4j.properties（固定名字），一个简单的配置文件如下：

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=[%p][%d{yy-MM-dd}][%c]%m%n
#文件输出的相关设置
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/logs.txt
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

log4j.rootLogger=DEBUG,console,file：意思是日志输出级别为DEBUG，输出到控制台、文件
其它详细配置自己研究吧

如何手动使用？

前提：配置好了log4j基本使用
在要手动输出日志的类中定义一个日志对象
在适当的位置调用该日志对象的相关方法
核心代码

public class UserMapperTest {
    private static Logger logger = Logger.getLogger(UserMapperTest.class);
    @Test
    public void log4jTest() {
        // 错误级别：debug < info < warn < error，级别越低输出的日志越详细
        logger.debug("hahaha...呵呵。。。");
        logger.info("hahaha...呵呵。。。");
        logger.warn("hahaha...呵呵。。。");
        logger.error("hahaha...呵呵。。。");
    }
}

分页

借助Map传start、pageSize给Mapper.xml，然后SQL中使用limit语句实现（推荐）。
RowBounds
PageHelper插件

使用注解开发

说明：适用于简单逻辑，复杂的逻辑不适合注解，比如字段属性映射关系就实现不了。
原理：反射、动态代理
注意：

如果接口上加了注解，那么同目录下务必不要有对应的Mapper.xml文件，或者Mapper.xml中不要定义同id的方法，会冲突。
如果方法上有多个参数，务必在每个参数前加上@Param()注解。

具体实现步骤

环境准备（略）
注解在接口上实现

public interface UserMapper {
    @Select("select * from user where id = #{id}")
    User getOne(int id);
}

mybatis核心配置文件中的mappers映射器中加载类

<mappers>
    <mapper class="cn.cnyasin.dao.UserMapper"/>
</mappers>

测试

lombok的使用

简介

Java使用工具。简化Javabean（POJO）的，免去Getter/Setter/Constructor/toString…。

用法（idea）

在idea的设置中的插件设置里搜索lombok进行安装，然后按提示会让你重启idea，重启后默认开启该插件支持，要关闭可以再次打开idea的插件设置项，找到installed，禁用或者卸载。
在要使用该用具的项目中加入lombok包依赖

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

在POJO中使用

支持的注解

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
@ExtensionMethod (Experimental, activate manually in plugin settings)

关联嵌套查询

属性列表

constructor - 用于在实例化类时，注入结果到构造方法中

idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
arg - 将被注入到构造方法的一个普通结果

id – 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
result – 注入到字段或 JavaBean 属性的普通结果
association – 一个复杂类型的关联；许多结果将包装成这种类型

嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用

collection – 一个复杂类型的集合

嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用

discriminator – 使用结果值来决定使用哪个 resultMap

case – 基于某些值的结果映射

嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

其他常用属性

property：映射到列结果的字段或属性。
column：数据库中的列名，或者是列的别名。
select：用于加载复杂类型属性的映射语句的ID，它会从column属性中指定的列检索数据，作为参数传递给此select语句。对外部select的命名引用。
resultMap：对外部resultMap的命名引用。
resultType：期望从这条语句中返回结果的类全限定名或别名，比如：User。
type：ResultMap的专用属性，该结果返回的类型，接受类的完全限定名或者一个类型别名，比如：User。
ofType：collection的专用属性，该结果集返回的类型，接受类的完全限定名或者一个类型别名，比如：User。
javaType：association的专用属性，一个Java类的全限定名或一个类型别名，比如：ArrayList。MyBatis通常可以自动推断类型。

具体实现核心代码

按查询嵌套

<!-- 多对一（association） -->
<select id="getOne" resultMap="studentMap">
    select * from student where id = #{id}
</select>
<resultMap id="studentMap" type="Student">
    <result property="createdAt" column="created_at"/>
    <result property="tid" column="tid"/>
    <association property="teacher" column="tid" javaType="Teacher" select="_getTeacher"/>
</resultMap>
<select id="_getTeacher" resultType="Teacher">
    select * from teacher where id = #{id}
</select>
<!-- ———————————————————————————————————————————————— -->
<!-- 一对多（collection） -->
<select id="getOne" resultMap="teacher">
    select * from teacher where id = #{id}
</select>
<resultMap id="teacher" type="Teacher">
    <id property="id" column="id"/>
    <result property="createdAt" column="created_at"/>
    <collection property="students" column="id" ofType="Student" select="student">
        <id property="id" column="id"/>
    </collection>
</resultMap>
<select id="student" resultType="Student">
    select id,name,created_at createdAt from student where tid = #{id}
</select>

按结果嵌套

<!-- 多对一（association） -->
<select id="getOne2" resultMap="studentResult">
    select s.*, t.`name` tName, t.created_at tCreatedAt
    from student s, teacher t
    where s.tid = t.id
    and s.id = #{id};
</select>
<resultMap id="studentResult" type="Student">
    <id property="id" column="id"/>
    <result property="name" column="name"/>
    <result property="tid" column="tid"/>
    <result property="createdAt" column="created_at"/>
    <association property="teacher" column="tid" javaType="Teacher" resultMap="teacherResult"/>
</resultMap>
<resultMap id="teacherResult" type="Teacher">
    <id property="id" column="tid"/>
    <result property="name" column="tName"/>
    <result property="createdAt" column="tCreatedAt"/>
</resultMap>
<!-- ————————————————————————————————————————————————— -->
<!-- 一对多（collection） -->
<!-- 方式一 -->
<select id="getOne2" resultMap="teacher2">
    select
    t.id t_id, t.name t_name, t.created_at t_created_at,
    s.id s_id, s.name s_name, s.created_at s_created_at
    from teacher t, student s
    where s.tid = t.id
    and t.id = #{id}
</select>
<resultMap id="teacher2" type="Teacher">
    <id property="id" column="t_id"/>
    <result property="name" column="t_name"/>
    <result property="createdAt" column="t_created_at"/>
    <collection property="students" column="id" ofType="Student" resultMap="student2"/>
</resultMap>
<resultMap id="student2" type="Student">
    <id property="id" column="s_id"/>
    <result property="name" column="s_name"/>
    <result property="createdAt" column="s_created_at"/>
</resultMap>
<!-- 方式二 -->
<select id="getOne3" resultMap="teacher3"></select>
<resultMap id="teacher3" type="Teacher">
    <id property="id" column="t_id"/>
    <result property="name" column="t_name"/>
    <result property="createdAt" column="t_created_at"/>
    <collection property="students" column="id" ofType="Student">
        <id property="id" column="s_id"/>
        <result property="name" column="s_name"/>
        <result property="createdAt" column="s_created_at"/>
    </collection>
</resultMap>

动态SQL

概念

你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

常用标签

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

环境准备（略）
具体实现核心代码

<!-- getAll -->
<resultMap id="userListResult" type="User">
    <id property="id" column="id"/>
    <result property="createdAt" column="created_at"/>
</resultMap>
<select id="getAll" resultMap="userListResult">
    select * from user
    <where>
        <if test="username != null">
            `username` = #{username}
        </if>
        <if test="email != null">
            and `email` = #{email}
        </if>
        <if test="password != null">
            and `password` = #{password}
        </if>
        <if test="ids != null">
            and id in
            <foreach collection="ids" item="id" open="(" separator="," close=")">
                #{id}
            </foreach>
        </if>
    </where>
    <choose>
        <when test="sort != null">
            order by `id` desc
        </when>
        <otherwise>
            order by `id` asc
        </otherwise>
    </choose>
</select>

<!-- updateOne -->
<update id="updateOne" parameterType="User">
    update user
    <set>
        <if test="username != null">`username` = #{username}</if>
        <if test="email != null">`email` = #{email}</if>
        <if test="password != null">`password` = #{password}</if>
        <if test="balance != null">`balance` = #{balance}</if>
    </set>
    where id = #{id}
</update>

SQL片段

使用sql标签抽取公共部分

<sql id="sql-where">
    <if test="username != null">
        `username` = #{username}
    </if>
    <if test="email != null">
        and `email` = #{email}
    </if>
    <if test="password != null">
        and `password` = #{password}
    </if>
    <if test="ids != null">
        and id in
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </if>
</sql>

在要使用片段的地方用include标签引用

<where>
    <include refid="sql-where"></include>
</where>

缓存

一级缓存

默认开启
默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。
相同的SQL，同一个会话只会执行一次（如果期间未执行非select语句）。

二级缓存

要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：<cache/>
效果如下

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

二级缓存也叫全局缓存，一个namespace一个二级缓存。
二级缓存可跨会话有效。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：工频电场python 工频电场强度

下一篇：ruoyi 后端怎么设置pagesize 后端如何设置cookie

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java 中mybatisplus 乘法函数 java的mybatis

java 中mybatisplus 乘法函数 java的mybatis

环境

回顾

Mybatis简介

第一个Mybatis项目

遇到的问题

补充说明

配置解析

生命周期

结果映射（resultMap ）

日志

分页

使用注解开发

lombok的使用

关联嵌套查询

动态SQL

缓存

51CTO博客