spring集成redis

亦凉 2022-05-28 23:44 257阅读 0赞 
  1. sprig集成redis，我的项目架构是springMVC+spring+ibatis 用maven管理 ，下面看代码

1. 在pom文件引入redis依赖包

  1.         <!-- redis集成spring -->
  2.     <dependency>
  3.             <groupId>org.springframework.data</groupId>
  4.             <artifactId>spring-data-redis</artifactId>
  5.             <version>1.4.2.RELEASE</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>redis.clients</groupId>
  10.             <artifactId>jedis</artifactId>
  11.             <version>2.6.2</version>
  12.         </dependency>

2.redis配置文件applicationContext-redis.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans
  3.     xmlns="http://www.springframework.org/schema/beans"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xmlns:context="http://www.springframework.org/schema/context"
  6.     xmlns:p="http://www.springframework.org/schema/p"
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
  9.       default-autowire="byName" >
  10.     <context:property-placeholder location="classpath*:/conf/redis.properties" ignore-unresolvable="true"/> 
  12.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  13.         <property name="maxIdle" value="${redis.maxIdle}" />
  14.         <property name="maxTotal" value="${redis.maxActive}" />
  15.         <property name="maxWaitMillis" value="${redis.maxWait}" />
  16.         <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  17.     </bean>
  19.     <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  20.       <property name="hostName" value="${redis.host}" />
  21.       <property name="port" value="${redis.port}" />
  22.       <property name="password" value="${redis.pass}" />
  23.       <property name="poolConfig" ref="poolConfig" />
  24.     </bean>
  26.     <bean id="stringSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
  27.     <!-- 开启事务，可以通过transcational注解控制 -->
  28.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  29.         <property name="connectionFactory" ref="connectionFactory" />
  30.         <property name="keySerializer" ref="stringSerializer" />
  31.         <property name="enableTransactionSupport" value="true" />
  32.     </bean>
  34. </beans>

3.redis.properties配置文件

  1. redis.host=redis地址
  2. redis.pass=密码
  3. redis.port=6379
  4. redis.maxIdle=300
  5. redis.maxActive=300
  6. redis.maxTotal=600
  7. redis.maxWait=1000
  8. redis.testOnBorrow=true

4. applicationContext.xml配置文件

在项目启动的时候会加载applicationContext-redis.xml文件，但是redis.properties需要配置，如下

  1.     <bean id="config"
  2.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  3.         <property name="locations">
  4.             <list>
  5.                 <value>classpath:/conf/db_mysql.properties</value>
  6.                 <value>classpath:/conf/redis.properties</value>
  7.             </list>
  8.         </property>
  9.     </bean>

5. 创建RedisService工具类，方便调用

  1. package com.base.redis;
  3. import java.io.UnsupportedEncodingException;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import java.util.Map;
  7. import java.util.Set;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.dao.DataAccessException;
  13. import org.springframework.data.redis.connection.RedisConnection;
  14. import org.springframework.data.redis.core.RedisCallback;
  15. import org.springframework.data.redis.core.RedisTemplate;
  16. import org.springframework.data.redis.serializer.JacksonJsonRedisSerializer;
  17. import org.springframework.stereotype.Service;
  19. import com.base.utils.StringUtils;
  21. @Service
  22. public class RedisService {
  24.     private Logger LOG = LoggerFactory.getLogger(RedisService.class);
  26.     @Autowired
  27.     private List<RedisTemplate<String, String>> redisTemplateList;
  29.     @Autowired
  30.     private RedisTemplate<String, String> redisTemplate;
  32.     /**
  33.      * 从缓存中删除指定的key
  34.      * @param keys
  35.      */
  36.     public void del(final String... keys) {
  37.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  38.             try {
  39.                 redisTemplate.execute(new RedisCallback<Long>() {
  40.                     public Long doInRedis(RedisConnection connection) throws DataAccessException {
  41.                         long result = 0;
  42.                         for (int i = 0; i < keys.length; i++) {
  43.                             result = connection.del(keys[i].getBytes());
  44.                         }
  45.                         return result;
  46.                     }
  47.                 });
  49.             } catch (Exception e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }
  53.     }
  55.     /**
  56.      * 重缓存中删除指定的key 模式匹配，效率低
  57.      * @param keys
  58.      */
  59.     public void delByReg(final String... keys) {
  60.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  61.             try {
  62.                 redisTemplate.execute(new RedisCallback<Long>() {
  63.                     public Long doInRedis(RedisConnection connection) throws DataAccessException {
  64.                         long result = 0;
  65.                         for (int i = 0; i < keys.length; i++) {
  66.                             Set<byte[]> keyset = connection.keys((keys[i] + "*").getBytes());
  67.                             for (byte[] key : keyset) {
  68.                                 result = connection.del(key);
  69.                             }
  70.                         }
  71.                         return result;
  72.                     }
  73.                 });
  75.             } catch (Exception e) {
  76.                 e.printStackTrace();
  77.             }
  78.         }
  79.     }
  81.     /**
  82.      * 判断一个键是否存在于缓存中
  83.      * @param key
  84.      * @return
  85.      */
  86.     public boolean exists(final String key) {
  87.         Boolean result = false;
  88.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  89.             try {
  90.                 result = (Boolean) redisTemplate.execute(new RedisCallback<Object>() {
  91.                     public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
  92.                         return connection.exists(key.getBytes());
  93.                     }
  94.                 });
  96.                 if (result) {
  97.                     break;
  98.                 }
  99.             } catch (Exception e) {
  100.                 e.printStackTrace();
  101.             }
  102.         }
  104.         return result;
  105.     }
  107.     /**
  108.      * 向缓存中插入数据
  109.      * @param key
  110.      * @param value
  111.      * @param liveTime
  112.      */
  113.     public void set(final byte[] key, final byte[] value, final long liveTime) {
  114.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  115.             try {
  116.                 redisTemplate.execute(new RedisCallback<Object>() {
  117.                     public Long doInRedis(final RedisConnection connection) throws DataAccessException {
  118.                         connection.set(key, value);
  119.                         if (liveTime > 0) {
  120.                             connection.expire(key, liveTime);
  121.                         }
  122.                         return 1L;
  123.                     }
  124.                 });
  125.             } catch (Exception e) {
  126.                 e.printStackTrace();
  127.             }
  128.         }
  129.     }
  131.     public <T> void set(String key, T value, long liveTime, Class<T> type) {
  132.         if (value == null)
  133.             return;
  134.         try {
  135.             JacksonJsonRedisSerializer<T> serializer = new JacksonJsonRedisSerializer<T>(type);
  136.             byte[] _value = serializer.serialize(value);
  137.             this.set(key.getBytes(), _value, liveTime);
  138.         } catch (Exception e) {
  139.             e.printStackTrace();
  140.         }
  141.     }
  143.     public void set(String key, String value, long liveTime) {
  144.         try {
  145.             this.set(key.getBytes(), value.getBytes("UTF-8"), liveTime);
  146.         } catch (UnsupportedEncodingException e) {
  147.             e.printStackTrace();
  148.         }
  149.     }
  151.     public <T> List<T> lRange(final String key, final Long begin, final Long end, final Class<T> type) {
  152.         return redisTemplate.execute(new RedisCallback<List<T>>() {
  154.             public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
  155.                 JacksonJsonRedisSerializer<T> serializer = new JacksonJsonRedisSerializer<T>(type);
  156.                 List<T> list = new ArrayList<T>();
  157.                 for (byte[] element : connection.lRange(key.getBytes(), begin, end)) {
  158.                     T bean = serializer.deserialize(element);
  159.                     list.add(bean);
  160.                 }
  161.                 return list;
  162.             }
  163.         });
  164.     }
  166.     /**
  167.      * 从缓存中获取数据
  168.      * @param key
  169.      * @return
  170.      */
  171.     public String get(final String key) {
  172.         String cacheValue = "";
  173.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  174.             try {
  175.                 cacheValue = redisTemplate.execute(new RedisCallback<String>() {
  176.                     public String doInRedis(RedisConnection connection) throws DataAccessException {
  177.                         try {
  178.                             byte[] cacheBytes = connection.get(key.getBytes());
  179.                             if (cacheBytes != null) {
  180.                                 String cacheStr = new String(cacheBytes, "utf-8");
  181.                                 return cacheStr;
  182.                             }
  183.                         } catch (Exception e) {
  184.                             LOG.info(e.getMessage());
  185.                         }
  186.                         return "";
  187.                     }
  188.                 });
  189.                 if (!StringUtils.isEmpty(cacheValue))
  190.                     break;
  191.             } catch (Exception e) {
  192.                 e.printStackTrace();
  193.             }
  194.         }
  195.         return cacheValue;
  196.     }
  198.     public <T> T get(final String key, final Class<T> clazz) {
  199.         T t = null;
  200.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  201.             t = redisTemplate.execute(new RedisCallback<T>() {
  202.                 public T doInRedis(RedisConnection connection) throws DataAccessException {
  203.                     byte[] data = connection.get(key.getBytes());
  204.                     if (data != null)
  205.                         return new JacksonJsonRedisSerializer<T>(clazz).deserialize(data);
  206.                     return null;
  207.                 }
  208.             });
  210.             if (t != null)
  211.                 break;
  212.         }
  213.         return t;
  214.     }
  216.     public <T> Long rPush(final String key, final List<T> list, final Class<T> type, final long expire) {
  217.         if (list == null) {
  218.             return 0L;
  219.         }
  220.         return redisTemplate.execute(new RedisCallback<Long>() {
  222.             public Long doInRedis(RedisConnection connection) throws DataAccessException {
  223.                 JacksonJsonRedisSerializer<T> serializer = new JacksonJsonRedisSerializer<T>(type);
  224.                 connection.multi();
  225.                 for (T value : list) {
  226.                     connection.rPush(key.getBytes(), serializer.serialize(value));
  227.                 }
  228.                 if (expire > 0) {
  229.                     connection.expire(key.getBytes(), expire);
  230.                 }
  231.                 connection.exec();
  232.                 return new Long(list.size());
  233.             }
  235.         });
  236.     }
  238.     /**
  239.      * 清空缓存
  240.      */
  241.     public void flushDB() {
  242.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  243.             try {
  244.                 redisTemplate.execute(new RedisCallback<String>() {
  245.                     public String doInRedis(RedisConnection connection) throws DataAccessException {
  246.                         connection.flushDb();
  247.                         return "ok";
  248.                     }
  249.                 });
  250.             } catch (Exception e) {
  251.                 e.printStackTrace();
  252.             }
  253.         }
  254.     }
  256.     /**
  257.      * 添加至有序集合
  258.      * @param key
  259.      * @param score
  260.      * @param value
  261.      */
  262.     public void zadd(final byte[] key, final double score, final byte[] value) {
  263.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  264.             try {
  265.                 redisTemplate.execute(new RedisCallback<String>() {
  266.                     public String doInRedis(RedisConnection connection) throws DataAccessException {
  267.                         connection.zAdd(key, score, value);
  268.                         return "ok";
  269.                     }
  270.                 });
  271.             } catch (Exception e) {
  272.                 e.printStackTrace();
  273.             }
  274.         }
  275.     }
  277.     /**
  278.      * 按条件获取有序集合元素子集
  279.      * @param key
  280.      *            有序集合key
  281.      * @param min
  282.      *            范围最小值
  283.      * @param max
  284.      *            范围最大值
  285.      * @param offset
  286.      *            从第0ffset+1个元素起
  287.      * @param count
  288.      *            返回上限
  289.      * @return
  290.      */
  291.     public Set<byte[]> zRangeByScore(final byte[] key, final double min, final double max, final long offset,
  292.             final long count) {
  293.         Set<byte[]> set = null;
  294.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  295.             try {
  296.                 set = redisTemplate.execute(new RedisCallback<Set<byte[]>>() {
  298.                     public Set<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
  299.                         return connection.zRangeByScore(key, min, max, offset, count);
  300.                     }
  302.                 });
  303.                 if (set != null) {
  304.                     break;
  305.                 }
  306.             } catch (Exception e) {
  307.                 e.printStackTrace();
  308.             }
  309.         }
  310.         return set;
  311.     }
  313.     /**
  314.      * 添加指定map至缓存
  315.      * @param key map唯一标识
  316.      * @param hashes
  317.      */
  318.     @SuppressWarnings({ "unchecked", "rawtypes" })
  319.     public void hMSet(final byte[] key, final Map<byte[], byte[]> hashes) {
  320.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  321.             try {
  322.                 redisTemplate.execute(new RedisCallback() {
  323.                     public Object doInRedis(RedisConnection connection) throws DataAccessException {
  324.                         connection.hMSet(key, hashes);
  325.                         return null;
  326.                     }
  327.                 });
  329.             } catch (Exception e) {
  330.                 e.printStackTrace();
  331.             }
  332.         }
  333.     }
  335.     /**
  336.      * 获取指定map中指定键对应的值列表
  337.      * @param key map的唯一标识
  338.      * @param fields 键数组
  339.      * @return 值数组
  340.      */
  341.     public List<byte[]> hMGet(final byte[] key, final byte[]... fields) {
  342.         List<byte[]> cacheValue = null;
  343.         for (RedisTemplate<String, String> redisTemplate : redisTemplateList) {
  344.             try {
  345.                 cacheValue = redisTemplate.execute(new RedisCallback<List<byte[]>>() {
  346.                     public List<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
  347.                         return connection.hMGet(key, fields);
  348.                     }
  349.                 });
  350.                 if (cacheValue != null) {
  351.                     break;
  352.                 }
  353.             } catch (Exception e) {
  354.                 e.printStackTrace();
  355.             }
  356.         }
  357.         return cacheValue;
  358.     }
  360.     // getters and setters
  361.     public List<RedisTemplate<String, String>> getRedisTemplateList() {
  362.         return redisTemplateList;
  363.     }
  365.     public void setRedisTemplateList(List<RedisTemplate<String, String>> redisTemplateList) {
  366.         this.redisTemplateList = redisTemplateList;
  367.     }
  369. }

接下来就是调用了，跟普通的service的使用方法是一样的。

发表评论

表情：
评论列表 （有 0 条评论，257人围观）

还没有评论，来说两句吧...

相关阅读

    相关 spring集成redis

        sprig集成redis，我的项目架构是springMVC+spring+ibatis 用maven管理 ，下面看代码 1. 在pom文件引入redis依赖包

    亦凉亦凉/ 0 赞/ 258 阅读

    相关 Spring集成Redis

    最近在做一个关于群聊的项目，由于聊天要求实时性，不可能直接访问数据库，所以使用了Redis来做缓存，这里将使用过程中遇到的问题记录一下。 使用Redis之前需要合理设计存储

    阳光穿透心脏的1/2处阳光穿透心脏的1/2处/ 0 赞/ 311 阅读