Mybatis

1. 数据持久化

数据持久化是指将数据保存在磁盘或其他永久存储介质上，以便在应用程序重新启动或系统崩溃后仍然可以访问和使用这些数据。在软件开发中，数据持久化是至关重要的，因为它确保了数据的长期存储和可靠性。以下是几种常见的数据持久化技术：

1. 关系型数据库：

• 关系型数据库是一种结构化的数据存储系统，其中的数据以表格的形式组织，并且可以使用 SQL（Structured Query Language）进行查询和操作。
• 常见的关系型数据库包括 MySQL、PostgreSQL、Oracle、SQL Server 等。
• 在关系型数据库中，数据通过 INSERT、UPDATE、DELETE 等 SQL 语句进行增加、修改和删除，通过 SELECT 语句进行查询。

2. 对象关系映射（ORM）：

• ORM 是一种编程技术，用于将对象模型和关系数据库之间的数据进行映射。
• ORM 框架（如Hibernate、JPA等）可以将Java对象映射到数据库表，使开发人员能够使用面向对象的方式来操作数据库。
• ORM 提供了更高级别的抽象，简化了数据访问和持久化的过程，减少了开发人员需要编写的SQL语句数量。

3. NoSQL数据库：

• NoSQL（Not Only SQL）数据库是一种非关系型数据库，它不使用固定的表格模式，而是以更灵活的方式存储数据。
• NoSQL数据库适用于需要处理大量非结构化或半结构化数据的场景，例如文档数据库、键值存储、列族数据库等。
• 常见的NoSQL数据库包括MongoDB、Cassandra、Redis等。

4. 文件系统：

• 在一些简单的应用程序中，可以将数据保存在文件中，例如使用文本文件、XML文件、JSON文件等。
• 文件系统是一种简单的数据持久化方式，但通常不适用于大规模或复杂的数据存储需求。

选择合适的数据持久化技术取决于应用程序的需求、性能要求、数据结构和开发团队的经验等因素。在设计和实现数据持久化方案时，需要综合考虑这些因素，并根据实际情况做出合适的选择。

2. Dao层，Service层，Controller层

Dao层负责数据的持久化，Service层负责业务逻辑的处理，而Controller层负责用户界面的交互和响应。

1. Dao层（数据访问层）：

• Dao层负责与数据存储（通常是数据库）进行交互，执行数据的读取、写入、更新和删除等操作。
• Dao层通常包含与数据存储相关的接口和实现类，这些类负责处理数据的持久化，并提供数据访问的接口给Service层。
• Dao层的设计应该封装数据库访问细节，使得上层的Service层可以更专注于业务逻辑而不需要关心数据库的具体实现。

2. Service层（业务逻辑层）：

• Service层负责实现应用程序的业务逻辑，包括处理业务规则、数据校验、事务管理等。
• Service层通常调用Dao层提供的接口来访问数据，执行业务逻辑操作，并且可能协调多个Dao层的操作以完成一个业务功能。
• Service层通常暴露给Controller层或其他外部组件的接口，用于处理来自用户界面或其他外部系统的请求。

3. Controller层（表示层）：

• Controller层负责接收用户的请求，调用适当的Service层来处理请求，并将处理结果返回给用户。
• Controller层通常包含Web框架中的控制器类，它们负责解析HTTP请求、验证用户输入、调用Service层处理业务逻辑，并将结果渲染到视图中返回给客户端。
• Controller层是应用程序与外部世界（例如Web浏览器、移动应用程序等）之间的接口，它将用户请求转换为应用程序的内部操作，并将处理结果返回给用户。

3. 为什么需要Mybatis

MyBatis是一个持久层框架，它简化了在Java应用程序中与关系型数据库的交互。使用MyBatis可以带来多方面的好处：

1. 简化数据库操作：MyBatis通过将数据库操作封装在映射文件中，可以大大简化与数据库的交互。开发人员无需编写大量的JDBC代码，而是可以使用简洁的XML或注解来定义SQL语句和参数映射。

2. 灵活的SQL编写：MyBatis允许开发人员编写原生的SQL语句，并且提供了丰富的SQL语句配置选项，包括动态SQL、参数化查询、结果集映射等功能。这使得开发人员可以灵活地编写复杂的SQL查询，并且可以优化SQL以提高性能。

3. 易于集成：MyBatis可以轻松地集成到现有的Java应用程序中，不需要引入过多的依赖。它与Spring Framework、Spring Boot等常用的Java框架和容器集成良好，可以与它们无缝配合使用。

4. 性能优化：MyBatis提供了一系列性能优化功能，包括缓存、延迟加载、批量操作等，可以提高数据库访问的性能和效率。通过合理地配置缓存和优化SQL语句，可以减少数据库访问次数和提高响应速度。

5. 与对象的映射：MyBatis支持将查询结果映射为Java对象，使得开发人员可以更方便地处理数据库查询结果，并且可以避免手动进行数据转换的繁琐工作。这种对象-关系映射（ORM）的能力使得开发人员可以使用面向对象的方式来操作数据库。

4. sqlSessionFactory —> SqlSession

1. SqlSessionFactory：

• SqlSessionFactory是MyBatis中的一个重要接口，它是用于创建SqlSession实例的工厂。通常情况下，SqlSessionFactory在应用程序的生命周期内只会被创建一次，因为它的创建开销较大，包括加载配置文件、解析映射文件等。一旦创建完成，SqlSessionFactory对象会被用来创建SqlSession对象。
• SqlSessionFactory负责初始化MyBatis的环境配置，包括数据库连接池、事务管理等。它可以通过配置文件或者Java代码进行配置，以满足不同应用场景的需求。
• 通常情况下，开发人员通过调用SqlSessionFactoryBuilder类的build()方法来创建SqlSessionFactory实例。

2. SqlSession：

• SqlSession是MyBatis中的一个重要接口，它代表了与数据库的一次会话。每个SqlSession都会拥有自己的一组数据库操作方法，包括插入、更新、删除、查询等操作。开发人员可以通过调用SqlSession的方法来执行这些数据库操作。
• SqlSession对象是线程不安全的，因此通常情况下它会被限定在方法作用域内，并且在执行完数据库操作后及时关闭。
• 在MyBatis中，SqlSession对象可以通过SqlSessionFactory的openSession()方法来创建。也可以通过指定是否自动提交事务来创建不同类型的SqlSession，比如openSession(true)表示自动提交事务的SqlSession。

User.java:

public class User {
    private int id;
    private String username;
    private String email;

    // Getters and setters
}

UserMapper.java

import com.example.model.User;

public interface UserMapper {
    User getUserById(int userId);
}

UserMapper.xml

<!-- UserMapper.xml -->
<!-- namespace 绑定对应的接口 -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" parameterType="int" resultType="com.example.model.User">
        SELECT id, username, email
        FROM users
        WHERE id = #{userId}
    </select>
</mapper>

mybatis-config.xml:

<!-- mybatis-config.xml -->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!-- 数据库连接配置 -->
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

Demo:

import com.example.model.User;
import com.example.mapper.UserMapper;
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 Main {
    public static void main(String[] args) {
        // 从配置文件加载配置
        String resource = "mybatis-config.xml";
        try (InputStream inputStream = Resources.getResourceAsStream(resource)) {
            // 创建SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

            // 创建SqlSession对象
            try (SqlSession session = sqlSessionFactory.openSession()) {
                // 获取Mapper接口的实现类对象
                UserMapper userMapper = session.getMapper(UserMapper.class);
                
                // 调用Mapper接口的方法执行查询
                User user = userMapper.getUserById(1);
                
                // 输出查询结果
                System.out.println(user);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5. namespace

在MyBatis中，namespace是指定映射文件中的命名空间。它用于在映射文件中唯一标识一个Mapper接口或者Mapper XML文件。

在MyBatis的映射文件中，namespace通常用来绑定一个Java接口，这个接口定义了对应SQL语句的方法。通过namespace，MyBatis能够知道要执行哪个Mapper接口中的方法。

例如，在一个MyBatis的映射文件（通常以.xml结尾，如上文的UserMapper.xml）中，你会看到类似以下的配置：

<mapper namespace="com.example.mapper.UserMapper">
    <!-- SQL语句以及结果映射配置 -->
</mapper>

在这个例子中，namespace指定了UserMapper接口的命名空间为com.example.mapper.UserMapper。这意味着在映射文件中定义的SQL语句将与UserMapper接口关联起来。

然后，在Java代码中，可以通过SqlSession的getMapper()方法获取对应的Mapper接口实现类对象，从而执行相应的SQL操作。

总之，namespace在MyBatis中用于唯一标识Mapper接口或Mapper XML文件，并在映射文件中绑定Java接口，以便与SQL语句相关联。

6. 增删改需要提交事务, mybatis如何实现

1. 手动提交事务： 在进行增删改操作后，显式地调用 commit() 方法提交事务。你可以在使用 SqlSession 进行数据库操作后手动提交事务，示例如下：

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    // 执行增删改操作
    sqlSession.insert("insertStatement", parameter);
    sqlSession.update("updateStatement", parameter);
    sqlSession.delete("deleteStatement", parameter);

    // 提交事务
    sqlSession.commit();
} finally {
    sqlSession.close();
}

2. 自动提交事务： 在 MyBatis 中，可以通过配置 SqlSessionFactory 来实现自动提交事务。你可以设置 autoCommit 属性为 true，这样 MyBatis 将会自动提交事务。示例如下：

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
sqlSessionFactory.getConfiguration().setEnvironment(new Environment("development", new JdbcTransactionFactory(), dataSource));
sqlSessionFactory.getConfiguration().setAutoCommit(true);

3. 使用声明式事务管理： 如果你使用 Spring 或其他支持声明式事务管理的框架，你可以在服务层方法上添加 @Transactional 注解来管理事务。示例如下：

@Transactional
public void performTransaction() {
    // 执行增删改操作
    myMapper.insert(data);
    myMapper.update(data);
    myMapper.delete(data);
}

7. @Transactional 注解

@Transactional 注解是用于声明一个方法需要在事务上下文中执行的注解。它通常用于基于 Spring 的应用程序中，用来管理数据库事务的行为。下面是关于 @Transactional 注解的一些详解：

1. 事务边界： @Transactional 注解可以被放置在方法级别或者类级别。当它被放置在类级别时，它会被应用于该类中所有的方法上，除非这些方法自身也被 @Transactional 注解修饰。

2. 传播行为（Propagation）： @Transactional 注解支持多种传播行为，用来定义方法调用之间事务的传播方式。例如，如果一个事务方法内部调用了另一个带有事务的方法，传播行为就定义了这两个事务方法之间事务的行为。常见的传播行为包括 REQUIRED、REQUIRES_NEW、NESTED 等。

3. 隔离级别（Isolation Level）： 事务的隔离级别定义了事务执行期间对数据修改的可见性。@Transactional 注解允许你指定所需的隔离级别，例如 READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE 等。

4. 超时设置（Timeout）： 你可以使用 @Transactional 注解来指定事务的超时时间，即事务执行的最长时间。如果事务在规定的时间内未完成，则会被自动回滚。

5. 回滚规则（Rollback Rules）： 通过 @Transactional 注解，你可以指定在发生特定类型的异常时是否回滚事务。你可以通过 rollbackFor 或 noRollbackFor 属性来定义需要回滚的异常类型。

6. 只读（Read-only）： 如果你的方法只涉及到读操作而不涉及写操作，你可以使用 readOnly 属性将事务设置为只读，这样可以提高性能。

7. 事务管理器（Transaction Manager）： @Transactional 注解需要与一个事务管理器一起使用，该事务管理器负责实际地管理事务的生命周期。在 Spring 应用程序中，你可以配置不同类型的事务管理器，如 DataSourceTransactionManager、JpaTransactionManager 等。

8. 注解参数： @Transactional 注解支持多个属性来配置事务的行为。除了上述提到的属性外，还有一些其他属性，如 isolation、propagation、timeout、readOnly、rollbackFor、noRollbackFor 等。

8. 在mybatis, 字段或者参数过多，考虑使用Map

UserMapper.java

import java.util.Map;

public interface UserMapper {
    Map<String, Object> getUserById(int id);
}

UserMapper.xml

<!-- UserMapper.xml -->
<mapper namespace="com.example.UserMapper">
    <select id="getUserById" resultType="java.util.Map" parameterType="map">
        SELECT * FROM users WHERE id = #{id} AND name = #{name}
    </select>
</mapper>

Demo.java

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {
    public static void main(String[] args) {
        // 创建 MyBatis 的 SqlSessionFactory
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(
                Main.class.getResourceAsStream("/mybatis-config.xml"));

        // 获取一个 SqlSession
        try (SqlSession session = sessionFactory.openSession()) {
            // 获取 UserMapper 接口的实例
            UserMapper userMapper = session.getMapper(UserMapper.class);

            Map<String, Object> map = new HashMap<>();
            map.put("id", 1);
            map.put("name", "张三");
            
            // 调用查询方法获取用户数据
            Map<String, Object> user = userMapper.getUser(map);

            // 打印查询结果
            System.out.println(user);
        }
    }
}

9. 模糊查询

<select id="searchUsersByName" parameterType="string" resultType="User">
    SELECT * FROM users WHERE name LIKE CONCAT('%', #{keyword}, '%');
</select>

10. 核心配置文件 mybatis-config.xml

1. configuration（配置）：根元素，包含了 MyBatis 的所有配置信息。

2. properties（属性）：用于配置属性，可以在 MyBatis 中引用这些属性值。

3. settings（设置）：包含了 MyBatis 的全局性设置，例如缓存、懒加载等。

4. typeAliases（类型别名）：用于为 Java 类型设置别名，简化 XML 映射文件中的配置。

5. typeHandlers（类型处理器）：用于处理 Java 类型和数据库类型之间的转换。

6. objectFactory（对象工厂）：用于创建结果对象的实例。

7. plugins（插件）：用于在 MyBatis 执行过程中添加自定义的拦截器。

8. environments（环境配置）：包含了 MyBatis 的不同环境配置，例如开发环境、测试环境、生产环境等。

9. environment（环境变量）：指定了一个具体的环境配置，包括事务管理器和数据源。

10. transactionManager（事务管理器）：用于配置 MyBatis 的事务管理器。

11. dataSource（数据源）：配置 MyBatis 使用的数据库连接池。

12. databaseIdProvider（数据库厂商标识）：用于设置不同数据库厂商的 SQL 语句。

13. mappers（映射器）：包含了 MyBatis 映射器（Mapper）的配置信息，指定了 XML 映射文件或者注解接口的位置。

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>
    <!-- 设置全局属性 -->
    <properties resource="db.properties"/>

    <!-- 设置全局设置 -->
    <settings>
        <setting name="cacheEnabled" value="true"/>
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

    <!-- 定义别名 -->
    <typeAliases>
        <typeAlias type="com.example.User" alias="User"/>
    </typeAliases>

    <!-- 注册类型处理器 -->
    <typeHandlers>
        <typeHandler handler="com.example.EmailTypeHandler"/>
    </typeHandlers>

    <!-- 配置对象工厂 -->
    <objectFactory type="com.example.MyObjectFactory"/>

    <!-- 配置插件 -->
    <plugins>
        <plugin interceptor="com.example.MyPlugin"/>
    </plugins>

    <!-- 配置数据源 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 配置映射器 -->
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

1. properties 元素：引用外部的属性文件，可以在这里定义数据库连接的属性，如用户名、密码等。

2. settings 元素：设置全局性的 MyBatis 参数，比如缓存和懒加载的开启与关闭。

3. typeAliases 元素：为 Java 类型设置别名，这样在 XML 映射文件中可以直接使用别名。

4. typeHandlers 元素：注册自定义的类型处理器，用于处理 Java 类型和数据库类型之间的转换。

5. objectFactory 元素：配置对象工厂，用于创建结果对象的实例。

6. plugins 元素：配置自定义的插件，用于在 MyBatis 执行过程中添加拦截器。

7. environments 元素：配置不同的环境，比如开发环境、测试环境和生产环境。

8. transactionManager 元素：配置事务管理器，这里使用的是 JDBC 事务管理器。

9. dataSource 元素：配置数据源，这里使用的是 POOLED 数据源，可以设置数据库的驱动、URL、用户名和密码等。

10. mappers 元素：配置映射器，指定了 XML 映射文件的位置。

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8
username=root
password=root

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

11. 组件的生命周期和作用域

1. SqlSessionFactoryBuilder：

• 生命周期：SqlSessionFactoryBuilder 是用于创建 SqlSessionFactory 实例的构建器。它通常是在应用程序启动时创建的，然后被丢弃，不会保留在整个应用程序的生命周期内。
• 作用域：SqlSessionFactoryBuilder 的作用域是短暂的，它通常在配置 MyBatis 的过程中使用，并且一旦创建了 SqlSessionFactory 实例，就不再需要它了。因此，它的作用域可以是方法级别或者一次配置过程的生命周期。

2. SqlSessionFactory：

• 生命周期：SqlSessionFactory 是应用程序启动时创建的，通常在整个应用程序的生命周期内保持不变。它负责创建 SqlSession 对象，是 MyBatis 中最重要的顶级工厂。
• 作用域：全局唯一，整个应用程序共享。

3. SqlSession：

• 生命周期：SqlSession 是在需要与数据库交互时由 SqlSessionFactory 创建的，它代表了一次数据库会话。一般情况下，它的生命周期很短，应该在需要时创建，用完即关闭。
• 作用域：通常情况下，SqlSession 的作用域是一个请求（Request）或者一个方法的执行过程。每个请求或方法执行都应该有自己的 SqlSession，并在使用完成后关闭。

4. Mapper接口：

• 生命周期：Mapper 接口通常是由 MyBatis 的映射器工厂根据配置文件加载时创建的，它与具体的 SQL 映射文件相对应。
• 作用域：Mapper 接口的作用域通常是短暂的，类似于 SqlSession，它们在需要时被创建并在使用完成后销毁。通常情况下，每个方法调用应该使用一个新的 Mapper 实例。

5. Mapper映射文件：

• 生命周期：Mapper 映射文件是在应用程序启动时加载并解析的，其中包含了 SQL 语句的定义和映射规则。
• 作用域：Mapper 映射文件的作用域是全局的，一旦加载就会一直存在于应用程序的内存中。

12. 如何解决属性名和字段名不一致的问题

1. 使用别名（ResultMap 别名）：在 SQL 查询中，使用 AS 关键字为查询结果的字段起一个别名，使其与 Java 对象的属性名保持一致。例如：

SELECT id AS userId, username AS userName FROM users;

这样，即使数据库字段名为 id 和 username，在查询结果中它们的别名会被映射为 userId 和 userName，与 Java 对象的属性名一致。

2. 使用 ResultMap 进行映射：在 XML 映射文件中定义 ResultMap，将数据库字段和 Java 对象的属性进行映射。在 ResultMap 中，可以使用 <result> 标签来指定字段名和属性名的映射关系，这样就可以解决属性名和字段名不一致的问题。

<resultMap id="userResultMap" type="User">
    <id property="userId" column="id"/>
    <result property="userName" column="username"/>
</resultMap>

3. 使用 @Result 注解：在注解方式下，可以直接在属性上使用 @Result 注解来指定属性和字段的映射关系。

@Result(property = "userId", column = "id")
@Result(property = "userName", column = "username")

13. 日志工厂

日志工厂是在应用程序中记录信息、警告和错误的关键工具。在 Java 开发中，日志工厂通常是通过使用相应的日志框架来实现的。下面是几种常用的日志框架：

1. SLF4J（Simple Logging Facade for Java）：SLF4J 是一个简单的日志门面，允许你在不同的日志实现之间切换，而无需修改应用程序代码。SLF4J 提供了统一的日志接口，而具体的日志记录实现可以是 Log4j、Log4j2、JDK Logging、Commons Logging 等。

2. Log4j：Log4j 是一个功能强大且灵活的日志记录框架，提供了丰富的配置选项和灵活的日志级别控制。它支持多种输出目标（如控制台、文件、数据库等），并可以通过配置文件进行灵活配置。

3. Log4j2：Log4j2 是 Log4j 的升级版，具有更好的性能和更丰富的功能。它提供了异步日志记录、插件化架构、基于 XML、JSON 或 YAML 的配置等特性，是一个现代化的日志框架。

4. JDK Logging：JDK Logging 是 Java Development Kit（JDK）提供的默认日志框架，它使用 java.util.logging 包提供日志记录功能。虽然功能相对简单，但是由于是 JDK 的一部分，因此具有良好的兼容性和稳定性。

5. Commons Logging：Commons Logging 是 Apache Commons 项目提供的一个通用日志接口，它允许开发者在不同的日志实现之间切换，类似于 SLF4J。然而，由于 Commons Logging 的设计存在一些缺陷，因此在实际项目中可能使用较少。

6. STDOUT Logging：STDOUT Logging 是一种简单的日志记录方式，将日志直接输出到标准输出流（stdout），通常用于调试和简单的日志记录需求。

7. NO Logging：这种方式并不是真正的日志框架，而是在应用程序中禁用日志记录，通常用于生产环境中为了提高性能而关闭日志记录功能。

在mybatis中如何进行配置和使用？

1. 选择日志实现

2. 导入日志框架依赖：在你的项目中添加选择的日志框架的依赖项。例如，如果你选择 Log4j 作为日志实现，需要在 Maven 或 Gradle 中添加 Log4j 的依赖项。

pom.xml

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.x.x</version> <!-- 替换为你使用的 Log4j 版本 -->
</dependency>

build.gradle

implementation 'org.apache.logging.log4j:log4j-core:2.x.x' // 替换为你使用的 Log4j 版本

3. 配置日志记录器：在 MyBatis 核心配置文件（通常是 mybatis-config.xml）中，配置日志记录器。你需要指定日志实现的类路径，并设置日志级别。以下是一个使用 Log4j 的示例配置：

<configuration>
    <!-- 其他配置项 -->
    
    <!-- 配置日志 -->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
</configuration>

如果你使用的是 Log4j2，可以将 value 设置为 LOG4J2。

4. 配置日志框架：根据选择的日志框架，你需要在项目中添加相应的日志配置文件。例如，对于 Log4j，你需要创建一个 log4j.xml 或 log4j.properties 文件，并配置日志输出格式、日志级别等。

以下是一个简单的 Log4j 配置示例：

#将等级为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/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

5. 在代码中使用日志：在项目中的代码中，你可以使用日志记录器来输出日志信息。例如，在 Java 类中使用 Log4j 输出日志：

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class MybatisExample {
    private static final Logger logger = LogManager.getLogger(MybatisExample.class);

    public void doSomething() {
        logger.debug("Debug message");
        logger.info("Info message");
        logger.warn("Warning message");
        logger.error("Error message");
    }
}

这样，在 MyBatis 执行过程中，你就能够在日志中看到相关的调试、信息、警告和错误消息。

14. 分页

基于数据库的分页查询

在 Mapper XML 文件中编写 SQL 查询语句，并添加分页参数：

<!-- 在 UserMapper.xml 文件中 -->
<select id="getUserList" resultType="User">
    SELECT * FROM user
    LIMIT #{offset}, #{pageSize}
</select>

然后，在 Java 代码中调用这个 SQL 查询语句，并传入分页参数：

// 在 UserMapper 接口中定义方法
List<User> getUserList(@Param("offset") int offset, @Param("pageSize") int pageSize);

// 在调用方法时传入分页参数
List<User> userList = userMapper.getUserList(0, 10); // 获取第一页，每页10条记录

这样就可以实现基于数据库的分页查询了。

基于应用程序的分页查询

使用 RowBounds

UserMapper.java

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

UserMapper.xml

    <!-- 分页2 -->
    <select id="getUserByRowBounds" resultMap="userMap">
        select * from  mybatis.user
    </select>

Demo

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

//      RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 2);

//      通过Java代码层面实现分页
        List<User> userList = sqlSession.selectList("com.github.subei.dao.UserMapper.getUserByRowBounds",null,rowBounds);

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

        sqlSession.close();
    }

使用 PageHelper

首先，需要在 Maven 或 Gradle 中添加 PageHelper 依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>latest_version</version>
</dependency>

然后，在代码中配置 PageHelper：

import com.github.pagehelper.PageHelper;

// 在查询之前调用 PageHelper.startPage 方法
PageHelper.startPage(pageNum, pageSize);
List<User> userList = userMapper.getUserList(); // 执行查询

// 获取分页信息
PageInfo<User> pageInfo = new PageInfo<>(userList);
System.out.println("总记录数：" + pageInfo.getTotal());
System.out.println("当前页码：" + pageInfo.getPageNum());
System.out.println("每页记录数：" + pageInfo.getPageSize());

15. 关于接口的理解

接口是一种编程概念，用于定义对象之间的通信协议或契约。在面向对象编程中，接口定义了类应该实现的方法签名，但不包含方法的具体实现。它们定义了一组公共的方法，类可以选择性地实现这些方法，从而确保类能够按照指定的接口进行交互。

以下是接口的一些关键特点和用途：

1. 抽象性： 接口是抽象的，它只描述了方法的签名而没有提供具体的实现。这使得接口成为一种强大的抽象工具，能够定义出不同类之间共享的行为和特征。

2. 多态性： 接口支持多态性，即一个类可以实现多个接口，从而具备不同的行为。这使得对象能够根据具体的上下文，以不同的方式进行交互。

3. 解耦合： 接口可以帮助实现代码的解耦合。通过将类的公共行为抽象成接口，可以使得类之间的依赖关系更松散，提高代码的灵活性和可维护性。

4. 规范化： 接口提供了一种规范化的编程方式，使得不同的实现类能够在接口约定下进行交互。这有助于团队合作，提高代码的可读性和可理解性。

5. 扩展性： 接口可以作为代码的扩展点，允许在不改变现有代码的情况下引入新的功能或实现。

16. 面向对象与面向过程的区别

1. 思维方式：

• 面向对象编程（OOP）： OOP强调的是将问题看作是一组对象的集合，每个对象都有其自身的状态（属性）和行为（方法）。这种编程范式更加注重模块化和抽象化，将现实世界中的实体和它们的关系映射到代码中。
• 面向过程编程（POP）： POP则更倾向于将问题看作是一系列的步骤或过程，强调的是通过一系列的函数来完成任务。在POP中，程序的主要组成部分是函数，而不是对象。

2. 数据与功能的组织方式：

• 面向对象编程（OOP）： OOP将数据（属性）和功能（方法）封装在对象中。对象通过消息传递进行通信，对象之间的交互通过方法调用来实现。这种封装性和消息传递机制有助于提高代码的模块化和可重用性。
• 面向过程编程（POP）： POP则将数据和功能分开处理，通过一系列的函数来对数据进行处理。数据通常是全局的或者作为函数参数传递，函数之间通过参数和返回值进行数据交换。

3. 可维护性和可扩展性：

• 面向对象编程（OOP）： OOP通常更具有可维护性和可扩展性。由于封装和继承等特性，可以更容易地对代码进行修改和扩展，同时也更容易理解和维护。
• 面向过程编程（POP）： POP的代码结构通常比较扁平，功能之间的耦合性较高，导致代码难以维护和扩展。

4. 重用性：

• 面向对象编程（OOP）： OOP倾向于通过类和对象的组合来实现代码的重用，可以通过继承、组合、接口等机制来促进代码的重用。
• 面向过程编程（POP）： POP的代码通常需要显式地进行拷贝粘贴或者将通用功能封装成函数来实现重用，但相比OOP而言，重用性通常较低。

17. Mybatis 如何使用注解开发

1. 配置MyBatis配置文件： 首先，在MyBatis的配置文件（通常是mybatis-config.xml）中启用注解功能，通过设置<settings>元素下的useGeneratedKeys和useColumnLabel属性来配置：

<configuration>
    <settings>
        <setting name="useGeneratedKeys" value="true"/>
        <setting name="useColumnLabel" value="true"/>
    </settings>
</configuration>

2. 创建数据访问接口： 创建一个Java接口，用于定义数据访问的方法。在方法上使用注解来映射SQL语句。

import org.apache.ibatis.annotations.*;

public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{userId}")
    User getUserById(@Param("userId") int userId);

    @Insert("INSERT INTO users(username, password) VALUES(#{username}, #{password})")
    @Options(useGeneratedKeys = true, keyProperty = "id") // 自动获取生成的主键并设置到User对象中
    int insertUser(User user);

    @Update("UPDATE users SET username = #{username}, password = #{password} WHERE id = #{id}")
    int updateUser(User user);

    @Delete("DELETE FROM users WHERE id = #{userId}")
    int deleteUser(@Param("userId") int userId);
}

3. 配置Mapper接口： 在MyBatis的配置文件中，配置Mapper接口的位置。（之前这里的 class 是 XxxMapper.xml）

<mappers>
    <mapper class="com.example.mapper.UserMapper"/>
</mappers>

4. 调用Mapper接口： 在应用程序中，通过MyBatis的SqlSessionFactory获取Mapper实例，并调用其中的方法。

SqlSessionFactory sessionFactory = MyBatisUtil.getSqlSessionFactory();
try (SqlSession session = sessionFactory.openSession()) {
    UserMapper userMapper = session.getMapper(UserMapper.class);

    // 使用注解定义的SQL语句进行数据操作
    User user = userMapper.getUserById(1);
    System.out.println(user);

    User newUser = new User("John", "password123");
    userMapper.insertUser(newUser);
    session.commit();
}

5. 注意事项：

• 在使用注解时，需要注意SQL语句的书写格式和参数的传递方式。
• 使用@Param注解来指定参数的名称，以便在SQL语句中引用。
• 使用@Options注解来配置自动生成的主键属性等选项。
• 在Mapper接口中定义的方法名和参数列表需要与SQL语句中的参数对应。

18. Mybatis 如何使用注解开发的底层原理，反射，动态代理

MyBatis使用注解开发的底层原理涉及到反射和动态代理两个重要的概念：

1. 反射： 反射是Java中一种高级特性，它允许程序在运行时检查和操作类、方法、属性等程序的内部结构。在MyBatis中，通过反射机制，可以在运行时解析注解，并根据注解中的信息来动态生成对应的SQL语句或者执行相应的数据库操作。

2. 动态代理： 动态代理是一种设计模式，它允许在运行时创建一个实现了一组给定接口的代理对象。在MyBatis中，Mapper接口中的方法都是定义了对数据库的操作，而这些方法的具体实现是由MyBatis框架在运行时动态生成的。MyBatis使用了JDK动态代理来生成Mapper接口的实现类，这样就可以在不编写实现类的情况下，直接调用Mapper接口中的方法。

结合反射和动态代理，MyBatis使用注解时的底层原理大致如下：

• 当应用程序启动时，MyBatis会扫描Mapper接口中的注解，并根据注解中的信息生成对应的SQL语句或者数据库操作逻辑。
• 对于带有@Select、@Insert、@Update、@Delete等注解的方法，MyBatis会解析这些注解，并根据注解中的SQL语句，动态生成对应的SQL执行代码。
• 对于带有@Param注解的方法参数，MyBatis会使用反射获取方法参数的名称，并将参数名称和值映射到SQL语句中。
• 在运行时，当应用程序调用Mapper接口中的方法时，实际上是调用了由MyBatis动态生成的代理对象的方法。
• 代理对象会根据方法的签名和注解等信息，调用相应的数据库操作，执行SQL语句，并返回结果。

19. @Param() 注解

@Param() 注解是 MyBatis 中用于指定方法参数的别名的注解。在 MyBatis 中，当 SQL 语句需要使用方法参数时，可以通过 @Param() 注解来为方法参数指定一个别名，这样在 XML 映射文件或者注解方式中引用参数时可以使用该别名而不是默认的参数名。这在需要传递多个参数或者参数名与 SQL 语句中的占位符不一致时非常有用。

20. #{}与${} 区别

• #{} 解析为一个 JDBC 预编译语句（prepared statement）的参数标记符，一个 #{ } 被解析为一个参数占位符；而${}仅仅为一个纯碎的 String 替换，在动态 SQL 解析阶段将会进行变量替换。

• #{} 解析之后会将String类型的数据自动加上引号，其他数据类型不会；而${} 解析之后是什么就是什么，他不会当做字符串处理。

• #{} 很大程度上可以防止SQL注入（SQL注入是发生在编译的过程中，因为恶意注入了某些特殊字符，最后被编译成了恶意的执行操作）；而${} 主要用于SQL拼接的时候，有很大的SQL注入隐患。

• 在某些特殊场合下只能用${}，不能用#{}。

  • 例如：在使用排序时ORDER BY $ {id}，如果使用#{id}，则会被解析成ORDER BY “id”,这显然是一种错误的写法。

21. lombok

Lombok是一个Java库，它通过注解的方式来简化Java类的开发，减少样板代码的编写。下面是Lombok中一些常用注解的介绍：

1. @Data：

• 该注解会自动为类生成默认的构造方法、getter和setter方法、toString()方法、hashCode()方法以及equals()方法。
• 使用@Data注解后，无需手动编写这些常用方法，可以大大减少代码量。

2. @AllArgsConstructor：

• 该注解会为类生成一个包含所有参数的构造方法。
• 使用该注解后，不需要手动编写构造方法，特别是当类的字段很多时，可以省去很多重复的代码。

3. @NoArgsConstructor：

• 该注解会为类生成一个无参的构造方法。
• 当需要一个无参构造方法时，可以使用该注解来自动生成。

4. @EqualsAndHashCode：

• 该注解会为类生成equals()和hashCode()方法。
• 生成的equals()方法会根据类的所有非静态字段来比较对象是否相等，同时生成的hashCode()方法会使用这些字段来计算哈希值。

5. @ToString：

• 该注解会为类生成toString()方法。
• 生成的toString()方法会按照格式ClassName(field1=value1, field2=value2, ...)输出类的所有字段的名称和值。

6. @Getter：

• 该注解用于生成类中所有字段的getter方法。
• 使用该注解后，无需手动编写getter方法，可以直接通过注解来自动生成。

22. 多对一 VS 一对多

1. 多对一：（1）按照查询嵌套处理；（2）按照结果嵌套处理
2. 一对多：（1）按照查询嵌套处理；（2）按照结果嵌套处理

1. 多对一

（1）按照查询嵌套处理

在多对一关联关系中，按照查询嵌套处理意味着在执行查询时，同时查询关联对象的信息，然后将其映射到主对象中。在 MyBatis 中，这通常通过嵌套查询来实现。通过在 XML 中定义一个额外的查询语句（嵌套子查询），并在主查询中引用它来获取关联对象的信息。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置文件-->
<mapper namespace="com.github.subei.dao.StudentMapper">

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

（2）按照结果嵌套处理

按照结果嵌套处理意味着在执行查询时，分别查询主对象和关联对象的信息，然后在 Java 代码中将它们组合起来形成最终结果。这种方式不需要在 XML 中定义额外的查询语句，而是通过 MyBatis 的结果映射来完成。我们可以通过嵌套 <resultMap> 元素来实现这一点，将关联对象的属性映射到主对象的属性中。

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

2. 一对多

（1）按照查询嵌套处理

在一对多关联关系中，按照查询嵌套处理意味着在执行查询时，同时查询主对象及其关联对象的信息，并将它们映射到一起。在 MyBatis 中，这同样可以通过嵌套查询来实现。在 XML 中定义一个查询语句，同时查询主对象和关联对象的信息，然后通过 <collection> 元素将关联对象的集合映射到主对象的属性中。

<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id = #{tid}
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>

<select id="getStudentByTeacherId" resultType="Student">
    select * from mybatis.student where tid = #{tid}
</select>

（2）按照结果嵌套处理

按照结果嵌套处理意味着分别查询主对象和关联对象的信息，然后在 Java 代码中将它们组合成最终结果。这种方式同样不需要在 XML 中定义额外的查询语句，而是通过 MyBatis 的结果映射来完成。我们可以使用嵌套 <resultMap> 元素来实现这一点，将关联对象的集合属性映射到主对象的属性中。

    <!--按结果嵌套查询-->
    <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"/>
        <!--复杂的属性，需要单独处理
        对象： association 集合： collection
        javaType="" 指定属性的类型！
        集合中的泛型信息，我们使用ofType获取
        -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

1. 关联 - association 【多对一】
2. 集合 - collection 【一对多】
3. javaType & ofType
4. JavaType 用来指定实体类中属性的类型
5. ofType 用来指定映射到List或者集合中的 pojo类型，泛型中的约束类型！

23. 动态 SQL

动态 SQL 是一种在 SQL 查询中根据不同条件生成不同 SQL 语句的技术。它在实际开发中非常有用，因为有时我们需要根据不同的条件动态构建查询语句以满足业务需求。

在 MyBatis 中，可以使用动态 SQL 功能来实现这一点。MyBatis 提供了一些标签来编写动态 SQL，最常用的包括 <if>、<choose>、<when>、<otherwise>、<trim>、<where>、<set>、<foreach> 等。

以下是一些常见的动态 SQL 使用示例：

1. 使用 <if> 标签根据条件包含或排除特定的 SQL 片段：

<select id="getEmployees" parameterType="map" resultType="Employee">
    SELECT * FROM employee
    <where>
        <if test="departmentId != null">
            AND department_id = #{departmentId}
        </if>
        <if test="name != null and name != ''">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
    </where>
</select>

在这个示例中，根据传入的参数，如果 departmentId 不为 null，则动态添加条件 department_id = #{departmentId} 到查询中，如果 name 也不为空，则动态添加条件 name LIKE '%name%'。

2. 使用 <choose>、<when>、<otherwise> 标签实现条件选择：

<select id="getEmployees" parameterType="map" resultType="Employee">
    SELECT * FROM employee
    <where>
        <choose>
            <when test="sortOrder == 'ASC'">
                ORDER BY name ASC
            </when>
            <when test="sortOrder == 'DESC'">
                ORDER BY name DESC
            </when>
            <otherwise>
                ORDER BY id DESC
            </otherwise>
        </choose>
    </where>
</select>

在这个示例中，根据传入的 sortOrder 参数的不同值，动态选择不同的排序方式。

3. 使用 <foreach> 标签进行动态 IN 查询：

<select id="getEmployeesByIds" parameterType="map" resultType="Employee">
    SELECT * FROM employee
    WHERE id IN
    <foreach collection="ids" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>

在这个示例中，根据传入的 ids 参数，动态构建一个 IN 查询，查询所有指定的员工信息。

24. mybatis 缓存

MyBatis 中的缓存是一种用于提高性能的重要机制，它可以在应用程序和数据库之间缓存查询的结果集，从而避免频繁地访问数据库，提高系统的响应速度。MyBatis 提供了两种类型的缓存：本地缓存/一级缓存（Local Cache）和二级缓存（Second Level Cache）。

1. 本地缓存/一级缓存（Local Cache）：

• 默认情况下，每次执行 SQL 时，MyBatis 会为该 SQL 语句创建一个本地缓存，用于存储查询结果。
• 本地缓存是与 SqlSession 关联的，意味着在同一个 SqlSession 中执行相同的 SQL 查询，会直接从本地缓存中获取结果，而不会再次查询数据库。
• 本地缓存是线程安全的，每个线程拥有自己的 SqlSession 和本地缓存。

2. 二级缓存（Second Level Cache）：

• 二级缓存是跨 SqlSession 的缓存，它可以缓存跨多个 SqlSession 的查询结果。
• 二级缓存的作用域是 Mapper 级别的，意味着同一个 Mapper 下的不同 SqlSession 可以共享相同的二级缓存。
• 默认情况下，二级缓存是禁用的，需要手动配置开启。
• 可以通过在 Mapper XML 文件中的 <cache> 元素中配置二级缓存的属性，如缓存类型、缓存刷新时间等。

二级缓存的配置示例：

1. 配置环境： 在 MyBatis 的配置文件（通常是 mybatis-config.xml）中开启二级缓存，并配置相应的属性。

<!-- 在 mybatis-config.xml 文件中配置 -->
<settings>
    <!-- 开启全局缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

2. 配置 Mapper 文件： 在需要使用二级缓存的 Mapper 接口对应的 XML 文件中，配置 <cache> 元素。

<!-- 在 Mappr XML 文件中配置 -->
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 开启二级缓存 -->
    <cache/>
    
    <!-- 其他 SQL 映射配置 -->
</mapper>

也可以自定义参数：

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

3. 确认实体类支持序列化： 被缓存的实体类需要实现 Serializable 接口，以便进行序列化和反序列化操作。这是因为二级缓存在将对象存储到缓存中时需要将其序列化为字节流，而在从缓存中取出对象时需要反序列化。

import java.io.Serializable;

public class User implements Serializable {
    // 类定义
}

4. 注意事项：

• 在需要使用二级缓存的 SQL 映射文件中，确保 SQL 语句的结果可以被缓存，即需要进行查询的结果需要是可序列化的对象。

• 确保数据库表的数据在被修改时，缓存能够及时更新或失效，以避免数据一致性问题。

• 对于需要缓存的实体对象，确保其实现了合适的 equals() 和 hashCode() 方法，以便在缓存中进行对象比较。

• 注意二级缓存的作用范围是 Mapper 级别的，因此同一个 Mapper 下的不同 SQL 查询结果可以共享二级缓存。

• 二级缓存默认是按照 LRU（最近最少使用）的算法进行缓存对象的淘汰。

• 在执行写操作（insert、update、delete）时，会清空该 Mapper 下的所有二级缓存。

• 对于查询语句中使用了动态 SQL、分页或嵌套查询的情况下，MyBatis 默认不会开启二级缓存。

• 只要开启了二级缓存，在同一个Mapper下就有效

• 所有的数据都会先放在一级缓存中；

• 只有当会话提交，或者关闭的时候，才会提交到二级缓冲中！

在实际应用中，使用缓存可以有效地提高系统的性能，但同时也需要注意缓存的合理使用，避免缓存数据过期导致数据不一致的问题。

25. Redis数据库来做缓存

1. 安装和配置 Redis：
   首先，你需要在你的服务器上安装并配置 Redis。可以通过下载 Redis 的官方发布版本或使用包管理工具来安装 Redis。安装完成后，确保 Redis 正在运行，并根据需要进行必要的配置（例如，设置密码、调整内存限制等）。

2. 选择 Redis 客户端：
   为了在应用程序中使用 Redis，你需要选择一个合适的 Redis 客户端库。各种编程语言都有相应的 Redis 客户端库，例如 Jedis（Java）、StackExchange.Redis（C#）、redis-py（Python）等。根据你的项目需求和喜好选择一个合适的客户端库。

3. 连接 Redis：
   在应用程序中，使用选定的 Redis 客户端库来连接 Redis 服务器。通常，你需要提供 Redis 服务器的主机名、端口号以及可能的认证信息（如果设置了密码）来建立连接。

4. 数据存取操作：
   一旦连接建立成功，你可以使用 Redis 客户端库提供的方法来进行数据的存取操作。常见的操作包括设置键值对、获取键值对、设置过期时间、删除键值对等。

5. 缓存策略：
   设计合适的缓存策略对于 Redis 缓存的有效使用至关重要。这包括决定哪些数据需要被缓存、设置适当的过期时间、处理缓存击穿和缓存雪崩等问题。

6. 集成到应用程序中：
   最后，将 Redis 缓存集成到你的应用程序中。通常，这涉及到在需要缓存的地方使用 Redis 来缓存数据，并在需要时从 Redis 中获取数据，而不是直接从数据库中获取。

参考

Mybatis笔记目录(6天) - subeiLY - 博客园