docker安装redis连接redis可视化工具Redis Desktop Manager+springboot项目使用Cache缓存+springboot项目整合 Redis 实现缓存

最新推荐文章于 2024-07-11 20:40:46 发布
最新推荐文章于 2024-07-11 20:40:46 发布
阅读量1.1k 收藏 3
点赞数
文章标签： docker安装redis连接redis可视化工具Redis Desk

今天进一步学习了redis的相关知识，希望下面的博客可以给博友们带来帮助。

docker安装redis连接Redis Desktop Manager

启动docker (系统控制ctl:control)
systemctl start docker

查找Docker Hub上的redis镜像
docker search redis

这里我们拉取官方的默认redis镜像
docker pull redis

查询已有的镜像
docker images

使用redis镜像
运行容器
docker run -p 6379:6379 -d redis
命令说明：
-p 6379:6379 : 将容器的6379端口映射到主机的6379端口

查看容器启动情况
docker ps

连接、查看容器，使用redis镜像执行redis-cli命令连接到刚启动的容器,主机IP为127.0.0.1
docker exec -it 43f7a65ec7f8 redis-cli
127.0.0.1:6379> info

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
打开redis可视化工具Redis Desktop Manager
在这里插入图片描述
连接本地redis
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
redis中文网 http://redis.cn/ 可以查看redis命令等
在这里插入图片描述

springboot项目使用Cache缓存

一.Cache缓存的作用

大规模的数据库查询操作会成为影响用户使用体验的瓶颈，此时Cache缓存往往是解决这一问题非常好的手段之一。

 
 

 
 
  • 1

1.JSR107

Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。

 
 

 
 
  • 1

示意图：

CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可 以在运行期访问多个CachingProvider。

CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache 存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。

Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个 CacheManager所拥有。

Entry是一个存储在Cache中的key-value对。

Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期 的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在这里插入图片描述
2.Spring缓存抽象

Spring从3.1开始定义了org.springframework.cache.Cache 和org.springframework.cache.CacheManager接口来统一不同的缓存技术； 并支持使用JCache（JSR-107）注解简化我们开发。

Cache接口为缓存的组件规范定义，包含缓存的各种操作集合。

Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache。

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否 已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法 并缓存结果后返回给用户。下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点：
1.、确定方法需要被缓存以及他们的缓存策略
Spring从3.1开始定义了org.springframework.cache.Cache 和org.springframework.cache.CacheManager接口来统一不同的缓存技术； 并支持使用JCache（JSR-107）注解简化我们开发。

Cache接口为缓存的组件规范定义，包含缓存的各种操作集合。

Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache。

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否 已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法 并缓存结果后返回给用户。下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点：
1.确定方法需要被缓存以及他们的缓存策略
2、从缓存中读取之前缓存存储的数据

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

二.几个重要概念&缓存注解
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
三.SpringBoot中Cache缓存的使用
1.引入依赖

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4

在这里插入图片描述
2.在配置文件中设置属性debug=true，这样就会打印所有的配置报告。

logging:
  level:
    com.szh.springboot_redis.mapper.*: debug
debug: true

 
 

 
 
  • 1
  • 2
  • 3
  • 4

在这里插入图片描述
2.@EnableCaching开启缓存

@MapperScan(basePackages = {"com.szh.springboot_redis.mapper"})
@SpringBootApplication
@EnableCaching  // 开启缓存注解
public class SpringbootRedisApplication {

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

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

在这里插入图片描述
3.@Cacheable缓存注解的使用 (标注在service业务层方法上)

执行流程：先执行@Cacheable注解中的getCache(String name)方法,根据name判断ConcurrentMap中是否有此缓存，如果没有缓存那么创建缓存并保存数据，另外service层的方法也会执行。如果有缓存不再创建缓存，另外service层的方法也不会执行。

总结：先执行@Cacheable----->再执行service层的方法

@Cacheable注解的属性如下:

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {

@AliasFor(“cacheNames”)
String[] value() default {};

@AliasFor(“value”)
String[] cacheNames() default {};

String key() default “”;

String keyGenerator() default “”;

String cacheManager() default “”;

String cacheResolver() default “”;

String condition() default “”;

String unless() default “”;

boolean sync() default false;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

service层代码

第一次查询数据库打印service类方法日志，并把数据保存到Cahce中

第二次传入相同参数不再执行service类方法，不会打印日志，查询的数据直接从缓存中获取

@Service
@CacheConfig(cacheNames = "person") //将cacheNames抽取出来
public class PersonService {
    @Autowired
    PersonDao personDao;

 /*1. @Cacheable的几个属性详解：
  *       cacheNames/value：指定缓存组件的名字
  *       key：缓存数据使用的key,可以用它来指定。默认使用方法参数的值，一般不需要指定
  *       keyGenerator：作用和key一样，二选一
  *       cacheManager和cacheResolver作用相同：指定缓存管理器，二选一
  *       condition：指定符合条件才缓存，比如：condition="#id&gt;3"
  *                   也就是说传入的参数id&gt;3才缓存数据
  *      unless：否定缓存，当unless为true时不缓存，可以获取方法结果进行判断
  *      sync：是否使用异步模式*/
 //@Cacheable(cacheNames= "person")
 //@Cacheable(cacheNames= "person",key="#id",condition="#id&gt;3")
 @Cacheable(key="#id")
 public Person queryPersonById(Integer id){
    System.out.println("查询"+id+"号员工信息");
    Person person=new Person();
    person.setId(id);
    return personDao.query(person);
}

/**
 * @CachePut:即调用方法，又更新缓存数据
 * 修改了数据库中的数据，同时又更新了缓存
 *
 *运行时机：
 * 1.先调用目标方法
 * 2.将目标方法返回的结果缓存起来
 *
 * 测试步骤：
 * 1.查询1号的个人信息
 * 2.以后查询还是之前的结果
 * 3.更新1号的个人信息
 * 4.查询一号员工返回的结果是什么？
 *     应该是更新后的员工
 *     但只更新了数据库，但没有更新缓存是什么原因？
 * 5.如何解决缓存和数据库同步更新？
 * 这样写：@CachePut(cacheNames = "person",key = "#person.id")
 *         @CachePut(cacheNames = "person",key = "#result.id")
 */
@CachePut(key = "#result.id")
public Person updatePerson(Person person){
    System.out.println("修改"+person.getId()+"号员工信息");
    personDao.update(person);
    return person;

}
/**
 * @CacheEvict:清除缓存
 *    1.key:指定要清除缓存中的某条数据
 *    2.allEntries=true:删除缓存中的所有数据
 *    beforeInvocation=false:默认是在方法之后执行清除缓存
 *    3.beforeInvocation=true:现在是在方法执行之前执行清除缓存，
 *                          作用是：只清除缓存、不删除数据库数据
 */
//@CacheEvict(cacheNames = "person",key = "#id")
@CacheEvict(cacheNames = "person",allEntries=true)
public void deletePerson(Integer id){
    System.out.println("删除"+id+"号个人信息");
    //删除数据库数据的同时删除缓存数据
    //personDao.delete(id);

    /**
     * beforeInvocation=true
     * 使用在方法之前执行的好处:
     * 1.如果方法出现异常，缓存依旧会被删除
     */
    //int a=1/0;
}

/**
 *   @Caching是 @Cacheable、@CachePut、@CacheEvict注解的组合
 *   以下注解的含义：
 *   1.当使用指定名字查询数据库后，数据保存到缓存
 *   2.现在使用id、age就会直接查询缓存，而不是查询数据库
 */
@Caching(
        cacheable = {@Cacheable(key="#name")},
        put={ @CachePut(key = "#result.id"),
              @CachePut(key = "#result.age")
            }
)
public Person queryPersonByName(String name){
    System.out.println("查询的姓名："+name);
    return personDao.queryByName(name);
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93

springboot项目整合 Redis 实现缓存操作

缓存大致流程
在这里插入图片描述

springboot-mybatis-redis 案例

pom.xml 依赖配置:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 <!-- Spring Boot 启动父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.szh</groupId>
    <artifactId>springboot_redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_redis</name> 
    <!--整合 Mybatis 并使用 Redis 作为缓存-->
    <description>Demo project for Spring Boot</description>

&lt;properties&gt;
    &lt;java.version&gt;1.8&lt;/java.version&gt;
&lt;/properties&gt;

&lt;dependencies&gt;
&lt;!-- &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-cache&lt;/artifactId&gt;
    &lt;/dependency&gt;--&gt;
      &lt;!-- Spring Boot Reids 依赖 --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.mybatis.spring.boot&lt;/groupId&gt;
        &lt;artifactId&gt;mybatis-spring-boot-starter&lt;/artifactId&gt;
        &lt;version&gt;2.0.1&lt;/version&gt;
    &lt;/dependency&gt;

    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-devtools&lt;/artifactId&gt;
        &lt;scope&gt;runtime&lt;/scope&gt;
        &lt;optional&gt;true&lt;/optional&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;mysql&lt;/groupId&gt;
        &lt;artifactId&gt;mysql-connector-java&lt;/artifactId&gt;
        &lt;scope&gt;runtime&lt;/scope&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.projectlombok&lt;/groupId&gt;
        &lt;artifactId&gt;lombok&lt;/artifactId&gt;
        &lt;optional&gt;true&lt;/optional&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-test&lt;/artifactId&gt;
        &lt;scope&gt;test&lt;/scope&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.data&lt;/groupId&gt;
        &lt;artifactId&gt;spring-data-redis&lt;/artifactId&gt;
        &lt;version&gt;2.1.8.RELEASE&lt;/version&gt;
        &lt;scope&gt;compile&lt;/scope&gt;
    &lt;/dependency&gt;
&lt;/dependencies&gt;

&lt;build&gt;
    &lt;plugins&gt;
        &lt;plugin&gt;
            &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
            &lt;artifactId&gt;spring-boot-maven-plugin&lt;/artifactId&gt;
        &lt;/plugin&gt;
    &lt;/plugins&gt;
&lt;/build&gt;

</project>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82

application.yml 应用配置文件，增加 Redis 相关配置

server:
  port: 8080

spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/first?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username: root
password: root
redis:
host: 192.168.72.129 ##Redis服务器地址
port: 6379 ## Redis服务器连接端口
database: 0 ## Redis数据库索引（默认为0）

logging:
level:
com.szh.springboot_redis.mapper.*: debug
debug: true

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

实体类这里就不细写了，各位小伙伴就根据自己相应的数据库来编写吧。

Service业务逻辑层

package com.szh.springboot_redis.service;

import com.szh.springboot_redis.pojo.Students;
import java.util.List;

public interface StudentService {

/**
 * 查询所有信息
 * @return
 */
List&lt;Students&gt; findAllStudnet();

/**
 * 删除指定信息
 * @param id
 * @return
 */
int delStudent(Integer id);

/**
 * 修改指定信息
 * @param students
 * @return
 */
int updateStudent(Students students);

/**
 * 根据id查询
 * @param id
 * @return
 */
Students findStudentById(Integer id);

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

业务逻辑实现类 StudnetServiceImpl .java：

package com.szh.springboot_redis.service.impl;

import com.szh.springboot_redis.mapper.StudentMapper;
import com.szh.springboot_redis.pojo.Students;
import com.szh.springboot_redis.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudnetServiceImpl implements StudentService {

@Autowired
private StudentMapper studentMapper;

@Autowired
private RedisTemplate redisTemplate;

/**
 * 查询所有信息
 * @return
 */
@Override
public List&lt;Students&gt; findAllStudnet() {
    String key = "student";
    ValueOperations&lt;String, List&lt;Students&gt;&gt; operations = redisTemplate.opsForValue();

    // 缓存存在
    boolean hasKey = redisTemplate.hasKey(key);
    if (hasKey) {
        List&lt;Students&gt; students = operations.get(key);
        return students;
    }else {
        // 从 DB 中获取城市信息
        List&lt;Students&gt; students = studentMapper.findAllStudnet();

        // 插入缓存
        operations.set(key, students);
        return students;
    }
}

/**
 * 根据id查询信息
 * @param id
 * @return
 */
@Override
public Students findStudentById(Integer id) {
    String key = "city_" + id;
    ValueOperations&lt;String, Students&gt; operations = redisTemplate.opsForValue();

    // 缓存存在
    boolean hasKey = redisTemplate.hasKey(key);
    if (hasKey) {
        Students students = operations.get(key);
        return students;
    }else {
    // 从 DB 中获取城市信息
    Students students = studentMapper.findStudentById(id);

    // 插入缓存
    operations.set(key, students);
    return students;
    }
}

/**
 * 删除指定信息
 * @param id
 * @return
 */
@Override
public int delStudent(Integer id) {
    int ret = studentMapper.delStudent(id);

    // 缓存存在，删除缓存
    String key = "studnet_" + id;
    boolean hasKey = redisTemplate.hasKey(key);
    if (hasKey) {
        redisTemplate.delete(key);
    }
    return ret;
}

/**
 * 修改指定信息
 * @param students
 * @return
 */
@Override
public int updateStudent(Students students) {
    int ret = studentMapper.updateStudent(students);

    // 缓存存在，删除缓存
    String key = "students_" + students.getSid();
    boolean hasKey = redisTemplate.hasKey(key);
    if (hasKey) {
        redisTemplate.delete(key);
    }
    return ret;
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108

Controller层
StudentController.java类

package com.szh.springboot_redis.controller;

import com.szh.springboot_redis.pojo.Students;
import com.szh.springboot_redis.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class StudentController {
@Autowired
StudentService studentService;

/**
 * 查询所有信息
 * @return
 */
@GetMapping("/select")
public List&lt;Students&gt; findStudents(){
    List&lt;Students&gt; students = studentService.findAllStudnet();
    return students;
}

/**
 * 根据id查询信息
 * @param id
 * @return
 */
@GetMapping("/select/{id}")
public Students selStudentId(@PathVariable("id") Integer id){
    Students student = studentService.findStudentById(id);
    return student;
}

/**
 * 修改信息
 * @param student
 * @return
 */
@PutMapping("/update")
public int update(Students student) {
    return studentService.updateStudent(student);
}

/**
 * 删除信息
 * @param id
 * @return
 */
@DeleteMapping("delete")
public int delete(Integer id) {
    return studentService.delStudent(id);
}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

修改springboot中redis配置中的修改RedisTemplate 默认的序列化规则，将缓存序列化。

配置config文件
RedisConfig.java类

package com.szh.springboot_redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

@Configuration
public class RedisConfig{
@Bean
@SuppressWarnings(“all”)
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

运行在这里插入图片描述
测试

第一次查询是用sql语句从mysql数据库中查询出数据
在这里插入图片描述
在这里插入图片描述
第二次直接从缓存中拿数据
在这里插入图片描述
redis的可视化工具Redis Desktop Manager查看
在这里插入图片描述
大功告成！
希望本博客可以给大家带来帮助。
转载至-CSDN*丢了微笑该如何释怀

      </div>
      <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-258a4616f7.css" rel="stylesheet">
              </div>
Y-JJJJ
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Docker安装Redis 7.x、SpringBoot整合Redis（单机模式）
hkl_Forever的博客
09-04 1417
redis-server /etc/redis/redis.conf：以容器内的配置文件方式启动redis服务，最终找到的是宿主机挂载的配置文件。-v：分别对应挂载的配置文件和数据存储目录，冒号左边是宿主机目录、右边是容器内目录，最终找到的是宿主机目录中的内容。3、本人的配置和数据存储目录统一放在 //devtools/redis 目录下的 conf、data目录下。1、因为需要redis的配置文件，这里最好去redis的官方去下载一个redis使用里面的配置文件即可。
docker build -t_利用Docker 缓存优化Spring Boot应用
weixin_39914938的博客
11-22 600
本文通过利用Docker分层缓存的特性，来优化基于Spring Boot的Docker镜像。现存问题之前Build存在的问题，由于之前打包Spring Boot应用我都是把依赖也会打进Jar包中。如下图/BOOT-INF/lib下就是依赖了可以看到依赖占用了35M+，但是我们的class只占用了不到200k，但是对于我们大多数情况下开发，我们的依赖并不会频繁改变。这就会导致一个问题，这导致每次在...
Window家庭版下docker desktop安装redis、mysql配置过程记录
最新发布
weixin_58786490的博客
07-11 651
所以最后只能将Docker Desktop重新卸载掉，然后安装时取消勾选Use WSL 2 instead of Hyper-V(recommended)选项才解决。可以看到左边host是我们本地的路径（自己创建好），conf文件去：找到对应的版本下载，然后拷贝出来改一下bind：0.0.0.0（原来应该是127.0.0.1）。打开任务管理-性能，查看是否虚拟化已经支持，若未支持则需要重启进入BIOS打开虚拟化支持。2、安装虚拟机并开启Hyper-V功能、虚拟机功能。
切图仔学后端-缓存
weixin_42684490的博客
10-11 223
前言 你好，我是一个前端切图仔。这是一篇切图仔学后端的学习笔记，今天我们盘的是缓存。本文实例搭建依赖的是 Node.js 。 缓存（cache），原始意义是指访问速度比一般随机存取存储器（RAM）快的一种高速存储器。 而在广义意义上，同样是存储的结构，若前者比后者的访问速率快一个量级，则称前者为后者的缓存。比如cache比内存快，内存取值比硬盘快等。 缓存简介 一般缓存都有如下特征： 命中率：命中率=正确结果数/请求缓存次数。它是衡量缓存有效性的重要指标，命中率越高，表名缓存的使用率越高 最大空间：可
Redis Desktop manager快速查询所需缓存数据
zoujian1991的博客
09-30 6445
前言 在使用Redis Desktop manager这个工具在进行大量缓存进行数据查找时会慢的让你抓狂，现在提供几个小技巧让你快速查询所需缓存。 1 学会使用console窗口 在连接的redis服务下面，右键弹出如下窗口，点击console进入控制台 2 redis命令 1、 keys *abc* 模糊查询key关键字 2 get key 通过get命令找到具体的缓存 -----------------------千里之行始于足下---------------------------------
学习--浏览器缓存 强缓存 协商缓存 离线缓存 一点cookie
AngelQ
09-10 455
##cookie 考察cookie存储 cookie放哪里，cookie能做的事情和存在的价值 document.cookie="键=值;expires=过期时间" //cookie 后端会操作，前端也可以 document.cookie="username=zs" //在控制台cookie里面可以看到 写一次就多存一个cookie 就需要用split拆分处理字符串 获取username或者age console.log(document.cookie) //获取 cookie coo.
docker-compose启动springboot项目-springboot+redis实战案例.zip
08-30
docker-compose启动springboot项目-springboot+redis实战案例。可以参考文章：https://blog.csdn.net/Ber_Bai/article/details/119995240
Docker安装Redis并使用Another Redis Desktop Manager连接
「 虚幻私塾」
09-13 1993
这时候，Another Redis DeskTop Manager作为一款基于nodejs开发的免费的Redis可视化管理工具，可以运行在Windows、Linux、Mac平台，而且是开源免费应用，就很推荐使用了。首先Docker运行的每个容器都是隔离的，Redis默认不允许外部连接，因此想要部署在Docker容器内的应用连接上Redis，需要修改Redis默认配置，这里我们以配置文件运行redis即可。可以通过 Sort by 查看其他版本的 Redis，默认是最新版本(
Docker安装Redis并介绍可视化客户端进行操作
09-08
主要介绍了Docker安装Redis并介绍可视化客户端进行操作方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
cordova自定义清理缓存插件，ionic中使用清理缓存功能
qq_37302082的博客
04-24 2293
虽然知道清理缓存对手机性能没啥用处，不过客户要求了嘛，开始做吧 首先是自定义cordova插件的过程： 1）npm install -g plugman 若我们需要自己编写自己的插件，则可以使用额外的一个叫做plugman的工具, 该工具可直接通过npm来安装。使用plugman的好处就是会自动帮我们生成一套代码框架，而不需要我们再自己一个个建立文件。 2）安装成功后，就可以使用plu...
Cordova 懒加载+网络图片下载缓存到本地
01-25
Cordova+vue 项目实现图片懒加载并网络图片下载到本地实现本地加载，提高图片加载速度 如要插件 npm install --save js-md5 cordova-plugin-file cordova-plugin-file-transfer 在mian.js 中引入使用
Redis Desktop Manager 显示二进制乱码问题
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
04-23 5930
在SpringBoot项目中 前面还多出了许多类似\xac\xed\x00\x05t\x00这种字符串，如下图第二个key 解决办法非常简单 添加一个RedisConfig类 代码如下 package demo.shiro.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springfra
SpringBoot结合Redis Desktop Manager使用Redis缓存
我是你庆歌的博客
04-08 479
@Cacheable缓存注解： @Service @CacheConfig(cacheNames = "person") //将cacheNames抽取出来 public class PersonService { @Autowired PersonDao personDao; /*1. @Cacheable的几个属性详解： * cache...
解决docker下安装redis后，RedisDesktopManager可以链接，但是springboot项目不能链接的问题
xmgdcxyzm的博客
09-16 1587
主要原因：docker中的redis需要添加密码，不然数据会丢失，添加了密码远程访问的时候可能会出现链接不上，密码报错等问题，是因为docker中的redis版本是随时更新的，可以用 docker images 查看版本 是latest，版本更新之后，项目就链接不上redis了，之前可能能连接上，最新版本的redis需要redis.conf 配置文件，这里如果继续用dockers下的redis，就需要配置，可以在网上搜索redis.conf,然后保存在linux，映射到dockers中的文件夹，这样可以解决
RedisDesktopManager安装、连接、操作、常见问题
热门推荐
love_eat_peach的博客
05-17 3万+
添加完成之后，如果没有显示，点击Reload刷新，会在列表中显示刚刚添加的key，右侧显示的是list列表值的详细信息，在这个页面右侧有3个按钮对应value值的新增、删除和重新加载。二、设置密码 为了安全一定要设，而且这里如果不绑定ip也不设密码的话，redis是默认保护模式，只能本虚拟机访问，不允许其他ip访问，本人刚开始图方便啥都不设，结果在这里踩坑了；选择某一个数据库，然后点击右键，就可以添加某一个元素，添加完之后，这个元素就可以保存到redis内存数据库中，
使用docker 安装redis 并通过 redis desktop manager 连接
啊狸！
02-02 8149
需要环境 linux、 docker 一、通过docker 下载 redis 镜像文件 docker pull redis //默认下载最新的版本 二、通过docker images 查看下载下来的redis镜像 三、创建 data 、conf、以及redis.conf配置文件，如若不然，无法通过redis deskTop manager访问 3.1 mkdir -p /root/redis/da...
使用Redis缓存出现的问题与解决方法
2302_78891428的博客
08-06 160
2. 布隆过滤器：在数据写入数据库的同时将这个 ID 同步到到布隆过滤器中，当请求的 id 不存在布隆过滤器中则说明该请求查询的数据一定没有在数据库中保存，就不要去数据库查询了。击穿指的是缓存中没有，但是数据库有数据，由于种种原因缓存过期了，Redis 这层流量防护屏障被击穿了，很多并发请求直奔数据库导致数据库压力过大可能会压垮数据库把服务搞死。即相同业务数据写缓存时，在基础过期时间之上，再加一个随机的过期时间，让数据在未来一段时间内慢慢过期，避免瞬时全部过期，对数据库造成过大压力。
SpringBoot-Redis操作-set-get均成功，但在可视化客户端查询不到解决方式
Leopard锋的博客
08-31 1714
现象： 单一项目，通过代码层，对缓存进行存储和读取，正常。但通过可视化界面客户端或是终端链接界面 get key 查询不到。 原因及解决方案： 存储时，没有对存储的信息做序列化，一般在网上参考的时候都会复制，部分人会遗忘。加入如下代码即可 /** * redis配置类 * */ @SuppressWarnings("unchecked") @Configuration @Slf4j public class RedisConfiguration { /** * spri
Docker搭建Redis Sentinel哨兵集群与SpringBoot集成教程
本文档详细介绍了如何在Spring Boot应用中整合Redis Sentinel哨兵集群，并使用Docker进行部署。主要步骤如下： 1. Docker环境准备: - 在CentOS 7系统上，首先确保防火墙已开启redis服务器所需的对外访问端口6379和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值