如何搭建redis模块及其工具类

已于 2022-02-23 19:38:06 修改
阅读量731 收藏 1
点赞数
分类专栏： 工具类 框架/架构 文章标签： redis java
于 2022-02-23 19:31:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EDT777/article/details/122986461
版权

文章目录

骨架演示

在这里插入图片描述

依赖

  <!--json模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-json</artifactId>
        </dependency>
        <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>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>

config包

RedisCacheManagerConfig.class

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizer;
import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizers;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Configuration
@ConditionalOnMissingBean(CacheManagerCustomizers.class)
public class RedisCacheManagerConfig {

	@Bean
	public CacheManagerCustomizers cacheManagerCustomizers(
			ObjectProvider<List<CacheManagerCustomizer<?>>> customizers) {
		return new CacheManagerCustomizers(customizers.getIfAvailable());
	}

}

RedisTemplateConfig.class

@EnableCaching
@Configuration
@AllArgsConstructor
@AutoConfigureBefore(RedisAutoConfiguration.class)
public class RedisTemplateConfig {

	@Bean
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
		Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
		ObjectMapper objectMapper = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
		objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jsonRedisSerializer.setObjectMapper(objectMapper);
		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setHashKeySerializer(new StringRedisSerializer());
		redisTemplate.setValueSerializer(jsonRedisSerializer);
		redisTemplate.setHashValueSerializer(jsonRedisSerializer);
		redisTemplate.setConnectionFactory(redisConnectionFactory);


		return redisTemplate;
	}

	@Bean
	@ConditionalOnProperty(value = "spring.redis.cluster.enable", havingValue = "true")
	public LettuceConnectionFactory redisConnectionFactory(RedisProperties redisProperties) {
		RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(
				redisProperties.getCluster().getNodes());

		// https://github.com/lettuce-io/lettuce-core/wiki/Redis-Cluster#user-content-refreshing-the-cluster-topology-view
		ClusterTopologyRefreshOptions clusterTopologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
				.enablePeriodicRefresh().enableAllAdaptiveRefreshTriggers().refreshPeriod(Duration.ofSeconds(5))
				.build();

		ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
				.topologyRefreshOptions(clusterTopologyRefreshOptions).build();

		// https://github.com/lettuce-io/lettuce-core/wiki/ReadFrom-Settings
		LettuceClientConfiguration lettuceClientConfiguration = LettuceClientConfiguration.builder()
				.readFrom(ReadFrom.SLAVE_PREFERRED).clientOptions(clusterClientOptions).build();

		return new LettuceConnectionFactory(redisClusterConfiguration, lettuceClientConfiguration);
	}

}

service包

RedisService.interface

public interface RedisService {

    String getString(final String key);
    /**
     * 保存属性
     */
    void set(String key, Object value, long time);

    /**
     * 保存属性
     */
    void set(String key, Object value);

    /**
     * 获取属性
     */
    Object get(String key);

    /**
     * 删除属性
     */
    Boolean del(String key);

    /**
     * 批量删除属性
     */
    Long del(List<String> keys);

    /**
     * 设置过期时间
     */
    Boolean expire(String key, long time);

    /**
     * 获取过期时间
     */
    Long getExpire(String key);

    /**
     * 判断是否有该属性
     */
    Boolean hasKey(String key);

    /**
     * 按delta递增
     */
    Long incr(String key, long delta);

    /**
     * 按delta递减
     */
    Long decr(String key, long delta);

    /**
     * 获取Hash结构中的属性
     */
    Object hGet(String key, String hashKey);

    /**
     * 向Hash结构中放入一个属性
     */
    Boolean hSet(String key, String hashKey, Object value, long time);

    /**
     * 向Hash结构中放入一个属性
     */
    void hSet(String key, String hashKey, Object value);

    /**
     * 直接获取整个Hash结构
     */
    Map<Object, Object> hGetAll(String key);

    /**
     * 直接设置整个Hash结构
     */
    Boolean hSetAll(String key, Map<String, Object> map, long time);

    /**
     * 直接设置整个Hash结构
     */
    void hSetAll(String key, Map<String, ?> map);

    /**
     * 删除Hash结构中的属性
     */
    void hDel(String key, Object... hashKey);

    /**
     * 判断Hash结构中是否有该属性
     */
    Boolean hHasKey(String key, String hashKey);

    /**
     * Hash结构中属性递增
     */
    Long hIncr(String key, String hashKey, Long delta);

    /**
     * Hash结构中属性递减
     */
    Long hDecr(String key, String hashKey, Long delta);

    /**
     * 获取Set结构
     */
    Set<Object> sMembers(String key);

    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, Object... values);

    /**
     * 向Set结构中添加属性
     */
    Long sAdd(String key, long time, Object... values);

    /**
     * 是否为Set中的属性
     */
    Boolean sIsMember(String key, Object value);

    /**
     * 获取Set结构的长度
     */
    Long sSize(String key);

    /**
     * 删除Set结构中的属性
     */
    Long sRemove(String key, Object... values);

    /**
     * 获取List结构中的属性
     */
    List<Object> lRange(String key, long start, long end);

    /**
     * 获取List结构的长度
     */
    Long lSize(String key);

    /**
     * 根据索引获取List中的属性
     */
    Object lIndex(String key, long index);

    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value);

    /**
     * 向List结构中添加属性
     */
    Long lPush(String key, Object value, long time);

    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Object... values);

    /**
     * 向List结构中批量添加属性
     */
    Long lPushAll(String key, Long time, Object... values);

    /**
     * 从List结构中移除属性
     */
    Long lRemove(String key, long count, Object value);

    /**
     * 通过key 获取对应数据 封装到指定的类
     */
    <T> T getObject(String key, Class clazz);


}

RedisServiceImpl.class

@Component
public class RedisServiceImpl implements RedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public String getString(final String key) {
        Object obj = redisTemplate.opsForValue().get(key);
        if (obj != null) {
            String value = String.valueOf(obj);
            return value;
        }
        return null;
    }
    @Override
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public Boolean del(String key) {
        return redisTemplate.delete(key);
    }

    @Override
    public Long del(List<String> keys) {
        return redisTemplate.delete(keys);
    }

    @Override
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    @Override
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public Long incr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    @Override
    public Long decr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    @Override
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    @Override
    public Boolean hSet(String key, String hashKey, Object value, long time) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        return expire(key, time);
    }

    @Override
    public void hSet(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    @Override
    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    @Override
    public Boolean hSetAll(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        return expire(key, time);
    }

    @Override
    public void hSetAll(String key, Map<String, ?> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    @Override
    public void hDel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    @Override
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    @Override
    public Long hIncr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

    @Override
    public Long hDecr(String key, String hashKey, Long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }

    @Override
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    @Override
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    @Override
    public Long sAdd(String key, long time, Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    @Override
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    @Override
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    @Override
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    @Override
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    @Override
    public Object lIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    @Override
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    @Override
    public Long lPush(String key, Object value, long time) {
        Long index = redisTemplate.opsForList().rightPush(key, value);
        expire(key, time);
        return index;
    }

    @Override
    public Long lPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    @Override
    public Long lPushAll(String key, Long time, Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        expire(key, time);
        return count;
    }

    @Override
    public Long lRemove(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }


    @Override
    public <T> T getObject(String key, Class clazz) {
        String jsonStr = this.getString(key);
        T t = null;
        if (StringUtils.isNotBlank(jsonStr)) {
            t = (T) JSONObject.parseObject(jsonStr, clazz, new Feature[0]);

        }
        return t;
    }




}
zeki豪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisModulesSDK, 帮助你编写redis模块的工具工具和脚本 ！.zip
09-17
RedisModulesSDK, 帮助你编写redis模块的工具工具和脚本 ！ RedisModulesSDK这个小 repo 是为了帮助你更轻松地编写Redis模块。包括： 1.redismodule.h你真正需要编写Redis模块的惟一文件。 请将这里路径放入模块路径的包含中，或者复制它。注意：这是来自
chr-redis:redisTemplate工具类
03-31
本文将详细介绍`RedisTemplate`工具类及其在实际开发中的应用。 首先，`RedisTemplate`是Spring Data Redis的核心组件，它提供了模板方法来执行各种Redis命令。在Spring框架中，我们可以通过以下方式配置`...
redis配制模板_给自己看的
maqingbin8888的专栏
08-03 853
config.properties redis.server=10.17.5.24 redis.port=6379 redis.default.db=0   redis.timeout=100000   redis.maxActive=300   redis.maxIdle=100 redis.maxWait=1000 redis.testOnBorrow=true  testDate=2015-...
redis模块
weixin_33937913的博客
11-22 238
1 import redis r = redis.Redis(host='ip',port=6379) key = r.rpop(list_name) string = r.get(key).decode() #连接redis，执行redis命令 #string直接返回是个bytes值，需要经过decode才是str。 　　 r = redis.Redis(h...
Redis（十七）：Redis模块
蓬莱道人的博客
06-30 1062
1. redis模块简介 2. 添加自定义模块 3. redis中安装布隆过滤器 1. redis模块简介 Redis Modules System是4.0出现一大改动点，使得可以通过外部模块对Redis进行功能性扩展。 2. 添加自定义模块 Redis的模块采用的是动态链接库的方式，可以启动的时候加载，也可以在运行时加载（MODULE LOAD）,在Linux系统里面，可以通过dlopen，dlsym等实现动态加载库，在业务系统里面，经常用于将业务代码和框架代码进行分离，以实现...
Python - redis 模块 - 进阶之路 - Day07
lixiang5453的博客
11-13 975
redis介绍 1. Redis是一个开源（BSD许可），内存数据结构存储，用作数据库，缓存和消息代理。 2. 它支持数据结构，如 字符串，散列，列表，集合，带有范围查询的排序集，位图，超级日志和带有半径查询的地理空间索引。 3. Redis具有内置复制，Lua脚本，LRU驱逐，事务和不同级别的磁盘持久性，并通过Redis Sentinel提供高可用性和Redis Cluster自动分区。 redis定义 1. redis是一个key-value存储系统。和Memcached类似，它支持存储的va
RedisDesktopManager0.9.5
08-29
2. **键值查看与编辑**：用户可以直观地查看和编辑Redis中的键（keys）及其对应的值（values），支持多种数据类型，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）和有序集合（sorted sets）等...
springboot-redis.zip
03-26
Spring Boot是Spring框架的一个模块，旨在简化Spring应用的初始搭建以及开发过程。它提供了开箱即用的设置，包括自动配置、内嵌的Web服务器（如Tomcat或Jetty）以及对各种Spring生态系统的支持。 2. **Redis**： ...
SpringMVC+maven+redis集成示例
04-05
通过这个名为`redisTest`的压缩包文件，我们可以预期包含了一个简单的`SpringMVC`项目，其中已经集成了`redis`，可能包含配置文件、控制器类和测试代码，帮助我们理解和实践这一集成过程。 总之，`SpringMVC`、`...
springboot_springcache_redis入门实例
10-31
然后，你可以定义一个配置类，声明Redis作为缓存管理器： ```java @Configuration @EnableCaching public class CacheConfig { @Bean public RedisConnectionFactory redisConnectionFactory() { return new ...
redis定制开发
shengguolin的博客
03-14 388
redis
编写redis工具类
永恩&猫咪的博客
06-17 372
1. 新建一个redis接口 public interface ICacheUtil { void removePattern(String var1); void remove(String key); boolean exists(String key); Object get(String key); boolean set(String key, Object value); boolean set(String key, Object v
自定义redis的工具类
qq_51076413的博客
05-02 201
redis工具类、redis的使用、SpringBooot整合redis、使用redis缓存数据
Redis模块化基本介绍
diaoxie6172的博客
07-26 194
概要 Redis Modules System基本概念 基本应用 参考资料 1. Redis Modules System基本概念 Redis Modules System是4.0出现一大改动点，使得可以通过外部模块对Redis进行功能性扩展。 Redis的模块采用的是动态链接库的方式，可以启动的时候加载，也可以在运行时加载（MODULE LOAD）,在Linux系统里面，可以通过d...
史上最全Redis开发教程
qq_43233285的博客
08-15 1446
最全Redis开发教程
spring boot集成redis缓存
qq_31603875的博客
10-19 357
因为@Cacheable 是使用AOP 代理实现的 ，通过创建内部类来代理缓存方法，这样就会导致一个问题，类内部的方法调用类内部的缓存方法不会走代理（因为方法之间的调用直接使用的是原始对象this，而非代理对象，因而内部调用不会产生代理），不会走代理，就不能正常创建缓存，所以每次都需要去调用数据库。② 把方法A和方法B放到两个不同的类里面，例如：如果两个方法都在同一个service接口里，把方法B放到另一个service里面，这样在A方法里调B方法，就可以使用B方法的缓存。1、为什么缓存没有被正常创建？
Redisson (StringRedisTemplate.opsForList().leftPop(key, count) StackOverflowError
t0m的专栏
06-01 3313
redisson-spring-boot-starter(3.16.8) opsForList().leftPop(key, count) StackOverflowError
SpringBoot整合elasticsearch实操
悟空码字的博客
03-24 256
关于ES的简单介绍和基于Linux安装以及遇到的问题和解决方法，已经在Linux安装Elasticsearch这篇文章详细说过了，请参考该文章。这篇主要来说说如何在SpringBoot上整合elasticsearch，直接看下面的干货吧。 1、pom文件 引入elasticsearch依赖 <dependency> <groupId>org.springfra...
12.Redis 安装ReJSON模块
我脾气很好
03-29 2732
redis序列化工具类
最新发布
09-06
关于 Redis 的序列化工具类，我可以为您提供一些参考。 在使用 Redis 存储数据时，需要将数据序列化为字节流进行存储，以及在读取数据时将字节流反序列化为原始对象。下面是一个简单的 Redis 序列化工具类的示例： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值