Spring06静态代理和动态代理

最新推荐文章于 2024-08-03 16:48:58 发布

阿巴巴巴巴巴巴

最新推荐文章于 2024-08-03 16:48:58 发布

阅读量100

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/weixin_42367504/article/details/115214545

版权

Spring 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

代理模式

为什么要学习代理模式，因为AOP的底层机制就是动态代理！
代理模式：静态代理、动态代理
学习aop之前 , 我们要先了解一下代理模式！
代理模式UML：
在这里插入图片描述

简单结构示意图：在这里插入图片描述

静态代理

静态代理角色分析

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

代码实现

Rent . java 即抽象角色

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

Host . java 即真实角色

//真实角色：房东，房东要出租房子
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房屋出租");
    }
}

Proxy . java 即代理角色

//代理角色：中介
public class Proxy implements Rent{
    private Host host;

    public void setHost(Host host) {
        this.host = host;
    }
    @Override
    //租房
    public void rent() {
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        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();
        //中介帮助房东
        proxy.setHost(host);
        //你去找房东
        proxy.rent();

    }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。

静态代理的好处
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情
- 公共的业务由代理来完成 . 实现了业务的分工
- 公共业务发生扩展时变得更加集中和方便
缺点
- 代理对象和被代理对象之前是一种强耦合,代理对象必须知道被代理对象具体的变量或方法,从而进行调用。一旦被代理对象多起来,那就需要创建多个代理,同样不好维护，工作量变大了 . 开发效率降低
思想**：我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想**
AOP：纵向开发，横向开发

动态代理

分析

动态代理的角色和静态代理的一样
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理–cglib
- 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
- 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

InvocationHandler（调用处理程序）：该接口中仅定义了一个方法（这个抽象方法在代理类中动态实）目的：调用处理程序，并返回结果（invoke）

public object invoke(Object obj,Method method, Object[] args)

-  obj：一般是指代理类
- method：被代理的方法
- args：method方法的参数数组

Proxy ：该类即为动态代理类，目的是为了生成一个动态代理
- 内容：
  - protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值。
  - static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
  - static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)

所谓DynamicProxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个DynamicProxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。在使用动态代理类时，我们必须实现InvocationHandler接口
通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。

代码实现

抽象角色和真实角色和之前的一样！

Rent . java 即抽象角色

//需要动态代理的接口
public interface Rent {
    //抽象角色：租房
     void rent();
}

Host . java 即真实角色

//需要代理的实际对象
public class Host implements Rent {
    //真实角色: 房东，房东要出租房子
    @Override
    public void rent() {
        System.out.println("房屋出租");
    }
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
    //要代理的真实对象
    private Object host;
    //构造方法，给我们要代理的真实对象赋初值
    public ProxyInvocationHandler(Object subject) {
        this.host = host;
    }

    /**
     *该方法负责集中处理动态代理类上的所有方法调用
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在代理真实对象前我们可以添加一些自己的操作
        seeHouse();
        System.out.println("Method:" + method);
        //动态代理的本质就是反射。当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        Object invoke = method.invoke(host, args);
        //在代理真实对象后我们也可以添加一些自己的操作
        fare();
        return invoke;
    }
    //看房
    public void seeHouse(){
        System.out.println("带客人看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收取中介费");
    }
}

Client . java

//动态代理演示
public class Client {
    public static void main(String[] args) {
        //代理的真实对象
        Host host=new Host();
        /**
         * ProxyInvocationHandler 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
         * 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.
         * 即：要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法
         */
        //代理实例的调用处理程序,将真实角色放置进去
        ProxyInvocationHandler invocationHandler=new ProxyInvocationHandler(host);
        ClassLoader loader = host.getClass().getClassLoader();
        Class<?>[] interfaces = host.getClass().getInterfaces();
        //动态生成对应的代理类！
        Rent proxy = (Rent) Proxy.newProxyInstance(loader, interfaces, invocationHandler);
        System.out.println("动态代理对象的类型："+proxy.getClass().getName());
        proxy.rent();
    }
}