Java动态代理实现AOP编程问题示例

原创柔情只为你懂 2024-12-09 22:00 23阅读 0赞

在Java中，动态代理是面向切面编程(AOP)的重要实现方式。下面是一个简单的AOP编程问题示例：

1. **定义一个目标类（Subject）**：
```java
public class Subject {
    private String name;

public Subject(String name) {
        this.name = name;
    }

// 真实的业务逻辑
    public void doSomething() {
        System.out.println("Subject doing something: " + name);
    }
}
```

2. **定义一个切面（Advice）**：
```java
public class LoggingAspect implements advising interfaces {

@Override
    public void before(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Logging aspect entering: " + pjp.getSignature());
    }

@Override
    public void afterThrowing(ThrowingJoinPoint pjp, Throwable t) throws Throwable {
        System.out.println("Logging aspect exiting due to exception: " + pjp.getSignature());
    }
}
```

3. **配置动态代理（创建代理类）**：
```java
import java.lang.reflect.Method;
import java.util.Arrays;

public class Main {

public static void main(String[] args) throws Throwable {
        // 1. 创建目标类Subject
        Subject subject = new Subject("Example Subject");

// 2. 创建切面LoggingAspect
        LoggingAspect loggingAspect = new LoggingAspect();

// 3. 配置动态代理（创建代理类））
        // 使用Proxy.newProxyInstance()方法，传入参数：目标对象、实现接口、是否可变
        Class<?> proxyClass = Proxy.getProxyClass(subject.getClass(), loggingAspect.getClass()));

// 4. 获取并使用代理对象
        Subject proxySubject = (Subject) proxyClass.newInstance();
        proxySubject.doSomething();

// 5. 通过代理对象访问切面方法
        Method beforeMethod = loggingAspect.getClass().getMethod("before", proxySubject.getClass()));
        beforeMethod.invoke(loggingAspect);

Method afterThrowingMethod = loggingAspect.getClass().getMethod("afterThrowing", proxySubject.getClass(), Arrays.asList(new Object[]{new Throwable("Test Exception")}}))));
        afterThrowingMethod.invoke(loggingAspect);
    }
}
```

以上示例中，我们创建了一个目标类`Subject`和一个切面类`LoggingAspect`。然后通过Proxy的代理机制，为这些类创建了动态代理对象。最后在代理对象上执行业务逻辑，并访问到切面方法。