java 操作redis工具类

1.添加maven的包

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

2.添加redis配置

spring.redis.database=1
spring.redis.host=127.0.0.1
#spring.redis.password=testpassword
spring.redis.port=6379
spring.redis.timeout=5000
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.min-idle=0

3.redis操作类
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

/**
 * Author:   linjunit
 * Version：Redis工具类
 * Date:     2020/6/12 0012
 * Description:
 * Modification  History:
 * Date            Author            Version            Description
 * --------------------------------------------------------------
 * Why & What is modified:
 */
@Component
@Slf4j
public class RedisClient {
    @Autowired
    RedisTemplate redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private static final String COLON = ":";
    /**
     * 存储到redis中的锁标志
     */
    private static final String LOCKED = "LOCKED";
    /**
     * 默认请求锁的超时时间(ms 毫秒)
     */
    private static final long TIME_OUT = 100;
    /**
     * 锁flag
     */
    private volatile boolean isLocked = false;

    /**
     * 缓存字符串
     *
     * @param table 表
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean set(String table, String key, String value) {
        try {
            key = table.equals("") ? key : table + COLON + key;
            stringRedisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception ex) {
            return false;
        }
    }

    /**
     * 缓存字符串
     *
     * @param table      表
     * @param key        键
     * @param value      值
     * @param expireTime 过期时间(秒)
     * @return
     */
    public boolean set(String table, String key, String value, long expireTime) {
        try {

            key = table.equals("") ? key : table + COLON + key;
            stringRedisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
            return true;
        } catch (Exception ex) {
            return false;
        }
    }

    /**
     * 缓存对象
     *
     * @param table 表
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean set(String table, String key, Object value) {
        try {
            String json = JSON.toJSONString(value);
            return this.set(table, key, json);
        } catch (Exception ex) {
            return false;
        }
    }

    /**
     * 缓存对象
     *
     * @param table      表
     * @param key        键
     * @param value      值
     * @param expireTime 过期时间(秒)
     * @return
     */
    public boolean set(String table, String key, Object value, long expireTime) {
        try {
            String json = JSON.toJSONString(value);
            return this.set(table, key, json, expireTime);
        } catch (Exception ex) {
            return false;
        }
    }


    /**
     * 根据键取缓存数据
     *
     * @param table 表
     * @param key   键
     * @return 缓存数据
     */
    public String get(String table, String key) {
        try {
            key = table.equals("") ? key : table + COLON + key;
            return stringRedisTemplate.opsForValue().get(key);
        } catch (Exception ex) {
            return "";
        }
    }

    /**
     * 根据键获取缓存对象
     *
     * @param table
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(String table, String key, Class<T> clazz) {
        try {
            key = table.equals("") ? key : table + COLON + key;
            String json = stringRedisTemplate.opsForValue().get(key);
            return JSON.parseObject(json, clazz);
        } catch (Exception ex) {
            return null;
        }
    }

    /**
     * 根据键删除缓存数据
     *
     * @param table
     * @param key
     * @return
     */
    public boolean del(String table, String key) {
        try {
            key = table.equals("") ? key : table + COLON + key;
            return stringRedisTemplate.delete(key);
        } catch (Exception ex) {
            return false;
        }
    }

    /**
     * 设置分布式Redis锁
     *
     * @param table      表
     * @param key        键
     * @param expireTime 过期时间(秒)
     * @return
     */
    public boolean lock(String table, String key, long expireTime) {
        long nowTime = System.nanoTime();
        long timeout = TIME_OUT * 1000000;
        final Random random = new Random();
        key = table.equals("") ? key : table + COLON + key;

        while ((System.nanoTime() - nowTime) < timeout) {
            boolean result = redisTemplate.opsForValue().setIfAbsent(key, LOCKED);

            if (result) {
                isLocked = true;
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                break;
            }
            try {
                Thread.sleep(10, random.nextInt(50000));
            } catch (InterruptedException e) {
                log.error("获取分布式锁休眠被中断：", e);
            }
        }
        return isLocked;
    }

    /**
     * 根据键判断是否有分布式锁
     *
     * @param table 表
     * @param key   键
     * @return
     */
    public boolean isLock(String table, String key) {
        key = table.equals("") ? key : table + COLON + key;
        redisTemplate.getConnectionFactory().getConnection().time();
        return redisTemplate.hasKey(key);
    }

    /**
     * 释放分布式Redis锁
     *
     * @param table 表
     * @param key   键
     */
    public void unlock(String table, String key) {
        // 释放锁
        // 不管请求锁是否成功，只要已经上锁，客户端都会进行释放锁的操作
        if (isLocked) {
            key = table.equals("") ? key : table + COLON + key;
            redisTemplate.delete(key);
        }
    }

    /**
     * 获取访问次数
     *
     * @param table      表
     * @param key        键
     * @param expireTime 过期时间(秒)
     * @return
     */
    public int getCount(String table, String key, long expireTime) {
        key = table.equals("") ? key : table + COLON + key;
        int resultCount = Math.toIntExact(redisTemplate.opsForValue().increment(key, 1));
        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
        return resultCount;
    }

    /**
     * 获取第二天零时失效的时间
     *
     * @return expireTime 过期时间(秒)
     */
    public Long getSecondsNextEarlyMorning() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_YEAR, 1);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return (cal.getTimeInMillis() - System.currentTimeMillis()) / 1000;
    }
}

4.简单的存储/获取redis

 

@Autowired
private RedisClient redis;

redis.set("uds_userToken", "uds_userToken", result);

StoreUserInfoOutput user = redis.get("uds_userToken",token,StoreUserInfoOutput.class);