Spring06-静态/动态代理模式

代理模式

• 为什么要学习代理模式，因为AOP的底层机制就是动态代理！
• 代理模式：
  • 静态代理
  • 动态代理
• 了解代理模式
  

静态代理

静态代理角色分析

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

简单示例

• Rent.java。租房的抽象类

//租房
public interface Rent {
    public void rent();
}

• Host.kava。真实角色

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

• Proxy.java。代理角色

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
        seeHosuse();
        host.rent();
        fare();
    }

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

    //收中介费
    public void fare(){
        System.out.println("中介费");
    }
}

• Client.java。顾客

public class Client {
    public static void main(String[] args) {
        //房东出租房子
        Host host = new Host();

        //代理，中介帮房东租房？代理会有一些附属操作
        Proxy proxy = new Proxy(host);

        //不用面对房东直接找中介即可
        proxy.rent();
    }
}

• 分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式。
• 静态代理的好处:
  • 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情
  • 公共的业务由代理来完成，实现了业务的分工
  • 公共业务发生扩展时变得更加集中和方便
• 缺点 :
  • 类多了，多了代理类，工作量变大了，开发效率降低。
  • 我们想要静态代理的好处，又不想要静态代理的缺点，所以，就有了动态代理。

AOP

在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

动态代理

• 动态代理的角色和静态代理的一样。

• 动态代理的代理类是动态生成的。静态代理的代理类是我们提前写好的

• 动态代理分为两类：一类是基于接口动态代理，一类是基于类的动态代理

  • 基于接口的动态代理——JDK动态代理
  • 基于类的动态代理——cglib

• 现在用的比较多的是 javasist 来生成动态代理，可以百度稍作理解。
  主要介绍使用JDK的原生代码来实现，其余的道理都是一样的。

相关类介绍

• JDK的动态代理需要了解两个类：
  • 核心 : InvocationHandler
  • Proxy

InvocationHandler：调用处理程序

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

proxy

简单实现

• 接口类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public 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 ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    //loader - 类加载器来定义代理类 
	//interfaces - 要实现的代理类的接口列表 
	//h - 调度方法调用的调用处理函数
    public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制来实现
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("执行了"+ msg +"方法");
    }
}

• Client

public class Client {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);//设置要代理的对象

        UserService proxy = (UserService)pih.getProxy();
        proxy.query();
    }
}

• 结果

执行了query方法
查询用户

• 定义了一个统一的代理类，可以代理多个接口。因为代理类中参数未Object target。因此避免了静态代理的缺陷。
• 原理：反射。

优点

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