代理模式：静态代理与动态代理（Java实例）

悠悠 2021-09-09 05:36 348阅读 0赞

**代理模式的角色分析**：

抽象角色：一般会使用接口或者抽象类来解决

真实角色：被代理的角色

代理角色：代理真实角色，一般都在代理真实角色后，会做一些附属操作

客户：访问代理对象的实体

--------------------

**实例**:房东出租房屋，找中介代理，客户之间找中介租房

**使用静态代理：**

接口：

public interface Rent {
        void rent();
    }

房东Host

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

代理中介Proxy

//中介
    public class Proxy implements Rent {
    
        private Host host;
    
        public Host getHost() {
            return host;
        }
    
        public void setHost(Host host) {
            this.host = host;
        }
    
        public Proxy(Host host) {
            this.host = host;
        }
    
        @Override
        public void rent() {
            seehouse();
            host.rent();
            hetong();
        }
        public void hetong() {
            System.out.println("签合同");
        }
        public void seehouse() {
            System.out.println("带客户去看房");
    
        }
    }

客户Client

public class Client {
        public static void main(String[] args) {
    //        直接房东出租房子
            Host host = new Host();
    //        host.rent();
    //        通过中介租房族
            Proxy proxy = new Proxy(host);
            proxy.rent();
        }
    }

测试：

![20210729122719811.png][]

--------------------

** 使用动态代理方式：**

*  动态代理和静态代理的角色一样
 *  动态代理的代理类是动态生成的，不是我们直接写好的
 *  动态代理分两类
    
     *  基于接口的动态代理（基于JDK）
     *  基于类的动态代理（基于cglib）

重点两个类的使用：Proxy（代理），InvocationHandler(调用处理程序)

依旧用上面的实例演示

接口：

public interface Rent {
        void rent();
    }

Host

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

动态代理类

public class ProxyInvocationHandler implements InvocationHandler {
    
        //    被代理的接口
        private Rent rent;
    
        public void setRent(Rent rent) {
            this.rent = rent;
        }
    
        //    生成得到的代理类
        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 {
            Object result = method.invoke(rent, args);
            return result;
        }
    }

测试：

public class Client {
        public static void main(String[] args) {
    //        真实角色
            Host host = new Host();
    //        调用程序处理角色来处理我们要调用的接口对象
            ProxyInvocationHandler pih = new ProxyInvocationHandler();
            pih.setRent(host);
            Rent proxy = (Rent) pih.getProxy();
            proxy.rent();
        }
    }

结果：

![20210729123950254.png][]

--------------------

代理模式的好处：

*  可以使真实角色的操作更加纯粹，不用去关注一一些公共的业务
 *  公共也就交给了代理角色，实现了业务的分工
 *  公共业务方式扩展的时候，方便集中管理

--------------------

上面的动态代理类可以写成下面的封装通用的形式：

public class ProxyInvocationHandler implements InvocationHandler {
    
        //    被代理的接口
        private Object target;
    
        public void setRent(Object target) {
            this.target = target;
        }
    
        //    生成得到的代理类
        public Object getProxy(){
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
        }
        //    处理代理实例，并返回结果
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = method.invoke(target, args);
            return result;
        }
    }

--------------------

上面实例整理参考自B站狂神编程教程视频

有不对的地方欢迎指正哦！！！！

O(∩\_∩)O哈哈~，觉得不错点赞支持一下哦！！！

[20210729122719811.png]: /images/20210813/984f52eb5ade4681a08ccc3751b34546.png
[20210729123950254.png]: /images/20210813/0b4e0d21bf814d3bb73ba36ec752734d.png