java设计模式(实战)-责任链模式

package com.huajie.aspect; 
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.huajie.annotation.ExtCacheable;
import com.huajie.common.cache.CacheHandler;
import com.huajie.common.cache.FirstCacheHadler;
import com.huajie.common.cache.RedisResult;
import com.huajie.common.cache.SecondCacheHadler;
import com.huajie.utils.RedisUtil;
import com.huajie.utils.StringUtil;
 

@Component
@Aspect
public class CacheableAspect {
 
	@Autowired
	private RedisUtil redisUtil;
 
	@Pointcut("@annotation(com.huajie.annotation.ExtCacheable)")
	public void annotationPointcut() {
	}
 
	@Around("annotationPointcut()")
	public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
		// 获得当前访问的class
		Class<?> className = joinPoint.getTarget().getClass();
		// 获得访问的方法名
		String methodName = joinPoint.getSignature().getName();
		// 得到方法的参数的类型
		Class<?>[] arGClass = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
		Object[] args = joinPoint.getArgs();
		String key = "";
		String nexTKEy = "";
		int expireTime = 1800;
		try {
			// 得到访问的方法对象
			Method method = className.getMethod(methodName, argClass);
			method.setAccessible(true);
			// 判断是否存在@ExtCacheable注解
			if (method.isAnnotationPresent(ExtCacheable.class)) {
				ExtCacheable annotation = method.getAnnotation(ExtCacheable.class);
				key = getRedisKey(args, annotation.key());
				nextKey = getRedisKey(args,annotation.nextKey());
				expireTime = getExpireTime(annotation);
			}
		} catch (Exception e) {
			throw new RuntimeException("redis缓存注解参数异常", e);
		}
		//责任链模式
		CacheHandler firstCacheHadler = new FirstCacheHadler();
		CacheHandler secondCacheHadler = new SecondCacheHadler();
		//设置下级处理者
		firstCacheHadler.setNext(secondCacheHadler);
		//获取处理级别
		int cacheLevel = getCacheLevel(key, nextKey);
		RedisResult result = new RedisResult(redisUtil, key, nextKey, joinPoint, cacheLevel, expireTime);
		//客户端调用
		return firstCacheHadler.HandleMessage(result);
	}
 
	private int getCacheLevel(String key, String nextKey) {
		if (StringUtil.isNotEmpty(key) && StringUtil.isNotEmpty(nextKey)) {
			return 2;
		} else {
			return 1;
		}
	}
 
	private int getExpireTime(ExtCacheable annotation) {
		return annotation.expireTime();
	}
 
	private String getRedisKey(Object[] args, String primalKey) {
		// 获取#p0...集合
		List<String> keyList = getKeyParsList(primalKey);
		for (String keyName : keyList) {
			int keyIndex = Integer.parseInt(keyName.toLowerCase().replace("#p", ""));
			Object parValue = args[keyIndex];
			primalKey = primalKey.replace(keyName, String.valueOf(parValue));
		}
		return primalKey.replace("+", "").replace("'", "");
	}
 
	// 获取key中#p0中的参数名称
	private static List<String> getKeyParsList(String key) {
		List<String> ListPar = new ArrayList<String>();
		if (key.indexOf("#") >= 0) {
			int plusIndex = key.substring(key.indexOf("#")).indexOf("+");
			int indexNext = 0;
			String parName = "";
			int indexPre = key.indexOf("#");
			if (plusIndex > 0) {
				indexNext = key.indexOf("#") + key.substring(key.indexOf("#")).indexOf("+");
				parName = key.substring(indexPre, indexNext);
			} else {
				parName = key.substring(indexPre);
			}
			ListPar.add(parName.trim());
			key = key.substring(indexNext + 1);
			if (key.indexOf("#") >= 0) {
				ListPar.addAll(getKeyParsList(key));
			}
		}
		return ListPar;
	} 
}

package com.huajie.common.cache;

public abstract class CacheHandler {
	// 定义处理级别
	protected final static int FirstCache_LEVEL_REQUEST = 1;
	protected final static int SecondCache_LEVEL_REQUEST = 2;
 
	// 能处理的级别
	private int level = 0;
	// 责任传递，下一个责任人是谁
	private CacheHandler nextHandler;
 
	// 每个类自己能处理那些请求
	public CacheHandler(int level) {
		this.level = level;
	}
 
	// 处理请求
	public final Object HandleMessage(RedisResult redisResult) throws Throwable {
		//如果women类型为当前处理的level
		if(redisResult.getCacheLevel()==this.level){
			return this.response(redisResult);
		}else{
			 if(null!=this.nextHandler){
				 return this.nextHandler.HandleMessage(redisResult);
			 }else{
				 //没有下级不处理
				 return null;
			 }
		}
	}
 
	public void setNext(CacheHandler handler) {
		this.nextHandler = handler;
	}
 
	// 有请示的回应
	protected abstract Object response(RedisResult redisResult) throws Throwable;
}

package com.huajie.common.cache; 
import org.aspectj.lang.ProceedingJoinPoint;
import com.huajie.utils.RedisUtil; 
public class FirstCacheHadler extends CacheHandler{ 
	public FirstCacheHadler() {
		super(CacheHandler.FirstCache_LEVEL_REQUEST);
	}
 
	@Override
	protected Object response(RedisResult redisResult) throws Throwable {
		String key = redisResult.getKey();
		RedisUtil redisUtil = redisResult.getRedisUtil();
		boolean  hasKey = redisUtil.hasKey(key);
		ProceedingJoinPoint joinPoint = redisResult.getJoinPoint();
		int expireTime = redisResult.getExpireTime();
		if (hasKey) {
			return redisUtil.get(key);
		} else {
			Object res = joinPoint.proceed();
			redisUtil.set(key, res);
			redisUtil.expire(key, expireTime);
			return res;
		}
	} 
}

package com.huajie.common.cache; 
import org.aspectj.lang.ProceedingJoinPoint;
import com.huajie.utils.RedisUtil; 
public class SecondCacheHadler extends CacheHandler { 
	public SecondCacheHadler() {
		super(CacheHandler.SecondCache_LEVEL_REQUEST);
	}
 
	@Override
	protected Object response(RedisResult redisResult) throws Throwable {
		String nextKey = redisResult.getNextKey();
		String key = redisResult.getKey();
		RedisUtil redisUtil = redisResult.getRedisUtil();
		ProceedingJoinPoint joinPoint = redisResult.getJoinPoint();
		int expireTime = redisResult.getExpireTime();
		boolean hasKey = redisUtil.hasKey(key);
		if (hasKey) {
			return redisUtil.get(key);
		} else {
			boolean hasNextKey = redisUtil.hasKey(nextKey);
			if (hasNextKey) {
				return redisUtil.get(nextKey);
			} else {
				Object res = joinPoint.proceed();
				redisUtil.set(nextKey, res);
				redisUtil.expire(nextKey, expireTime);
				return res;
			}
		}
	}
}

package com.huajie.common.cache; 
import org.aspectj.lang.ProceedingJoinPoint;
import com.huajie.utils.RedisUtil;
import lombok.Data;
 
@Data
public class RedisResult implements IRedisResult {
	private int cacheLevel;
	private Object result;
	private RedisUtil redisUtil;
	private String key;
	private String nextKey;
	private int expireTime;
	private ProceedingJoinPoint joinPoint;
 
	@Override
	public int getCacheLevel() {
		return cacheLevel;
	}
 
	@Override
	public Object getResult() {
		return result;
	}
 
	public RedisResult(RedisUtil redisUtil, String key, String nextKey, ProceedingJoinPoint joinPoint, int cacheLevel,int expireTime) {
		this.redisUtil = redisUtil;
		this.key = key;
		this.joinPoint = joinPoint;
		this.cacheLevel = cacheLevel;
		this.nextKey = nextKey;
		this.expireTime = expireTime;
	} 
}

@Override
	@ExtCacheable(key = "middle+#p0+#p1+#p2", nextKey = "middle+#p0+#p2")
	public List<MiddleManage> listMiddleManageInfo(String leadergroupId, String uuid, String yearDetailId) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("leadergroupId", leadergroupId);
		map.put("uuid", uuid);
		map.put("yearDetailId", yearDetailId);
		List<MiddleManage> middleManageDetailList = middleManageMapper.listMiddleManageInfo(map);
		return middleManageDetailList;
	}