Java Around类代码示例

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("execution(* org.packt.aop.transaction.dao.impl.EmployeeDaoImpl.getEmployees(..))")
public Object cacheMonitor(ProceedingJoinPoint joinPoint) throws Throwable  {
   logger.info("executing " + joinPoint.getSignature().getName());
   Cache cache = cacheManager.getCache("employeesCache");
  
   logger.info("cache detected is  " + cache.getName());
   logger.info("begin caching.....");
   String key = joinPoint.getSignature().getName();
   logger.info(key);
   if(cache.get(key) == null){
	   logger.info("caching new Object.....");
	   Object result = joinPoint.proceed();
	   cache.put(new Element(key, result)); 	   
	   return result;
   }else{
	   logger.info("getting cached Object.....");
	   return cache.get(key).getObjectValue();
   }
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("readDao()") 
public Object aroundTemplateRead(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    ReadWriteSplittingDataSourceHolder.setReadDataSource();
    Object processResult = null;
    //需要先定位是哪个DataSourceGroupId的
    //设置为读状态
    processResult = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
    return processResult;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("execution(@org.apache.servicecomb.tracing.Span * *(..)) && @annotation(spanAnnotation)")
public Object advise(ProceedingJoinPoint joinPoint, Span spanAnnotation) throws Throwable {
  String spanName = spanAnnotation.spanName();
  String callPath = spanAnnotation.callPath();
  Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
  LOG.debug("Generating zipkin span for method {}", method.toString());
  if ("".equals(spanName)) {
    spanName = method.getName();
  }
  if ("".equals(callPath)) {
    callPath = method.toString();
  }

  return adviser.invoke(spanName, callPath, joinPoint::proceed);

}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("execution( * com.way.learning.service..*ServiceImpl.checkAnswer(..))")
public Object updateAnswerResult(ProceedingJoinPoint pjp) throws Throwable{
	System.out.println(pjp.getSignature().getName()+"() target method call....");
	Member mvo=(Member)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
	Object[ ] params=pjp.getArgs();
	int questionNo=Integer.parseInt(params[0].toString());
	String userId=mvo.getUserId();
	answerService.updatePostCntSubmit(questionNo);
	answerService.updateMyCntSubmit(questionNo,userId );
	Object result= pjp.proceed();
		if(result.toString().equals("1") ){
			answerService.updatePostCntRight(questionNo);
			answerService.updateMyCntRight(questionNo,userId );
		}else answerService.updateMyCntWrong(questionNo, userId );	
		
	return result;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("methodAnnotated() || constructorAnnotated()")//在连接点进行方法替换
public Object aroundJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    LogUtils.showLog("TimeLog getDeclaringClass", methodSignature.getMethod().getDeclaringClass().getCanonicalName());
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();
    long startTime = System.nanoTime();
    Object result = joinPoint.proceed();//执行原方法
    StringBuilder keyBuilder = new StringBuilder();
    keyBuilder.append(methodName + ":");
    for (Object obj : joinPoint.getArgs()) {
        if (obj instanceof String) keyBuilder.append((String) obj);
        else if (obj instanceof Class) keyBuilder.append(((Class) obj).getSimpleName());
    }
    String key = keyBuilder.toString();
    LogUtils.showLog("TimeLog", (className + "." + key + joinPoint.getArgs().toString() + " --->:" + "[" + (TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) + "ms]"));// 打印时间差
    return result;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("methodAnnotated()")//在连接点进行方法替换
public Object aroundJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String methodName = methodSignature.getName();
    MemoryCacheManager mMemoryCacheManager = MemoryCacheManager.getInstance();
    StringBuilder keyBuilder = new StringBuilder();
    keyBuilder.append(methodName);
    for (Object obj : joinPoint.getArgs()) {
        if (obj instanceof String) keyBuilder.append((String) obj);
        else if (obj instanceof Class) keyBuilder.append(((Class) obj).getSimpleName());
    }
    String key = keyBuilder.toString();
    Object result = mMemoryCacheManager.get(key);//key规则 ： 方法名＋参数1+参数2+...
    LogUtils.showLog("MemoryCache", "key：" + key + "--->" + (result != null ? "not null" : "null"));
    if (result != null) return result;//缓存已有，直接返回
    result = joinPoint.proceed();//执行原方法
    if (result instanceof List && result != null && ((List) result).size() > 0 //列表不为空
            || result instanceof String && !TextUtils.isEmpty((String) result)//字符不为空
            || result instanceof Object && result != null)//对象不为空
        mMemoryCacheManager.add(key, result);//存入缓存
    LogUtils.showLog("MemoryCache", "key：" + key + "--->" + "save");
    return result;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
/**
 * @param pjp the proceeding join point
 * @return the result of the method being wrapped
 * @throws Throwable
 */
@Around("springRepositories()")
public Object traceAroundRepositoryMethods(ProceedingJoinPoint pjp) throws Throwable {
    logger.trace("Advising repository");
    boolean hasClassAnnotation = false;

    for (Class<?> i : pjp.getTarget().getClass().getInterfaces()) {
        if (i.getAnnotation(XRayEnabled.class) != null) {
            hasClassAnnotation = true;
            break;
        }
    }

    if (hasClassAnnotation) {
        return this.processXRayTrace(pjp);
    } else {
        return XRayInterceptorUtils.conditionalProceed(pjp);
    }
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
/**
 * Advice that logs when a method is entered and exited.
 *
 * @param joinPoint join point for advice
 * @return result
 * @throws Throwable throws IllegalArgumentException
 */
@Around("loggingPointcut()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    if (log.isDebugEnabled()) {
        log.debug("Enter: {}.{}() with argument[s] = {}", joinPoint.getSignature().getDeclaringTypeName(),
            joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
    }
    try {
        Object result = joinPoint.proceed();
        if (log.isDebugEnabled()) {
            log.debug("Exit: {}.{}() with result = {}", joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName(), result);
        }
        return result;
    } catch (IllegalArgumentException e) {
        log.error("Illegal argument: {} in {}.{}()", Arrays.toString(joinPoint.getArgs()),
                joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());

        throw e;
    }
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("anyRepositoryMethod()")
public Object invokeWithCatTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
  String name =
      joinPoint.getSignature().getDeclaringType().getSimpleName() + "." + joinPoint.getSignature()
          .getName();
  Transaction catTransaction = Tracer.newTransaction("SQL", name);
  try {
    Object result = joinPoint.proceed();
    catTransaction.setStatus(Transaction.SUCCESS);
    return result;
  } catch (Throwable ex) {
    catTransaction.setStatus(ex);
    throw ex;
  } finally {
    catTransaction.complete();
  }
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("within(@com.minsx.spring.jpatemplate.Query *)||@annotation(com.minsx.spring.jpatemplate.Query)")
public Object handleAnnotation(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("--------------");
    Class<? extends Object> invokeClass = pjp.getTarget().getClass();
    String signatureName = pjp.getSignature().getName();
    Method methods[] = invokeClass.getMethods();
    for (Method method : methods) {
        if (method.getName().equals(signatureName)) {
            String paramCollection = method.getAnnotation(Query.class).value();
            LOGGER.info(String.format("Query sql is %s", paramCollection));
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter : parameters) {
                parameter.getName();
            }
        }
    }
    pjp.proceed();
    return new User(1, "goodsavess", "Ss123456", "[email protected]");
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("classPointcut() && delPointcut()  && @annotation(mapping)")
public String delEmployee(ProceedingJoinPoint joinPoint,  RequestMapping mapping) throws Throwable{
	   HttpServletRequest req = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
	   logger.info("executing " + joinPoint.getSignature().getName());
	   int userId = (Integer)req.getSession().getAttribute("userId");
	   System.out.println("userId" + userId);
	   
	   List<RolePermission> permission = loginServiceImpl.getPermissionSets(userId);
	   if(isAuthroize(permission)){
		   logger.info("user " + userId + " is authroied to delete");
		   joinPoint.proceed();
		   return "menu";
	   }else{
		   logger.info("user " + userId + " is NOT authroied to delete");
		   return "banned";
	   }
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
/**
 * 接收到客户端请求时执行
 *
 * @param pjp
 * @return
 * @throws Throwable
 */
@Around("controllerAspect()")
public Object execute(ProceedingJoinPoint pjp) throws Throwable {
    // 从切点上获取目标方法
    MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
    Method method = methodSignature.getMethod();
    /**
     * 验证Token
     */
    if (method.isAnnotationPresent(Token.class)) {
        // 从 request header 中获取当前 token
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader(DEFAULT_TOKEN_NAME);
        if (StringUtils.isEmpty(token)) {
            throw new TokenException("客户端X-Token参数不能为空,且从Header中传入,如果没有登录,请先登录获取Token");
        }
        // 检查 token 有效性
        if (!tokenManager.checkToken(token)) {
            String message = String.format("Token [%s] 非法", token);
            throw new TokenException(message);
        }
    }

    // 调用目标方法
    return pjp.proceed();
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("retryOnOptFailure()")
public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
    int numAttempts = 0;
    do {
        numAttempts++;
        try {
            return pjp.proceed();
        } catch (OptimisticLockingFailureException ex) {
            if (numAttempts > maxRetries) {
                //log failure information, and throw exception
                throw ex;
            } else {
                //log failure information for audit/reference
                //will try recovery
            }
        }
    } while (numAttempts <= this.maxRetries);

    return null;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
@Around("constructor()")
public Object constructProcess(ProceedingJoinPoint joinPoint) throws Throwable {
  Object result = joinPoint.proceed();
  Object puppet = joinPoint.getTarget();
  //Only inject the class that marked by Puppet annotation.

  Method onAttach = getRiggerMethod("onPuppetConstructor", Object.class);
  onAttach.invoke(getRiggerInstance(), puppet);
  return result;
}
 

import org.aspectj.lang.annotation.Around; //导入依赖的package包/类
/**
 * Aspect for logging before service calls.
 *
 * @param joinPoint joinPoint
 * @return method result
 * @throws Throwable throwable
 */
@SneakyThrows
@Around("servicePointcut() && !excluded()")
public Object logBeforeService(ProceedingJoinPoint joinPoint) {

    StopWatch stopWatch = StopWatch.createStarted();

    try {
        logStart(joinPoint);

        Object result = joinPoint.proceed();

        logStop(joinPoint, result, stopWatch);

        return result;
    } catch (Exception e) {
        logError(joinPoint, e, stopWatch);
        throw e;
    }

}