redis集成到Springmvc中及使用实例

redis是现在主流的缓存工具了,因为使用简单、高效且对服务器要求较小,用于大数据量下的缓存

spring也提供了对redis的支持: org.springframework.data.redis.core.RedisTemplate

为了在springmvc环境中使用redis,官方推荐是和jedis结合使用,由jedis来管理连接这些

首先进行整合配置

1.properties文件

#############Common Redis configuration
cache.redis.maxIdle=5
cache.redis.maxActive=20
cache.redis.maxWait=1000
cache.redis.testOnBorrow=true ##############Redis configuration
cache.redis.host=127.0.0.1
cache.redis.port=6379
cache.redis.password=
cache.redis.db=0
cache.redis.timeout=2000 ##############
cache.cacheExpire=500

2.xml配置文档

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${cache.redis.maxActive}" />
<property name="maxIdle" value="${cache.redis.maxIdle}" />
<property name="maxWaitMillis" value="${cache.redis.maxWait}" />
<property name="testOnBorrow" value="${cache.redis.testOnBorrow}" />
</bean> <bean id="redisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="usePool" value="true"></property>
<property name="hostName" value="${cache.redis.host}" />
<property name="port" value="${cache.redis.port}" />
<property name="password" value="${cache.redis.password}" />
<property name="timeout" value="${cache.redis.timeout}" />
<property name="database" value="${cache.redis.db}"></property>
<constructor-arg index="0" ref="jedisPoolConfig" />
</bean> <bean id="redisCache" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="redisConnectionFactory" />
<property name="keySerializer" ref="stringRedisSerializer" />
<property name="valueSerializer" ref="stringRedisSerializer" />
<property name="hashKeySerializer" ref="stringRedisSerializer" />
<property name="hashValueSerializer" ref="stringRedisSerializer" />
</bean> <bean id="stringRedisSerializer"
class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</beans>

3.使用实例之,存入到redis

package net.zicp.xiaochangwei.web.cache;

import java.util.List;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit; import net.zicp.xiaochangwei.web.dao.CityDao;
import net.zicp.xiaochangwei.web.dao.FeedBackDao;
import net.zicp.xiaochangwei.web.dao.HobbyDao;
import net.zicp.xiaochangwei.web.dao.PhotoDao;
import net.zicp.xiaochangwei.web.dao.RolePermissionDao;
import net.zicp.xiaochangwei.web.dao.UserDao;
import net.zicp.xiaochangwei.web.entity.City;
import net.zicp.xiaochangwei.web.entity.Hobby;
import net.zicp.xiaochangwei.web.entity.HobbyType;
import net.zicp.xiaochangwei.web.entity.Permission;
import net.zicp.xiaochangwei.web.entity.Photos;
import net.zicp.xiaochangwei.web.entity.Role;
import net.zicp.xiaochangwei.web.entity.UserInfo;
import net.zicp.xiaochangwei.web.utils.Constant;
import net.zicp.xiaochangwei.web.utils.NamedThreadFactory; import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component; import com.alibaba.fastjson.JSON; /**
*
* @author xiaochangwei
* redis缓存变动较少的数据并定时刷新
*/
@Component
public class BasicDataCacheLoader implements InitializingBean, DisposableBean { private final Logger log = LoggerFactory.getLogger(this.getClass()); protected static final int CORE_SIZE = Runtime.getRuntime().availableProcessors() * 2; @Value("${cache.cacheExpire}")
private long cacheExpire; private ScheduledThreadPoolExecutor executor = null; @Autowired
private RedisTemplate<String, String> redisCache; @Autowired
private FeedBackDao feedBackDao; @Autowired
private RolePermissionDao rolePermissionDao; @Autowired
private CityDao cityDao; @Autowired
private HobbyDao hobbyDao; @Autowired
private UserDao userDao; @Autowired
private PhotoDao photoDao; @Override
public void destroy() throws Exception {
executor.shutdownNow();
} @Override
public void afterPropertiesSet() throws Exception { executor = new ScheduledThreadPoolExecutor(CORE_SIZE, new NamedThreadFactory("static-info-loader"));
RefreshCache refreshCache = new RefreshCache();
refreshCache.run();
executor.scheduleWithFixedDelay(refreshCache, cacheExpire, cacheExpire, TimeUnit.SECONDS); } private class RefreshCache implements Runnable {
@Override
public void run() {
log.info("---开始刷新角色权限缓存-----");
List<Role> roles = rolePermissionDao.getAllRole();
if (CollectionUtils.isNotEmpty(roles)) {
for (Role role : roles) {
List<Permission> permissions = rolePermissionDao.getPermissionByRole(role.getRid());
role.setPermissions(permissions);
redisCache.opsForValue().set(Constant.ROLE + role.getRid(), JSON.toJSONString(role));
}
} log.info("---开始刷新城市缓存-----");
List<City> cityProvince = cityDao.getAllProvince();
redisCache.opsForValue().set(Constant.CITY_ROOT, JSON.toJSONString(cityProvince));
if (CollectionUtils.isNotEmpty(cityProvince)) {
for (City sheng : cityProvince) {
List<City> shis = cityDao.getCityByParentId(sheng.getCid());
sheng.setChildren(shis);
redisCache.opsForValue().set(Constant.CITY + sheng.getCid(), JSON.toJSONString(sheng));
if (CollectionUtils.isNotEmpty(shis)) {
for (City shi : shis) {
List<City> xians = cityDao.getCityByParentId(shi.getCid());
shi.setChildren(xians);
redisCache.opsForValue().set(Constant.CITY + shi.getCid(), JSON.toJSONString(shi));
for (City xian : xians) {
redisCache.opsForValue().set(Constant.CITY + xian.getCid(), JSON.toJSONString(xian));
}
}
}
}
} log.info("---开始刷新兴趣爱好缓存-----");
List<HobbyType> allHobby = hobbyDao.getAllHobbys();
if(CollectionUtils.isNotEmpty(allHobby)){
for(HobbyType ht : allHobby){
List<Hobby> hobbys = hobbyDao.getHobbyItems(ht.getHtId());
if(CollectionUtils.isNotEmpty(hobbys)){
ht.setHobbys(hobbys);
}
redisCache.opsForValue().set(Constant.HOBBY + ht.getHtId(), JSON.toJSONString(ht));
}
} log.info("---开始刷新用户信息缓存-----");
List<UserInfo> userinfos = userDao.getAllUserInfo();
if(CollectionUtils.isNotEmpty(userinfos)){
for(UserInfo userInfo : userinfos){
List<Photos> photos = photoDao.getUserPhotos(userInfo.getUserId());
if(CollectionUtils.isNotEmpty(photos)){
userInfo.setPhotos(photos);
}
redisCache.opsForValue().set(Constant.USER_INFO + userInfo.getUserId(), JSON.toJSONString(userInfo));
}
} }
}
}

4.从redis中获取并解析为对象

@Override
public List<UserInfo> getUserInfoFromCache(int number) {
Set<String> sets = redis.keys(Constant.USER_INFO + "*");
Iterator<String> it = sets.iterator();
List<UserInfo> result = new LinkedList<UserInfo>();
int i = 0;
while(it.hasNext() && i<number){
String item = it.next();
String value = redis.opsForValue().get(item);
result.add(JSON.parseObject(value,UserInfo.class));
i++;
}
return result;
}
上一篇:php在linux中执行外部命令


下一篇:Easy Tag Write(3.1)