AOP详解

一、AOP概念

1、什么是 AOP

• AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

• AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、AOP 的作用及其优势

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

3、AOP 的底层实现

• AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

4、常用的动态代理技术

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

5、JDK代理(了解)

• 代码

/**
 * 接口类
 */
public interface TargetInterface {

    void say();
}

/**
 * 目标类
 */
public class Target implements TargetInterface {
    public void say() {
        System.out.println("目标类执行了");
    }
}


 public static void main( String[] args ) {
        final Target target = new Target();
        TargetInterface proxy = (TargetInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    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.say();
    }

• Proxy.newProxyInstance() 方法是生成代理对象的，有三个参数，类加载器 ，目标类的所有接口字节码对象，InvocationHandler
• InvocationHandler ： 可以理解为一个回调函数，里面的invoke()是关键，代理对象执行方法就是在执行invoke()方法
• method.invoke(target, args);属于反射，方法的执行，代码如下，作为目前阶段的了解

public class Target {
    
    public void say1(String name) {
        System.out.println("你好"+name);
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class<Target> targetClass = Target.class;
        Method method= targetClass.getMethod("say1", String.class);
        method.invoke(targetClass.newInstance(),"tom");
    }
}

6、cglib代理（了解）

• 使用cglib的时候需要导入依赖

  
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.0.5.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.8.13version>
    dependency>

• 代码

 public static void main( String[] args ) {
        final Target target = new Target(); //创建目标对象
        Enhancer enhancer = new Enhancer();   //创建增强器
        enhancer.setSuperclass(Target.class);//设置父类
        enhancer.setCallback(new MethodInterceptor() { //设置回调
            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.say();
    }

7、AOP 相关概念

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

二、xml的AOP

1、书写步骤

• 1.1 导入 AOP 相关坐标

  
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.0.5.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.8.13version>
    dependency>

• 1.2 创建目标接口和目标类（内部有切点）

/**
 * 接口类
 */
public interface TargetInterface {

    void say();
}

/**
 * 目标类
 */
public class Target implements TargetInterface {
 	@Override
    public void say() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("目标类执行了");
    }
}

• 1.3 创建切面类（内部有增强方法）

public class MyAspect {
     //前置增强方法
    public void before(){
        System.out.println("前置代码增强了");
    }
    //后置增强方法
    public void after(){
        System.out.println("后置");
    }
    //环绕增强
    public Object around(ProceedingJoinPoint p){
        long start = System.currentTimeMillis();
        String className = p.getSignature().getDeclaringTypeName();
        String method =  p.getSignature().getName();
        Object proceed = null;
        try {
            proceed = p.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("类名：" + className);
        System.out.println("方法名是：" + method);
        System.out.println("执行时间长是:"+(end-start));
        return proceed;
    }
}

• 1.4 将目标类和切面类的对象创建权交给 spring

<bean id="target" class="com.xinzih.service.impl.Target"/>

<bean id="myAspect" class="com.xinzih.aspect.MyAspect"/>

• 1.5 在 applicationContext.xml 中配置织入关系

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="myAspect" class="com.xinzhi.aspect.MyAspect" />

    <bean id="target" class="com.xinzhi.target.impl.TargetInterfaceImpl" />

    <aop:config>
        <aop:aspect ref="myAspect">


            <aop:around method="around" pointcut="execution(* com.xinzhi.target.impl.*.*(..))"/>
        aop:aspect>
    aop:config>

beans>

• 1.6 测试代码

public static void main( String[] args ) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        TargetInterface bean = (TargetInterface)applicationContext.getBean("target");
        bean.say();
 }

2、切点表达式

execution([修饰符] 返回值类型 包名.类名.方法名(参数))
	常用的书写格式：
	execution(* 包名.*.*(..))

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

三、注解的AOP

1、书写步骤

• 1. 创建目标接口和目标类（内部有切点）
• 2. 创建切面类（内部有增强方法）
• 3. 将目标类和切面类的对象创建权交给 spring
• 4. 在切面类中使用注解配置织入关系
• 5. 在配置文件中开启组件扫描和 AOP 的自动代理
• 6. 测试

/**
 * 目标类
 */
@Component("target")
public class Target implements TargetInterface {

    public void say() {
        System.out.println("目标类执行了");
    }
}

@Component
@Aspect
public class MyAspect {
    //前置增强方法
    @Before("execution(* com.xinzhi.target.impl.*.*(..))")
    public void before(){
        System.out.println("前置代码增强了");
    }
    //后置增强方法
    @After("execution(* com.xinzhi.target.impl.*.*(..))")
    public void after(){
        System.out.println("后置");
    }
    //环绕增强
    @Around("execution(* com.xinzhi.target.impl.*.*(..))")
    public Object around(ProceedingJoinPoint p){
        long start = System.currentTimeMillis();
        String className = p.getSignature().getDeclaringTypeName();
        String method =  p.getSignature().getName();
        Object proceed = null;
        try {
            proceed = p.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("类名：" + className);
        System.out.println("方法名是：" + method);
        System.out.println("执行时间长是:"+(end-start));
        return proceed;
    }
}

<!--组件扫描-->
<context:component-scan base-package="com.xinzhi"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>