你说说RPC的一个请求的流程是怎么样的？

{
	"interfaces": "interface=com.jimoer.rpc.test.producer.TestService;method=printTest;parameter=com.jiomer.rpc.test.producer.TestArgs",
	"requestId": "3",
	"parameter": {
		"com.jiomer.rpc.test.producer.TestArgs": {
			"age": 20,
			"name": "Jimoer"
		}
	}
}

// 定义请求的URL
String tcpURL = "tcp://testProducer/TestServiceImpl";
// 定义接口请求
TestService testService = ProxyFactory.create(TestService.class, tcpURL);
// 组装请求参数
TestArgs testArgs = new TestArgs(20,"Jimoer");
// 通过动态代理执行请求
String result = testService.printTest(testArgs);

Proxy.newProxyInstance(getClass().getClassLoader(), interfaces.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                // 第一步：获取调用服务的地址列表
                ListregistryInfos = interfacesMethodRegistryList.get(clazz);

                if (registryInfos == null) {
                    throw new RuntimeException("无法找到服务提供者");
                }

                // 第二步： 通过自身的负载均衡策略选择一个地址
                RegistryInfo registryInfo = loadBalancer.choose(registryInfos);

                // 第三步：Netty的网络请求处理
                ChannelHandlerContext ctx = channels.get(registryInfo);
                // 第四步：根据接口类的全路径名和方法生成唯一标识
                String identify = InvokeUtils.buildInterfaceMethodIdentify(clazz, method);
                String requestId;
                // 第五步：通过加锁的方式保证生成的requestId的唯一性
                synchronized (ApplicationContext.this) {
                    requestIdWorker.increment();
                    requestId = String.valueOf(requestIdWorker.longValue());
                }
                // 第六步： 组织参数
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("interfaces", identify);
                jsonObject.put("parameter", param);
                jsonObject.put("requestId", requestId);
                System.out.println("发送给服务端JSON为：" + jsonObject.toJSONString());
                // $$ 多条消息之间的分隔符
                String msg = jsonObject.toJSONString() + "$$";
                ByteBuf byteBuf = Unpooled.buffer(msg.getBytes().length);
                byteBuf.writeBytes(msg.getBytes());
                // 第七步：这里发起调用
                ctx.writeAndFlush(byteBuf);
                // 这里会将线程进行阻塞，知道服务提供方将请求处理好之后返回结果，再唤醒。
                waitForResult();
                return result;

            }
        });

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    try {
        String message = (String) msg;
        if (messageCallback != null) {
        	// 将接收到的消息放到回调方法中
            messageCallback.onMessage(message);
        }
    } finally {
        ReferenceCountUtil.release(msg);
    }
}

client.setMessageCallback(message -> {
    // 这里收单服务端返回的消息，先压入队列
    RpcResponse response = JSONObject.parseObject(message, RpcResponse.class);
	System.out.println("收到一个响应：" + response);
    String interfaceMethodIdentify = response.getInterfaceMethodIdentify();
    String requestId = response.getRequestId();
    // 设定唯一标识
    String key = interfaceMethodIdentify + "#" + requestId;
    Invoker invoker = inProgressInvoker.remove(key);
    // 将结果设置到代理对象中
    invoker.setResult(response.getResult());
	// 加锁再释放之前的阻塞线程。
    synchronized (ApplicationContext.this) {
        ApplicationContext.this.notifyAll();
    }
});

@Override
public void setResult(String result) {
    synchronized (this) {
        this.result = JSONObject.parseObject(result, returnType);
        notifyAll();
    }
}