Springboot整合Redis入門完整篇，零基礎入門教學教程

記錄一次簡易集成Redis緩存 自定義Redisconfig配置 自定義序列化操作 加深印像

 

整合前提工具環境准備:

 

1、redis官網 https://redis.io/download

下載安裝redis 

 

 

 

 

 

 

 運行成功

 

注意事項:

1，開啟遠程服務 放行防火牆 6379 端口 具體操作百度

2，配置

 

 

 

 

本地連接ip 就是127.0.0.1

如果在服務器端 要注釋這行

3.配置 密碼

還是在這這個文件redis.windows.conf 里面查找

requirepass

 

 

 

 4.

再把protected-mode=yes的yes改為no,

 

 

下載Redis視圖軟件 http://www.pc6.com/softview/SoftView_450180.html#download

 

 

 

 

 

 

springboot整合redis開始

 

第一步配置導包

 

<dependency>

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

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

</dependency> 

 

第二步 
實體類的配置
Redis讀取數據都需要經過反序列化 不然讀取失敗 出錯

要使用redis，實體類必須實現序列化接口
implements Serializable
否則會拋java.io.NotSerializableException異常。

反序列化讀取Json數據
@JsonIgnoreProperties(ignoreUnknown = true)

配置反序列化類

FastJson2JsonRedisSerializer

代碼如下

package com.ruoyi.project.system.role.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.apache.shiro.util.Assert;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;

public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {

    private ObjectMapper objectMapper = new ObjectMapper();
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        ParserConfig.getGlobalInstance().addAccept("com.openailab.oascloud");

    }

    public FastJson2JsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz);
    }

    public void setObjectMapper(ObjectMapper objectMapper) {
        Assert.notNull(objectMapper, "'objectMapper' must not be null");
        this.objectMapper = objectMapper;
    }

    protected JavaType getJavaType(Class<?> clazz) {
        return TypeFactory.defaultInstance().constructType(clazz);
    }


}

 

配置application.yml

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: root #如果沒設置密碼留空
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 500
        min-idle: 0
    lettuce:
      shutdown-timeout: 0

 

 

配置RedisConfig

* 1) RedisTemplate（或StringRedisTemplate）雖然已經自動配置，但是不靈活（第一沒有序列化，第二泛型為<Object, Object>不是我們想要的類型）
* 所以自己實現RedisTemplate或StringRedisTemplate）
* 2) 采用RedisCacheManager作為緩存管理器

package com.ruoyi.project.system.role.controller;


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

import java.lang.reflect.Method;
import java.time.Duration;



@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    private RedisSerializer<String> keySerializer() {

        return new StringRedisSerializer();

    }

    //使用Jackson序列化器

    private RedisSerializer<Object> valueSerializer() {

        return new GenericJackson2JsonRedisSerializer();

    }

    @Bean

    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {

        //緩存配置對象

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(30L)) //設置緩存的默認超時時間：30分鍾

                .disableCachingNullValues()             //如果是空值，不緩存

                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))         //設置key序列化器

                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer((valueSerializer())));  //設置value序列化器

        return RedisCacheManager

                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))

                .cacheDefaults(redisCacheConfiguration).build();

    }

    @Override

    @Bean

    public KeyGenerator keyGenerator() {

        // TODO Auto-generated method stub

        return new KeyGenerator() {

            @Override

            public Object generate(Object object, Method method, Object... objects) {

                // TODO Auto-generated method stub

                StringBuilder sb = new StringBuilder();

                sb.append(object.getClass().getName());

                sb.append(method.getName());

                for (Object obj : objects) {

                    if (obj != null) {

                        sb.append(obj.toString());

                    }

                }

                return sb.toString();

            }

        };

    }





    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        FastJson2JsonRedisSerializer fastJson2JsonRedisSerializer = new FastJson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        fastJson2JsonRedisSerializer.setObjectMapper(objectMapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // string的value采用fastJson序列化方式
        redisTemplate.setValueSerializer(fastJson2JsonRedisSerializer);
        // hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // hash的value采用fastJson序列化方式
        redisTemplate.setHashValueSerializer(fastJson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }





}

 

 在啟動類上面加上redis緩存注解

 

 

在conroller使用redis

@Cacheable只是一種注解使用方法 更多的使用方法自行研究擴展

@Cacheable(cacheNames = "product", key = "123")

 

訪問controler

 

 第二次訪問就會讀取redis 記錄一次簡易集成

如何使用注解啦,這一步反而是最簡單的.其實只用到了兩個注解,@Cacheable和@CacheEvict.第一個注解代表從緩存中查詢指定的key,如果有,從緩存中取,不再執行方法.如果沒有則執
行方法,並且將方法的返回值和指定的key關聯起來,放入到緩存中.而@CacheEvict則是從緩存中清除指定的key對應的數據.使用的代碼如下:

@Cacheable(value="thisredis", key="'users_'+#id") public User findUser(Integer id) { User user = new User(); user.setUsername("hlhdidi"); user.setPassword("123"); user.setUid(id.longValue()); System.out.println("log4j2壞啦?"); logger.info("輸入user,用戶名:{},密碼:{}",user.getUsername(),user.getPassword()); return user; } @CacheEvict(value="thisredis", key="'users_'+#id",condition="#id!=1") public void delUser(Integer id) { // 刪除user System.out.println("user刪除"); }
可以看出,我們用@Cacheable的value屬性指定具體緩存,並通過key將其放入緩存中.這里key非常靈活,支持spring的el表達式,可以通過方法參數產生可變的key(見findUser方法),也可以通過其指定在
什么情況下,使用/不使用緩存(見delUser方法).

 

 

更多的操作和優化 可自行研究