面向切面编程AOP

一、简介

1、AOP

Aspect Oriented Programming的缩写，为面向切面编程，通过预编译和运行期动态代理实现程序功能。

是OOP的延续，是函数式编程的一种衍生范型。

2、作用及优势

• 作用：在程序运行期间，在不修改源码的前提下对方法进行功能增强。
• 优势：减少代码重复，提高开发效率，便于维护

3、底层实现

通过Spring提供的动态代理技术实现，在运行期间，Spring通过动态代理技术动态生成代理对象，代理对象方法执行时进行增强功能的介入。

4、AOP的动态代理技术

• JDK代理：基于接口的动态代理技术
• cglib代理：基于父类的动态代理技术

5、jdk动态代理

import org.junit.Test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkTest {

    @Test
    public void testTarget() {
        final Target target = new Target();
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("前置增强代码");
                        Object invoke = method.invoke(target, args);
                        System.out.println("后置增强代码");
                        return invoke;
                    }
                }
        );
        proxy.method();
    }
}

interface TargetInterface {
    public void method();
}

class Target implements  TargetInterface {

    public void method() {
        System.out.println("Target running");
    }
}

6、cglib动态代理

import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibTest {

    @Test
    public void testCglib(){
        final Target target = new Target();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Target.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("前置代码增强");
                Object invoke = method.invoke(target, objects);
                System.out.println("后置代码增强");
                return invoke;
            }
        });
        Target proxy = (Target) enhancer.create();
        proxy.method();
    }
}

7、相关概念

• Target（目标对象）：代理的目标对象
• Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
• Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
• Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
• Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
• Aspect（切面）：是切入点和通知（引介）的结合
• Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

二、基于XML的AOP开发

1、快速入门

1. 导入AOP的相关坐标

   <dependency>
       <groupId>org.aspectj</groupId>
       <artifactId>aspectjweaver</artifactId>
       <version>1.8.13</version>
   </dependency>
   

2. 创建目标接口和目标类

   package xyz.nchu200462.aop;
   
   public interface TargetInterface {
       public void method();
   }
   

   package xyz.nchu200462.aop.impl;
   
   import xyz.nchu200462.aop.TargetInterface;
   
   public class Target implements TargetInterface {
       @Override
       public void method() {
           System.out.println("Target running");
       }
   }
   

3. 创建切面类

   package xyz.nchu200462.aop;
   
   public class MyAspect {
       public void before(){
           System.out.println("前置代码增强");
       }
   }
   

4. 将目标类和切面类的创建权给Spring

   <bean id="target" class="xyz.nchu200462.aop.impl.Target"/>
   <bean id="myAspect" class="xyz.nchu200462.aop.MyAspect"/>
   

5. 在applicationContext.xml中织入关系

   • 引入命名空间

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

   • 织入关系

     <aop:config>
         <aop:aspect ref="myAspect">
             <aop:before method="before" pointcut="execution(public void xyz.nchu200462.aop.impl.Target.method())"></aop:before>
         </aop:aspect>
     </aop:config>
     

6. 测试

   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Controller;
   import org.springframework.test.context.ContextConfiguration;
   import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
   import xyz.nchu200462.aop.TargetInterface;
   
   @RunWith(SpringJUnit4ClassRunner.class)
   @ContextConfiguration("classpath:applicationContext.xml")
   public class SpringAopTest {
   
       @Autowired
       private TargetInterface target;
   
       @Test
       public void test1(){
           target.method();
       }
   }
   

2、详解

1. 切点表达式写法

语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数)

• 访问修饰符可以省略
• 返回值类型、包名、类名、方法名可以使用星号* 代表任意
• 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
• 参数列表可以使用两个点 … 表示任意个数，任意类型的参数

execution(public void com.itheima.aop.Target.method())
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

2. 通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

• 前置通知：<aop:before>
• 后置通知：<aop:after-returning>
• 环绕通知：<aop:around>
• 异常抛出通知：<aop:throwing>
• 最终通知：<aop:after>

3. 切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut属性来引用抽取后的切点表达式

<aop:config>
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* xyz.nchu200462.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

三、基于注解的AOP开发

1、快速入门

1. 创建目标接口和目标类及切面类

点击跳转

2. 将目标类和切面类对象的创建权给Spring

package xyz.nchu200462.aop.impl;

import org.springframework.stereotype.Component;
import xyz.nchu200462.aop.TargetInterface;

@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running");
    }
}

package xyz.nchu200462.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* xyz.nchu200462.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强");
    }
}

2、注解通知的类型

• 前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
• 后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
• 环绕通知 @Around 用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
• 异常抛出通知 @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行
• 最终通知 @After 用于配置最终通知。无论增强方式执行是否有异常都会

3、切点表达式的抽取

package xyz.nchu200462.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强");
    }
    @Pointcut("execution(* xyz.nchu200462.aop.*.*(..))")
    public void myPoint(){}
}