一：Spring AOP 切面写法参考及相关内容解释

由于使用的是spring框架，对象都是由spring统一管理的，所以最后使用的是 Spring AOP 切面编程来统一记录接口的执行时间，具体代码如下（基于注解的方式）：

第一步：定义注解：

“

package com.test.Config.annotation;

import java.lang.annotation.Documented;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface AopLoggerFilter {

}

”

第二步：写相关切面内容

@Component

@Aspect

public class AopLoggerAspect {

 private static final Logger logger = Logger.getLogger(AopLoggerAspect.class);

//定义注解格式

@Pointcut(“@annotation(com.test.Config.annotation.AopLoggerFilter)”) //定义注解在项目中的包文件名

public void pointCut() {

}

//定义切面规则

@Pointcut(“execution(public * com.iflytek.credit.platform.*.service.impl.*Impl.*(..)) || execution(public * com.iflytek.credit.platform.*.controller.*Controller.*(..))”)

public void pointCut() {

}

@Before(“pointCut()”)

    public void boBefore(JoinPoint joinPoint) {

        String methodName = joinPoint.getSignature().getName();

        logger.info(“Method Name : [” + methodName + “] —> AOP before “);

    }

    @After(“pointCut()”)

    public void doAfter(JoinPoint joinPoint) {

        String methodName = joinPoint.getSignature().getName();

        logger.info(“Method Name : [” + methodName + “] —> AOP after “);

    }

    @AfterReturning(pointcut = “pointCut()”,returning = “result”)

    public void afterReturn(JoinPoint joinPoint, Object result) {

        String methodName = joinPoint.getSignature().getName();

        logger.info(“Method Name : [” + methodName + “] —> AOP after return ,and result is : ” + result.toString());

    }

    @AfterThrowing(pointcut = “pointCut()”,throwing = “throwable”)

    public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {

        String methodName = joinPoint.getSignature().getName();

        logger.info(“Method Name : [” + methodName + “] —> AOP after throwing ,and throwable message is : ” + throwable.getMessage());

    }

    @Around(“pointCut()”)

    public Object around(ProceedingJoinPoint joinPoint) {

        String methodName = joinPoint.getSignature().getName();

        try {

            logger.info(“Method Name : [” + methodName + “] —> AOP around start”);

            long startTimeMillis = System.currentTimeMillis();

            //调用 proceed() 方法才会真正的执行实际被代理的方法

            Object result = joinPoint.proceed();

            long execTimeMillis = System.currentTimeMillis() – startTimeMillis;

            logger.info(“Method Name : [” + methodName + “] —> AOP method exec time millis : ” + execTimeMillis);

            logger.info(“Method Name : [” + methodName + “] —> AOP around end , and result is : ” + result.toString());

            return result;

        } catch (Throwable te) {

            logger.error(te.getMessage(),te);

            throw new RuntimeException(te.getMessage());

        }

    }

}

首先，需要创建一个类，然后在类名上加上两个注解

@Component

@Aspect

@Component 注解是让这个类被spring当作一个bean管理，@Aspect 注解是标明这个类是一个切面对象

类里面每个方法的注解含义如下：

@Pointcut  用于定义切面的匹配规则，如果想要同事匹配多个的话，可以使用 || 把两个规则连接起来，具体可以参照上面的代码

@Before  目标方法执行前调用

@After  目标方法执行后调用

@AfterReturning  目标方法执行后调用，可以拿到返回结果，执行顺序在 @After 之后

@AfterThrowing  目标方法执行异常时调用

@Around  调用实际的目标方法，可以在目标方法调用前做一些操作，也可以在目标方法调用后做一些操作。使用场景有：事物管理、权限控制，日志打印、性能分析等等

以上就是各个注解的含义和作用，重点的两个注解就是 @Pointcut 和 @Around 注解，@Pointcut用来指定切面规则，决定哪些地方使用这个切面；@Around 会实际的去调用目标方法，这样就可以在目标方法的调用前后做一些处理，例如事物、权限、日志等等。

需要注意的是，这些方法的执行顺序：

执行目标方法前： 先进入 around ，再进入 before 
目标方法执行完成后： 先进入 around ，再进入 after ，最后进入 afterreturning 

另外，使用spring aop 需要在spring的配置文件加上以下这行配置，以开启aop ：

<aop:aspectj-autoproxy/>

同时，maven中需要加入依赖的jar包：

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.6.12</version>
</dependency>
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.6.12</version>
</dependency>

总结一下，Spring AOP 其实就是使用动态代理来对切面层进行统一的处理，动态代理的方式有：JDK动态代理和 cglib 动态代理，JDK动态代理基于接口实现， cglib 动态代理基于子类实现。spring默认使用的是JDK动态代理，如果没有接口，spring会自动的使用cglib动态代理。

二：Spring AOP中JoinPoint的用法

1：JoinPoint 对象

JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象.

常用API

2：ProceedingJoinPoint对象

ProceedingJoinPoint对象是JoinPoint的子接口,该对象只用在@Around的切面方法中,
添加了以下两个方法。

Object proceed() throws Throwable //执行目标方法

Object proceed(Object[] var1) throws Throwable //传入的新的参数去执行目标方法

3：Demo

切面类

@Aspect

@Component

public class aopAspect {

    /**

     * 定义一个切入点表达式,用来确定哪些类需要代理

     * execution(* aopdemo.*.*(..))代表aopdemo包下所有类的所有方法都会被代理

     */

    @Pointcut(“execution(* aopdemo.*.*(..))”)

    public void declareJoinPointerExpression() {}

    /**

     * 前置方法,在目标方法执行前执行

     * @param joinPoint 封装了代理方法信息的对象,若用不到则可以忽略不写

     */

    @Before(“declareJoinPointerExpression()”)

    public void beforeMethod(JoinPoint joinPoint){

        System.out.println(

“目标方法名为:” + joinPoint.getSignature().getName()

);

        System.out.println(

“目标方法所属类的简单类名:” + joinPoint.getSignature().getDeclaringType().getSimpleName()

);

        System.out.println(

“目标方法所属类的类名:” + joinPoint.getSignature().getDeclaringTypeName()

);

        System.out.println(

“目标方法声明类型:” + Modifier.toString(joinPoint.getSignature().getModifiers())

);

        //获取传入目标方法的参数

        Object[] args = joinPoint.getArgs();

        for (int i = 0; i < args.length; i++) {

            System.out.println(“第” + (i+1) + “个参数为:” + args[i]);

        }

        System.out.println(“被代理的对象:” + joinPoint.getTarget());

        System.out.println(“代理对象自己:” + joinPoint.getThis());

    }

    /**

     * 环绕方法,可自定义目标方法执行的时机

     * @param pjd JoinPoint的子接口,添加了

     *            Object proceed() throws Throwable 执行目标方法

     *            Object proceed(Object[] var1) throws Throwable 传入的新的参数去执行目标方法

     *            两个方法

     * @return 此方法需要返回值,返回值视为目标方法的返回值

     */

    @Around(“declareJoinPointerExpression()”)

    public Object aroundMethod(ProceedingJoinPoint pjd){

        Object result = null;

        try {

            //前置通知

            System.out.println(“目标方法执行前…”);

            //执行目标方法

            //result = pjd.proeed();

            //用新的参数值执行目标方法

            result = pjd.proceed(new Object[]{“newSpring”,”newAop”});

            //返回通知

            System.out.println(“目标方法返回结果后…”);

        } catch (Throwable e) {

            //异常通知

            System.out.println(“执行目标方法异常后…”);

            throw new RuntimeException(e);

        }

        //后置通知

        System.out.println(“目标方法执行后…”);

        return result;

    }

}

被代理类

/**

 * 被代理对象

 */

@Component

public class TargetClass {

    /**

     * 拼接两个字符串

     */

    public String joint(String str1, String str2) {

        return str1 + “+” + str2;

    }

}

测试类

public class TestAop {

    @Test

    public void testAOP() {

        //1、创建Spring的IOC的容器

        ApplicationContext ctx = new ClassPathXmlApplicationContext(“classpath:bean.xml”);

        //2、从IOC容器中获取bean的实例

        TargetClass targetClass = (TargetClass) ctx.getBean(“targetClass”);

        //3、使用bean

        String result = targetClass.joint(“spring”,”aop”);

        System.out.println(“result:” + result);

    }

}

输出结果

目标方法执行前…

目标方法名为:joint

目标方法所属类的简单类名:TargetClass

目标方法所属类的类名:aopdemo.TargetClass

目标方法声明类型:public

第1个参数为:newSpring

第2个参数为:newAop

被代理的对象:aopdemo.TargetClass@4efc180e

代理对象自己:aopdemo.TargetClass@4efc180e (和上面一样是因为toString方法也被代理了)

目标方法返回结果后…

目标方法执行后…

result:newSpring+newAop

声明

内容为笔者的学习笔记,若内容有误,还请赐教!谢谢