- pom.xml先引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
- 项目配置
spring:
profiles:
active: dev #指定为开发环境
#redis 配置
redis:
type: standalone
config:
type: manual
host: 119.x.x.x
port: 6379
password:
maxIdle: 500
maxTotal: 500
maxWaitMillis: -1
Spring在 org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration类下配置的两个RedisTemplate的Bean。
(1) RedisTemplate<Object, Object>
这个Bean使用JdkSerializationRedisSerializer进行序列化,即key, value需要实现Serializable接口,redis数据格式比较难懂
(2) StringRedisTemplate,即RedisTemplate<String, String>
key和value都是String。当需要存储实体类时,需要先转为String,再存入Redis。一般转为Json格式的字符串,所以使用StringRedisTemplate,需要手动将实体类转为Json格式。
ValueOperations<String, String> valueTemplate = stringTemplate.opsForValue();
Gson gson = new Gson();
valueTemplate.set("StringKey1", "hello spring boot redis, String Redis");
String value = valueTemplate.get("StringKey1");
System.out.println(value);
valueTemplate.set("StringKey2", gson.toJson(new Person("theName", 11)));
Person person = gson.fromJson(valueTemplate.get("StringKey2"), Person.class);
System.out.println(person);
2.2 配置一个RedisTemplate<String,Object>的Bean
Spring配置的两个RedisTemplate都不太方便使用,所以可以配置一个RedisTemplate<String,Object> 的Bean,key使用String即可(包括Redis Hash 的key),value存取Redis时默认使用Json格式转换。如下
@Bean(name = "template")
public RedisTemplate<String, Object> template(RedisConnectionFactory factory) {
// 创建RedisTemplate<String, Object>对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
// 定义Jackson2JsonRedisSerializer序列化对象
Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
// 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会报异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);
StringRedisSerializer stringSerial = new StringRedisSerializer();
// redis key 序列化方式使用stringSerial
template.setKeySerializer(stringSerial);
// redis value 序列化方式使用jackson
template.setValueSerializer(jacksonSeial);
// redis hash key 序列化方式使用stringSerial
template.setHashKeySerializer(stringSerial);
// redis hash value 序列化方式使用jackson
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();
return template;
}
- 所以可以这样使用
@Autowired
private RedisTemplate<String, Object> template;
public void test002() {
ValueOperations<String, Object> redisString = template.opsForValue();
// SET key value: 设置指定 key 的值
redisString.set("strKey1", "hello spring boot redis");
// GET key: 获取指定 key 的值
String value = (String) redisString.get("strKey1");
System.out.println(value);
redisString.set("strKey2", new User("ID10086", "theName", 11));
User user = (User) redisString.get("strKey2");
System.out.println(user);
}
- redis缓存
package com.enation.app.javashop.framework.cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* redis的cache实现
*
* @author fk
* @version v6.4
* @since v6.4 2017年9月25日 下午4:32:49
*/
@Component
public class RedisCacheImpl implements Cache {
@Autowired
private RedisTemplate redisTemplate;
public RedisCacheImpl() {
}
@Override
public Object get(Object key) {
return redisTemplate.opsForValue().get(key);
}
@Override
public List multiGet(Collection keys) {
return redisTemplate.opsForValue().multiGet(keys);
}
@Override
public void multiSet(Map map) {
redisTemplate.opsForValue().multiSet(map);
}
@Override
public void multiDel(Collection keys) {
redisTemplate.delete(keys);
}
@Override
public void put(Object key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
@Override
public void put(Object key, Object value, int exp) {
redisTemplate.opsForValue().set(key, value, exp, TimeUnit.SECONDS);
}
@Override
public void remove(Object key) {
redisTemplate.delete(key);
}
/**
* 删除
*
* @param key
*/
@Override
public void vagueDel(Object key) {
Set<String> keys = redisTemplate.keys(key + "*");
redisTemplate.delete(keys);
}
@Override
public void clear() {
Set keys = redisTemplate.keys("*");
redisTemplate.delete(keys);
}
@Override
public void putHash(Object key, Object hashKey, Object hashValue) {
redisTemplate.opsForHash().put(key, hashKey, hashValue);
}
@Override
public void putAllHash(Object key, Map map) {
redisTemplate.opsForHash().putAll(key, map);
}
@Override
public Object getHash(Object key, Object hashKey) {
return redisTemplate.opsForHash().get(key, hashKey);
}
@Override
public Map<Object, Object> getHash(Object key) {
return this.redisTemplate.opsForHash().entries(key);
}
@Override
public void setSetValue(Object key, Object value) {
redisTemplate.boundSetOps(key).add(value);
}
@Override
public Set getSetValue(Object key) {
Set set = redisTemplate.boundSetOps(key).members();
return set;
}
}
-
Mybatis二级缓存,使用redis作为缓存
package com.enation.app.javashop.framework.cache;
import com.enation.app.javashop.framework.context.ApplicationContextHolder;
import com.enation.app.javashop.framework.logs.Logger;
import com.enation.app.javashop.framework.logs.LoggerFactory;
import org.springframework.data.redis.connection.RedisServerCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Mybatis二级缓存,使用redis作为缓存。<br/>
* 所有的key都是由mybatis生成的,如:<br/>
* "1040379671:3603394099:com.enation.app.javashop.mapper.UserMapper.selectById:0:2147483647:SELECT id,name,age,email FROM user WHERE id=? :1287644473261592577:MybatisSqlSessionFactoryBean"
*
* @author kingapex
* @version 1.0
* @since 7.2.2
* 2020/7/27
*/
public class MybatisRedisCache implements org.apache.ibatis.cache.Cache {
/**
* 读写锁
*/
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
/**
* 操作缓存template
*/
private RedisTemplate<String, Object> redisTemplate;
/**
* 唯一id
*/
private String id;
private final Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 缓存实现构造器
*
* @param id 唯一id
*/
public MybatisRedisCache(final String id) {
if (id == null) {
throw new IllegalArgumentException("Cache instances require an ID");
}
this.id = id;
}
/**
* 获取唯一id
*
* @return
*/
@Override
public String getId() {
return this.id;
}
/**
* 像缓存中存入一个对象
*
* @param key
* @param value
*/
@Override
public void putObject(Object key, Object value) {
logger.debug("存入key:"+id+"--"+ key);
if (value != null) {
getRedisTemplate().opsForHash().put(id,key,value);
// getRedisTemplate().opsForValue().set(getKey(key), value);
}
}
/**
* 由缓存中读取对象
*
* @param key
* @return
*/
@Override
public Object getObject(Object key) {
logger.debug("获取key:"+id+"--"+ key);
try {
if (key != null) {
Object obj =getRedisTemplate().opsForHash().get(id, key);
System.out.println("cache + "+obj);
// Object obj = getRedisTemplate().opsForValue().get(getKey(key));
return obj;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 移除一个对象,这个方法只有在发生回滚是调用。
* 在删除是不会调用,目的是如果发生了删除且缓存过,则查不用读库
* As of 3.3.0 this method is only called during a rollback
* for any previous value that was missing in the cache.
* This lets any blocking cache to release the lock that
* may have previously put on the key.
* A blocking cache puts a lock when a value is null
* and releases it when the value is back again.
* This way other threads will wait for the value to be
* available instead of hitting the database.
*
* @param key
* @return
*/
@Override
public Object removeObject(Object key) {
logger.debug("移除key:"+id+"--"+ key);
if (key != null) {
getRedisTemplate().opsForHash().delete(id, key);
}
return null;
}
@Override
public void clear() {
logger.debug("移除相关的的key-->" + this.id + "*");
getRedisTemplate().opsForHash().getOperations().delete(id);
}
@Override
public int getSize() {
Long size = getRedisTemplate().execute((RedisCallback<Long>) RedisServerCommands::dbSize);
logger.debug("获取大小:"+size.intValue());
return size.intValue();
}
/**
* 为mybatis提供读写锁
*
* @return
*/
@Override
public ReadWriteLock getReadWriteLock() {
return this.readWriteLock;
}
private RedisTemplate<String, Object> getRedisTemplate() {
if (redisTemplate == null) {
redisTemplate = (RedisTemplate<String, Object>) ApplicationContextHolder.getBean("redisTemplate");
}
return redisTemplate;
}
}