spring boot實際應用(五) redis

阿新 • • 發佈：2019-01-15

package com.ecej.nove.redis.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;

/**
 *
 * @author QIANG
 *
 */
public class JedisClusterUtils {

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    private static JedisClusterUtils cacheUtils;

    @PostConstruct
    public void init() {
        cacheUtils = this;
        cacheUtils.redisTemplate = this.redisTemplate;
    }

    /**
     * 將資料存入快取
     *
     * @param key
     * @param val
     * @return
     */
    public static void saveString(String key, String val) {

        ValueOperations<String, String> vo = cacheUtils.redisTemplate.opsForValue();
        vo.set(key, val);
    }

    /**
     * 將資料存入快取的集合中
     *
     * @param key
     * @param val
     * @return
     */
    public static void saveToSet(String key, String val) {

        SetOperations<String, String> so = cacheUtils.redisTemplate.opsForSet();

        so.add(key, val);
    }

    /**
     *
     *
     * @param key
     *            快取Key
     * @return keyValue
     * @author:mijp
     * @since:2017/1/16 13:23
     */
    public static String getFromSet(String key) {
        return cacheUtils.redisTemplate.opsForSet().pop(key);
    }

    /**
     * 將 key的值儲存為 value ，當且僅當 key 不存在。 若給定的 key 已經存在，則 SETNX 不做任何動作。 SETNX 是『SET
     * if Not eXists』(如果不存在，則 SET)的簡寫。 <br>
     * 儲存成功，返回 true <br>
     * 儲存失敗，返回 false
     */
    public static boolean saveNX(String key, String val) {

        /** 設定成功，返回 1 設定失敗，返回 0 **/
        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.setNX(key.getBytes(), val.getBytes());
        });

    }

    /**
     * 將 key的值儲存為 value ，當且僅當 key 不存在。 若給定的 key 已經存在，則 SETNX 不做任何動作。 SETNX 是『SET
     * if Not eXists』(如果不存在，則 SET)的簡寫。 <br>
     * 儲存成功，返回 true <br>
     * 儲存失敗，返回 false
     *
     * @param key
     * @param val
     * @param expire
     *            超時時間
     * @return 儲存成功，返回 true 否則返回 false
     */
    public static boolean saveNX(String key, String val, int expire) {

        boolean ret = saveNX(key, val);
        if (ret) {
            cacheUtils.redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return ret;
    }

    /**
     * 將資料存入快取（並設定失效時間）
     *
     * @param key
     * @param val
     * @param seconds
     * @return
     */
    public static void saveString(String key, String val, int seconds) {

        cacheUtils.redisTemplate.opsForValue().set(key, val, seconds, TimeUnit.SECONDS);
    }

    /**
     * 將自增變數存入快取
     */
    public static void saveSeq(String key, long seqNo) {

        cacheUtils.redisTemplate.delete(key);
        cacheUtils.redisTemplate.opsForValue().increment(key, seqNo);
    }

    /**
     * 將遞增浮點數存入快取
     */
    public static void saveFloat(String key, float data) {

        cacheUtils.redisTemplate.delete(key);
        cacheUtils.redisTemplate.opsForValue().increment(key, data);
    }

    /**
     * 儲存複雜型別資料到快取
     *
     * @param key
     * @param obj
     * @return
     */
    public static void saveBean(String key, Object obj) {

        cacheUtils.redisTemplate.opsForValue().set(key, JSON.toJSONString(obj));
    }

    /**
     * 儲存複雜型別資料到快取（並設定失效時間）
     *
     * @param key
     * @param Object
     * @param seconds
     * @return
     */
    public static void saveBean(String key, Object obj, int seconds) {

        cacheUtils.redisTemplate.opsForValue().set(key, JSON.toJSONString(obj), seconds, TimeUnit.SECONDS);
    }

    /**
     * 功能: 存到指定的佇列中<br />
     * 左近右出<br\> 作者: 耿建委
     *
     * @param key
     * @param val
     * @param size
     *            佇列大小限制 0：不限制
     */
    public static void saveToQueue(String key, String val, long size) {

        ListOperations<String, String> lo = cacheUtils.redisTemplate.opsForList();

        if (size > 0 && lo.size(key) >= size) {
            lo.rightPop(key);
        }
        lo.leftPush(key, val);
    }

    /**
     * 儲存到hash集合中
     *
     * @param hName
     *            集合名
     * @param key
     * @param val
     */
    public static void hashSet(String hName, String key, String value) {

        cacheUtils.redisTemplate.opsForHash().put(hName, key, value);
    }

    /**
     * 根據key獲取所以值
     * 
     * @param key
     * @return
     */
    public static Map<Object, Object> hgetAll(String key) {

        return cacheUtils.redisTemplate.opsForHash().entries(key);
    }

    /**
     * 儲存到hash集合中
     *
     * @param <T>
     *
     * @param hName
     *            集合名
     * @param key
     * @param val
     */
    public static <T> void hashSet(String hName, String key, T t) {

        hashSet(hName, key, JSON.toJSONString(t));
    }

    /**
     * 取得複雜型別資料
     *
     * @param key
     * @param obj
     * @param clazz
     * @return
     */
    public static <T> T getBean(String key, Class<T> clazz) {

        String value = cacheUtils.redisTemplate.opsForValue().get(key);
        if (value == null) {
            return null;
        }
        return JSON.parseObject(value, clazz);
    }

    /**
     * 從快取中取得字串資料
     *
     * @param key
     * @return 資料
     */
    public static String getString(String key) {
        cacheUtils.redisTemplate.opsForValue().get(key);

        return cacheUtils.redisTemplate.opsForValue().get(key);
    }

    /**
     *
     * 功能: 從指定佇列裡取得資料<br />
     * 作者: 耿建委
     *
     * @param key
     * @param size
     *            資料長度
     * @return
     */
    public static List<String> getFromQueue(String key, long size) {

        boolean flag = cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.exists(key.getBytes());
        });

        if (flag) {
            return new ArrayList<>();
        }
        ListOperations<String, String> lo = cacheUtils.redisTemplate.opsForList();
        if (size > 0) {
            return lo.range(key, 0, size - 1);
        } else {
            return lo.range(key, 0, lo.size(key) - 1);
        }
    }

    /**
     *
     * 功能: 從指定佇列裡取得資料<br />
     * 作者: 耿建委
     *
     * @param key
     * @return
     */
    public static String popQueue(String key) {

        return cacheUtils.redisTemplate.opsForList().rightPop(key);

    }

    /**
     * 取得序列值的下一個
     *
     * @param key
     * @return
     */
    public static Long getSeqNext(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {

            return connection.incr(key.getBytes());

        });
    }

    /**
     * 取得序列值的下一個
     *
     * @param key
     * @return
     */
    public static Long getSeqNext(String key, long value) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {

            return connection.incrBy(key.getBytes(), value);

        });

    }

    /**
     * 將序列值回退一個
     *
     * @param key
     * @return
     */
    public static void getSeqBack(String key) {

        cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> connection.decr(key.getBytes()));

    }

    /**
     * 從hash集合裡取得
     *
     * @param hName
     * @param key
     * @return
     */
    public static Object hashGet(String hName, String key) {

        return cacheUtils.redisTemplate.opsForHash().get(hName, key);
    }

    public static <T> T hashGet(String hName, String key, Class<T> clazz) {

        return JSON.parseObject((String) hashGet(hName, key), clazz);
    }

    /**
     * 增加浮點數的值
     *
     * @param key
     * @return
     */
    public static Double incrFloat(String key, double incrBy) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Double>) connection -> {

            return connection.incrBy(key.getBytes(), incrBy);

        });
    }

    /**
     * 判斷是否快取了資料
     *
     * @param key
     *            資料KEY
     * @return 判斷是否快取了
     */
    public static boolean isCached(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.exists(key.getBytes());
        });
    }

    /**
     * 判斷hash集合中是否快取了資料
     *
     * @param hName
     * @param key
     *            資料KEY
     * @return 判斷是否快取了
     */
    public static boolean hashCached(String hName, String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.hExists(key.getBytes(), key.getBytes());
        });
    }

    /**
     * 判斷是否快取在指定的集合中
     *
     * @param key
     *            資料KEY
     * @param val
     *            資料
     * @return 判斷是否快取了
     */
    public static boolean isMember(String key, String val) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.sIsMember(key.getBytes(), val.getBytes());
        });
    }

    /**
     * 從快取中刪除資料
     *
     * @param string
     * @return
     */
    public static void delKey(String key) {

        cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> connection.del(key.getBytes()));
    }

    /**
     * 設定超時時間
     *
     * @param key
     * @param seconds
     */
    public static void expire(String key, int seconds) {
        cacheUtils.redisTemplate
                .execute((RedisCallback<Boolean>) connection -> connection.expire(key.getBytes(), seconds));

    }

    /**
     * 列出set中所有成員
     *
     * @param setName
     *            set名
     * @return
     */
    public static Set<Object> listSet(String setName) {

        return cacheUtils.redisTemplate.opsForHash().keys(setName);

    }

    /**
     * 向set中追加一個值
     *
     * @param setName
     *            set名
     * @param value
     */
    public static void setSave(String setName, String value) {

        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.sAdd(setName.getBytes(), value.getBytes()));

    }

    /**
     * 逆序列出sorted set包括分數的set列表
     *
     * @param key
     *            set名
     * @param start
     *            開始位置
     * @param end
     *            結束位置
     * @return 列表
     */
    public static Set<Tuple> listSortedsetRev(String key, int start, int end) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Set<Tuple>>) connection -> {
            return connection.zRevRangeWithScores(key.getBytes(), start, end);
        });
    }

    /**
     * 逆序取得sorted sort排名
     *
     * @param key
     *            set名
     * @param member
     *            成員名
     * @return 排名
     */
    public static Long getRankRev(String key, String member) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {
            return connection.zRevRank(key.getBytes(), member.getBytes());
        });

    }

    /**
     * 根據成員名取得sorted sort分數
     *
     * @param key
     *            set名
     * @param member
     *            成員名
     * @return 分數
     */
    public static Double getMemberScore(String key, String member) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Double>) connection -> {
            return connection.zScore(key.getBytes(), member.getBytes());
        });
    }

    /**
     * 向sorted set中追加一個值
     *
     * @param key
     *            set名
     * @param score
     *            分數
     * @param member
     *            成員名稱
     */
    public static void saveToSortedset(String key, Double score, String member) {

        cacheUtils.redisTemplate.execute(
                (RedisCallback<Boolean>) connection -> connection.zAdd(key.getBytes(), score, member.getBytes()));
    }

    /**
     * 從sorted set刪除一個值
     *
     * @param key
     *            set名
     * @param member
     *            成員名稱
     */
    public static void delFromSortedset(String key, String member) {
        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.zRem(key.getBytes(), member.getBytes()));

    }

    /**
     * 從hash map中取得複雜型別資料
     *
     * @param key
     * @param field
     * @param clazz
     */
    public static <T> T getBeanFromMap(String key, String field, Class<T> clazz) {

        byte[] input = cacheUtils.redisTemplate.execute((RedisCallback<byte[]>) connection -> {
            return connection.hGet(key.getBytes(), field.getBytes());
        });
        return JSON.parseObject(input, clazz, Feature.AutoCloseSource);
    }

    /**
     * 從hashmap中刪除一個值
     *
     * @param key
     *            map名
     * @param field
     *            成員名稱
     */
    public static void delFromMap(String key, String field) {

        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.hDel(key.getBytes(), field.getBytes()));

    }

    /**
     *
     * @Description: 根據key增長 ，計數器
     * @author clg
     * @date 2016年6月30日 下午2:37:52
     *
     * @param key
     * @return
     */
    public static long incr(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {
            return connection.incr(key.getBytes());
        });
    }

    /**
     *
     * @Description: 根據key獲取當前計數結果
     * @author clg
     * @date 2016年6月30日 下午2:38:20
     *
     * @param key
     * @return
     */
    public static String getCount(String key) {

        return cacheUtils.redisTemplate.opsForValue().get(key);
    }

    /**
     * 將所有指定的值插入到存於 key 的列表的頭部。如果 key 不存在，那麼在進行 push 操作前會建立一個空列表
     *
     * @param <T>
     *
     * @param key
     * @param value
     * @return
     */
    public static <T> Long lpush(String key, T value) {

        return cacheUtils.redisTemplate.opsForList().leftPush(key, JSON.toJSONString(value));
    }

    /**
     * 只有當 key 已經存在並且存著一個 list 的時候，在這個 key 下面的 list 的頭部插入 value。 與 LPUSH 相反，當
     * key 不存在的時候不會進行任何操作
     *
     * @param key
     * @param value
     * @return
     */
    public static <T> Long lpushx(String key, T value) {

        return cacheUtils.redisTemplate.opsForList().leftPushIfPresent(key, JSON.toJSONString(value));
    }

    /**
     * 返回儲存在 key 裡的list的長度。 如果 key 不存在，那麼就被看作是空list，並且返回長度為 0
     *
     * @param key
     * @return
     */
    public static Long llen(String key) {

        return cacheUtils.redisTemplate.opsForList().size(key);
    }

    /**
     * 返回儲存在 key 的列表裡指定範圍內的元素。 start 和 end
     * 偏移量都是基於0的下標，即list的第一個元素下標是0（list的表頭），第二個元素下標是1，以此類推
     *
     * @param key
     * @return
     */
    public static List<String> lrange(String key, long start, long end) {

        return cacheUtils.redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 移除並且返回 key 對應的 list 的第一個元素
     *
     * @param key
     * @return
     */
    public static String lpop(String key) {

        return cacheUtils.redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 儲存到hash集合中 只在 key 指定的雜湊集中不存在指定的欄位時，設定欄位的值。如果 key 指定的雜湊集不存在，會建立一個新的雜湊集並與
     * key 關聯。如果欄位已存在，該操作無效果。
     *
     * @param hName
     *            集合名
     * @param key
     * @param val
     */
    public static void hsetnx(String hName, String key, String value) {

        cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hSetNX(key.getBytes(),
                key.getBytes(), value.getBytes()));

    }

    /**
     * 儲存到hash集合中 只在 key 指定的雜湊集中不存在指定的欄位時，設定欄位的值。如果 key 指定的雜湊集不存在，會建立一個新的雜湊集並與
     * key 關聯。如果欄位已存在，該操作無效果。
     *
     * @param <T>
     *
     * @param hName
     *            集合名
     * @param key
     * @param val
     */
    public static <T> void hsetnx(String hName, String key, T t) {
        hsetnx(hName, key, JSON.toJSONString(t));
    }

}

spring boot實際應用(五) redis

package com.ecej.nove.redis.utils; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurr

spring boot 實際應用(二) 編寫測試類

spring boot的測試類在開發中我們是非常需要的，看了不少文章也感覺比較麻煩，下面說個最簡單的``` @RunWith(SpringRunner.class) @SpringBootTe

spring boot項目之redis分布式鎖的應用

key 什麽其他 ng- 分布式鎖即使功能 pri ont SETNX key value 起始版本：1.0.0 時間復雜度：O(1) 將key設置值為value，如果key不存在，這種情況下等同SET命令。當key存在時，什麽也不做。SETNX是”SET i

spring boot 開發—第五篇SpringDataJPA整合 Redis 實現快取

對druid專案進行改造，增加redis快取支援。 1、redis簡介 Redis 是完全開源免費的，遵守BSD協議，是一個高效能的key-value資料庫。 Redis 與其他 key - value 快取產品有以下三個特點： Redis支援資料

Spring boot 2.0的Redis快取應用

範培忠 2018-04-18　　Spring Boot2.0.0.RELEASE在2018年3月1日正式釋出。2.0下對Redis的使用與之前略有不同。具體實現如下：一、Maven依賴和配置新增3個依賴：<dependency>

spring boot/cloud 應用監控

alt min .com cnblogs ima target 器監控斷路器 htm 原文地址：http://www.cnblogs.com/skyblog/p/5633635.html 應用的監控功能，對於分布式系統非常重要。如果把分布式系統比作整個社會系統。那麽各個

基於Spring Boot構建應用開發規範

SpringBoot 項目規範 1.規範的意義和作用編碼規範可以最大限度的提高團隊開發的合作效率編碼規範可以盡可能的減少一個軟件的維護成本 , 並且幾乎沒有任何一個軟件，在其整個生命周期中，均由最初的開發人員來維護編碼規範可以改善軟件的可讀性，可以讓開發人員盡快而徹底地理解新的代碼規範性編碼

spring boot 利用redisson實現redis的分布式鎖

代碼 sched 技術商品 onf 定義必須配置線 oracle 原文：http://liaoke0123.iteye.com/blog/2375469 利用redis實現分布式鎖，網上搜索的大部分是使用java jedis實現的。 redis官方推薦的分布式

Spring Boot 2.0(五)：Docker Compose + Spring Boot + Nginx + Mysql 實踐

work 加載 ports access 分享圖片 htm 初始化 visit edi 我知道大家這段時間看了我寫關於 docker 相關的幾篇文章，不疼不癢的，仍然沒有感受 docker 的便利，是的，我也是這樣認為的，I know your felling 。前期了解

Spring Boot整合JPA、Redis和Swagger2

enc code extends art redis學習 and 小結 JD pip 好久沒有總結了，最近也一直在學習。今天就把spring boot與其它技術的整合做個小總結，主要是jpa、redis和swagger2。公司裏有用到這些，整合起來也很簡單。首先，新建一個

Spring Boot入門系列五（FreeMarker模板的使用）

前端 start marker pin 用戶需要類庫準備 control FreeMarker模板的使用　　FreeMarker是一款模板引擎：即一種基於模板和要改變的數據，並用來生成輸出文本（HTML網頁、電子郵件、配置文件、源代碼等）的通用工具。它不是面向

Spring Boot 企業級應用開發實戰

-o .com 註解 ping 折騰 jar 服務開啟 blog Spring Boot 企業級應用開發實戰【下載地址：https://pan.baidu.com/s/1SbB-auGkUN6r2i6dtv7t_w 】 Spring Boot是目前Spring技術體系中炙

基於spring-boot的應用程序的單元測試方案

supported nsa action throws 接口 insert tomat clas 資料概述本文主要介紹如何對基於spring-boot的web應用編寫單元測試、集成測試的代碼。此類應用的架構圖一般如下所示：我們項目的程序，對應到上圖中的web應用部

精選Spring Boot三十五道必知必會知識點！

其它同時 ont 帶來 ng2 數據源 mvc atl name Spring Boot、Spring MVC 和 Spring 有什麽區別？ 1、Spring Spring最重要的特征是依賴註入。所有 SpringModules 不是依賴註入就是 IOC 控制反轉。當

spring boot項目之redis緩存

程序 ati 如果 lec 第一次數據寫入緩存 list()方法以程序為例，tomcat裏是我們的java應用，第一步會先從redis獲取，如果沒有，就會從db上面獲取，如果取出了，他還會把取出的東西重新寫回redis 使用緩存的步驟：一、在SellApplic

精選Spring Boot三十五道必知必會知識點

問題一 Spring Boot、Spring MVC 和 Spring 有什麼區別？ 1、Spring Spring最重要的特徵是依賴注入。所有 SpringModules 不是依賴注入就是 IOC 控制反轉。當我們恰當的使用 DI 或者是 IOC 的時候，我們可以開發鬆耦合應用。

Spring Boot入門教程(五十): httpclient

在開發中經常會遇到呼叫第三方的介面，這裡介紹一下在spring boot中如何使用httpclient來發送get和post請求。引入依賴 <dependency> <groupId>org.apache.httpco

Spring boot 4 應用打包部署

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

Spring Boot基礎教程 ( 五 )

首先，回顧並詳細說明一下在快速入門中使用的@Controller、@RestController、@RequestMapping註解。如果您對Spring MVC不熟悉並且還沒有嘗試過快速入門案例，建議先看一下快速入門的內容。 @Controller：修飾class，用來建立處理http

基於spring-boot的應用程序的單元+集成測試方案

回歸 path turn behavior pat 一個 match 多場景 mybatis框架概述本文主要介紹單元測試、集成測試相關的概念、技術實現以及最佳實踐。本文的demo是基於Java語言，Spring Boot構建的web應用。測試框架使用Junit，模擬框

spring boot實際應用(五) redis

相關推薦