Spring AOP 切面学习随笔

一：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

方法名	功能
signature getsignature();	获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的class等信息
object[] getargs();	获取传入目标方法的参数对象
object gettarget();	获取被代理的对象
object getthis();	获取代理对象

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

 

声明

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