基于aop的redis自动缓存实现
目的:
对于查询接口所得到的数据,只需要配置注解,就自动存入redis!此后一定时间内,都从redis中获取数据,从而减轻数据库压力。
示例:
package com.itliucheng.biz;
import com.itliucheng.annotation.CacheKey;
import com.itliucheng.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* Created by wangliucheng on 2017/9/14 0014.
*/
@Service
public class DemoAnnotationService {
@Cacheable(expire = 300)
public List<Integer> getList(@CacheKey(key = "anyParameter") String anyParameter) {
List<Integer> list = new ArrayList();
//模拟数据库操作
list.add(1);
list.add(2);
list.add(3);
return list;
}
}
对于getList方法,只需要第一次查询,然后存入redis,以后的300s之内都从redis中获取数据
此示例需要了解注解,不了解的可以先看一下注解 这篇
接下来就是具体的操作过程
学习时只关注技术,所以项目就以简单为例
1.创建maven项目,配置pom
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.itliucheng</groupId>
<artifactId>annotation</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
<spring-framework.version>4.1.5.RELEASE</spring-framework.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- spring aop支持 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- aspectj支持 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.6</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.5</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.32</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
项目的结构基本是这样

2.代码部分
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Cacheable {
int expire() default 0;
}
参数的注解,默认无参
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheKey {
String key() default "";
}
没有配置文件,我们都用注解的形式
@Configuration//声明当前类是一个配置类
@ComponentScan("com.itliucheng.biz")//自动扫描包下面所有@Service @Component @Repository和@Controller的类,并注册为bean
@EnableAspectJAutoProxy//注解开启Spring对AspectJ的支持
public class AopConfig {
}
获取jedis实例
public class JedisClient {
private static class JedisHolder{
private static Jedis jedis = new Jedis("10.0.0.32",6279);
}
private JedisClient(){}
public static Jedis getInstance(){
return JedisHolder.jedis;
}
}
接下来是aop的环绕通知
package com.itliucheng.biz;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.itliucheng.JedisClient;
import com.itliucheng.annotation.CacheKey;
import com.itliucheng.annotation.Cacheable;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
/**
* Created by wangliucheng on 2017/9/14 0014.
*/
@Aspect
@Component
public class CacheAspect {
private static final Jedis jedis = JedisClient.getInstance();
@Around("@annotation(cache)")
public Object cached(ProceedingJoinPoint pjp, Cacheable cache) {
String key = this.getCacheKey(pjp);
String value = jedis.get(key);
if(!StringUtils.isEmpty(value)) {
return this.isJSONArray(value, pjp);
}
Object obj = null;
try {
obj = pjp.proceed();
if(obj == null) {
return obj;
}
value = JSON.toJSONString(obj);
} catch (Throwable throwable) {
throwable.printStackTrace();
}
if(cache.expire() <= 0) {
jedis.set(key, value);
} else {
jedis.setex(key,cache.expire(),value);
}
if(obj instanceof List) {
if(((List)obj).size() > 0) {
Class<?> entityClazz = ((List)obj).toArray()[0].getClass();
return JSONArray.parseArray(value, entityClazz);
}
return JSONArray.parseArray(value);
}
return this.isJSONArray(value, pjp);
}
private Object isJSONArray(String value, ProceedingJoinPoint pjp) {
Object obj = JSONObject.parse(value);
MethodSignature signature = (MethodSignature) pjp.getSignature();
Type type = signature.getMethod().getGenericReturnType();
try {
if (obj instanceof JSONArray) {
if (ParameterizedType.class.isAssignableFrom(type.getClass())) {
Type[] var7 = ((ParameterizedType) type).getActualTypeArguments();
int var8 = var7.length;
byte var9 = 0;
if (var9 < var8) {
Type t1 = var7[var9];
return JSONArray.parseArray(value, (Class) t1);
}
}
return null;
} else {
return JSON.parseObject(value, Class.forName(type.getTypeName()));
}
} catch (ClassNotFoundException | JSONException var11) {
return null;
}
}
private String getCacheKey(ProceedingJoinPoint pjp) {
StringBuilder buf = new StringBuilder();
Signature signature = pjp.getSignature();
String declaringTypeName = signature.getDeclaringTypeName();
String name = signature.getName();
buf.append(declaringTypeName).append(".").append(name);
Object[] args = pjp.getArgs();
Annotation[][] pas = ((MethodSignature)signature).getMethod().getParameterAnnotations();
int length = pas.length;
for(int i = 0; i < length; ++i) {
Annotation[] var1 = pas[i];
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
Annotation an = var1[var3];
if(an instanceof CacheKey) {
buf.append("|").append(((CacheKey)an).key()).append("=").append(args[i].toString());
break;
}
}
}
return buf.toString();
}
}
业务层的某个方法
package com.itliucheng.biz; import com.itliucheng.annotation.CacheKey;
import com.itliucheng.annotation.Cacheable;
import org.springframework.stereotype.Service; import java.util.ArrayList;
import java.util.List; /**
* Created by wangliucheng on 2017/9/14 0014.
*/
@Service
public class DemoAnnotationService {
@Cacheable(expire = 300)
public List<Integer> getList(@CacheKey(key = "anyParameter") String anyParameter) {
List<Integer> list = new ArrayList();
//模拟数据库操作
System.out.println("我在查数据库呢!");
list.add(1);
list.add(2);
list.add(3);
return list;
}
}
最后是main方法
public class test {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AopConfig.class);
DemoAnnotationService demoAnnotationService = context.getBean(DemoAnnotationService.class);
List<Integer> abc = demoAnnotationService.getList("abc");
abc.forEach(System.out::println);
}
}
这一套完成之后启动main方法,多次请求发现,300s内只有第一次会打印
我在查数据库呢!
1
2
3
其余均只打印123
是不是很方便?
基于aop的redis自动缓存实现的更多相关文章
- SpringBoot AOP控制Redis自动缓存和更新
导入redis的jar包 <!-- redis --> <dependency> <groupId>org.springframework.boot</gro ...
- java基于注解的redis自动缓存实现
目的: 对于查询接口所得到的数据,只需要配置注解,就自动存入redis!此后一定时间内,都从redis中获取数据,从而减轻数据库压力. 示例: package com.itliucheng.biz; ...
- 基于AOP和Redis实现对接口调用情况的监控及IP限流
目录 需求描述 概要设计 代码实现 参考资料 需求描述 项目中有许多接口,现在我们需要实现一个功能对接口调用情况进行统计,主要功能如下: 需求一:实现对每个接口,每天的调用次数做记录: 需求二:如果某 ...
- 注解+AOP实现redis遍历缓存
1.注解 package com.yun.smart.annotation; import java.lang.annotation.ElementType; import java.lang.ann ...
- 【docker构建】基于docker搭建redis数据库缓存服务
搭建redis服务 首先拉取镜像==>运行镜像为容器 # 先搜索下redis镜像 [root@VM_0_10_centos wordpress]# docker search redis # 拉 ...
- SpringBoot集成Redis实现缓存处理(Spring AOP实现)
第一章 需求分析 计划在Team的开源项目里加入Redis实现缓存处理,因为业务功能已经实现了一部分,通过写Redis工具类,然后引用,改动量较大,而且不可以实现解耦合,所以想到了Spring框架的A ...
- ssm+redis 如何更简洁的利用自定义注解+AOP实现redis缓存
基于 ssm + maven + redis 使用自定义注解 利用aop基于AspectJ方式 实现redis缓存 如何能更简洁的利用aop实现redis缓存,话不多说,上demo 需求: 数据查询时 ...
- 基于redis分布式缓存实现
Redis的复制功能是完全建立在之前我们讨论过的基 于内存快照的持久化策略基础上的,也就是说无论你的持久化策略选择的是什么,只要用到了Redis的复制功能,就一定会有内存快照发生,那么首先要注意你 的 ...
- 【开源项目系列】如何基于 Spring Cache 实现多级缓存(同时整合本地缓存 Ehcache 和分布式缓存 Redis)
一.缓存 当系统的并发量上来了,如果我们频繁地去访问数据库,那么会使数据库的压力不断增大,在高峰时甚至可以出现数据库崩溃的现象.所以一般我们会使用缓存来解决这个数据库并发访问问题,用户访问进来,会先从 ...
随机推荐
- 【机器学习】集成学习之sklearn中的xgboost基本用法
原创博文,转载请注明出处!本文代码的github地址 博客索引地址 1.数据集 数据集使用sklearn自带的手写数字识别数据集mnist,通过函数datasets导入.mnist共1797个样 ...
- Java 多线程 2015/9/21
http://lavasoft.blog.51cto.com/62575/27069 http://blog.csdn.net/aboy123/article/details/38307539 ...
- BZOJ4550: 小奇的博弈(NIMK博弈& 组合数& DP)
4550: 小奇的博弈 Time Limit: 2 Sec Memory Limit: 256 MBSubmit: 159 Solved: 104[Submit][Status][Discuss] ...
- 十天学会单片机Day6 学会看数据手册 (IIC总线PCF859芯片( A/D D/A)应用)
1.实际电路 2.引脚图 3.地址 高四位为固定地址1001,A2A1A0可编程地址,通过观察实际电路,可知A2A1A0 为000.最低位为读写为,1为读,0为写. 4.控制字 控制寄存器的高半字节用 ...
- Servlet传统配置方式和Servlet3.0使用注解的方式
一.Servlet的传统配置方式 在JavaWeb开发中, 每次编写一个Servlet都需要在web.xml文件中进行配置,如下所示: <servlet> <servlet-name ...
- Codeforces 311B Cats Transport【斜率优化DP】
LINK 题目大意 有一些猫,放在一些位置,人一步移动一个位置 给出每个猫出现的时间,每个人可以自由安排其出发时间,沿途已经出现的猫捡起,猫等待的时间是被减去的时间减去出现的时间 猫可以等人,人不能等 ...
- BZOJ1412 ZJOI2009 狼和羊的故事 【网络流-最小割】
BZOJ1412 ZJOI2009 狼和羊的故事 Description “狼爱上羊啊爱的疯狂,谁让他们真爱了一场:狼爱上羊啊并不荒唐,他们说有爱就有方向......” Orez听到这首歌,心想:狼和 ...
- NET Core项目模板
打造自己的.NET Core项目模板 https://www.cnblogs.com/catcher1994/p/10061470.html 前言 每个人都有自己习惯的项目结构,有人的喜欢在项目里面建 ...
- String.format()格式化日期(2)
在以前的开发中,日期格式化一直使用的是SimpleDateFormat进行格式化.今天发现String.format也可以格式化.当 然,两种方式的优劣没有进行深入分析. 1. 日期格式化 (2018 ...
- 接口结构+一个selenium例子
大家今天可以先建一个项目目录,明天我们在码代码: 我看好多朋友都在看selenium方面的东西,在这里给大家一个和讯网自动发文章的selenium代码,有兴趣的朋友可以试试,船长已亲测可用,不明白的地 ...