手撸RPC框架 -动态代理屏蔽RPC服务调用底层细节
站长
· 阅读数 20
大家好，我是小趴菜，接下来我会从0到1手写一个RPC框架，该专题包括以下专题，有兴趣的小伙伴就跟着我一起学习吧
本章源码地址：gitee.com/baojh123/se…
自定义注解 -> opt-01
服务提供者收发消息基础实现 -> opt-01
自定义网络传输协议的实现 -> opt-02
自定义编解码实现 -> opt-03
服务提供者调用真实方法实现 -> opt-04
完善服务消费者发送消息基础功能 -> opt-05
注册中心基础功能实现 -> opt-06
服务提供者整合注册中心 -> opt-07
服务消费者整合注册中心 -> opt-08
完善服务消费者接收响应结果 -> opt-09
服务消费者，服务提供者整合SpringBoot -> opt-10
动态代理屏蔽RPC服务调用底层细节 -> opt-10
SPI机制基础功能实现 -> opt-11
SPI机制扩展随机负载均衡策略 -> opt-12
SPI机制扩展轮询负载均衡策略 -> opt-13
SPI机制扩展JDK序列化 -> opt-14
SPI机制扩展JSON序列化 -> opt-15
SPI机制扩展protustuff序列化 -> opt-16
前言
在上一章中，我们已经成功的将服务提供者和服务消费者与SpringBoot成功整合了。但是在那一章中，我们已经实现了基于动态代理来屏蔽了RPC顶层服务调用的细节，这一章来说明如何去实现动态代理
实现
新建 xpc-rpc-proxy 代理模块，然后在创建二个子模块
- com.xpc.proxy.common.ObjectProxy
package com.xpc.proxy.common;
import com.xpc.proxy.common.consumer.Consumer;
import com.xpc.rpc.common.enums.RpcMsgType;
import com.xpc.rpc.protocol.ProtocolMessage;
import com.xpc.rpc.protocol.header.RpcHeader;
import com.xpc.rpc.protocol.request.RpcRequest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ObjectProxy <T> implements InvocationHandler {
private Consumer consumer;
private Class<T> clazz;
public ObjectProxy(Consumer consumer,Class clazz) {
this.consumer = consumer;
this.clazz = clazz;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//开始构造请求对象
ProtocolMessage<RpcRequest> rpcRequestProtocolMessage = new ProtocolMessage<>();
RpcRequest rpcRequest = new RpcRequest();
RpcHeader rpcHeader = new RpcHeader();
rpcHeader.setMsgType(RpcMsgType.REQUEST.getType());
rpcHeader.setRequestId(1L);
rpcRequestProtocolMessage.setRpcHeader(rpcHeader);
rpcRequest.setClassName(clazz.getName());
rpcRequest.setMethodName(method.getName());
rpcRequest.setParameterTypes(method.getParameterTypes());
rpcRequest.setParameters(args);
rpcRequestProtocolMessage.setT(rpcRequest);
//发送请求
return consumer.sendRequest(rpcRequestProtocolMessage);
}
}
- Consumer：客户端发送请求的接口，RpcConsumer是它的具体实现
- Class：代理接口的class，我们是给接口直接进行代理，所以这个Class也就是这个被代理的 接口的class
创建获取代理的通用接口：com.xpc.proxy.common.ProxyFactory
package com.xpc.proxy.common;
import com.xpc.proxy.common.consumer.Consumer;
public interface ProxyFactory {
/**
* 获取代理对象
*/
<T> T getProxy(Class clazz);
}
JDK动态代理实现: com.xpc.rpc.proxy.jdk.JdkProxy
package com.xpc.rpc.proxy.jdk;
import com.xpc.proxy.common.ObjectProxy;
import com.xpc.proxy.common.ProxyFactory;
import com.xpc.proxy.common.consumer.Consumer;
import java.lang.reflect.Proxy;
public class JdkProxy implements ProxyFactory {
private Consumer consumer;
public JdkProxy(Consumer consumer) {
this.consumer = consumer;
}
//获取代理对象
@Override
public <T> T getProxy(Class clazz) {
ClassLoader classLoader = clazz.getClassLoader();
Class<?>[] interfaces = new Class[]{clazz};
return (T) Proxy.newProxyInstance(classLoader, interfaces, new ObjectProxy<T>(consumer,clazz));
}
}
在 com.xpc.consumer.spring.scanner.reference.ReferenceScanner中，我们扫描到有成员变量被@DubboReference注解标记，那么我们就要为这个接口生成代理对象，并注入到这个变量中去
package com.xpc.consumer.spring.scanner.reference;
import com.xpc.consumer.spring.config.RpcConsumerAutoConfig;
import com.xpc.consumer.spring.scanner.ClassScanner;
import com.xpc.rpc.annotation.DubboReference;
import com.xpc.rpc.consumer.RpcConsumer;
import com.xpc.rpc.proxy.jdk.JdkProxy;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.util.List;
public class ReferenceScanner extends ClassScanner {
private static final Logger LOGGER = LoggerFactory.getLogger(ReferenceScanner.class);
public void doScanDubboReferenceByPackage(String packageName) throws Exception{
// 其它代码省略
classList.forEach(item -> {
try {
Class<?> clazz = Class.forName(item);
Field[] clazzFields = clazz.getDeclaredFields();
for(Field field : clazzFields) {
DubboReference dubboReference = field.getAnnotation(DubboReference.class);
if(dubboReference != null) {
Class<?> targetClazz = field.getType();
JdkProxy jdkProxy = new JdkProxy(RpcConsumer.getInstance());
//获取这个接口的代理对象
Object proxy = jdkProxy.getProxy(targetClazz);
//将代理对象设置到这个变量中去
setField(field, RpcConsumerAutoConfig.getObject(clazz),proxy,true);
}
}
} catch (Exception e) {
e.printStackTrace();
}
});
}
/**
* 设置类的属性值
*
* @param field 成员变量
* @param target 类实例
* @param value 成员变量的值
* @param accessible 是否允许设置私有属性
*/
public static void setField(Field field, Object target, Object value,boolean accessible){
try {
//是否允许设置私有的成员变量的值
field.setAccessible(accessible);
field.set(target,value);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}