🍁 作者：知识浅谈，CSDN签约讲师，CSDN博客专家，华为云云享专家，阿里云专家博主
📌 擅长领域：全栈工程师、爬虫、ACM算法
🔥 公众号: 知识浅谈

🤞这次都给他拿下🤞

🎈前言

在面向对象编程中，代理模式是一种常见的设计模式，用于控制对对象的访问。代理模式有两种主要类型：静态代理和动态代理。尽管它们都可以用来实现代理功能，但它们在实现方式、灵活性和使用场景上存在显著区别。本文将深入探讨静态代理和动态代理的主要区别，并介绍它们各自的优缺点和适用场景。

🎈静态代理

  • 定义：
    静态代理是指在编译时就确定了代理类和目标类的关系。代理类和目标类之间的关系是固定的，因此在编译时需要明确代理类的实现。

  • 实现方式：
    静态代理通常涉及创建一个代理类，这个代理类实现了与目标类相同的接口，并在其中委托实际的操作给目标类。代理类的代码和目标类的代码是分开的，代理类通常会在方法调用前后执行一些附加的操作（如日志记录、权限检查等）。

  • 示例代码：
    假设有一个 Subject 接口和一个 RealSubject 实现类，我们可以创建一个 StaticProxy 类来作为代理。

    // Subject接口
public interface Subject {
    void request();
}

// RealSubject实现类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject request");
    }
}

// StaticProxy代理类
public class StaticProxy implements Subject {
    private RealSubject realSubject;

    public StaticProxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        // 代理类的附加功能
        System.out.println("StaticProxy before request");
        realSubject.request();
        System.out.println("StaticProxy after request");
    }
}
    • 1.
    • 2.
    • 3.
    • 4.
    • 5.
    • 6.
    • 7.
    • 8.
    • 9.
    • 10.
    • 11.
    • 12.
    • 13.
    • 14.
    • 15.
    • 16.
    • 17.
    • 18.
    • 19.
    • 20.
    • 21.
    • 22.
    • 23.
    • 24.
    • 25.
    • 26.
    • 27.
    • 28.
    • 29.
    • 30.

  • 优点：
    简单直观，易于理解和实现。
    代理类的行为可以在编译时确定。

  • 缺点：
    每增加一个目标类，就需要增加一个对应的代理类，代码重复度高。
    不够灵活，难以处理动态的代理需求。

🎈动态代理

  • 定义：
    动态代理是在运行时创建代理对象的一种机制。与静态代理不同，动态代理不需要在编译时就确定代理类的具体实现。动态代理通过反射机制在运行时创建代理对象，并将方法调用转发给目标对象。

  • 实现方式：
    在 Java 中，动态代理可以使用 java.lang.reflect.Proxy 类和 InvocationHandler 接口来实现。动态代理允许我们在运行时创建代理实例，并通过 InvocationHandler 的 invoke 方法来处理对目标对象方法的调用。

  • 示例代码：
    以下是使用 Java 动态代理创建代理对象的示例：

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

// InvocationHandler实现类
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("DynamicProxy before method");
        Object result = method.invoke(target, args);
        System.out.println("DynamicProxy after method");
        return result;
    }
}

// 使用动态代理创建代理对象
public class DynamicProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Subject proxyInstance = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                new DynamicProxyHandler(realSubject));

        proxyInstance.request();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 优点：
    灵活性高，可以在运行时创建代理对象。
    不需要为每个目标类创建一个代理类，减少了代码的重复。
    可以动态地处理不同的目标对象和方法调用。
  • 缺点：
    相对复杂，理解和调试较难。
    可能会影响性能，因为代理对象是在运行时动态生成的。

🍚总结

  • 静态代理：

    实现时机：编译时
    代码重复性：较高，每个目标类需要一个对应的代理类
    灵活性：较低，代理类的行为在编译时确定
    适用场景：当代理类的逻辑简单，且目标类数量较少时

  • 动态代理：
    实现时机：运行时
    代码重复性：较低，通过一个通用的代理实现处理多个目标类
    灵活性：较高，可以动态处理不同的目标对象和方法调用
    适用场景：当需要处理动态的代理需求，或目标类数量较多时
    静态代理和动态代理各有优缺点，选择使用哪种代理方式应根据具体的需求和应用场景来决定。在实际开发中，动态代理的灵活性和减少代码重复的优点通常使其成为更受欢迎的选择，但在某些简单的应用场景中，静态代理可能更易于实现和维护。

大功告成，撒花致谢🎆🎇🌟，关注我不迷路，带你起飞带你富。
作者：知识浅谈