当前位置： 首页 > news >正文

Redis在SpringBoot项目中使用

news 来源：原创 2024/4/27 22:20:48

完整版配置（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.8.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.microStationCom</groupId>
	<artifactId>WebApi</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>WebApi</name>
	<!-- springboot 打war包。 默认打包方式为 jar , 这里修改为war -->

<!--	<packaging>war</packaging>-->
	<!-- -->
    <packaging>jar</packaging>
	<description>microStationCom WebApi</description>
	<properties>
		<java.version>1.8</java.version>
		<tencent.qcloudsms.version>3.1.298</tencent.qcloudsms.version>
		<pagehelper.version>5.0.3</pagehelper.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<!--最终打成war包，排除内置的tomcat
			<exclusions>
				<exclusion>
					<groupId>org.springframework.boot</groupId>
					<artifactId>spring-boot-starter-tomcat</artifactId>
				</exclusion>
			</exclusions>
			-->
		</dependency>

		<!-- reids -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<!-- 不依赖Redis的异步客户端lettuce -->
			<exclusions>
				<exclusion>
					<groupId>io.lettuce</groupId>
					<artifactId>lettuce-core</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<!-- Jedis客户端依赖，默认版本： jedis = 2.9.3 , commons-pool2 = 2.6.2 -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.3</version>
		</dependency>

		<dependency>
			<groupId>com.microsoft.sqlserver</groupId>
			<artifactId>sqljdbc4</artifactId>
			<version>4.0</version>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>

		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-core</artifactId>
		</dependency>

		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.9</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<!-- mybatis plus 代码生成器 -->
		<!--mybatis plus-->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-generator</artifactId>
			<version>3.4.0</version>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.4.0</version>
		</dependency>

		<!--MyBatis的PageHelper插件-->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>${pagehelper.version}</version>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
			<version>3.1.0</version>
		</dependency>

		<dependency>
			<groupId>org.freemarker</groupId>
			<artifactId>freemarker</artifactId>
			<version>2.3.28</version>
		</dependency>


		<dependency>
			<groupId>com.github.davidfantasy</groupId>
			<artifactId>mybatis-plus-generator-ui</artifactId>
			<version>1.4.5</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>


		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional>
			<scope>runtime</scope>
		</dependency>


		<!-- swagger -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.9.2</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.9.2</version>
		</dependency>

		<!-- 使用httpclient需要的maven依赖  -->
		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpcore</artifactId>
			<version>4.4.9</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.6</version>
		</dependency>
		<!-- logging日志 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-logging</artifactId>
		</dependency>

		<!--添加servlet-api的依赖,用来打war包  -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- jstl -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- 引入JWT -->
		<dependency>
			<groupId>com.auth0</groupId>
			<artifactId>java-jwt</artifactId>
			<version>3.4.1</version>
		</dependency>

		<!-- 腾讯云短信功能 -->
		<dependency>
			<groupId>com.tencentcloudapi</groupId>
			<artifactId>tencentcloud-sdk-java</artifactId>
			<version>3.1.298</version>
		</dependency>

		<dependency>
			<groupId>com.github.qcloudsms</groupId>
			<artifactId>qcloudsms</artifactId>
			<version>1.0.6</version>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<fork>false</fork>
				</configuration>
			</plugin>

		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</pluginRepository>
	</pluginRepositories>

</project>

application.properties

# 使用配置文件
spring.profiles.active=dev

#调试模式
# 1、在application.properties文件添加 debug=true
# 2、
debug=true


# Redis 配置
spring.redis.database=0
spring.redis.host=192.168.0.198
spring.redis.port=6379
spring.redis.password=123456
spring.redis.timeout=6000
spring.redis.jedis.pool.min-idle=20
# 最大空闲数，数据库连接的最大空闲时间。超过空闲数量，数据库连接将被标记为不可用，然后被释放。设为0表示无限制
spring.redis.jedis.pool.max-idle=100
##jedis的最大活跃连接数设为0表示无限制
spring.redis.jedis.pool.max-active=500
#最大等待时间：单位ms
#jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
#如果超过等待时间，则直接抛出JedisConnectionException
spring.redis.jedis.pool.max-wait=60000
Redis配置类: JedisConfig.java
package com.microStationCom.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.StringUtils;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


/**
 * redis配置类
 */
@Configuration
public class JedisConfig extends CachingConfigurerSupport {

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

    /**
     * SpringSession  需要注意的就是redis需要2.8以上版本，然后开启事件通知，在redis配置文件里面加上
     * notify-keyspace-events Ex
     * Keyspace notifications功能默认是关闭的（默认地，Keyspace 时间通知功能是禁用的，因为它或多或少会使用一些CPU的资源）。
     * 或是使用如下命令：
     * redis-cli config set notify-keyspace-events Egx
     * 如果你的Redis不是你自己维护的，比如你是使用阿里云的Redis数据库，你不能够更改它的配置，那么可以使用如下方法：在applicationContext.xml中配置
     * <util:constant static-field="org.springframework.session.data.redis.config.ConfigureRedisAction.NO_OP"/>
     *
     * @return
     */

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    @Value("${spring.redis.password}")
    private String password;

    @Bean
    public JedisPool redisPoolFactory() {

        logger.info("============== JedisPool 连接池注入 开始 ===============");
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        jedisPoolConfig.setMaxTotal(maxActive);
        jedisPoolConfig.setMinIdle(minIdle);
        JedisPool jedisPool = null;
        if (StringUtils.isEmpty(password)) {
            jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
        } else {
            jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
        }
        logger.info("JedisPool 连接池注入成功");
        logger.info("redis连接信息  地址：" + host + ":" + port + ":" + password);
        logger.info("============== JedisPool 连接池注入 结束 ===============");
        return jedisPool;
    }




    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(new StringRedisSerializer());
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }



    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(new StringRedisSerializer());
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

Redis缓存工具类: RedisCacheUtils.java
package com.microStationCom.util;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
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.PostConstruct;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis 缓存工具类
 */
@Component
public class RedisCacheUtils {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate;

    public static StringRedisTemplate stringRedisTemplate1;

    public static RedisTemplate redisTemplate1;

    //单位警情数据前缀
    public static final String KEY_ALARM_GROUPID_PREFIX = "alarmWz:groupId_";
    //redis中key的超时时间
    public static final long KEY_ALARM_TIMEOUT = 12 * 60 * 60;//单位为秒，2小时（7200秒）


//    /** redis操作模板，面向对象的模板 */
//    private static StringRedisTemplate stringRedisTemplate
//            = (StringRedisTemplate) SpringUtil.getBean("stringRedisTemplate");
//    private static RedisTemplate<String, Object> redisTemplate
//            = (RedisTemplate) SpringUtil.getBean("redisTemplate");

    /**
     * 删除缓存<br>
     * 根据key精确匹配删除
     *
     * @param key
     */
    @SuppressWarnings("unchecked")
    public static void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate1.delete(key[0]);
            } else {
                redisTemplate1.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * (根据key精确匹配删除)
     * @param key
     */
    public static void deleteByKey(String  key) {
        if (key != null) {
            if (stringRedisTemplate1.delete(key) == true)
            {
            }else{
                redisTemplate1.delete(key);
            }

        }
    }

    /**
     * 批量删除<br>
     * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删）
     *
     * @param pattern
     */
    public void batchDel(String... pattern) {
        for (String kp : pattern) {
            redisTemplate1.delete(redisTemplate1.keys(kp + "*"));
        }
    }

    /**
     * 取得缓存（int型）
     *
     * @param key
     * @return
     */
    public  Integer getInt(String key) {
        String value = stringRedisTemplate1.boundValueOps(key).get();
        if (StringUtils.isNotEmpty(value)) {
            return Integer.valueOf(value);
        }
        return null;
    }

    /**
     * 取得缓存（字符串类型）
     *
     * @param key
     * @return
     */
    public static String getStr(String key) {
        return stringRedisTemplate1.boundValueOps(key).get();
    }

    /**
     * 取得缓存（字符串类型）
     *
     * @param key
     * @return
     */
    public static String getStr(String key, boolean retain) {
        String value = stringRedisTemplate1.boundValueOps(key).get();
        if (!retain) {
            redisTemplate1.delete(key);
        }
        return value;
    }

    /**
     * 模糊查询(根据规则) 返回 keys
     * @param pattern
     * @return
     */
    public static Set<String> searchKeys(String pattern){
       return stringRedisTemplate1.keys(pattern);
    }


    /**
     * 获取缓存<br>
     * 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值
     *
     * @param key
     * @return
     */
    public static Object getObj(String key) {
        return redisTemplate1.boundValueOps(key).get();
    }

    /**
     * 获取缓存<br>
     * 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值
     *
     * @param key
     * @param retain
     *            是否保留
     * @return
     */
    public  Object getObj(String key, boolean retain) {
        Object obj = redisTemplate1.boundValueOps(key).get();
        if (!retain) {
            redisTemplate.delete(key);
        }
        return obj;
    }

    /**
     * 获取缓存<br>
     * 注：该方法暂不支持Character数据类型
     *
     * @param key
     *            key
     * @param clazz
     *            类型
     * @return
     */
    @SuppressWarnings("unchecked")
    public  <T> T get(String key, Class<T> clazz) {

        return (T) redisTemplate1.boundValueOps(key).get();
    }

    /**
     * 获取缓存json对象<br>
     *
     * @param key
     *            key
     * @param clazz
     *            类型
     * @return
     * @throws Exception

    @SuppressWarnings("unchecked")
    public  <T> T getJson(String key, Class<T> clazz) throws Exception {
        String jsonStr=null;
        jsonStr=stringRedisTemplate.boundValueOps(key).get();
        if(jsonStr==null){
            return null;
        }else{
            return (T) JsonUtil.jsonToBean(jsonStr, clazz);
        }
    } */

    /**
     * 将value对象写入缓存
     *
     * @param key
     * @param value
     * @param time
     *            失效时间(秒)
     */
    public static void set(String key, Object value, Long time) {
        if (value.getClass().equals(String.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Integer.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Double.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Float.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Short.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Long.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        } else if (value.getClass().equals(Boolean.class)) {
            stringRedisTemplate1.opsForValue().set(key, value.toString());
        }
        else {
            redisTemplate1.opsForValue().set(key, value);
        }
        if (time != null && time > 0) {
            redisTemplate1.expire(key, time, TimeUnit.SECONDS);
            stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
        }
    }

    /**
     * 将value对象以JSON格式写入缓存
     *
     * @param key
     * @param value
     * @param time
     *            失效时间(秒)

    public  void setJson(String key, Object value, Long time) {
        stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
        if (time!=null&&time > 0) {
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    }
     */

    /**
     * 更新key对象field的值
     *
     * @param key
     *            缓存key
     * @param field
     *            缓存对象field
     * @param value
     *            缓存对象field值

    public  void setJsonField(String key, String field, String value) {
        JSONObject obj = JSON.parseObject(stringRedisTemplate.boundValueOps(key).get());
        obj.put(field, value);
        stringRedisTemplate.opsForValue().set(key, obj.toJSONString());
    }
     */

    /**
     * 递减操作
     *
     * @param key
     * @param by
     * @return
     */
    public  double decr(String key, double by) {
        return redisTemplate1.opsForValue().increment(key, -by);
    }

    /**
     * 递增操作
     *
     * @param key
     * @param by
     * @return
     */
    public  double incr(String key, double by) {
        return redisTemplate1.opsForValue().increment(key, by);
    }

    /**
     * 获取double类型值
     *
     * @param key
     * @return
     */
    public  double getDouble(String key) {
        String value = stringRedisTemplate.boundValueOps(key).get();
        if (StringUtils.isNotBlank(value)) {
            return Double.valueOf(value);
        }
        return 0d;
    }

    /**
     * 设置double类型值
     *
     * @param key
     * @param value
     * @param time
     *            失效时间(秒)
     */
    public  void setDouble(String key, double value, Long time) {
        stringRedisTemplate1.opsForValue().set(key, String.valueOf(value));
        if (time!=null&&time > 0) {
            stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
        }
    }

    /**
     * 设置double类型值
     *
     * @param key
     * @param value
     * @param time
     *            失效时间(秒)
     */
    public  void setInt(String key, int value, Long time) {
        stringRedisTemplate1.opsForValue().set(key, String.valueOf(value));
        if (time!=null&&time > 0) {
            stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
        }
    }

    /**
     * 将map写入缓存
     *
     * @param key
     * @param map
     * @param time
     *            失效时间(秒)
     */
    public  <T> void setMap(String key, Map<String, T> map, Long time) {
        redisTemplate1.opsForHash().putAll(key, map);
    }

    /**
     * 将map写入缓存
     *
     * @param key
     * @param map
     * @param time
     *            失效时间(秒)

    @SuppressWarnings("unchecked")
    public  <T> void setMap(String key, T obj, Long time) {
        Map<String, String> map = (Map<String, String>)JsonUtil.parseObject(obj, Map.class);
        redisTemplate.opsForHash().putAll(key, map);
    }
     */

    /**
     * 向key对应的map中添加缓存对象
     *
     * @param key
     * @param map
     */
    public  <T> void addMap(String key, Map<String, T> map) {
        redisTemplate1.opsForHash().putAll(key, map);
    }

    /**
     * 向key对应的map中添加缓存对象
     *
     * @param key
     *            cache对象key
     * @param field
     *            map对应的key
     * @param value
     *            值
     */
    public  void addMap(String key, String field, String value) {
        redisTemplate1.opsForHash().put(key, field, value);
    }

    /**
     * 向key对应的map中添加缓存对象
     *
     * @param key
     *            cache对象key
     * @param field
     *            map对应的key
     * @param obj
     *            对象
     */
    public  <T> void addMap(String key, String field, T obj) {
        redisTemplate1.opsForHash().put(key, field, obj);
    }

    /**
     * 获取map缓存
     *
     * @param key
     * @param clazz
     * @return

    public  <T> Map<String, T> mget(String key, Class<T> clazz) {
        BoundHashOperations<String, String, T> boundHashOperations = redisTemplate.boundHashOps(key);
        return boundHashOperations.entries();
    }*/

    /**
     * 获取map缓存中的某个对象
     *
     * @param key
     * @param field
     * @param clazz
     * @return
     */
    @SuppressWarnings("unchecked")
    public  <T> T getMapField(String key, String field, Class<T> clazz) {
        return (T) redisTemplate1.boundHashOps(key).get(field);
    }

    /**
     * 获取map缓存
     *
     * @param key
     * @param clazz
     * @return

    public  <T> T getMap(String key, Class<T> clazz) {
        BoundHashOperations<String, String, String> boundHashOperations = redisTemplate.boundHashOps(key);
        Map<String, String> map = boundHashOperations.entries();
        return JsonUtil.parseObject(map, clazz);
    } */

    /**
     * 删除map中的某个对象
     *
     * @author lh
     * @date 2016年8月10日
     * @param key
     *            map对应的key
     * @param field
     *            map中该对象的key
     */
    public void delMapField(String key, String... field) {
        BoundHashOperations<String, String, ?> boundHashOperations = redisTemplate1.boundHashOps(key);
        boundHashOperations.delete(field);
    }

    /**
     * 指定缓存的失效时间
     *
     * @author FangJun
     * @date 2016年8月14日
     * @param key
     *            缓存KEY
     * @param time
     *            失效时间(秒)
     */
    public  void expire(String key, Long time) {
        if (time!=null&&time > 0) {
            redisTemplate1.expire(key, time, TimeUnit.SECONDS);
        }
    }

    /**
     * 添加set
     *
     * @param key
     * @param value
     */
    public  void sadd(String key, String... value) {
        redisTemplate1.boundSetOps(key).add(value);
    }

    /**
     * 删除set集合中的对象
     *
     * @param key
     * @param value
     */
    public  void srem(String key, String... value) {
        redisTemplate1.boundSetOps(key).remove(value);
    }

    /**
     * set重命名
     *
     * @param oldkey
     * @param newkey
     */
    public  void srename(String oldkey, String newkey) {
        redisTemplate1.boundSetOps(oldkey).rename(newkey);
    }




    /**
     * 短信缓存
     *
     * @author fxl
     * @date 2016年9月11日
     * @param key
     * @param value
     * @param time

    public  void setIntForPhone(String key, Object value, int time) {
        stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
        if (time > 0) {
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    }
     */

    /**
     * 模糊查询keys
     *
     * @param pattern
     * @return
     */
    public static Set<String> keys(String pattern) {

        return redisTemplate1.keys(pattern);
    }

    /**
     *
     * @Description (检查key是否存在，返回boolean值 )
     * @author feizhou
     * @Date 2018年5月29日下午5:37:40
     * @version 1.0.0
     * @param key
     * @return
     */
    public  Boolean   ishasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    @PostConstruct
    public StringRedisTemplate getStringRedisTemplate() {
        stringRedisTemplate1 = stringRedisTemplate;
        System.out.println("获取缓存： getStringRedisTemplate ... " + stringRedisTemplate.toString());
        return stringRedisTemplate1;
    }

    public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        System.out.println("设置缓存： setStringRedisTemplate ... " + stringRedisTemplate.toString());
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @PostConstruct
    public RedisTemplate<String, Object> getRedisTemplate() {
        redisTemplate1 = redisTemplate;
        System.out.println("获取缓存： getStringRedisTemplate ... " + stringRedisTemplate.toString());
        return redisTemplate1;
    }

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        System.out.println("设置缓存： setRedisTemplate ... " + redisTemplate.toString());
        this.redisTemplate = redisTemplate;
    }
}


//操作redis,直接在控制器类或工具类中，使用 RedisCacheUtils.java类并调用相关的静态方法。
//从redis缓存中取警情信息，条件：需要unitUid
            //操作redis
            String key = RedisCacheUtils.KEY_ALARM_GROUPID_PREFIX + unitUid;
            String alarmDataStr = RedisCacheUtils.getStr(key);
            if (!StringUtils.isEmpty(alarmDataStr)){
                logger.info("警情信息确认（小程序）：alarmId-{}, deptId-{}, groupNo-{}, unitUid-{} ", alarmId , deptId , groupNo , unitUid);

                List<AlarmData> list = JSONArray.parseArray(alarmDataStr , AlarmData.class);
                //List<AlarmData> list = JSONObject.parseObject(alarmDataStr , List.class);
                if (null != list && list.size() > 0){

                    //更新警情车辆调派记录(小程序)：确认时间    2022-08-12
                    AlarmData alarmData = list.get(0);
                    int saveFlag = alarmFlowbakService.saveAlarmCarFlowQrsj(alarmData.getUpid() , unitUid);
                    logger.info("警情信息确认（小程序）：更新调派车辆记录确认时间 , 更新标记:{} , upid:{} , unitUid:{} ...  " , saveFlag , alarmData.getUpid() , unitUid );
                    RedisCacheUtils.deleteByKey(key);
                    logger.info("警情信息确认（小程序）：从 Redis 缓存中清除警情信息 ... {} " , alarmDataStr);
                }else{
                    logger.error("警情信息确认（小程序）：从 Redis 缓存中读取警情信息出现错误！！！ {} " , alarmDataStr);
                    return JsonUtils.JsonException("确认警情信息出现错误，请联系管理员");
                }
            }

其他资料

SpringBoot整合Redisicon-default.png?t=M85Bhttps://blog.csdn.net/hello_list/article/details/124893755Jedis连接工具 和 SpringBoot整合Redisicon-default.png?t=M85Bhttps://www.cnblogs.com/zxhbk/p/13054709.html

相关文章：

  • Android AIDL跨进程通信
  • Java大牛必会|分布式缓存实现方案之Spring Cache
  • KF、EKF、IEKF、UKF卡尔曼滤波器
  • Neo4j入门+深入
  • 21年icpc上海区域赛B题Strange Permutations (容斥+生成函数)
  • 【CSS】QQ邮箱布局，词典四列布局，行内布局
  • 滑动窗口问题
  • Java的输入 Scanner in=new Scanner(System.in)；
  • 接口请求返回状态码
  • Cocos Creator游戏引擎
  • [静态时序分析简明教程(一)] 绪论
  • ADU87、DCB20X-E等设备以RTSP方式添加第三方相机或录像机教程
  • 计算机网络常见面试题汇总（建议收藏）
  • 【从零带你玩转Linux】Linux环境搭建
  • AMBA总线相关知识记录
  • 〔开发系列〕一次关于小程序开发的深度总结
  • 2017年终总结、随想
  • 77. Combinations
  • AHK 中 = 和 == 等比较运算符的用法
  • HTTP传输编码增加了传输量，只为解决这一个问题 | 实用 HTTP
  • in typeof instanceof ===这些运算符有什么作用
  • Iterator 和 for...of 循环
  • Lsb图片隐写
  • spring + angular 实现导出excel
  • Web标准制定过程
  • 机器人定位导航技术 激光SLAM与视觉SLAM谁更胜一筹？
  • 七牛云 DV OV EV SSL 证书上线，限时折扣低至 6.75 折！
  • 使用SAX解析XML
  • python最赚钱的4个方向，你最心动的是哪个？
  • UI设计初学者应该如何入门？
  • ​RecSys 2022 | 面向人岗匹配的双向选择偏好建模
  • （￥1011）－（一千零一拾一元整）输出
  • （02）vite环境变量配置
  • (cljs/run-at (JSVM. :browser) 搭建刚好可用的开发环境!)
  • (zz)子曾经曰过：先有司，赦小过，举贤才
  • (转）可以带来幸福的一本书
  • .aanva
  • .libPaths()设置包加载目录
  • .NET Core 将实体类转换为 SQL(ORM 映射)
  • .NET 自定义中间件 判断是否存在 AllowAnonymousAttribute 特性 来判断是否需要身份验证
  • .NET/C# 使窗口永不获得焦点
  • .NET框架
  • .NET框架设计—常被忽视的C#设计技巧
  • @四年级家长，这条香港优才计划+华侨生联考捷径，一定要看！
  • [2013AAA]On a fractional nonlinear hyperbolic equation arising from relative theory
  • [CSS] 点击事件触发的动画
  • [Docker]十二.Docker consul集群搭建、微服务部署,Consul集群+Swarm集群部署微服务实战
  • [flask]http请求//获取请求头信息+客户端信息
  • [hdu 1247]Hat’s Words [Trie 图]
  • [IDF]聪明的小羊
  • [JavaScript]_[初级]_[关于forof或者for...of循环语句的用法]
  • [leetcode 双指针]
  • [LeetCode] Sort List
  • [LeetCode][面试算法]逻辑闭环的二分查找代码思路
  • [leetcode]114. Flatten Binary Tree to Linked List由二叉树构建链表