栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

springboot引入redis的使用

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

springboot引入redis的使用

首先,pom文件新增依赖


  
       org.springframework.boot
       spring-boot-starter-data-redis
  

  
       org.projectlombok
       lombok
       1.18.20
  

yml文件新增配置

redis:
  database: 0
  host: 127.0.0.1
  password:
  port: 6379
  timeout: 5000
  ssl: false

新增启动文件

@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        // 只需要run一下,就能发布一个springboot应用
        // 相当于之前将web工程发布到tomcat服务器,只是在springboot中集成了tomcat插件
        SpringApplication.run(RedisApplication.class, args);
    }
}

目录结构如图:

新增工具类文件:

@Service
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    
    public Boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    
    public Boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(keys);
        }
    }

    
    public void removePattern(final String pattern) {
        Set keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    
    public Object get(final String key) {
        Object result = null;
        ValueOperations operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    
    public Object hmGet(String key, Object hashKey) {
        HashOperations hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    
    public void lPush(String k, Object v) {
        ListOperations list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    
    public List lRange(String k, long l, long l1) {
        ListOperations list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    
    public void add(String key, Object value) {
        SetOperations set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    
    public Set setMembers(String key) {
        SetOperations set = redisTemplate.opsForSet();
        return set.members(key);
    }

    
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    
    public Set rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    } 

 controller:

@RestController
@RequestMapping("/redis")
@Slf4j
public class TestController {
    @Autowired
    private RedisUtil redisUtil;

    @GetMapping("/set")
    public Boolean setKey(@RequestParam("key") String key, @RequestParam("value") Object value) {
        try {
            redisUtil.set(key, value);
        } catch (Exception e) {
            log.error("redis加入失败:{}", e.getStackTrace());
            return false;
        }
        return true;
    }

    @GetMapping("/get")
    public Object getKey(@RequestParam("key") String key) {
        try {
            return redisUtil.get(key);
        } catch (Exception e) {
            log.error("redis获取失败:{}", e.getStackTrace());
            return false;
        }
    }

}

能成功插入本地redis数据

 启动项目前,先启动本地redis.

这种方式容易有乱码,如上图

对于redis操作,springboot进行了很好的封装,那就是spring data redis。提供了一个高度封装的RedisTemplate类来进行一系列redis操作,连接池自动管理;同时将事务封装操作,交由容器进行处理.。

从图上能看出,出现乱码,因为,引用默认的RedisTemplate,它的默认序列化方式是JDK,而这种方式可读性差。

为了解决以上问题,需进行更改默认序列化:

有两种方式,一种是自定义RedisTemplate类,另一种使用 String RedisTemplate 进行序列化

先讲第二种: String RedisTemplate是spring自带的,直接引用

@Autowired
    private StringRedisTemplate stringRedisTemplate;

spring只限于字符串结构,不建议使用。

再讲自定义redisTemplate类,可以更换序列化方式:

①JdkSerializationRedisSerializer。默认方式,无需变更

直接引入即可

@Autowired
    private RedisTemplate redisTemplate;

自定义是更改为非JDK序列化,这里有以下几种选择:

①Jackson

②faskjson

③genericFastJson

其实还有一种是StringRedisSerializer,但是,我们直接引入StringRedisTemplate就解决了,无需自定义,所以这种方式多此一举,可以不讨论,但是key的赋值方式是用了string方式。

目录结构如图:

工具类依旧不动,自动注入redisTemplate

RedisConfig新增文件,代码如下:

这一步会在启动时,重写redisTemplate,所以叫自定义

package com.hyj.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
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
@Slf4j
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        //为了开发方便,一般使用
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(factory);

//        //Json方式的序列化
//        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//        ObjectMapper objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

//        //faskjskn方式序列化
//        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);

        //String方式的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        GenericFastJsonRedisSerializer jackson2JsonRedisSerializer = new GenericFastJsonRedisSerializer();


        //------设置各模板的序列化方式------
        //设置key的序列化方式为string(不设置的话会乱码)
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        //设置value的序列化方式为json
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }
}

每一种方式的变更如图:

FastJson2JsonRedisSerializer需要新增文件,内容如下:
package com.hyj.config;

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.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;

import java.nio.charset.Charset;

public class FastJson2JsonRedisSerializer implements RedisSerializer {

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

    private Class clazz;

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

    }

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

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

    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);
    }
}

 至此,四种方式的序列化讲解完毕。

实际运行,

①Jackson序列化,list类型的数据如图:

读取:Jackson2JsonRedisSerializer报错

②FastJson2JsonRedisSerializer

 读取:

 ③GenericFastJson

下面开始数据读取:

GenericFastJson:

综上所述:推荐FastJson和genericFastJson吧,Jackson肯定是不咋推荐的,反序列化报错

 

 

原文出处:Redis之RedisTemplate配置方式(序列和反序列化)_Redis_服务器之家

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号