redis是一个缓存服务器，使用键值对存储数据，由于redis与web系统交互的时候是在不同域（同主机但不同端口也算跨域，tomcat是8080，而redis是6379），需要进行不同组件之间的跨域请求，经过了网络传输，在这个过程中，需要缓存的对象必须实现序列化接口，请求双方才能正常处理请求或者回应。说了这么久，其实就是想说明使用redis，对象必须实现序列化。下面开始正式介绍redis在SSM框架的配置！
- 使用maven导入依赖
<!-- spring的依赖 ,redis配置类需要扫描--> <!-- Spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jms</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> </dependency> <!-- redis cache related.....start --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <!-- redis cache related.....end --> |
<?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" xmlns:cache="http://www.springframework.org/schema/cache" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.2.xsd"> <context:property-placeholder location="classpath:properties/redis.properties"/> <!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 --> <cache:annotation-driven cache-manager="cacheManager"/> <!-- 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> <!-- spring自己的缓存管理器，这里定义了缓存位置名称 ，即注解中的value --> <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager"> <property name="caches"> <set> <!-- 这里可以配置多个redis --> <!-- <bean class="com.cn.util.RedisCache"> <property name="redisTemplate" ref="redisTemplate" /> <property name="name" value="default"/> </bean> --> <bean class="edu.mooc.utils.RedisCache"> <property name="redisTemplate" ref="redisTemplate"/> <property name="name" value="common"/> <!-- common名称要在类或方法的注解中使用 --> </bean> </set> </property> </bean> </beans> |
3.redis连接的属性文件
# 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 |
<import resource="spring-redis.xml"></import>原因：服务器启动的时候就会加载applicationContext-dao.xml这个文件，因为web.xml中设置了
contextConfigLocation，服务器启动就会加载这个这个配置下包含的配置文件。
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/applicationContext-*.xml</param-value>
</context-param>亲测的结果是加到springmvc的配置文件中无效，如果说法有误，欢迎指正。
5.redis工具类（负责进行key的操作）
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;
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>() {
@Override
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>() {
@Override
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>() {
@Override
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>() {
@Override
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;
}
}6.在这里，我们使用注解的形式定义需要进行缓存操作
@Service
public class CourseServiceImpl implements CourseService {
@Autowired
private TCourseMapper courseMapper;
@Autowired
private TConstsClassifyMapper constsClassifyMapper;
/**
* 根据关键字查找课程
*
* @param keyWord
*/
@Override
//@CacheEvict(value="common",key="'id_'+#id")
@CacheEvict(value="common",key="#keyWord")
public List<TCourse> queryCourseByFuzzySerarch(String keyWord) {
TCourseExample e = new TCourseExample();
TCourseExample.Criteria criteria = e.createCriteria();
/**
* 模糊查找课程名+未被置为已删除的课程信息
*/
criteria.andNameLike("%" + keyWord);
criteria.andDelEqualTo(false);
List<TCourse> courseList = courseMapper.selectByExample(e);
return courseList;
}
/**
* 根据ParentCode查询出该分类下的所有子分类
*
* @param parentCode
* @return
*/
@Override
@Cacheable(value="common",key="#parentCode")
public List<TConstsClassify> queryClassifyByParentCode(String parentCode) {
TConstsClassifyExample e = new TConstsClassifyExample();
TConstsClassifyExample.Criteria criteria = e.createCriteria();
/**
* ParentCode=parentCode
* Del=false
*/
criteria.andParentCodeEqualTo(parentCode);
criteria.andDelEqualTo(false);
List<TConstsClassify> clist = constsClassifyMapper.selectByExample(e);
return clist;
}
}
取两段段代码说明：
@Cacheable(value="common",key="#parentCode")
public List<TConstsClassify> queryClassifyByParentCode(String parentCode)(1)@Cacheable主要针对方法配置，判断key在redis是否存在，若存在，则直接从redis中取，
不存在则查数据库，再将结果放在缓存中并将结果返回
(2)value是缓存的名字，在redis的配置中必须制定一个，类似于一块空间，
而这块空间中有许多key-value
(3)key是键，键的名字可以使用多种方式生成，比如key="#parentCode"，
就是key名以参数列表中的parentCode为名，#不能丢。
如果不填key，默认是由下面的参数表组合而成的。
假如需要起一个固定的名字，使用key="'xxx'"即可，比如查询所有班级学生的信息，使用key="'studentAll'"
@CacheEvict(value="common",key="#keyWord")
public List<TCourse> queryCourseByFuzzySerarch(String keyWord)(2)value是缓存的名字，在redis的配置中必须制定一个，类似于一块空间，
而这块空间中有许多key-value
(3)key是键，在这里意思是删除key与keyWord的值相同的key
总结：redis的同步策略的 两种方式：
1. 主动缓存过期时间，比如5分钟，5分钟后数据在redis清除
2. 主动更新，就是存放在redis中数据不设置过期时间，当数据发生变化时主动更新缓存
2. 主动更新，就是存放在redis中数据不设置过期时间，当数据发生变化时主动更新缓存
第一种的话不能避免脏数据，第二种显得更好
部分效果结果展示：
1.第一次访问：（数据库）,并加入了缓存
2.第二次缓存:(走的缓存)
3.执行key的过期操作后
参考博文：https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/index.html
https://blog.csdn.net/aqsunkai/article/details/51758900
扫一扫
459
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
