用spring管理redis缓存，使框架更加优雅

一、配置maven的pom.xml 文件

    	<!-- redis -->
	<dependency>
	  <groupId>redis.clients</groupId>
	  <artifactId>jedis</artifactId>
	  <version>2.8.1</version>
	</dependency>
        <dependency>  
         <groupId>org.springframework.data</groupId>  
         <artifactId>spring-data-redis</artifactId>  
         <version>1.5.0.RELEASE</version>  
       </dependency>

二、配置applicationContext.xml文件

	<!-- cache manager -->
	<cache:annotation-driven cache-manager="cacheManager" /> 
	
	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
		<property name="caches">
			<set>
				<ref bean="cache"/>
			</set>
		</property>
	</bean>
	
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
           <property name="connectionFactory"   ref="jedisConnectionFactory" />
    </bean>
    
    <bean id="cache" class="com.gccode.springsession.cache.RedisCache">
           <property name="redisTemplate" ref="redisTemplate" />
           <property name="name" value="default"/>
    </bean>

三、重写spring cache的实现方法

package com.gccode.springsession.cache;

import org.springframework.cache.Cache;

/**
 * Title: 继承spring cache
 *
 */
public interface BaseCache extends Cache{
	
	/**
	  * 
	  * @param key
	  * @param value
	  * @param time
	  */
	 public void put(Object key, Object value ,int time);
}

package com.gccode.springsession.cache;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

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;

/**
 * Title: 实现并重写spring cache 的方法
 */
public class RedisCache implements BaseCache{

	private RedisTemplate<String, Object> redisTemplate;
	
	private String name;
	
	private int timeout;
	
	public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }
	
	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
	

	public int getTimeout() {
		return timeout;
	}

	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public Object getNativeCache() {
		// TODO Auto-generated method stub
		return this.redisTemplate;
	}

	@Override
	public ValueWrapper get(Object key) {
		// TODO Auto-generated method stub
		 final String keyf = (String) key;
	        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, final int timeout) {
		// TODO Auto-generated method stub
        final String keyf = (String) key;
        final Object valuef = value;
        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 (timeout > 0) {
                    connection.expire(keyb, timeout);
                }
                return 1L;
            }
        });
	}

	@Override
    public void put(Object key, Object value) {
        // TODO Auto-generated method stub
        final String keyf = (String) key;
        final Object valuef = value;
        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 (timeout > 0) {
                    connection.expire(keyb, timeout);
                }
                return 1L;
            }
        });
    }



	@Override
    public void evict(Object key) {
        // TODO Auto-generated method stub
        final String keyf = (String) key;
        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
		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;
	}
	
    /**
     * 将对象转化为字节流数组 <br>
     *
     * @param obj
     * @return
     */
    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;
    }
	
	/**
     * 将字节流数据转化为对象 <br>
     * 
     *
     * @param bytes
     * @return
     */
    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;
    }
}

四、调用，在所需的类中引入即可

	@Resource(name="cache")
	private BaseCache cache;