SpringBoot中集成Redis

已于 2023-06-19 16:56:39 修改
阅读量3.8k 收藏 3
点赞数
文章标签： redis spring boot java
于 2023-06-19 11:10:03 首次发布
阿弥陀佛 欢迎流通 功德无量
本文链接：https://blog.csdn.net/fxtxz2/article/details/131282235
版权

目标

在原有SpringBoot项目中，集成Redis，并实现Dao层，Service层，Controller层。

pom.xml

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

使用Spring Boot的Redis依赖。

application-dev.yaml

spring:
  redis:
    host: ${REDIS_HOST:localhost}
    port: ${REDIS_PORT:6379}
    database: 0
    password: ${REDIS_PASSWORD}

RedisConfig.java



import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
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.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author zyl
 */
@Configuration
public class RedisConfig {

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

这里配置使用redis的链接池，以及key，hash key和数据存储使用的序列化方式。

Domain层

City.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author zyl
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
public class City implements Serializable {
    private Long id;

    private String name;

    private String state;

    private String country;
}

注意：这里要实现Serializable接口，只有这样，我们这里使用的Redis依赖库才能够正常使用。

Dao层

CityDao.java

/**
 * @author zyl
 */
public interface CityDao {
    void save(City city);
    City findById(Long id);

    void delete(Long id);
}

上面是Dao的定义层，下面来看看Dao的实现层：

CityDaoImpl.java

import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * @author zyl
 */
@Repository
public class CityDaoImpl implements CityDao {
    private static final String HASH_REFERENCE = "City";

    @Resource
    private RedisTemplate<String, City> redisTemplate;

    @Override
    public void save(City city) {
        Long id = city.getId();
        String key = HASH_REFERENCE + "_" + id;
        BoundHashOperations<String, Long, City> boundHashOperations = redisTemplate.boundHashOps(key);
        boundHashOperations.putIfAbsent(id, city);
        boundHashOperations.expire(60, TimeUnit.SECONDS);
    }

    @Override
    public City findById(Long id) {
        String key = HASH_REFERENCE + "_" +id;
        BoundHashOperations<String, Long, City> boundHashOperations = redisTemplate.boundHashOps(key);
        return boundHashOperations.get(id);
    }

    @Override
    public void delete(Long id) {
        String key = HASH_REFERENCE + "_" +id;
        BoundHashOperations<String, Long, City> boundHashOperations = redisTemplate.boundHashOps(key);
        boundHashOperations.delete(id);
    }
}

注意这里重点是通过BoundHashOperations类来实现Redis相关对象的操作。BoundHashOperations类是操作Redis的重点类。如果使用通过HashOperations类让redis里面的数据过期处理，有点麻烦，故这里使用BoundHashOperations类处理。

VO层

ApiRes.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.http.HttpStatus;

/**
 * 通用响应类
 * @author zyl
 */
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class ApiRes<T> {
    private int status = HttpStatus.OK.value();
    private String message;
    private T data;

    public static final String SUCCESS_MSG = "操作成功";
    public static final String ERROR_MSG = "操作成功";

    /**
     * 返回成功数据
     * @author zyl
     * @return 成功消息
     */
    public static <T> ApiRes<T> success(T data)
    {
        return ApiRes.success(SUCCESS_MSG, data);
    }

    /**
     * 返回成功消息
     * @author zyl
     * @param msg 返回内容
     * @return 成功消息
     */
    public static <T> ApiRes<T> success(String msg)
    {
        return ApiRes.success(msg, null);
    }

    /**
     * 返回成功消息
     * @author zyl
     * @param msg 返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static <T> ApiRes<T> success(String msg, T data)
    {
        return new ApiRes<>(HttpStatus.OK.value(), msg, data);
    }

    /**
     * 返回错误消息
     * @author zyl
     */
    public static <T> ApiRes<T> error()
    {
        return ApiRes.error(ERROR_MSG);
    }

    /**
     * 返回错误消息
     * @author zyl
     * @param msg 返回内容
     * @return 警告消息
     */
    public static <T> ApiRes<T> error(String msg)
    {
        return ApiRes.error(msg, null);
    }

    /**
     * 返回错误消息
     * @author zyl
     * @param msg 返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static <T> ApiRes<T> error(String msg, T data)
    {
        return new ApiRes<>(HttpStatus.INTERNAL_SERVER_ERROR.value(), msg, data);
    }

    /**
     * 返回错误消息
     * @author zyl
     * @param msg 返回内容
     * @param code 响应编码
     * @return 警告消息
     */
    public static <T> ApiRes<T> error(int code, String msg)
    {
        return new ApiRes<>(code, msg, null);
    }
}

这里定义实现了统一响应VO，下面继续实现定义City的响应VO：

CityRes.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zyl
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
public class CityRes {
    private Long id;

    private String name;

    private String state;

    private String country;
}

City响应VO定义实现。

Service层

CityService.java

/**
 * 测试city模板
 * @author zyl
 */
public interface CityService {

    ApiRes<CityRes> findByState(String state);

    ApiRes<CityRes> findById(Long id);

    void delete(Long id);
}

CityServiceImpl.java

import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author zyl
 */
@Service
public class CityServiceImpl implements CityService {

    @Resource
    private CityMapper cityMapper;

    @Resource
    private CityDao cityDao;
    @Override
    public ApiRes<CityRes> findByState(String state) {
        City city = cityMapper.findByState(state);
        if (city == null) {
            throw new HandleException("没有找到城市数据");
        }
        CityRes cityRes = CityRes.builder().build();
        BeanUtils.copyProperties(city, cityRes);
        return ApiRes.success(cityRes);
    }

    @Override
    public ApiRes<CityRes> findById(Long id) {
        // 先查缓存
        City city = cityDao.findById(id);
        if (city == null) {
            // 查数据库
            city = cityMapper.findById(id);
            if (city != null) {
                // 更新缓存
                cityDao.save(city);
            }
        }

        if (city == null) {
            throw new HandleException("没有找到城市数据");
        }
        CityRes cityRes = CityRes.builder().build();
        BeanUtils.copyProperties(city, cityRes);
        return ApiRes.success(cityRes);
    }

    @Override
    public void delete(Long id) {
        cityMapper.delete(id);
        cityDao.delete(id);
    }
}

这里的HandleException类，是自定义异常处理类，这里就不再给出详细实现了。CityMapper类是mybatis的相关定义实现，这不是这里需要关注的，故也不再给出详细实现了。

Controller层

HelloController.java

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;

/**
 * 测试模板
 * @author zyl
 */
@RefreshScope
@RestController
@RequestMapping("/hello")
public class HelloController {

    @Resource
    private CityService cityService;

    @GetMapping("/city/findById")
    public ResponseEntity<ApiRes<CityRes>> cityFindById(@RequestParam Long id) {
        return ResponseEntity.ok(cityService.findById(id));
    }

    @GetMapping("/city/delete")
    public ResponseEntity<ApiRes<String>> cityDelete(@RequestParam Long id) {
        cityService.delete(id);
        ApiRes<String> apiRes = ApiRes.success("删除成功");
        return ResponseEntity.ok(apiRes);
    }
}

SQL

drop table if exists city;
create table city (id int primary key auto_increment, name varchar(200), state varchar(200), country varchar(200));
insert into city (name, state, country) values ('San Francisco', 'CA', 'US');
insert into city (name, state, country) values ('San Francisco2', 'CA2', 'US2');

测试

这里只看看Redis里面存的数据效果图：

redis存数据效果
看看postman中的响应：
获取数据postman

总结

这里主要使用BoundHashOperations类来处理redis中的对象。为什么不使用HashOperations类？因为不能直接使用HashOperations类对对象进行过期时间设置，而BoundHashOperations类可以这弄。这里值得注意的是，我们只能对Redis里面的整个散列进行过期，不能对散列里面的具体key过期。这一点Redis规范要注意一下。具体如下图：
redis hashs
我们能对1过期，但是不能对2进行过期处理。HashOperations类就是把多个对象存在一个1里面，我们这里为了实现单个对象过期处理，就只能使用BoundHashOperations类，在一个1里面存一个对象，这样实现对一个对象的redis过期。
总的来说，BoundHashOperations类可以自己过期Redis数据，HashOperations类没有直接过期数据方法。

参考：

亚林瓜子
关注
SpringBoot中集成Redis实现对redis中数据的解析和存储
BADAO_LIUMANG_QIZHI的博客
03-30 1009
上面讲的操作redis的工具类，但是对于redis的集成并没做细讲。下面参考若依框架的实现，从中抽离出集成redis的部分实现。
Spring Boot 集成 Redis
yd1628570241的博客
04-21 207
1. Spring Boot 集成 Redis 1.1 依赖导入 Spring Boot 集成 redis 很方便，只需要导入一个 redis 的 starter 依赖即可。如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
SpringBoot 集成 Redis
最新发布
2301_79438104的博客
10-08 1587
一：SpringBoot 集成 Redis①Redis是一个 NoSQL（not only）数据库， 常作用缓存 Cache 使用。②Redis是一个中间件、是一个独立的服务器；常用的数据类型： string , hash ,set ,zset , list③通过Redis客户端可以使用多种语言在程序中，访问 Redis 数据；java 语言中使用的客户端库有 Jedis，lettuce, Redisson 等。
SpringBoot集成Redis
gghfzs1的博客
09-27 1479
作为数据库,Redis是一个非常快的非关系数据库(),它可以存储键(key)与五种不同类型的值之间的映射,可以将存储在内的键值对数据持久化到硬盘,可以使用复制特性来扩展读性能,还可以使用客户端分片来扩展写性能。1.1数据类型Redis数据类型不仅与关系数据库管理系统(RDBMS)不同,也不同于任何简单的NoSQL键值数据存储。String（字符串）Hash（哈希）List（列表）Set（集合）Zset（Sorted Set：有序集合）
SpringBoot教程（十四） | SpringBoot之集成Redis
qq_20236937的博客
04-09 8626
Redis是我们Java开发中，使用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用使用场景，可以做缓存，分布式锁，自增序列等，使用redis的方式和我们使用数据库的方式差不多，首先我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在程序中进行集成，然后通过客户端完成对redis的增删改查操作。
springboot集成Redis
魏波
08-01 459
springboot集成Redis
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
springboot中集成redis的方案
02-09
文档中一步步的详细描述了如何集成springboot的方案，通过文档可以顺利集成这个redis方案
Spring 集成 Redis
必行
12-20 1809
1、利用spring-data-redis整合 org.springframework.data spring-data-redis 1.0.2.RELEASE org.springframework spring-core 3.1.2
springboot使用redis
热门推荐
qq_49044908的博客
12-12 4万+
springboot使用redis redis-service.exe : 服务端,启动后不要关闭 redis-cli.exe : 客户端,访问redis中的数据 redisclient-win32.x86_64.2.0.jar : redis的图形界面客户端,执行方式是在这个文件的目录执行 java -jar redisclient-win32.x86_64.2.0.jar 或者在这个jar包的目录下点击即可直接执行 点击server,点击add,设置端口号就可以访问redis了 springboot
SpringBoot应用中集成Redis实战教程
以上就是SpringBoot集成Redis的基本步骤。你可以根据实际需求扩展配置，比如添加密码认证、设置超时时间、连接池配置等。此外，Spring Data Redis还提供了更高级的抽象，如`StringRedisTemplate`和`RedisTemplate`，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值