springcloud集成redis

1、application.properties/application.yml配置：

  redis:
    # redis数据库索引（默认为0），我们使用索引为3的数据库，避免和其他数据库冲突
    database: 3
    # redis服务器地址（默认为localhost）
    host: localhost
    # redis端口（默认为6379）
    port: 6379
    # redis访问密码（默认为空）
    password:
    # redis连接超时时间（单位为毫秒）
    timeout: 1000
    # redis连接池配置
    jedis:
      pool:
        # 最大可用连接数（默认为8，负数表示无限）
        max-active: 8
        # 最大空闲连接数（默认为8，负数表示无限）
        max-idle: 8
        # 最小空闲连接数（默认为0，该值只有为正数才有作用）
        min-idle: 0
        # 从连接池中获取连接最大等待时间（默认为-1，单位为毫秒，负数表示无限）
        max-wait: -1

 

2、pom.xml配置

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
       <groupId>com.alicp.jetcache</groupId>
       <artifactId>jetcache-starter-redis</artifactId>
       <version>2.5.9</version>
</dependency>

 

3、代码中通用的redis工具类

package com.tianque.xueliang.controlalarm.common.redis;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.GeoResults;
import org.springframework.data.geo.Point;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.core.GeoOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.util.concurrent.TimeUnit;

/**
 * @Author: [e-mail]
 * @Description:
 * @Date: Created in 9:33 2019/3/15
 * @Modifired by:
 */
public class RedisUtil {
    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    static private RedisTemplate redisTemplate;

    static private  RedisTemplate getRedisTemplate() {
        if (redisTemplate == null) {
            redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
        }
        return redisTemplate;
    }


    /**
     * Clears this cache instance
     */
    public static void clear() {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return null;
        });
    }

    /**
     * Remove cached query result from redis
     *
     * @param key
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Object removeObject(Object key) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            redisTemplate.delete(key);
            logger.debug("Remove cached query result from redis");
        }
        catch (Throwable t) {
            logger.error("Redis remove failed", t);
        }
        return null;
    }


    /**
     * Put query result to redis
     *
     * @param key
     * @param value
     */
    @SuppressWarnings("unchecked")
    public static void putObject(Object key, Object value, long EXPIRE_TIME, TimeUnit timeUnit) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            ValueOperations opsForValue = redisTemplate.opsForValue();
            opsForValue.set(key, value, EXPIRE_TIME, timeUnit);
            logger.debug("Put query result to redis");
        }
        catch (Throwable t) {
            logger.error("Redis put failed", t);
        }
    }

    /**
     * Put geo result to redis
     *
     * @param key
     * @param m
     */
    @SuppressWarnings("unchecked")
    public static Long geoAdd(Object key, Point point, Object m) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            GeoOperations geoValue = redisTemplate.opsForGeo();
            logger.debug("geoAdd result to redis");
            return geoValue.geoAdd(key,point,m);

        }
        catch (Throwable t) {
            logger.error("geoAdd failed", t);
        }
        return null;
    }

    /**
     * geo dist result to redis
     *
     * @param key
     * @param m1,m2
     */
    @SuppressWarnings("unchecked")
    public static Distance geoDist(Object key, Object m1, Object m2) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            GeoOperations geoValue = redisTemplate.opsForGeo();
            logger.debug("geoAdd result to redis");
            return  geoValue.geoDist(key,m1,m1);
        }
        catch (Throwable t) {
            logger.error("geoAdd failed", t);
        }
        return null;
    }

    /**
     * nearDist
     * @param key
     * @param circle
     * @param args
     * @return
     */
    public static GeoResults<RedisGeoCommands.GeoLocation> nearDist(Object key, Circle circle, RedisGeoCommands.GeoRadiusCommandArgs args) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            GeoOperations geoValue = redisTemplate.opsForGeo();
            logger.debug("geoAdd result to redis");
            return  geoValue.geoRadius(key,circle,args);
        }
        catch (Throwable t) {
            logger.error("geoAdd failed", t);
        }
        return null;
    }



    public static double zscore(String key, Object member) {
        double value = 0;
        RedisTemplate redisTemplate = getRedisTemplate();
        value = redisTemplate.opsForZSet().score(key,member);
        return value;
    }

    /***
     * <p>
     * Description: 得到值
     * </p>
     *
     * @param key
     */
    public static Object get(String key) {
        Object value = null;
        RedisTemplate redisTemplate = getRedisTemplate();
        value = redisTemplate.opsForValue().get(key);
        return value;
    }

    /***
     * <p>
     * Description: 设置键值
     * </p>
     * @param key
     *            value
     */
    public static void set(String key, Object value) {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.opsForValue().set(key,value);
    }

    /***
     * <p>
     * Description: 设置键值 并同时设置有效期
     * </p>
     * @param key
     *            seconds秒数 value
     */
    public static void setex(String key, String value) {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.opsForValue().setIfAbsent(key,value);
    }

    /**
     *判断redis中是否已存在key对应的value
     * @param key
     * @return true/false
     *
     */
    public static boolean isExistValue(String key){
        if (StringUtils.isBlank(key)){
            return false;
        }

        // 根据key获取redis的value
        RedisTemplate redisTemplate = getRedisTemplate();
        Object value = redisTemplate.opsForValue().get(key);

        if (value == null){
            return false;
        }
        return true;
    }

    /**
     *判断redis中是否已存在key
     * @param key
     * @return true/false
     *
     */
    public static boolean isExistKey(String key){
        if (StringUtils.isBlank(key)){
            return false;
        }
        RedisTemplate redisTemplate = getRedisTemplate();
        return redisTemplate.hasKey(key);
    }
}

4、举例说明：

if (RedisUtil.isExistKey(job.getJob_id() + job.getLive_id() + f.getId())){
                logger.info("已存在预警信息，不需要重复发送！,redisKey:{}",job.getJob_id() + job.getLive_id() + f.getId());
                return ;
            }else {
                String value = sysConfigService.getValueByKey(Constant.ALARM_RIDDING_TIME);
                logger.info("该预警不在redis中，可以发送预警..key:{},去重时间value:{}",job.getJob_id() + job.getLive_id(),value);
                RedisUtil.putObject(job.getJob_id() + job.getLive_id() + f.getId(), Constant.PROCESS_METHOD_ADMISSBILITY_CENTER,Long.parseLong(value), TimeUnit.MINUTES);

            }