spring系列---SpringDataRedis使用

2019年10月2日 145次阅读来源: source

SpringDataRedis简介

1项目常见问题思考

当每天大量流量访问系统的时候会对系统早上大量的压力 解决方式之一就是缓存,另一种是网页静态化。今天我先贴出第一种方法的配置第二种方法日后再发布。

2 Redis官网介绍

redis是一款开源的Key-Value数据库，运行在内存中，由ANSI C编写。企业开发通常采用Redis来实现缓存。同类的产品还有memcache 、memcached 、MongoDB等。
本人的网络官网访问不了 先看中文的吧

3 Jedis

Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。

4 Spring Data Redis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis,  JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。

spring-data-redis针对jedis提供了如下功能：

连接池自动管理，提供了一个高度封装的“RedisTemplate”类
针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
- ValueOperations：简单K-V操作
- SetOperations：set类型数据操作
- ZSetOperations：zset类型数据操作
- HashOperations：针对map类型的数据操作
- ListOperations：针对list类型的数据操作

5 准备工作

（1）构建Maven工程 spring_data_redis_demo

（2）引入Spring相关依赖、引入JUnit依赖（内容参考资料中配置文件）

（3）引入Jedis和SpringDataRedis依赖

pom.xml

<!-- 缓存 -->
       <dependency>
           <groupId>redis.clients</groupId>
           <artifactId>jedis</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.data</groupId>
           <artifactId>spring-data-redis</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.data</groupId>
           <artifactId>spring-data-commons</artifactId>
           <version>1.8.4.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.apache.commons</groupId>
           <artifactId>commons-pool2</artifactId>
       </dependency>

spring/applicationContext-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd   
            http://www.springframework.org/schema/context   
            http://www.springframework.org/schema/context/spring-context.xsd   ">

    <context:property-placeholder location="classpath*:properties/*.properties"/>

    <!-- redis 相关配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>

    <bean id="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="JedisConnectionFactory"/>
    </bean>

</beans>

maxIdle ：最大空闲数
maxWaitMillis:连接时的最大等待毫秒数
testOnBorrow：在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的；

properties/redis-config.properties 工具类

# Redis settings 
# server IP 
redis.host=127.0.0.1
# server port 
redis.port=6379
# server pass 
redis.pass=
# use dbIndex 
redis.database=0
# 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例
redis.maxIdle=300
#表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间(毫秒)，则直接抛出JedisConnectionException；
redis.maxWait=3000
# 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的  
redis.testOnBorrow=true

utils.RedisCache

package utils;
import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
  
import org.springframework.cache.Cache; 
import org.springframework.cache.support.SimpleValueWrapper; 
import org.springframework.dao.DataAccessException; 
import org.springframework.data.redis.connection.RedisConnection; 
import org.springframework.data.redis.core.RedisCallback; 
import org.springframework.data.redis.core.RedisTemplate;
//    Redis缓存管理类
// @author Administrator
public class RedisCache implements Cache{

      private RedisTemplate<String, Object> redisTemplate;  
      private String name;  
      public RedisTemplate<String, Object> getRedisTemplate() { 
        return redisTemplate;  
      } 
         
      public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { 
        this.redisTemplate = redisTemplate;  
      } 
         
      public void setName(String name) { 
        this.name = name;  
      } 
         
      @Override 
      public String getName() { 
        // TODO Auto-generated method stub  
        return this.name;  
      } 
      
      @Override 
      public Object getNativeCache() { 
       // TODO Auto-generated method stub  
        return this.redisTemplate;  
      } 
       
      @Override 
      public ValueWrapper get(Object key) { 
       // TODO Auto-generated method stub 
       System.out.println("get key"); 
       final String keyf = key.toString(); 
       Object object = null; 
       
       
       object = redisTemplate.execute(new RedisCallback<Object>() { 
       public Object doInRedis(RedisConnection connection)  
             throws DataAccessException { 
         byte[] key = keyf.getBytes(); 
         byte[] value = connection.get(key); 
         if (value == null) { 
           return null; 
          } 
         return toObject(value); 
         } 
        }); 
        return (object != null ? new SimpleValueWrapper(object) : null); 
       } 
       
       @Override 
       public void put(Object key, Object value) { 
        // TODO Auto-generated method stub 
        System.out.println("put key"); 
        final String keyf = key.toString();  
        final Object valuef = value;  
        final long liveTime = 86400;  
        redisTemplate.execute(new RedisCallback<Long>() {  
          public Long doInRedis(RedisConnection connection)  
              throws DataAccessException {  
            byte[] keyb = keyf.getBytes();  
            byte[] valueb = toByteArray(valuef);  
            connection.set(keyb, valueb);  
            if (liveTime > 0) {  
              connection.expire(keyb, liveTime);  
             }  
            return 1L;  
           }  
         });  
       } 
      
       private byte[] toByteArray(Object obj) {  
         byte[] bytes = null;  
         ByteArrayOutputStream bos = new ByteArrayOutputStream();  
         try {  
          ObjectOutputStream oos = new ObjectOutputStream(bos);  
          oos.writeObject(obj);  
          oos.flush();  
          bytes = bos.toByteArray();  
          oos.close();  
          bos.close();  
         }catch (IOException ex) {  
            ex.printStackTrace();  
         }  
         return bytes;  
        }  
      
        private Object toObject(byte[] bytes) { 
         Object obj = null;  
          try { 
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);  
            ObjectInputStream ois = new ObjectInputStream(bis);  
            obj = ois.readObject();  
            ois.close();  
            bis.close();  
          } catch (IOException ex) {  
            ex.printStackTrace();  
          } catch (ClassNotFoundException ex) {  
            ex.printStackTrace();  
          }  
          return obj;  
        } 
       
        @Override 
        public void evict(Object key) {  
         // TODO Auto-generated method stub  
         System.out.println("del key"); 
         final String keyf = key.toString();  
         redisTemplate.execute(new RedisCallback<Long>() {  
         public Long doInRedis(RedisConnection connection)  
              throws DataAccessException {  
           return connection.del(keyf.getBytes());  
          }  
         });  
        } 
       
        @Override 
        public void clear() {  
          // TODO Auto-generated method stub  
          System.out.println("clear key"); 
          redisTemplate.execute(new RedisCallback<String>() {  
            public String doInRedis(RedisConnection connection)  
                throws DataAccessException {  
             connection.flushDb();  
              return "ok";  
            }  
          });  
        } 
      
        @Override
        public <T> T get(Object key, Class<T> type) { 
          // TODO Auto-generated method stub 
          return null; 
        } 
        
        @Override
        public ValueWrapper putIfAbsent(Object key, Object value) { 
          // TODO Auto-generated method stub 
          return null; 
        } 
}

    原文作者：source
    原文地址: https://segmentfault.com/a/1190000016359875
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。