springboot集成redisserver

最新推荐文章于 2023-07-02 16:01:43 发布
最新推荐文章于 2023-07-02 16:01:43 发布
阅读量1.1k 收藏
点赞数
分类专栏： java 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29408999/article/details/106182783
版权

springboot集成redisserver;

package cn.cai.microservice.redisconfig;

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.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

/**
*

*/
@Configuration
@EnableCaching
@SuppressWarnings({ “rawtypes”, “unchecked” })
public class RedisConfig extends CachingConfigurerSupport { 

/**
 * 生成key的策略
 * @return
 */
@Override
@Bean
public KeyGenerator keyGenerator() {
    return (target, method, params) -> {
        StringBuilder sb = new StringBuilder();
        sb.append(target.getClass().getName());
        sb.append(method.getName());
        for (Object obj : params) {
            sb.append(obj.toString());
        }
        return sb.toString();
    };
}

/**
 * 管理缓存
 */
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
    return rcm;
}

/**
 * RedisTemplate配置
 */
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
	Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
}

}

===================================================
package cn.cai.microservice.redisconfig;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

  • @author: daizhiqing

  • @Description: Redis缓存服务

  • @date: 2017/12/31
    */
    @Service
    @SuppressWarnings({“unchecked”,“rawtypes”})
    public class RedisServer {

    @Autowired
    private RedisTemplate redisTemplate;

    /**

    • 写入缓存
    • @param key
    •        缓存key
    • @param value
    •        缓存value
    • @return
      */
      public boolean set(final String key, Object value) {
      boolean result = false;
      try {
      ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
      operations.set(key, value);
      result = true;
      } catch (Exception e) {
      //LogTrace.error(e.getMessage(), e);
      }
      return result;
      }

    /**

    • 写入缓存设置失效时间
    • @param key
    •        缓存key
    • @param value
    •        缓存value
    • @param expireTime
    •        缓存失效时间
    • @return
      */
      public boolean set(final String key, Object value, Long expireTime) {
      boolean result = false;
      try {
      ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
      operations.set(key, value);
      redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
      result = true;
      } catch (Exception e) {
      LogTrace.error(e.getMessage(), e);
      }
      return result;
      }

    /**

    • 设置已有缓存的缓存时间
    • @param key
    •        缓存key
    • @param expireTime
    •        缓存失效时间
    • @return
      */
      public boolean expire(final String key, Long expireTime) {
      return redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
      }

    /**

    • 批量删除缓存-keys
    • @param keys
    •        缓存key的List集合

    */
    public void remove(final String… keys) {
    for (String key : keys) {
    remove(key);
    }
    }

    /**

    • 批量删除缓存-给定模式
    • @param pattern
    •        给定模式 pattern

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

    /**

    • 删除缓存
    • @param key
    •        缓存key

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

    /**

    • 判断一个缓存是否存在
    • @param key
    •        缓存key
    • @return
      */
      public boolean exists(final String key) {
      return redisTemplate.hasKey(key);
      }

    /**

    • 读取缓存
    • @param key
    •        缓存key
    • @return
      */
      public String get(final String key) {
      if (StringUtils.isEmpty(key)) {
      return null;
      }
      Object result = null;
      if (exists(key)) {
      ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
      result = operations.get(key);
      }
      return null == result ? null : result.toString();
      }

    /**

    • 哈希添加缓存
    • @param key
    •        缓存key
    • @param hashKey
    •        Hash-key
    • @param value
    •        缓存value

    */
    public void hashSet(String key, String hashKey, String value) {
    HashOperations<String, String, String> hash = redisTemplate.opsForHash();
    hash.put(key, hashKey, value);
    }

    /**

    • 哈希获取缓存
    • @param key
    •        缓存key
    • @param hashKey
    •        Hash-key
    • @return
      */
      public String hashGet(String key, String hashKey) {
      HashOperations<String, String, String> hash = redisTemplate.opsForHash();
      return hash.get(key, hashKey);
      }

    /**

    • 删除一个hash 中的 key
    • @param key
    • @param hashKey
    • @return
      */
      public Long hashDel(String key, Object hashKey) {
      HashOperations<String, String, String> hash = redisTemplate.opsForHash();
      return hash.delete(key, hashKey);
      }

    /**

    • 获取对应一个hash map
    • @param key
    • @return
      */
      public Map<String, String> hashEntries(String key) {
      HashOperations<String, String, String> hash = redisTemplate.opsForHash();
      return hash.entries(key);
      }

    /**

    • 无序set集合添加缓存
    • @param key
    •        缓存key
    • @param value
    •        缓存value

    */
    public void sadd(String key, Object value) {
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    set.add(key, value);
    }

    /**

    • 无序set集合获取缓存
    • @param key
    •        缓存key
    • @return
      */
      public Set smembers(String key) {
      SetOperations<String, Object> set = redisTemplate.opsForSet();
      return set.members(key);
      }

    /**

    • 有序集合添加缓存
    • @param key
    •        缓存key
    • @param value
    •        缓存value
    • @param scoure
      */
      public void zAdd(String key, Object value, double scoure) {
      ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
      zset.add(key, value, scoure);
      }

    /**

    • 有序集合获取缓存
    • @param key
    •        缓存key
    • @param scoure
    •        score最小值，闭区间
    • @param scoure1
    •        score最大值，闭区间
    • @return
      */
      public Set rangeByScore(String key, double scoure, double scoure1) {
      ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
      return zset.rangeByScore(key, scoure, scoure1);
      }

    /**

    • 获取一个缓存剩余有效时间
    • 1、不存在的 key // 指令：TTL key 返回(integer) -2
    • 2、存在，但没有设置剩余生存时间 // 指令 TTL key 返回 (integer) -1
    • 3、有剩余生存时间的 key // 指令 TTL key 返回秒(integer)
    • @param key
    •        缓存key
    • @return
      */
      public Long getExpire(String key) {
      return redisTemplate.getExpire(key);
      }

    /**

    • 获取一个缓存剩余有效时间
    • 1、不存在的 key // 指令：TTL key 返回(integer) -2
    • 2、存在，但没有设置剩余生存时间 // 指令 TTL key 返回 (integer) -1
    • 3、有剩余生存时间的 key // 指令 TTL key 返回秒(integer)
    • @param key
    •        缓存key
    • @return
      */
      public Long getExpireByTime(String key) {
      return redisTemplate.getExpire(key,TimeUnit.SECONDS);
      }

    /************************************************

    • 有序list 集合操作
      ********************************************/
      /
    • 列表添加（leftPush依次由左边添加;返回添加成功后list size ）
    • @param key
    •        缓存key
    • @param val
    •        缓存value
    • @return
      */
      public Long leftPush(String key, Object val , long time) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      Long size = list.leftPush(key, val );
      if (time > 0) {
      redisTemplate.expire(key, time, TimeUnit.SECONDS);
      }
      return size;
      }

    /**

    • 列表添加（rightPush依次有右边添加;返回添加后 list size ）
    • @param key
    •        缓存key
    • @param val
    •        缓存value
    • @return
      */
      public Long rightPush(String key, Object val, long time) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      Long size = list.rightPush(key, val);
      if (time > 0) {
      redisTemplate.expire(key, time, TimeUnit.SECONDS);
      }
      return size;
      }

    /**

    • 删除最左边的那个项 （rightPush 添加 删除最早一条 ；leftPush 添加 删除最晚一条 ）
    • @param key
    •        缓存key
    • @return
      */
      public Object leftPop(String key) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      return list.leftPop(key);
      }

    /**

    • 删除最右边的那个项 （rightPush 添加 删除最晚一条 ；leftPush 添加 删除最早一条 ）
    • @param key
    •        缓存key
    • @return
      */
      public Object rightPop(String key) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      return list.rightPop(key);
      }

    /**

    • 列表获取（获得list集合 【 0 ，-1 代表所有值】）
    • @param key
    •        缓存key
    • @return
      */
      public List getList(String key) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      return list.range(key, 0, -1);
      }

    /**

    • 传入list 集合 key 和需要 删除的下标，返回移除数量
    • @param key
    •        缓存key
    • @param index
    •        需要删除的下标
    • @return
      */
      public Long remove(String key, int index) {
      ListOperations<String, Object> list = redisTemplate.opsForList();
      return list.remove(key, 0, list.index(key, index));
      }

    public Long incrBy(String key, long value){
    return redisTemplate.opsForValue().increment(key,value);
    }
    }
    ======================================
    package cn.cai.microservice.redisconfig;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisCommands;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

/**

  • Created by Velsson on 2018/3/8 0008.
    */
    @Component
    public class RedisLock {

    private static final Logger logger = LoggerFactory.getLogger(RedisLock.class);

    @Autowired
    private RedisTemplate redisTemplate;

    private ThreadLocal lockFlag = new ThreadLocal<>();

    private ThreadLocal sqlLine = new ThreadLocal<>();

    //释放锁的原子操作lua脚本
    public static final String UNLOCK_LUA;

    /**

    • 默认的锁超时时间:15秒
      /
      private Long default_expire = 15000L;
      /      *
    • 默认的重试次数 100次
      /
      private Integer default_retryTimes = 100;
      /      *
    • 默认的重试间隔时间:0.3秒
      */
      private Long default_sleepMillis = 300L;

    static {
    StringBuilder sb = new StringBuilder();
    sb.append("if redis.call(“get”,KEYS[1]) == ARGV[1] ");
    sb.append("then “);
    sb.append(” return redis.call(“del”,KEYS[1]) ");
    sb.append("else “);
    sb.append(” return 0 ");
    sb.append("end ");
    UNLOCK_LUA = sb.toString();
    }

    /**

    • 是否开启sql记录
    • @param key
    • @param openSqlLine
    • @return
      */
      public boolean lock(String key, boolean openSqlLine) {
      return lock(key, null, null, null, openSqlLine);
      }

    public boolean lock(String key) {
    return lock(key, null, null, null, false);
    }

    /**

    • 获取redisKey
    • @return
      */
      public String getRedisKey() {
      return lockFlag.get();
      }

    public AtomicInteger getSqlLine() {
    return sqlLine.get();
    }

    /**

    • @param key 锁住的key
    • @param expire 锁存在时间
    • @param retryTimes 重试次数
    • @param sleepMillis 重试间隔
    • @return
      */
      public boolean lock(String key, Long expire, Integer retryTimes, Long sleepMillis, boolean openSqlLine) {
      expire = expire == null || expire < 0 ? default_expire : expire;
      retryTimes = retryTimes == null || retryTimes <= 0 ? default_retryTimes : retryTimes;
      sleepMillis = sleepMillis == null || sleepMillis <= 0 ? default_sleepMillis : sleepMillis;
      boolean result = false;
      do {
      result = setRedis(key, expire);
      if (!result) {
      try {
      Thread.sleep(sleepMillis);
      } catch (InterruptedException e) {
      logger.error(“休眠线程异常”, e);
      return false;
      }
      }
      } while ((!result) && retryTimes-- > 0);
      if (result && openSqlLine) sqlLine.set(new AtomicInteger(0));
      return result;
      }

    private boolean setRedis(final String key, final long expire) {
    try {
    Object result = redisTemplate.execute(new RedisCallback() {
    @Override
    public String doInRedis(RedisConnection connection) throws DataAccessException {
    JedisCommands commands = (JedisCommands) connection.getNativeConnection();
    String uuid = UUID.randomUUID().toString();
    lockFlag.set(uuid);
    return commands.set(key, uuid, “NX”, “PX”, expire);
    }
    });
    return !StringUtils.isEmpty(result);
    } catch (Exception e) {
    logger.error(“设置redis锁异常”, e);
    }
    return false;
    }

    public boolean releaseLock(String key) {
    try {
    //为了防止内部嵌套的锁释放时删除了lockFlag的值导致外层锁释放时报错，所以采取删除key的方式来解决
    String flag = lockFlag.get();
    if (StringUtils.isEmpty(flag)){
    redisTemplate.delete(key);
    return true;
    }

         final List<String> keys = new ArrayList<>();
     keys.add(key);
     final List<String> args = new ArrayList<>();
     args.add(flag);
     Long result = (Long) redisTemplate.execute(new RedisCallback<Long>() {
         public Long doInRedis(RedisConnection connection) throws DataAccessException {
             Object nativeConnection = connection.getNativeConnection();
             if (nativeConnection instanceof JedisCluster) {
                 return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
             } else if (nativeConnection instanceof Jedis) {
                 return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
             }
             return 0L;
         }
     });
     return result != null && result > 0;
 } catch (Exception e) {
     logger.error("释放redis锁异常", e);
 } finally {
     if (null != this.getSqlLine()) {
         sqlLine.remove();
     }
     lockFlag.remove();
 }
 return false;

    }
    }
    =====&

最低0.47元/天 解锁文章
神奇的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合redis做缓存
congge
09-13 9万+
之前的项目中，用到过redis，主要是使用redis做缓存，redis在web开发中使用的场景很多，其中缓存是其中一个很重要的使用场景，之所以用作缓存，得益于redis的读写数据，尤其是在读取数据的时候是直接走内存的，这样在高并发访问数据的时候，和查询数据库相比，redis读取数据的高效性、快速性的优势可见一斑，据说新浪单是每天的所有内容的统计的总的访问数量可以达到上百亿次，这种场景下，如果没有r...
SpringBoot连接Redis服务
mutf7的博客
08-09 1063
SpringBoot连接Redis服务 1、前期准备 redis环境服务的安装 redis服务器防火墙端口的开放 redis配置文件redis.conf中bind修改 开发工具：idea 2、目标 快速构建Springboot+SSM+Redis+Swagger集成框架 3、具体流程 3.1 pom.xml整合SSM+Redis+Swagger相关依赖 <dependency> <groupId>org.springframework.boot</groupId&g
Springboot集成Redis操作缓存源码
最新发布
05-08
Redis（Remote Dictionary Server），即远程字典服务，是一个开源的、使用ANSI C语言编写的、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。详细操作可参考：https://korgs.blog.csdn.net/article/details/138491959
Redis在SpringBoot中的简单应用
jingjiaohuan的博客
10-28 5651
本文作为作者学习的日志，仅供学习使用
springboot框架学习 service层使用redis缓存实现查询与插入
m0_59588838的博客
04-27 1144
昨天实现了springboot框架集成redis并实现redis数据库的基本操作： Linux黑窗口使用的部分redis基础命令： get key 获取key的值 set key v 设置key的值 del key 删除key（应用于所有类型） incr key 将储存的值加上1 decr key 将储存的值减去1 incrby key amout 加上整数amount decrby key amout 减去整数amount append key v 将值...
Spring Boot中使用Redis
shaopengjie的博客
08-23 5270
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
springBoot中redisService封装
qq_42794038的博客
08-20 898
service层： public interface RedisService { //把字符串类型的value写入缓存 public boolean setString(String key,String value); //把字符串类型的value写入缓存（有失效时间） public boolean setString(String key ,String va...
Spring Boot 操作 Redis 的各种实现
2301_78526383的博客
07-02 2482
/ =====================================================================使用Spring cahce 注解方式实现缓存。System.out.println("================线程已结束================================" + s);// ================== ==============读写锁测试 =============================
springboot集成redis
SZNZNN的博客
09-26 78
springboot集成redis 一、<String, String> 存储 pom.xml <!-- 引入依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> application.p
springboot集成测试里的redis
08-26
redisServer = new RedisServer(6379); redisServer.start(); } @PreDestroy public void stopRedis() { redisServer.stop(); } } ``` 在这个类中，我们使用 `RedisServer` 来模拟 Redis 服务器。在 `start...
Springboot集成Redis操作缓存-源码
05-08
Redis（Remote Dictionary Server），即远程字典服务，是一个开源的、使用ANSI C语言编写的、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。详细可参考 ...
SpringBoot整合Lettuce redis过程解析
08-25
相比之下，Jedis是直连Redis Server的客户端程序，在多线程环境下非线程安全，除非使用连接池，为每个Jedis实例增加物理连接。 现在，让我们开始介绍SpringBoot整合Lettuce Redis的过程： 一、添加依赖 首先，...
springboot集成phoenix/presto/tidb/redis各模式等组件demo.zip
04-14
2. spring-boot-admin-client、springboot admin server图形界面管理 3. activemq 4. mysql 5. presto（hive/kudu） 6. phoenix 7. Tidb 8. Clickhouse 9. Redis单机、redis集群、redis哨兵模式 10. swagger...
Spring Boot集成redis，实现redisService ，动态设置数据缓存时间
码农六子
07-17 4518
1、导入maven依赖 &lt;!-- springboot整合 redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-redis&lt;/artifactId&gt; &lt...
IMD下载软件的使用
热门推荐
Whynot_baby的博客
07-24 15万+
用惯了迅雷和百度云，似乎就不会用其它的下载工具 众所周知，常用的下载工具都有限速的困扰 因此这次，介绍一款性能极优的下载工具——IMD 下载地址： http://www.pc6.com/softview/SoftView_24680.html 在PC6下载站下载的软件，亲测可用。 IMD优势1：体积小，仅7.9M，且完全无广告，界面干净清洁 IMD优势2：速度快，相比限速后的各类下载软件，彷佛为我打开了一个新的世界。 功能新发现：一般在图片搜索功能，仅能看到首页，但后面的就看不到了，IMD就有这种魔力能把后
JAVA----同步公众号自定义菜单
Damys
07-12 396
同步公众号自定义菜单
在SpringBoot中使用redis实现分布式锁
yfy的博客
09-04 387
在企业的项目中，经常会碰到多线程安全的问题。特别是在涉及到金钱方面的，安全问题更是重中之重。如何保证多线程下的安全就成了必须要解决的问题。 在之前负责的某个项目中，有几个地方就被人恶意攻击过。用户申请提现的时候，通过接口快速访问，可以跳过钱包余额的校验达到多次提现。在微信小程序支付订单的时候，小程序支付完之后，瞬时调用多次检查订单状态的接口，也会导致多线程的问题，导致钱包余额增加多次。 最开始...
spring boot redis分布式锁
weixin_34380296的博客
01-03 124
2019独角兽企业重金招聘Python工程师标准>>> ...
windows10使用springboot集成redis
07-27
要在Windows 10上使用Spring Boot集成Redis，你可以按照以下步骤进行操作： 步骤1：安装和配置Redis 1. 下载Redis：在Windows上，你可以从Redis官方网站（https://redis.io/download）下载最新的Redis版本。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值