搞懂分布式技术14：Spring Boot使用注解集成Redis缓存
本文内容参考网络，侵删
本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
喜欢的话麻烦点下Star哈
文章首发于我的个人博客：
www.how2playlife.com
该系列博文会告诉你什么是分布式系统，这对后端工程师来说是很重要的一门学问，我们会逐步了解常见的分布式技术、以及一些较为常见的分布式系统概念，同时也需要进一步了解zookeeper、分布式事务、分布式锁、负载均衡等技术，以便让你更完整地了解分布式技术的具体实战方法，为真正应用分布式技术做好准备。
如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
本文转载自 linkedkeeper.com
Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集成Redis也很简单，看下面步骤配置：
一、添加pom依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
二、创建 RedisClient.java
注意该类存放的package
package org.springframework.data.redis.connection.jedis;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisException;
/**
* 工具类 RedisClient
* 因为本类中获取JedisPool调用的是JedisConnectionFactory中protected修饰的方法fetchJedisConnector()
* 所以该类需要与JedisConnectionFactory在同一个package中
*
* @author 单红宇(CSDN CATOOP)
* @create 2017年4月9日
*/
public class RedisClient {
private static Logger logger = LoggerFactory.getLogger(RedisClient.class);
private JedisConnectionFactory factory;
public RedisClient(JedisConnectionFactory factory) {
super();
this.factory = factory;
}
/**
* put操作（存储序列化对象）+ 生效时间
*
* @param key
* @param value
* @return
*/
public void putObject(final String key, final Object value, final int cacheSeconds) {
if (StringUtils.isNotBlank(key)) {
redisTemplete(key, new RedisExecute<Object>() {
@Override
public Object doInvoker(Jedis jedis) {
try {
jedis.setex(key.getBytes(Protocol.CHARSET), cacheSeconds, serialize(value));
} catch (UnsupportedEncodingException e) {
}
return null;
}
});
}
}
/**
* get操作（获取序列化对象）
*
* @param key
* @return
*/
public Object getObject(final String key) {
return redisTemplete(key, new RedisExecute<Object>() {
@Override
public Object doInvoker(Jedis jedis) {
try {
byte[] byteKey = key.getBytes(Protocol.CHARSET);
byte[] byteValue = jedis.get(byteKey);
if (byteValue != null) {
return deserialize(byteValue);
}
} catch (UnsupportedEncodingException e) {
return null;
}
return null;
}
});
}
/**
* setex操作
*
* @param key
* 键
* @param value
* 值
* @param cacheSeconds
* 超时时间，0为不超时
* @return
*/
public String set(final String key, final String value, final int cacheSeconds) {
return redisTemplete(key, new RedisExecute<String>() {
@Override
public String doInvoker(Jedis jedis) {
if (cacheSeconds == 0) {
return jedis.set(key, value);
}
return jedis.setex(key, cacheSeconds, value);
}
});
}
/**
* get操作
*
* @param key
* 键
* @return 值
*/
public String get(final String key) {
return redisTemplete(key, new RedisExecute<String>() {
@Override
public String doInvoker(Jedis jedis) {
String value = jedis.get(key);
return StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
}
});
}
/**
* del操作
*
* @param key
* 键
* @return
*/
public long del(final String key) {
return redisTemplete(key, new RedisExecute<Long>() {
@Override
public Long doInvoker(Jedis jedis) {
return jedis.del(key);
}
});
}
/**
* 获取资源
*
* @return
* @throws JedisException
*/
public Jedis getResource() throws JedisException {
Jedis jedis = null;
try {
jedis = factory.fetchJedisConnector();
} catch (JedisException e) {
logger.error("getResource.", e);
returnBrokenResource(jedis);
throw e;
}
return jedis;
}
/**
* 获取资源
*
* @return
* @throws JedisException
*/
public Jedis getJedis() throws JedisException {
return getResource();
}
/**
* 归还资源
*
* @param jedis
* @param isBroken
*/
public void returnBrokenResource(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
/**
* 释放资源
*
* @param jedis
* @param isBroken
*/
public void returnResource(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
/**
* 操作jedis客户端模板
*
* @param key
* @param execute
* @return
*/
public <R> R redisTemplete(String key, RedisExecute<R> execute) {
Jedis jedis = null;
try {
jedis = getResource();
if (jedis == null) {
return null;
}
return execute.doInvoker(jedis);
} catch (Exception e) {
logger.error("operator redis api fail,{}", key, e);
} finally {
returnResource(jedis);
}
return null;
}
/**
* 功能简述: 对实体Bean进行序列化操作.
*
* @param source
* 待转换的实体
* @return 转换之后的字节数组
* @throws Exception
*/
public static byte[] serialize(Object source) {
ByteArrayOutputStream byteOut = null;
ObjectOutputStream ObjOut = null;
try {
byteOut = new ByteArrayOutputStream();
ObjOut = new ObjectOutputStream(byteOut);
ObjOut.writeObject(source);
ObjOut.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (null != ObjOut) {
ObjOut.close();
}
} catch (IOException e) {
ObjOut = null;
}
}
return byteOut.toByteArray();
}
/**
* 功能简述: 将字节数组反序列化为实体Bean.
*
* @param source
* 需要进行反序列化的字节数组
* @return 反序列化后的实体Bean
* @throws Exception
*/
public static Object deserialize(byte[] source) {
ObjectInputStream ObjIn = null;
Object retVal = null;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
ObjIn = new ObjectInputStream(byteIn);
retVal = ObjIn.readObject();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != ObjIn) {
ObjIn.close();
}
} catch (IOException e) {
ObjIn = null;
}
}
return retVal;
}
interface RedisExecute<T> {
T doInvoker(Jedis jedis);
}
}
三、创建Redis配置类
RedisConfig.java
package com.shanhy.example.redis;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.RedisClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* Redis配置
*
* @author 单红宇(CSDN catoop)
* @create 2016年9月12日
*/
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new RedisObjectSerializer());
template.afterPropertiesSet();
return template;
}
@Bean
public RedisClient redisClient(JedisConnectionFactory factory){
return new RedisClient(factory);
}
}
RedisObjectSerializer.java
package com.shanhy.example.redis;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.serializer.support.DeserializingConverter;
import org.springframework.core.serializer.support.SerializingConverter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
/**
* 实现对象的序列化接口
* @author 单红宇(365384722)
* @myblog http://blog.csdn.net/catoop/
* @create 2017年4月9日
*/
public class RedisObjectSerializer implements RedisSerializer<Object> {
private Converter<Object, byte[]> serializer = new SerializingConverter();
private Converter<byte[], Object> deserializer = new DeserializingConverter();
static final byte[] EMPTY_ARRAY = new byte[0];
@Override
public Object deserialize(byte[] bytes) {
if (isEmpty(bytes)) {
return null;
}
try {
return deserializer.convert(bytes);
} catch (Exception ex) {
throw new SerializationException("Cannot deserialize", ex);
}
}
@Override
public byte[] serialize(Object object) {
if (object == null) {
return EMPTY_ARRAY;
}
try {
return serializer.convert(object);
} catch (Exception ex) {
return EMPTY_ARRAY;
}
}
private boolean isEmpty(byte[] data) {
return (data == null || data.length == 0);
}
}
四、创建测试方法
下面代码随便放一个Controller里
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 缓存测试
*
* @return
* @author SHANHY
* @create 2016年9月12日
*/
@RequestMapping("/redisTest")
public String redisTest() {
try {
redisTemplate.opsForValue().set("test-key", "redis测试内容", 2, TimeUnit.SECONDS);// 缓存有效期2秒
logger.info("从Redis中读取数据：" + redisTemplate.opsForValue().get("test-key").toString());
TimeUnit.SECONDS.sleep(3);
logger.info("等待3秒后尝试读取过期的数据：" + redisTemplate.opsForValue().get("test-key"));
} catch (InterruptedException e) {
e.printStackTrace();
}
return "OK";
}
五、配置文件配置Redis
application.yml
spring:
# Redis配置
redis:
host: 192.168.1.101
port: 6379
password:
# 连接超时时间（毫秒）
timeout: 10000
pool:
max-idle: 20
min-idle: 5
max-active: 20
max-wait: 2
这样就完成了Redis的配置，可以正常使用 redisTemplate 了。
atoop/article/details/71275331
一、创建 Caching 配置类
RedisKeys.java
package com.shanhy.example.redis;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
/**
* 方法缓存key常量
*
* @author SHANHY
*/
@Component
public class RedisKeys {
// 测试 begin
public static final String _CACHE_TEST = "_cache_test";// 缓存key
public static final Long _CACHE_TEST_SECOND = 20L;// 缓存时间
// 测试 end
// 根据key设定具体的缓存时间
private Map<String, Long> expiresMap = null;
@PostConstruct
public void init(){
expiresMap = new HashMap<>();
expiresMap.put(_CACHE_TEST, _CACHE_TEST_SECOND);
}
public Map<String, Long> getExpiresMap(){
return this.expiresMap;
}
}
CachingConfig.java
package com.shanhy.example.redis;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.core.RedisTemplate;
/**
* 注解式环境管理
*
* @author 单红宇(CSDN catoop)
* @create 2016年9月12日
*/
@Configuration
@EnableCaching
public class CachingConfig extends CachingConfigurerSupport {
/**
* 在使用@Cacheable时，如果不指定key，则使用找个默认的key生成器生成的key
*
* @return
*
* @author 单红宇(CSDN CATOOP)
* @create 2017年3月11日
*/
@Override
public KeyGenerator keyGenerator() {
return new SimpleKeyGenerator() {
/**
* 对参数进行拼接后MD5
*/
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(".").append(method.getName());
StringBuilder paramsSb = new StringBuilder();
for (Object param : params) {
// 如果不指定，默认生成包含到键值中
if (param != null) {
paramsSb.append(param.toString());
}
}
if (paramsSb.length() > 0) {
sb.append("_").append(paramsSb);
}
return sb.toString();
}
};
}
/**
* 管理缓存
*
* @param redisTemplate
* @return
*/
@Bean
public CacheManager cacheManager(RedisTemplate<String, Object> redisTemplate, RedisKeys redisKeys) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
// 设置缓存默认过期时间（全局的）
rcm.setDefaultExpiration(1800);// 30分钟
// 根据key设定具体的缓存时间，key统一放在常量类RedisKeys中
rcm.setExpires(redisKeys.getExpiresMap());
List<String> cacheNames = new ArrayList<String>(redisKeys.getExpiresMap().keySet());
rcm.setCacheNames(cacheNames);
return rcm;
}
}
二、创建需要缓存数据的类
TestService.java
package com.shanhy.example.service;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import com.shanhy.example.redis.RedisKeys;
@Service
public class TestService {
/**
* 固定key
*
* @return
* @author SHANHY
* @create 2017年4月9日
*/
@Cacheable(value = RedisKeys._CACHE_TEST, key = "'" + RedisKeys._CACHE_TEST + "'")
public String testCache() {
return RandomStringUtils.randomNumeric(4);
}
/**
* 存储在Redis中的key自动生成，生成规则详见CachingConfig.keyGenerator()方法
*
* @param str1
* @param str2
* @return
* @author SHANHY
* @create 2017年4月9日
*/
@Cacheable(value = RedisKeys._CACHE_TEST)
public String testCache2(String str1, String str2) {
return RandomStringUtils.randomNumeric(4);
}
}
说明一下，其中 @Cacheable 中的 value 值是在 CachingConfig的cacheManager 中配置的，那里是为了配置我们的缓存有效时间。其中 methodKeyGenerator 为 CachingConfig 中声明的 KeyGenerator。
另外，Cache 相关的注解还有几个，大家可以了解下，不过我们常用的就是 @Cacheable，一般情况也可以满足我们的大部分需求了。还有 @Cacheable 也可以配置表达式根据我们传递的参数值判断是否需要缓存。
注： TestService 中 testCache 中的 mapper.get 大家不用关心，这里面我只是访问了一下数据库而已，你只需要在这里做自己的业务代码即可。
三、测试方法
下面代码，随便放一个 Controller 中
package com.shanhy.example.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.RedisClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.shanhy.example.service.TestService;
/**
* 测试Controller
*
* @author 单红宇(365384722)
* @myblog http://blog.csdn.net/catoop/
* @create 2017年4月9日
*/
@RestController
@RequestMapping("/test")
public class TestController {
private static final Logger LOG = LoggerFactory.getLogger(TestController.class);
@Autowired
private RedisClient redisClient;
@Autowired
private TestService testService;
@GetMapping("/redisCache")
public String redisCache() {
redisClient.set("shanhy", "hello,shanhy", 100);
LOG.info("getRedisValue = {}", redisClient.get("shanhy"));
testService.testCache2("aaa", "bbb");
return testService.testCache();
}
}
至此完毕！
最后说一下，这个 @Cacheable 基本是可以放在所有方法上的，Controller 的方法上也是可以的（这个我没有测试 _）。
搞懂分布式技术14：Spring Boot使用注解集成Redis缓存的更多相关文章
- 搞懂分布式技术12：分布式ID生成方案
搞懂分布式技术12:分布式ID生成方案 ## 转自: 58沈剑 架构师之路 2017-06-25 一.需求缘起 几乎所有的业务系统,都有生成一个唯一记录标识的需求,例如: 消息标识:message-i ...
- 搞懂分布式技术21：浅谈分布式消息技术 Kafka
搞懂分布式技术21:浅谈分布式消息技术 Kafka 浅谈分布式消息技术 Kafka 本文主要介绍了这几部分内容: 1基本介绍和架构概览 2kafka事务传输的特点 3kafka的消息存储格式:topi ...
- 搞懂分布式技术28：微服务（Microservice）那点事
搞懂分布式技术28:微服务(Microservice)那点事 微服务(Microservice)那点事 肥侠 2016-01-13 09:46:53 浏览58371 评论15 分布式系统与计算 微服务 ...
- 搞懂分布式技术19：使用RocketMQ事务消息解决分布式事务
搞懂分布式技术19:使用RocketMQ事务消息解决分布式事务 初步认识RocketMQ的核心模块 rocketmq模块 rocketmq-broker:接受生产者发来的消息并存储(通过调用rocke ...
- 搞懂分布式技术11：分布式session解决方案与一致性hash
搞懂分布式技术11:分布式session解决方案与一致性hash session一致性架构设计实践 原创: 58沈剑 架构师之路 2017-05-18 一.缘起 什么是session? 服务器为每个用 ...
- 搞懂分布式技术9：Nginx负载均衡原理与实践
搞懂分布式技术9:Nginx负载均衡原理与实践 本篇摘自<亿级流量网站架构核心技术>第二章 Nginx负载均衡与反向代理 部分内容. 当我们的应用单实例不能支撑用户请求时,此时就需要扩容, ...
- 搞懂分布式技术10：LVS实现负载均衡的原理与实践
搞懂分布式技术10:LVS实现负载均衡的原理与实践 浅析负载均衡及LVS实现 原创: fireflyc 写程序的康德 2017-09-19 负载均衡 负载均衡(Load Balance,缩写LB)是一 ...
- 搞懂分布式技术5：Zookeeper的配置与集群管理实战
搞懂分布式技术5:Zookeeper的配置与集群管理实战 4.1 配置文件 ZooKeeper安装好之后,在安装目录的conf文件夹下可以找到一个名为“zoo_sample.cfg”的文件,是ZooK ...
- 搞懂分布式技术6：Zookeeper典型应用场景及实践
搞懂分布式技术6:Zookeeper典型应用场景及实践 一.ZooKeeper典型应用场景实践 ZooKeeper是一个高可用的分布式数据管理与系统协调框架.基于对Paxos算法的实现,使该框架保证了 ...
随机推荐
- VC++ 创建及调用Dll
一._stdcall 被这个关键字修饰的函数,其参数都是从右向左通过堆栈传递的(__fastcall 的前面部分由ecx,edx传), 函数调用在返回前要由被调用者清理堆栈. 这个关键字主要见于Mic ...
- BUUCTF | [SUCTF 2019]EasySQL (堆叠注入)
fuzz ing了一下,发现了一堆过滤: 同时发现了注入点,这个应该是var_dump()函数 ===============第二天的分割线 好吧我放弃了,找了一下wp 正确解:select 1;se ...
- window安装nginx
下载安装 到nginx官网上下载相应的安装包,http://nginx.org/en/download.html: 下载进行解压,将解压后的文件放到自己心仪的目录下,我的解压文件放在了d盘根目录下,如 ...
- [CSP-S模拟测试]:联盟（搜索+树的直径）
题目描述 $G$国周边的$n$个小国家构成一个联盟以抵御$G$国入侵,为互相支援,他们建立了$n−1$条双向通路,使得任意两个国家可以经过通路相互到达.当一个国家受到攻击时,所有其它国家都会沿着最短路 ...
- EasyUI 中的双击某行 并赋值给input事件
项目是由mvc+easyUI开发,双击事件在下边.有注释写着呢 function DataList(supCode) { myDatagrid2.datagridId = "GridView ...
- java 字符串的操作方法
方法 作用 范例 indexOf() 找到第一个字符出现的位置,()以下标来判断,返回的是字符所在的下标 int num = String.indexOf("字符") l ...
- 实用｜从0到1 搭建Web性能监控系统
工具介绍 1. Statsd 是一个使用Node开发网络守护进程,它的特点是通过UDP(性能好,及时挂了也不影响主服务)或者TCP来监听各种数据信息,然后发送聚合数据到后端服务进行处理. 常见支持的「 ...
- Vue2.0---vuex初理解
先来一张vuex的帅照 第一眼看到这张图片我内心是万匹草泥马飞过. 简单理解: vuex:一个可以全局被使用的状态管理的“仓库”:state.js中定义初始状态,通过action去触发mutatio ...
- Redis 系列（02）数据结构
目录 Redis 系列(02)数据结构 Redis 系列目录 1. String 1.1 基本操作 1.2 数据结构 1.3 Redis数据存储结构 2. Hash 2.1 基本操作 2.2 数据结构 ...
- vue 引入阿里图标
1.去阿里图标矢量图标库将想要的图标添加入库 2.再去库中将图标添加到项目. 3.再到我的项目中,选择,我这里采用的是将图标代码包下载到本地再引入到vue项目中. 4.在vue项目的assets文件夹 ...