redis个人基础教程（四）springboot redis 存储对象篇

最新推荐文章于 2025-03-26 23:55:58 发布

skindow

最新推荐文章于 2025-03-26 23:55:58 发布

阅读量639

点赞数

分类专栏： redis

本文链接：https://blog.youkuaiyun.com/qq_42255763/article/details/99817183

版权

redis 专栏收录该内容

5 篇文章

订阅专栏

参考文章：https://blog.youkuaiyun.com/m0_38075425/article/details/81181726

接着上篇讲redis个人基础教程（三）springboot redis demo篇我们知道，java需要把一个对象持久化在磁盘中，需要将该对象进行序列化后再保存在磁盘当中，所以这个要被保存的对象需要实现serializable接口，我们先创建一个这样的类，比如Book类
注意：我这里使用了lombok

package com.skindow.pojo;

import lombok.Data;

import java.io.Serializable;

/**
 * Created by Administrator on 2019/8/20.
 */
@Data
public class Book implements Serializable {
    private static final long serialVersionUID = -1324354924637626383L;
    /**
     * 书名
     */
    private String name;
    /**
     * 类别
     */
    private String type;
    /**
     * 价格
     */
    private String price;
}

被持久化的对象实现了序列化，但是我们需要将其持久化redis当中，所以这里需要提供一个redis序列化类，来对该类进行持久化，且我们再将其从redis中拿出来的时候还需要将其转化成对象，所以这个redis序列化类还需要提供反序列，这里我们使用spring的SerializingConverter和DeserializingConverter类来实现java对象的序列化和反序列化，这两个类实现了Converter接口。使用这个类相比getBytes()方法的好处是可以将大的对象也可以序列化，性能相比getBytes()做了优化。

package com.skindow.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.serializer.support.DeserializingConverter;
import org.springframework.core.serializer.support.SerializingConverter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.lang.Nullable;

/**
 * Created by Administrator on 2019/8/20.
 */
@Slf4j
public class RedisSerialUtil implements RedisSerializer<Object> {
    /**
     * 定义序列化和反序列化转化类
     */
    private Converter<Object, byte[]> serializer = new SerializingConverter();
    private Converter<byte[], Object> deserializer = new DeserializingConverter();
    /**
     * 定义转换空字节数组
     */
    private static final byte[] EMPTY_ARRAY = new byte[0];

    @Nullable
    @Override
    public byte[] serialize(@Nullable Object o) throws SerializationException {
        byte[] byteArray = null;
        if (null == o) {
            log.info("----------------------------->:Redis待序列化的对象为空.");
            byteArray = EMPTY_ARRAY;
        } else {
            try {
                byteArray = serializer.convert(o);
            } catch (Exception e) {
                log.error("----------------------------->Redis序列化对象失败,异常：",e);
                byteArray = EMPTY_ARRAY;
            }
        }
        return byteArray;
    }

    @Nullable
    @Override
    public Object deserialize(@Nullable byte[] bytes) throws SerializationException {
        Object obj = null;
        if((null == bytes)|| (bytes.length == 0)){
            log.info("---------------------------------->Redis待反序列化的对象为空.");
        }else{
            try {
                obj = deserializer.convert(bytes);
            } catch (Exception e) {
                log.error("------------------------------------->Redis反序列化对象失败,异常：",e);
            }
        }
        return obj;
    }
}

给redisTemplate配置序列化和反序列化

package com.skindow.config;

import com.skindow.util.RedisSerialUtil;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;
import java.time.Duration;

/**redis配置类
 * Created by Administrator on 2019/8/19.
 */
public class RedisConfig {
    
    /**创建redis连接工厂
     * @param defaultRedisConfig
     * @param defaultPoolConfig
     * @return
     */
    @Bean
    @ConditionalOnBean(name = "defaultRedisConfig")
    public LettuceConnectionFactory defaultLettuceConnectionFactory(RedisStandaloneConfiguration defaultRedisConfig,
                                                                    GenericObjectPoolConfig defaultPoolConfig) {
        LettuceClientConfiguration clientConfig =
                LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(100))
                        .poolConfig(defaultPoolConfig).build();
        return new LettuceConnectionFactory(defaultRedisConfig, clientConfig);
    }

    /** 给redisTemplate配置连接工厂
     * @param defaultLettuceConnectionFactory
     * @return
     */
    @Bean
    @ConditionalOnBean(name = "defaultLettuceConnectionFactory")
    public RedisTemplate<String, String> defaultRedisTemplate(
            LettuceConnectionFactory defaultLettuceConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(defaultLettuceConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Configuration
    @ConditionalOnProperty(name = "host", prefix = "spring.redis")
    public static class DefaultRedisConfig {
        @Value("${spring.redis.host}")
        private String host;
        @Value("${spring.redis.port}")
        private Integer port;
        @Value("${spring.redis.password}")
        private String password;
        @Value("${spring.redis.database}")
        private Integer database;

        @Value("${spring.redis.lettuce.pool.max-active}")
        private Integer maxActive;
        @Value("${spring.redis.lettuce.pool.max-idle}")
        private Integer maxIdle;
        @Value("${spring.redis.lettuce.pool.max-wait}")
        private Long maxWait;
        @Value("${spring.redis.lettuce.pool.min-idle}")
        private Integer minIdle;

        /** 配置读取到的连接池配置信息
         * @return
         */
        @Bean
        public GenericObjectPoolConfig defaultPoolConfig() {
            GenericObjectPoolConfig config = new GenericObjectPoolConfig();
            config.setMaxTotal(maxActive);
            config.setMaxIdle(maxIdle);
            config.setMinIdle(minIdle);
            config.setMaxWaitMillis(maxWait);
            return config;
        }
        
        /** 配置读取到的redis连接配置信息
         * @return
         */
        @Bean
        public RedisStandaloneConfiguration defaultRedisConfig() {
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
            config.setHostName(host);
            config.setPassword(RedisPassword.of(password));
            config.setPort(port);
            config.setDatabase(database);
            return config;
        }

        @Bean
        public RedisTemplate<Serializable, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
            RedisTemplate<Serializable, Object> template = new RedisTemplate<Serializable, Object>();
            template.setConnectionFactory(connectionFactory);
            template.afterPropertiesSet();
            // redis存取对象的关键配置
            template.setKeySerializer(new StringRedisSerializer());
            // ObjectRedisSerializer类为java对象的序列化和反序列化工具类
            template.setValueSerializer(new RedisSerialUtil());
            return template;
        }
    }
}

测试

提供者

package com.skindow.serviceImpl;

import com.alibaba.dubbo.common.utils.StringUtils;
import com.alibaba.dubbo.config.annotation.Service;
import com.skindow.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import java.awt.print.Book;
import java.io.Serializable;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * Created by Administrator on 2019/8/7.
 */
@Service
public class DemoServiceImpl implements DemoService {
    @Autowired
    private RedisTemplate<Serializable, Object>defaultRedisTemplate;
    @Override
    public String setBook(String key,Book book) {
        if (book == null)
        {
            return "book is null!";
        }
        defaultRedisTemplate.opsForValue().set(key,book);
        return "success";
    }
        @Override
    public String getValueByKey(String key) {
        if (StringUtils.isEmpty(key))
        {
            return "key is empty!";
        }
        return defaultRedisTemplate.opsForValue().get(key).toString();
    }
}

package com.skindow.service;

import java.awt.print.Book;

/**
 * Created by Administrator on 2019/8/7.
 */
public interface DemoService {
        String getValueByKey(String key);
        String setBook(String key,Book book);
}

package com.skindow.controller;

import com.skindow.service.DemoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;

import java.awt.print.Book;

/**
 * Created by Administrator on 2019/8/7.
 */
@Controller
@Slf4j
@RequestMapping("/api/demo")
@Api("skindow-test")
public class DemoController {
    @Autowired
    private DemoService demoService;

    @RequestMapping("/test")
    @ResponseBody
    @ApiIgnore//使用该注解忽略这个API
    public String test()
    {
        return demoService.sayHello("skindow");
    }

    @RequestMapping("/testAop")
    @ResponseBody
    @ApiOperation(httpMethod = "GET", value = "测试AOP", consumes = "application/json")
    public String testAop(@RequestParam(value="name") String name,@RequestParam(value="age") Integer age)
    {
        return demoService.sayHello(name,age);
    }

    @RequestMapping("/setRedis")
    @ResponseBody
    @ApiOperation(httpMethod = "GET", value = "给redis新建key-value", consumes = "application/json")
    public String setRedis(@RequestParam(value="value") String value,@RequestParam(value="key") String key)
    {
        return demoService.testRedis(key,value);
    }

    @RequestMapping("/getRedis")
    @ResponseBody
    @ApiOperation(httpMethod = "GET", value = "在redis通过key获取value", consumes = "application/json")
    public String getRedis(@RequestParam(value="key") String key)
    {
        return demoService.getValueByKey(key);
    }

    @RequestMapping(value="/setBook",method= RequestMethod.POST)
    @ResponseBody
    @ApiOperation(httpMethod = "POST", value = "在redis中持久化对象Book", consumes = "application/json")
    public String Set(@RequestParam(value="key") String key,@RequestBody Book book)
    {
        return  demoService.setBook(key,book);
    }
}

这里我们使用swagger2测试
http://127.0.0.1:8092/swagger-ui.html#/demo-controller/SetUsingPOST
在这里插入图片描述
ok，成功。我们用Redis Desktop Manager 工具进行查看

我们再用getRedis方法进行测试
加粗样式
通过上图我们可以看到里面的相关属性，ok，教程教程就到这了=-=