1.2_springboot2.x中redis缓存&原理介绍

2023-02-27 08:25:51

1、整合redis作为缓存

说明这里springboot版本2.19

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构

1、安装redis,使用docker安装

docker search redis

docker pull redis 下载redis，这里已经下载过了就不演示了

使用docker images 查看容器：

启动redis

docker run -d -p 6379:6379 --name myredis docker.io/redis

将虚拟机的端口和容器的端口绑定并且后台运行

使用客户端连接（host根据自己配置）

配置好进入页面

1.1.1、概念介绍

1.jedis和lettuce介绍

Lettuce 和 Jedis 的定位都是Redis的client

Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接

Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，因为StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

springboot2之前redis的连接池为jedis，2.0以后redis的连接池改为了lettuce，lettuce能够支持redis4，需要java8及以上。lettuce是基于netty实现的与redis进行同步和异步的通信，之前看到spring-session-data-redis里的samples已经改为使用LettuceConnectionFactory

所以下面我们看下如何来使用Lettuce来操作Redis

RedisAutoConfiguration 自动配置类

@Configuration

@ConditionalOnClass(RedisOperations.class)

@EnableConfigurationProperties(RedisProperties.class)

@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })

public class RedisAutoConfiguration {

可以知道RedisAutoConfiguration完成了对JedisConnectionFactory和LettuceConnectionFactory的自动配置。

同时RedisProperties源码中封装了对redis配置，包括jedis和lettuce

@ConfigurationProperties(prefix = "spring.redis")

public class RedisProperties {

    private final Jedis jedis = new Jedis();

	private final Lettuce lettuce = new Lettuce();

}

因此我们在使用时直接通过yml配置即可使用Lettuce来连接Redis

1.1.2、引入starter

使用Lettuce连接Redis，maven项目，引入依赖,注意lettuce连接池的使用需要引入commons-pool2依赖包

 <!--引入redis-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-pool2</artifactId>

        </dependency>

1.1.3、配置redis

application.yml配置

#redis 的配置

# springboot2.x以上如此配置，由于2.x的客户端是lettuce

# 单位要带上

spring:

  redis:

    host: 192.168.56.101

    port: 6379

    database: 0

    lettuce:

      pool:

        max-active: 8

        min-idle: 0

        max-idle: 8

        max-wait: 10000ms

      shutdown-timeout: 100ms

1.1.4、测试redis是否成功

原理：RedisAutoConfiguration中有两个操作类

stringRedisTemplate; //操作k,v都是字符串

redisTemplate; //操作k，v 都是对象

@Configuration

@ConditionalOnClass(RedisOperations.class)

@EnableConfigurationProperties(RedisProperties.class)

@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })

public class RedisAutoConfiguration {

	@Bean

	@ConditionalOnMissingBean(name = "redisTemplate")

	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)

			throws UnknownHostException {

		RedisTemplate<Object, Object> template = new RedisTemplate<>();

		template.setConnectionFactory(redisConnectionFactory);

		return template;

	}

	@Bean

	@ConditionalOnMissingBean

	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)

			throws UnknownHostException {

		StringRedisTemplate template = new StringRedisTemplate();

		template.setConnectionFactory(redisConnectionFactory);

		return template;

	}

}

Redis:常见的五大数据类型：String、List(列表)、Set（集合） Hash(散列) 、ZSet(有序集合) stringRedisTemplate.opsForValue() [String]

stringRedisTemplate.opsForList() [List]

stringRedisTemplate.opsForSet() [Set]

stringRedisTemplate.opsForHash() [Hash]

stringRedisTemplate.opsForZSet() [ZSet]

redis中测试保存对象（以json格式）

    @Test

    public void testRedis02(){

        Employee emp = employeeMapper.getEmpById(1);

        //默认如果保存对象，使用jdk序列化机制，序列化的数据保存在redis中

        //redisTemplate.opsForValue().set("emp-01",emp);

        /**将数据以json形式保存

         * 1、自己转为json

         * 2、redisTemplate默认的序列化规则，可以改变序列化规则，自定义配置类

         */

        EmployeeRedisTemplate.opsForValue().set("emp-01",emp);

    }

自定义redis配置类

@Configuration

public class MyRedisConfig {

    @Bean

    public RedisTemplate<Object, Employee> EmployeeRedisTemplate(RedisConnectionFactory redisConnectionFactory)

            throws UnknownHostException {

        RedisTemplate<Object, Employee> template = new RedisTemplate<>();

        template.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer<Employee> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);

        template.setDefaultSerializer(valueSerializer());

        return template;

    }

结果

1.1.5、测试redis缓存

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

这时候org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration失效，用org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration代替，原因是：

提前判断是否有CacheManager.class判断成功，有了redis的RedisCacheManager

@Configuration

@ConditionalOnClass(RedisConnectionFactory.class)

@AutoConfigureAfter(RedisAutoConfiguration.class)

@ConditionalOnBean(RedisConnectionFactory.class)

@ConditionalOnMissingBean(CacheManager.class)

@Conditional(CacheCondition.class)

class RedisCacheConfiguration {

    @Bean

	public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,

			ResourceLoader resourceLoader) {

		RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)

				.cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));

		List<String> cacheNames = this.cacheProperties.getCacheNames();

		if (!cacheNames.isEmpty()) {

			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));

		}

		return this.customizerInvoker.customize(builder.build());

	}

}

@ConditionalOnMissingBean(CacheManager.class) redis顺序在前，因此加载RedisCacheManager

1、引入redis的start,容器中保存的是RedisCacheManager

2、RedisCacheManager帮我们创建RedisCache来作为缓存组件，RedisCache通过redis缓存数据

3、默认保存数据k-v都是Object类型的，默认利用序列化

怎么以json保存?

RedisCacheConfiguration

@Bean

	public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,

			ResourceLoader resourceLoader) {

		RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)

				.cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));

		List<String> cacheNames = this.cacheProperties.getCacheNames();

		if (!cacheNames.isEmpty()) {

			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));

		}

		return this.customizerInvoker.customize(builder.bud());

	}

1、引入了redis的starter,CacheManager变为RedisCacheManager *

2、默认创建的RedisCacheManager操作redis缓存数据是通过cacheDefaults()

RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)      .cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));

3、调用 this.defaultCacheConfiguration = defaultCacheConfiguration;

public static class RedisCacheManagerBuilder {

		private RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

public RedisCacheManagerBuilder cacheDefaults(RedisCacheConfiguration defaultCacheConfiguration) {

			Assert.notNull(defaultCacheConfiguration, "DefaultCacheConfiguration must not be null!");

			this.defaultCacheConfiguration = defaultCacheConfiguration;

			return this;

		}

4、再调用defaultCacheConfig()

RedisCacheConfiguration

注意RedisCacheConfiguration是spring-data-redis下的配置包，区别redis的自动配置包

public static RedisCacheConfiguration defaultCacheConfig() {

		return defaultCacheConfig(null);

	}

可以查看defaultCacheConfig方法查看默认的序列化机制

public static RedisCacheConfiguration defaultCacheConfig(@Nullable ClassLoader classLoader) {

		DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();

		registerDefaultConverters(conversionService);

		return new RedisCacheConfiguration(Duration.ZERO, true, true, CacheKeyPrefix.simple(),

				SerializationPair.fromSerializer(RedisSerializer.string()),

				SerializationPair.fromSerializer(RedisSerializer.java(classLoader)), conversionService);

	}

SerializationPair.fromSerializer(RedisSerializer.string()),

				SerializationPair.fromSerializer(RedisSerializer.java(classLoader)), conversionService);

默认使用jdk序列化机制

static RedisSerializer<Object> java(@Nullable ClassLoader classLoader) {

		return new JdkSerializationRedisSerializer(classLoader);

	}

1.1.6自定义缓存管理器

在redis配置类中

@Configuration

public class MyRedisConfig {

    // key键序列化方式

    private RedisSerializer<String> keySerializer() {

        return new StringRedisSerializer();

    }

    // value值序列化方式

    private GenericJackson2JsonRedisSerializer valueSerializer(){

        return new GenericJackson2JsonRedisSerializer();

    }

/*

    * 配置缓存管理器

    *  @Primary 具有多个缓存管理器，必须得指定一个默认的缓存管理器,springboot1.5.9要制定

    * */

    //@Primary

    @Bean

    public RedisCacheManager myRedisCacheManager(RedisConnectionFactory redisConnectionFactory) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()

                // 设置key的序列化方式

                .entryTtl(Duration.ofSeconds(600000)) // 60s缓存失效

                // 设置key的序列化方式

                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))

                // 设置value的序列化方式

                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))

                // 不缓存null值

                .disableCachingNullValues();

        RedisCacheManager redisCacheManager= RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config)

                .transactionAware()

                .build();

        System.out.println("自定义RedisCacheManager加载完成");

        return redisCacheManager;

    }

配置完成

测试：

service

@Service

public class DeptService {

    @Autowired

    DeparmentMapper deparmentMapper;

    //@Qualifier("myRedisCacheManager")

    @Autowired

    RedisCacheManager redisCacheManager;

      //  可以从缓存中获取数据，可以对缓存进行操作

    public Department getDeptById(Integer id){

        Department department =deparmentMapper.getDeptByID(id);

        Cache dept = redisCacheManager.getCache("dept");

        dept.put("dept:dept1",department);

        return department;

    }

controller

@RestController

public class DeptController {

    @Autowired

    DeptService deptService;

    @GetMapping("/dept/{id}")

    public Department getDeptById(@PathVariable("id") Integer id){

        return deptService.getDeptById(id);

    }

}

结果：

码农公寓