• Redis的发布订阅在SpringMVC（或xml配置）项目中使用(注意版本兼容问题)

    在Spring中使用 Redis ,除了需要 jedis.jar 外，还需要下载 spring-data-redis.jar，打开网址 https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis ， 

    注意 spring5以上需要配置 spring-data-redis 2.0

    基于spring主版本为4.3.13.RELEASE的项目，测试以下对应版本可用。

    spring-data-redis版本

    jedis版本

    备注

    1.5.2.RELEASE

    2.7.3

    1.6.0.RELEASE

    2.7.2  2.7.3

    1.6.2.RELEASE

    2.8.0

    1.8.1.RELEASE

    2.9.0

    1.8.4.RELEASE

    2.9.0

    项目中使用的版本：

    spring-data-redis-1.6.6.RELEASE.jar   jedis-2.9.0.jar

    项目结构

     

    1、客户端（订阅）：

    redis.properties

    1. #redis pool config
    2. redis.pool.maxActive=1000
    3. redis.pool.maxIdle=100
    4. redis.pool.maxWaitMillis=10000
    5. redis.pool.testOnBorrow=true
    6.  
    7. #redis config
    8. redis.host=192.168.0.198
    9. redis.port=6379
    10. redis.timeout=6000
    11. redis.password=123456
    12. redis.dbindex=8
    13. redis.usePool=1
    14. redis.default.expire=1800000
    15. redis.topicName=message

     applicationContext-redis.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    7. 	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    8. 	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    9. 	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
    10.  
    11. 	<description>Redis configurationdescription>
    12.  
    13. 	
    15.  
    16. 	
    17. 	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    18. 		<property name="maxIdle" value="${redis.pool.maxIdle}">property>
    19. 		<property name="maxTotal" value="${redis.pool.maxActive}" />
    20. 		<property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
    21. 		<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
    22. 		
    23. 	bean>
    24.  
    25. 	<bean id="jedisConnectionFactory"
    26. 		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
    27. 		destroy-method="destroy">
    28. 		<property name="poolConfig" ref="jedisPoolConfig">property>
    29. 		<property name="hostName" value="${redis.host}">property>
    30. 		<property name="port" value="${redis.port}">property>
    31. 		<property name="password" value="${redis.password}">property>
    32. 		<property name="timeout" value="${redis.timeout}">property>
    33. 		
    34. 	bean>
    35.  
    36. 	
    37. 	<bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    38. 	<bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
    39. 	<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
    40. 		<property name="connectionFactory" ref="jedisConnectionFactory" />
    41. 		
    42. 		
    43. 		<property name="keySerializer" ref="stringRedisSerializer" />
    44. 		<property name="valueSerializer" ref="stringRedisSerializer" />
    45. 	bean>
    46.  
    47. 	<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
    48. 		<property name="connectionFactory" ref="jedisConnectionFactory" />
    49. 		<property name="keySerializer">
    50. 			<bean
    51. 				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    52. 		property>
    53. 		<property name="valueSerializer">
    54. 			<bean
    55. 				class="org.springframework.data.redis.serializer.StringRedisSerializer">
    56. 			bean>
    57. 		property>
    58. 	bean>
    59.     
    60.  
    61. 	
    62. 	
    63. 	<bean id="redisMessageListener" class="com.gy.xf.listener.RedisMessageListener">
    64. 		<property name="stringRedisTemplate" ref="redisTemplate">property>
    65. 	bean>
    66. 	
    67. 	<bean id="topicContainer" class="org.springframework.data.redis.listener.RedisMessageListenerContainer" destroy-method="destroy">
    68. 		
    69. 		<property name="connectionFactory" ref="jedisConnectionFactory">property>
    70. 		
    71. 		<property name="taskExecutor">
    72. 			<bean class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">
    73. 				<property name="poolSize" value="3">property>
    74. 			bean>
    75. 		property>
    76.  
    77. 		
    78. 		<property name="messageListeners">
    79. 			<map>
    80. 				
    81. 				<entry key-ref="redisMessageListener">
    82. 					
    83. 					<bean class="org.springframework.data.redis.listener.ChannelTopic" >
    84. 						<constructor-arg value="${redis.topicName}">constructor-arg>
    85. 					bean>
    86. 				entry>
    87. 			map>
    88. 		property>
    89. 	bean>
    90.  
    91.  
    92.  
    93.  
    94. beans>

    RedisMessageListener.java

    1. package com.gy.xf.listener;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.fasterxml.jackson.databind.ObjectMapper;
    5. import com.gy.xf.entity.redis.AlarmInfo;
    6. import com.gy.xf.util.RedisCacheUtils;
    7. import com.sun.org.apache.regexp.internal.RE;
    8. import org.apache.commons.lang.StringUtils;
    9. import org.apache.http.HttpEntity;
    10. import org.apache.http.HttpStatus;
    11. import org.apache.http.entity.StringEntity;
    12. import org.apache.http.util.EntityUtils;
    13. import org.slf4j.Logger;
    14. import org.slf4j.LoggerFactory;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.data.redis.connection.Message;
    17. import org.springframework.data.redis.connection.MessageListener;
    18. import org.springframework.data.redis.core.StringRedisTemplate;
    19.  
    20. /**
    21.  * Redis 发布订阅监听类
    22.  */
    23. public class RedisMessageListener implements MessageListener {
    24.  
    25.     private Logger logger = LoggerFactory.getLogger(RedisMessageListener.class);
    26.  
    27. //    @Autowired
    28.     private StringRedisTemplate stringRedisTemplate;// = (StringRedisTemplate) SpringUtil.getBean("stringRedisTemplate");
    29.  
    30.  
    31.     //初始化JSON解析器
    32.     public ObjectMapper mapper = new ObjectMapper();
    33.  
    34.     @Override
    35.     public void onMessage(Message message, byte[] bytes) {
    36.         //获取消息
    37.         byte[] body = message.getBody();
    38.         //使用值序列化器转换
    39.         String msgBody = (String) stringRedisTemplate.getValueSerializer().deserialize(body);
    40.         //获取channel
    41. //        byte[] channel = message.getChannel();
    42. //        String channelName = (String) stringRedisTemplate.getValueSerializer().deserialize(channel);
    43.  
    44.         //渠道名称转换
    45. //        String bytesStr = new String(bytes);
    46.         //logger.info("Redis监听消息：直接获取渠道名称 = " + bytesStr);
    47.         logger.info("警情处理(Redis缓存): 本条消息处理开始.................................");
    48.         AlarmInfo model = JSON.parseObject(msgBody , AlarmInfo.class);
    49.         if (null != model){
    50.             //判断groupId是否在专职队单位id表中
    51.             String groupIdList = RedisCacheUtils.getStr(RedisCacheUtils.KEY_ALARM_GROUPIDS);
    52.             if (!StringUtils.isEmpty(groupIdList)){
    53.                 if(groupIdList.indexOf(model.getGroupId())!=-1){
    54.                     String alarmKey = RedisCacheUtils.KEY_ALARM_GROUPID_PREFIX + model.getGroupId();
    55.                     RedisCacheUtils.set(alarmKey , model.getUploadId() , RedisCacheUtils.KEY_ALARM_TIMEOUT);//0 或 null 标示永不不超时
    56.                     logger.info("警情处理(Redis缓存): 将专职队调派信息写入缓存。groupId:{} , uploadId:{} " , new Object[]{
    57.                           model.getGroupId() , model.getUploadId()
    58.                     });
    59.                 }else{
    60.                     logger.info("警情处理(Redis缓存): 非专职队调派信息，不处理！！！groupId:{} , uploadId:{} " , new Object[]{
    61.                                 model.getGroupId() , model.getUploadId()
    62.                     });
    63. //                    if(model.getGroupId().indexOf(groupIdList)!=-1){
    64. //                        logger.info("警情处理(缓存): 非专职队调派信息，不处理。groupId:{} , uploadId:{} " , new Object[]{
    65. //                                model.getGroupId() , model.getUploadId()
    66. //                        });
    67. //                    }
    68.                 }
    69.             }else{
    70.                 logger.error("警情处理(Redis缓存): 读取专职队单位id缓存数据不存在，请检查！！！");
    71.             }
    72.         }
    73.         logger.info("警情处理(Redis缓存): 本条消息处理完毕.................................");
    74.     }
    75.  
    76.     /**
    77.      * 发送消息
    78.      * https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code
    79.      * @return
    80.      * @throws Exception
    82.     public void sendMessage(String sysId, String postData) {
    83.         try {
    84.             String access_token = CacheUtils.getStr(CacheUtils.KEY_WX_ACCESS_TOKEN);
    85.             if (StringUtils.isEmpty(access_token)){
    86.                 logger.error("Redis监听消息：发送消息,获取 access_token 失败，数据不存在, sysId = {} " , sysId);
    87.             }
    88.             //拼接url
    89.             String url = Constants.GET_TEMPLATE_MESSAGE_PREFIX + "access_token=" + access_token;
    90.             //请求返回结果
    91.             WxRequestReult result = null;
    92.             //请求地址
    93.             //logger.info("发送模板消息给用户 , 请求url = " + url);
    94.             CloseableHttpClient httpClient = HttpClients.custom().build();
    96.             //创建post请求及设置参数
    97.             HttpPost httpPost = new HttpPost(url);
    98.             httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");
    99.             StringEntity stringEntity = new StringEntity(postData , Constants.UTF_8);
    100.             httpPost.setEntity(stringEntity);
    101.             //发送请求
    102.             CloseableHttpResponse response = httpClient.execute(httpPost);
    103.             //设置 post  参数
    104.             final int statusCode = response.getStatusLine().getStatusCode();
    105.             int code = HttpStatus.SC_OK;
    106.             HttpEntity entity = response.getEntity();
    107.             //处理数据
    108.             if (code == statusCode && entity != null) {
    109.                 result = mapper.readValue(EntityUtils.toString(entity) , WxRequestReult.class);
    110.                 response.close();
    111.                 httpClient.close();
    112.             }
    114.             logger.info("Redis监听消息：发送消息 ,  sysId = {} , 请求结果 = {}" , sysId , mapper.writeValueAsString(result) );
    115.             //如果访问失败了则返回 null
    117.         } catch (Exception e){
    118.             e.printStackTrace();
    119.             logger.info("Redis监听消息：发送消息 , sysId = {} , 出现异常 = {}" , sysId , e.getMessage());
    120.         }
    122.     }
    123.      */
    124.  
    125.  
    126.     public StringRedisTemplate getStringRedisTemplate() {
    127.         return stringRedisTemplate;
    128.     }
    129.  
    130.     public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
    131.         this.stringRedisTemplate = stringRedisTemplate;
    132.     }
    133. }

    RedisCacheUtils.java

    1. package com.gy.xf.util;
    2.  
    3. import org.apache.commons.lang.StringUtils;
    4. import org.springframework.data.redis.core.BoundHashOperations;
    5. import org.springframework.data.redis.core.RedisTemplate;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.util.CollectionUtils;
    8.  
    9. import java.util.Map;
    10. import java.util.Set;
    11. import java.util.concurrent.TimeUnit;
    12.  
    13. /**
    14.  * Redis 缓存工具类
    15.  */
    16. public class RedisCacheUtils {
    17.  
    18.     /** Redis 发布订阅模式： 与redis配置文件的redis.topicName一致 */
    19.     public static final String REDIS_CHANNEL_NAME = "message";
    20.  
    21.     /** 固定token:  16位 , Aes加密作为 key 参数 */
    22.     public static final String CSRFTOKEN = "fireoms2021kqxlr";
    23.  
    24.     /**
    25.      * app端登录用户用户唯一id  token key 前缀
    26.      */
    27.     public static final String USER_ID_TOKEN_KEY_PREFIX = "user:lid_";
    28.     /**
    29.      * app端登录用户  token key 前缀
    30.      */
    31.     public static final String USER_TOKEN_KEY_PREFIX = "user:u_";
    32.  
    33.  
    34.     /**
    35.      * app端消息推送用户 token key 前缀
    36.      */
    37.     public static final String PUSH_TOKEN_KEY_PREFIX = "push:u_";
    38.  
    39.  
    40.     //登录用户过期时间（7天后）
    41.     public static final long TOKEN_EXPIRE_TIME_USER = 7 * 24 * 60 * 60;//(用户过期时间)
    42.  
    43.     //单位id列表
    44.     public static final String KEY_ALARM_GROUPIDS = "alarm:groupIds";
    45.     //单位警情数据前缀
    46.     public static final String KEY_ALARM_GROUPID_PREFIX = "alarm:groupId_";
    47.     //redis中key的超时时间
    48.     public static final long KEY_ALARM_TIMEOUT = 12 * 60 * 60;//单位为秒，2小时（7200秒）
    49.  
    50.     /** --------------------- 微信公众平台：Redis 参数 --------------------- */
    51.     //redis中key的超时时间
    52.     public static final long KEY_WX_TIMEOUT = 7200;//单位为秒，2小时
    53.     //公众号中访问access_token: 2小时过期
    54.     public static final String KEY_WX_ACCESS_TOKEN = "wx:access_token";
    55.     //公众号网页开发中的jsapi中请求的票据：2小时过期
    56.     public static final String KEY_WX_TICKET = "wx:ticket";
    57.     //接收公众号消息数据
    58.     public static final String KEY_WX_USER_PREFIX = "wx:u_";
    59.  
    60.     /**
    61.      * 生成签名及判断签名是否相同
    62.      */
    63.     public static boolean isEqualsSignData(String clientSignData, String data){
    64.         String signData = MD5.Md5(data);
    65.         if (clientSignData.equals(signData)){
    66.             return true;
    67.         }
    68.         return false;
    69.     }
    70.  
    71.  
    72.     /** redis操作模板，面向对象的模板 */
    73.     private static StringRedisTemplate stringRedisTemplate
    74.             = (StringRedisTemplate) SpringUtil.getBean("stringRedisTemplate");
    75.     private static RedisTemplate redisTemplate
    76.             = (RedisTemplate) SpringUtil.getBean("redisTemplate");
    77.  
    78.     /**
    79.      * 删除缓存
    80.      * 根据key精确匹配删除
    81.      *
    82.      * @param key
    83.      */
    84.     @SuppressWarnings("unchecked")
    85.     public static void del(String... key) {
    86.         if (key != null && key.length > 0) {
    87.             if (key.length == 1) {
    88.                 redisTemplate.delete(key[0]);
    89.             } else {
    90.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
    91.             }
    92.         }
    93.     }
    94.  
    95.     /**
    96.      * (根据key精确匹配删除)
    97.      * @param key
    98.      */
    99.     public static void deleteByKey(String  key) {
    100.         if (key != null) {
    101.             redisTemplate.delete(key);
    102.         }
    103.     }
    104.  
    105.     /**
    106.      * 批量删除
    107.      * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删）
    108.      *
    109.      * @param pattern
    110.      */
    111.     public void batchDel(String... pattern) {
    112.         for (String kp : pattern) {
    113.             redisTemplate.delete(redisTemplate.keys(kp + "*"));
    114.         }
    115.     }
    116.  
    117.     /**
    118.      * 取得缓存（int型）
    119.      *
    120.      * @param key
    121.      * @return
    122.      */
    123.     public  Integer getInt(String key) {
    124.         String value = stringRedisTemplate.boundValueOps(key).get();
    125.         if (StringUtils.isNotEmpty(value)) {
    126.             return Integer.valueOf(value);
    127.         }
    128.         return null;
    129.     }
    130.  
    131.     /**
    132.      * 取得缓存（字符串类型）
    133.      *
    134.      * @param key
    135.      * @return
    136.      */
    137.     public static String getStr(String key) {
    138.         return stringRedisTemplate.boundValueOps(key).get();
    139.     }
    140.  
    141.     /**
    142.      * 取得缓存（字符串类型）
    143.      *
    144.      * @param key
    145.      * @return
    146.      */
    147.     public static String getStr(String key, boolean retain) {
    148.         String value = stringRedisTemplate.boundValueOps(key).get();
    149.         if (!retain) {
    150.             redisTemplate.delete(key);
    151.         }
    152.         return value;
    153.     }
    154.  
    155.     /**
    156.      * 模糊查询(根据规则) 返回 keys
    157.      * @param pattern
    158.      * @return
    159.      */
    160.     public static Set searchKeys(String pattern){
    161.        return stringRedisTemplate.keys(pattern);
    162.     }
    163.  
    164.  
    165.     /**
    166.      * 获取缓存
    167.      * 注：基本数据类型(Character除外)，请直接使用get(String key, Class clazz)取值
    168.      *
    169.      * @param key
    170.      * @return
    171.      */
    172.     public static Object getObj(String key) {
    173.         return redisTemplate.boundValueOps(key).get();
    174.     }
    175.  
    176.     /**
    177.      * 获取缓存
    178.      * 注：java 8种基本类型的数据请直接使用get(String key, Class clazz)取值
    179.      *
    180.      * @param key
    181.      * @param retain
    182.      *            是否保留
    183.      * @return
    184.      */
    185.     public  Object getObj(String key, boolean retain) {
    186.         Object obj = redisTemplate.boundValueOps(key).get();
    187.         if (!retain) {
    188.             redisTemplate.delete(key);
    189.         }
    190.         return obj;
    191.     }
    192.  
    193.     /**
    194.      * 获取缓存
    195.      * 注：该方法暂不支持Character数据类型
    196.      *
    197.      * @param key
    198.      *            key
    199.      * @param clazz
    200.      *            类型
    201.      * @return
    202.      */
    203.     @SuppressWarnings("unchecked")
    204.     public   T get(String key, Class clazz) {
    205.  
    206.         return (T) redisTemplate.boundValueOps(key).get();
    207.     }
    208.  
    209.     /**
    210.      * 获取缓存json对象
    211.      *
    212.      * @param key
    213.      *            key
    214.      * @param clazz
    215.      *            类型
    216.      * @return
    217.      * @throws Exception
    219.     @SuppressWarnings("unchecked")
    220.     public   T getJson(String key, Class clazz) throws Exception {
    221.         String jsonStr=null;
    222.         jsonStr=stringRedisTemplate.boundValueOps(key).get();
    223.         if(jsonStr==null){
    224.             return null;
    225.         }else{
    226.             return (T) JsonUtil.jsonToBean(jsonStr, clazz);
    227.         }
    228.     } */
    229.  
    230.     /**
    231.      * 将value对象写入缓存
    232.      *
    233.      * @param key
    234.      * @param value
    235.      * @param time
    236.      *            失效时间(秒)
    237.      */
    238.     public static void set(String key, Object value, Long time) {
    239.         if (value.getClass().equals(String.class)) {
    240.             stringRedisTemplate.opsForValue().set(key, value.toString());
    241.         } else if (value.getClass().equals(Integer.class)) {
    242.             stringRedisTemplate.opsForValue().set(key, value.toString());
    243.         } else if (value.getClass().equals(Double.class)) {
    244.             stringRedisTemplate.opsForValue().set(key, value.toString());
    245.         } else if (value.getClass().equals(Float.class)) {
    246.             stringRedisTemplate.opsForValue().set(key, value.toString());
    247.         } else if (value.getClass().equals(Short.class)) {
    248.             stringRedisTemplate.opsForValue().set(key, value.toString());
    249.         } else if (value.getClass().equals(Long.class)) {
    250.             stringRedisTemplate.opsForValue().set(key, value.toString());
    251.         } else if (value.getClass().equals(Boolean.class)) {
    252.             stringRedisTemplate.opsForValue().set(key, value.toString());
    253.         } else {
    254.             redisTemplate.opsForValue().set(key, value);
    255.         }
    256.         if (time != null && time > 0) {
    257.             redisTemplate.expire(key, time, TimeUnit.SECONDS);
    258.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    259.         }
    260.     }
    261.  
    262.     /**
    263.      * 将value对象以JSON格式写入缓存
    264.      *
    265.      * @param key
    266.      * @param value
    267.      * @param time
    268.      *            失效时间(秒)
    270.     public  void setJson(String key, Object value, Long time) {
    271.         stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
    272.         if (time!=null&&time > 0) {
    273.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    274.         }
    275.     }
    276.      */
    277.  
    278.     /**
    279.      * 更新key对象field的值
    280.      *
    281.      * @param key
    282.      *            缓存key
    283.      * @param field
    284.      *            缓存对象field
    285.      * @param value
    286.      *            缓存对象field值
    288.     public  void setJsonField(String key, String field, String value) {
    289.         JSONObject obj = JSON.parseObject(stringRedisTemplate.boundValueOps(key).get());
    290.         obj.put(field, value);
    291.         stringRedisTemplate.opsForValue().set(key, obj.toJSONString());
    292.     }
    293.      */
    294.  
    295.     /**
    296.      * 递减操作
    297.      *
    298.      * @param key
    299.      * @param by
    300.      * @return
    301.      */
    302.     public  double decr(String key, double by) {
    303.         return redisTemplate.opsForValue().increment(key, -by);
    304.     }
    305.  
    306.     /**
    307.      * 递增操作
    308.      *
    309.      * @param key
    310.      * @param by
    311.      * @return
    312.      */
    313.     public  double incr(String key, double by) {
    314.         return redisTemplate.opsForValue().increment(key, by);
    315.     }
    316.  
    317.     /**
    318.      * 获取double类型值
    319.      *
    320.      * @param key
    321.      * @return
    322.      */
    323.     public  double getDouble(String key) {
    324.         String value = stringRedisTemplate.boundValueOps(key).get();
    325.         if (StringUtils.isNotBlank(value)) {
    326.             return Double.valueOf(value);
    327.         }
    328.         return 0d;
    329.     }
    330.  
    331.     /**
    332.      * 设置double类型值
    333.      *
    334.      * @param key
    335.      * @param value
    336.      * @param time
    337.      *            失效时间(秒)
    338.      */
    339.     public  void setDouble(String key, double value, Long time) {
    340.         stringRedisTemplate.opsForValue().set(key, String.valueOf(value));
    341.         if (time!=null&&time > 0) {
    342.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    343.         }
    344.     }
    345.  
    346.     /**
    347.      * 设置double类型值
    348.      *
    349.      * @param key
    350.      * @param value
    351.      * @param time
    352.      *            失效时间(秒)
    353.      */
    354.     public  void setInt(String key, int value, Long time) {
    355.         stringRedisTemplate.opsForValue().set(key, String.valueOf(value));
    356.         if (time!=null&&time > 0) {
    357.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    358.         }
    359.     }
    360.  
    361.     /**
    362.      * 将map写入缓存
    363.      *
    364.      * @param key
    365.      * @param map
    366.      * @param time
    367.      *            失效时间(秒)
    368.      */
    369.     public   void setMap(String key, Map map, Long time) {
    370.         redisTemplate.opsForHash().putAll(key, map);
    371.     }
    372.  
    373.     /**
    374.      * 将map写入缓存
    375.      *
    376.      * @param key
    377.      * @param map
    378.      * @param time
    379.      *            失效时间(秒)
    381.     @SuppressWarnings("unchecked")
    382.     public   void setMap(String key, T obj, Long time) {
    383.         Map map = (Map)JsonUtil.parseObject(obj, Map.class);
    384.         redisTemplate.opsForHash().putAll(key, map);
    385.     }
    386.      */
    387.  
    388.     /**
    389.      * 向key对应的map中添加缓存对象
    390.      *
    391.      * @param key
    392.      * @param map
    393.      */
    394.     public   void addMap(String key, Map map) {
    395.         redisTemplate.opsForHash().putAll(key, map);
    396.     }
    397.  
    398.     /**
    399.      * 向key对应的map中添加缓存对象
    400.      *
    401.      * @param key
    402.      *            cache对象key
    403.      * @param field
    404.      *            map对应的key
    405.      * @param value
    406.      *            值
    407.      */
    408.     public  void addMap(String key, String field, String value) {
    409.         redisTemplate.opsForHash().put(key, field, value);
    410.     }
    411.  
    412.     /**
    413.      * 向key对应的map中添加缓存对象
    414.      *
    415.      * @param key
    416.      *            cache对象key
    417.      * @param field
    418.      *            map对应的key
    419.      * @param obj
    420.      *            对象
    421.      */
    422.     public   void addMap(String key, String field, T obj) {
    423.         redisTemplate.opsForHash().put(key, field, obj);
    424.     }
    425.  
    426.     /**
    427.      * 获取map缓存
    428.      *
    429.      * @param key
    430.      * @param clazz
    431.      * @return
    433.     public   Map mget(String key, Class clazz) {
    434.         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
    435.         return boundHashOperations.entries();
    436.     }*/
    437.  
    438.     /**
    439.      * 获取map缓存中的某个对象
    440.      *
    441.      * @param key
    442.      * @param field
    443.      * @param clazz
    444.      * @return
    445.      */
    446.     @SuppressWarnings("unchecked")
    447.     public   T getMapField(String key, String field, Class clazz) {
    448.         return (T) redisTemplate.boundHashOps(key).get(field);
    449.     }
    450.  
    451.     /**
    452.      * 获取map缓存
    453.      *
    454.      * @param key
    455.      * @param clazz
    456.      * @return
    458.     public   T getMap(String key, Class clazz) {
    459.         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
    460.         Map map = boundHashOperations.entries();
    461.         return JsonUtil.parseObject(map, clazz);
    462.     } */
    463.  
    464.     /**
    465.      * 删除map中的某个对象
    466.      *
    467.      * @author lh
    468.      * @date 2016年8月10日
    469.      * @param key
    470.      *            map对应的key
    471.      * @param field
    472.      *            map中该对象的key
    473.      */
    474.     public void delMapField(String key, String... field) {
    475.         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
    476.         boundHashOperations.delete(field);
    477.     }
    478.  
    479.     /**
    480.      * 指定缓存的失效时间
    481.      *
    482.      * @author FangJun
    483.      * @date 2016年8月14日
    484.      * @param key
    485.      *            缓存KEY
    486.      * @param time
    487.      *            失效时间(秒)
    488.      */
    489.     public  void expire(String key, Long time) {
    490.         if (time!=null&&time > 0) {
    491.             redisTemplate.expire(key, time, TimeUnit.SECONDS);
    492.         }
    493.     }
    494.  
    495.     /**
    496.      * 添加set
    497.      *
    498.      * @param key
    499.      * @param value
    500.      */
    501.     public  void sadd(String key, String... value) {
    502.         redisTemplate.boundSetOps(key).add(value);
    503.     }
    504.  
    505.     /**
    506.      * 删除set集合中的对象
    507.      *
    508.      * @param key
    509.      * @param value
    510.      */
    511.     public  void srem(String key, String... value) {
    512.         redisTemplate.boundSetOps(key).remove(value);
    513.     }
    514.  
    515.     /**
    516.      * set重命名
    517.      *
    518.      * @param oldkey
    519.      * @param newkey
    520.      */
    521.     public  void srename(String oldkey, String newkey) {
    522.         redisTemplate.boundSetOps(oldkey).rename(newkey);
    523.     }
    524.  
    525.  
    526.  
    527.  
    528.     /**
    529.      * 短信缓存
    530.      *
    531.      * @author fxl
    532.      * @date 2016年9月11日
    533.      * @param key
    534.      * @param value
    535.      * @param time
    537.     public  void setIntForPhone(String key, Object value, int time) {
    538.         stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
    539.         if (time > 0) {
    540.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    541.         }
    542.     }
    543.      */
    544.  
    545.     /**
    546.      * 模糊查询keys
    547.      *
    548.      * @param pattern
    549.      * @return
    550.      */
    551.     public static Set keys(String pattern) {
    552.  
    553.         return redisTemplate.keys(pattern);
    554.     }
    555.  
    556.     /**
    557.      *
    558.      * @Description (检查key是否存在，返回boolean值 )
    559.      * @author feizhou
    560.      * @Date 2018年5月29日下午5:37:40
    561.      * @version 1.0.0
    562.      * @param key
    563.      * @return
    564.      */
    565.     public  Boolean   ishasKey(String key) {
    566.         return stringRedisTemplate.hasKey(key);
    567.     }
    568.  
    569. }

    SpringUtil.java

    1. package com.gy.xf.util;
    2.  
    3. import org.springframework.beans.BeansException;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.ApplicationContextAware;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9.  * 工具类 - Spring
    10.  * @author zgp2010
    11.  *
    12.  */
    13.  
    14. public class SpringUtil implements ApplicationContextAware {
    15. 	
    16. 	private static ApplicationContext applicationContext;
    17.  
    18. 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    19. 		SpringUtil.applicationContext = applicationContext;
    20. 	}
    21.  
    22. 	public static ApplicationContext getApplicationContext() {
    23. 		return applicationContext;
    24. 	}
    25.  
    26. 	/**
    27. 	 * 根据Bean名称获取实例
    28. 	 * 
    29. 	 * @param name
    30. 	 *            Bean注册名称
    31. 	 * 
    32. 	 * @return bean实例
    33. 	 * 
    34. 	 * @throws BeansException
    35. 	 */
    36. 	public static Object getBean(String name) throws BeansException {
    37. 		return applicationContext.getBean(name);
    38. 	}
    39. }

    applicationContext.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xmlns:cache="http://www.springframework.org/schema/cache"
    7. 	xmlns:jee="http://www.springframework.org/schema/jee"
    8. 	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    9. 	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    10. 	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    11. 	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
    12.     http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd
    13.     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd" >
    14.  
    15. 	
    16.  
    17. 	<bean name="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean" >
    18.     	 <property name="jndiName" value="java:comp/env/jdbc/MSSQLDS">property>
    19.     bean>
    20. 	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    21. 		<property name="dataSource"><ref bean="dataSource" />property>
    22. 	bean>
    23. 	<bean name="new_dataSource" class="org.springframework.jndi.JndiObjectFactoryBean" >
    24.     	 <property name="jndiName" value="java:comp/env/jdbc/MSSQLDSALARM">property>
    25.     bean>
    26.     <bean id="newjdbcTemple" class="org.springframework.jdbc.core.JdbcTemplate">
    27.         <property name="dataSource" ref="new_dataSource"/>
    28.     bean>
    29. 	<bean id="transactionManager"
    30. 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    31. 		<property name="dataSource"><ref bean="dataSource" />property>
    32. 	bean>
    33. 	<bean id="dataSourceTransactionManager"
    34. 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    35. 		<property name="dataSource"><ref bean="dataSource" />property>
    36. 	bean>
    37. 	<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
    38.  
    39.  
    40.  
    41. 	
    42. 	<bean id="springUtil" class="com.gy.xf.util.SpringUtil" lazy-init="false" />
    43.  
    44.  
    45. 	
    46.  
    47. 	<context:property-placeholder location="classpath*:*.properties">context:property-placeholder>
    48.  
    49.     
    50.     <import resource="com/gy/xf/spring/spring-admin.xml" />
    51.    
    52.  
    53. 	
    54. 	<cache:annotation-driven cache-manager="springCacheManager" proxy-target-class="false"/>
    55. 	<bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
    56. 		<property name="configLocation" value="classpath:ehcache-settings.xml"/>
    57. 		<property name="shared" value="true">property>
    58.  	bean>
    59. 	<bean id="springCacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
    60. 		<property name="cacheManager" ref="ehcacheManager"/>
    61. 	bean>
    62.  
    63.  
    64. 	
    65. 	<import resource="applicationContext-redis.xml">import>
    66.  
    67. beans>

    2、服务端（发布）：
     

    说明：服务端和客户端的redis连接参数都是一样的，这里不再重复贴出配置文件。

    服务端发布内容，用到的是 redisTemplate中的 convertAndSend(String channel, Object message) 方法。只要服务端和客户端配置的channel名字是一样的，服务端发送客户端订阅了就能收到。

    /** Redis 发布订阅模式： 与redis配置文件的redis.topicName一致 */
    public static final String REDIS_CHANNEL_NAME = "message";

    1. public void convertAndSend(String channel, Object message) {
    2.         Assert.hasText(channel, "a non-empty channel is required");
    3.         final byte[] rawChannel = this.rawString(channel);
    4.         final byte[] rawMessage = this.rawValue(message);
    5.         this.execute(new RedisCallback() {
    6.             public Object doInRedis(RedisConnection connection) {
    7.                 connection.publish(rawChannel, rawMessage);
    8.                 return null;
    9.             }
    10.         }, true);
    11.     }
      12.  

      实际用法，在控制器类中或工具类中 注入 RedisTemplate类 或者 StringRedisTemplate 类，在需要发布消息的地方执行 convertAndSend 方法即可。
       

      1.   AlarmInfo model = new AlarmInfo(groupId , uploadId);
      2.   String postData = JSON.toJSONString(model);
      3.   logger.info("地理信息系统调派专职队车辆，参数:{}" , postData);
      4.   stringRedisTemplate.convertAndSend(RedisCacheUtils.REDIS_CHANNEL_NAME , postData);
       

       

      
                
                    
                

                
    12. 

                    相关阅读:
      
                    
Spring @ComponentScan 自定义扫描规则                            
      
【OpenMMLab】AI实战营第二期Day5：MMPretrain代码课                            
      
Win10电脑任务栏没有蓝牙图标的简单解决方法                            
      
chrome安装vue devtools                            
      
基于YOLOV8模型的农作机器和行人目标检测系统（PyTorch+Pyside6+YOLOv8模型）                            
      
搭建Github图床                            
      
C语言用筛选法求 100 之内的素数（挖去 1，被除数平方根）                            
      
python 虚拟环境管理                            
      
面向大规模队列，百万并发的多优先级消费系统设计                            
      
学习在php中将特大数字转成带有千/万/亿为单位的字符串                            
      
                          
                
      13. 
                
    13. 
                    原文地址：https://blog.csdn.net/zgphacker2010/article/details/127136955
                
      14.