设计模式：代理模式---动/静态代理 - proxy

1、什么是设计模式？

• 设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
• 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

2、为什么要学习代理模式？

• 因为这是spring AOP 的底层实现。
• 面试重点内容

3、什么是代理模式？

• 代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。

• 作用：可以拓展目标对象的功能。

• 

  

4、代理模式主要有二种不同的形式：

1. 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的 .class 文件就已经存在了

2. 动态代理（JDK 代理、接口代理）：在程序运行时运用反射机制动态创建而成，动态就是在程序运行时生成的，而不是编译时。

3. cglib 代理（可以在内存动态的创建对象，而不是实现接口，属于动态代理的范畴）

5.静态代理

角色分析：

- 抽象角色:一般会使用接口或者抽象类来解决 （租房）
- 真实角色：被代理的角色 （房东）
- 代理角色：代理真实角色的角色，代理后，一般会有一些增强的功能。 （中介）
- 客户：访问代理对象的人 （租房的人）

代码举例。

//租房的接口 抽象角色
public interface Rent {
    public void rent();
}

//房东 真实角色
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

//中介 代理角色  原则能用组合的时候，少用继承
public class Proxy implements Rent {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        fare();
        hetong();
    }

    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    public void hetong(){
        System.out.println("签租赁合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }

}

public class Client {
    public static void main(String[] args) {
        //房东出租房子
        Host host = new Host();
        //中介帮房东出租房子，而且还会有一些附加的操作。
        Proxy proxy = new Proxy(host);

        proxy.rent();
    }
}

静态代理的好处：

1. 可以使真实角色的操作更加纯粹。比如房东只管出租房子。
2. 公共业务交给代理角色，实现了业务的分工。
3. 公共业务发送扩展时，方便集中管理。

缺点：

• 一个真实角色就会产生一个代理角色，代码量增加。开发效率变低。

6.动态代理

• 动态代理的角色和静态代理是一样的。
• 动态代理的代理类是动态生成的，不是我们直接写好的。
• 动态代理分为两大类:
• 基于接口的动态代理。—jdk代理
• 基于类的动态代理。----cglib

java动态代理机制中有两个重要的接口和类
InvocationHandler（接口）调用处理程序 和Proxy（类）代理，
这一个类Proxy和接口InvocationHandler是我们实现动态代理的核心；

InvocationHandler：

Proxy:

代码解析

package com.wang.demo3;

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

public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
    }
    //参数1：类加载器，参数2：被代理的接口 参数3：InvocationHandler 的对象。这里是自己本身。
    public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        //动态代理的本质，就是使用反射机制实现
        seeHouse();
        Object result = method.invoke(rent, args);
        return result;
    }
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    /*Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
            new Class[] { Foo.class },
            handler);*/
}

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理角色：现在没有 ，只有处理程序ProxyInvocationHandler。需要处理程序来生成一个代理类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象： 即真实角色和代理角色都要实现抽象角色的接口，此时帮代理角色实现
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

总结：Proxy：生成动态代理实例的
InvocationHandler:调用处理程序，并返回一个结果。

动态代理的好处：

1. 可以使真实角色的操作更加纯粹。比如房东只管出租房子。
2. 公共业务交给代理角色，实现了业务的分工。
3. 公共业务发送扩展时，方面管理。
4. 一个动态代理类代理的是一个接口，一般就是对应的一类业务。
5. 一个动态代理类，可以代理多个类，只要实现了同一个接口即可。