Spring AOP 切面学习随笔

2019-08-08 00:00:00 学习 切面 随笔

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

 

声明

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

相关文章