項目中用的一些工具（持續更新）

記錄項目中常用的工具類

1、Json 工具類

引入依賴：

<!-- json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>

工具類：

import com.alibaba.fastjson.JSONObject;

/**
 * Json工具類
 */
public class JsonUtils {

    /**
     * java對象轉成json字符串
     * @param obj 源對象
     * @return JSON字符串
     */
    public static String objToJson(Object obj) {
        if (obj != null) {
            return JSONObject.toJSONString(obj);
        }
        return null;
    }

    /**
     * json字符串轉成java對象
     * @param json JSON字符串
     * @param clazz 轉成的目標對象類型
     * @param <T> 目標對象
     * @return
     */
    public static <T> T jsonToObj(String json, Class<T> clazz) {
        return JSONObject.parseObject(json, clazz);
    }
}

2、Redis 工具類

package com.cbec.util;

import com.cbec.bean.ScoreOrder;
import com.cbec.constans.ConsCode;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * Redis工具類，使用之前請確保RedisTemplate成功注入
 *
 * @author ye17186
 * @version 2019/2/22 10:48
 */
@Component
public final class RedisUtils {

    private RedisUtils() {
    }

    @SuppressWarnings("unchecked")
    private static RedisTemplate<String, Object> redisTemplate = SpringUtils.getBean("redisTemplate");

//    @Autowired
//    public static RedisTemplate redisTemplate;
    /**
     * 設置有效時間
     *
     * @param key Redis鍵
     * @param timeout 超時時間
     * @return true=設置成功；false=設置失敗
     */
    public static boolean expire(final String key, final long timeout) {

        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 設置有效時間
     *
     * @param key Redis鍵
     * @param timeout 超時時間
     * @param unit 時間單位
     * @return true=設置成功；false=設置失敗
     */
    public static boolean expire(final String key, final long timeout, final TimeUnit unit) {

        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }

    /**
     * 刪除單個key
     *
     * @param key 鍵
     * @return true=刪除成功；false=刪除失敗
     */
    public static boolean del(final String key) {

        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }

    /**
     * 刪除多個key
     *
     * @param keys 鍵集合
     * @return 成功刪除的個數
     */
    public static long del(final Collection<String> keys) {

        Long ret = redisTemplate.delete(keys);
        return ret == null ? 0 : ret;
    }


    /**
     * 取出指定前綴的key集合
     *
     * @param prefix Redis鍵前綴
     */
    public static Set<String> getKeys(final String prefix) {
        Set<String> keys = redisTemplate.keys(prefix);
        for(String key : keys){
            System.out.println(key);
        }
        return keys;
    }


    /**
     * 存入普通對象
     *
     * @param key Redis鍵
     * @param value 值
     */
    public static void set(final String key, final Object value) {

        redisTemplate.opsForValue().set(key, value);
    }

    // 存儲普通對象操作

    /**
     * 存入普通對象
     *
     * @param key 鍵
     * @param value 值
     * @param timeout 有效期，單位秒
     */
    public static void set(final String key, final Object value, final long timeout) {

        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 獲取普通對象
     *
     * @param key 鍵
     * @return 對象
     */
    public static Object get(final String key) {

        try {
           return redisTemplate.opsForValue().get(key);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }

    }

    /**
     * 通過search模糊匹配訂單
     * 訂單的存儲規則：
     * 主鍵: scoreorder+"_"+訂單id+“_B_”+買方id+"_S_"+賣方id
     * value： 訂單信息
     * @param search : 訂單id 或 買方id 或 賣方id
     * @param sb ： 訂單查："" 買方查：B 賣方查：S
     * @return
     */
    public static List<ScoreOrder> likeOrderGet(final String search,String sb) {
        try {
            List<ScoreOrder> list = new ArrayList<>();
            String pattern = ConsCode.SCORE_OREDER + "*"+ sb +"_" + search + "*";
            Set<String> keys = redisTemplate.keys(pattern);
            for (String k: keys) {
                Object obj = redisTemplate.opsForValue().get(k);
                if(obj != null) {
                    list.add((ScoreOrder)obj);
                }
            }
            return list;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根據模糊的key獲取準確的key集合
     * @param key 訂單id 或 買方id 或 賣方id
     * @param sb 訂單查："", 買方查：B ,賣方查：S
     * @return
     */
    public static String getCurrencyKey(String key,String sb) {
        String pattern = ConsCode.SCORE_OREDER + "*"+sb+"_" + key + "*";
        Set<String> keys = redisTemplate.keys(pattern);
        if(keys != null && keys.size() > 0) {
            return keys.iterator().next();
        }
        return null;
    }

    /**
     * 查詢訂單的過期時間
     * @param search   訂單id 或 買方id 或 賣方id
     * @param sb 訂單查："", 買方查：B ,賣方查：S
     * @return
     */
    public static Long getOrderExpireTime(String search,String sb) {
        String key = getCurrencyKey(search, sb);
        if(key == null) {
            return -2L; //key不存在
        }
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    // 存儲Hash操作

    /**
     * 往Hash中存入數據
     *
     * @param key Redis鍵
     * @param hKey Hash鍵
     * @param value 值
     */
    public static void hPut(final String key, final String hKey, final Object value) {

        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 往Hash中存入多個數據
     *
     * @param key Redis鍵
     * @param values Hash鍵值對
     */
    public static void hPutAll(final String key, final Map<String, Object> values) {

        redisTemplate.opsForHash().putAll(key, values);
    }

    /**
     * 獲取Hash中的數據
     *
     * @param key Redis鍵
     * @param hKey Hash鍵
     * @return Hash中的對象
     */
    public static Object hGet(final String key, final String hKey) {

        return redisTemplate.opsForHash().get(key, hKey);
    }

    /**
     * 獲取多個Hash中的數據
     *
     * @param key Redis鍵
     * @param hKeys Hash鍵集合
     * @return Hash對象集合
     */
    public static List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {

        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }


    // 存儲Set相關操作

    /**
     * 往Set中存入數據
     *
     * @param key Redis鍵
     * @param values 值
     * @return 存入的個數
     */
    public static long sSet(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 刪除Set中的數據
     *
     * @param key Redis鍵
     * @param values 值
     * @return 移除的個數
     */
    public static long sDel(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }

    // 存儲List相關操作

    /**
     * 往List中存入數據
     *
     * @param key Redis鍵
     * @param value 數據
     * @return 存入的個數
     */
    public static long rPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().leftPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入數據
     *
     * @param key Redis鍵
     * @param value 數據
     * @return 存入的個數
     */
    public static long lPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多個數據
     *
     * @param key Redis鍵
     * @param values 多個數據
     * @return 存入的個數
     */
    public static long lPushAll(final String key, final Collection<Object> values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多個數據
     *
     * @param key Redis鍵
     * @param values 多個數據
     * @return 存入的個數
     */
    public static long lPushAll(final String key, final Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 從List中獲取begin到end之間的元素
     *
     * @param key Redis鍵
     * @param start 開始位置
     * @param end 結束位置（start=0，end=-1表示獲取全部元素）
     * @return List對象
     */
    public static List<Object> lGet(final String key, final int start, final int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }
}