SpringBoot：缓存

点击查看SpringBoot缓存demo：LearnSpringBoot09Cache-Redis

技术摘要

  1. 注解版的 mybatis
  2. @CacheConfig
  3. @Cacheable
  4. @CachePut：既调用方法，又更新缓存数据；同步更新缓存
  5. @CacheEvict：缓存清除
  6. @Caching：定义复杂的缓存规则
  7. CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字；
  8. 搭建Redis缓存环境及测试
  9. RedisTemplate
  10. 自定义CacheManager

一、缓存抽象

在这里插入图片描述

二、重要的概念和缓存注解

在这里插入图片描述

三、搭建基本环境

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>LearnSpringBoot09Cache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>LearnSpringBoot09Cache</name>
    <description>LearnSpringBoot09Cache</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
<!--        https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using.build-systems.starters -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter-jdbc</artifactId>-->
<!--        </dependency>-->
        <dependency>

            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.mybatis.spring.boot</groupId>-->
<!--            <artifactId>mybatis-spring-boot-starter</artifactId>-->
<!--            <version>3.0.2</version>-->
<!--            <scope>test</scope>-->
<!--        </dependency>-->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
3.1 创建出department和employee表

department表数据
在这里插入图片描述

employee表数据
在这里插入图片描述

3.2 创建javaBean封装数据

Department.java代码

package com.example.learnspringboot09cache.bean;

import java.io.Serializable;

public class Department implements Serializable {

    private Integer id;
    private String departmentName;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    public Integer getId() {
        return id;
    }

    public String getDepartmentName() {
        return departmentName;
    }
}

Employee.java代码

package com.example.learnspringboot09cache.bean;

import java.io.Serializable;

/*
https://blog.csdn.net/qq_26898033/article/details/129951400
 */
public class Employee implements Serializable {

    private Integer id;
    private String lastName;
    private Integer gender;
    private String email;
    private Integer dId;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setdId(Integer dId) {
        this.dId = dId;
    }

    public Integer getId() {
        return id;
    }

    public String getLastName() {
        return lastName;
    }

    public Integer getGender() {
        return gender;
    }

    public String getEmail() {
        return email;
    }

    public Integer getdId() {
        return dId;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", lastName='" + lastName + '\'' +
                ", gender=" + gender +
                ", email='" + email + '\'' +
                ", dId=" + dId +
                '}';
    }
}
3.3 整合MyBatis操作数据库
3.3.1 配置数据源信息

application.properties配置

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://192.168.0.103:3307/dbjdbc
#spring.datasource.url=jdbc:mysql://localhost:3306/springboot_cache
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver  可以不写，springboot自动识别驱动

# 开启驼峰命名匹配规则
mybatis.configuration.map-underscore-to-camel-case=true

#打印 mapper sql 语句
logging.level.com.example.learnspringboot09cache.mapper=debug

spring.data.redis.host=192.168.0.103
spring.data.redis.port=6379
#spring.data.redis.password=123456
# 查看控制台日志 打印自动配置相关信息，这里主页看缓存配置类
debug=true
3.3.2 使用注解版的MyBatis

@MapperScan指定需要扫描的mapper接口所在的包

LearnSpringBoot09CacheApplication.java代码

@MapperScan(value = "com.example.learnspringboot09cache.mapper")
@SpringBootApplication
@EnableCaching
public class LearnSpringBoot09CacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(LearnSpringBoot09CacheApplication.class, args);
    }

}
3.3.3 创建Mapper接口，并使用@Mapper注解

DepartmentMapper.java代码

package com.example.learnspringboot09cache.mapper;

import com.example.learnspringboot09cache.bean.Department;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface DepartmentMapper {
    @Select("SELECT * FROM department WHERE id = #{id}")
    Department getDeptById(Integer id);
}

EmployeeMapper.java代码

package com.example.learnspringboot09cache.mapper;

import com.example.learnspringboot09cache.bean.Employee;
import org.apache.ibatis.annotations.*;

/*
注解版的 mybatis
 */
@Mapper
public interface EmployeeMapper {
    @Select("SELECT * FROM employee WHERE id = #{id}")
    public Employee getEmpById(Integer id);

    @Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("DELETE FROM employee WHERE id=#{id}")
    public void deleteEmpById(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,d_id) VALUES(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmployee(Employee employee);

    @Select("SELECT * FROM employee WHERE lastName = #{lastName}")
    Employee getEmpByLastName(String lastName);
}
3.3.4 测试Mapper接口

LearnSpringBoot09CacheApplicationTests.java代码

@SpringBootTest
class LearnSpringBoot09CacheApplicationTests {
    @Autowired
    EmployeeMapper employeeMapper;


    @Test
    void contextLoads() {
        Employee employee = employeeMapper.getEmpById(1);
        System.out.println(employee);
    }

}

测试结果
在这里插入图片描述

从打印结果可以看出与数据库里的employee表数据一致，说明mapper接口可用

3.3.5 在网页上测试mapper接口

创建Service
EmployeeService.java

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;
    public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
    }
 }

创建Controller
EmployeeController.java

package com.example.learnspringboot09cache.controller;

import com.example.learnspringboot09cache.bean.Employee;
import com.example.learnspringboot09cache.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmployeeController {
    @Autowired
    EmployeeService employeeService;
    @GetMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable(value = "id") Integer id){
        return employeeService.getEmpById(id);
    }
    @GetMapping("/emp")
    public Employee update(Employee employee){
        Employee emp = employeeService.updateEmp(employee);

        return emp;
    }

    @GetMapping("/delemp")
    public String deleteEmp(Integer id){
        employeeService.deleteEmp(id);
        return "success";
    }

    @GetMapping("/emp/lastname/{lastName}")
    public Employee getEmpByLastName(@PathVariable("lastName") String lastName){
        return employeeService.getEmpByLastName(lastName);
    }

}

使用@PathVariable取路径变量

测试结果
在这里插入图片描述

在application.properties配置文件里，开启驼峰命名匹配规则
mybatis.configuration.map-underscore-to-camel-case=true

四、快速体验缓存

提醒：先安装Redis，示例使用docker安装Redis，如果下图

在这里插入图片描述

  1. 开启基于注解的缓存 @EnableCaching
  2. 标注缓存注解即可
    @Cacheable
    @CacheEvict
    @CachePut

默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在 ConcurrentMap<Object, Object>中
开发中使用缓存中间件；redis、memcached、ehcache；

4.1.1未开启缓存时，每次查询数据都需要访问数据库

验证

在application.properties配置文件里添加打印 mapper sql 语句

#打印 mapper sql 语句
logging.level.com.example.learnspringboot09cache.mapper=debug

在浏览器里访问http://localhost:8080/emp/4
在这里插入图片描述
看控制台查询结果已经打印的SQL日志
在这里插入图片描述

从控制台打印的日志可以看到，每次请求都发送了SQL语句，即每次都从数据库里查询

4.1.2 使用@Cacheable开启缓存

提醒：需要先启动Redis，否则运行项目后查询失败，因为连接redis失败

EmployeeService.java代码

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    /*
     * 将方法的运行结果进行缓存；以后再要相同的数据，直接从缓存中获取，不用调用方法；
     * CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字；
     *  *
     * 原理：
     *   1、自动配置类；CacheAutoConfiguration
     *      CacheConfigurationImportSelector selectImports 方法返回的配置类如下
     *   2、缓存的配置类
     *   org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration
     *   org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
     *   3、哪个配置类默认生效：看控制台打印的 缓存配置类 Positive matches: 找 matched
     *
     *   4、给容器中注册了一个CacheManager：ConcurrentMapCacheManager
     *   5、可以获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中；
     *
     *   运行流程：
     *   @Cacheable：
     *   1、方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
     *      （CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
     *   2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
     *      key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
     *          SimpleKeyGenerator生成key的默认策略；
     *                  如果没有参数；key=new SimpleKey()；
     *                  如果有一个参数：key=参数的值
     *                  如果有多个参数：key=new SimpleKey(params)；
     *   3、没有查到缓存就调用目标方法；
     *   4、将目标方法返回的结果，放进缓存中
     *
     *   @Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，
     *   如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；
     *
     *   核心：
     *      1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
     *      2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator
     *
     *
     *   几个属性：
     *      cacheNames/value：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；
     *
     *      key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值  1-方法的返回值
     *              编写SpEL； #i d;参数id的值   #a0  #p0  #root.args[0]
     *              getEmp[2]
     *
     *      keyGenerator：key的生成器；可以自己指定key的生成器的组件id
     *              key/keyGenerator：二选一使用;
     *
     *
     *      cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器
     *
     *      condition：指定符合条件的情况下才缓存；
     *              ,condition = "#id>0"
     *          condition = "#a0>1"：第一个参数的值》1的时候才进行缓存
     *
     *      unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
     *              unless = "#result == null"
     *              unless = "#a0==2":如果第一个参数的值是2，结果不缓存；
     *      sync：是否使用异步模式, 不支持 unless
     */
//    @Cacheable(cacheNames = {"emp"}, condition = "#id > 0")
    @Cacheable(cacheNames = {"emp"})
//    @Cacheable(cacheNames = {"emp"}, key = "#root.methodName+'['+#id+']'")// 自定义key
//    @Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator")// key  和  keyGenerator 二选一
//    @Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator", condition = "#id > 1")// key  和  keyGenerator 二选一
//    @Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator", condition = "#a0 > 1", unless = "#a0 == 2")// key  和  keyGenerator 二选一
    public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
    }
}

控制台日志
在这里插入图片描述

从控制台打印的日志可以看到，每次请求不再发送SQL语句了，即不再查询数据库了，说明缓存生效了

4.1.3 原理

  1. 自动配置类；CacheAutoConfiguration
    查看内部类CacheConfigurationImportSelector，里面有 selectImports 方法返回的配置类如下：2 缓存的配置类
    在这里插入图片描述

  2. 缓存的配置类
    org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration

    org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration

    org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration

    org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration

    org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration

    org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration

    org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration

    org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration

    org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration

    org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration

    org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration

  3. 哪个配置类默认生效：看控制台打印的 缓存配置类 Positive matches: 找 matched，搜索CacheConfiguration，发现 RedisCacheConfiguration 在matched里
    ** 注意：pom.xml里引入Redis之后 ，RedisCacheConfiguration， 默认的是 SimpleCacheConfiguration**
    提醒：在application.properties配置文件里添加 debug=true
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  4. 给容器中注册了一个CacheManager：ConcurrentMapCacheManager
    注意：引入Redis之后，注册的是 RedisCacheManager
    在这里插入图片描述

  5. 可以获取和创建CacheNames类型的缓存组件；他的作用将数据保存在ConcurrentMap中；

4.1.4 运行流程

运行流程：
@Cacheable：

  1. 方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
    CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
  2. 去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
    key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
    SimpleKeyGenerator生成key的默认策略；
    如果没有参数；key=new SimpleKey()；
    如果有一个参数：key=参数的值
    如果有多个参数：key=new SimpleKey(params)；
  3. 没有查到缓存就调用目标方法；
  4. 将目标方法返回的结果，放进缓存中

@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，
如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；

核心：

  1. 使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
  2. key使用keyGenerator生成的，默认是SimpleKeyGenerator
4.1.5 几个属性

cacheNames/value：指定缓存组件的名字；将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；

key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值 1-方法的返回值

编写SpEL； #i d;参数id的值 #a0 #p0 #root.args[0]
getEmp[2]

keyGenerator：key的生成器；可以自己指定key的生成器的组件id
key/keyGenerator：二选一使用;

cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器

condition：指定符合条件的情况下才缓存；
condition = “#id>0”
condition = “#a0>1”：第一个参数的值 大于1的时候才进行缓存

unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
unless = “#result == null”
unless = “#a0==2”:如果第一个参数的值是2，结果不缓存；
sync：是否使用异步模式, 不支持 unless

1. 自定义key

 @Cacheable(cacheNames = {"emp"}, key = "#root.methodName+'['+#id+']'")
 public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
}

2. 使用keyGenerator
注意：key 和 keyGenerator 是二选一，不同同时使用

    @Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator")// key  和  keyGenerator 二选一
 public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
 }

自定义生成 key
MyCacheConfig.java代码

package com.example.learnspringboot09cache.config;

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;

/*
自定义生成 key
 */
@Configuration
public class MyCacheConfig {

    @Bean(value = "mykeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString()+"]";
            }
        };
    }
}

Debug运行项目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3. condition：指定符合条件的情况下才缓存；

@Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator", condition = "#id > 1")
  public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
    }

上面意味着 查询id小于等于1的员工信息始终不会缓存，只有id大于1才会缓存

4. condition和 unless条件

    @Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator", condition = "#a0 > 1", unless = "#a0 == 2")// 如果id 为1和2 都不会缓存
    public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
    }

上面意味着：如果id 为1、2 都不会缓存，因为1不满足condition条件， 2 不满足unless条件

5. sync：是否使用异步模式
注意：sync 默认是false，如果开启了，则不支持unless
看源码

在这里插入图片描述

开启异步

@Cacheable(cacheNames = {"emp"}, keyGenerator = "mykeyGenerator", condition = "#id > 1", sync = true)// 上面意味着 查询id小于等于1的员工信息始终不会缓存，只有id大于1才会缓存
  public Employee getEmpById(Integer id){
        System.out.println("员工 编号："+id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
}
4.1.6 @CachePut

@CachePut：既调用方法，又更新缓存数据；同步更新缓存
修改了数据库的某个数据，同时更新缓存；
运行时机：
1、先调用目标方法
2、将目标方法的结果缓存起来

在EmployeeService.java新增下面的updateEmp方法

 	@CachePut(value = "emp",key = "#result.id")
    public Employee updateEmp(Employee employee){
        System.out.println("updateEmp:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }

测试步骤：

  1. 查询1号员工；查到的结果会放在缓存中；
    key：1 value：lastName：张三
  2. 以后查询还是之前的结果
  3. 更新1号员工；【lastName:zhangsan；gender:0】
    将方法的返回值也放进缓存了；
  4. 查询1号员工？
    应该是更新后的员工；
    key = “#employee.id”:使用传入的参数的员工id；
    key = “#result.id”：使用返回后的id
    @Cacheable的key是不能用#result

为什么是没更新前的？【1号员工没有在缓存中更新】

4.1.7 @CacheEvict

@CacheEvict：缓存清除
key：指定要清除的数据
allEntries = true：指定清除这个缓存中所有的数据
beforeInvocation = false：缓存的清除是否在方法之前执行
默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除

beforeInvocation = true：
代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除

在EmployeeService.java新增下面的deleteEmp方法

//删除指定的id数据
@CacheEvict(value="emp", key = "#id")
public void deleteEmp(Integer id){
     System.out.println("deleteEmp:"+id) ;
     employeeMapper.deleteEmpById(id);
     //int i = 10/0;
 }

//清除缓存中所有数据
@CacheEvict(value="emp", allEntries = true)
public void deleteEmp(Integer id){
     System.out.println("deleteEmp:"+id) ;
     employeeMapper.deleteEmpById(id);
     //int i = 10/0;
 }

//模拟方法出错情况下，清空缓存
 @CacheEvict(value="emp", beforeInvocation = true)
 public void deleteEmp(Integer id){
     System.out.println("deleteEmp:"+id) ;
     //employeeMapper.deleteEmpById(id);
     int i = 10/0;// 模拟出错
 }
4.1.8 @Caching

@Caching：定义复杂的缓存规则

在EmployeeService.java新增下面的getEmpByLastName方法

 @Caching(
            cacheable = {
                    @Cacheable(value="emp", key = "#lastName")
            },
            put = {
                    @CachePut(value="emp", key = "#result.id"),
                    @CachePut(value="emp", key = "#result.email")
            }
    )
    public Employee getEmpByLastName(String lastName){
        return employeeMapper.getEmpByLastName(lastName);
    }
4.1.9 @CacheConfig

@CacheConfig(cacheNames=“emp”,cacheManager = “employeeCacheManager”) //抽取缓存的公共配置

//前面写的value="emp"都可以去掉了，统一使用下面的cacheNames="emp"
@CacheConfig(cacheNames="emp",cacheManager = "employeeCacheManager") //抽取缓存的公共配置
@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;
}

默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在 ConcurrentMap<Object, Object>中

五、整合redis作为缓存

Redis英文官网
Redis中文官网
Redis命令中文官网
Redis桌面管理工具-Mac电脑

开发中使用缓存中间件；redis、memcached、ehcache；
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

步骤如下

5.1. 安装redis

示例在docker里安装redis；

在这里插入图片描述

5.2. 引入redis的starter

点击查看Spring官网里starters

在这里插入图片描述

在pom.xml添加spring-boot-starter-data-redis依赖
在这里插入图片描述

5.3. 配置redis
spring.data.redis.host=192.168.0.102
spring.data.redis.port=6379

在这里插入图片描述
引入redis之后，RedisAutoConfiguration就开始生效了
在这里插入图片描述

RedisAutoConfiguration类里的RedisTemplate和StringRedisTemplate是Spring用来简化操作Redis

5.4 测试Template

自定义Template
MyRedisConfig.java类里的方法

@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Employee> ser = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        template.setDefaultSerializer(ser);
        return template;
    }
    @Bean
    public RedisTemplate<Object, Department> deptRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Department> template = new RedisTemplate<Object, Department>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Department> ser = new Jackson2JsonRedisSerializer<Department>(Department.class);
        template.setDefaultSerializer(ser);
        return template;
    }
}

LearnSpringBoot09CacheApplicationTests.java代码

package com.example.learnspringboot09cache;

import com.example.learnspringboot09cache.bean.Employee;
import com.example.learnspringboot09cache.mapper.EmployeeMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

@SpringBootTest
class LearnSpringBoot09CacheApplicationTests {
    @Autowired
    EmployeeMapper employeeMapper;

    @Autowired
    StringRedisTemplate stringRedisTemplate;//  操作k-v字符串的

    @Autowired
    RedisTemplate redisTemplate; // k-v 都是对象

    @Autowired
    RedisTemplate<Object, Employee> empRedisTemplate;//这个是在 MyRedisConfig 类里定义的 empRedisTemplate

    /**
     * Redis常见的五大数据类型
     *  String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）
     *  stringRedisTemplate.opsForValue()[String（字符串）]
     *  stringRedisTemplate.opsForList()[List（列表）]
     *  stringRedisTemplate.opsForSet()[Set（集合）]
     *  stringRedisTemplate.opsForHash()[Hash（散列）]
     *  stringRedisTemplate.opsForZSet()[ZSet（有序集合）]
     */
    @Test
    public void test01(){
        // https://www.redis.net.cn/tutorial/3511.html
//        stringRedisTemplate.opsForValue().append("msg", "hello");//给 Redis保存数据
//        String msg = stringRedisTemplate.opsForValue().get("msg");//读数据
//        System.out.println("msg值："+msg);


//		stringRedisTemplate.opsForList().leftPush("mylist","1");
//		stringRedisTemplate.opsForList().leftPush("mylist","2");
    }

    //测试保存对象
    @Test
    public void test02(){
    	//注意：Employee 需要序列化
        Employee empById = employeeMapper.getEmpById(2);
//        System.out.println(empById);
        //默认如果保存对象，使用jdk序列化机制，序列化后的数据保存到redis中
//        redisTemplate.opsForValue().set("emp-01",empById);
//        System.out.println(redisTemplate.opsForValue().get("emp-01"));

        //1、将数据以json的方式保存
        //(1)自己将对象转为json
        //(2)redisTemplate默认的序列化规则；改变默认的序列化规则；
        empRedisTemplate.opsForValue().set("emp01",empById);
        System.out.println(empRedisTemplate.opsForValue().get("emp01"));
    }

    @Test
    void contextLoads() {
        Employee employee = employeeMapper.getEmpById(1);
        System.out.println(employee);
    }

}

测试stringRedisTemplate结果
在这里插入图片描述

测试自定义 empRedisTemplate结果
提醒：这个是在 MyRedisConfig 类里定义的 empRedisTemplate
在这里插入图片描述

六、测试缓存

原理：CacheManager===Cache 缓存组件来实际给缓存中存取数据

  1. 引入redis的starter，容器中保存的是 RedisCacheManager；
  2. RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件；RedisCache通过操作redis缓存数据的
  3. 默认保存数据 k-v 都是Object；利用序列化保存；如何保存为json
    1、引入了redis的starter，cacheManager变为 RedisCacheManager；
    2、默认创建的 RedisCacheManager 操作redis的时候使用的是 RedisTemplate<Object, Object>;
    3、RedisTemplate<Object, Object> 是 默认使用jdk的序列化机制;
  4. 自定义CacheManager；

6.1 自定义CacheManager

提醒：@Primary 作用是将某个缓存管理器作为默认的
注意：存在在多个CacheManager时，必须指定一个作为默认的
注意：实际开发中还是使用 RedisTemplate<Object, Object>

DepartmentMapper.java代码

@Mapper
public interface DepartmentMapper {
    @Select("SELECT * FROM department WHERE id = #{id}")
    Department getDeptById(Integer id);
}

DeptService.java代码

package com.example.learnspringboot09cache.service;

import com.example.learnspringboot09cache.bean.Department;
import com.example.learnspringboot09cache.mapper.DepartmentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cache.Cache;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.stereotype.Service;


@Service
//@CacheConfig(cacheNames="dept"/*,cacheManager = "deptCacheManager"*/) //抽取缓存的公共配置，指定CacheManager， employeeCacheManager在 MyRedisConfig类里定义的
public class DeptService {

    @Autowired
    DepartmentMapper departmentMapper;

//    @Qualifier(value = "deptCacheManager")
//    @Autowired
//    RedisCacheManager deptCacheManager;


    /**
     *  缓存的数据能存入redis；
     *  第二次从缓存中查询就不能反序列化回来；
     *  存的是dept的json数据;CacheManager默认使用RedisTemplate<Object, Employee>操作Redis
     *
     *
     * @param id
     * @return
     */
    @Cacheable(cacheNames = "dept",cacheManager = "deptCacheManager")//也可以在方法里指定CacheManager
    public Department getDeptById(Integer id){
        System.out.println("查询部门"+id);
        Department department = departmentMapper.getDeptById(id);
        return department;
    }

    // 使用缓存管理器得到缓存，进行api调用
//    public Department getDeptById(Integer id){
//        System.out.println("查询部门"+id);
//        Department department = departmentMapper.getDeptById(id);
//
//        //获取某个缓存
//        Cache dept = deptCacheManager.getCache("dept");
//        dept.put("dept:1",department);
//
//        return department;
//    }

}

MyRedisConfig.java类代码

package com.example.learnspringboot09cache.config;


import com.example.learnspringboot09cache.bean.Department;
import com.example.learnspringboot09cache.bean.Employee;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.CacheKeyPrefix;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.format.support.DefaultFormattingConversionService;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.UnknownHostException;
import java.time.Duration;

@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Employee> ser = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        template.setDefaultSerializer(ser);
        return template;
    }
    @Bean
    public RedisTemplate<Object, Department> deptRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Department> template = new RedisTemplate<Object, Department>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Department> ser = new Jackson2JsonRedisSerializer<Department>(Department.class);
        template.setDefaultSerializer(ser);
        return template;
    }

    /*
    https://blog.csdn.net/qq_43366662/article/details/121249962

    https://huaweicloud.csdn.net/637ef512df016f70ae4ca5cb.html
     */
    @Primary  //将某个缓存管理器作为默认的  注意：存在在多个CacheManager时，必须指定一个作为默认的
    @Bean
    public RedisCacheManager defaultCacheManager(RedisConnectionFactory connectionFactory) throws InvocationTargetException, IllegalAccessException, InstantiationException {
        //对 对象类型（employee）和string类型的序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        Jackson2JsonRedisSerializer<String> keySerializer = new Jackson2JsonRedisSerializer<>(String.class);

        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        RedisCacheConfiguration.registerDefaultConverters(conversionService);
        RedisCacheConfiguration redisCacheConfiguration = null;

        Constructor[] constructors = RedisCacheConfiguration.class.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            constructor.setAccessible(true);
            if(constructor.getParameterTypes().length==7){//因为只有构造方法，所以判断方式比较随意
                redisCacheConfiguration = (RedisCacheConfiguration) constructor.newInstance(Duration.ZERO, true, true, CacheKeyPrefix.simple(), RedisSerializationContext.SerializationPair.fromSerializer(keySerializer), RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer),conversionService);
            }
        }

        assert redisCacheConfiguration != null;
        //通过RedisCacheManagerBuilder来创建RedisCacheManager，也可以直接new
        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory).cacheDefaults(redisCacheConfiguration).build();
    }

    @Bean
    public RedisCacheManager employeeCacheManager(RedisConnectionFactory connectionFactory) throws InvocationTargetException, IllegalAccessException, InstantiationException {
        //对 对象类型（employee）和string类型的序列化
        Jackson2JsonRedisSerializer<Employee> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Employee.class);
        Jackson2JsonRedisSerializer<String> keySerializer = new Jackson2JsonRedisSerializer<>(String.class);

        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        RedisCacheConfiguration.registerDefaultConverters(conversionService);
        RedisCacheConfiguration redisCacheConfiguration = null;

        Constructor[] constructors = RedisCacheConfiguration.class.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            constructor.setAccessible(true);
            if(constructor.getParameterTypes().length==7){//因为只有构造方法，所以判断方式比较随意
                redisCacheConfiguration = (RedisCacheConfiguration) constructor.newInstance(Duration.ZERO, true, true, CacheKeyPrefix.simple(), RedisSerializationContext.SerializationPair.fromSerializer(keySerializer), RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer),conversionService);
            }
        }

        assert redisCacheConfiguration != null;
        //通过RedisCacheManagerBuilder来创建RedisCacheManager，也可以直接new
        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory).cacheDefaults(redisCacheConfiguration).build();
    }


    @Bean
    public RedisCacheManager deptCacheManager(RedisConnectionFactory connectionFactory) throws InvocationTargetException, IllegalAccessException, InstantiationException {
        //对 对象类型（employee）和string类型的序列化
        Jackson2JsonRedisSerializer<Department> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Department.class);
        Jackson2JsonRedisSerializer<String> keySerializer = new Jackson2JsonRedisSerializer<>(String.class);

        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        RedisCacheConfiguration.registerDefaultConverters(conversionService);
        RedisCacheConfiguration redisCacheConfiguration = null;

        Constructor[] constructors = RedisCacheConfiguration.class.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            constructor.setAccessible(true);
            if(constructor.getParameterTypes().length==7){//因为只有构造方法，所以判断方式比较随意
                redisCacheConfiguration = (RedisCacheConfiguration) constructor.newInstance(Duration.ZERO, true, true, CacheKeyPrefix.simple(), RedisSerializationContext.SerializationPair.fromSerializer(keySerializer), RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer),conversionService);
            }
        }

        assert redisCacheConfiguration != null;
        //通过RedisCacheManagerBuilder来创建RedisCacheManager，也可以直接new
        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory).cacheDefaults(redisCacheConfiguration).build();
    }




    //CacheManagerCustomizers可以来定制缓存的一些规则
//    @Primary  //将某个缓存管理器作为默认的， 注意实际开发中还是使用 RedisTemplate<Object, Object>
//    @Bean
//    public RedisCacheManager employeeCacheManager(RedisTemplate<Object, Employee> empRedisTemplate){
//        RedisCacheManager cacheManager = new RedisCacheManager(empRedisTemplate);
//        //key多了一个前缀
//
//        //使用前缀，默认会将CacheName作为key的前缀
//        cacheManager.setUsePrefix(true);
//
//        return cacheManager;
//    }

//    @Bean
//    public RedisCacheManager deptCacheManager(RedisTemplate<Object, Department> deptRedisTemplate){
//        RedisCacheManager cacheManager = new RedisCacheManager(deptRedisTemplate);
//        //key多了一个前缀
//
//        //使用前缀，默认会将CacheName作为key的前缀
//        cacheManager.setUsePrefix(true);
//
//        return cacheManager;
//    }


}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/627742.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

达梦(DM) SQL数据及字符串操作

达梦(DM) SQL数据及字符串操作

达梦DM SQL数据及字符串操作 数据操作字符串操作 这里继续讲解DM数据库的操作&#xff0c;主要涉及插入、更新、删除操作。 数据操作 插入数据&#xff0c;不指定具体列的话就需要插入除自增列外的其他列&#xff0c;当然自增列也可以直接指定插入 INSERT INTO SYS_USER VALU…
阅读更多...
5---Linux小程序“进度条”及缓冲区的概念(逻辑梳理，轻松理解)

5---Linux小程序“进度条”及缓冲区的概念(逻辑梳理，轻松理解)

一、缓冲区的解析&#xff1a; 1.1论点的引入&#xff1a; 在Linux中有一个接口sleep&#xff0c;可以使得C/C程序休眠一段指定的时间。他需要依赖的头文件是<unistd.h>&#xff0c;注意这个接口为Linux私有。 usleep接口类似sleep接口&#xff0c;但是单位为微秒。下面…
阅读更多...
Linux 通过关键字查找文件

Linux 通过关键字查找文件

按文件名查找 find 路径 -name “文件名” 查找当前目录下的所有mk文件 find . -name "*.mk"按关键字查找 find 路径 -name “文件名” | xargs grep -n “关键字” 参数&#xff1a; xargs 是给命令传递参数的一个过滤器&#xff0c;也是组合多个命令的一个工具 -n…
阅读更多...
基于springboot实现的在线动漫信息平台

基于springboot实现的在线动漫信息平台

开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09; 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven…
阅读更多...
Windows内核--Kernel API简析(3.1)

Windows内核--Kernel API简析(3.1)

如果所有的内核提供的功能&#xff0c;内核提供进程/线程创建和终止&#xff0c;内存分配和释放&#xff0c;文件操作&#xff0c;网络功能&#xff0c;驱动程序加载和卸载等功能。这些API将在后面陆续介绍&#xff0c;如下先介绍Kernel提供的基础API(Kernel自身或Driver使用).…
阅读更多...
SpringBoot内置插件的使用（jackson和lombok）

SpringBoot内置插件的使用（jackson和lombok）

文章目录 引言I lombok(自动为属性生成构造器)II jacksonsee also引言 idea正式版2021.2.2 已经捆绑安装jackson和lombok插件 I lombok(自动为属性生成构造器) Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。 htt…
阅读更多...
基于ProxySQL中间件实现MySQL的读写分离

基于ProxySQL中间件实现MySQL的读写分离

目录 ProxySQL简介 ProxySQL安装 配置YUM仓库 YUM安装 关于读写分离的实现 集群信息 测试读写分离 测试总结 ProxySQL Configuration CLI ProxySQL简介 ProxySQL是一个高性能的MySQL协议代理&#xff0c;它支持多种数据库后端&#xff0c;包括Amazon Aurora、RDS、Cl…
阅读更多...
51单片机：点亮一个LED灯

51单片机：点亮一个LED灯

1.新建工程 选择AT89C52&#xff0c;在Atmel下显示的是See Microchip 并不需要添加启动文件到文件夹中。 添加main.c文件&#xff0c;c比cpp效率高&#xff0c;.asm汇编即更底层 程序编写好后 nop(); 该函数在这个头文件里面 #include <INTRINS.H> #include <R…
阅读更多...
AI应用案例：律师服务质量评价

AI应用案例：律师服务质量评价

利用微调后的模型对律师的服务质量进行评价是一种高效且客观的方法。首先&#xff0c;我们需要一个预先训练好的模型作为基础&#xff0c;这个模型可能已经具备了处理文本或类似数据的能力。然后&#xff0c;针对律师服务质量的特定需求&#xff0c;我们对模型进行微调&#xf…
阅读更多...
电脑录屏软件有哪些？这3款神器必须要知道

电脑录屏软件有哪些？这3款神器必须要知道

在当今现代社会&#xff0c;电脑录屏软件已经成为人们日常生活中不可或缺的一部分。无论是录制游戏精彩瞬间、制作教程、还是在线会议记录&#xff0c;一款好用的电脑录屏软件都能帮助我们更高效地完成任务。可是电脑录屏软件有哪些呢&#xff1f;接下来&#xff0c;我们将介绍…
阅读更多...
MES系统在电线电缆行业生产上的应用

MES系统在电线电缆行业生产上的应用

MES系统在线缆行业的应用可以带来多重价值&#xff0c;包括提高生产效率、降低生产成本、提高产品质量、优化库存管理、改善生产环境和提高企业竞争力等方面。因此&#xff0c;在电线电缆行业中广泛应用MES系统可以提高企业的经济效益和社会效益&#xff0c;推动企业发展和行业…
阅读更多...
30W 宽电压输入 AC/DC 导轨式开关电源——TPR/DG-30-XS 系列

30W 宽电压输入 AC/DC 导轨式开关电源——TPR/DG-30-XS 系列

TPR/DG-30-XS 系列导轨式开关电源&#xff0c;额定输出功率为30W&#xff0c;产品输入范围&#xff1a;90-264VAC。提供12V、24V输出&#xff0c;12V输出时&#xff0c;工作温度范围 (-25℃~70℃)具有短路保护&#xff0c;过载保护等功能&#xff0c;并具备高效率&#xff0c;高…
阅读更多...
地平线旭日X3开发板Object Detection测试调试

地平线旭日X3开发板Object Detection测试调试

旭日X3派具有最高5TOPS的等效算力 (X3M BPU主频1.2GHz、算力5TOS; X3E BPU 主频0.6GHZ&#xff0c;算力3TOPS)&#xff0c; 因此在开发板上可以运行丰富的AI算法。 在系统/app/ai_inference目录下提供了基础算法示例&#xff1a; 01_basic_sample 系统给出的测试程序只能对给…
阅读更多...
中腾食品上海食堂承包创新食堂空间，构建企业第三文化沙龙

中腾食品上海食堂承包创新食堂空间，构建企业第三文化沙龙

在快节奏的现代职场生活中&#xff0c;企业食堂已不再是简单的餐饮供应地&#xff0c;而是逐渐演变成为员工休息休闲、互动体验、阅读思考的重要场所。中腾国际团餐产业集团通过专业的定制化食堂承包&#xff0c;在企业食堂内部打造企业第三文化空间&#xff0c;为员工提供一个…
阅读更多...
社交媒体的探索者：探寻Facebook的发展历程

社交媒体的探索者：探寻Facebook的发展历程

在当今数字化时代&#xff0c;社交媒体已经成为了人们日常生活中不可或缺的一部分&#xff0c;而Facebook作为最具影响力的社交平台之一&#xff0c;其发展历程承载着无数的探索与创新。本文将深入探讨Facebook的发展历程&#xff0c;从其创立初期到如今的全球化影响&#xff0…
阅读更多...
leetcode.环形链表问题

leetcode.环形链表问题

目录 题目1 示例 解题思路 代码实现 补充 题目2 示例 解题思路 代码实现 题目1 该题链接&#xff1a;https://leetcode.cn/problems/linked-list-cycle/description/ 示例 解题思路 要创建两个指针一个是快指针(fast)&#xff0c;另一个慢指针(slow)。快指针走两步慢指…
阅读更多...
网络安全快速入门（十二）(下) 目录结构相关命令补充

网络安全快速入门（十二）(下) 目录结构相关命令补充

12.4 补充命令 我们已经了解了linux的目录结构&#xff0c;接下来我们大概看一下针对目录及文件的一些相关命令&#xff0c; 我们本章只讲三个目录及文件相关的命令&#xff0c;分别是tree&#xff0c;find及校验文件命令&#xff0c;我们一个一个来看这些命令。 12.4.1 tree命…
阅读更多...
MySQL 编译安装

MySQL 编译安装

一、数据库的基本概念 数据&#xff08;Data&#xff09; 数据库中存储的实际信息&#xff0c;可以是数字、文本、图像等形式。 表 以行和列的形式结构化存储数据。 数据库 表的集合&#xff0c;存放数据的仓库 数据库 ——> 数据表 ——> 数据 数据库管理系统&…
阅读更多...
【OceanBase诊断调优】—— 备份恢复如何定位 NFS 服务异常

【OceanBase诊断调优】—— 备份恢复如何定位 NFS 服务异常

当备份、归档出现异常时&#xff0c;我们应该首先排除备份介质、网络是否正常&#xff0c;本文讲述如何通过系统表和日志来定位 NFS 服务异常。 适用版本 OceanBase 数据库所有版本。 如何查看备份归档异常&#xff1f; 查看备份归档状态表&#xff0c;MAX_NEXT_TIME 应与当…
阅读更多...
Adaboost集成学习 | Matlab实现基于CNN-BiLSTM-Adaboost集成学习时间序列预测（股票价格预测）

Adaboost集成学习 | Matlab实现基于CNN-BiLSTM-Adaboost集成学习时间序列预测（股票价格预测）

目录 效果一览基本介绍模型设计程序设计参考资料效果一览 基本介绍 Adaboost集成学习 | Matlab实现基于CNN-BiLSTM-Adaboost集成学习时间序列预测（股票价格预测） 模型设计 融合Adaboost的CNN-BiLSTM模型的时间序列预测，下面是一个基本的框架。 数据准备： 收集并整理用于时…
阅读更多...
最新文章

Copyright @ 2022~2023