核心作用:

• 通过代理,控制对对象的访问!
  可以详细控制访问某个(某类)对象的方法,在调用这个方法前做前置处理,调用这个方法后做后置处理(即:AOP的微观实现!),从而实现将统一流程代码放到代理类中处理。
• AOP(Aspect Oriented Programming面向切面编程)的核心实现机制!

核心角色

• 抽象角色
  定义代理角色和真实角色的公共对外方法。
• 真实角色
  实现抽象角色,定义真实角色所要实现的业务逻辑，供代理角色调用。
  关注真正的业务逻辑!
• 代理角色
  实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。
  将统一的流程控制放到代理角色中处理!

应用场景

• 安全代理:屏蔽对真实角色的直接访问。
• 远程代理:通过代理类处理远程方法调用(RMI)。
• 延迟加载:先加载轻量级的代理对象,真正需要再加载真实对象。
  比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100M，在打开文件时不可能将所有的图片都显示出来，这样就可以用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

静态代理(静态定义代理类)

代理模式

package proxy.staticProxy;

public interface Star {
    void confer();          //  面谈
    void signContract();    // 签合同
    void bookTicket();      // 订票
    void sing();            // 唱歌
    void collectMoney();    // 收钱
}

package proxy.staticProxy;

public class RealStar implements Star{
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    public void sing() {
        System.out.println("RealStar(Jay).sing()");
    }

    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
}

package proxy.staticProxy;

public class ProxyStar implements Star{
    private Star star;

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

    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket()");
    }

    public void sing() {
        star.sing();
    }

    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }
}

package proxy.staticProxy;

public class Client {
    public static void main(String[] args) {
        Star Jay = new RealStar();
        Star proxy = new ProxyStar(Jay);

        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

输出:
ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTicket()
RealStar(Jay).sing()
ProxyStar.collectMoney()

动态代理(动态生成代理类)

• JDK自带的动态代理
• javaassist字节码操作库实现
• CGLIB
• ASM(底层使用指令,可维护性较差)

动态代理相比于静态代理的优点

• 抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理,这样,我们可以更加灵活和统一的处理众多的方法。

JDK自带的动态代理

• java.lang.reflect.Proxy
  作用:动态生成代理类和对象
• java.lang.reflect.InvocationHandler(处理器接口)
  可以通过invoke方法实现对真实角色的代理访问。
  每次通过Proxy生成代理类对象 对象时都要指定对应处理器

package proxy.dynamicProxy;

public interface Star {
    void confer();          //  面谈
    void signContract();    // 签合同
    void bookTicket();      // 订票
    void sing();            // 唱歌
    void collectMoney();    // 收钱
}

package proxy.dynamicProxy;

public class RealStar implements Star {
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    public void sing() {
        System.out.println("RealStar(Jay).sing()");
    }

    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
}

package proxy.dynamicProxy;

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

public class StarHandler implements InvocationHandler{
    Star realStar;

    public StarHandler(Star realStar) {
        this.realStar = realStar;
    }

    /**
     * @param proxy 指代我们所代理的那个真实对象
     * @param method 指代的是我们所要调用真实对象的某个方法的Method对象
     * @param args 指代的是调用真实对象某个方法时接受的参数
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;
        // 在代理真实对象前我们可以添加一些自己的操作
        System.out.println("真正的方法执行前!");
        System.out.println("面谈,签合同,预付款,订机票");

        if (method.getName().equals("sing")){
            // 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
            object = method.invoke(realStar,args);
        }

        // 在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("真正的方法执行后!");
        System.out.println("收尾款");
        return object;
    }
}

package proxy.dynamicProxy;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        // 我们要代理的真实对象
        Star realStar = new RealStar();
        // 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
        StarHandler handler = new StarHandler(realStar);

        /**
         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
         * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
         * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
         */
        Star proxy = (Star) Proxy.newProxyInstance(handler.getClass().getClassLoader(), realStar.getClass().getInterfaces(), handler);

        proxy.sing();
    }
}