Java中动态代理：实现接口与增强功能的区别

原创小咪咪 2024-11-21 23:48 31阅读 0赞

在Java中，动态代理主要通过Proxy类的proxyNewInstance方法来实现。它主要用于实现对类的方法拦截和控制。

1. 实现接口：如果你有一个接口需要被一个类实现，这通常使用常规的面向对象编程方式。例如：

```java
public interface MyInterface {
    void doSomething();
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        // 实现逻辑
    }
}
```

2. 增强功能：动态代理的主要用途在于增强功能，而不是实现接口。通过代理方法，可以在不修改原类代码的情况下，对原方法进行扩展或改变行为。

例如：

```java
// 定义一个目标接口和对应的实现类
public interface MyLoggingInterface {
    void log(String message);
}

class MyClass implements MyLoggingInterface {
    @Override
    public void log(String message) {
        // 实现原始日志功能
        System.out.println("Original log: " + message);
    }
}

// 使用动态代理增强功能
public class LoggingProxy implements InvocationHandler {
    private final Object target;

public LoggingProxy(MyLoggingInterface target) {
        this.target = target;
    }

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 记录原始方法信息
        String methodName = method.getName();
        logOriginalMethod(methodName);

// 调用目标对象的方法，并记录日志
        Object result = method.invoke(target, args);
        logMethodResult(result, methodName);

return result;
    }

private void logOriginalMethod(String methodName) {
        System.out.println("Logging original method: " + methodName);
    }

private void logMethodResult(Object result, String methodName) {
        System.out.println("Logging method result: " + methodName + " -> " + result);
    }
}

// 使用动态代理增强原类功能
public class Main {
    public static void main(String[] args) {
        // 创建目标对象并创建动态代理
        MyLoggingInterface target = new MyClass();
        LoggingProxy proxy = new LoggingProxy(target);

// 调用代理对象的方法，观察日志记录
        String message = "Hello, World!";
        proxy.log(message);
    }
}
```

在这个例子中，`MyLoggingInterface`是目标接口，`MyClass`实现了这个接口。通过`LoggingProxy`代理类，我们可以动态地对`log`方法进行增强，例如添加日志记录功能。