Spring4.0整合Redis实用示例

上篇我们介绍了redis数据的安装与使用,以及顺便介绍了redis一款可视化工具，所以这篇我们开始介绍Spring4.0与Redis的整合,通过两种方式来示例Redis的使用,一种是AOP方式,对所有满足表达式的类与方法进行redis缓存，另一种是使用自定义注解方式达到灵活配置自己需要注解的方法。下面将慢慢介绍如何从一步一步的整合与使用，本文所示范的项目框架为：spring4.0+SpringMVC+Mybatis3.0+CXF+Redis+Maven,此文章仅展示spring+redis整合。

一、Redis介绍

什么是Redis？
      redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
它有什么特点？
（1）Redis数据库完全在内存中，使用磁盘仅用于持久性。
（2）相比许多键值数据存储，Redis拥有一套较为丰富的数据类型。
（3）Redis可以将数据复制到任意数量的从服务器。
Redis 优势？
 （1）异常快速：Redis的速度非常快，每秒能执行约11万集合，每秒约81000+条记录。
 （2）支持丰富的数据类型：Redis支持最大多数开发人员已经知道像列表，集合，有序集合，散列数据类型。这使得它非常容易解决各种各样的问题，因为我们知道哪些问题是可以处理通过它的数据类型更好。
（3）操作都是原子性：所有Redis操作是原子的，这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
（4）多功能实用工具：Redis是一个多实用的工具，可以在多个用例如缓存，消息，队列使用(Redis原生支持发布/订阅)，任何短暂的数据，应用程序，如Web应用程序会话，网页命中计数等。
Redis 缺点？
（1）单线程
（2）耗内存

二、实用范例

1.maven中引入jar包

<!-- redis缓存依赖 -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.6.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.7.3</version>
		</dependency>

2.配置Bean,在application.xml中增加相关配置

<!--加载数据库文件，读取数据库相关信息,加载redis配置信息 -->
	<context:property-placeholder location="classpath:redis.properties" />

<!-- jedis 连接池配置 -->
	<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>
	<!-- redis 连接工厂 -->
	<bean id="connectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="poolConfig" ref="poolConfig" />
		<property name="port" value="${redis.port}" />
		<property name="hostName" value="${redis.host}" />
		<!-- <property name="password" value="${redis.password}" /> -->
		<property name="timeout" value="${redis.timeout}"></property>
	</bean>
	<!-- redis操作模板，这里采用尽量面向对象的模板 -->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="connectionFactory" />
		<!-- 如果不配置Serializer，那么存储的时候只能使用String，如果用对象类型存储，那么会提示错误 can't cast to String！！！ -->
		<property name="keySerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
		</property>
	</bean>

	<!-- cache配置 -->
	<bean id="methodCacheInterceptor" class="com.idream.ishare.common.interceptor.MethodCacheInterceptor">
		<property name="redisUtil" ref="redisUtil" />
	</bean>
	<bean id="redisUtil" class="com.idream.ishare.common.utils.RedisUtil">
		<property name="redisTemplate" ref="redisTemplate" />
	</bean>

其中对应的redis.properties配置如下

#redis center
redis.host=127.0.0.1
redis.port=6379
#redis.password=123456
redis.maxIdle=100
redis.maxActive=300
redis.maxWait=1000
redis.testOnBorrow=true
redis.timeout=100000
  
# no cache class
#targetNames=xxxRecordManager,xxxSetRecordManager,xxxStatisticsIdentificationManager 
targetNames=
# no cache method
methodNames= 
  
# cache failure time(s)
#com.service.impl.xxxRecordManager= 60
#com.service.impl.xxxSetRecordManager= 60
defaultCacheExpireTime=100

fep.local.cache.capacity =10000

3.增加相应的工具类与AOP切面类

1）RedisUtil：用来缓存和去除数据的实例

/**
 * redis cache 工具类
 * 
 */
public final class RedisUtil {

	private RedisTemplate<Serializable, Object> redisTemplate;

	/**
	 * 批量删除对应的value
	 * 
	 * @param keys
	 */
	public void remove(final String... keys) {
		for (String key : keys) {
			remove(key);
		}
	}

	/**
	 * 批量删除key
	 * 
	 * @param pattern
	 */
	public void removePattern(final String pattern) {
		Set<Serializable> keys = redisTemplate.keys(pattern);
		if (keys.size() > 0)
			redisTemplate.delete(keys);
	}

	/**
	 * 删除对应的value
	 * 
	 * @param key
	 */
	public void remove(final String key) {
		if (exists(key)) {
			redisTemplate.delete(key);
		}
	}

	/**
	 * 判断缓存中是否有对应的value
	 * 
	 * @param key
	 * @return
	 */
	public boolean exists(final String key) {
		return redisTemplate.hasKey(key);
	}

	/**
	 * 读取缓存
	 * 
	 * @param key
	 * @return
	 */
	public Object get(final String key) {
		Object result = null;
		ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
		result = operations.get(key);
		return result;
	}

	/**
	 * 写入缓存
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(final String key, Object value) {
		boolean result = false;
		try {
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			operations.set(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 写入缓存
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(final String key, Object value, Long expireTime) {
		boolean result = false;
		try {
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			operations.set(key, value);
			redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	public void setRedisTemplate(RedisTemplate<Serializable, Object> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}
}

2)MethodCacheInterceptor
切面MethodCacheInterceptor，对application.xml配置AOP切面中符合切面的类与方法进行拦截，同时加入判断如果缓存存在数据，从缓存取数据。否则第一次从数据库取，并将结果保存到缓存 中去

public class MethodCacheInterceptor implements MethodInterceptor {

	private Logger logger = LoggerFactory.getLogger(MethodCacheInterceptor.class);

	private RedisUtil redisUtil;
	private List<String> targetNamesList; // 不加入缓存的service名称
	private List<String> methodNamesList; // 不加入缓存的方法名称
	private Long defaultCacheExpireTime; // 缓存默认的过期时间

	/**
	 * 初始化读取不需要加入缓存的类名和方法名称
	 */
	public MethodCacheInterceptor() {
		try {
			if (logger.isInfoEnabled()) {
				logger.info("进入redis缓存切面类,MethodCacheInterceptor");
				logger.info("读取redis配置文件redis.properties,其绝对路劲为:"
						+ MethodCacheInterceptor.class.getResource("/redis.properties").getFile());
			}
			File f = new File(MethodCacheInterceptor.class.getResource("/redis.properties").getFile());
			// 配置文件位置直接被写死，有需要自己修改下
			InputStream in = new FileInputStream(f);
			Properties p = new Properties();
			p.load(in);
			// 分割字符串
			String[] targetNames = p.getProperty("targetNames").split(",");
			String[] methodNames = p.getProperty("methodNames").split(",");

			// 加载过期时间设置
			defaultCacheExpireTime = Long.valueOf(p.getProperty("defaultCacheExpireTime"));
			// 创建list
			targetNamesList = new ArrayList<String>(targetNames.length);
			methodNamesList = new ArrayList<String>(methodNames.length);
			Integer maxLen = targetNames.length > methodNames.length ? targetNames.length : methodNames.length;
			// 将不需要缓存的类名和方法名添加到list中
			for (int i = 0; i < maxLen; i++) {
				if (i < targetNames.length) {
					targetNamesList.add(targetNames[i]);
				}
				if (i < methodNames.length) {
					methodNamesList.add(methodNames[i]);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		
		if (logger.isInfoEnabled()) {
			logger.info("进入redis缓存切面类的invoke方法,MethodCacheInterceptor.invoke(invocation)");
		}
		
		Object value = null;

		String targetName = invocation.getThis().getClass().getName();
		String methodName = invocation.getMethod().getName();
		
		Boolean isNeedCache=isAddCache(targetName, methodName);
		if (logger.isInfoEnabled()) {
			logger.info("判断当前类和方法是否不需要缓存(配置文件中设定有默认的非缓存类和方法),是否需要缓存:"+isNeedCache);
		}
		if (!isNeedCache) {
			// 若不需要缓存则执行方法返回结果
			return invocation.proceed();
		}
		Object[] arguments = invocation.getArguments();
		String key = getCacheKey(targetName, methodName, arguments);
		if (logger.isInfoEnabled()) {
			logger.info("获取缓存key="+key);
		}
		try {
			if (logger.isInfoEnabled()) {
				logger.info("判断是否存在缓存,isExist:"+redisUtil.exists(key));
			}
			// 判断是否有缓存
			if (redisUtil.exists(key)) {
				if (logger.isInfoEnabled()) {
					logger.info("若该key对应的缓存已存在,则直接返回缓存值,value="+redisUtil.get(key));
				}
				return redisUtil.get(key);
			}
			// 写入缓存
			value = invocation.proceed();
			if (logger.isInfoEnabled()) {
				logger.info("若该key对应的缓存不存在,则反射获取当前方法返回结果作为该key的缓存值value="+value);
			}
			if (value != null) {
				final String tkey = key;
				final Object tvalue = value;
				new Thread(new Runnable() {
					@Override
					public void run() {
						if (logger.isInfoEnabled()) {
							logger.info("写入当前key对应的value,{key:"+tkey+",value:"+tvalue+"}");
						}
						redisUtil.set(tkey, tvalue, defaultCacheExpireTime);

					}
				}).start();
			}
		} catch (Exception e) {
			e.printStackTrace();
			if (value == null) {
				return invocation.proceed();
			}
		}
		return value;
	}

	/**
	 * 是否加入缓存
	 * 
	 * @return
	 */
	private boolean isAddCache(String targetName, String methodName) {
		boolean flag = true;
		if (targetNamesList.contains(targetName) || methodNamesList.contains(methodName)) {
			flag = false;
		}
		return flag;
	}

	/**
	 * 创建缓存key
	 * 
	 * @param targetName
	 * @param methodName
	 * @param arguments
	 */
	private String getCacheKey(String targetName, String methodName, Object[] arguments) {
		StringBuffer sbu = new StringBuffer();
		sbu.append(targetName).append("_").append(methodName);
		if ((arguments != null) && (arguments.length != 0)) {
			for (int i = 0; i < arguments.length; i++) {
				sbu.append("_").append(arguments[i]);
			}
		}
		return sbu.toString();
	}

	public void setRedisUtil(RedisUtil redisUtil) {
		this.redisUtil = redisUtil;
	}
}

4.最后我们开始配置xml以确定那些类与方法需要进行缓存
1)方式一：AOP切面方式,在application.xml中增加如下AOP配置

<aop:config>
		<aop:pointcut id="redisMethodCachePointcut"
			expression="execution(* com.idream.ishare.*.service.impl.*.*(..))" />
		<aop:advisor advice-ref="methodCacheInterceptor"
			pointcut-ref="redisMethodCachePointcut" />
	</aop:config>

由上可知我们是对符合expression表达式的所有类与方法都进行缓存。(至此,AOP切面方式的spring与redis集成已全部完毕,下面测试中会给出相应示例)

2)方式二：使用自定义注解的方式来灵活标识那些方法需要惊醒Redis缓存

首先我们需要添加自定义注解RedisCache

/**
 * redis缓存
 * @author HASEE
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCache {
	
	/**
	 * key
	 * @return
	 */
	String key() default "";
	
	/**
	 * value
	 * @return
	 */
	String value() default "";
	
}

然后在application.xml中增加对该注解的过滤匹配,标识所有添加注解的方法都需要缓存

<aop:config>
		<aop:pointcut id="redisMethodCachePointcut"
			expression="@annotation(com.idream.ishare.common.annotation.RedisCache)" />
		<aop:advisor advice-ref="methodCacheInterceptor"
			pointcut-ref="redisMethodCachePointcut" />
	</aop:config>

最后在我们需要缓存的方法中增加注解即可

@RedisCache
	public DataResult<UserRegistVO> queryUserByName(String userAccount) {
		DataResult<UserRegistVO> dataResult = new DataResult<UserRegistVO>();
		UserRegistVO userRegistVO=new UserRegistVO();
		if (!StringUtils.isEmpty(userAccount)) {
			userRegistVO.setUserAccount(userAccount);
			UserRegistVO uRegistVO = registerDao.queryUserByName(userRegistVO);
			dataResult.setData(uRegistVO);
			if (uRegistVO != null) {
				dataResult.setMsgCode(200);
				dataResult.setMessage("该用户已存在");
			} else {
				dataResult.setMsgCode(404);
				dataResult.setMessage("该用户不存在"); 
			}
		} else {
			dataResult.setData(userRegistVO);
			dataResult.setMsgCode(500);
			dataResult.setMessage("请检查用户名是否输入");
		}
		return dataResult;
	}

至此,在项目中,有该注解的地方才会使用缓存，没有注解的地方与普通的方法一样。
个人比较推荐第二种方式来进行redis缓存配置,原因就不用多说。

三、redis测试
1.首先我们测试AOP方式,将以下两个方法均请求一次,看控制台输出日志

控制台输出

通过日志我们可以看到,AOP的方式对于两个方法均进行了缓存判断,即使用缓存


2.我们测试自定义注解方式,将以下两个方法均请求一次(与AOP不同的是,这次仅在queryUserByName方法中增加@RedisCache注解),看控制台输出日志

控制台日志输出

在这一次测试中,仅有添加了注解的方法才进入的缓存，没有注解的方法与普通方法一样。

最后我们看使用缓存后所达到的效果(此处使用注解方式所打印的日志)

第一次请求的时候判断是否存在缓存的时候结果为false，然后查询数据将查询的将结果写入了缓存中；
第二次请求的时候判断是否存在缓存的时候结果为true，然后直接返回缓存中的结果集。


至此我们介绍完了Spring集成Redis.