Spring—— 代理模式

---

AOP的底层机制时动态代理

一、静态代理

静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现
• 真实角色 : 被代理的角色
• 代理角色 : 代理真实角色 ; 代理真实角色后 ,一般会做一些附属的操作
• 客户 : 使用代理角色来进行一些操作

抽象角色：租房

//抽象角色：租房
public interface Lease {
    public void rent();
}

真实角色: 房东，房东要出租房子

//真实角色: 房东，房东要出租房子
public class Landlord implements Lease {
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

代理角色：中介，代理房东把房子租出去

//代理角色，中介
public class Intermediary implements Lease{
    private Landlord landlord;

    public Intermediary(Landlord landlord) {
        this.landlord = landlord;
    }

    public void rent() {
        this.landlord.rent();
        kanfang();
        hetong();
        shouqian();
    }

    public void kanfang() {
        System.out.println("中介：看房");
    }

    public void hetong(){
        System.out.println("中介：签合同");
    }

    public void shouqian() {
        System.out.println("中介：收钱");
    }
}

顾客：去租房子

//顾客
public class Customer {
    public static void main(String[] args) {
        Intermediary intermediary = new Intermediary(new Landlord());
        intermediary.rent();
    }
}

现在顾客要租房子，直接去找中介，中介会代理房东把房子租出去，同时，中介会有附属操作。

静态代理的好处:

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情
• 公共的业务由代理来完成 . 实现了业务的分工
• 公共业务发生扩展时变得更加集中和方便

缺点 :

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

二、动态代理（反射）

Lease.java

//抽象角色：租房
public interface Lease {
    public void rent();
}

Landlord.java

//真实角色: 房东，房东要出租房子
public class Landlord implements Lease {
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

getProxy()方法返回的是我们需要的代理类

public class ProxyInvocationHandler implements InvocationHandler {

    private Lease lease;

    public void setLease(Lease lease) {
        this.lease = lease;
    }
    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public  Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),lease.getClass().getInterfaces(),this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(lease,args);
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        //真实角色
        Landlord landlord = new Landlord();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setLease(landlord);//将真实角色放置进去！
        Lease lease = (Lease) pih.getProxy();//动态生成对应的代理类！
        lease.rent();
    }
}

如果现在有附加操作，只需要在invoke方法里面加需要执行的操作即可。

public class ProxyInvocationHandler implements InvocationHandler {

    private Lease lease;

    public void setLease(Lease lease) {
        this.lease = lease;
    }
    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public  Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),lease.getClass().getInterfaces(),this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(lease,args);
        kanfang();
        hetong();
        shouqian();
        
        return result;
    }
    public void kanfang() {
        System.out.println("中介：看房");
    }

    public void hetong(){
        System.out.println("中介：签合同");
    }

    public void shouqian() {
        System.out.println("中介：收钱");
    }
}

把代码改为一个通用类，只需要把代码中的Lease改为Object即可。

public class ProxyInvocationHandler implements InvocationHandler {

    private Object obj;

    public void setObj(Object obj) {
        this.obj = obj;
    }

    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public  Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(obj,args);
        kanfang();
        hetong();
        shouqian();
        return result;
    }
    public void kanfang() {
        System.out.println("中介：看房");
    }

    public void hetong(){
        System.out.println("中介：签合同");
    }

    public void shouqian() {
        System.out.println("中介：收钱");
    }
}

动态代理的好处：

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工
• 公共业务发生扩展时变得更加集中和方便
• 一个动态代理 , 一般代理某一类业务
• 一个动态代理可以代理多个类，代理的是接口