Spring AOP原理之代理模式

代理模式

静态代理模式

该模式分为三个角色，首先定义一个顶层抽象接口，然后有两个类分别实现它，一个核心功能角色类，负责核心功能的逻辑开发；另一个就是代理角色类，实现接口，同时持有一个核心功能角色，同时他只专注于其他功能的开发，核心功能由传入的核心角色进行。代码如下：
抽象角色接口

//一个明星接口
public interface Star {
	//演唱之前收门票
    void ticket();
    //演唱
    void sing();
    //收钱
    void money();
}

真实明星类

public class RealStar implements Star {
    private  String name;
    public RealStar(String name) {
        this.name = name;
    }

    @Override
    public void ticket() {
        System.out.println("卖票");
    }

    @Override
    public void sing() {
        System.out.println("RealStar:"+name+"唱歌");
    }

    @Override
    public void money() {
        System.out.println("收钱");
    }
}

//代理角色类

public class ProxyStar implements Star {
	//传入真实角色
    private Star realstar;

    public ProxyStar(Star realstar) {
        this.realstar = realstar;
    }

    @Override
    public void ticket() {
        System.out.println("卖票");
    }
	//核心功能由真实角色负责
    @Override
    public void sing() {
        realstar.sing();
    }

    @Override
    public void money() {
        System.out.println("收钱");
    }
}

测试

public static void main(String[] args) {
        Star star = new RealStar("小陈");
        Star ps = new ProxyStar(star);

        ps.sing();
    }

静态代理模式

由静态代理模式的demo，我们大概了解了代理模式主要工作原理，但是我们需要手动创建代理角色类，那么在Spring中我们如何进行自动管理呢，这就用到了动态代理模式
代码
首先，在抽象角色接口和真实角色类没有区别，

• 主要在于动态代理模式创建了一个实现InvocationHandler 的handler类 来对所有的方法进行集中管理
  代码

public class ProxyHandler implements InvocationHandler {
    private Star star;

    public ProxyHandler(Star star) {
        this.star = star;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       star.ticket();
        method.invoke(star,args);
        star.money();
        return null;
    }
}

测试类

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        Star star = new RealStar("czh");

        ProxyHandler handler = new ProxyHandler(star);
		//利用reflect.Proxy生成一个代理对象
        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);

        proxy.sing();
    }
}

我们可以看到 我们在测试中只调用了核心方法，但是全部都执行了，因为我们是将handler对象统一丢入，所以都会执行。 这就是Spring AOP功能实现的原理的一种。