什么是代理模式？

角色：一个接口（一类业务

 public interface Rent {
     public void rent();
     public void add();
     public void delete();
 }

接口的实现类（具体的实现方法

 public class Host implements Rent{
     @Override
     public void rent() {
         System.out.println("租房子了");
     }
 
     public void add(){
         System.out.println("增加");
     }
     public void delete(){
         System.out.println("删除");
     }
 }

用户想要使用这个具体的方法就需要调用具体的实现类 impl

但是又不想直接访问就用另外一个代理类来代替他做一个封装

静态代理

生成一个 HostP 对象，这个对象内部可以实现原先 host 的所有功能，并且可以扩展一些功能，但实际上里面的功能还是由 host 提供的。

 public class HostP implements Rent{
 
     private Host host;
     public void setHost(Host host) {
         this.host = host;
     }
     @Override
     public void rent() {
         host.rent();
     }
     @Override
     public void add() {
         host.add();
     }
     public void delete(){
         System.out.println("delete 租户");
     }
 }

代理模式的优缺点

使用代理模式具有以下几个优点：

1、代理模式能将代理对象与真实被调用的目标对象分离。

2、一定程度上降低了系统的耦合度，扩展性好。

3、可以起到保护目标对象的作用。

4、可以对目标对象的功能增强。

当然，代理模式也是有缺点的：

1、代理模式会造成系统设计中类的数量增加。

2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。

3、增加了系统的复杂度。
————————————————
版权声明：本文为CSDN博主「Leon_Jinhai_Sun」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Leon_Jinhai_Sun/article/details/109553543

动态代理

JDK动态代理实现

技术：java反射

前提：代理的类实现了接口。

通过newProxyInstance()函数获得proxy对象，这个对象就代理了实现了这个接口所有的类，然后使用这个代理对象即可。代理对象会自动调用相应的方法。比如

IRpcHelloService RpcHello = RpcProxy.create(IRpcHelloService.class);
System.out.println(RpcHello.hello("Tom老师"));

RpcHello 是 IRpcHelloService.class这个接口的代理类，IRpcHelloServiceImpl实现了这个接口，那么RpcHello.hello("Tom老师")就相当于调用了IRpcHelloServiceImpl中的hello方法。

newProxyInstance，方法有三个参数：

loader: 用哪个类加载器去加载代理对象

interfaces:动态代理类需要实现的接口

h:动态代理方法在执行时，会调用h里面的invoke方法去执行

public class ProxyHost implements InvocationHandler {

    private Object target;
	// 注入一个实现类  
    public void setTarget(Object target) {
        this.target = target;
    }
	// 根据实现类  拿到其实现的方法
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }
    // 在使用时直接调用方法即可  
    // 调用时就会通过 invoke来实现
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
        System.out.println("调用方法前的日志");// 在调用原对象的方法时  可以增强
        Object result = method.invoke(target,args);
        System.out.println("调用方法后的日志");
        return result;
    }

}