利用spring的拦截器自定义缓存的实现实例代码

本文研究的主要是利用spring的拦截器自定义缓存的实现,具体实现代码如下所示。

Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、数据库驱动网站的速度。本文利用Memcached 的实例和spring的拦截器实现缓存自定义的实现。利用拦截器读取自定义的缓存标签,key值的生成策略。

自定义的Cacheable

package com.jeex.sci;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
	String namespace();
	String key() default "";
	int[] keyArgs() default {
	}
	;
	String[] keyProperties() default {
	}
	;
	String keyGenerator() default "";
	int expires() default 1800;
}

自定义的CacheEvict

package com.jeex.sci;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheEvict {
	String namespace();
	String key() default "";
	int[] keyArgs() default {
	}
	;
	String[] keyProperties() default {
	}
	;
	String keyGenerator() default "";
}

spring如果需要前后通知的话,一般会实现MethodInterceptor public Object invoke(MethodInvocation invocation) throws Throwable

public Object invoke(MethodInvocation invoction) throws Throwable {
	Method method = invoction.getMethod();
	Cacheable c = method.getAnnotation(Cacheable.class);
	if (c != null) {
		return handleCacheable(invoction, method, c);
	}
	CacheEvict ce = method.getAnnotation(CacheEvict.class);
	if (ce != null) {
		return handleCacheEvict(invoction, ce);
	}
	return invoction.proceed();
}

处理cacheable标签

private Object handleCacheable(MethodInvocation invoction, Method method,
    Cacheable c) throws Throwable {
	String key = getKey(invoction, KeyInfo.fromCacheable(c));
	if (key.equals("")) {
		if (log.isDebugEnabled()){
			log.warn("Empty cache key, the method is " + method);
		}
		return invoction.proceed();
	}
	long nsTag = (long) memcachedGet(c.namespace());
	if (nsTag == null) {
		nsTag = long.valueOf(System.currentTimeMillis());
		memcachedSet(c.namespace(), 24*3600, long.valueOf(nsTag));
	}
	key = makeMemcachedKey(c.namespace(), nsTag, key);
	Object o = null;
	o = memcachedGet(key);
	if (o != null) {
		if (log.isDebugEnabled()) {
			log.debug("CACHE HIT: Cache Key = " + key);
		}
	} else {
		if (log.isDebugEnabled()) {
			log.debug("CACHE MISS: Cache Key = " + key);
		}
		o = invoction.proceed();
		memcachedSet(key, c.expires(), o);
	}
	return o;
}

处理cacheEvit标签

private Object handleCacheEvict(MethodInvocation invoction,
    CacheEvict ce) throws Throwable {
  String key = getKey(invoction, KeyInfo.fromCacheEvict(ce));    

  if (key.equals("")) {
    if (log.isDebugEnabled()) {
      log.debug("Evicting " + ce.namespace());
    }
    memcachedDelete(ce.namespace());
  } else {
    Long nsTag = (Long) memcachedGet(ce.namespace());
    if (nsTag != null) {
      key = makeMemcachedKey(ce.namespace(), nsTag, key);
      if (log.isDebugEnabled()) {
        log.debug("Evicting " + key);
      }
      memcachedDelete(key);
    }
  }
  return invoction.proceed();
} 

根据参数生成key

//使用拦截到方法的参数生成参数
private String getKeyWithArgs(Object[] args, int[] argIndex) {
  StringBuilder key = new StringBuilder();
  boolean first = true;
  for (int index: argIndex) {
    if (index < 0 || index >= args.length) {
      throw new IllegalArgumentException("Index out of bound");
    }
    if (!first) {
      key.append(':');
    } else {
      first = false;
    }
    key = key.append(args[index]);
  }
  return key.toString();
} 

根据属性生成key

private String getKeyWithProperties(Object o, String props[])
    throws Exception {
  StringBuilder key = new StringBuilder();
  boolean first = true;
  for (String prop: props) {
    //把bean的属性转为获取方法的名字
    String methodName = "get"
        + prop.substring(0, 1).toUpperCase()
        + prop.substring(1);
    Method m = o.getClass().getMethod(methodName);
    Object r = m.invoke(o, (Object[]) null);
    if (!first) {
      key.append(':');
    } else {
      first = false;
    }
    key = key.append(r);
  }
  return key.toString();
} 

利用自定义的生成器生成key

//使用生成器生成key
private String getKeyWithGenerator(MethodInvocation invoction, String keyGenerator)
    throws Exception {
  Class<?> ckg = Class.forName(keyGenerator);
  CacheKeyGenerator ikg = (CacheKeyGenerator)ckg.newInstance();
  return ikg.generate(invoction.getArguments());
} 

保存key信息的帮助类

private static class KeyInfo {
	String key;
	int[] keyArgs;
	String keyProperties[];
	String keyGenerator;
	static KeyInfo fromCacheable(Cacheable c) {
		KeyInfo ki = new KeyInfo();
		ki.key = c.key();
		ki.keyArgs = c.keyArgs();
		ki.keyGenerator = c.keyGenerator();
		ki.keyProperties = c.keyProperties();
		return ki;
	}
	static KeyInfo fromCacheEvict(CacheEvict ce) {
		KeyInfo ki = new KeyInfo();
		ki.key = ce.key();
		ki.keyArgs = ce.keyArgs();
		ki.keyGenerator = ce.keyGenerator();
		ki.keyProperties = ce.keyProperties();
		return ki;
	}
	String key() {
		return key;
	}
	int[] keyArgs() {
		return keyArgs;
	}
	String[] keyProperties() {
		return keyProperties;
	}
	String keyGenerator() {
		return keyGenerator;
	}
}

参数的设置

//使用参数设置key
@Cacheable(namespace="BlackList", keyArgs={0, 1})
public int anotherMethond(int a, int b) {
  return 100;
} 

测试类:

package com.jeex.sci.test;
import net.spy.memcached.MemcachedClient;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class TestMain {
	public static void main(String args[]) throws InterruptedException{
		ApplicationContext ctx = new FileSystemXmlApplicationContext("/src/test/resources/beans.xml");
		MemcachedClient mc = (MemcachedClient) ctx.getBean("memcachedClient");
		BlackListDaoImpl dao = (BlackListDaoImpl)ctx.getBean("blackListDaoImpl");
		while (true) {
			System.out.println("################################GETTING START######################");
			mc.flush();
			BlackListQuery query = new BlackListQuery(1, "222.231.23.13");
			dao.searchBlackListCount(query);
			dao.searchBlackListCount2(query);
			BlackListQuery query2 = new BlackListQuery(1, "123.231.23.14");
			dao.anotherMethond(333, 444);
			dao.searchBlackListCount2(query2);
			dao.searchBlackListCount3(query2);
			dao.evict(query);
			dao.searchBlackListCount2(query);
			dao.evictAll();
			dao.searchBlackListCount3(query2);
			Thread.sleep(300);
		}
	}
}

总结

以上就是本文关于利用spring的拦截器自定义缓存的实现实例代码的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

您可能感兴趣的文章:

  • SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法
  • springboot+mybatis+redis 二级缓存问题实例详解
  • SpringBoot项目中使用redis缓存的方法步骤
  • Spring AOP实现Redis缓存数据库查询源码
  • SpringMVC拦截器实现单点登录
  • SpringMVC拦截器实现监听session是否过期详解
  • 防止SpringMVC拦截器拦截js等静态资源文件的解决方法
  • 详解SpringMVC拦截器配置及使用方法
(0)

相关推荐

  • SpringMVC拦截器实现单点登录

    单点登录的功能在实际的应用场景中还是很重要的,逻辑上我们也不允许一个用户同时在进行着两个操作,下面就来了解一下SpringMVC的单点登录实现 SpringMVC的拦截器不同于Spring的拦截器,SpringMVC具有统一的入口DispatcherServlet,所有的请求都通过DispatcherServlet,所以只需要在DispatcherServlet上做文章即可,DispatcherServlet也没有代理,同时SpringMVC管理的Controller也不有代理. 1,先探究一个

  • Spring AOP实现Redis缓存数据库查询源码

    应用场景 我们希望能够将数据库查询结果缓存到Redis中,这样在第二次做同样的查询时便可以直接从redis取结果,从而减少数据库读写次数. 需要解决的问题 操作缓存的代码写在哪?必须要做到与业务逻辑代码完全分离. 如何避免脏读? 从缓存中读出的数据必须与数据库中的数据一致. 如何为一个数据库查询结果生成一个唯一的标识?即通过该标识(Redis中为Key),能唯一确定一个查询结果,同一个查询结果,一定能映射到同一个key.只有这样才能保证缓存内容的正确性 如何序列化查询结果?查询结果可能是单个实体

  • SpringMVC拦截器实现监听session是否过期详解

    本文主要向大家介绍了SpringMVC拦截器实现:当用户访问网站资源时,监听session是否过期的代码,具体如下: 一.拦截器配置 <mvc:interceptors> <mvc:interceptor> <mvc:mapping path="/**"/> <mvc:exclude-mapping path="/user/login"/> <!-- 不拦截登录请求 --> <mvc:exclude-

  • springboot+mybatis+redis 二级缓存问题实例详解

    前言 什么是mybatis二级缓存? 二级缓存是多个sqlsession共享的,其作用域是mapper的同一个namespace. 即,在不同的sqlsession中,相同的namespace下,相同的sql语句,并且sql模板中参数也相同的,会命中缓存. 第一次执行完毕会将数据库中查询的数据写到缓存,第二次会从缓存中获取数据将不再从数据库查询,从而提高查询效率. Mybatis默认没有开启二级缓存,需要在全局配置(mybatis-config.xml)中开启二级缓存. 本文讲述的是使用Redi

  • 防止SpringMVC拦截器拦截js等静态资源文件的解决方法

    SpringMVC提供<mvc:resources>来设置静态资源,但是增加该设置如果采用通配符的方式增加拦截器的话仍然会被拦截器拦截,可采用如下方案进行解决: 方案一.拦截器中增加针对静态资源不进行过滤(涉及spring-mvc.xml) <mvc:resources location="/" mapping="/**/*.js"/> <mvc:resources location="/" mapping=&quo

  • SpringBoot项目中使用redis缓存的方法步骤

    本文介绍了SpringBoot项目中使用redis缓存的方法步骤,分享给大家,具体如下: Spring Data Redis为我们封装了Redis客户端的各种操作,简化使用. - 当Redis当做数据库或者消息队列来操作时,我们一般使用RedisTemplate来操作 - 当Redis作为缓存使用时,我们可以将它作为Spring Cache的实现,直接通过注解使用 1.概述 在应用中有效的利用redis缓存可以很好的提升系统性能,特别是对于查询操作,可以有效的减少数据库压力. 具体的代码参照该

  • 详解SpringMVC拦截器配置及使用方法

    本文介绍了SpringMVC拦截器配置及使用方法,分享给大家,具体如下: 常见应用场景 1.日志记录:记录请求信息的日志,以便进行信息监控.信息统计.计算PV(Page View)等. 2.权限检查:如登录检测,进入处理器检测检测是否登录,如果没有直接返回到登录页面: 3.性能监控:有时候系统在某段时间莫名其妙的慢,可以通过拦截器在进入处理器之前记录开始时间,在处理完后记录结束时间,从而得到该请求的处理时间(如果有反向代理,如apache可以自动记录): 4.通用行为:读取cookie得到用户信

  • SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法

    介绍 使用mybatis时可以使用二级缓存提高查询速度,进而改善用户体验. 使用redis做mybatis的二级缓存可是内存可控<如将单独的服务器部署出来用于二级缓存>,管理方便. 1.在pom.xml文件中引入redis依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifac

  • 利用spring的拦截器自定义缓存的实现实例代码

    本文研究的主要是利用spring的拦截器自定义缓存的实现,具体实现代码如下所示. Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.本文利用Memcached 的实例和spring的拦截器实现缓存自定义的实现.利用拦截器读取自定义的缓存标签,key值的生成策略. 自定义的Cacheable package com.jeex.sci; @Target(ElementT

  • vue下axios拦截器token刷新机制的实例代码

    //创建http.js文件,以下是具体代码: //引入安装的axios插件 import axios from 'axios' import router from '@/router'; import Vue from 'vue' const qs = require("qs"); let _this = new Vue(); let isLock = false; let refreshSubscribers = []; //判断token是否过期 function isToken

  • Spring Boot拦截器实现步骤及测试实例

    第一步,定义拦截器: package com.zl.interceptor; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public

  • Spring Boot如何利用拦截器加缓存完成接口防刷操作

    目录 为什么需要接口防刷 技术解析 主要代码 测试结果 总结 为什么需要接口防刷 为了减缓服务器压力,将服务器资源留待给有价值的请求,防止恶意访问,一般的程序都会有接口防刷设置,接下来介绍一种简单灵活的接口防刷操作 技术解析 主要采用的技术还是拦截+缓存,我们可以通过自定义注解,将需要防刷的接口给标记出来管理,利用缓存统计指定时间区间里,具体的某个ip访问某个接口的频率,如果超过某个阈值,就让他进一会儿小黑屋,到期自动解放 主要代码 前置环境搭建,Spring Boot项目,引入Web和Redi

  • SpringBoot中利用AOP和拦截器实现自定义注解

    目录 前言 Spring实现自定义注解 1.引入相关依赖 2.相关类 Java实现自定义注解 通过Cglib实现 通过JDk动态代理实现 Cglib和JDK动态代理的区别 写在最后 前言 最近遇到了这样一个工作场景,需要写一批dubbo接口,再将dubbo接口注册到网关中,但是当dubbo接口异常的时候会给前端返回非常不友好的异常.所以就想要对异常进行统一捕获处理,但是对于这种service接口使用@ExceptionHandler注解进行异常捕获也是捕获不到的,应为他不是Controller的

  • 使用Spring方法拦截器MethodInterceptor

    目录 Spring方法拦截器MethodInterceptor 前言 Spring拦截器实现+后台原理(MethodInterceptor) MethodInterceptor MethodInterceptor接口 AspectJ的注解 简单介绍下关键词 切面设置 execution表达式 下面分析下Spring @Aspect Spring方法拦截器MethodInterceptor 前言 实现MethodInterceptor 接口,在调用目标对象的方法时,就可以实现在调用方法之前.调用方

  • 一文了解Spring中拦截器的原理与使用

    目录 1.Spring中的拦截器 1.1HandlerInterceptor拦截器 1.2 MethodInterceptor拦截器 2.二者的区别 1.Spring中的拦截器 在web开发中,拦截器是经常用到的功能.它可以帮我们预先设置数据以及统计方法的执行效率等等. 今天就来详细的谈一下spring中的拦截器.spring中拦截器主要分两种,一个是HandlerInterceptor,一个是MethodInterceptor. 1.1HandlerInterceptor拦截器 Handler

  • spring boot拦截器实现IP黑名单实例代码

    前言 最近一直在搞 Hexo+GithubPage 搭建个人博客,所以没怎么进行 SpringBoot 的学习.所以今天就将上次的"?秒防刷新"进行了一番修改.上次是采用注解加拦截器(@Aspect)来实现功能的.但是,如果需求是一个全局的拦截器对于大部分URL都进行拦截的话,自己一个个加显然是不可能的.而且上次的拦截器对于Controller的参数有所要求,在实际他人引用总是显得不方便.所以,这次使用了继承HandlerInterceptor来实现拦截器. 功能需求 对于项目中某类U

  • 详解Spring AOP 拦截器的基本实现

    一个程序猿在梦中解决的 Bug 没有人是不做梦的,在所有梦的排行中,白日梦最令人伤感.不知道身为程序猿的大家,有没有睡了一觉,然后在梦中把睡之前代码中怎么也搞不定的 Bug 给解决的经历?反正我是有过. 什么是 AOP ? AOP 为 Aspect Oriented Programming 的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP 是 OOP 的延续,是软件开发中的一个热点,也是 Spring 框架中的一个重要内容,是函数式编程的一种衍生

  • spring boot拦截器的使用场景示例详解

    前言 在用户登陆之后,我们一般会把用户登陆的状态和相关信息进行存储,把对应的token返回到客户端进行存储,下次请求过来时,系统可以通过token拿到当前这个用户的相关信息,这是授权通常的作法,而有时一些业务里,你存储的用户信息不是全局的,可能只是某几个接口会用户某些信息,而你把它存储起来就不是很合理:并且一些隐私信息持久化到redis也不合理,这时就需要统一对这种接口的请求做一起处理了. 拦截器HandlerInterceptor 我们可以去实现这个HandlerInterceptor接口,它

随机推荐