Java代理模式详解：静态代理与动态代理的区别及选择

# 1. Java代理模式概述

代理模式是一种结构型设计模式，它允许开发者在不改变原有对象的基础上，增加额外的处理逻辑。在Java中，代理模式常被用于实现对象的延迟加载、事务处理、安全控制等场景。通过代理对象，可以在访问目标对象前后增加一些业务逻辑处理，从而达到控制目标对象行为的目的。代理模式主要分为静态代理和动态代理两大类，它们在实际应用中有着各自的特点和适用场景。在深入探讨静态代理和动态代理之前，让我们先从代理模式的基本概念和角色开始了解。

# 2. 静态代理的原理与实现

## 2.1 静态代理的基础理论

### 2.1.1 代理模式的定义与角色

代理模式是设计模式中的一种，它提供了一种访问某对象的方式，同时可以对该对象的功能进行增强。在代理模式中，主要涉及到以下几个角色：

- **主题（Subject）**：定义了RealSubject和Proxy的共同接口，这样就在任何使用RealSubject的地方都可以使用Proxy。
- **真实主题（RealSubject）**：定义了Proxy所代表的真实对象。
- **代理（Proxy）**：保存一个引用使得代理可以访问实体，并提供一个与Subject的接口相同的接口，这样代理就可以用来代替实体。

代理模式的结构图可以简单表示为：

classDiagram
    class Subject {
        <<interface>>
        +request()
    }
    class RealSubject {
        +request()
    }
    class Proxy {
        -realSubject: RealSubject
        +request()
    }

    Subject <|.. RealSubject
    Subject <|.. Proxy
    Proxy --> RealSubject

### 2.1.2 静态代理的工作机制

静态代理机制的核心在于，代理类和真实主题类共同实现一个接口，或者是继承同样的父类。在编译期，代理类的字节码就已经确定，客户端直接通过代理类来调用方法。

在静态代理中，代理对象的创建是在编译时完成的，通常由开发人员手动编写代码实现。客户端调用一个方法时，实际上是先调用了代理类中的方法，然后代理类的方法再去调用真实主题类中的方法。在这个过程中，可以在代理类中添加额外的逻辑，例如日志记录、权限检查、事务管理等。

## 2.2 静态代理的实践应用

### 2.2.1 创建代理接口与实现类

在Java中，我们首先定义一个主题接口，然后分别实现真实主题类和代理类：

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

// 真实主题类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

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

    public ProxySubject(Subject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("ProxySubject: Before calling request.");
        realSubject.request();
        System.out.println("ProxySubject: After calling request.");
    }
}

### 2.2.2 实现具体的代理类

上例中，`ProxySubject` 就是我们的代理类，它实现了与 `RealSubject` 相同的接口 `Subject`。在 `ProxySubject` 的 `request` 方法中，我们可以在调用真实主题的 `request` 方法前后执行额外的操作。

### 2.2.3 静态代理的代码示例与分析

客户端代码如下：

public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxySubject = new ProxySubject(realSubject);

        proxySubject.request();
    }
}

在这段代码中，客户端通过代理类 `ProxySubject` 来访问真实主题类 `RealSubject`。输出结果如下：

ProxySubject: Before calling request.
RealSubject: Handling request.
ProxySubject: After calling request.

这个过程演示了静态代理的基本工作流程。客户端完全不需要感知 `RealSubject` 的存在，它可以与 `ProxySubject` 交互，而 `ProxySubject` 负责转发请求到 `RealSubject` 并且可以在请求前后执行附加操作。

### 静态代理的优势与局限

#### 2.3.1 静态代理的优缺点

**优点**：

- 简单易理解，实现容易；
- 在不修改委托对象代码的情况下，可以对委托对象的行为进行拦截和增强；
- 客户端不需要知道具体的代理对象，只需要和主题接口交互，从而降低了耦合度。

**缺点**：

- 代理类和委托类是紧密耦合的，每个委托类都需要一个对应的代理类；
- 当委托类的数量很多时，代理类也会相应地增加，这会增加系统的复杂性。

#### 2.3.2 静态代理适用场景

静态代理主要适用于：

- 需要在客户端与目标类之间加入一个拦截，进行额外的业务处理；
- 客户端无需知道真实的业务逻辑，只需要通过代理类与之交互。

### 表格对比分析

| 代理类型 | 实现复杂度 | 灵活性 | 性能 | 应用场景 |
| -------------- | ---------- | ------ | ---- | ---------------------------------------------------- |
| 静态代理 | 较低 | 低 | 较高 | 简单的业务逻辑增强，如权限验证、日志记录、事务控制等 |
| 动态代理 | 较高 | 高 | 较低 | 需要动态生成代理类，支持插件化开发，如Spring AOP等 |

通过上述分析，我们了解了静态代理的基础理论和实践应用，并对静态代理的优缺点和适用场景有了清晰的认识。接下来，我们将深入探讨动态代理的工作原理和实现方式。

# 3. 动态代理的原理与实现

## 3.1 动态代理的基础理论

### 3.1.1 Java动态代理机制
在理解Java动态代理机制之前，让我们先回顾一下代理模式的基本概念。动态代理是一种设计模式，它允许我们通过一个中介（代理类）来控制对真实对象的访问。与静态代理不同，动态代理在运行时生成代理类，这意味着代理类是在程序执行期间动态创建的。

Java动态代理通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。Proxy类提供了创建代理实例的方法，而InvocationHandler接口定义了在调用代理实例上的方法时需要执行的动作。Java动态代理只能代理实现了接口的类，因为它通过接口来生成代理类。

### 3.1.2 动态代理的工作原理
动态代理的工作原理可以用以下步骤来概括：

1. 创建一个实现了`InvocationHandler`接口的处理器类。
2. 在处理器类中实现`invoke`方法，这个方法定义了方法被调用时应执行的动作。
3. 使用`Proxy.newProxyInstance()`方法创建代理实例，该方法需要类加载器、一组接口以及一个实现了`InvocationHandler`的实例。
4. 当调用代理实例上的方法时，实际上是调用了处理器的`invoke`方法。

由于代理类是动态生成的，因此不需要像静态代理那样预先定义代理类。这种方式提高了程序的灵活性和扩展性，但也意味着代理类无法在编译时进行类型检查。

## 3.2 动态代理的实践应用

### 3.2.1 Java反射机制简介
在深入动态代理的实现之前，需要先对Java的反射机制有一个基本的了解。Java反射机制允许在运行时分析和操作Java类以及