代理模式：静态代理与动态代理（Java实例）-蒲公英云

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

悠悠 2021-09-09 05:36 539阅读 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();
    }
}

测试：

使用动态代理方式：

动态代理和静态代理的角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分两类
- 基于接口的动态代理（基于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();
    }
}

结果：

代理模式的好处：

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

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

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;
    }
}