springAOP实现方法运行时间统计

aop的before和after，寻思分别在两个方法里获得当前时间，最后一减就可以了。

因此，今天就探讨了一下这个问题，和大家分享一下。

创建maven工程，引入spring的依赖包，配置好applicationContext-aop.xml，如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.1.xsd
">

<!-- 切面所在的类包路径 -->
<context:component-scan base-package="com.product" />
<!-- 启动该切面代理 -->
<!-- <aop:aspectj-autoproxy proxy-target-class="true"/> -->

</beans>

然后，创建两个包，一个来放切面类，一个放测试类。

测试类如下

package com.product.service;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Service
public class TimeTest {

public void testMethod(){
System.out.println("执行方法");
}

public void testMethod2(){
int sum = 0;
for(int i=0;i<1000;i++){
sum += i;
}
System.out.println(sum);
System.out.println("执行方法2");
}

@SuppressWarnings("resource")
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:applicationContext-aop.xml");
TimeTest A = (TimeTest)ctx.getBean("timeTest");
A.testMethod();
//A.testMethod2();
ctx.destroy();
}

}

写这个切面类。

package com.product.test.aopTest;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MethodTimeMonitor {

private long startTime;

//声明切面类路径，类型必须为final String类型的,注解里要使用的变量只能是静态常量类型的
//public static final String POINT = "execution(* com.product.service.*.*(..))";
//也可以使用注解声明切入点,如下
@Pointcut("execution(* com.product.service.*.*(..))")
public void point(){}

@Before("point()")
public void doBefore(){
this.startTime = System.currentTimeMillis();
}

@After("point()")
public void doAfter(){
long endTime = System.currentTimeMillis();
System.out.println("方法执行了"+(endTime-this.startTime)+"ms");
}

}
现在，运行测试类，ok，看到如下结果：

说明次思路可行。

只是，当面试官继续问我before和after是写在两个方法中，那变量怎么能互通的时候，我竟然忘了它们本来就在一个类里，只需要把起始时间设为成员变量就好了，支吾了半天没答上来。

之后，笔者看了些资料，发现还有其他思路，比如aroud。

此思路和之前的没太大改变，只是在MethodTimeMonitor里，注掉之前的方法，新增around方法，如下：

@Around("point()")
public Object doAround(ProceedingJoinPoint pjp){
long startTime = System.currentTimeMillis();
Object obj = null;
try {
obj = pjp.proceed();
} catch (Throwable e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime = System.currentTimeMillis();

MethodSignature signature = (MethodSignature) pjp.getSignature();
String methodName = signature.getDeclaringTypeName() + "." + signature.getName();
System.out.println(methodName+"方法执行了"+(endTime-startTime)+"ms");
return obj;
}

好了，再次运行测试类，发现还是能得到一样的结果。

此外，笔者还了解到，aspect可以通过配置的方式实现，详见http://calatustela.iteye.com/blog/1910025。

另外，要提醒大家的是，注意：

1.配置文件尽可能放在src下，引入时直接加classpath就可以了。

2.<context:annotation-config />的作用是为使用到的注解自动配置对应的AnnotationBeanPostProcessor。而当使用自动扫描<context:component-scan 
base-package="com.product.service" />后，它兼具有上述功能，因此两者取一即可。
此外，注意使用了spring注解的类包都要包括在内，否则可能某些包没有扫描，出现意外结果。
3.spring的注解bean加载机制中，获取某个bean用context.getBean("className");不过注意，className是该类首字母小写后的类名。若要自定义，可在注解后声明，如
@Controller("Name")。详见http://blog.csdn.net/damon834274634/article/details/38725909。
---------------------

转自：https://blog.csdn.net/baidu_41722481/article/details/79379040