Spring AOP

AOP

Aspect Oriented Programming 面向方面编程戒面向切面编程
AOP 关注点是共同处理，可以通过配置将其作用到某一个戒多个目标对象上。好处是实现组件重复
利用，改善程序结构，提高灵活性。将共通组件不目标对象解耦。

AOP 相关概念

• 1) Aspect 切面（方面）
  指的是共通业务处理，可以切入到多个目标对象，可多次使用
• 2) JoinPoint 连接点
  指的是切面组件在目标对象上作用的位置，例如：方法上戒者发生异常
• 3) Pointcut 切入点
  切入点是连接点的集合，采用表达式指定
• 4) Target Object 目标对象
• 5) Advice 通知
  指的是切面组件在连接点上执行的劢作。例如：在方法调用前、方法调用后、方法调用前后等
• 6) AutoProxy 劢态代理
  采用了 AOP之后，容器返回的对象是代理对象。用户在使用时，由代理对象调用切面组件和目标对象的功能
  a. 目标对象有接口采用 JDK 代理、
  b. 目标对象没有接口采用 CGLIB 代理

导入jar包

编写spring的配置文件applicationContext.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd
        "
        xmlns:util="http://www.springframework.org/schema/util"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"    
        >
    <!-- configure the package for spring to scan -->
    <context:component-scan base-package="test.Spring.AOP" />
    <!-- make the aspectj annotation to be used -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

HelloWordImpl

public interface HelloWord {
    public int sayHello(int num);
}
@Component
public class HelloWordImpl implements HelloWord{
    public int sayHello(int num){
        System.out.println("hello word");
        return 100/num;
    }
}

SpringAOP注释的类型

• @Before 前置通知 在方法执行前执行
• @After 后置通知 在方法执行后执行
• @AfterThrowing 异常通知 在方法抛出异常之后执行
• @AfterReturning 返回通知 在方法返回结果之后执行
• @Around 环绕通知 环绕着方法执行

@Component
@Aspect
public class HelloWordAspect {
    @Before(value="execution(* test.Spring.AOP.HelloWord.sayHello(..))")
    public void beforeMethod(JoinPoint jp){
        String methodName = jp.getSignature().getName();
        System.out.println(methodName);
        System.out.println("before method execute,args are "+Arrays.toString(jp.getArgs()));
    }
    @After("execution(* test.Spring.AOP.HelloWord.sayHello(..))")
    public void afterMethod(JoinPoint jp){
        System.out.println("after method execute,args are "+Arrays.toString(jp.getArgs()));
    }
    @AfterThrowing(value="execution(* test.Spring.AOP.HelloWord.sayHello(..))",throwing="ex")
    public void afterThrow(Exception ex){
        System.out.println("afterThrow"+ex.getMessage());    
    }
    @AfterReturning(value="execution(* test.Spring.AOP.HelloWord.sayHello(..))",returning="result")
    public void afterReturn(Object result){
        System.out.println("the result is "+result);
    }
}

主函数

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextForAOP.xml");
        HelloWord hw = (HelloWord) context.getBean("helloWordImpl");
        hw.sayHello(10);
    }
}

使用Around环绕通知切面类实现类似效果

@Component
@Aspect
public class HelloWordAspectAround {
    @Around(value="execution(* test.Spring.AOP.HelloWord.sayHello(..)))")
    public Object aroundMethod(ProceedingJoinPoint pjp){
        Object result = null;
        String methodName = pjp.getSignature().getName();
        try {
            result = pjp.proceed();        
            System.out.println("the result is "+result);
        } catch (Throwable e) {
            System.out.println("Exception occurs : "+e.getMessage());
            throw new RuntimeException(e);
        }
        System.out.println(methodName+" end");
        return result;
    }
}