Java代理模式实战演练

# 1. 什么是代理模式？

代理模式是一种结构性设计模式，它允许对象提供一种替代方式来控制对其它对象的访问。通过使用代理对象，可以在访问目标对象时添加额外的逻辑，比如权限检查、性能监控、缓存等。代理模式在实际项目中应用广泛，能够有效地实现解耦和增强目标对象的功能。

## 1.1 代理模式概述

代理模式通过引入代理对象来间接访问目标对象，从而可以在访问目标对象时增加额外的功能。

## 1.2 代理模式的优点

- 可以有效控制对目标对象的访问，并实现细粒度的权限控制。
- 可以实现对目标对象的增强，而不需要修改目标对象的代码。

## 1.3 代理模式的应用场景

- 远程代理：通过代理对象访问远程的对象，如WebService、远程方法调用等。
- 虚拟代理：用于按需创建昂贵对象的代理，延迟对象的实例化。
- 安全代理：控制对目标对象的访问权限，进行安全验证。
- 智能引用：在访问目标对象时添加额外的逻辑，例如缓存、性能监控等。

以上是代理模式的概述，接下来我们将深入讨论Java中的代理模式。

# 2. Java中的代理模式

代理模式是一种结构型设计模式，允许对象在其上被加以控制。

### 2.1 静态代理

#### 2.1.1 静态代理的实现方式
静态代理是在编译期间就已经确定代理类的实现方式。

#### 2.1.2 静态代理的示例代码

// 接口
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 RealSubject realSubject;

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

    @Override
    public void request() {
        System.out.println("ProxySubject: Pre-processing");
        realSubject.request();
        System.out.println("ProxySubject: Post-processing");
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProxySubject proxySubject = new ProxySubject(realSubject);
        proxySubject.request();
    }
}

在静态代理的示例代码中，ProxySubject类作为RealSubject类的代理类，在该类中进行了前置处理和后置处理。

### 2.2 动态代理

动态代理是在运行时动态生成代理类的实现方式。

#### 2.2.1 JDK动态代理
JDK动态代理是通过反射实现的代理模式，利用`java.lang.reflect.Proxy`和`java.lang.reflect.InvocationHandler`接口实现动态代理。

#### 2.2.2 CGLIB动态代理
CGLIB（Code Generation Library）动态代理使用字节码生成框架来实现代理，它通过继承目标类的方式创建代理对象。

#### 2.2.3 动态代理的比较与选择
JDK动态代理和CGLIB动态代理各有优缺点，具体选择应根据实际需求和场景进行权衡和选择。

以上是Java中的代理模式的部分内容，包括静态代理和动态代理的基本概念和实现方式。接下来将介绍具体的实战演练。

# 3. 静态代理实战演练

静态代理是代理类在编译期间就确定的代理方式，代理类和被代理类的关系在编译期间就确定了，无法动态改变。

#### 3.1 创建接口和实现类

首先，我们创建一个接口`Subject`，其中包含一个 `request()` 方法：

// Subject.java
public interface Subject {
    void request();
}

接着，我们创建一个实现接口的具体类`RealSubject`：

// RealSubject.java
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject handles the request.");
    }
}

#### 3.2 创建代理类

然后，我们创建一个代理类`ProxySubject`，该类实现了`Subject`接口，并在 `request()` 方法中调用了`RealSubject`的 `request()` 方法：

// ProxySubject.java
public class ProxySubject implements Subject {
    private RealSubject realSubject;

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

    @Override
    public void request() {
        System.out.println("ProxySubject handles the request.");
        realSubject.request();
    }
}

#### 3.3 客户端调用示例

最后，我们来看一下客户端的调用示例，即如何使用静态代理类：

// Client.java
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProxySubject proxy = new ProxySubject(realSubject);
        proxy.request();
    }
}

在上述代码中，我们创建了一个`RealSubject`对象和一个`ProxySubject`对象，然后通过`ProxySubject`对象来调用`request()`方法。运行客户端代码会输出：

ProxySubject handles the request.
RealSubject handles the request.

上述内容是关于【静态代理实战演练】的详细内容，包括接口和实现类的创建、代理类的编写、以及客户端调用示例。

# 4. JDK动态代理实战演练

在本节中，我们将通过实例演示如何使用JDK动态代理来实现代理模式。JDK动态代理是基于接口的代理，它通过在运行时动态生成代理类来实现对目标对象的代理。下面我们将逐步介绍实现的步骤。

#### 4.1 创建接口和实现类

首先，我们需要创建一个接口`Subject`和它的实现类`RealSubject`，代码如下：

// Subject.java
public interface Subject {
    void request();
}

// RealSubject.java
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Processing request...");
    }
}

#### 4.2 实现InvocationHandler接口

接下来，我们需要实现`InvocationHandler`接口来处理代理实例的方法调用。创建一个名为`ProxyHandler`的类来实现`InvocationHandler`接口，代码如下：

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

public class ProxyHandler implements InvocationHandler {
    private Object realSubject;

    public ProxyHandler(Object realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("ProxyHandler: Before requesting...");
        Object result = method.invoke(realSubject, args);
        System.out.println("ProxyHandler: After requesting...");
        return result;
    }
}

#### 4.3 创建代理对象

接下来，我们需要创建代理对象，并将目标对象和`ProxyHandler`传入`Proxy.newProxyInstance()`方法来生成代理对象。代码如下：

import java.lang.reflect.Proxy;

public class DynamicProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProxyHandler handler = new ProxyHandler(realSubject);

        Subject proxySubject = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[] { Subject.class },
                handler);

        proxySubject.request();
    }
}

#### 4.4 客户端调用示例

最后，我们通过客户端调用来演示JDK动态代理的效果：

public class Client {
    public static void main(String[] args) {
        DynamicProxyDemo.main(new String[]{});
    }
}

以上就是使用JDK动态代理实现代理模式的实战演练。通过这个示例，我们可以清楚地看到代理对象在调用目标对象方法前后分别执行了预处理和后处理的逻辑。

# 5. CGLIB动态代理实战演练

CGLIB（Code Generation Library）是一个开源的代码生成库，使用CGLIB可以在运行时动态生成指定类的子类，从而实现代理功能。与JDK动态代理相比，CGLIB动态代理不要求委托类实现接口，可以代理非接口类型的类。

### 5.1 创建需要被代理的类

首先，我们需要创建一个普通的类作为CGLIB动态代理的目标类。例如，假设我们有一个`Calculator`类，其中包含了求和的方法`add()`。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

### 5.2 创建MethodInterceptor子类

接下来，我们需要创建一个继承自CGLIB的`MethodInterceptor`类，用于实现对目标类方法的代理。

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

import java.lang.reflect.Method;

public class CalculatorInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method execution...");

        Object result = proxy.invokeSuper(obj, args);

        System.out.println("After method execution...");

        return result;
    }
}

### 5.3 创建代理对象

接下来，我们使用CGLIB动态代理为`Calculator`类创建代理对象。在这个示例中，我们将使用`Enhancer`类来实现代理对象的创建。

import net.sf.cglib.proxy.Enhancer;

public class CalculatorProxy {

    public static Calculator createProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Calculator.class);
        enhancer.setCallback(new CalculatorInterceptor());
        return (Calculator) enhancer.create();
    }
}

### 5.4 客户端调用示例

最后，让我们看一下如何在客户端调用CGLIB动态代理生成的代理对象。

public class Main {
    public static void main(String[] args) {
        // 创建代理对象
        Calculator calculatorProxy = CalculatorProxy.createProxy();

        // 调用代理对象的方法
        int result = calculatorProxy.add(10, 20);
        System.out.println("Result: " + result);
    }
}

通过以上步骤，我们成功地演示了如何使用CGLIB动态代理进行代理类的实现和调用。这里的`CalculatorInterceptor`类中的`intercept()`方法会在代理方法执行前后打印相应的信息，从而展示出代理的效果。

CGLIB动态代理在某些场景下比JDK动态代理更加灵活，适用于那些无法实现接口的类的代理需求。

# 6. 代理模式的总结与展望

代理模式作为一种常见的设计模式，在实际项目中有着广泛的应用。通过本文的介绍，我们对代理模式有了更深入的了解，接下来我们将对代理模式进行总结，并展望未来的发展方向。

#### 6.1 代理模式的应用场景总结

代理模式适用于各种场景，包括但不限于远程代理、虚拟代理、保护代理、智能引用等。在实际项目中，我们可以根据具体的业务需求来选择合适的代理模式，从而更好地实现业务功能。

#### 6.2 代理模式的局限性

尽管代理模式有着诸多优点，但也存在一些局限性。比如，静态代理需要针对每个被代理对象创建代理类，且难以扩展；动态代理在性能方面可能会有所损耗；CGLIB动态代理无法代理final方法等。

#### 6.3 代理模式在实际项目中的应用建议

在实际项目中，我们应该根据具体的业务场景来选择合适的代理模式，并且在实施过程中需要考虑到代理模式的局限性，灵活运用代理模式，避免过度设计和滥用。

#### 6.4 未来代理模式的发展方向

随着技术的不断发展，代理模式也在不断演进。未来代理模式可能会更加注重性能优化、更加智能化的代理实现、更加简洁高效的代理语法等方面的发展。同时，代理模式可能会与其他设计模式结合，形成更加强大和灵活的设计思路。

总之，代理模式作为一种常见的设计模式，有着广泛的应用前景和发展空间。我们期待在未来的项目中更加灵活、高效地运用代理模式，为软件开发和设计带来更大的价值。

以上就是关于代理模式的总结与展望部分的内容，希望能为你对代理模式的理解提供帮助。