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

r囧r小猫 2022-08-18 11:52 125阅读 0赞

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);
    		}
    	}
    }