Spring学习记录06——代理模式

代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

介绍

意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

应用实例：

• 买火车票不一定在火车站买，也可以去代售点，代售点就是代理
• 租房子不用直接找房东，可以找中介商租房子，中介商就是代理

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

静态代理

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现

真实角色 : 实现抽象角色的功能，被代理的角色

代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 ，通过对代理角色的增加操作，避免改动真实角色的代码

客户 : 使用代理角色来进行一些操作 .

例1

来模拟租房子

RentHouse.java
这是一个有租房子功能的接口

public interface RentHouse {
    void rentHouse();
}

Landlord.java
这是房东类，实现了租房子的功能

public class Landlord implements RentHouse{
    @Override
    public void rentHouse() {
        System.out.println("房东要出租房子");
    }
}

Client.java
这是客户类，客户需要租房子，所以现在客户向房东租房子

public class Client {
    public static void main(String[] args) {
        Landlord landlord = new Landlord();
        //向房东租房子
        landlord.rentHouse();
    }
}

现在模拟了向房东租房子的动作，那么现在问题升级了，现在租房子的手续特别的麻烦，我们根本没有时间去办理那么多的手续，那么中介就诞生了，中介可以帮我们完成所有的事情，而我们要做的事情就是找到中介即可

Proxy.java
这是一个中介，实现了租房子的接口，并且添加了办手续的功能

public class Proxy implements RentHouse{
    private Landlord landlord;

    public void setLandlord(Landlord landlord) {
        this.landlord = landlord;
    }

    @Override
    public void rentHouse() {
        lookHouse();
        //其实还是房东租出房子 只是添加了相关手续
        landlord.rentHouse();
        signContract();
    }

    public void lookHouse() {
        System.out.println("中介去看房了！");
    }

    public void signContract() {
        System.out.println("签署合同！");
    }

}

接下来用户只需要找中介租房即可，并且还可以添加相关的手续，如果后序需要添加更多 的手续只需在代理中实现即可，并不需要改动核心的代码

public class Client {
    public static void main(String[] args) {
        Landlord landlord = new Landlord();
        Proxy proxy = new Proxy();
        proxy.setLandlord(landlord);
        proxy.rentHouse();
    }
}

在上面的例子中
抽象角色——RentHouse，租房子
实际角色——Landlord ，房东
代理角色——Proxy，中介商
客户角色——Client，需要租房的人

例2

下面在来一个例子
模拟一下数据库的操作
首先是一个UserService接口，也就是抽象角色

public interface UserService {
    void add();

    void delete();

    void update();

    void query();
}

UserServiceImpl，真实角色，实现了抽象角色的功能

package com.wcy.demo02;

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("添加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

此时已经可以通过实例化UserServiceImpl来操作数据库，那么如果要添加功能呢，我们不会去轻易的更改源码，所以添加一个代理UserServiceProxy，并添加一个打印日志的功能

public class UserServiceProxy implements UserService {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

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

接下来客户只需要通过代理来操作即可

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

总结

静态代理的好处:

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

• 公共的业务由代理来完成 . 实现了业务的分工 ,

• 公共业务发生扩展时变得更加集中和方便 .

缺点 :

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

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

动态代理

• 动态代理的角色和静态代理的一样
• 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
• 动态代理利用反射机制在运行时创建代理类
• 使用动态代理，我们不用为每一个类都创建动态代理
• 使用动态代理需要用到两个类
  java.lang.reflect.InvocationHandler 和 java.lang.reflect.Proxy
• InvocationHandler是用于代理实例调用处理程序实现的接口
  该接口中只有一个方法

public Object invoke(Object proxy, Method method, Object[] args) 
throws Throwable;

参数说明
- proxy - 调用该方法的代理实例
- method - 所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
- args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 

• Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类

 Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class<?>[] { Foo.class },
                                          handler); 

接下来用动态代理数据库操作的模拟例子
UserService.java

package com.wcy.demo04;

public interface UserService {
    void add();

    void delete();

    void update();

    void query();
}

UserServiceImpl.java

package com.wcy.demo04;

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("添加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

ProxyInvocationHandler.java

package com.wcy.demo04;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {
    // 需要代理的目标
    Object target;

    public void setUserService(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 {
        beforeLog(method.getName());
        Object result = method.invoke(target, args);
        afterLog(method.getName());
        return result;
    }

    /**
     * 方法执行之前的操作
     * @param msg
     */
    public void beforeLog(String msg) {
        System.out.println("调用了" + msg + "方法");
    }

    /**
     * 方法执行之后的操作
     * @param msg
     */
    public void afterLog(String msg) {
        System.out.println(msg + "方法调用结束！");
    }
}

客户调用

package com.wcy.demo04;

public class Client {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        // 传入代理对象
        proxyInvocationHandler.setUserService(userService);
        // 获取代理实例
        UserService proxy = (UserService) proxyInvocationHandler.getProxy();
        proxy.add();
    }
}

这样就实现了动态代理
以后需要代理只需要将被代理对象传入ProxyInvocationHandler 即可，这样就不用为每一个被代理的对象单独创建一个代理类

动态代理的好处

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

公共的业务由代理来完成 . 实现了业务的分工 ,

公共业务发生扩展时变得更加集中和方便 .

一个动态代理 , 一般代理某一类业务

一个动态代理可以代理多个类，代理的是接口！