Spring学习（七）—— 代理模式

Spring学习源码：https://download.csdn.net/download/qq_41505957/20606092

代理模式

代理模式：

• 静态代理
• 动态代理

静态代理

例子：顾客要租房，房东要出租房子，

Landlord.java 房东要出租房子。

public class Landlord {
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

Customera.java 顾客要租房，那么只需要创建一个房东类，调用房东类的租房方法即可。

public class Customer {
    public static void main(String[] args) {
        Landlord landlord = new Landlord();
        landlord.rent();
    }
}

静态代理角色分析

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

使用代理模式，把租房这个抽象角色剥离出来，现在顾客租房不去找房东，而是找中介，在这过程中，中介会有附属操作。

抽象角色：租房

//抽象角色：租房
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();
    }
}

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

静态代理的好处:

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

缺点 :

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

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

创建一个抽象类，里面有增删改查业务

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

实现类

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加用户");
    }

    public void delete() {
        System.out.println("删除用户");
    }

    public void update() {
        System.out.println("更新用户");
    }

    public void query() {
        System.out.println("查询用户");
    }
}

调用方法：

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.add();
    }
}

现在如果要加一个日志功能，如果直接在原有的代码上修改，将会改变代码的结构，可以用代理模式实现。

增加一个代理类：

public class UserServiceProxy implements UserService{
    private UserServiceImpl userServiceImpl;

    public UserServiceProxy(UserServiceImpl userServiceImpl) {
        this.userServiceImpl = userServiceImpl;
    }

    public void add() {
        log("add");
        userServiceImpl.add();
    }

    public void delete() {
        log("delete");
        userServiceImpl.delete();
    }

    public void update() {
        log("update");
        userServiceImpl.update();
    }

    public void query() {
        log("query");
        userServiceImpl.query();
    }

    public void log(String method){
        System.out.println("调用" + method +"方法");
    }
}

调用方法

public class Client {
    public static void main(String[] args) {
        UserServiceProxy userServiceProxy = new UserServiceProxy(new UserServiceImpl());
        userServiceProxy.add();
    }
}

动态代理

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("中介：收钱");
    }
}

动态代理的好处：

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