动态代理更改Java方法的返回参数（可用于优化feign调用后R对象的统一处理）
动态代理更改Java方法的返回参数（可用于优化feign调用后R对象的统一处理）
需求
某些场景，调用别人的方法，但是它外面包了一层，我们只需要里面实际的数据，例如后端开发中的R对象，实际最终只需要data。也就是说可以看成，调用原始方法，代理后更改为别的类型。
下面是R对象，实际运用大同小异，方便大家理解。
public class R<T> 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;
}
@Override
public 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(Class<T> 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 R<T> 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> R<T> success(T data) {
return new R<T>()
.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 R<String> find1() {
return R.success("f1");
}
default R<List<String>> find2() {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
return R.success(list);
}
default R<Double> 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();
List<String> find2();
Double find3(Double d);
}
ClientProxyDhHandlerfeign调用其他微服务接口，统一解析代理处理器
可以看到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;
}
@Override
public 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(Class<T> 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;
@Autowired
public ExampleService(ExampleClient exampleClient) {
this.afterExampleClient = ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);
}
public void testAll(){
//假设这里调用所有
String f1 = afterExampleClient.find1();
System.out.println("f1 = " + f1);
List<String> 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 {
@Autowired
private ExampleService exampleService;
@Test
public void test1(){
exampleService.testAll();
}
}
测试结果
总结，每新增一个Client（feign的微服务调用接口）仅需要创建一个与其对应的AfterClient接口 。需要使用的service,只需要使用动态代理，传入ClientProxyDhHandler并注入到容器中，即可完成统一的远程调用处理。
拓展
如下还有一个小问题，此方式注入到Spring容器中，每次使用者都需要创建代理对象，很麻烦。
@Autowired
public ExampleService(ExampleClient exampleClient) {
this.afterExampleClient = ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);
}
解决方案：通过配置类，一次配置，其他使用者直接进行注入。如下：
@Configuration
public class AfterClientConfiguration {
@Bean
public AfterExampleClient afterExampleClient(ExampleClient exampleClient) {
AfterExampleClient afterExampleClient = ClientProxyDhHandler.create(AfterExampleClient.class, exampleClient);
return afterExampleClient;
}
}
至此，优化完成。🎉🎊
原文地址：https://blog.csdn.net/qq_38367575/article/details/140664978
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！