java 实现,执行某个方法时,拦截这个方法
时间: 2024-02-06 16:02:36 浏览: 22
可以使用 Java 的代理模式来实现方法拦截。代理模式是一种结构型设计模式,它允许你提供一个代理对象来控制对某个对象的访问。
在 Java 中,代理模式通常有两种实现方式:静态代理和动态代理。其中,静态代理需要手动实现代理类,而动态代理则可以在运行时自动生成代理类。
下面是使用动态代理实现方法拦截的示例代码:
```java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MethodInterceptorDemo {
public static void main(String[] args) {
RealObject realObject = new RealObject();
MyInvocationHandler handler = new MyInvocationHandler(realObject);
Object proxyObject = Proxy.newProxyInstance(
realObject.getClass().getClassLoader(),
realObject.getClass().getInterfaces(),
handler);
((MyInterface)proxyObject).doSomething();
}
}
interface MyInterface {
void doSomething();
}
class RealObject implements MyInterface {
public void doSomething() {
System.out.println("RealObject doSomething");
}
}
class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method invocation");
Object result = method.invoke(target, args);
System.out.println("After method invocation");
return result;
}
}
```
在上面的示例代码中,我们定义了一个 `MyInterface` 接口,其中有一个 `doSomething` 方法。我们希望在调用这个方法时,能够在方法执行前后打印一些信息。因此,我们使用了动态代理来实现方法拦截。
首先,我们定义了一个 `RealObject` 类,它实现了 `MyInterface` 接口,并实现了 `doSomething` 方法。然后,我们定义了一个 `MyInvocationHandler` 类,它实现了 `InvocationHandler` 接口,并在 `invoke` 方法中实现了方法拦截的逻辑。最后,我们在 `MethodInterceptorDemo` 类中使用 `Proxy.newProxyInstance` 方法来创建代理对象,并调用代理对象的 `doSomething` 方法。
当我们运行这段代码时,输出结果如下:
```
Before method invocation
RealObject doSomething
After method invocation
```
可以看到,在调用代理对象的 `doSomething` 方法时,会先执行 `MyInvocationHandler` 中的 `invoke` 方法,打印 "Before method invocation",然后再执行 `RealObject` 中的 `doSomething` 方法,打印 "RealObject doSomething",最后再执行 `MyInvocationHandler` 中的 `invoke` 方法,打印 "After method invocation"。因此,我们成功地实现了方法拦截。