【java设计模式】——代理设计模式,两种举例说明

OldGj_

已于 2023-12-04 20:35:09 修改

阅读量1.2k

点赞数 31

分类专栏：设计模式学习文章标签： java 设计模式开发语言

于 2023-12-04 20:11:13 首次发布

本文链接：https://blog.csdn.net/guojiaqi_/article/details/134792893

版权

设计模式学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

代理设计模式

1.介绍

Spring 框架中AOP底层使用动态代理设计模式。通过学习动态代理设计模式可以很好的理解Spring框架AOP底层

代理模式（Proxy）是GoF23种设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。

代理设计模式包括：静态代理和动态代理。

静态代理：代理对象由程序员自己编写，里面提供硬编码方式来访问调用者

动态代理:

JDK动态代理：一种基于接口的代理实现
Cglib动态代理：一种基于继承的代理实现

代理设计模式优点：

保护代理对象。客户不能直接访问真实对象。只能通过代理对象进行访问
可扩展性。复合开闭原则，可以实现在不修改真实代理对象情况下，进行扩展。
对于一些访问困难的真实对象，可以使用代理对象，更轻松的访问。

代理设计模式缺点：

系统复杂性增加。类的数目增加，代码相对更复杂一点。
性能降低。每次访问真实对象，只能通过代理对象。

在这里插入图片描述

2.静态代理示例

以房屋买卖为例子（简易流程），客户想要买房，找中介，由中介带看房东的房子。

客户看好了，想要买，房东也同意买了，中介收取客户的中介费。

daili

创建房东（真实对象）

新建com.spring.proxy.staticproxy.Fangdong

public class Fangdong {
  public void bigHouse(){
    System.out.println("房东的大房子");
   }
}

创建中介类（代理对象）

新建com.spring.proxy.staticproxy.Zhongjie

public class Zhongjie {
  public void zhongjie(){
    System.out.println("约谈客户，进行带看");// 扩展功能
    Fangdong fangdong = new Fangdong();
    fangdong.bigHouse();
    System.out.println("交易成功，收取中介费"); // 扩展功能
   }
}

创建客户类（调用者）

com.spring.proxy.staticproxy.Kehu

public class Kehu {
  public static void main(String[] args) {
    Zhongjie zhongjie = new Zhongjie();
    zhongjie.zhongjie();
   }
}

3.动态代理示例

3.1JDK动态代理

JDK动态代理是基于接口来实现的，底层是基于Java 反射技术实现的。

创建接口

创建接口com.spring.proxy.jdkproxy.House

因为JDK动态代理要求调用者必须实现接口。所以先建立接口

public interface bigHouse {
    void bighose();
}

创建真实对象类

创建类com.spring.proxy.jdkproxy.Fangdong

/**
 * JDK动态代理强制要求：真实的被调用的类必须实现接口
 */
public class FangDong implements bigHouse{
    @Override
    public void bighose() {
        System.out.println("大房子");
    }
}

创建代理类

创建com.spring.proxy.jdkproxy.Zhongjie

/**
 * 在JDK动态代理底层是基于java的反射机制实现的。本质上就是方法的调用
 *
 * 负责调用真实对象方法的类，必须实现InvocationHandler接口
 */
public class ZhongJie implements InvocationHandler {

    private FangDong fangDong;

    public ZhongJie(FangDong fangDong) {
        this.fangDong = fangDong;
    }

    /**
     *
     * @param proxy 产生的代理对象
     * @param method 真实对象中被调用的方法对象
     * @param args 被调用方法的参数
     * @return 被调用方法的返回值，都当做invoke方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("带看");

        //坑：千万不要用invoke方法的第一个参数proxy，他是代理对象，而不是真实对象
        Object result = method.invoke(fangDong, args);

        System.out.println("中介费");

        return result;
    }
}

创建客户类

创建com.spring.proxy.jdkproxy.Kehu

public class KeHu {

    public static void main(String[] args) {


        /**
         * 参数1：ClassLoader   在当前程序中，所有类的类加载器都是同一个对象
         *       作用：让生成的代理对象立即生效，（invoke中的proxy对象）
         * 参数2：Class[]，放接口，告诉编译器，调用的是哪个方法
         *       作用：数组中放哪个接口，接口中的方法对象就会传递给invoke中的method方法对象
         * 参数3：InvocationHandler对象，负责调用真实对象的处理类，就是ZhongJie
         */
        //动态代理：动态：不是就调用某个对象的方法，而是想调哪个对象都可以
        InvocationHandler zhongJie = new ZhongJie(new FangDong());
        bigHouse bigHouse = (bigHouse) Proxy.newProxyInstance(Kehu.class.getClassLoader(), 
                                                              new Class[]{bigHouse.class}, 																					zhongJie);
        bigHouse.bighose();
    }
}

第二例子

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

// 定义接口
interface Hello {
    void sayHello();
}

// 实现接口的类
class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

// 创建InvocationHandler实例，用于处理代理逻辑
class HelloProxy implements InvocationHandler {
    private Object target;

    public HelloProxy(Object target) {
        this.target = target; // 保存目标对象的引用
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoking"); // 在调用目标方法前执行一些逻辑
        Object result = method.invoke(target, args); // 调用目标对象的方法
        System.out.println("After invoking"); // 在调用目标方法后执行一些逻辑
        return result; // 返回结果
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建目标对象
        Hello hello = new HelloImpl();

        // 创建代理对象
        Hello proxy = (Hello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(), // 使用目标对象的类加载器
                hello.getClass().getInterfaces(), // 获取目标对象实现的接口列表
                new HelloProxy(hello) // 指定InvocationHandler实例
        );

        // 调用代理方法
        proxy.sayHello();
    }
}

3.2Cglib动态代理

Cglig是基于继承的，是第三方提供的技术，需要导入jar包，并且。

    <dependencies>
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
    </dependency>
  </dependencies>

创建房东类

/**
 * 真实被调用对象
 */
public class FangDong {
    public void bigHouse(){
        System.out.println("大房子");
    }
}

创建中介类

/**
 * 作用：调用真实对象的方法
 */
public class ZhongJie implements MethodInterceptor {


    /**
     *
     * @param o 目标对象：即FangDong对象
     * @param method 目标方法
     * @param objects 目标方法参数
     * @param methodProxy 生成的代理对象（即FangDong的子类）
     * @return 目标方法返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("带看");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("中介费");
        return  result;

    }
}

创建客户类

public class KeHu {

    public static void main(String[] args) {
        //所有方法都在Enhancer中
        Enhancer enhancer = new Enhancer();
        //1.setSuperClass(真实是哪个类)  真实是哪个类，根据这个类创建代理对象，即FangDong的子类
        enhancer.setSuperclass(FangDong.class);
        //2.setCallBack(对象)    设置由哪个类作为增强实现类
        enhancer.setCallback(new ZhongJie());
        //3.create()   创建代理对象，返回值为object类型，本质为代理对象
        FangDong fangDong = (FangDong) enhancer.create();
        fangDong.bigHouse();
    }

}

测试结果，发现出现异常,这是因为Java 17版本中的Java Platform Module System（java 9就开始有了）引起的，特别是强封装的实现。

Caused by: java.lang.reflect.InaccessibleObjectException: Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int,java.security.ProtectionDomain) throws java.lang.ClassFormatError accessible: module java.base does not "opens java.lang" to unnamed module @1376c05c

把代码原封不动的放在Java 11的环境中就可以使用。

如果必须要在Java17中使用添加JVM参数，表示允许使用未命名模块。

--add-opens java.base/java.lang=ALL-UNNAMED

使用CGLib实现动态代理需要引入相关的依赖库。在示例中，我们将使用cglib-nodep库来创建代理对象。下面是一个使用CGLib实现动态代理的示例代码：

首先，确保已添加CGLib的依赖。对于Maven项目，可以在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib-nodep</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

然后，编写以下示例代码：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

// 目标类
class Hello {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

// 创建MethodInterceptor实例，用于处理代理逻辑
class HelloInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before invoking"); // 在调用目标方法前执行一些逻辑
        Object result = proxy.invokeSuper(obj, args); // 调用目标方法
        System.out.println("After invoking"); // 在调用目标方法后执行一些逻辑
        return result; // 返回结果
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Hello.class); // 设置父类为目标类
        enhancer.setCallback(new HelloInterceptor()); // 设置回调对象

        // 创建代理对象
        Hello proxy = (Hello) enhancer.create();

        // 调用代理方法
        proxy.sayHello();
    }
}

在上述示例中，我们首先定义了一个Hello类作为目标类。然后，创建了一个HelloInterceptor类实现MethodInterceptor接口，用于在代理对象的方法执行前后进行处理。接下来，使用Enhancer类创建代理对象，并设置目标类和回调对象。最后，通过调用代理对象的方法来触发代理逻辑。

运行以上代码，输出结果将会是：

Before invoking
Hello, World!
After invoking

这就是一个使用CGLib实现的动态代理的例子。注意，在使用CGLib时，需要引入相应的依赖并设置目标类和回调对象。