广州做商城网站,公司网站一般用什么软件做,游戏推广员怎么做,网络营销包括几个部分动态代理更改Java方法的返回参数#xff08;可用于优化feign调用后R对象的统一处理#xff09; 需求原始解决方案优化后方案1.首先创建AfterInterface.java2.创建InvocationHandler处理代理方法3. 调用 实际运行场景拓展 需求
某些场景#xff0c;调用别人的方法#xff0… 动态代理更改Java方法的返回参数可用于优化feign调用后R对象的统一处理 需求原始解决方案优化后方案1.首先创建AfterInterface.java2.创建InvocationHandler处理代理方法3. 调用 实际运行场景拓展 需求
某些场景调用别人的方法但是它外面包了一层我们只需要里面实际的数据例如后端开发中的R对象实际最终只需要data。也就是说可以看成调用原始方法代理后更改为别的类型。 下面是R对象实际运用大同小异方便大家理解。
public class RT implements Serializable {private static final long serialVersionUID 1L;/*** 正确返回码*/public static final String SUCCESS_CODE 0;/*** 返回码*/private String code;/*** 返回消息*/private String message;/*** 响应数据*/private T data;/*** 请求ID*/private String requestId;public boolean isSuccess() {return SUCCESS_CODE.equals(code);}
}下面仅仅举例重点看出怎么转换返回类型的没有实际意义。具体使用场景可参考后面可参考具体在实际运用场景的 原始解决方案
PreInterface.java 模拟原始方法返回值。
package com.zdh.proxy.chagemethod;/*** author zdh* date 2024/07/24* desc*/
public interface PreInterface {default double method1() {return 2.3;}default int method2() {return 123;}default boolean method3() {return true;}
}
新建一个PreManager 类获得PreInterface对象重新封装所有方法。
package com.zdh.proxy.chagemethod;/*** author developer_ZhangXinHua* date 2024/07/24* desc 详细信息*/
public class PreManager {//正常从容器中拿PreInterface afterInterface new PreInterface(){};public String method1() {return manager: afterInterface.method1();}public String method2() {return manager: afterInterface.method2();}public String method3() {return manager: afterInterface.method3();}public static void main(String[] args) {PreManager preManager new PreManager();System.out.println(preManager.method1());System.out.println(preManager.method2());System.out.println(preManager.method3());}
}
缺点显而易见每个原始PreInterface就需要对应实现一个PreManager而且需要重新实现每个方法。
优化后方案
PreInterface.java 与上面一样不再给出。
1.首先创建AfterInterface.java
重点因为后面代理的时候需要用到方法名和参数列表进行调用所以方法名和参数列表一定要与PreInterface的对应的方法名相同。
package com.zdh.proxy.chagemethod;/*** author zdh* date 2024/07/24* desc*/
public interface AfterInterface {public String method1();public String method2();public String method3();
}
2.创建InvocationHandler处理代理方法
package com.zdh.proxy.chagemethod;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** author zdh* date 2024/07/24* desc*/
public class MethodProxyDhHandler implements InvocationHandler {private final Object target;public MethodProxyDhHandler(Object target) {this.target target;}Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//根据反射拿到和代理后的方法同名且方法参数相同的方法Method targetMethod target.getClass().getMethod(method.getName(), method.getParameterTypes());Object ob targetMethod.invoke(target, args);return proxy after:ob;}public static T T create(ClassT interfaceClass, Object target) {return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),new Class[]{interfaceClass},new MethodProxyDhHandler(target));}}
3. 调用 public static void main(String[] args) {PreInterface preTarget new PreInterface() {};AfterInterface afterInterface create(AfterInterface.class, preTarget);String s1 afterInterface.method1();System.out.println(s1 s1);String s2 afterInterface.method2();System.out.println(s2 s2);String s3 afterInterface.method3();System.out.println(s3 s3);}可以看到已经全部转成了String类型。这里只是测试如果使用Spring等框架可以直接从容器中获取afterInterface 然后afterInterface 创建代理到容器中。
实际运行场景
上述方式仅仅为了简化大家的理解那么现在有个疑问上述方式有啥用呢。目前我遇到场景可用于优化feign调用后R对象的统一处理 仅适用公司内部R对象都统一获取到R对象根据错误码等判断成功与否若成功可以直接拆掉直接返回data。 R.java 后端controller返回参数大同小异。 package cn.zdh;import lombok.Data;
import lombok.experimental.Accessors;import java.io.Serializable;Data
Accessors(chain true)
public class RT implements Serializable {private static final long serialVersionUID 1L;/*** 正确返回码*/public static final String SUCCESS_CODE 0;/*** 返回码*/private String code;/*** 返回消息*/private String message;/*** 响应数据*/private T data;/*** 请求ID*/private String requestId;public boolean isSuccess() {return SUCCESS_CODE.equals(code);}/*** 构造带返回数据的成功响应*//*** 构造带返回数据的成功响应*/public static T RT success(T data) {return new RT().setCode(R.SUCCESS_CODE).setData(data);}
}下面ExampleClient和ExampleClientImpl 仅用于模拟feign远程调用。正常项目里面只需要一个ExampleClient 接口 package cn.zdh.client;import cn.zdh.R;import java.util.ArrayList;
import java.util.List;/*** author zdh* date 2024/07/24* desc 模拟feign远程调用*/
public interface ExampleClient {default RString find1() {return R.success(f1);}default RListString find2() {ListString list new ArrayListString();list.add(a);list.add(b);return R.success(list);}default RDouble find3(Double d) {return R.success(d);}}
package cn.zdh.client;import org.springframework.stereotype.Component;/*** author developer_ZhangXinHua* date 2024/07/24* desc 详细信息*/
Component
public class ExampleClientImpl implements ExampleClient{
} AfterExampleClient 拆掉R之后的data作为方法的返回类型注意方法名和参数要与ExampleClient 方法名和参数一 一对应。简单来讲复制粘贴把返回值删掉R。 package cn.zdh.afterclient;import java.util.List;/*** author developer_ZhangXinHua* date 2024/07/23* desc 定义需要代理后的方法*/
public interface AfterExampleClient {String find1();ListString find2();Double find3(Double d);
} ClientProxyDhHandler feign调用其他微服务接口统一解析代理处理器 可以看到invoke方法中对R对象进行了统一处理并且后续根据需要可以通过错误码进行日志输出和报错通过全局异常处理器返回前端。 package cn.zdh.proxy;//package com.zdh.proxyfeign;import cn.zdh.R;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** author zdh* date 2024/07/24* desc feign调用其他系统接口统一解析代理处理器*/
public class ClientProxyDhHandler implements InvocationHandler {private final Object target;public ClientProxyDhHandler(Object target) {this.target target;}Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Method targetMethod target.getClass().getMethod(method.getName(), method.getParameterTypes());R? r (R?) targetMethod.invoke(target, args);if (r ! null r.isSuccess()) {return r.getData();}/*后续可以根据错误码进行日志输出和报错通过全局异常处理器返回前端。*/return null;}public static T T create(ClassT interfaceClass, Object target) {return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),new Class[]{interfaceClass},new ClientProxyDhHandler(target));}
} ExampleService 模拟service层的调用 package cn.zdh.service;import cn.zdh.afterclient.AfterExampleClient;
import cn.zdh.client.ExampleClient;
import cn.zdh.proxy.ClientProxyDhHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.List;/*** author developer_ZhangXinHua* date 2024/07/23* desc 模拟调用代理后的对象。*/
Service
public class ExampleService{private final AfterExampleClient afterExampleClient;Autowiredpublic ExampleService(ExampleClient exampleClient) {this.afterExampleClient ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);}public void testAll(){//假设这里调用所有String f1 afterExampleClient.find1();System.out.println(f1 f1);ListString f2 afterExampleClient.find2();System.out.println(f2 f2);Double f3 afterExampleClient.find3(3.2);System.out.println(f3 f3);}} Spring Test 测试 RunWith(SpringJUnit4ClassRunner.class)
SpringBootTest
ActiveProfiles(value test)
public class ZdhTest {Autowiredprivate ExampleService exampleService;Testpublic void test1(){exampleService.testAll();}}测试结果 总结每新增一个Clientfeign的微服务调用接口仅需要创建一个与其对应的AfterClient接口 。需要使用的service,只需要使用动态代理传入ClientProxyDhHandler并注入到容器中即可完成统一的远程调用处理。
拓展
如下还有一个小问题此方式注入到Spring容器中每次使用者都需要创建代理对象很麻烦。
Autowired
public ExampleService(ExampleClient exampleClient) {this.afterExampleClient ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);
}解决方案通过配置类一次配置其他使用者直接进行注入。如下
Configuration
public class AfterClientConfiguration {Beanpublic AfterExampleClient afterExampleClient(ExampleClient exampleClient) {AfterExampleClient afterExampleClient ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);return afterExampleClient;}
}至此优化完成。
