Spring AOP 切面@Around注解的用法说明

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.reflect.MethodSignature;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import javax.persistence.EntityManager;

/**

  * 控制器切面

  *

  * @author lichuang

  */

@Component

@Aspect

public class ControllerAspect {

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

  @Autowired

  private EntityManager entityManager;

  /**

   * 调用controller包下的任意类的任意方法时均会调用此方法

   */

  @Around ( "execution(* com.company.controller.*.*(..))" )

  public Object run1(ProceedingJoinPoint joinPoint) throws Throwable {

   //获取方法参数值数组

   Object[] args = joinPoint.getArgs();

   //得到其方法签名

   MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

   //获取方法参数类型数组

   Class[] paramTypeArray = methodSignature.getParameterTypes();

   if (EntityManager. class .isAssignableFrom(paramTypeArray[paramTypeArray.length - 1 ])) {

    //如果方法的参数列表最后一个参数是entityManager类型，则给其赋值

    args[args.length - 1 ] = entityManager;

   }

   logger.info( "请求参数为{}" ,args);

   //动态修改其参数

   //注意，如果调用joinPoint.proceed()方法，则修改的参数值不会生效，必须调用joinPoint.proceed(Object[] args)

   Object result = joinPoint.proceed(args);

   logger.info( "响应结果为{}" ,result);

   //如果这里不返回result，则目标对象实际返回值会被置为null

   return result;

  }

  @Pointcut ( "execution(* com.company.controller.*.*(..))" )

  public void pointCut2() {}

  @Around ( "pointCut2()" )

  public Object run2(ProceedingJoinPoint joinPoint) throws Throwable {

   //获取方法参数值数组

   Object[] args = joinPoint.getArgs();

   //得到其方法签名

   MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

   //获取方法参数类型数组

   Class[] paramTypeArray = methodSignature.getParameterTypes();

   if (EntityManager. class .isAssignableFrom(paramTypeArray[paramTypeArray.length - 1 ])) {

    //如果方法的参数列表最后一个参数是entityManager类型，则给其赋值

    args[args.length - 1 ] = entityManager;

   }

   logger.info( "请求参数为{}" ,args);

   //动态修改其参数

   //注意，如果调用joinPoint.proceed()方法，则修改的参数值不会生效，必须调用joinPoint.proceed(Object[] args)

   Object result = joinPoint.proceed(args);

   logger.info( "响应结果为{}" ,result);

   //如果这里不返回result，则目标对象实际返回值会被置为null

   return result;

  }

}

method start time: 1480223298250

userHello

method end time: 1480223299250

package me.laiyijie.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import me.laiyijie.demo.service.HelloInterface;

public class App {

  public static void main(String[] args) {

   ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( "root-context.xml" );

   HelloInterface userService = context.getBean(HelloInterface. class );

   userService.sayHello();

   context.close();

  }

}

package me.laiyijie.demo.service;

public interface HelloInterface{

  void sayHello();

}

package me.laiyijie.demo.service;

import org.springframework.stereotype.Service;

@Service

public class UserServiceImpl implements HelloInterface {

  public void sayHello() {

   try {

    Thread.sleep( 1000 );

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

   System.out.println( "userHello" );

  }

}

package me.laiyijie.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.stereotype.Service;

@Service

@Aspect

public class TimeMonitor {

  @Around ( "execution(* me.laiyijie.demo.service.UserServiceImpl.sayHello(..))" )

  public void monitorAround(ProceedingJoinPoint pjp) throws Throwable {

   System.out.println( "method start time:" + System.currentTimeMillis());

   Object re = pjp.proceed();

   System.out.println( "method end time:" + System.currentTimeMillis());

  }

}

@Around ( "execution(* me.laiyijie.demo.service.UserServiceImpl.sayHello(..))" )

execution(* me.laiyijie.demo.service.UserServiceImpl.sayHello(..))

public Object monitorAround(ProceedingJoinPoint pjp)

<? 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:context = "http://www.springframework.org/schema/context"

  xmlns:aop = "http://www.springframework.org/schema/aop"

  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd

   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

  < aop:aspectj-autoproxy ></ aop:aspectj-autoproxy >

  < context:component-scan base-package = "me.laiyijie.demo" ></ context:component-scan >

</ beans >

< project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" >

  < modelVersion >4.0.0</ modelVersion >

  < groupId >me.laiyijie</ groupId >

  < artifactId >demo</ artifactId >

  < version >0.0.1-SNAPSHOT</ version >

  < packaging >jar</ packaging >

  < dependencies >

   <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->

   < dependency >

    < groupId >org.springframework</ groupId >

    < artifactId >spring-context</ artifactId >

    < version >4.3.2.RELEASE</ version >

   </ dependency >

   <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->

   < dependency >

    < groupId >org.aspectj</ groupId >

    < artifactId >aspectjweaver</ artifactId >

    < version >1.8.9</ version >

   </ dependency >

  </ dependencies >

</ project >