通过JDK动态代理类实现一个类中多种方法的不同增强

1.为什么说JDK动态代理必须要实现当前父接口才能使用

　　JDK动态代理是基于接口的代理，它要求目标类（被代理的类）必须实现一个或多个接口。这是因为JDK动态代理是通过创建目标类的接口的代理对象来实现的，代理对象实现了目标接口，并在方法调用时委托给InvocationHandler中的invoke方法来处理。
　　在JDK动态代理中，Proxy类的newProxyInstance方法接受一个ClassLoader，一组接口和一个InvocationHandler，然后生成一个代理类的实例。这个代理类实例实现了指定的接口，并将方法调用委托给InvocationHandler中的invoke方法。
　　自我结论：可能是因为比如生成的$Proxy代理类如果没有父接口 那他内部也不知道通过InvocationHandler来调用谁来进行增强了 还有就是可能有一些决策问题。
2.JDK动态代理的$Proxy实现
　　Cat父接口

1. //父接口
2. interface Cat {
3.     //开车
4.     void drive();
5.     //下车
6.     void off();
7. }

复制代码

　　InvocationHandler接口

1. interface InvocationHandler {
2.     //代理类，代理方法，代理方法参数  
3.     Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
4. }

复制代码

　　$Proxy0代理类

1. class $Proxy0 implements Cat {
2.     private InvocationHandler invocationHandler;
3.     private Map<String, Method> methods;
5.     public $Proxy0(InvocationHandler invocationHandler) {
6.         this.invocationHandler = invocationHandler;
7.         this.methods = new HashMap<>();
8.         try {
9.             methods.put("drive", Cat.class.getMethod("drive"));
10.             methods.put("off", Cat.class.getMethod("off"));
11.         } catch (NoSuchMethodException e) {
12.             throw new RuntimeException(e);
13.         }
14.     }
16.     @Override
17.     public void drive() {
18.         try {
19.             invocationHandler.invoke(this, methods.get("drive"), new Object[0]);
20.         } catch (Throwable e) {
21.             throw new RuntimeException(e);
22.         }
23.     }
25.     @Override
26.     public void off() {
27.         try {
28.             invocationHandler.invoke(this, methods.get("off"), new Object[0]);
29.         } catch (Throwable e) {
30.             throw new RuntimeException(e);
31.         }
32.     }
33. }

复制代码

　　CustomLogicHandler 多个方法不同增强

1. class CustomLogicHandler implements InvocationHandler {
2.     private Object target;
3.     private Map<String, Runnable> methodEnhancements;
5.     public CustomLogicHandler(Object target) {
6.         this.target = target;
7.         this.methodEnhancements = new HashMap<>();
8.         methodEnhancements.put("drive", () -> System.out.println("开车增强"));
9.         methodEnhancements.put("off", () -> System.out.println("下车增强"));
10.     }
11.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
12.         // 根据方法名获取增强逻辑
13.         Runnable enhancement = methodEnhancements.get(method.getName());
14.         if (enhancement != null) {
15.             enhancement.run();
16.         }
17.         // 委托给目标对象执行原方法
18.         Object result = method.invoke(target, args);
19.         return result;
20.     }
21. }

复制代码

 
　　Fute实现类（待增强类）

1. class FuTe implements Cat {
2.     @Override
3.     public void drive() {
4.         System.out.println("我要开始开车了");
5.     }
7.     @Override
8.     public void off() {
9.         System.out.println("我要下车了");
10.     }
11.     public static void main(String[] args) {
12.         Cat realObject = new FuTe();
13.         CustomLogicHandler customLogicHandler = new CustomLogicHandler(realObject);
15.         Cat proxyObject = (Cat) new $Proxy0(customLogicHandler);
17.         proxyObject.drive();
18.         System.out.println("------");
19.         proxyObject.off();
20.     }
21. }

复制代码

　　总结：在这个例子中，CustomLogicHandler中的methodEnhancements存储了不同方法的增强逻辑，而不再使用if语句。在$Proxy0中的methods也类似地存储了不同方法的Method对象。这种方式可以更灵活地处理不同方法的增强逻辑，而不需要使用大量的if语句。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！