Spring-AOP

Spring之AOP

什么是aop?
aop的意思是：面向方面编程（Aspect-Oriented Programming），将一批具备逻辑相关性的类视作一个切面，并以切面为单位，添加功能；通常用于实现具备横切性质的系统级服务，它是与oop（面向对象编程）互为补充的思想。

它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向切面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“切面”了。

作为面向对象的一种补充，广泛地应用于一些横切性质的系统级服务，例如权限控制、内容传递、性能优化等

(功能如下图所示)



AOP的名词解释：

连接点 JoinPoint ： 可以被切入的点，通常是方法。连接点对象描述了当前连接点的信息，比如，目标对象、方法信息、参数等

切面 Aspect ： 将切面模块化，包含了要切入的功能，切入点等

织入 Weaving: 将切面应用到目标对象的过程

切入点 PointCut ： 需要织入通知的连接点，通常用SPEL描述

引入 Introduction： 对目标对象添加方法和属性

通知 Advice ： 需要向切面加入的功能

代理 Proxy : AOP的一种实现方式


aop的实现原理

aop是通过代理模式，提供了一个代理类，实现了被代理类的一个共同接口，然后在代理类中持有一个被代理类的实例，在被代理类中添加代码，从而达到添加功能的目的。

静态代理

静态代理(Static Proxy)：由程序员创建或特定工具自动生成源代码，再对其编译。

动态代理（Dynamic Proxy）：在程序运行时，运用反射机制动态创建

代码实现静态代理

//声明一个接口
public interface KillPigService {

    double kill(String pigName);

}


//被代理的类，实现声明的接口
public class KillPigServiceImpl implements KillPigService {

    public double kill(String pigName) {
        System.out.println("屠宰："+pigName);
        return 100;
    }
}

//创建代理的类
public class KillPigServiceImplProxy implements KillPigService {
//持有被代理的类的实例
    private KillPigServiceImpl killPigServiceImpl = new KillPigServiceImpl();
    
    public double kill(String pigName) {
    //添加功能
        System.out.println("执行 killPigServiceImpl#kill方法，参数为"+pigName);

        long before = System.currentTimeMillis();
        double result =  killPigServiceImpl.kill(pigName);
        long after = System.currentTimeMillis();

        System.out.println("执行 killPigServiceImpl#kill方法结束,耗时"+(after-before)+"毫秒");

        return result;
    }
}


public class ProxyApp {
    public static void main(String[] args) {
       //创建代理类的实例
          KillPigService kps = new KillPigServiceImplProxy();
        kps.kill("八戒");

      
    }
}

代码实现动态代理

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public Object getProxy(Object target){
        this.target=target;
        //this指的是当前实例，当前实例持有了被代理的实例
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName() + "执行，参数为"+ Arrays.toString(args));
        long before = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long after = System.currentTimeMillis();
        System.out.println(method.getName() + "执行，耗时"+(after-before)+"毫秒");

        return result;
    }
}

public class ProxyApp {
    public static void main(String[] args) {
       //创建代理类的实例
          KillPigService proxy = (KillPigService)new DynamicProxy().getProxy(new KillPigServiceImpl());
        proxy.kill("佩奇");