From 7b2589bc2eef2189957302205876a0e771982b16 Mon Sep 17 00:00:00 2001 From: Wxx <2563806166@qq.com> Date: Sun, 5 May 2024 20:32:24 +0800 Subject: [PATCH 1/2] version1 --- version1/pom.xml | 38 +++++++++++ .../src/main/java/part1/Client/IOClient.java | 36 ++++++++++ .../main/java/part1/Client/TestClient.java | 25 +++++++ .../java/part1/Client/proxy/ClientProxy.java | 40 +++++++++++ .../main/java/part1/Server/TestServer.java | 25 +++++++ .../Server/provider/ServiceProvider.java | 34 ++++++++++ .../java/part1/Server/server/RpcServer.java | 12 ++++ .../server/impl/SimpleRPCRPCServer.java | 40 +++++++++++ .../server/impl/ThreadPoolRPCRPCServer.java | 58 ++++++++++++++++ .../part1/Server/server/work/WorkThread.java | 58 ++++++++++++++++ .../java/part1/common/Message/RpcRequest.java | 25 +++++++ .../part1/common/Message/RpcResponse.java | 30 ++++++++ .../src/main/java/part1/common/pojo/User.java | 25 +++++++ .../common/service/Impl/UserServiceImpl.java | 32 +++++++++ .../part1/common/service/UserService.java | 16 +++++ .../src/main/java/part2/Client/IOClient.java | 36 ++++++++++ .../main/java/part2/Client/TestClient.java | 26 +++++++ .../netty/handler/NettyClientHandler.java | 28 ++++++++ .../NettyClientInitializer.java | 43 ++++++++++++ .../java/part2/Client/proxy/ClientProxy.java | 53 +++++++++++++++ .../part2/Client/rpcClient/RpcClient.java | 15 ++++ .../Client/rpcClient/impl/NettyRpcClient.java | 62 +++++++++++++++++ .../rpcClient/impl/SimpleSocketRpcCilent.java | 41 +++++++++++ .../main/java/part2/Server/TestServer.java | 26 +++++++ .../netty/handler/NettyRPCServerHandler.java | 52 ++++++++++++++ .../NettyServerInitializer.java | 46 +++++++++++++ .../Server/provider/ServiceProvider.java | 32 +++++++++ .../java/part2/Server/server/RpcServer.java | 11 +++ .../Server/server/impl/NettyRPCRPCServer.java | 49 +++++++++++++ .../server/impl/SimpleRPCRPCServer.java | 39 +++++++++++ .../server/impl/ThreadPoolRPCRPCServer.java | 58 ++++++++++++++++ .../part2/Server/server/work/WorkThread.java | 58 ++++++++++++++++ .../java/part2/common/Message/RpcRequest.java | 25 +++++++ .../part2/common/Message/RpcResponse.java | 29 ++++++++ .../src/main/java/part2/common/pojo/User.java | 25 +++++++ .../common/service/Impl/UserServiceImpl.java | 32 +++++++++ .../part2/common/service/UserService.java | 16 +++++ .../main/java/part3/Client/TestClient.java | 27 ++++++++ .../netty/handler/NettyClientHandler.java | 27 ++++++++ .../NettyClientInitializer.java | 42 ++++++++++++ .../java/part3/Client/proxy/ClientProxy.java | 43 ++++++++++++ .../part3/Client/rpcClient/RpcClient.java | 15 ++++ .../Client/rpcClient/impl/NettyRpcClient.java | 68 +++++++++++++++++++ .../rpcClient/impl/SimpleSocketRpcCilent.java | 41 +++++++++++ .../Client/serviceCenter/ServiceCenter.java | 14 ++++ .../Client/serviceCenter/ZKServiceCenter.java | 59 ++++++++++++++++ .../main/java/part3/Server/TestServer.java | 26 +++++++ .../netty/handler/NettyRPCServerHandler.java | 51 ++++++++++++++ .../NettyServerInitializer.java | 46 +++++++++++++ .../Server/provider/ServiceProvider.java | 47 +++++++++++++ .../java/part3/Server/server/RpcServer.java | 11 +++ .../Server/server/impl/NettyRPCRPCServer.java | 48 +++++++++++++ .../server/impl/SimpleRPCRPCServer.java | 39 +++++++++++ .../part3/Server/server/work/WorkThread.java | 58 ++++++++++++++++ .../serviceRegister/ServiceRegister.java | 15 ++++ .../impl/ZKServiceRegister.java | 62 +++++++++++++++++ .../java/part3/common/Message/RpcRequest.java | 25 +++++++ .../part3/common/Message/RpcResponse.java | 29 ++++++++ .../src/main/java/part3/common/pojo/User.java | 25 +++++++ .../common/service/Impl/UserServiceImpl.java | 32 +++++++++ .../part3/common/service/UserService.java | 16 +++++ 61 files changed, 2162 insertions(+) create mode 100644 version1/pom.xml create mode 100644 version1/src/main/java/part1/Client/IOClient.java create mode 100644 version1/src/main/java/part1/Client/TestClient.java create mode 100644 version1/src/main/java/part1/Client/proxy/ClientProxy.java create mode 100644 version1/src/main/java/part1/Server/TestServer.java create mode 100644 version1/src/main/java/part1/Server/provider/ServiceProvider.java create mode 100644 version1/src/main/java/part1/Server/server/RpcServer.java create mode 100644 version1/src/main/java/part1/Server/server/impl/SimpleRPCRPCServer.java create mode 100644 version1/src/main/java/part1/Server/server/impl/ThreadPoolRPCRPCServer.java create mode 100644 version1/src/main/java/part1/Server/server/work/WorkThread.java create mode 100644 version1/src/main/java/part1/common/Message/RpcRequest.java create mode 100644 version1/src/main/java/part1/common/Message/RpcResponse.java create mode 100644 version1/src/main/java/part1/common/pojo/User.java create mode 100644 version1/src/main/java/part1/common/service/Impl/UserServiceImpl.java create mode 100644 version1/src/main/java/part1/common/service/UserService.java create mode 100644 version1/src/main/java/part2/Client/IOClient.java create mode 100644 version1/src/main/java/part2/Client/TestClient.java create mode 100644 version1/src/main/java/part2/Client/netty/handler/NettyClientHandler.java create mode 100644 version1/src/main/java/part2/Client/netty/nettyInitializer/NettyClientInitializer.java create mode 100644 version1/src/main/java/part2/Client/proxy/ClientProxy.java create mode 100644 version1/src/main/java/part2/Client/rpcClient/RpcClient.java create mode 100644 version1/src/main/java/part2/Client/rpcClient/impl/NettyRpcClient.java create mode 100644 version1/src/main/java/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.java create mode 100644 version1/src/main/java/part2/Server/TestServer.java create mode 100644 version1/src/main/java/part2/Server/netty/handler/NettyRPCServerHandler.java create mode 100644 version1/src/main/java/part2/Server/netty/nettyInitializer/NettyServerInitializer.java create mode 100644 version1/src/main/java/part2/Server/provider/ServiceProvider.java create mode 100644 version1/src/main/java/part2/Server/server/RpcServer.java create mode 100644 version1/src/main/java/part2/Server/server/impl/NettyRPCRPCServer.java create mode 100644 version1/src/main/java/part2/Server/server/impl/SimpleRPCRPCServer.java create mode 100644 version1/src/main/java/part2/Server/server/impl/ThreadPoolRPCRPCServer.java create mode 100644 version1/src/main/java/part2/Server/server/work/WorkThread.java create mode 100644 version1/src/main/java/part2/common/Message/RpcRequest.java create mode 100644 version1/src/main/java/part2/common/Message/RpcResponse.java create mode 100644 version1/src/main/java/part2/common/pojo/User.java create mode 100644 version1/src/main/java/part2/common/service/Impl/UserServiceImpl.java create mode 100644 version1/src/main/java/part2/common/service/UserService.java create mode 100644 version1/src/main/java/part3/Client/TestClient.java create mode 100644 version1/src/main/java/part3/Client/netty/handler/NettyClientHandler.java create mode 100644 version1/src/main/java/part3/Client/netty/nettyInitializer/NettyClientInitializer.java create mode 100644 version1/src/main/java/part3/Client/proxy/ClientProxy.java create mode 100644 version1/src/main/java/part3/Client/rpcClient/RpcClient.java create mode 100644 version1/src/main/java/part3/Client/rpcClient/impl/NettyRpcClient.java create mode 100644 version1/src/main/java/part3/Client/rpcClient/impl/SimpleSocketRpcCilent.java create mode 100644 version1/src/main/java/part3/Client/serviceCenter/ServiceCenter.java create mode 100644 version1/src/main/java/part3/Client/serviceCenter/ZKServiceCenter.java create mode 100644 version1/src/main/java/part3/Server/TestServer.java create mode 100644 version1/src/main/java/part3/Server/netty/handler/NettyRPCServerHandler.java create mode 100644 version1/src/main/java/part3/Server/netty/nettyInitializer/NettyServerInitializer.java create mode 100644 version1/src/main/java/part3/Server/provider/ServiceProvider.java create mode 100644 version1/src/main/java/part3/Server/server/RpcServer.java create mode 100644 version1/src/main/java/part3/Server/server/impl/NettyRPCRPCServer.java create mode 100644 version1/src/main/java/part3/Server/server/impl/SimpleRPCRPCServer.java create mode 100644 version1/src/main/java/part3/Server/server/work/WorkThread.java create mode 100644 version1/src/main/java/part3/Server/serviceRegister/ServiceRegister.java create mode 100644 version1/src/main/java/part3/Server/serviceRegister/impl/ZKServiceRegister.java create mode 100644 version1/src/main/java/part3/common/Message/RpcRequest.java create mode 100644 version1/src/main/java/part3/common/Message/RpcResponse.java create mode 100644 version1/src/main/java/part3/common/pojo/User.java create mode 100644 version1/src/main/java/part3/common/service/Impl/UserServiceImpl.java create mode 100644 version1/src/main/java/part3/common/service/UserService.java diff --git a/version1/pom.xml b/version1/pom.xml new file mode 100644 index 0000000..4ae066c --- /dev/null +++ b/version1/pom.xml @@ -0,0 +1,38 @@ + + + 4.0.0 + + org.example + version1 + 1.0-SNAPSHOT + + 8 + 8 + UTF-8 + + + + org.projectlombok + lombok + 1.18.30 + compile + + + io.netty + netty-all + 4.1.51.Final + compile + + + + org.apache.curator + curator-recipes + 5.1.0 + + + + + + \ No newline at end of file diff --git a/version1/src/main/java/part1/Client/IOClient.java b/version1/src/main/java/part1/Client/IOClient.java new file mode 100644 index 0000000..8c7f61f --- /dev/null +++ b/version1/src/main/java/part1/Client/IOClient.java @@ -0,0 +1,36 @@ +package part1.Client; + + + +import part1.common.Message.RpcRequest; +import part1.common.Message.RpcResponse; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/4 18:31 + */ +public class IOClient { + //这里负责底层与服务端的通信，发送request，返回response + public static RpcResponse sendRequest(String host, int port, RpcRequest request){ + try { + Socket socket=new Socket(host, port); + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + + oos.writeObject(request); + oos.flush(); + + RpcResponse response=(RpcResponse) ois.readObject(); + return response; + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/version1/src/main/java/part1/Client/TestClient.java b/version1/src/main/java/part1/Client/TestClient.java new file mode 100644 index 0000000..f9b7bab --- /dev/null +++ b/version1/src/main/java/part1/Client/TestClient.java @@ -0,0 +1,25 @@ +package part1.Client; + + +import part1.Client.proxy.ClientProxy; +import part1.common.service.UserService; +import part1.common.pojo.User; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 18:39 + */ +public class TestClient { + public static void main(String[] args) { + ClientProxy clientProxy=new ClientProxy("127.0.0.1",9999); + UserService proxy=clientProxy.getProxy(UserService.class); + + User user = proxy.getUserByUserId(1); + System.out.println("从服务端得到的user="+user.toString()); + + User u=User.builder().id(100).userName("wxx").sex(true).build(); + Integer id = proxy.insertUserId(u); + System.out.println("向服务端插入user的id"+id); + } +} diff --git a/version1/src/main/java/part1/Client/proxy/ClientProxy.java b/version1/src/main/java/part1/Client/proxy/ClientProxy.java new file mode 100644 index 0000000..3701bdf --- /dev/null +++ b/version1/src/main/java/part1/Client/proxy/ClientProxy.java @@ -0,0 +1,40 @@ +package part1.Client.proxy; + + +import lombok.AllArgsConstructor; +import part1.Client.IOClient; +import part1.common.Message.RpcRequest; +import part1.common.Message.RpcResponse; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 16:49 + */ +@AllArgsConstructor +public class ClientProxy implements InvocationHandler { + //传入参数service接口的class对象，反射封装成一个request + private String host; + private int port; + + //jdk动态代理，每一次代理对象调用方法，都会经过此方法增强（反射获取request对象，socket发送到服务端） + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + //构建request + RpcRequest request=RpcRequest.builder() + .interfaceName(method.getDeclaringClass().getName()) + .methodName(method.getName()) + .params(args).paramsType(method.getParameterTypes()).build(); + //IOClient.sendRequest 和服务端进行数据传输 + RpcResponse response= IOClient.sendRequest(host,port,request); + return response.getData(); + } + public T getProxy(Class clazz){ + Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this); + return (T)o; + } +} diff --git a/version1/src/main/java/part1/Server/TestServer.java b/version1/src/main/java/part1/Server/TestServer.java new file mode 100644 index 0000000..682b912 --- /dev/null +++ b/version1/src/main/java/part1/Server/TestServer.java @@ -0,0 +1,25 @@ +package part1.Server; + + +import part1.Server.server.RpcServer; +import part1.common.service.Impl.UserServiceImpl; +import part1.common.service.UserService; +import part1.Server.server.impl.SimpleRPCRPCServer; +import part1.Server.provider.ServiceProvider; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/11 19:39 + */ +public class TestServer { + public static void main(String[] args) { + UserService userService=new UserServiceImpl(); + + ServiceProvider serviceProvider=new ServiceProvider(); + serviceProvider.provideServiceInterface(userService); + + RpcServer rpcServer=new SimpleRPCRPCServer(serviceProvider); + rpcServer.start(9999); + } +} diff --git a/version1/src/main/java/part1/Server/provider/ServiceProvider.java b/version1/src/main/java/part1/Server/provider/ServiceProvider.java new file mode 100644 index 0000000..8864448 --- /dev/null +++ b/version1/src/main/java/part1/Server/provider/ServiceProvider.java @@ -0,0 +1,34 @@ +package part1.Server.provider; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/16 17:35 + */ +//本地服务存放器 +public class ServiceProvider { + //集合中存放服务的实例 + private Map interfaceProvider; + + public ServiceProvider(){ + this.interfaceProvider=new HashMap<>(); + } + //本地注册服务 + + public void provideServiceInterface(Object service){ + String serviceName=service.getClass().getName(); + Class[] interfaceName=service.getClass().getInterfaces(); + + for (Class clazz:interfaceName){ + interfaceProvider.put(clazz.getName(),service); + } + + } + //获取服务实例 + public Object getService(String interfaceName){ + return interfaceProvider.get(interfaceName); + } +} diff --git a/version1/src/main/java/part1/Server/server/RpcServer.java b/version1/src/main/java/part1/Server/server/RpcServer.java new file mode 100644 index 0000000..76df981 --- /dev/null +++ b/version1/src/main/java/part1/Server/server/RpcServer.java @@ -0,0 +1,12 @@ +package part1.Server.server; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:26 + */ +public interface RpcServer { + //开启监听 + void start(int port); + void stop(); +} diff --git a/version1/src/main/java/part1/Server/server/impl/SimpleRPCRPCServer.java b/version1/src/main/java/part1/Server/server/impl/SimpleRPCRPCServer.java new file mode 100644 index 0000000..09afdff --- /dev/null +++ b/version1/src/main/java/part1/Server/server/impl/SimpleRPCRPCServer.java @@ -0,0 +1,40 @@ +package part1.Server.server.impl; + + +import lombok.AllArgsConstructor; +import part1.Server.server.RpcServer; +import part1.Server.server.work.WorkThread; +import part1.Server.provider.ServiceProvider; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:37 + */ +@AllArgsConstructor +public class SimpleRPCRPCServer implements RpcServer { + private ServiceProvider serviceProvide; + @Override + public void start(int port) { + try { + ServerSocket serverSocket=new ServerSocket(port); + System.out.println("服务器启动了"); + while (true) { + //如果没有连接，会堵塞在这里 + Socket socket = serverSocket.accept(); + //有连接，创建一个新的线程执行处理 + new Thread(new WorkThread(socket,serviceProvide)).start(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void stop() { + } +} diff --git a/version1/src/main/java/part1/Server/server/impl/ThreadPoolRPCRPCServer.java b/version1/src/main/java/part1/Server/server/impl/ThreadPoolRPCRPCServer.java new file mode 100644 index 0000000..0d32e1f --- /dev/null +++ b/version1/src/main/java/part1/Server/server/impl/ThreadPoolRPCRPCServer.java @@ -0,0 +1,58 @@ +package part1.Server.server.impl; + + +import part1.Server.server.RpcServer; +import part1.Server.server.work.WorkThread; +import part1.Server.provider.ServiceProvider; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/19 15:30 + */ +public class ThreadPoolRPCRPCServer implements RpcServer { + private final ThreadPoolExecutor threadPool; + private ServiceProvider serviceProvider; + + public ThreadPoolRPCRPCServer(ServiceProvider serviceProvider){ + threadPool=new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), + 1000,60, TimeUnit.SECONDS,new ArrayBlockingQueue<>(100)); + this.serviceProvider= serviceProvider; + } + public ThreadPoolRPCRPCServer(ServiceProvider serviceProvider, int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue workQueue){ + + threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); + this.serviceProvider = serviceProvider; + } + + @Override + public void start(int port) { + System.out.println("服务端启动了"); + try { + ServerSocket serverSocket=new ServerSocket(); + while (true){ + Socket socket= serverSocket.accept(); + threadPool.execute(new WorkThread(socket,serviceProvider)); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part1/Server/server/work/WorkThread.java b/version1/src/main/java/part1/Server/server/work/WorkThread.java new file mode 100644 index 0000000..064b9c2 --- /dev/null +++ b/version1/src/main/java/part1/Server/server/work/WorkThread.java @@ -0,0 +1,58 @@ +package part1.Server.server.work; + + +import lombok.AllArgsConstructor; +import part1.Server.provider.ServiceProvider; +import part1.common.Message.RpcRequest; +import part1.common.Message.RpcResponse; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/14 17:39 + */ +@AllArgsConstructor +public class WorkThread implements Runnable{ + private Socket socket; + private ServiceProvider serviceProvide; + @Override + public void run() { + try { + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + //读取客户端传过来的request + RpcRequest rpcRequest = (RpcRequest) ois.readObject(); + //反射调用服务方法获取返回值 + RpcResponse rpcResponse=getResponse(rpcRequest); + //向客户端写入response + oos.writeObject(rpcResponse); + oos.flush(); + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + private RpcResponse getResponse(RpcRequest rpcRequest){ + //得到服务名 + String interfaceName=rpcRequest.getInterfaceName(); + //得到服务端相应服务实现类 + Object service = serviceProvide.getService(interfaceName); + //反射调用方法 + Method method=null; + try { + method= service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType()); + Object invoke=method.invoke(service,rpcRequest.getParams()); + return RpcResponse.sussess(invoke); + } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + System.out.println("方法执行错误"); + return RpcResponse.fail(); + } + } +} diff --git a/version1/src/main/java/part1/common/Message/RpcRequest.java b/version1/src/main/java/part1/common/Message/RpcRequest.java new file mode 100644 index 0000000..0d8f171 --- /dev/null +++ b/version1/src/main/java/part1/common/Message/RpcRequest.java @@ -0,0 +1,25 @@ +package part1.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 18:30 + * 定义发送的消息格式 + */ +@Data +@Builder +public class RpcRequest implements Serializable { + //服务类名，客户端只知道接口 + private String interfaceName; + //调用的方法名 + private String methodName; + //参数列表 + private Object[] params; + //参数类型 + private Class[] paramsType; +} diff --git a/version1/src/main/java/part1/common/Message/RpcResponse.java b/version1/src/main/java/part1/common/Message/RpcResponse.java new file mode 100644 index 0000000..906ee1c --- /dev/null +++ b/version1/src/main/java/part1/common/Message/RpcResponse.java @@ -0,0 +1,30 @@ +package part1.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 19:18 + */ +@Data +@Builder +public class RpcResponse implements Serializable { + //状态信息 + private int code; + private String message; + //具体数据 + private Object data; + //构造成功信息 + public static RpcResponse sussess(Object data){ + return RpcResponse.builder().code(200).data(data).build(); + } + //构造失败信息 + public static RpcResponse fail(){ + return RpcResponse.builder().code(500).message("服务器发生错误").build(); + } +} + diff --git a/version1/src/main/java/part1/common/pojo/User.java b/version1/src/main/java/part1/common/pojo/User.java new file mode 100644 index 0000000..d7cef8c --- /dev/null +++ b/version1/src/main/java/part1/common/pojo/User.java @@ -0,0 +1,25 @@ +package part1.common.pojo; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 17:50 + */ +@Builder +@Data +@NoArgsConstructor +@AllArgsConstructor +public class User implements Serializable { + // 客户端和服务端共有的 + private Integer id; + private String userName; + private Boolean sex; +} + diff --git a/version1/src/main/java/part1/common/service/Impl/UserServiceImpl.java b/version1/src/main/java/part1/common/service/Impl/UserServiceImpl.java new file mode 100644 index 0000000..373243b --- /dev/null +++ b/version1/src/main/java/part1/common/service/Impl/UserServiceImpl.java @@ -0,0 +1,32 @@ +package part1.common.service.Impl; + + +import part1.common.pojo.User; +import part1.common.service.UserService; + +import java.util.Random; +import java.util.UUID; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:28 + */ +public class UserServiceImpl implements UserService { + @Override + public User getUserByUserId(Integer id) { + System.out.println("客户端查询了"+id+"的用户"); + // 模拟从数据库中取用户的行为 + Random random = new Random(); + User user = User.builder().userName(UUID.randomUUID().toString()) + .id(id) + .sex(random.nextBoolean()).build(); + return user; + } + + @Override + public Integer insertUserId(User user) { + System.out.println("插入数据成功"+user.getUserName()); + return user.getId(); + } +} \ No newline at end of file diff --git a/version1/src/main/java/part1/common/service/UserService.java b/version1/src/main/java/part1/common/service/UserService.java new file mode 100644 index 0000000..0e539bd --- /dev/null +++ b/version1/src/main/java/part1/common/service/UserService.java @@ -0,0 +1,16 @@ +package part1.common.service; + + +import part1.common.pojo.User; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:27 + */ +public interface UserService { + // 客户端通过这个接口调用服务端的实现类 + User getUserByUserId(Integer id); + //新增一个功能 + Integer insertUserId(User user); +} diff --git a/version1/src/main/java/part2/Client/IOClient.java b/version1/src/main/java/part2/Client/IOClient.java new file mode 100644 index 0000000..066736a --- /dev/null +++ b/version1/src/main/java/part2/Client/IOClient.java @@ -0,0 +1,36 @@ +package part2.Client; + + + +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/4 18:31 + */ +public class IOClient { + //这里负责底层与服务端的通信，发送request，返回response + public static RpcResponse sendRequest(String host, int port, RpcRequest request){ + try { + Socket socket=new Socket(host, port); + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + + oos.writeObject(request); + oos.flush(); + + RpcResponse response=(RpcResponse) ois.readObject(); + return response; + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/version1/src/main/java/part2/Client/TestClient.java b/version1/src/main/java/part2/Client/TestClient.java new file mode 100644 index 0000000..3ce5d38 --- /dev/null +++ b/version1/src/main/java/part2/Client/TestClient.java @@ -0,0 +1,26 @@ +package part2.Client; + + +import part2.Client.proxy.ClientProxy; +import part2.common.pojo.User; +import part2.common.service.UserService; + + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 18:39 + */ +public class TestClient { + public static void main(String[] args) { + ClientProxy clientProxy=new ClientProxy("127.0.0.1",9999,0); + UserService proxy=clientProxy.getProxy(UserService.class); + + User user = proxy.getUserByUserId(1); + System.out.println("从服务端得到的user="+user.toString()); + + User u=User.builder().id(100).userName("wxx").sex(true).build(); + Integer id = proxy.insertUserId(u); + System.out.println("向服务端插入user的id"+id); + } +} diff --git a/version1/src/main/java/part2/Client/netty/handler/NettyClientHandler.java b/version1/src/main/java/part2/Client/netty/handler/NettyClientHandler.java new file mode 100644 index 0000000..12d5693 --- /dev/null +++ b/version1/src/main/java/part2/Client/netty/handler/NettyClientHandler.java @@ -0,0 +1,28 @@ +package part2.Client.netty.handler; + +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.util.AttributeKey; +import part2.common.Message.RpcResponse; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 17:29 + */ +public class NettyClientHandler extends SimpleChannelInboundHandler { + @Override + protected void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception { + // 接收到response, 给channel设计别名，让sendRequest里读取response + AttributeKey key = AttributeKey.valueOf("RPCResponse"); + ctx.channel().attr(key).set(response); + ctx.channel().close(); + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + //异常处理 + cause.printStackTrace(); + ctx.close(); + } +} diff --git a/version1/src/main/java/part2/Client/netty/nettyInitializer/NettyClientInitializer.java b/version1/src/main/java/part2/Client/netty/nettyInitializer/NettyClientInitializer.java new file mode 100644 index 0000000..5bec33d --- /dev/null +++ b/version1/src/main/java/part2/Client/netty/nettyInitializer/NettyClientInitializer.java @@ -0,0 +1,43 @@ +package part2.Client.netty.nettyInitializer; + + +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.codec.LengthFieldBasedFrameDecoder; +import io.netty.handler.codec.LengthFieldPrepender; +import io.netty.handler.codec.serialization.ClassResolver; +import io.netty.handler.codec.serialization.ObjectDecoder; +import io.netty.handler.codec.serialization.ObjectEncoder; +import part2.Client.netty.handler.NettyClientHandler; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 17:26 + */ +public class NettyClientInitializer extends ChannelInitializer { + @Override + protected void initChannel(SocketChannel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + //消息格式 【长度】【消息体】，解决沾包问题 + pipeline.addLast( + new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4)); + //计算当前待发送消息的长度，写入到前4个字节中 + pipeline.addLast(new LengthFieldPrepender(4)); + //编码器 + //使用Java序列化方式，netty的自带的解码编码支持传输这种结构 + pipeline.addLast(new ObjectEncoder()); + //解码器 + //使用了Netty中的ObjectDecoder，它用于将字节流解码为 Java 对象。 + //在ObjectDecoder的构造函数中传入了一个ClassResolver 对象，用于解析类名并加载相应的类。 + pipeline.addLast(new ObjectDecoder(new ClassResolver() { + @Override + public Class resolve(String className) throws ClassNotFoundException { + return Class.forName(className); + } + })); + + pipeline.addLast(new NettyClientHandler()); + } +} diff --git a/version1/src/main/java/part2/Client/proxy/ClientProxy.java b/version1/src/main/java/part2/Client/proxy/ClientProxy.java new file mode 100644 index 0000000..a6b5a4e --- /dev/null +++ b/version1/src/main/java/part2/Client/proxy/ClientProxy.java @@ -0,0 +1,53 @@ +package part2.Client.proxy; + + +import lombok.AllArgsConstructor; +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; +import part2.Client.IOClient; +import part2.Client.rpcClient.RpcClient; +import part2.Client.rpcClient.impl.NettyRpcClient; +import part2.Client.rpcClient.impl.SimpleSocketRpcCilent; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 16:49 + */ +public class ClientProxy implements InvocationHandler { + //传入参数service接口的class对象，反射封装成一个request + + private RpcClient rpcClient; + public ClientProxy(String host,int port,int choose){ + switch (choose){ + case 0: + rpcClient=new NettyRpcClient(host,port); + break; + case 1: + rpcClient=new SimpleSocketRpcCilent(host,port); + } + } + public ClientProxy(String host,int port){ + rpcClient=new NettyRpcClient(host,port); + } + //jdk动态代理，每一次代理对象调用方法，都会经过此方法增强（反射获取request对象，socket发送到服务端） + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + //构建request + RpcRequest request=RpcRequest.builder() + .interfaceName(method.getDeclaringClass().getName()) + .methodName(method.getName()) + .params(args).paramsType(method.getParameterTypes()).build(); + //数据传输 + RpcResponse response= rpcClient.sendRequest(request); + return response.getData(); + } + public T getProxy(Class clazz){ + Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this); + return (T)o; + } +} diff --git a/version1/src/main/java/part2/Client/rpcClient/RpcClient.java b/version1/src/main/java/part2/Client/rpcClient/RpcClient.java new file mode 100644 index 0000000..21690b1 --- /dev/null +++ b/version1/src/main/java/part2/Client/rpcClient/RpcClient.java @@ -0,0 +1,15 @@ +package part2.Client.rpcClient; + +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 18:55 + */ +public interface RpcClient { + + //定义底层通信的方法 + RpcResponse sendRequest(RpcRequest request); +} diff --git a/version1/src/main/java/part2/Client/rpcClient/impl/NettyRpcClient.java b/version1/src/main/java/part2/Client/rpcClient/impl/NettyRpcClient.java new file mode 100644 index 0000000..b3dab27 --- /dev/null +++ b/version1/src/main/java/part2/Client/rpcClient/impl/NettyRpcClient.java @@ -0,0 +1,62 @@ +package part2.Client.rpcClient.impl; + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.Channel; +import io.netty.channel.ChannelFuture; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.util.AttributeKey; +import part2.Client.netty.nettyInitializer.NettyClientInitializer; +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; +import part2.Client.rpcClient.RpcClient; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 19:40 + */ +public class NettyRpcClient implements RpcClient { + private String host; + private int port; + private static final Bootstrap bootstrap; + private static final EventLoopGroup eventLoopGroup; + public NettyRpcClient(String host,int port){ + this.host=host; + this.port=port; + } + //netty客户端初始化 + static { + eventLoopGroup = new NioEventLoopGroup(); + bootstrap = new Bootstrap(); + bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class) + //NettyClientInitializer这里 配置netty对消息的处理机制 + .handler(new NettyClientInitializer()); + } + @Override + public RpcResponse sendRequest(RpcRequest request) { + try { + //创建一个channelFuture对象，代表这一个操作事件，sync方法表示堵塞直到connect完成 + ChannelFuture channelFuture = bootstrap.connect(host, port).sync(); + //channel表示一个连接的单位，类似socket + Channel channel = channelFuture.channel(); + // 发送数据 + channel.writeAndFlush(request); + //sync()堵塞获取结果 + channel.closeFuture().sync(); + // 阻塞的获得结果，通过给channel设计别名，获取特定名字下的channel中的内容（这个在hanlder中设置） + // AttributeKey是，线程隔离的，不会由线程安全问题。 + // 当前场景下选择堵塞获取结果 + // 其它场景也可以选择添加监听器的方式来异步获取结果 channelFuture.addListener... + AttributeKey key = AttributeKey.valueOf("RPCResponse"); + RpcResponse response = channel.attr(key).get(); + + System.out.println(response); + return response; + } catch (InterruptedException e) { + e.printStackTrace(); + } + return null; + } +} diff --git a/version1/src/main/java/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.java b/version1/src/main/java/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.java new file mode 100644 index 0000000..7e9f09c --- /dev/null +++ b/version1/src/main/java/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.java @@ -0,0 +1,41 @@ +package part2.Client.rpcClient.impl; + +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; +import part2.Client.rpcClient.RpcClient; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 18:58 + */ +public class SimpleSocketRpcCilent implements RpcClient { + private String host; + private int port; + public SimpleSocketRpcCilent(String host,int port){ + this.host=host; + this.port=port; + } + @Override + public RpcResponse sendRequest(RpcRequest request) { + try { + Socket socket=new Socket(host, port); + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + + oos.writeObject(request); + oos.flush(); + + RpcResponse response=(RpcResponse) ois.readObject(); + return response; + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/version1/src/main/java/part2/Server/TestServer.java b/version1/src/main/java/part2/Server/TestServer.java new file mode 100644 index 0000000..a055f3e --- /dev/null +++ b/version1/src/main/java/part2/Server/TestServer.java @@ -0,0 +1,26 @@ +package part2.Server; + + +import part2.Server.server.impl.NettyRPCRPCServer; +import part2.common.service.Impl.UserServiceImpl; +import part2.common.service.UserService; +import part2.Server.provider.ServiceProvider; +import part2.Server.server.RpcServer; +import part2.Server.server.impl.SimpleRPCRPCServer; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/11 19:39 + */ +public class TestServer { + public static void main(String[] args) { + UserService userService=new UserServiceImpl(); + + ServiceProvider serviceProvider=new ServiceProvider(); + serviceProvider.provideServiceInterface(userService); + + RpcServer rpcServer=new NettyRPCRPCServer(serviceProvider); + rpcServer.start(9999); + } +} diff --git a/version1/src/main/java/part2/Server/netty/handler/NettyRPCServerHandler.java b/version1/src/main/java/part2/Server/netty/handler/NettyRPCServerHandler.java new file mode 100644 index 0000000..14948cc --- /dev/null +++ b/version1/src/main/java/part2/Server/netty/handler/NettyRPCServerHandler.java @@ -0,0 +1,52 @@ +package part2.Server.netty.handler; + +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import lombok.AllArgsConstructor; +import part2.Server.provider.ServiceProvider; +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 16:40 + * 因为是服务器端，我们知道接受到请求格式是RPCRequest + * Object类型也行，强制转型就行 + */ +@AllArgsConstructor +public class NettyRPCServerHandler extends SimpleChannelInboundHandler { + private ServiceProvider serviceProvider; + @Override + protected void channelRead0(ChannelHandlerContext ctx, RpcRequest request) throws Exception { + //接收request，读取并调用服务 + RpcResponse response = getResponse(request); + ctx.writeAndFlush(response); + ctx.close(); + } + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + cause.printStackTrace(); + ctx.close(); + } + private RpcResponse getResponse(RpcRequest rpcRequest){ + //得到服务名 + String interfaceName=rpcRequest.getInterfaceName(); + //得到服务端相应服务实现类 + Object service = serviceProvider.getService(interfaceName); + //反射调用方法 + Method method=null; + try { + method= service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType()); + Object invoke=method.invoke(service,rpcRequest.getParams()); + return RpcResponse.sussess(invoke); + } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + System.out.println("方法执行错误"); + return RpcResponse.fail(); + } + } +} diff --git a/version1/src/main/java/part2/Server/netty/nettyInitializer/NettyServerInitializer.java b/version1/src/main/java/part2/Server/netty/nettyInitializer/NettyServerInitializer.java new file mode 100644 index 0000000..254b04c --- /dev/null +++ b/version1/src/main/java/part2/Server/netty/nettyInitializer/NettyServerInitializer.java @@ -0,0 +1,46 @@ +package part2.Server.netty.nettyInitializer; + + +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.codec.LengthFieldBasedFrameDecoder; +import io.netty.handler.codec.LengthFieldPrepender; +import io.netty.handler.codec.serialization.ClassResolver; +import io.netty.handler.codec.serialization.ObjectDecoder; +import io.netty.handler.codec.serialization.ObjectEncoder; +import lombok.AllArgsConstructor; +import part2.Server.netty.handler.NettyRPCServerHandler; +import part2.Server.provider.ServiceProvider; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 16:15 + */ +@AllArgsConstructor +public class NettyServerInitializer extends ChannelInitializer { + private ServiceProvider serviceProvider; + @Override + protected void initChannel(SocketChannel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + //消息格式 【长度】【消息体】，解决沾包问题 + pipeline.addLast( + new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4)); + //计算当前待发送消息的长度，写入到前4个字节中 + pipeline.addLast(new LengthFieldPrepender(4)); + + //使用Java序列化方式，netty的自带的解码编码支持传输这种结构 + pipeline.addLast(new ObjectEncoder()); + //使用了Netty中的ObjectDecoder，它用于将字节流解码为 Java 对象。 + //在ObjectDecoder的构造函数中传入了一个ClassResolver 对象，用于解析类名并加载相应的类。 + pipeline.addLast(new ObjectDecoder(new ClassResolver() { + @Override + public Class resolve(String className) throws ClassNotFoundException { + return Class.forName(className); + } + })); + + pipeline.addLast(new NettyRPCServerHandler(serviceProvider)); + } +} diff --git a/version1/src/main/java/part2/Server/provider/ServiceProvider.java b/version1/src/main/java/part2/Server/provider/ServiceProvider.java new file mode 100644 index 0000000..5cee41f --- /dev/null +++ b/version1/src/main/java/part2/Server/provider/ServiceProvider.java @@ -0,0 +1,32 @@ +package part2.Server.provider; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/16 17:35 + */ +public class ServiceProvider { + private Map interfaceProvider; + + public ServiceProvider(){ + this.interfaceProvider=new HashMap<>(); + } + + public void provideServiceInterface(Object service){ + String serviceName=service.getClass().getName(); + Class[] interfaceName=service.getClass().getInterfaces(); + + for (Class clazz:interfaceName){ + interfaceProvider.put(clazz.getName(),service); + } + + } + + public Object getService(String interfaceName){ + return interfaceProvider.get(interfaceName); + } + +} diff --git a/version1/src/main/java/part2/Server/server/RpcServer.java b/version1/src/main/java/part2/Server/server/RpcServer.java new file mode 100644 index 0000000..6abbf2a --- /dev/null +++ b/version1/src/main/java/part2/Server/server/RpcServer.java @@ -0,0 +1,11 @@ +package part2.Server.server; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:26 + */ +public interface RpcServer { + void start(int port); + void stop(); +} diff --git a/version1/src/main/java/part2/Server/server/impl/NettyRPCRPCServer.java b/version1/src/main/java/part2/Server/server/impl/NettyRPCRPCServer.java new file mode 100644 index 0000000..97632a6 --- /dev/null +++ b/version1/src/main/java/part2/Server/server/impl/NettyRPCRPCServer.java @@ -0,0 +1,49 @@ +package part2.Server.server.impl; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.ChannelFuture; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import lombok.AllArgsConstructor; +import part2.Server.netty.nettyInitializer.NettyServerInitializer; +import part2.Server.provider.ServiceProvider; +import part2.Server.server.RpcServer; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 14:01 + */ +@AllArgsConstructor +public class NettyRPCRPCServer implements RpcServer { + private ServiceProvider serviceProvider; + @Override + public void start(int port) { + // netty 服务线程组boss负责建立连接， work负责具体的请求 + NioEventLoopGroup bossGroup = new NioEventLoopGroup(); + NioEventLoopGroup workGroup = new NioEventLoopGroup(); + System.out.println("netty服务端启动了"); + try { + //启动netty服务器 + ServerBootstrap serverBootstrap = new ServerBootstrap(); + //初始化 + serverBootstrap.group(bossGroup,workGroup).channel(NioServerSocketChannel.class) + //NettyClientInitializer这里 配置netty对消息的处理机制 + .childHandler(new NettyServerInitializer(serviceProvider)); + //同步堵塞 + ChannelFuture channelFuture=serverBootstrap.bind(port).sync(); + //死循环监听 + channelFuture.channel().closeFuture().sync(); + }catch (InterruptedException e){ + e.printStackTrace(); + }finally { + bossGroup.shutdownGracefully(); + workGroup.shutdownGracefully(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part2/Server/server/impl/SimpleRPCRPCServer.java b/version1/src/main/java/part2/Server/server/impl/SimpleRPCRPCServer.java new file mode 100644 index 0000000..8033bab --- /dev/null +++ b/version1/src/main/java/part2/Server/server/impl/SimpleRPCRPCServer.java @@ -0,0 +1,39 @@ +package part2.Server.server.impl; + + +import lombok.AllArgsConstructor; +import part2.Server.provider.ServiceProvider; +import part2.Server.server.RpcServer; +import part2.Server.server.work.WorkThread; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:37 + */ +@AllArgsConstructor +public class SimpleRPCRPCServer implements RpcServer { + private ServiceProvider serviceProvide; + @Override + public void start(int port) { + try { + ServerSocket serverSocket=new ServerSocket(port); + System.out.println("服务器启动了"); + while (true) { + Socket socket = serverSocket.accept(); + new Thread(new WorkThread(socket,serviceProvide)).start(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part2/Server/server/impl/ThreadPoolRPCRPCServer.java b/version1/src/main/java/part2/Server/server/impl/ThreadPoolRPCRPCServer.java new file mode 100644 index 0000000..834c9a5 --- /dev/null +++ b/version1/src/main/java/part2/Server/server/impl/ThreadPoolRPCRPCServer.java @@ -0,0 +1,58 @@ +package part2.Server.server.impl; + + +import part2.Server.provider.ServiceProvider; +import part2.Server.server.RpcServer; +import part2.Server.server.work.WorkThread; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/19 15:30 + */ +public class ThreadPoolRPCRPCServer implements RpcServer { + private final ThreadPoolExecutor threadPool; + private ServiceProvider serviceProvider; + + public ThreadPoolRPCRPCServer(ServiceProvider serviceProvider){ + threadPool=new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), + 1000,60, TimeUnit.SECONDS,new ArrayBlockingQueue<>(100)); + this.serviceProvider= serviceProvider; + } + public ThreadPoolRPCRPCServer(ServiceProvider serviceProvider, int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue workQueue){ + + threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); + this.serviceProvider = serviceProvider; + } + + @Override + public void start(int port) { + System.out.println("服务端启动了"); + try { + ServerSocket serverSocket=new ServerSocket(); + while (true){ + Socket socket= serverSocket.accept(); + threadPool.execute(new WorkThread(socket,serviceProvider)); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part2/Server/server/work/WorkThread.java b/version1/src/main/java/part2/Server/server/work/WorkThread.java new file mode 100644 index 0000000..a3985bf --- /dev/null +++ b/version1/src/main/java/part2/Server/server/work/WorkThread.java @@ -0,0 +1,58 @@ +package part2.Server.server.work; + + +import lombok.AllArgsConstructor; +import part2.Server.provider.ServiceProvider; +import part2.common.Message.RpcRequest; +import part2.common.Message.RpcResponse; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/14 17:39 + */ +@AllArgsConstructor +public class WorkThread implements Runnable{ + private Socket socket; + private ServiceProvider serviceProvide; + @Override + public void run() { + try { + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + //读取客户端传过来的request + RpcRequest rpcRequest = (RpcRequest) ois.readObject(); + //反射调用服务方法获取返回值 + RpcResponse rpcResponse=getResponse(rpcRequest); + //向客户端写入response + oos.writeObject(rpcResponse); + oos.flush(); + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + private RpcResponse getResponse(RpcRequest rpcRequest){ + //得到服务名 + String interfaceName=rpcRequest.getInterfaceName(); + //得到服务端相应服务实现类 + Object service = serviceProvide.getService(interfaceName); + //反射调用方法 + Method method=null; + try { + method= service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType()); + Object invoke=method.invoke(service,rpcRequest.getParams()); + return RpcResponse.sussess(invoke); + } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + System.out.println("方法执行错误"); + return RpcResponse.fail(); + } + } +} diff --git a/version1/src/main/java/part2/common/Message/RpcRequest.java b/version1/src/main/java/part2/common/Message/RpcRequest.java new file mode 100644 index 0000000..f6f398d --- /dev/null +++ b/version1/src/main/java/part2/common/Message/RpcRequest.java @@ -0,0 +1,25 @@ +package part2.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 18:30 + * 定义发送的消息格式 + */ +@Data +@Builder +public class RpcRequest implements Serializable { + //服务类名，客户端只知道接口 + private String interfaceName; + //调用的方法名 + private String methodName; + //参数列表 + private Object[] params; + //参数类型 + private Class[] paramsType; +} diff --git a/version1/src/main/java/part2/common/Message/RpcResponse.java b/version1/src/main/java/part2/common/Message/RpcResponse.java new file mode 100644 index 0000000..a681df8 --- /dev/null +++ b/version1/src/main/java/part2/common/Message/RpcResponse.java @@ -0,0 +1,29 @@ +package part2.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 19:18 + */ +@Data +@Builder +public class RpcResponse implements Serializable { + //状态信息 + private int code; + private String message; + //具体数据 + private Object data; + + public static RpcResponse sussess(Object data){ + return RpcResponse.builder().code(200).data(data).build(); + } + public static RpcResponse fail(){ + return RpcResponse.builder().code(500).message("服务器发生错误").build(); + } +} + diff --git a/version1/src/main/java/part2/common/pojo/User.java b/version1/src/main/java/part2/common/pojo/User.java new file mode 100644 index 0000000..bf999d7 --- /dev/null +++ b/version1/src/main/java/part2/common/pojo/User.java @@ -0,0 +1,25 @@ +package part2.common.pojo; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 17:50 + */ +@Builder +@Data +@NoArgsConstructor +@AllArgsConstructor +public class User implements Serializable { + // 客户端和服务端共有的 + private Integer id; + private String userName; + private Boolean sex; +} + diff --git a/version1/src/main/java/part2/common/service/Impl/UserServiceImpl.java b/version1/src/main/java/part2/common/service/Impl/UserServiceImpl.java new file mode 100644 index 0000000..37e6262 --- /dev/null +++ b/version1/src/main/java/part2/common/service/Impl/UserServiceImpl.java @@ -0,0 +1,32 @@ +package part2.common.service.Impl; + + +import part2.common.pojo.User; +import part2.common.service.UserService; + +import java.util.Random; +import java.util.UUID; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:28 + */ +public class UserServiceImpl implements UserService { + @Override + public User getUserByUserId(Integer id) { + System.out.println("客户端查询了"+id+"的用户"); + // 模拟从数据库中取用户的行为 + Random random = new Random(); + User user = User.builder().userName(UUID.randomUUID().toString()) + .id(id) + .sex(random.nextBoolean()).build(); + return user; + } + + @Override + public Integer insertUserId(User user) { + System.out.println("插入数据成功"+user.getUserName()); + return user.getId(); + } +} \ No newline at end of file diff --git a/version1/src/main/java/part2/common/service/UserService.java b/version1/src/main/java/part2/common/service/UserService.java new file mode 100644 index 0000000..b6817fe --- /dev/null +++ b/version1/src/main/java/part2/common/service/UserService.java @@ -0,0 +1,16 @@ +package part2.common.service; + + +import part2.common.pojo.User; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:27 + */ +public interface UserService { + // 客户端通过这个接口调用服务端的实现类 + User getUserByUserId(Integer id); + //新增一个功能 + Integer insertUserId(User user); +} diff --git a/version1/src/main/java/part3/Client/TestClient.java b/version1/src/main/java/part3/Client/TestClient.java new file mode 100644 index 0000000..112bcc3 --- /dev/null +++ b/version1/src/main/java/part3/Client/TestClient.java @@ -0,0 +1,27 @@ +package part3.Client; + + +import part3.common.pojo.User; +import part3.common.service.UserService; +import part3.Client.proxy.ClientProxy; + + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 18:39 + */ +public class TestClient { + public static void main(String[] args) { + ClientProxy clientProxy=new ClientProxy(); + //ClientProxy clientProxy=new part2.Client.proxy.ClientProxy("127.0.0.1",9999,0); + UserService proxy=clientProxy.getProxy(UserService.class); + + User user = proxy.getUserByUserId(1); + System.out.println("从服务端得到的user="+user.toString()); + + User u=User.builder().id(100).userName("wxx").sex(true).build(); + Integer id = proxy.insertUserId(u); + System.out.println("向服务端插入user的id"+id); + } +} diff --git a/version1/src/main/java/part3/Client/netty/handler/NettyClientHandler.java b/version1/src/main/java/part3/Client/netty/handler/NettyClientHandler.java new file mode 100644 index 0000000..28f173e --- /dev/null +++ b/version1/src/main/java/part3/Client/netty/handler/NettyClientHandler.java @@ -0,0 +1,27 @@ +package part3.Client.netty.handler; + +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.util.AttributeKey; +import part3.common.Message.RpcResponse; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 17:29 + */ +public class NettyClientHandler extends SimpleChannelInboundHandler { + @Override + protected void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception { + // 接收到response, 给channel设计别名，让sendRequest里读取response + AttributeKey key = AttributeKey.valueOf("RPCResponse"); + ctx.channel().attr(key).set(response); + ctx.channel().close(); + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + cause.printStackTrace(); + ctx.close(); + } +} diff --git a/version1/src/main/java/part3/Client/netty/nettyInitializer/NettyClientInitializer.java b/version1/src/main/java/part3/Client/netty/nettyInitializer/NettyClientInitializer.java new file mode 100644 index 0000000..bca4a4c --- /dev/null +++ b/version1/src/main/java/part3/Client/netty/nettyInitializer/NettyClientInitializer.java @@ -0,0 +1,42 @@ +package part3.Client.netty.nettyInitializer; + + +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.codec.LengthFieldBasedFrameDecoder; +import io.netty.handler.codec.LengthFieldPrepender; +import io.netty.handler.codec.serialization.ClassResolver; +import io.netty.handler.codec.serialization.ObjectDecoder; +import io.netty.handler.codec.serialization.ObjectEncoder; +import part3.Client.netty.handler.NettyClientHandler; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 17:26 + */ +public class NettyClientInitializer extends ChannelInitializer { + @Override + protected void initChannel(SocketChannel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + //消息格式 【长度】【消息体】，解决沾包问题 + pipeline.addLast( + new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4)); + //计算当前待发送消息的长度，写入到前4个字节中 + pipeline.addLast(new LengthFieldPrepender(4)); + + //使用Java序列化方式，netty的自带的解码编码支持传输这种结构 + pipeline.addLast(new ObjectEncoder()); + //使用了Netty中的ObjectDecoder，它用于将字节流解码为 Java 对象。 + //在ObjectDecoder的构造函数中传入了一个ClassResolver 对象，用于解析类名并加载相应的类。 + pipeline.addLast(new ObjectDecoder(new ClassResolver() { + @Override + public Class resolve(String className) throws ClassNotFoundException { + return Class.forName(className); + } + })); + + pipeline.addLast(new NettyClientHandler()); + } +} diff --git a/version1/src/main/java/part3/Client/proxy/ClientProxy.java b/version1/src/main/java/part3/Client/proxy/ClientProxy.java new file mode 100644 index 0000000..8cb957e --- /dev/null +++ b/version1/src/main/java/part3/Client/proxy/ClientProxy.java @@ -0,0 +1,43 @@ +package part3.Client.proxy; + + +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; +import part3.Client.rpcClient.RpcClient; +import part3.Client.rpcClient.impl.NettyRpcClient; +import part3.Client.rpcClient.impl.SimpleSocketRpcCilent; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/6 16:49 + */ +public class ClientProxy implements InvocationHandler { + //传入参数service接口的class对象，反射封装成一个request + + private RpcClient rpcClient; + public ClientProxy(){ + rpcClient=new NettyRpcClient(); + } + + //jdk动态代理，每一次代理对象调用方法，都会经过此方法增强（反射获取request对象，socket发送到服务端） + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + //构建request + RpcRequest request=RpcRequest.builder() + .interfaceName(method.getDeclaringClass().getName()) + .methodName(method.getName()) + .params(args).paramsType(method.getParameterTypes()).build(); + //数据传输 + RpcResponse response= rpcClient.sendRequest(request); + return response.getData(); + } + public T getProxy(Class clazz){ + Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this); + return (T)o; + } +} diff --git a/version1/src/main/java/part3/Client/rpcClient/RpcClient.java b/version1/src/main/java/part3/Client/rpcClient/RpcClient.java new file mode 100644 index 0000000..44b702b --- /dev/null +++ b/version1/src/main/java/part3/Client/rpcClient/RpcClient.java @@ -0,0 +1,15 @@ +package part3.Client.rpcClient; + +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 18:55 + */ +public interface RpcClient { + + //定义底层通信的方法 + RpcResponse sendRequest(RpcRequest request); +} diff --git a/version1/src/main/java/part3/Client/rpcClient/impl/NettyRpcClient.java b/version1/src/main/java/part3/Client/rpcClient/impl/NettyRpcClient.java new file mode 100644 index 0000000..a4fc493 --- /dev/null +++ b/version1/src/main/java/part3/Client/rpcClient/impl/NettyRpcClient.java @@ -0,0 +1,68 @@ +package part3.Client.rpcClient.impl; + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.Channel; +import io.netty.channel.ChannelFuture; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.util.AttributeKey; +import part3.Client.serviceCenter.ServiceCenter; +import part3.Client.serviceCenter.ZKServiceCenter; +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; +import part3.Client.netty.nettyInitializer.NettyClientInitializer; +import part3.Client.rpcClient.RpcClient; + +import java.net.InetSocketAddress; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 19:40 + */ +public class NettyRpcClient implements RpcClient { + + private static final Bootstrap bootstrap; + private static final EventLoopGroup eventLoopGroup; + + private ServiceCenter serviceCenter; + public NettyRpcClient(){ + this.serviceCenter=new ZKServiceCenter(); + } + + //netty客户端初始化 + static { + eventLoopGroup = new NioEventLoopGroup(); + bootstrap = new Bootstrap(); + bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class) + .handler(new NettyClientInitializer()); + } + @Override + public RpcResponse sendRequest(RpcRequest request) { + //从注册中心获取host,post + InetSocketAddress address = serviceCenter.serviceDiscovery(request.getInterfaceName()); + String host = address.getHostName(); + int port = address.getPort(); + try { + ChannelFuture channelFuture = bootstrap.connect(host, port).sync(); + Channel channel = channelFuture.channel(); + // 发送数据 + channel.writeAndFlush(request); + //sync()堵塞获取结果 + channel.closeFuture().sync(); + // 阻塞的获得结果，通过给channel设计别名，获取特定名字下的channel中的内容（这个在hanlder中设置） + // AttributeKey是，线程隔离的，不会由线程安全问题。 + // 当前场景下选择堵塞获取结果 + // 其它场景也可以选择添加监听器的方式来异步获取结果 channelFuture.addListener... + AttributeKey key = AttributeKey.valueOf("RPCResponse"); + RpcResponse response = channel.attr(key).get(); + + System.out.println(response); + return response; + } catch (InterruptedException e) { + e.printStackTrace(); + } + return null; + } +} diff --git a/version1/src/main/java/part3/Client/rpcClient/impl/SimpleSocketRpcCilent.java b/version1/src/main/java/part3/Client/rpcClient/impl/SimpleSocketRpcCilent.java new file mode 100644 index 0000000..b2f6af3 --- /dev/null +++ b/version1/src/main/java/part3/Client/rpcClient/impl/SimpleSocketRpcCilent.java @@ -0,0 +1,41 @@ +package part3.Client.rpcClient.impl; + +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; +import part3.Client.rpcClient.RpcClient; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/2 18:58 + */ +public class SimpleSocketRpcCilent implements RpcClient { + private String host; + private int port; + public SimpleSocketRpcCilent(String host,int port){ + this.host=host; + this.port=port; + } + @Override + public RpcResponse sendRequest(RpcRequest request) { + try { + Socket socket=new Socket(host, port); + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + + oos.writeObject(request); + oos.flush(); + + RpcResponse response=(RpcResponse) ois.readObject(); + return response; + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/version1/src/main/java/part3/Client/serviceCenter/ServiceCenter.java b/version1/src/main/java/part3/Client/serviceCenter/ServiceCenter.java new file mode 100644 index 0000000..1b2c02e --- /dev/null +++ b/version1/src/main/java/part3/Client/serviceCenter/ServiceCenter.java @@ -0,0 +1,14 @@ +package part3.Client.serviceCenter; + +import java.net.InetSocketAddress; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/3 21:42 + */ +//服务中心接口 +public interface ServiceCenter { + // 查询：根据服务名查找地址 + InetSocketAddress serviceDiscovery(String serviceName); +} diff --git a/version1/src/main/java/part3/Client/serviceCenter/ZKServiceCenter.java b/version1/src/main/java/part3/Client/serviceCenter/ZKServiceCenter.java new file mode 100644 index 0000000..a23ff1c --- /dev/null +++ b/version1/src/main/java/part3/Client/serviceCenter/ZKServiceCenter.java @@ -0,0 +1,59 @@ +package part3.Client.serviceCenter; + +import org.apache.curator.RetryPolicy; +import org.apache.curator.framework.CuratorFramework; +import org.apache.curator.framework.CuratorFrameworkFactory; +import org.apache.curator.retry.ExponentialBackoffRetry; + +import java.net.InetSocketAddress; +import java.util.List; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/3 21:41 + */ +public class ZKServiceCenter implements ServiceCenter{ + // curator 提供的zookeeper客户端 + private CuratorFramework client; + //zookeeper根路径节点 + private static final String ROOT_PATH = "MyRPC"; + + //负责zookeeper客户端的初始化，并与zookeeper服务端进行连接 + public ZKServiceCenter(){ + // 指数时间重试 + RetryPolicy policy = new ExponentialBackoffRetry(1000, 3); + // zookeeper的地址固定，不管是服务提供者还是，消费者都要与之建立连接 + // sessionTimeoutMs 与 zoo.cfg中的tickTime 有关系， + // zk还会根据minSessionTimeout与maxSessionTimeout两个参数重新调整最后的超时值。默认分别为tickTime 的2倍和20倍 + // 使用心跳监听状态 + this.client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181") + .sessionTimeoutMs(40000).retryPolicy(policy).namespace(ROOT_PATH).build(); + this.client.start(); + System.out.println("zookeeper 连接成功"); + } + //根据服务名（接口名）返回地址 + @Override + public InetSocketAddress serviceDiscovery(String serviceName) { + try { + List strings = client.getChildren().forPath("/" + serviceName); + // 这里默认用的第一个，后面加负载均衡 + String string = strings.get(0); + return parseAddress(string); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + // 地址 -> XXX.XXX.XXX.XXX:port 字符串 + private String getServiceAddress(InetSocketAddress serverAddress) { + return serverAddress.getHostName() + + ":" + + serverAddress.getPort(); + } + // 字符串解析为地址 + private InetSocketAddress parseAddress(String address) { + String[] result = address.split(":"); + return new InetSocketAddress(result[0], Integer.parseInt(result[1])); + } +} diff --git a/version1/src/main/java/part3/Server/TestServer.java b/version1/src/main/java/part3/Server/TestServer.java new file mode 100644 index 0000000..63a8ef4 --- /dev/null +++ b/version1/src/main/java/part3/Server/TestServer.java @@ -0,0 +1,26 @@ +package part3.Server; + + +import part3.Server.server.impl.NettyRPCRPCServer; +import part3.common.service.Impl.UserServiceImpl; +import part3.common.service.UserService; +import part3.Server.provider.ServiceProvider; +import part3.Server.server.RpcServer; +import part3.Server.server.impl.SimpleRPCRPCServer; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/11 19:39 + */ +public class TestServer { + public static void main(String[] args) { + UserService userService=new UserServiceImpl(); + + ServiceProvider serviceProvider=new ServiceProvider("127.0.0.1",9999); + serviceProvider.provideServiceInterface(userService); + + RpcServer rpcServer=new NettyRPCRPCServer(serviceProvider); + rpcServer.start(9999); + } +} diff --git a/version1/src/main/java/part3/Server/netty/handler/NettyRPCServerHandler.java b/version1/src/main/java/part3/Server/netty/handler/NettyRPCServerHandler.java new file mode 100644 index 0000000..aea757f --- /dev/null +++ b/version1/src/main/java/part3/Server/netty/handler/NettyRPCServerHandler.java @@ -0,0 +1,51 @@ +package part3.Server.netty.handler; + +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import lombok.AllArgsConstructor; +import part3.Server.provider.ServiceProvider; +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 16:40 + * 因为是服务器端，我们知道接受到请求格式是RPCRequest + * Object类型也行，强制转型就行 + */ +@AllArgsConstructor +public class NettyRPCServerHandler extends SimpleChannelInboundHandler { + private ServiceProvider serviceProvider; + @Override + protected void channelRead0(ChannelHandlerContext ctx, RpcRequest request) throws Exception { + RpcResponse response = getResponse(request); + ctx.writeAndFlush(response); + ctx.close(); + } + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + cause.printStackTrace(); + ctx.close(); + } + private RpcResponse getResponse(RpcRequest rpcRequest){ + //得到服务名 + String interfaceName=rpcRequest.getInterfaceName(); + //得到服务端相应服务实现类 + Object service = serviceProvider.getService(interfaceName); + //反射调用方法 + Method method=null; + try { + method= service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType()); + Object invoke=method.invoke(service,rpcRequest.getParams()); + return RpcResponse.sussess(invoke); + } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + System.out.println("方法执行错误"); + return RpcResponse.fail(); + } + } +} diff --git a/version1/src/main/java/part3/Server/netty/nettyInitializer/NettyServerInitializer.java b/version1/src/main/java/part3/Server/netty/nettyInitializer/NettyServerInitializer.java new file mode 100644 index 0000000..aff1fdb --- /dev/null +++ b/version1/src/main/java/part3/Server/netty/nettyInitializer/NettyServerInitializer.java @@ -0,0 +1,46 @@ +package part3.Server.netty.nettyInitializer; + + +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.codec.LengthFieldBasedFrameDecoder; +import io.netty.handler.codec.LengthFieldPrepender; +import io.netty.handler.codec.serialization.ClassResolver; +import io.netty.handler.codec.serialization.ObjectDecoder; +import io.netty.handler.codec.serialization.ObjectEncoder; +import lombok.AllArgsConstructor; +import part3.Server.provider.ServiceProvider; +import part3.Server.netty.handler.NettyRPCServerHandler; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 16:15 + */ +@AllArgsConstructor +public class NettyServerInitializer extends ChannelInitializer { + private ServiceProvider serviceProvider; + @Override + protected void initChannel(SocketChannel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + //消息格式 【长度】【消息体】，解决沾包问题 + pipeline.addLast( + new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4)); + //计算当前待发送消息的长度，写入到前4个字节中 + pipeline.addLast(new LengthFieldPrepender(4)); + + //使用Java序列化方式，netty的自带的解码编码支持传输这种结构 + pipeline.addLast(new ObjectEncoder()); + //使用了Netty中的ObjectDecoder，它用于将字节流解码为 Java 对象。 + //在ObjectDecoder的构造函数中传入了一个ClassResolver 对象，用于解析类名并加载相应的类。 + pipeline.addLast(new ObjectDecoder(new ClassResolver() { + @Override + public Class resolve(String className) throws ClassNotFoundException { + return Class.forName(className); + } + })); + + pipeline.addLast(new NettyRPCServerHandler(serviceProvider)); + } +} diff --git a/version1/src/main/java/part3/Server/provider/ServiceProvider.java b/version1/src/main/java/part3/Server/provider/ServiceProvider.java new file mode 100644 index 0000000..fa39e0a --- /dev/null +++ b/version1/src/main/java/part3/Server/provider/ServiceProvider.java @@ -0,0 +1,47 @@ +package part3.Server.provider; + +import part3.Server.serviceRegister.ServiceRegister; +import part3.Server.serviceRegister.impl.ZKServiceRegister; + +import java.net.InetSocketAddress; +import java.util.HashMap; +import java.util.Map; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/16 17:35 + */ +public class ServiceProvider { + private Map interfaceProvider; + + private int port; + private String host; + //注册服务类 + private ServiceRegister serviceRegister; + + public ServiceProvider(String host,int port){ + //需要传入服务端自身的网络地址 + this.host=host; + this.port=port; + this.interfaceProvider=new HashMap<>(); + this.serviceRegister=new ZKServiceRegister(); + } + + public void provideServiceInterface(Object service){ + String serviceName=service.getClass().getName(); + Class[] interfaceName=service.getClass().getInterfaces(); + + for (Class clazz:interfaceName){ + //本机的映射表 + interfaceProvider.put(clazz.getName(),service); + //在注册中心注册服务 + serviceRegister.register(clazz.getName(),new InetSocketAddress(host,port)); + } + } + + public Object getService(String interfaceName){ + return interfaceProvider.get(interfaceName); + } + +} diff --git a/version1/src/main/java/part3/Server/server/RpcServer.java b/version1/src/main/java/part3/Server/server/RpcServer.java new file mode 100644 index 0000000..d0a0fa5 --- /dev/null +++ b/version1/src/main/java/part3/Server/server/RpcServer.java @@ -0,0 +1,11 @@ +package part3.Server.server; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:26 + */ +public interface RpcServer { + void start(int port); + void stop(); +} diff --git a/version1/src/main/java/part3/Server/server/impl/NettyRPCRPCServer.java b/version1/src/main/java/part3/Server/server/impl/NettyRPCRPCServer.java new file mode 100644 index 0000000..2e4a34b --- /dev/null +++ b/version1/src/main/java/part3/Server/server/impl/NettyRPCRPCServer.java @@ -0,0 +1,48 @@ +package part3.Server.server.impl; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.ChannelFuture; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import lombok.AllArgsConstructor; +import part3.Server.netty.nettyInitializer.NettyServerInitializer; +import part3.Server.provider.ServiceProvider; +import part3.Server.server.RpcServer; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/26 14:01 + */ +@AllArgsConstructor +public class NettyRPCRPCServer implements RpcServer { + private ServiceProvider serviceProvider; + @Override + public void start(int port) { + // netty 服务线程组boss负责建立连接， work负责具体的请求 + NioEventLoopGroup bossGroup = new NioEventLoopGroup(); + NioEventLoopGroup workGroup = new NioEventLoopGroup(); + System.out.println("netty服务端启动了"); + try { + //启动netty服务器 + ServerBootstrap serverBootstrap = new ServerBootstrap(); + //初始化 + serverBootstrap.group(bossGroup,workGroup).channel(NioServerSocketChannel.class) + .childHandler(new NettyServerInitializer(serviceProvider)); + //同步堵塞 + ChannelFuture channelFuture=serverBootstrap.bind(port).sync(); + //死循环监听 + channelFuture.channel().closeFuture().sync(); + }catch (InterruptedException e){ + e.printStackTrace(); + }finally { + bossGroup.shutdownGracefully(); + workGroup.shutdownGracefully(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part3/Server/server/impl/SimpleRPCRPCServer.java b/version1/src/main/java/part3/Server/server/impl/SimpleRPCRPCServer.java new file mode 100644 index 0000000..f77262a --- /dev/null +++ b/version1/src/main/java/part3/Server/server/impl/SimpleRPCRPCServer.java @@ -0,0 +1,39 @@ +package part3.Server.server.impl; + + +import lombok.AllArgsConstructor; +import part3.Server.provider.ServiceProvider; +import part3.Server.server.RpcServer; +import part3.Server.server.work.WorkThread; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/12 11:37 + */ +@AllArgsConstructor +public class SimpleRPCRPCServer implements RpcServer { + private ServiceProvider serviceProvide; + @Override + public void start(int port) { + try { + ServerSocket serverSocket=new ServerSocket(port); + System.out.println("服务器启动了"); + while (true) { + Socket socket = serverSocket.accept(); + new Thread(new WorkThread(socket,serviceProvide)).start(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void stop() { + + } +} diff --git a/version1/src/main/java/part3/Server/server/work/WorkThread.java b/version1/src/main/java/part3/Server/server/work/WorkThread.java new file mode 100644 index 0000000..32eb732 --- /dev/null +++ b/version1/src/main/java/part3/Server/server/work/WorkThread.java @@ -0,0 +1,58 @@ +package part3.Server.server.work; + + +import lombok.AllArgsConstructor; +import part3.common.Message.RpcRequest; +import part3.common.Message.RpcResponse; +import part3.Server.provider.ServiceProvider; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.Socket; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/14 17:39 + */ +@AllArgsConstructor +public class WorkThread implements Runnable{ + private Socket socket; + private ServiceProvider serviceProvide; + @Override + public void run() { + try { + ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream()); + ObjectInputStream ois=new ObjectInputStream(socket.getInputStream()); + //读取客户端传过来的request + RpcRequest rpcRequest = (RpcRequest) ois.readObject(); + //反射调用服务方法获取返回值 + RpcResponse rpcResponse=getResponse(rpcRequest); + //向客户端写入response + oos.writeObject(rpcResponse); + oos.flush(); + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + private RpcResponse getResponse(RpcRequest rpcRequest){ + //得到服务名 + String interfaceName=rpcRequest.getInterfaceName(); + //得到服务端相应服务实现类 + Object service = serviceProvide.getService(interfaceName); + //反射调用方法 + Method method=null; + try { + method= service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType()); + Object invoke=method.invoke(service,rpcRequest.getParams()); + return RpcResponse.sussess(invoke); + } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { + e.printStackTrace(); + System.out.println("方法执行错误"); + return RpcResponse.fail(); + } + } +} diff --git a/version1/src/main/java/part3/Server/serviceRegister/ServiceRegister.java b/version1/src/main/java/part3/Server/serviceRegister/ServiceRegister.java new file mode 100644 index 0000000..65c5be3 --- /dev/null +++ b/version1/src/main/java/part3/Server/serviceRegister/ServiceRegister.java @@ -0,0 +1,15 @@ +package part3.Server.serviceRegister; + +import java.net.InetSocketAddress; + +/** + * @author wxx + * @version 1.0 + * @create 2024/5/3 16:58 + */ +// 服务注册接口 +public interface ServiceRegister { + // 注册：保存服务与地址。 + void register(String serviceName, InetSocketAddress serviceAddress); + +} diff --git a/version1/src/main/java/part3/Server/serviceRegister/impl/ZKServiceRegister.java b/version1/src/main/java/part3/Server/serviceRegister/impl/ZKServiceRegister.java new file mode 100644 index 0000000..9fe332a --- /dev/null +++ b/version1/src/main/java/part3/Server/serviceRegister/impl/ZKServiceRegister.java @@ -0,0 +1,62 @@ +package part3.Server.serviceRegister.impl; + +import org.apache.curator.RetryPolicy; +import org.apache.curator.framework.CuratorFramework; +import org.apache.curator.framework.CuratorFrameworkFactory; +import org.apache.curator.retry.ExponentialBackoffRetry; +import org.apache.zookeeper.CreateMode; +import part3.Server.serviceRegister.ServiceRegister; + +import java.net.InetSocketAddress; +/** + * @author wxx + * @version 1.0 + * @create 2024/5/3 17:28 + */ +public class ZKServiceRegister implements ServiceRegister { + // curator 提供的zookeeper客户端 + private CuratorFramework client; + //zookeeper根路径节点 + private static final String ROOT_PATH = "MyRPC"; + + //负责zookeeper客户端的初始化，并与zookeeper服务端进行连接 + public ZKServiceRegister(){ + // 指数时间重试 + RetryPolicy policy = new ExponentialBackoffRetry(1000, 3); + // zookeeper的地址固定，不管是服务提供者还是，消费者都要与之建立连接 + // sessionTimeoutMs 与 zoo.cfg中的tickTime 有关系， + // zk还会根据minSessionTimeout与maxSessionTimeout两个参数重新调整最后的超时值。默认分别为tickTime 的2倍和20倍 + // 使用心跳监听状态 + this.client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181") + .sessionTimeoutMs(40000).retryPolicy(policy).namespace(ROOT_PATH).build(); + this.client.start(); + System.out.println("zookeeper 连接成功"); + } + //注册服务到注册中心 + @Override + public void register(String serviceName, InetSocketAddress serviceAddress) { + try { + // serviceName创建成永久节点，服务提供者下线时，不删服务名，只删地址 + if(client.checkExists().forPath("/" + serviceName) == null){ + client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/" + serviceName); + } + // 路径地址，一个/代表一个节点 + String path = "/" + serviceName +"/"+ getServiceAddress(serviceAddress); + // 临时节点，服务器下线就删除节点 + client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path); + } catch (Exception e) { + System.out.println("此服务已存在"); + } + } + // 地址 -> XXX.XXX.XXX.XXX:port 字符串 + private String getServiceAddress(InetSocketAddress serverAddress) { + return serverAddress.getHostName() + + ":" + + serverAddress.getPort(); + } + // 字符串解析为地址 + private InetSocketAddress parseAddress(String address) { + String[] result = address.split(":"); + return new InetSocketAddress(result[0], Integer.parseInt(result[1])); + } +} diff --git a/version1/src/main/java/part3/common/Message/RpcRequest.java b/version1/src/main/java/part3/common/Message/RpcRequest.java new file mode 100644 index 0000000..63ba31f --- /dev/null +++ b/version1/src/main/java/part3/common/Message/RpcRequest.java @@ -0,0 +1,25 @@ +package part3.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 18:30 + * 定义发送的消息格式 + */ +@Data +@Builder +public class RpcRequest implements Serializable { + //服务类名，客户端只知道接口 + private String interfaceName; + //调用的方法名 + private String methodName; + //参数列表 + private Object[] params; + //参数类型 + private Class[] paramsType; +} diff --git a/version1/src/main/java/part3/common/Message/RpcResponse.java b/version1/src/main/java/part3/common/Message/RpcResponse.java new file mode 100644 index 0000000..537b630 --- /dev/null +++ b/version1/src/main/java/part3/common/Message/RpcResponse.java @@ -0,0 +1,29 @@ +package part3.common.Message; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/2/1 19:18 + */ +@Data +@Builder +public class RpcResponse implements Serializable { + //状态信息 + private int code; + private String message; + //具体数据 + private Object data; + + public static RpcResponse sussess(Object data){ + return RpcResponse.builder().code(200).data(data).build(); + } + public static RpcResponse fail(){ + return RpcResponse.builder().code(500).message("服务器发生错误").build(); + } +} + diff --git a/version1/src/main/java/part3/common/pojo/User.java b/version1/src/main/java/part3/common/pojo/User.java new file mode 100644 index 0000000..46a0a87 --- /dev/null +++ b/version1/src/main/java/part3/common/pojo/User.java @@ -0,0 +1,25 @@ +package part3.common.pojo; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 17:50 + */ +@Builder +@Data +@NoArgsConstructor +@AllArgsConstructor +public class User implements Serializable { + // 客户端和服务端共有的 + private Integer id; + private String userName; + private Boolean sex; +} + diff --git a/version1/src/main/java/part3/common/service/Impl/UserServiceImpl.java b/version1/src/main/java/part3/common/service/Impl/UserServiceImpl.java new file mode 100644 index 0000000..6fc44b2 --- /dev/null +++ b/version1/src/main/java/part3/common/service/Impl/UserServiceImpl.java @@ -0,0 +1,32 @@ +package part3.common.service.Impl; + + +import part3.common.pojo.User; +import part3.common.service.UserService; + +import java.util.Random; +import java.util.UUID; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:28 + */ +public class UserServiceImpl implements UserService { + @Override + public User getUserByUserId(Integer id) { + System.out.println("客户端查询了"+id+"的用户"); + // 模拟从数据库中取用户的行为 + Random random = new Random(); + User user = User.builder().userName(UUID.randomUUID().toString()) + .id(id) + .sex(random.nextBoolean()).build(); + return user; + } + + @Override + public Integer insertUserId(User user) { + System.out.println("插入数据成功"+user.getUserName()); + return user.getId(); + } +} \ No newline at end of file diff --git a/version1/src/main/java/part3/common/service/UserService.java b/version1/src/main/java/part3/common/service/UserService.java new file mode 100644 index 0000000..07efce0 --- /dev/null +++ b/version1/src/main/java/part3/common/service/UserService.java @@ -0,0 +1,16 @@ +package part3.common.service; + + +import part3.common.pojo.User; + +/** + * @author wxx + * @version 1.0 + * @create 2024/1/28 16:27 + */ +public interface UserService { + // 客户端通过这个接口调用服务端的实现类 + User getUserByUserId(Integer id); + //新增一个功能 + Integer insertUserId(User user); +} From 0c472f2652758c4c8ec2840f38ec969b23fed5b3 Mon Sep 17 00:00:00 2001 From: Wxx <2563806166@qq.com> Date: Sun, 5 May 2024 20:40:08 +0800 Subject: [PATCH 2/2] version1 --- .../target/classes/part1/Client/IOClient.class | Bin 0 -> 1487 bytes .../target/classes/part1/Client/TestClient.class | Bin 0 -> 2082 bytes .../classes/part1/Client/proxy/ClientProxy.class | Bin 0 -> 2537 bytes .../target/classes/part1/Server/TestServer.class | Bin 0 -> 969 bytes .../part1/Server/provider/ServiceProvider.class | Bin 0 -> 1474 bytes .../classes/part1/Server/server/RpcServer.class | Bin 0 -> 163 bytes .../Server/server/impl/SimpleRPCRPCServer.class | Bin 0 -> 1396 bytes .../server/impl/ThreadPoolRPCRPCServer.class | Bin 0 -> 2536 bytes .../part1/Server/server/work/WorkThread.class | Bin 0 -> 3143 bytes .../Message/RpcRequest$RpcRequestBuilder.class | Bin 0 -> 1979 bytes .../part1/common/Message/RpcRequest.class | Bin 0 -> 3426 bytes .../Message/RpcResponse$RpcResponseBuilder.class | Bin 0 -> 1588 bytes .../part1/common/Message/RpcResponse.class | Bin 0 -> 3094 bytes .../part1/common/pojo/User$UserBuilder.class | Bin 0 -> 1467 bytes .../target/classes/part1/common/pojo/User.class | Bin 0 -> 2753 bytes .../common/service/Impl/UserServiceImpl.class | Bin 0 -> 1965 bytes .../part1/common/service/UserService.class | Bin 0 -> 269 bytes .../target/classes/part2/Client/IOClient.class | Bin 0 -> 1487 bytes .../target/classes/part2/Client/TestClient.class | Bin 0 -> 2084 bytes .../netty/handler/NettyClientHandler.class | Bin 0 -> 1901 bytes .../NettyClientInitializer$1.class | Bin 0 -> 1102 bytes .../NettyClientInitializer.class | Bin 0 -> 1876 bytes .../classes/part2/Client/proxy/ClientProxy.class | Bin 0 -> 2956 bytes .../part2/Client/rpcClient/RpcClient.class | Bin 0 -> 216 bytes .../Client/rpcClient/impl/NettyRpcClient.class | Bin 0 -> 2804 bytes .../rpcClient/impl/SimpleSocketRpcCilent.class | Bin 0 -> 1648 bytes .../target/classes/part2/Server/TestServer.class | Bin 0 -> 968 bytes .../netty/handler/NettyRPCServerHandler.class | Bin 0 -> 3318 bytes .../NettyServerInitializer$1.class | Bin 0 -> 1102 bytes .../NettyServerInitializer.class | Bin 0 -> 2026 bytes .../part2/Server/provider/ServiceProvider.class | Bin 0 -> 1474 bytes .../classes/part2/Server/server/RpcServer.class | Bin 0 -> 163 bytes .../Server/server/impl/NettyRPCRPCServer.class | Bin 0 -> 2316 bytes .../Server/server/impl/SimpleRPCRPCServer.class | Bin 0 -> 1396 bytes .../server/impl/ThreadPoolRPCRPCServer.class | Bin 0 -> 2536 bytes .../part2/Server/server/work/WorkThread.class | Bin 0 -> 3143 bytes .../Message/RpcRequest$RpcRequestBuilder.class | Bin 0 -> 1979 bytes .../part2/common/Message/RpcRequest.class | Bin 0 -> 3426 bytes .../Message/RpcResponse$RpcResponseBuilder.class | Bin 0 -> 1588 bytes .../part2/common/Message/RpcResponse.class | Bin 0 -> 3094 bytes .../part2/common/pojo/User$UserBuilder.class | Bin 0 -> 1467 bytes .../target/classes/part2/common/pojo/User.class | Bin 0 -> 2753 bytes .../common/service/Impl/UserServiceImpl.class | Bin 0 -> 1965 bytes .../part2/common/service/UserService.class | Bin 0 -> 269 bytes .../target/classes/part3/Client/TestClient.class | Bin 0 -> 2032 bytes .../netty/handler/NettyClientHandler.class | Bin 0 -> 1901 bytes .../NettyClientInitializer$1.class | Bin 0 -> 1102 bytes .../NettyClientInitializer.class | Bin 0 -> 1876 bytes .../classes/part3/Client/proxy/ClientProxy.class | Bin 0 -> 2536 bytes .../part3/Client/rpcClient/RpcClient.class | Bin 0 -> 216 bytes .../Client/rpcClient/impl/NettyRpcClient.class | Bin 0 -> 3308 bytes .../rpcClient/impl/SimpleSocketRpcCilent.class | Bin 0 -> 1648 bytes .../Client/serviceCenter/ServiceCenter.class | Bin 0 -> 212 bytes .../Client/serviceCenter/ZKServiceCenter.class | Bin 0 -> 3281 bytes .../target/classes/part3/Server/TestServer.class | Bin 0 -> 1018 bytes .../netty/handler/NettyRPCServerHandler.class | Bin 0 -> 3318 bytes .../NettyServerInitializer$1.class | Bin 0 -> 1102 bytes .../NettyServerInitializer.class | Bin 0 -> 2026 bytes .../part3/Server/provider/ServiceProvider.class | Bin 0 -> 1951 bytes .../classes/part3/Server/server/RpcServer.class | Bin 0 -> 163 bytes .../Server/server/impl/NettyRPCRPCServer.class | Bin 0 -> 2316 bytes .../Server/server/impl/SimpleRPCRPCServer.class | Bin 0 -> 1396 bytes .../part3/Server/server/work/WorkThread.class | Bin 0 -> 3143 bytes .../Server/serviceRegister/ServiceRegister.class | Bin 0 -> 211 bytes .../serviceRegister/impl/ZKServiceRegister.class | Bin 0 -> 3883 bytes .../Message/RpcRequest$RpcRequestBuilder.class | Bin 0 -> 1979 bytes .../part3/common/Message/RpcRequest.class | Bin 0 -> 3426 bytes .../Message/RpcResponse$RpcResponseBuilder.class | Bin 0 -> 1588 bytes .../part3/common/Message/RpcResponse.class | Bin 0 -> 3094 bytes .../part3/common/pojo/User$UserBuilder.class | Bin 0 -> 1467 bytes .../target/classes/part3/common/pojo/User.class | Bin 0 -> 2753 bytes .../common/service/Impl/UserServiceImpl.class | Bin 0 -> 1965 bytes .../part3/common/service/UserService.class | Bin 0 -> 269 bytes 73 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 version1/target/classes/part1/Client/IOClient.class create mode 100644 version1/target/classes/part1/Client/TestClient.class create mode 100644 version1/target/classes/part1/Client/proxy/ClientProxy.class create mode 100644 version1/target/classes/part1/Server/TestServer.class create mode 100644 version1/target/classes/part1/Server/provider/ServiceProvider.class create mode 100644 version1/target/classes/part1/Server/server/RpcServer.class create mode 100644 version1/target/classes/part1/Server/server/impl/SimpleRPCRPCServer.class create mode 100644 version1/target/classes/part1/Server/server/impl/ThreadPoolRPCRPCServer.class create mode 100644 version1/target/classes/part1/Server/server/work/WorkThread.class create mode 100644 version1/target/classes/part1/common/Message/RpcRequest$RpcRequestBuilder.class create mode 100644 version1/target/classes/part1/common/Message/RpcRequest.class create mode 100644 version1/target/classes/part1/common/Message/RpcResponse$RpcResponseBuilder.class create mode 100644 version1/target/classes/part1/common/Message/RpcResponse.class create mode 100644 version1/target/classes/part1/common/pojo/User$UserBuilder.class create mode 100644 version1/target/classes/part1/common/pojo/User.class create mode 100644 version1/target/classes/part1/common/service/Impl/UserServiceImpl.class create mode 100644 version1/target/classes/part1/common/service/UserService.class create mode 100644 version1/target/classes/part2/Client/IOClient.class create mode 100644 version1/target/classes/part2/Client/TestClient.class create mode 100644 version1/target/classes/part2/Client/netty/handler/NettyClientHandler.class create mode 100644 version1/target/classes/part2/Client/netty/nettyInitializer/NettyClientInitializer$1.class create mode 100644 version1/target/classes/part2/Client/netty/nettyInitializer/NettyClientInitializer.class create mode 100644 version1/target/classes/part2/Client/proxy/ClientProxy.class create mode 100644 version1/target/classes/part2/Client/rpcClient/RpcClient.class create mode 100644 version1/target/classes/part2/Client/rpcClient/impl/NettyRpcClient.class create mode 100644 version1/target/classes/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.class create mode 100644 version1/target/classes/part2/Server/TestServer.class create mode 100644 version1/target/classes/part2/Server/netty/handler/NettyRPCServerHandler.class create mode 100644 version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer$1.class create mode 100644 version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer.class create mode 100644 version1/target/classes/part2/Server/provider/ServiceProvider.class create mode 100644 version1/target/classes/part2/Server/server/RpcServer.class create mode 100644 version1/target/classes/part2/Server/server/impl/NettyRPCRPCServer.class create mode 100644 version1/target/classes/part2/Server/server/impl/SimpleRPCRPCServer.class create mode 100644 version1/target/classes/part2/Server/server/impl/ThreadPoolRPCRPCServer.class create mode 100644 version1/target/classes/part2/Server/server/work/WorkThread.class create mode 100644 version1/target/classes/part2/common/Message/RpcRequest$RpcRequestBuilder.class create mode 100644 version1/target/classes/part2/common/Message/RpcRequest.class create mode 100644 version1/target/classes/part2/common/Message/RpcResponse$RpcResponseBuilder.class create mode 100644 version1/target/classes/part2/common/Message/RpcResponse.class create mode 100644 version1/target/classes/part2/common/pojo/User$UserBuilder.class create mode 100644 version1/target/classes/part2/common/pojo/User.class create mode 100644 version1/target/classes/part2/common/service/Impl/UserServiceImpl.class create mode 100644 version1/target/classes/part2/common/service/UserService.class create mode 100644 version1/target/classes/part3/Client/TestClient.class create mode 100644 version1/target/classes/part3/Client/netty/handler/NettyClientHandler.class create mode 100644 version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer$1.class create mode 100644 version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer.class create mode 100644 version1/target/classes/part3/Client/proxy/ClientProxy.class create mode 100644 version1/target/classes/part3/Client/rpcClient/RpcClient.class create mode 100644 version1/target/classes/part3/Client/rpcClient/impl/NettyRpcClient.class create mode 100644 version1/target/classes/part3/Client/rpcClient/impl/SimpleSocketRpcCilent.class create mode 100644 version1/target/classes/part3/Client/serviceCenter/ServiceCenter.class create mode 100644 version1/target/classes/part3/Client/serviceCenter/ZKServiceCenter.class create mode 100644 version1/target/classes/part3/Server/TestServer.class create mode 100644 version1/target/classes/part3/Server/netty/handler/NettyRPCServerHandler.class create mode 100644 version1/target/classes/part3/Server/netty/nettyInitializer/NettyServerInitializer$1.class create mode 100644 version1/target/classes/part3/Server/netty/nettyInitializer/NettyServerInitializer.class create mode 100644 version1/target/classes/part3/Server/provider/ServiceProvider.class create mode 100644 version1/target/classes/part3/Server/server/RpcServer.class create mode 100644 version1/target/classes/part3/Server/server/impl/NettyRPCRPCServer.class create mode 100644 version1/target/classes/part3/Server/server/impl/SimpleRPCRPCServer.class create mode 100644 version1/target/classes/part3/Server/server/work/WorkThread.class create mode 100644 version1/target/classes/part3/Server/serviceRegister/ServiceRegister.class create mode 100644 version1/target/classes/part3/Server/serviceRegister/impl/ZKServiceRegister.class create mode 100644 version1/target/classes/part3/common/Message/RpcRequest$RpcRequestBuilder.class create mode 100644 version1/target/classes/part3/common/Message/RpcRequest.class create mode 100644 version1/target/classes/part3/common/Message/RpcResponse$RpcResponseBuilder.class create mode 100644 version1/target/classes/part3/common/Message/RpcResponse.class create mode 100644 version1/target/classes/part3/common/pojo/User$UserBuilder.class create mode 100644 version1/target/classes/part3/common/pojo/User.class create mode 100644 version1/target/classes/part3/common/service/Impl/UserServiceImpl.class create mode 100644 version1/target/classes/part3/common/service/UserService.class diff --git a/version1/target/classes/part1/Client/IOClient.class b/version1/target/classes/part1/Client/IOClient.class new file mode 100644 index 0000000000000000000000000000000000000000..3887808be5ef845b87d645be5c366db61faa6015 GIT binary patch literal 1487 zcma)6TT|0O6#kZ80wLT=ffi6MqP7)?AYPz=Vg;?1Rw={CV+bn*+N36_`rwbk7nqS5 z$7lbJ?~Z4a7J}1ZY^J-}bG~!?&e{C>^Zf^a1-z3H!+i;JGTJaN;epr}WQ6fh!Xt5b zEJMN*Az2j5k~n51EK69Cuqxvzo=I4f@SGvKY?y|-$`DGWcNoGsYo9ap6bzFW>(xDO zZ)K;ObUQZ`hz~(Ic3gc9mUCKi<@8UV|j$ z804~5w{^Z@h%RZb_Gdb!-UOONQiCSb#7EuaFn0 z*9zXCpkNbm1x1t?#{Ge5)$}I8{Y}65(gkf~=t;c+%2hPSDO&D^RX6u9AXKx0x1y|p zmP5(Vd+EX-1O`8r=k>x7!(gj%6_=#vfM1y&hD0iTIXGA6D%tQNhzx3kqi%8(AdGHO zz)wIyolRW22`Yq_&d;{t@@6dq!K{5@R-hsuDs|_O=7HvYzX^^v<9W3=&{SZJ?j~Ig znx$=9(>W&4N8cRrYXi}RIIRP8QfX(jM>1z%-#qmotx-=H!w|hIJ^%?M>C}N?jF3ba z|E5oqM0@TWZM&I~GlYug2=C6EB65c4QurK_IJBRkV=0mhPoF|ghELI%jGRLGiLRw+ zGI~-ZL@zs`ynrm0(cRd45Q0c01DV!AT8HRKV2TpRPzow;U=cUTVhk%7#~Rfr(%nKk zVdpVQ`VdKO6K0GOog&+D!bHd_gh||@B3I}?MTijDv8V@ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/Client/TestClient.class b/version1/target/classes/part1/Client/TestClient.class new file mode 100644 index 0000000000000000000000000000000000000000..0ccacd24d34f3889fe8e9bf243acf50547d41a22 GIT binary patch literal 2082 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 literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/Server/server/RpcServer.class b/version1/target/classes/part1/Server/server/RpcServer.class new file mode 100644 index 0000000000000000000000000000000000000000..50b6f39fe3acde2d3340e2962ba659c259c24b5b GIT binary patch literal 163 zcmX|)K?=e!6h!B@X;UkR7jR!U2Ej83t^^D2V+h4kY)E1c=fVScDDg+Z)i7^nnAiL9 z1hB(gVkS`&iV(Gr1koJUXO<90N64FG>UO+)WB1p=5*8$?e}xgxovG3)KA2AL@_pxg+x_nS@?+x@fI;LHoKzv8Cvge`4LGgh z3A|-7( z*EEXv4BwXfiZD@f%>|3>*4!gw+0Y#;&rDWcT5!-vEWmTBmc5$jQ*N{P{ zf@>PaaGeGI_WDKn`J3{qmGaAX<>xD3H=ZdN*Kh+jHQWL-X$j2~4QF1TdFWfl1A(J8 z$6P7PW7l8M?{kPy8rrd2I=d~0I~qEW7HAKR)z(`>4rvLZKD(3Ue-ykXw8^u!d)V9yA`H<+X)H*Q(fel{*JgxETDK2RCLHoMLiT2h%DQg z9}bV!Fl9f{Kq_6;gTLBzxI(My-T&x-u4<>#OO7LNN9eXW3@mKE8Q(B1^zcHr@_x7R zACqUocc6~z4s>$t;_fpNh;ts=gqZDKM=bvyb#3uA)c36+ad#8S>?Rs!`!gSqT!*@j zU2D+ZZk6*?H?7hLp!3&AvwOHc!p8$#C9#)|_tVWm^x+T@hxz98@DVynjeLyisq4f( zbd#CH31Sa0#8V9BAn`F`hREsRELTU!6FA0oCt}~xs^IvRBq%t+E2p5B+7!~2q_V`x z$iym#SQuC$6!eD9wMbbp&-;gLg*ZyIbggFA(VWSCMDkAyZJ`AQAyK~rRKwab5+*A> G_WuM-B~D8K literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/Server/server/impl/ThreadPoolRPCRPCServer.class b/version1/target/classes/part1/Server/server/impl/ThreadPoolRPCRPCServer.class new file mode 100644 index 0000000000000000000000000000000000000000..29a7d90f4f97b6280b67f783de882bd182368a0b GIT binary patch literal 2536 zcmcguTT>fV9RDo@mV`xa1;i4u6eWa9ic+-&QJ~ZYxs^~V*4wfiVIkRFHyZ>$Kp#5e zj32<4KIx1PopvlZWyTlZ{2ZeF5RUbCPC`f&93C7Q=CJ2~`~B~SU;cdZ6M$g^5wv4U z$Mp!_#SM8RtH_W)qhU*93uQY)8!HGONO0GFQ{2G|jk{nO-)1Tiy%AP_SWVH4K#lNT=zWo$=Bo zVJ$99@;C1{-Sf`sRWdn!O2+JrxWy1hPG(P}U2DsB)^FxSPK?Od49oR}EJDiuk`ZZ1 z#+fm9>`X3mOs(4z!W&Q9+hU3KDK*Wcac-yhDCAa6Ju`G3ibu<>q`#T(@PnpFbYQ(!L#(qidiO6P&~|j=LZRb}vg~cL8PcpLTS^0&*COKANrw3{_BkLk4URq*>&3ZHq zQie^?%#zt@IT_rdmdIvZpDT+s=lDmJ(SNMs!a!@#Q&W@kbJtQDlCl4850ylp+RX-n zrK)su%)xOVFZi|-qyoMg85zP+?n}sY&XYoEhkCJ+JwPpPJ+<(vO-l{~4IJgBY{o_k zY9++-MSkk*BIiXH>Yd`Sw3Wga*N~K{S1zjYTk=gy-~u1gc4&BkFJ+VLXFj?WvZeVq zM0zJ);(39$3~I>%2IBkB;s>Z$`4N?S2sKtdJ%_4C&<{|v(y+FV@IE4sQ5)}j4CA3P z*Tu7m=0KkO*QS|bwQpv^9r<{(`*#T55+8`3Na*5vt zU6h)G7$W6Weplc%(uQ%lkg=aprSyj$p|0tWpep8fp)W)LlOBSts+2;NWdON5mn4imD4|M|R* zH>labg1(6>bgZ9_T*ZhAaj2MpA&kx#O591k^`4 b8MJm>)@nt#qQLVR;X|uRsbP|$6}a{n-EExy literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/Server/server/work/WorkThread.class b/version1/target/classes/part1/Server/server/work/WorkThread.class new file mode 100644 index 0000000000000000000000000000000000000000..e26c7777683c13714bda141107827cfedeafa1c7 GIT binary patch literal 3143 zcma)8X?N6Q6n@gqG;Ihi1uB%aWoaZsVoA+h|hxI7}`Q5laZcpRF7Dhvx3DFq|Y6|BOj zkd2AUxB>%*#nXg>G%^ZISTeFQj>xbTIMAx#B3Fq?1xImAtRELHo{;gRjHhHgEuq4( zQWLr>p|<<5HmM~|-AxX9q7Dhwj&4sHDZSseCXEqY!rJbvX1nW?gOuxbGV9B2@4cjF z)3n^qnY=bN?~@Sgw1ja@w_)nNxy-O`4{5_`O6GQ3DJ{KEvkmbc2+J+Yk+8&vV_3<) z;lp~$?aR5@oIB{+x|R{{ErUvnZ&Kl&8HwU|3DK(3B*CMYF!M=g6I zxu2JzafUQP_1S~2mYV3%vK|jIo*|$y-5t;ifOa*_fXEB8qj?66BIXLioU|r9`n{BU zz$LLQEYKWzl(cN)t zM8cxb7Ph|y6C&0+yvjT%<5{mhPsn(Vc3Tb8aJNb52(X1}G|KHQ>rqspGHB)Ol)l># zl~+@uzDlIRVP3&^S6`8C2@RgqOIBxEbDUnw-EHN}k)jGqM#Y;*sCWx+t7t;A zjCWMLi}zHV#u*i7h4_7ZAmf~h5Al(TkMW6&6DqdjQyHJB_#Eenx3p2OHJD3{`?)FZ z6M@o|PU~Y@dS@!djtZ$HN=^zX?qb=cydoOXY*uzrn^~6eg^Dln6=%Zrvp-+|@yzv; z7jB$C_2=nxH!fb3@wJL?a6!el_)aiOj#fqn(ezCvVNMB!U*Pm#5)I@`(;q}WwR;V;@Y__R+qwF(E4?BpDWZ7*TdG#mY|vnbS{gU20L&xoTv z$MZTkR9WQxe(3}Ue{nX3#5`oY`bzVQBT|Wl#EWl`QO!t8Sj8OwS704z}q|RCe=TbD92u&1lE$;9gD7t$c2Q!s`;$U@4YiIngvyz7ls5 z;btOhC&~^=w-a9*HMgOHx=l#pc4AzHdaTDCUKF*o+2DCquo0UOqg{+X?xG$ez!v%f zWq^z_ej{#;(TqovAF8C#w1SI!h<8p8W36RWb9<%sSZf~hD4frKT^_f!$LeFPd|r^p z!uEK5{3_}%iF+PPf55W2%kyZsipEQH=ObDa+!qJ;C6UMzojHi~7tY9o{UK|@3 z!A7FpgigjFBHv5gZG^a;vBW8_rF^HCojpNp1n=2$FyS8lIvHR!*Y2f-K(h(Eu-oGW zSPbcJ(iNAnN5)Er}~AYgu;%wU;R>^DupJ&rN9v6#k~SZR=v8KmkRmg3^{tt>6`k0$MI9m;fOm{@S)%t=eE1{Md&5P&na5OJL>S2d8zx)(%;(XpIITLi>8z(5$9O zfZ;B{a%zPzfo0v$trZ4uB6-N*Td$P}9m(qk-)&Y4+&s_<6+7HoQL7wkrY_FTrO!In zDZYWddU20`Zt{k;*3>H{ZZfD_hQUoc5>AkXJVk3|(#2Y}S~Jo+ywT9gJncT5a!rSW zg4;;6CGHd{c_XIHM0@^D4R1!Z(Lp6^eKV$5zN4npNT;sb-7ZA8Zsx^b5Itd-OkDY% zN*=Uovd|1e^q|*_?$?@Tk>_+V77@2?^8%~l9`36c!mx^%5F;2>F@`$~6IV=tc>0cE zW#B5w{O;*8%icM_U7Nru+6^h$cwG__OO zO0~p!{h-zG>5j2$Es2|wvx0a)pTR-;O8VdtttQJOx@~J}xUH$@V7P1B<4{P`WYEn7 zS!vRYv_EwL_RWUGNe1l82+;$o1mGba(TRo;k4cKhOXSQ$T1m}(hbQ%wOb_BD+n>iI z#Cc9&J5J#>)|<$CZ6cAVAR57RuZVotCK8nrL}N%$v?8?~(yi3|Hj(!lsmW3&i9l9O zAtzHG^4_!o`|XrqN3Tj#6h-z%zL1=cAwh0!r_4O5V{{H)uZ`zB&agTA8~< z@aO`eX!snr1TU$mDs8W@`=ssrf!pF3kw?FC?5E>72L9(g=Xm$f_=uK2!4&B*d5=;~ HlL-9z*RurnpG#%PNnuKJ6g7-Im zgFirCc+jM87|B4Nf=k62w^1*Gs^X<3|Y}$6Uma{Y830(5Gf}I*JOD;jC>SvtVFOW zb0LCa1SL7T5kWbEitO59RKvKbuxGK9U9@ggt%`lJn#-?QWd&oVP_W9U@@A!CRTMgM z1=}iLHM7>dxoIiHXRnzz%}m}btY?<&a;~sGp%C4)?2Y1@s}U-hWpk6JdslqA3#-?x ztS!3k@$#*b+~!wtd{U!rDYsrQ?P{3{J-ZYp)5ob3n#>h)_Hl*Tq|b>5X!nl)77vMk z%k`YPprD;9uF-95HdnCbtDCDsW-(-(vvc=8K zVj(kURVwDXm1zW*fO}_~?D=}{j)nj20TLN`LwL28%VWvZ)1VDCP5vB!fAm@al@=^xbzPuQ!@(s z`Nf&J(}YSnRJJPBysgl=(|P-l-%G?Ux<$xBUn*A1S!+5cLk3>L%L-$q|1PH8j8)kG6dMEQaoS+VJ!aq?kzNz&b-WSAX9jNJwt+V>Zs0vE z8u%PvDD>?ld%Zy>8c#_!rDw{(m-vdD8yRebWQzT4WRURK5~=VtzHt=X4dFi(RLa1I zIL5kbICc4;(CuvHikT>tX$m?Y1Lki0pRtt9CA*IZ-Z~x5&5Xnq`%ojB=4`BB)2P zR-`8(4KX}hr$FoC5GI(Vl2uq!7;RN@yLv>UsW=Xn>-0F(3R{aFg9H4+?SsPe&=3&D z@Y5L((l|4DwZdU!xT3w|UCsv_{{cr51VKj<3>uD5Hk?}qNa!SYTvTId!z*}| zCxU5^nB*_=0HKTb5&nU)YC@oduAX*=v-s81KOrEh0iSBz0qeTdJ+Mj`-oiMz)402( zF)O2mv9{B=x1}*F$qT$6w!YK2zlE_IsR{a?#FU3XE|XY=oXkn4{EzQ+Zs~P3>X{08 znNm33`kvsk-XlDd*uRChTj9~3^&Vk~+;ajaiB%Xd%enrpT?~BEyIh_hp}m{%ki)SW z^H0$O`PiPOZ z=Pr!Vgtm?Lnuam1Q^gn$C3MjVJw*I2Iud#!?!@VFY`ZCT@()fP@?{d^JhY7~=3@dkz_a8)iIPy0- z!OEFcf~dpi_w~212;x&`^w3JF2NCiPa;>XvRH(KB>7%-ZFF6cePdjcgM{XtL?p;Ol1&~nczfy#Mot#3!{#=p zWiM<&Vp+m6(dbyf`;-ERGE^6cG{}$Z7(Sq+IUza+?J@eGF+@r+EKuq(l^W}SZ1g~{ zDb#ed<}IqxA3t1P3`+DVO=|i9;%sSqnt^Kl0xJ$m)Sq^Zy hjpuf@3zsY|>8HI{2XN8J*d^@e9HsXVKNc^b?O(62x0(O| literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/common/Message/RpcResponse$RpcResponseBuilder.class b/version1/target/classes/part1/common/Message/RpcResponse$RpcResponseBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..5944e04c7b26af5cdbc2a0fbf2a526df1559e75f GIT binary patch literal 1588 zcmb_cZBNrs6n^gBI%?&m3{XLxirS5riVQ_z^M%A@$Qp#c_i)ZXU&tjGB3kfeJtO=wV&aNpSssd8W^gLsa{?yvO@zv0qhP|h6 z`L1Q}apbPy8|TkH*7wbZPiL8R%eMTAKvFAgQ|LwjI#RQ2^TR=_Zn~e0dNTla8b)*5 za4r6iHdFo=%Ol{;c4O1@+K%m+Zx5{IuIUOWRogb*ji%vwCdI7O+J@^d=?$mVa%}y5 z*svbUoQ?Sr3iY?DRSQ>4t!lkw{1>c&%hBtTq^d7|8lgsH8xSGWzH%Z#f5U z!+dA4P@^##7dcqLP25s2j+}xCOe&bd4T1b1IXG=yVCwIBrvk_IT8tHq0yG}avVt-y zyu1>S=kw8=mT6??^E{P7z-yY~f`Z4;1eOQ&6)$_*%jj8`p*RAXR_)~~wsRsP4SmLF zw@sTAS?D`4XV{?*QB{&=hKKXw<8yE)^)8IZJ$emPdMA=duv+9LSg^p7W@Iz;k(dye zCQm0T$fk>3i0|YiFhgr5*c`@f@|7?EcL*HhkK;bAoV-TS39?dg`Ur{QH*$N^C&Q2^ zoq~hDxatHR^Z?BrA$e&az8C{dVYVMo>e4{W3LSzso*_-SQ<`WJBdpKF0ArPoA??S6utk&)k!`xPfiwyEK*fLH zjN>@N4URL6H{t~|=!^tMW*ogi$NvH9y_X_BXLr+VOBgzI+V?&0d(L_Goadag+duyM z>1P1L_#}!L-ie|G$7Oj}miNLqA^XWFHsVx-2B&3tUzRflJ`mk0182q6l4VYoj9AZ$ zWQ%mpz(N!WoC;%6_N*-D!?+MePQ;}!^0F5U6b)Qdh|d%=Gj_RH$d~PX)ogCwE-9Fk z`Mg~k&spWNT~^RCg?U>+O)3~mcDZaV@D!gqZ(Xv|IV-=Ao~@L!`Grwh&RZ30rS8bw zc{@{~&L~#}j(9tgK3`AYKUK6!m2K%vVQHz5Pfxp#N&BJ`_;DwYbyL~AeYm4yq+5`_hGF*UBS9j0_sNuq!Nl>tRVzn&ni`yBKNS@8LS@nEIAOAHxw&G_b>kdy)NXS{ zU7dS~%~q_;g=wqk)ST17zE%ilto(j?I>kk+yy$YKADx+;-mefU+2v}kLS5qldY_9I zt`yuPNyBWRTFTf5veIB}zItpCmQ8HOu!+qmnRp3h6BTS>s`tP8?B1te-@E$lz0be+ z^UAfquU!4>=1miQsG3OQk~q8|#}~!xWrgie>iQ;)pwRmyFB4PPXW~`tFtHQ6OuQk- z-54=3jU5V|s~cr`^xJ)jCS~r&OniusWciq!4EB088ec-Nbapl(_f|xZ zL_e)kJdIMXxVQfZ)sEk52&8HV)}VdoxD0R&IR>2=q-?sz($hReFoZ20P>MkE6Bi)$ z4}s!(4IvLnp@Gy*t2DNHey8cD@g|YF4I|Zk3*pq@Eksg7w-EiF_W_@0s}n=YwZ}HR zLOng5L?wxYld8m#a3TycLQb#uq+Tz=@Ex?AxD8V>^vBi869>t&PIDJbJ@o^^Hz@c6 zY4?$#dx0n!z$VU-)l9~lI&)^5I7e4ICz?8sVvpxM!Z?M1kVEBa0%MN%de>r^z>r6v z!Wi~Gf-}HstQAK(O=x=!uQ$Vaq@a(BN7_qp_%?HKlw@Tvuj)YR8|d1NfnO2(5_<5) zz%PhR53*@nog;;HgZ#TDIv&~%^VBw?4gH3eF6}PbufrVb(rRe0o5x3Vn#4y!UAowW z?jn92u`a!fz3UojQvRT?58bd2x&bZISjD&#b_dR4g1s4_W&-knGdkuz+3zcs|VQNiV^-7A}@Q7*WKKu&bkn>x;_20 z*4vY&jK-yvp9T-+K0$QCOtg*e(Z+h(Mi+&^vttf(awKozwt?#~hH7}mxsQ)%qUh2* zO<35Zs;4)Hny^q62!}pl+kByrLPO$1j$b^BF!QT6ZQSC| px^ldR?syO78lGD{jxN*gTXERSF@Ra32b@X+Q9i4MujO7u{s#<5a7_RJ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/common/pojo/User$UserBuilder.class b/version1/target/classes/part1/common/pojo/User$UserBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..4dad3e51692c03f433541e35221ad0eb6122eb3d GIT binary patch literal 1467 zcma)6+iuf95IyT$oVbRzsY$sLN`WN3m_mS-w0&qLq)JtJC{*eTl9Q~0Bgc*$2k}`T zl}4fxAHYW;W@0CGXh3=J&g|^WnVB=Y{`LFEPXHC{YM4hki#e?DvdYVviggVsm@1xW zP*KicgXMExUSv?o;AIA{c=uYxriv{A#cl{J9JZ{_mg!h-(>!nk*_3`&Ak*tg|Hx`f zfn3btIPh(^N#}{K{4yT9=Xs8_Tsli{+pZn#l2fsCB9Pqo8U!Q9*R!35^ab<-*OmUhV|BZd4wnx*mLF`Gb+6s_T(je~ zJd^#GV?k8MRxwuju(i^3v77POsOu?1$I=d2nKCw2n>3D*t0!xz<$EPSTcbWfPttIP$Ks7#_;asoM5VMS? zK-V#Cbvn`|j@RNaqY+=G3r$hGMEjV3SWERP`$K;`q(?bV&ou#s87EC)(g%`wCz+;? z1_By4X(mZQGF9$Fd?Q7{9a_@^<1Fryu7?h|hXU>BWm1wbxJup%+0^pNcPQnrq+Sir zhb~b#IS=aMtOk}Q0VSpe;>H*#k4KY$l2ZdQGYqth#}Uvj{nVHj;{vJE@)>n^h6H`d zKGKu>3~4e(G|^>?us#w4j8(aSdfG=OmpzBZnCF7kw=k-HY^Nw!}n{T#FZ%T07TCrlAv_udEQ;GDkr_w-;Ec~C;@bDzG&eDfFw8mo?z8qj>#VcSPXGGn*WUn~z?O|q(@P@_EC?muU=O*}+YjzmnmW1JA*lgR*?B3vStl zZ{ur)%xc50pKAq`b-%9Q&R45`{d~o1H2j7_B3M^Au(0KQ=M^hnb)z_6ZTcI2eOAF~ zF>cA*_7$=*z)G_oR5!SuZ1}gkW6#xU72m6J&0cHocVu#EVaKaCj}^Q`%S%FWv%$%Ndu6MD26I>Vbx zX>Vu`gzna!Jp1%o$1$+d^vd5XdOM-stXWnY6PLZ}1>s3^(`#(%D@{&L&6CFE<@v=6 zG8HWbChIyoQly!QU6(}iyr-ZSxdl?`i*{p}!*_eS*#2;IY2JM?<=@bBR3Vm{z{<0Lh@s{I@d~)13aV#RymB)DAJR-m3IgYpbJ&Mrc$zzf{7*2A zdxbw>{RlI8ukbsp#p(Pm?C_I@voy`2WX$}DOwM?W{deKcB8*(Vsa z@jm}M>In{NGZi(c$W8f^%mk*$C+we99OfQ-lbnUUlD?wTsH2Rt7`-|)d)k-_ zB|kJYyGg;Fp~79*GrMqai9cO3WFconD~?=)UdoiraEUh%201x1TsqWW)H8a+h*lEI zxIn?!_Hj9sE`c;V)kmb7 zfHubHc118N2J0Yuy#$jco2b?fH>sWUl@pIJz%H~eJGhG>k#HCLvsrCtIAsrLJ1zcU z+PfI(Z3epDbQ?MmNu%UfB-*Rf!yaO^_wDTudqHmxTfkBje1k*{5*^MnIP50*=?5_K xGY{~ecbpA#~^mdYEJUp0!Jz$JbqczZ8!mOoVavx6K`{{ls%=wAQ; literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/common/service/Impl/UserServiceImpl.class b/version1/target/classes/part1/common/service/Impl/UserServiceImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..4f66e73cdc8f4e466b69131e9f9fa0f602f4af9f GIT binary patch literal 1965 zcma)7TW=dh6#gc5vd(&FTIWijr70!YNz>K1VZrAmr9W;AtAMehfUN<`~ZFjarhO8GrPWRaA+U)%$}J!-}%mEX8!!=(H{WL zpsZpPS}$I~DFv^ph(L?sv>eY!@mdV8%kiv=b2zWy4Ha={DyDHk#hbV&1+87eTT)z> zt1~KQF(=ixrI?T59l8HqDbfnwQ}Dim3`5Ta!!q2943T7Ng&{g?7X(9J#<0XfwUiUi zlAbeZCXuo8y1Ak|hSckmQTK*XVVKO6b;muW9zpgwSP>QGW*;3dhl{f?bk) zeaNb7nA$aejtrw!^2jitli$){q;fZ?!CVsZ2tA=8;+~^K#FS&y}Nh5 z+WqMl+QE^?+v~2AMZ(?J6bArL+mXM8)mV%VlBhZKois)J^*&nhZnj7cl(a z{V~@LP^rYp{{j(;4D;n;8*2&}x$9<@6kb8l0OzNi?GJPmi1y$26^qv?>B+VBBGz|M#F2`) z$q*vbSbWMfcl%{y7~Qun2mm zXk;{YPi%qxMn7G6fn<+A*@vU_&w~vFa*Q;F7jc}VG~OhzD2?;Kqw6sut6PXBx;^wv zdQcKE`ti`~L4AxkE%7VccxD?1JoI@uNLvn_@Q~O>zlQ-2g9}p+2`TVCO8$Wa`53@B z25}lgIE!J-VZ>)N5qPaLBL8$JjT5JFT74NwLYbp4g$X~{Nt~$jT_wGXkjL8i4h4LN tn{0{MNQ;W<8yu#L9r0Zc1prOgW4;@DTrlO+KZ%cNRLS8bdNSA0`!8Xx3kU!J literal 0 HcmV?d00001 diff --git a/version1/target/classes/part1/common/service/UserService.class b/version1/target/classes/part1/common/service/UserService.class new file mode 100644 index 0000000000000000000000000000000000000000..216f6e47e6b4e4ab96a9153bd5252c4b4cee198a GIT binary patch literal 269 zcmZ`!K?=e^44i1SS_OTAM|;pk@Yb6Lp-}K3K47h(w6xu_)`DO2-~)V=xLX7f^pb?h z%w+O--tGX_7`Yg_@CcKH>%*D#=4xwrA}r=nCL1YoStcSZYfe}PepE?auSBehLY1OY znG#kI5XNa~hSuaQ|3meE_!7Lmy6Bj=(wLVv1!4B(X4ZDs-hT6p>XUbO c%s8(51VYC=3UnMo7Y<;04}F6WT#IAy0;cUuIsgCw literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/IOClient.class b/version1/target/classes/part2/Client/IOClient.class new file mode 100644 index 0000000000000000000000000000000000000000..56de353bc735b9f0b991343d255121619f0c467c GIT binary patch literal 1487 zcma)6TT|0O6#kZ80wvr^ffi6MqP7)?B3@`g#R^(2tx|@O#}HNsl%yu9`rwbkmv%;G z9H0F=zB`^xS{j@VV>8{&p7WjCch2V5pYJ~aEaP1SQQVbqFM=*CNw_ceZVV_RwNq7>$Q#_NfF5x*tcvUxa=Ltg~nc8It=F9`mFi_A9UaXz& zb8AQ4uaG2KFg3NZt6I7^H-$mxNVgfr3RTr|mXusY=Z2%?OWsSCq1Wcd!8ZR`=_ zK3O%+piTP`0>jtA||Ku4+xQZ0ZVxT{R7xQ=qVIYA2jx z40$08?kHtfM9P3^QkIjRMmLqx{xR2_Qq8H>97=<$r!Gj8GVu>6Z}>6Y7WX1D%>GYS zjEEcY)x7aV<5fpD4T={$G6g45pSnp2>8hqhI+kaUtQLDSS44CPCZ~O6N7YWY)T-Mc z2|0#H*{oR_-_%7H`&zwO6pfHEj2JcBZAzOlA%4Ly?ut9oC1V4d0``(2aT(?#OvWqZ z1?shoHz>&1LQF;xC5CBlU^+FuMeuOTZ@zRv8yUJ%cYtyg)wYYKvuW0hg9`}NEaR;x zYoy~)G7Pp|c!R*;#d5t~IAR#>G_K;33>@-H)58!?rrLvZd9D&oFM>$FMmXvxM?S*n zCi(pM6x7*x+l^l#y!3vybceTU8S!WB39|wf`cSFaM>G#K?*}b#tQF6#y@{p*t8_Q% zYS1k0SgOV`gCY9nh+h|oF2raZp_4*8qdk;vfPHh-qqK%yVH9KZE_(pPk)Tr##xX$> zVf>puO%m<7b9C*cCmIM8&k@{Ps3X)sI1@aFBo5sT^khPb;CvmCM6izDM5qq=C;Bqs zMEI;oh(UHnc>!6hqQAKhAOMj{8WCDYX&s{{jyXyoO(`h2h80{Viz%#O8tYV}NOv3E zgk8cU=>sIWNth{0bdGGN2@@i#0A_K6id>`r93cW^m%}aGrd_-xk#dX9QKUPR**r;! PlCKgLNWMs?E+~HiQF?Lq literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/TestClient.class b/version1/target/classes/part2/Client/TestClient.class new file mode 100644 index 0000000000000000000000000000000000000000..9dae8654942dfd5da2e7896dfa69ef4f1592745d GIT binary patch literal 2084 zcma)7OLN;)7(Lf7*@}o0=jjGYNt@PblekF>ZId>o2^0)&5^x$wLjl>obrodE$a0#j zU;#4>GdwrUFl<<`V!>nKv}C5kn%{xjzrc#&yOLbXCYjcrxi5W>bI$i&>92qPxDVhg z?#Or=XC$1B;&~YXyddG6n9s|&fY~mDF&D!{T#_&^L&ljXE{pj^8CS3%Rx~W)C9!>3 z##Ou$#j9e@$aoE}i&a((*F>bHD3*oGii9^LyvY!`s2Q3)&k#(FuQ7xc%_3)rXElQ_ z)yjEpt*UvQP7+zOpz3R?rHQ?F7_x6`Rfc4?qFVM$dQsQ7VW(Gl)pnP26tJvn2E$-# zBfF_?scBs`O6ir(UxJj-L_(GnvNk^uo^=^D-t{(_>5um61V8FoHJ`y zfnU{xK=BssDZy01GdRp}xJ{b>VP=R;&zze&P5)`(kt3R}$HCAQtm3+aH3e_sZ3XMN zAz?$oJGjX()G6{pP1B2l=Apm$zI^b*7md$u+uI6slqDDfE@` z&5cE+>TSjM>c=2$sd|ks-xA%K@q4u@9H&g8X%=?Gn4wOX^e1c@jvw4YK4Q6@s?EzJ zrCB3-11?O>Os~*ou!$g7%Y-zdRw~@+%+$OwK5p)jS6^}*Z0nmxZA^06rfbX4pYrqc zf>L`s>a;^4eJTQ&PPcc!Pr3<(3L)j2-PPr&)Z8fd?J1IF9f?F=9sT4r zP{&{$L$jfYWau7-1DFl_A|%N*Nl6a5{w>_2h!UP2bfXu;=p)4axQsz;UoB#j- literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/netty/handler/NettyClientHandler.class b/version1/target/classes/part2/Client/netty/handler/NettyClientHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..1f6f7ecadfd0753b13723f64c8a9885117124243 GIT binary patch literal 1901 zcmbVMTUXOS5dO9of^85eB8oRa!2;Ew;uS=+fFK1tEk~cXVJ*=#=}9*VzrkPQ3yKdO zpZ!rDXPfkb<)#nGW@dK2Z+7;Z{QCX<2Y_kh66nH2Cngif;8qg1VI(nyJ4xKdJ@qx6 zzMx$C7gl(e(HmhFI3!5)9or%Mt5-xhT9%UbM-R%DE=D z-*C@TcIb@BZL7*)c%t zSWD+DH_QtoMmE?H=44$*iXAx^jDps8)GN82O5s7uAaERK<)sMbwl#45tQV z==8#LhLMvgh~R_RWw_j|+LxAXJeSh5ioO)9VwVni{$R^?EA_U`ACotGGW{H3Cl+^1 zQIQrMSp(VKqHbroU)q)o^QS(3?mhp=4Vyb9V{_YcKdB3@wJ~mTze;!Cf9MW|r~gB- zQG72zDFGSW>4x0C|Ko+EkYfvI7QcYwn90awo3)q_e`;5DFqL-EAh5E zxsJ2wW=Q5=XX_%;FstJ!<}^IhF^}gOUg*eTLBpbsCA`$Jj1>*9bgZh>p+Npei&95F z&NJNlr!is3v<<~EEn(6S|_kdB?w%y{!o+Hy&A zV-4i`jU76(#1h77V$v;`e`OKkg`*JZ$HZy47#_AruDzxf@Pk3Z9%x`64AC%G1hjV1bl(1-*O8!i1jMmXqf=5dSS4o?K5s)cR3BY6U&Oc((CHA^1SrqzPgortizK!q)3NdT{O+>2W z6N*|3dWZakhcQ>e7HF8qlmhT zhL0vH)c@1Bzq-v(UOxEM@K8jCVMpru7)`hu#WXz;H8u)UK@FsF;Hb@Wb{aF88y%a)zXd|+wm zj|6E{-s;4*oi@v%6{B4ME0=AFY58*W7vYh1jkpfUR^v6AU%(n)k^7w4_(aKz=oT&z zU7uOuBFZF@eTK%!;u0#zXIRfjvRH-YH{?GNlfx3GwgOXFz!Y#9SIF%uSvz#D<67o- Yogi;y+)Zp`ceijGCE{%24xRM<1~Bd?4gdfE literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/netty/nettyInitializer/NettyClientInitializer.class b/version1/target/classes/part2/Client/netty/nettyInitializer/NettyClientInitializer.class new file mode 100644 index 0000000000000000000000000000000000000000..9f22eb6ee3fa34411dc60db9b88ed80a4f9856a0 GIT binary patch literal 1876 zcmbtUTTc@~6#k}L8M-YXpeQOA0i~47DtM(8ltQIRMIr{%_%v)MbaB}>yNeND^e_1$ zQKRwMAK=ds&$LUaw2ilYm@|9kT)uPt_T%Fh05_1;(TAxhdNIv0!(nh-)7~5&9_k3= zdK9ymgUIPw6;|dmIZKiwv=><48Ac3(u1t zLtDynEPsJPi%)Dagwv&hWa!FSj$GT@-IDH8v1JpdCs#6sy(wHv{RhmjU$n?ZDpwY+ zKWn6IOFF*cNZ;SDo>{VO3EO%tU1LqLt0HymBtujoNEZd+vKbQboK*^Jm{q3XmCP5? zH#RCHkW4DLA+yLZ{)Y+-?PaShZ3>NHq){m_ydKC9GJWNhDa*c9ay*Xv39_gr$Y*3v;;^r=Rnrm-$4FdL;k*OVDcmE&UbY|iY6mm-Gq=#OC(4;Y3Tav9)V z6;8pHF2h_+f|9LRhDj}88ae4~`^AhU?ZT4qWFg~k>yghGncUO#a^Nx+}}lA#+MK!!X-I#go)@)I&lQ!g##3BTawB34r{KQVo6T-}`m! zx01NFM;Xpd*rr{-|DmA4~t1}+MPobY^xO#FFE^FgMPe*_>LuQ*?f z|IhwW@Nd`6^-=k%Q}Ao=Rkr36>6Pr4(xnB2%d}bhXk!B!7_~${ofqiOAj*iIN*sW_ zqe}=E>1?YodvS^Gv8n(DFi3x4RdSM2%HL_7Yee5pen5!f(Ny>|w7m8S;e1b<#x;Hb zzVQL=Av~)+Me@YePjaLA1H?`;JMy2*#=qWiP6eGtzt)elC?Mfw1hO4KSDcbQM+Bu>jdWj?^zoPd& h&K$dKOjjf@Uo%Bc6y1}g9Xbr951_WZS}5A4Kmf&JQ=(E{(Y7Fo2;yrxy`)2vnJ}3G#RtCr z3m^QVOAV+?e}F$q-S^HUnUGZ0;=|0`$9e2?&c0{v-~asn7l7CBy@3&&*Kxr>0vG$R z2bXkQHqe8M2J(2vz`Iy9unS8DmT^T+)#$36z9*;G*A0At8&cz@jt>po z!bdtj*71psPc`)URePcA2shAhXt8Sf!Kq9*&op;3*BUZe4ZZV@>jXIsBU6iatb10b zY`LXOA@Ciyl+EX-uWLvxc&kFg&PB%+%Nvyy;TNryGFOHcJ=-c@w|qy=qs3IP=F~Kd zw>z);-h<5u$yGU~>(rW8Bg~;rzuc>OKKHad5!!2>SEIWfg}}1cm#nJtq=NoT!=7%q zCG1|uz2~h{uMn5GvT{e*K{n>o7q`n?$}EXs&0Edhifu*0)16BidQ?d5@FRKpt|(&~ z#$u|^IAV~NUt+3;ySUV#`{M3~kO`WIQfYgYisuq%t!9;ktm3s$gt^@2i(1ulWttjg z?BJ~&pocE}CFXul|B8dZhkD-_EQQ92CIK3RBmlHUMv&3?cJL%9H z_a-=_UmU_=QlK)aTrDICRw59<&O%*^o3g89&OdfUJfrQx

Z^cKenyv^sF8ZF>9zXo@fdBGOw`wvAB48Z^Z literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/rpcClient/RpcClient.class b/version1/target/classes/part2/Client/rpcClient/RpcClient.class new file mode 100644 index 0000000000000000000000000000000000000000..0038bab2c2b55276bf6fc913162071b1c2079544 GIT binary patch literal 216 zcmaKmJr06E6ols?fh($ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/rpcClient/impl/NettyRpcClient.class b/version1/target/classes/part2/Client/rpcClient/impl/NettyRpcClient.class new file mode 100644 index 0000000000000000000000000000000000000000..4192d71fb43383e1ab04e903ba77d4e9799772e3 GIT binary patch literal 2804 zcma)8Yg-dX6n-ZOE`(JqAj+lGOKSnawO*N-Vo9NOYAR(0E!mNroX zA=9og(>DE!0$l_3x=at=pgI|6SqijeO|F(( z3Lixk>$tDrfr=6yGT2c9ZkIxl2@1Yc@fE&S@QsRZ@f|CyvF}xUkBq?4N*R`m$|hyj zbZTo$#oHKQj#SXw6s?LM@FR<*f+mGF7x^5Na^*aJ5s?UlqiK?^ecxg#WXD1RkJFulvJ#0rA z6tI5>)!6w~B*WQBPyRO}$X1mlxsvBgR%+5I62C7(Q|cTqIiFTYJx_*?P)IGAwig1B zWs|Sk_OhSZRoX&C*nSpV-C%2JT8Zww=_;GcNmW~z)q&co$?>J&nl=3D3-x^U=^0D+ zyjSN{c(E*7l2O=Bqd1ADBFw8wWs~gZD~6?q6cSt==F=t-bWP4ZLE{W(_8rbi;s!Cq z@fcS(iA!>B8+r~gbnF=tLw(PX{EegphB>xVB+$*V2Q7TD>_Hz!NI4j>;W#v|C?Gsm zgnz-o2_A3)??lIly+rTg-mS+-4L#){Pm$a}(u74EJGBWlLE>(Km)JAf^cZd3O&i$T-SlW?cmwU?5l=$!G~@d#6>5GQt)vX1 zlZN(E=OffqW0QOrXE24cn8P`u&tn0je87!`R!u=6{t`~&6fNi_;xy4o^1ROPEG17- z>N#>XkuOEg3&hc`iXU!K(tFh9BB?6pi1QM$mq}@c_!~I|ej=nHh* ze2&g1*!Kcm{M-KoDSGTN_HE$6OLVn&Z=i?s3-ofgZv(F{29e@T!Lf@vfoYItY&sbY QjTWC`Bm~|kJ%NdT0VHY%GXMYp literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.class b/version1/target/classes/part2/Client/rpcClient/impl/SimpleSocketRpcCilent.class new file mode 100644 index 0000000000000000000000000000000000000000..84f7e0d7c73e59968809537f443867db96519ac6 GIT binary patch literal 1648 zcmb7EYf}_Q6g|DKk!55R5m{M{7)_Q%oQUQjAes<1Vs;^62`N4fLkC88XC^bVNxtPT zX_Z2iR9X3)-{Nnua=K@C86ssRGgbY#_w>29Z=deJ-@SeV;2wT1VhneOZ~^yJ^SOa9 zipb$h17E5Beh~%C8(2`2#Uh6AKv|Yl^H5D68Ti`3HwKoA_!cV$>IS|u@K_+X??e2ePUIhu;_Yjyd*GQeIL0xy+!b{zbgew4cC)v-Oi2- zH|?D^Eu#(JvD;gA=&E_on2Yz_NZ@WGu)}!HT5h}2i>)wldLy?Jw5^tEWy^P-$#{b< zw@nc98jhs5yCHw=N|pLbwMXLkosREWO&LY@p0v24hgq2Z03r%}FOp;}L^_bb`DBNl zjIAU#omt;!x|PJ^`qui+Q|ZL(-8ksRte3Pq8l?6#`7h9_m&Tk4WfD=~`hUqvu!0v; zC13f&kwNVG9^)BdzXnqupweX``fMwz1+5=Xw8r7e%IR_Kv)VBTX-UH=YOkF;M_5NB8ow( z?}=JzSPNYsNmVB`$b%}Ys+&~WlP8oVFj1X87S&13m3#M56+P`yL?a|h6<6R=iYMiu zI3|v1(hkKk{CnuevcI>B>HD7;7ZfW0OS>EGQ&PMOyM6FjKc3!b56uk*d|-HOD96pv zb|j|wrj3C@M}|LT#z!xsl%{*?3X}9!INPQ@%f3`Qgs9EDLZ()Eh3pFryux;rFCa*k zBiRtCMo4y*mTSo}e8iFZN;-_tBNZsa08_Z$3-gxi3-r~GklU`kWR#c49wOg7LSg&X z0gOYOSv$gz8W#^SJfEALIe-FcEjmox$ zBHKyYEBvoun)%&khI7nh5g&8K4Lrh4zS*DXT|9KL&qbAX4IH_ireGK=&o$FXE;nX@gbQy zny?tG6gXBV6mORY!PkrPGy0-hl$0Y4Egi==Vc1MXCbAi-$pL*B+;BHg;HX=QiF(!c z0xmy0>M+*LJLeg}!}GMvbmJbXBLwfHwA}A8Lw*|2#iC1OwwrzIL)~rlWWZE^X?#pO zn`TCH-dcct58Vchh0s_ekVOT5Lzeyxz+578wLrGBM2_bC`_|D9 z6qeAgS_>4r$14rvCrTM4{M(cP#8)J)D%R=U#4fhbKrPH^MZ9F+AY2i9LzaK!fAYKl literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/netty/handler/NettyRPCServerHandler.class b/version1/target/classes/part2/Server/netty/handler/NettyRPCServerHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..465acff2293d50b67be09686a82fb074b6b07357 GIT binary patch literal 3318 zcmbVO+glW69DYC8-GO05L@~umG!GnIGqVIE4MizH1k%b*!|(wEyEE(TEJAiZTXt4^ zy6mb;?S$GzPuKk+KK4&k?>95d?goNS7dtcG_dC76^ZxnwZ@&ZBk8gD};+Y!sV?aFy zb)3YIj!igKO~SB_5sd117N^zS8TEKh$MbkWeVx_uB3{z*GG5W}ss>ZTm<|g=)fk7Y z!i0`VOewmpV+*D=%qVLa4OtD2z}md@W^GFjdG4$|Eib>G%$znoTb-lJgg<5H z1@@JL55W+FvYsAP(1wS4LeC;h^rO=9=LGHWV;>C-XVi$rJka71%=_ z!qJb-Su*F_6w%-^0&?-(V-_Z-e1XIFjJ1E-oHf%K)0s?Nm6|o??Ny{uKL=DSw z2-HkUe>lc{ta%0CQOZ`}h+RwB&a68VjXfDAsEGIIg*t7CvPI{(_ zNE{j!Coe7-fi*Tu%bPGQIcR48V_?MhY-f@ZT2$-;sjT#;+;M@%5_?`~j|Hh{xN^+iWxhXm@1w_y{MU4<1Tu&Kzk7^E=P0=tT& zmAa9POW-a$`q@+GJ=>Q@obldFAwMOszqI2QYkX-@=b z#8Z%SHOH~w2Q5D8ad2=EG^_5aV^Q>#Pm>L_QjA1APj;52^=_Mz{X~swE^vJ^Ql$<@ zs!FxTi`hfL4R=11pqv_#ZrOJFaGtu1;IsjrR| z1-qq4kKirUQVO`dW{69v3vqD2lw*jUJ6IZp=(f~MTnR-mv20Tq_T`#xanWk|LO#z? zAaGzALoF*z!FX4d_Rf6Xms!?_Tj2JMRwfI6C@dgPnpwIXR$2KqcTP}c8UEF3C`GcE zc=bnT!n892JDB6u9P7e1{(0NNe~khaYP#|(iG&(5JU8()&3A(DjjioBAO_nyZlR(A zXWDL|QsB&wq*PD`P#En2EjD~A@E z7y_MgDas#jTR?K4^%taQQX3SViH-$S@v@pfeE~I{iOq=)ej5u|)0y0yyouWD>b-#a zpRm4u!vY#^V&iqHTgM%=A8Vs`UG!c@iV9jQbUt@7L7O$9oWq^`rGd?pp-*xBQFjA7+K!&7)12kC4rpPkgF&>Wz?Lk!jvl-UCD z53iFNx-~qh;jo4y8l{9rgM$0$SQr;{Q%MB{^wt}=ueI%0q>6b@kq6iiz}pyd#ZdI1 vqD0+M)>AKOP2^NCR5tb2w)Q`;X#ty;*JT8H^+;D~zK&D6f}!XO-cSDv$mE5~ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer$1.class b/version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer$1.class new file mode 100644 index 0000000000000000000000000000000000000000..9fc32557665e4363f88cdd320d52c6252730e738 GIT binary patch literal 1102 zcmbtT-)|B@5dO9to?K5s)cT|Ts0w<3@oeLZLhymKNfV@rn7%K^3R|zc&E7%Oze*pB z#s~iZ|0v_^L4c?aroH55cfOtZW_D)w=dbTS06fFv0vz1&kjGsQTe#=qzKaJgDh%h+ zu}msY8Cu;FZql8wFU(Y!P>D4CFq8XArjp0dcE^*QL+3o!WmN(s}6d6EcH+h<6kvQ77KjYxDn zrKr`Qd&H+ajJXurlH^6QiVGw+ zW>&a}5@}?gu`#l^gfem&*K^V=SHAHLxlgoN!;&Ugp~)|3^0Aaow{ROp+S$Y%TIu@@AL1w+ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer.class b/version1/target/classes/part2/Server/netty/nettyInitializer/NettyServerInitializer.class new file mode 100644 index 0000000000000000000000000000000000000000..7527f69c0a75a12c1b907cfe8fdb882003b339e8 GIT binary patch literal 2026 zcmbtVTTc@~6#k}L8M<8*@P5C6mR4N_?^I9=)oMXvji&Kw*iK+^-8Q=mQ4`~X{vi{! zQKRwMpWu%X&uo`cXd5v$=}hNbzVn^SOn?6V@*TiMJV;^}Opfy$7dS?>H><0wIy8(W zNqLFmvW{L{;kc?p$2E@Y9OF9rkkw(}2FFAKdoZb^A2)UERTj5&lHBIVaZE871=p2c z&Jn&ZeTE&r^j2(3&Uw`pyCOY?)5V(bf>E-I;Cb}_eQDwI^k_^2yyCxmt$8e(EDN1H8 zvLSeV`h_KHfn9Zdj%kLTtSZk$SeUIW@6dD9_@*c{WqXZfN;Gjq1<^6?jH1vkd1u0Ik(B?9jux zTw~g!q8r$c1Il@XVYr#JMLu**JKjhG2XTnudWT3M@s?@oa=RE#wnd6Yp~abD=XztC zw}oLSHPSw$k$cMp>rEBZN8OTR-J-3TGjLI<6onr!-XP4$|7X^5*H()lo*ej!N` z;9cf37{kn&_&3DL+E-}h!EGAXcpW{Z&)_jUX{vh5Bu#9V>g76;n}tUCEBeamI=0ub zW3#fqoc@4;ItC-fd*Ttp5n7Lc(|Ul`LpXt>xJv5`hOvY*c#E?n0gg3z(|(*zlmXeC zq&zuZ(~C1qNT)~|C&_90(umWlGM*q!jCP$^?M!DrVqiUP57_{_L;O7rt0ul4){pg1 xQT5WKQ&?jWRwAAGfnA@lyEBv#!X_f9by^xS1QMg9&W8Ir?4w;L>pt4)^9QtwG)n*g literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/provider/ServiceProvider.class b/version1/target/classes/part2/Server/provider/ServiceProvider.class new file mode 100644 index 0000000000000000000000000000000000000000..2e22d589c487db712f09c887294f20f7d97392bb GIT binary patch literal 1474 zcma)6+fEZv6kVsC_LO#@Tv`+r1raDkC?X(G1Oz3T0GiZbj88)uVX%~DIwg^3zr+_` zHBpF~@B#jWPyT~X;yN?a3*duEbEbRmwJ&S!GxOumw-W#pScxKr5sA?#0vKsR6dC0i zi{cK()p0jQ)TBD5B<@K}3$$59$FyG?dGndQe_(Bywm^J!*EldT6~`)M){IhCpebi< z7Y(Okn*x((qjR2FFpArmoMT(X?QDbR>E^DPce3-W5uUS(mNPF9Obu-aXv_OstQKFj zispJ{Z_~7&8=D1s+E@4UMq$ISEoJ*o&DpWa0)wk1!*<3qInzEc?M%rZ*|n`Y1$MjS z#}ty0CsmdL$<)R9)Igzp!8kmmA`Ri?f>AEBnk;)|)O4;kE?u9TK+F%X8+$H+I>c8* zpt+{A4|>&5sM@CUEcLggD*eQH@LXC+n!HfN^Ec-lBmai0bJg=!Eiog}BM{v-9bXiI zfkrL-S%(^W)fh%|`xQHHu2^bA2|vGjV@4HU9j$1idiAUG*eLIC1|2$@b<83wF{k4` z=5;J!QR0D)B`oWBh(`kb|Fu|w*1ERdaA#Z|1%U`jx}pknq#6lTm5$fT_&CWFZ#9WC z8TAbkP`gIFi-cW}pF3%;3qbO`?WKw%Fx@D$uj)me8z-$vA7tNioAP7-fTNdheT-iN z!A}5n=d*=Y0C5EQpDW_oPS28S1Fh*}i1c>^ULGU(1==SU-NCbk2z6@AjWaVrOJ_E7 zkVGe+e9LgzulI}S2z`sgM+hAuyyiXS`pB%-rJYQLf>YsSI2n46o-QpJ9-o!z&(OLg zp~GJh3F5`Ou=sHLQ}x%N`d>kqX9ue$*s&8s>^8&a0wZdc354itMHg*Jd(odt{kw{5 zoGXH9bmKY#M2+DFdN^Y*k)8B-nKzl~#rhb##aK52r%aa;{SpHbgAytJ1bP2PABzql s?NeT0nE+E_iU~UO+)WB1p=5*8$;)D^W^*oY-sd^*?Y!ZSf1dpcU;w6s z!5A2Z8Ze9-^|%?s2yRJuJ%%WT_;6do9X^jrc%uPlFcw22#<^sI50j0U!kc_}s}U(o zbFvu;cVjq(*%;a}B;joda}v@F&93gO8=5}r*y~1CcNi|G@~Y$YD`|S6J4!xyA@&uD z!weDEBTa^IVybt6rcpbq6JyG-^qIn1MtA1bj7gGs%GOkKL3Iqi4}{`i-MM4ip6fYk zp5ao;uoX-9yiFyuFAc0HY0;@oT28er-5f7?1&7!#lwrXeWwcU*AWW#OsOzd?s@AeH zWqG>e6!M;)9s5Mn^PXW_q!#vahRe`b9RMC6ii5G1H1_^CC)FH{O7Lh$Zy1*0jW8q=)%G5lFpi3)?SiA};|9-5+aY(Z@fb1mloGKY(VC{qco_o{ z-jT6@MTRpXcYl5R)!w7;{{HdF-ZxM79{up=vj-C1m9d2P7`jWmMs&4TTwe3d zXJ{=$=5vm{;orFmqV%Tg>1$Lsc7f6ne`VM-~W~Dg`ycFj#5SsHwW{a7~We8Qx%x#sQ_@yvUdHhYGz) zgJ1ehOQWlk_#b3vk5Qtt+K)Pmp;0q!SKn``aW_}+vi62GK|#~+7ff@L`%_^-!81%n zvn{RQIMmIQl0VI&U_=v}=U{Zv2dbUEKpphd@e4*Dxe%?-;v9|V0rmyLkVyJ?7i?)8 zb<@E-^Akexa1oJRL`g0Ug*(E1SBt2RHxv>39noDhE+v14yp5(JPAqnWJBw)EK?^m3 zNJnG`CmD7S=L3lr`-*5?BzWuM_vqnVMVzjb#fPHhZAbLCr({+;?$ISaCFU(MaTN~u zyoJxj9K!RonnY(hb1UX!gczA<`>fv`cDw-CHmJxQE5ATK$Z%3HwE0>k%VVM}=o5-p#fh)|2WRJT#sB~S literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/server/impl/SimpleRPCRPCServer.class b/version1/target/classes/part2/Server/server/impl/SimpleRPCRPCServer.class new file mode 100644 index 0000000000000000000000000000000000000000..8c1adcc23e6f7cd2476191ec04e4c9b71d7f9418 GIT binary patch literal 1396 zcmb7ETTc@~6#k|_m#&LQ6;KfsFW8pLdaE}OF9?d3ODNIsxU3skX?Hi<1@#a3U}EB{ zi7!6Mo53heB=Ob6-(md~M*U{DN~`$bb~`(B&Ue0ZnKSeG`-hJJ&SFx*pb7y!fs;7Z zjMFO4;H;En6`WIWK7n1hprRQURVcV5ham;SDq3(^MH@yGTv2dU!8L)MCCgv6O>4$? zSMB?jz=@n^_`zvCPr2pmUL^O!^%l+_5@;#~L<%&fCenBL8Fi(7YtDA8sg>e_<!6{+b}Vu!1V+gQZn!Ou}g&4^I?~X&A>%4Y$Bdc7-$r!&%hlmVC>& zFL1POo2zAc==#h0Jq{5{!*1-6&Th-$j)r!m1$KvI_4U?}Lt28U@7s>~9|f-qZF=E> zWwQ3&+Y!uqX0%6jCi%yuz$$Vp+!Y#bwZe>VJ3&5RszvVU?}%%}0*WU=1&4O2sE5J= z(aLrfhr+EjOxaH)NTq9f@K>7-Rn2O8_dhzIv)1YCisQ)B5xQ*+0}GpP&Noa8Jv`8D zJl{$FV{%V;4>WMzjt-8UTzx_ujr?XeA?CZvh)uplL$YxLP5m2)Pi;b(-$e8LK;|71 zWvFHB*nsx>M`e=go$Dk4bpBdMyO;ALyga~J0{iH=i*62}AKgS8lo)9hRXg5J=%7AdRrJb&n`8jcVxU8|WgS~Gp`k@%A#88R>kiTWL&8rGJP JFj?tw;3rtMPDTI# literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/server/impl/ThreadPoolRPCRPCServer.class b/version1/target/classes/part2/Server/server/impl/ThreadPoolRPCRPCServer.class new file mode 100644 index 0000000000000000000000000000000000000000..3ef15efbb0d71b14aa8cecf21c86ce52bce9781b GIT binary patch literal 2536 zcmcguTT>fV9RDo@mV`xa1;i4u6eWa9N~LNGR)JC*-a>+ry3%`x-ZPtdDl&A=$+m$x6DK?u+s_4b*!B43nxe{ z7DXnvg_R3je?&ulR`^@CCFXs1%U%_}hMsB9^n;6u6dA%#cm;;Kmk3g~denC8;Hrjr z?36maOBzBG?y4a0wC#x5TxLc1i{?t2l%{FdGSf?@Z_9gu7z)S+vol`0 zB&>z`3I68&rhDFLy-FshPRN*@5w{rP$nos)v}F3J2?Wdrsu(-}+3 zYju_d61+F&qi{r!NGTEnF!D{5ziVhK5mDV$6x0}DOP*`HiR9emwk5p4b{!fCd9K8( zO9iI2Ib(XNYdN`UH1Cj~4O~w{WlXvgNx3=S64!0n?Prh1v9xao<>(sd#5gDMlw+*p zGXo}83|LszAq;$ufs@q7eBazDYY~ZdNgitk&Z5IW6ff&oH(+CfQ~BHduMh4$`2G8b z2j4tAxcA+!Pw(p3G>}GyX;B`kw3g(|fCE><`LaDy7+KlAiQ7E#;Y(Q0z!%`+X;#L{ zQ*0nBGm$vX)W1x>h6ZI!we8%>hOk(q=y66CJS)F2*d#|P?DRm*W@JqS#Y;=9uvrhM zLCUZRnprYCEhmFp)DqdO>vLtX<{ba1GWw5ITo`B#dTMfFZuVMALo)W??V*zBQ#;u} zuvC?9jyX8$<9Xk9f>gj)BO^mN%zX)&&UsQO?NBdPvInTet)~`VwQ0#=pn=2Ol+D;k zL9K*XzQ|8}UF5vzLcLQQmbOy(;u?}N^~yyxev7_o37q3Y+71mb@uh5%{me(VLbf#j zhDh(kD?HEfmO(8!z(9NtT6`ZB%Ri!W7oo<=XJ=6L82UbHmK#?05Z*)N32NhgPhdP! z=DK(`(HsaBB2*7y`U!HLl-9gabmLXtXkLMH%@g`H@+9;Fg!%jf(IRw5v^CUT-LC%) zsuD*~U4-gJ8_jmmkc7GcT^cDuMGH`p)`OUGB#K^sRVukS`jpdAIy-=BMH@tdRxa?{ zpo>y-5JRL~;)a~umn2ZC3g(tg@F1f cCxh0G%37@mmlb$EBYbF8DK$(`v;x=u0vDj22LJ#7 literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/Server/server/work/WorkThread.class b/version1/target/classes/part2/Server/server/work/WorkThread.class new file mode 100644 index 0000000000000000000000000000000000000000..99c3e6c4a15833065428e9ec55ee0bfd29e1a6ac GIT binary patch literal 3143 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 literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/Message/RpcRequest.class b/version1/target/classes/part2/common/Message/RpcRequest.class new file mode 100644 index 0000000000000000000000000000000000000000..cb983fd23ab039783faa7586a72dd37d998e3f6d GIT binary patch literal 3426 zcmb_dTXz#x6#h;!lcediDWSJil!8^#v?YMxr56;CLa`TYD+*O)nhtFsO+qq3K}CJz zH~0hOg$G^B7MHB$(idFIALNsW-=3KylQakqcBSX+bI#spe`oJ+@A>neUw#E}6yHX% z2PRoopN4TIiV#-9Fr!?r%8(K5HIXbCu12wr4Uw{Pa7~ui!^lMu$4Ug7 zGUp>GL{OBY8xfQuD9f%LMkS1!3cD7InMLbH#VXq;E7{zdRZ=i!@_DOtDrc6>|1Zl&wNCE(uK27A8VyJO*hdw@hn-Vk1`=JHr__*u|~>L@)55Ny}FWzRI` zy_;9H$b1Ji=X}X;fe`l7LtH^{O=JYq9MnzpK0hUQdfCN-R34 z+JKMiD!$&N->nC)YUBsl)1X)c4 zt)Zss+wB}S@5UTee+_oIdj74BCELtgpEHXN@7Pz^1Qa3}Gk;p3Qrs}h8!r8W$>A9V z{ruw0+-X9k94cAmO3qg3Y3vLmz(3c98QpTFjO8La)78yzG(wnQp?jc*(UcSHD31vPBo zBOGJh)t$P0Q0R8HvW4`L#nzL{-ges&GemZ~`V~8yOP?r}%vf zu~wufAq_D+Tcbeh;t(d7#iEs8Qy6PiayxoNy{R}3mTUAl&< zjVFR>keK8z@(`hm4-o!=vT8t}gsz@;nzQ)TQ$HafssW#B+yU#l)IG3D7~aA-*lgV0 z(wLRe!dPoI?rmwzO7a5lhpjgo_qQ;1BQ-(albG@l$Ym0%kdrydl>hOa&Mm#JMlDkz zFH;J~Ti+9W-g|^+68pFDPAfdx^WGyYk$X zcHM(9me97*Uez$hb*dQSp@c3vp+|_{Lq|eSgnUXJRO$E`omHb4*RkqayH70sDs$g> z*2P%M-Ca!M3}4WLGS0H{0*u@mX1Et*MPJ4_N*e!9;608y<}krno?+$A@&5g24@dq+ zXBhL3(Hq7Be-ZT<{jS)iVli6tYv9I+ZC^QA&?Ptm@M+|#Ru+qpumqrz&xLo*U$m1J zv)nZ?sZBWn-P1L(!Ei>pM(!azwvDbUvTuxQa*)uxlZXVFN3zLd25(nw!N|#?b=chI zwCsf~NGwZOCK??J_<&LXQHJUQkp}s3J&X@2X-Hsb}8M}nNoTKy};>Y48wEYX#cDJ4Y literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/Message/RpcResponse$RpcResponseBuilder.class b/version1/target/classes/part2/common/Message/RpcResponse$RpcResponseBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..eaa4c0500e362b83d22b3aa9d2f159dd21c322f1 GIT binary patch literal 1588 zcmb_cZBNrs6n^gBI%?&m3{XLxirS5rDhx$o^M%A@$4t!lkw{1>c&%hBtTq^d7|8lgsH8xSGWzH%Z#f5U z!+dA4P@^##7dcqLP25s2j+}xCOe&bd4T1b1IXG=yVCwIBrvk_IT8tHq0yG}avVt-y zyu1>S=kw8=mT6??^E{P7z-yY~f`Z4;1eOQ&6)$_*%jj8`p*RAXR_)~~wsRsP4SmLF zw@sTAS?D`4XV{?*QB{&=hKKXw<8yE)^)8IZJ$emPdMA=duv+9LSg^p7W@Iz;k(dye zCQm0T$fk>3i0|YiFhgr5*c`@f@|7?EcL*HhkK;bAoV-TS39?dg`Ur{QH*$N^C&Q2^ zoq~hDxatHR^Z?BrA$e&az8C{dVYVMo>e4{W3LSzso*_-SQ<`WJBdpKF0ArPoA?^WJ^M{yyFyod`?6l5*HxPD#NW zFBF{8zPw#7J7oneTby+i)VPAN;FQbu98cE7dHa%`$=ijw%ygxcE6k11a@MZc%XLR) z&O6x(bw;@=aKzi53i$f^zKKP5F>*|9_%uU067uoV%5%*o~8yT*-u3Uy;zxdJ5HGFU23jY_quV8xoWSu z;-1bsv`$y-?1f2t(XBbBgMF?Y+;x z`18uOzpq^V>*h@py{MYV;F37JAjcQQ>t%&)PwM(6jiAu;Brg*a*lXfdY&Wq3J59VH z$6XjUF^TO8T`L=9Y4qCziKb-kM@@W)k7W6noDB5%H5z3L4D<+TuEAxNv(Lm7c9N?G zxYrKsP4_BS%uG8R(R}W*H?}+3a8I0_CJb;C#)ExX@4BbN(%sQqfm!eMr^Muda!Mlh z;-XWSRTvD0y9C`J%DZYzdbcq1c=a;4rR*PPkB$61JO_p65k^Q_kRPFtbfLSm5xKV^ zh7|f}mF8)Ldd0o{N2qrEUPCBdL%0U*JJ+S3Ys59^!T@E{GnSs_DTYC8_JPs_k{?Te z)IS8W^co^Ql0pM%J*_g>;`^PZpT?Vx^lcdF4Yv?Y58Og5J$MW8?|B~zc(%DQq&<7Q zg00lk(@j*8=x|e&I6B-2!;FyA>p!W-k1%=%EhlcnlnjG$weiG3@~t!61yfJ|fanbh z!9dyrWaxe%N(Qirb8ID(R#RurY!m1BO6QKI&Li0EI}bBXAt2&Xxst$E*L$sJu|#0R zCs1J&dmh2*XEj!fBb_F+y@uDD;XG2%$HgPGDN)e0`ew_BohQclUx>WyeO`BQmpbc0#LD&z z(pqm%nlc)XR(=|MnEM3L2{V=$*{zLsCr0Llz_X(+b8;ka(M11s7=txD%nUPH?l< pd$Lu-2CJKL4bQF|M~`XmtvKZ87{WBsLvE#kIG@$R*K!YH{{vLR literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/pojo/User$UserBuilder.class b/version1/target/classes/part2/common/pojo/User$UserBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..76e3c451beb542438bab47b85169edaef315c77f GIT binary patch literal 1467 zcma)6+iuf95IyT$oTP@NsY$sLN`NH27)pSaw0&qLq)JhFC{*eTl9Q~0Bgc*$2k}`T zl~$q>AHYW;W@0CGX+U}K&g|^WnVB=Y{`LFEPXIOSWH66v8aXWUvck)%inR<9FjPFt zKt(l$=PcKGd67abg_kM3;@xW%8!9#h6ss+;(CC_wjBvht6XI`Q>u#uIt*;bm%O(WjU6=Lr&$&kwARUZ4*qkVL9?(*lSAfz1g%! zz;4U5k4(?veQ1pPpR9qv+y~0PJGAV!^aQkh$C2KiZ4L&K4oi)`>G|tM%kA}C$LPCV z*I@rrB#7$REJrFIw^o@gb|V@ac0FV0rL<#KW{gcVxn+Ud<$ne6YfUF3h)?8=reP>;@LJlCrm$GAT(ATqkdZY-)A+JCy2IQm=*= z0+%qHoJVzWRvk;zfMPQPabpZrz@uqE@tJ{`83rohaR{_SKQ-n>KS$!YdP3cuAVy#O z49V$z1~lmtn&`5HSRaW2#;Tn|Jw8J!pFTx~F;6j<*8)98B7ZH=<7~f9`YE#i%T)_= UDJYMauiyd64CTsE_4kqf0}q@xBLDyZ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/pojo/User.class b/version1/target/classes/part2/common/pojo/User.class new file mode 100644 index 0000000000000000000000000000000000000000..c59ad76e871c8288e82107f6b3db18e655dffb52 GIT binary patch literal 2753 zcma)8?Q&C96kR8|UrBCh3H>07TCrlAv_ugFQ;GMW|VVHCF-DmB6)>&tto&NRDufG8}iESI7q@l2! zf`t_suF9}#V=c}3QyD%>V+_~Cx-P@#@_EC?7ikP&*}+Yjzm(yY1JA*_gR*>W2yWSi zZ{sV4%xc50pKk?~4Zp77&R45`{X)fSH2j7_BG^zkw6N`c>lG_rb+b5MZTg#jeOAF~ zF>cA*@fET$z)G_oR5!VvZ1}gkW6#%W72m6J&0cTscWiQMVb`lSPZZ0wot;{>xLez< z6@}77j2A3S&lGMKc3lzTG^|tdG$c>QIOHx z3V6K3PuZLMWtdhN=o1ciCEq`zMbL^IvwQQ-LCuCHH#*se+teDjA)vF(NE{aJA}EWf zaG$O`?QKGY|4qxQ@JL-LF0XI<<>u_vbp=)HzNcu3`qi3Sa`U!GG9mZvgdS~%&hREv z+8f#fp}Vy&&jG#GaSW_9z4F(K-fpNjYnIi<#AUB~QFzka@)}$EN|TdQ^Q3WQd4BOC zdD6D(exp@svW7wu#)Kv?(aG;LYg!(H&ji(=d6wWw5n?tjVY^ym;zz2+JaHM*E45a= z>|Y9`vQn!&;Bl!bg`@vpq%Ib)=;C=Caq$9Pbnz0#6-N69x;T%wT)c{7E+0FsY0S9D zqu}BK-d7mwl(J^L|3V#MH5qKox!A;(3<1k%db};p93`0^r(!hJl#7p1P#Ef@(-*HW z9J+#9amDA;s082Z=VW=iyMC2bFcTNDU5hc;pM5+WMA zUP5#WXG+I;04d^*67>qd#k#xEg>-Oz}&J`W$NGj0c$zzf{Esk= zdxbw>{Qxt0ukbsp#p(PW?C_I@voy`2WX$}DOwM?OgLmQ1>M;&$GZi(c$W8f^%mk*$C+weA9OgcIlbnUUlD?wTsN;;Y7`-|)d&Zax zB|kDWyG6mBp~79*Gkb7vi9cO3WFconD~?=)UdoiraEUh%201x1TsqQU)U$fSh*lEI zxJbd+_HiYYE`c;V)rX{- zfHubHc118N2J0Yuy#$jco2b?fH>sWUm6H!Kz%FzkJGh4-k#G+OvsrCtIAsrMJ1zcU z+Itx3Z3epDbQ?MuNu%UfB-*Rf!yaI?_w5}FdqHmxTfkBje1k*{5*^MnIP50*>H9G9 xGxzbIcbpA#~^mdYEJUp0!Jz-4|Vcze%rmOoVavx6K`{{m*o=wko? literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/service/Impl/UserServiceImpl.class b/version1/target/classes/part2/common/service/Impl/UserServiceImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..9ed2ee720bdf9012a29e2a6ce6d6c633af20f957 GIT binary patch literal 1965 zcma)7TW=dh6#gc5vd(&FTIWijr70!YNz;Y4(3X^zCLv&OlTs&vgzMU#x*OKJ)_NVa z?|>>K1VZrAmr9W;AtAMehfUN<`~ZFjarhO8GrPWRaA+U)%$}J!-}%mEX8!!=(H{WL zpsZpPS}$I~s|rr3h(L?sv>eY!@mdV8%kiv=b2zWy4Ha={DyDHk#hbV&1+87eTT)z> zt1~KQF(=ixrI?T59l8HqDbfnwQ}Dim3`5Ta!!q2943T7Ng&{g?7X(9J#<0XfwUiUi zlAbeZCXuo8y1Ak|hSckmQTK*XVVKO6b;muW9zpgwSP>QGW*;3dhl{f?bk) zeaNb7nA$aejtrw!^2jitli$){q;fZ?!CVsZ2tA=8;+~^K#FS&y}Nh5 z+WqMl+QE^?+v~2AMZ(?J6bArL+mXM8)mV%VlBhZKois)J^*&nhZnj7cl(a z{V~@LP^rYp{{j(;4D;n;8*2&}x$9<@6kb8l0OzNi?GJPmi1y$26^qv?>B+VBBGz|M#F2`) z$q*vbSbWMfcl%{y7~Qun2mm zXk;{YPi%qxMn7G6fn<+A*@vU_&w~vFa*Q;F7jc}VG~OhzD2?;Kqw6sut6PXBx;^wv zdQcKE`ti`~L4AxkE%7VccxD?1JoI@uNLvn_@Q~O>zlQ-2g9}p+2`TVCO8$Wa`53@B z25}lgIE!J-VZ>)N5qPaLBL8$JjT5JFT74NwLYbp4g$X~{Nt~$jT_wGXkjL8i4h4LN tn{0{MNQ;W<8yu#L9r0Zc1prOgW4;@DTrlO+KZ%cNRLS8bdNSA0`!AQV3l#tW literal 0 HcmV?d00001 diff --git a/version1/target/classes/part2/common/service/UserService.class b/version1/target/classes/part2/common/service/UserService.class new file mode 100644 index 0000000000000000000000000000000000000000..51f12d341ed0302d147c7556d325f3d996a21004 GIT binary patch literal 269 zcmZ`!K?=e^44i1SS_OTAM|;o(@z$FMp-}K3K47h(w6xu_)`DO2-~)V=xLX7f^pb?h z%w+O--tGX_7`Yg_@CcKH>%*D#=4xwrA}r=nCL1YoStcSZYfe}PepE?auSBehLY1OY znG#kI5XNa~hSuaQ|3meE_!7Lmy6Bj=(wLVv1!4B(X4ZDs-hT6p>XUbO c%s8(51VYC=3UnMo7Y<;04}F6WT#IAy0;sc0Jpcdz literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Client/TestClient.class b/version1/target/classes/part3/Client/TestClient.class new file mode 100644 index 0000000000000000000000000000000000000000..72e4294715e29f001951f506b5d216d4b535befc GIT binary patch literal 2032 zcma)7+jA3D9R5z4bdz+YCG<)KYXwZ9B?_p}Le)mmXlSdwD4^mdIfSjrZrp5Y>$A={ z&Uk%s#_`1mpM3E05WvnbKKpkVc=r!*{LXGdHnAN@X3q6@`M&S`&e^~I{o@XRGpNQf zj#C;=#}QKf8Pz`%$Fq2@4`G~*;T&c)%*7GIsVL5?{z4q{cwUXzynq+gbRmv3UW(#n z)nAO`6}+lO8P&X|BE23(R=Hf#u&7~4p!d9KneMzmPjYHqAe^=fQlLL;T5_>g&Piw0 z$d$N~$l7_Mv~D=2nl~52?hUglFqW+tj(a+lE}7DDQ>(J-`olQ}EE}dJFr2)a-7q$d zRLQW4sTJ2Tt>T=Q&~S!z^Y35~Wje`|`tf1966&UTbt=Jp3XGjZC69}0F!V7@USgtHehuiTLyXNHOMNx3AQ6n}gJFUB^ij zSq&d;ZRxlHQ^STz{DF=V$~r9AIx6^3V7&45H}@0V{p#Dsr$4FaOkx&P24WcL;NI3p zV4#hADYqf>u0XUXUGEqLjwSMB%&w8dkPp+eQ_HMymvt_UGLiNgm5Q{w zGqtWkfSbS6JViPVcT~sy+N4~r?b`|rCWAbiL0Pk&I-O9cPelPM@k$N_Nw=Wz3D9z_ z8tU^@YR&YFWl6_74#^vPj9GUFcO>9O3X>1E5;zwG^Pm&xN)WB_7#EE)FX7o>m=>pp zgBd8M1=}u3!+W)^1f^}RlT%MsZgqifZ9b$b5l>~_(>-Nm8r`%=%`4VsneMJ-$MtBb z*HzZdTNC8t3)Ct$JdT6>3aMWRLcLyW4|A4cFW5(p--P(h+kT8~ueZ1l6CCTl0Ygl3 z7Q+)b!WHHG4|-?`e7u9u<(ufqo=Al2i2RB0rRnf3^xlRR!s73U?jXkfc%rWkeWs2_ z*wwMGj{aL17%0%Pj{S*59S7(&SjSKu!?WS(vG8q-gfJTkL>Q&(Sfq|I-@lD`5>X-< zV4L87kOYVLT^-?*I*Mx;!!`w&pvAn87)No8vnU)qi6r?X_#jTb|Y z8M?eMonicB3LwBhHwUmMf+m(1r zom|IR^e`myFSB(KX_(jX7z-Mn=vc&(hNn8RSk|zjV-?SItYKZla~&Hhbu^Iw-$kio z0OuKQ{?nK+q}zt#n3gc~H}A2b4u;_dNSj6(wD;Wh#nu~!nN-Uq7f8oWX>PK4CvCZ; zx$6z&`i=c@W{D+?)5N4&Fn`M;#G$_-(vOMLa52obNUpu67Vx7%!X9j39}UqkR|U<> zKx+e9MA~86t{Q^zV@hB3m57O?2kxd{HxL6;@}qYz zSq80)){d#qV4vtCf5cV;B!h%##&Wd(#K#qH@lJl?2B;TZ;`*-UTFxK~*st>~B<| yH>%Kam1>PNnR=J0851E>hVm3sd}=!V9q|Jsj%#N;#BWv|!F9@x;098)b@CUT=J4VG literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer$1.class b/version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer$1.class new file mode 100644 index 0000000000000000000000000000000000000000..15ceae66cceee21520a111deb6da717458874035 GIT binary patch literal 1102 zcmbtT-ER^>5dSS4o?K6%sP&_Mw3g}t#AsRi@>qTpN!YXMsmYSMNjNP@W^INS!C8Q62MkU} z4+TT1E0yR?js_xm!v`^GDqS7%_<$$U$}^>7AHd-6D!da!oEqQ8Z~Q6sw^gX6eAnF$B(j1|8imQcHc+h*hsBX7u)2}mm|f^ zBq4|3e}c5?ZHnXd^(2YJp0p)d|93+k+VE7uT@}STrHo$+GuA^F_k7$(;KRjvA4Sw$ z)O|Eiq5hw~{nZ_Y^5Vg-28SXt43DLrjnSB^VNBB#QDdVp71Tf)CvHnY^F~#BJuP;^ zu(80&ZhG46>4_T7Ysc{X^qDfO*fH%;LQ2F8^`JXXGMXyGR7dZG3H#YGvuxVA%md=`)g_q19HxLvxJ+(W$l9TE4OcV2 YYXo^c<8EL*ySs^7C=q89cj%<=H$KTH5dZ)H literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer.class b/version1/target/classes/part3/Client/netty/nettyInitializer/NettyClientInitializer.class new file mode 100644 index 0000000000000000000000000000000000000000..322f0e7ba0fb96dafb1c062191a1878b0c60991a GIT binary patch literal 1876 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 literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Client/serviceCenter/ServiceCenter.class b/version1/target/classes/part3/Client/serviceCenter/ServiceCenter.class new file mode 100644 index 0000000000000000000000000000000000000000..0cace88dd894e1cdc6d6616d19b66dd7e7f483bb GIT binary patch literal 212 zcmY+8K?=e!6h!B1ZPk@{in=j^?z)nSAP6pUf|!0vYH1~n1+V7919&JgrGmH_hT$y)=%exwF?P^f&UFq NKo}zE97bLT2tWL<3c!c%03Jq9A$kMo!y|s+!fr9^7sI169xKFvm>v?t;UWa^crl*9lSMd!qlM4{ z7(`S^hGgggl%cZ_!{Rw2hS6deI3{DP7?p_07!S}uT!tAyH4*`=##4o`#M2h)P5@O% z%9se?I8F%hq>Pg?o|aG$jTw5}k)XDl)`+SlwCJd=Mw6E2n3g(hY2*5F(;8F5o}_JB zuw6n?Pghspk?z*M0}_Jm$FvDejcM@_wb!wX_y`r|h0VC_XmO`sizRjXYBA!5vr~dU zRNF5hFKiA`x}e>N>z&E*LEY-p24j>2+s&vJ>(?wptkc3gXVkDIG_)r)%h{lYUD&Fv zTN6f94>JVaQV$*Mow+82f`l0}qLUJ8a)sBUJJw{kt3ln8w6VR09W^I(i@O>_x5icL ziQ>AWMmY4E(J|d=9U8K9+ol!ScEcys5>GMd7%{coupI%%dnrL;n2ToE-ghFZCmh3! zQ>i$Oqm$fAD4$KnWMZ0-RddX@%rKWu!A@G6*XwA}u?{Wa^2idAP&z``9#LuB*+_GT zm5zB%dIe71%9yC~0OYnHL1E%-J)qXfqP|?T`aul#7GOX@9kuc*d5krgZAsOcIu$y_Y?-?1-DtHbrN|@i&ym@^ie@)w( zo3=E`cuB#_ctydhcum3UI3=O(zZai`{Eo? zF~KKIb4=G0x>a-Y_lq~qUcPba+~21!$#_S>yLeB*`}jaY#oY6?Cuzinbc>~=D) z^4;u8Xu8)Fl8<%w#3z06DzjL-GtbbZ?dapY&&X${pBtvy%?nT@Q`g4n$U9uK#VpK( zP>RL5FITo%@x^S@;ZdG)OQ+W6yM?GF40V5YN47W%v_wLW4>96gj&5nW*^PycIbD%u z^q%bz>FY(phC6bY8xcbvHmz>W8I`c+E{ME-K@R=oLNLX8&BDmMUEp%*UUYqyTNr}7 z1E%eGcc{!&w<(gxFOP_Xs@ZnDaI$gd+liP#<+Zuc<-DUxv!EjU5*ZPFxzN4uxV%k< ziK9G+12#LX;MZIT5^DJ!=@YjGKQAlMfOV9u=iG;4X{yNbMEehLLaIfcUd6pDhyDJUt-`vvpse#ZQ3SRmmilmtst2>$3AZ{}DH znPUabEnIzT!lGb#3Khgtk;39@SmMJUsO)I)U&B%{t?H~>H-%+aIvP?~E?uE9(8(qO$%BAb zi2{ym`6XLR4(j-(o~|3Po%{%B8!bMelnZ*W#d zpUe2n(pQ~9QH?h2r+uHelQVwu-JOf;h3Qot*Rgt_!Qb4F*L)Rgrm!~aLHy?ciI=%o mSg-N+Wvnko#EnrVD-YoywS8!J@pa$@J_GdF$GDuO=-t+c6=bU?g|M~d~z$+Z7Na4AHT@@iI_u?q2h~R}>$_iep zh@+B36*UEQ1^W!KH>PDeZyCbX+9gBe#J=JT>8@$<-h49T;zA#eNt5l`hCaU3g(>&G zGU9wTXAFhzR2R;X*5_iug?7Pbj`w>^2`9Q~F>F;ocCYn?u8nnTr1c$PTBBnZP!}Ug zvH2e}LvlXjLZ&heqOj+~81`ghTN;_9Ui+~2A-uG&J`?uByyAkP5@a{^4K7=Xzj374 zgqRuG(Enxo0Q` zns^^gV%a`?-8!JREkPP7G|^(H2cmttrUdG7$N6%8c0!+5oD9t1qfksjn#CR>4^b0mv+LY0)D;wiQfCharw31R0iN<{sM literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/netty/handler/NettyRPCServerHandler.class b/version1/target/classes/part3/Server/netty/handler/NettyRPCServerHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..2d7b34d4091cae58b2e7ac61f6cf783733383976 GIT binary patch literal 3318 zcmbVOS$h*z7=BMlGVL&wvdW@Tkflvqf`BM3AXv6)TS{9&#ceu0G((e_FqxEA+;3AM5sIN0RUc^f}UdAgLUe#b~7}H^4s0rhc zjX0}g0$D}3b*#rZ4U@`RPD5UUBe1k6y(!z0L!LWjk4sNrTYtgy{9Tz55~PvbJpPWwHP1G)0QmwHbpeJjDW11d(F~B))zQ<-&p(4nNwyaXF3y^(X8iQP!S8Fo3zZ5LbPg5 z4uQoJ(jSg-A8DHhc$BhvIAYgQwln2U205$(J27@nT0R{YB(&Aw8J1^rq}WsPL_vC{ zibxz96(=t)7=a}=OUpZJT5{0L|Hr_H@7c}-CA6s61yXtGXWemubv5?9&>jm?(a67K z#5b+U0kaSkSvP83k~1Dv`@VUy6z1`OitLD6@+^7OR_(TK&bHaE@@L>t?9|{J zC}GOL1x#z0G4L8L8h9OV7s6Gw=@HHSnIIypInwd}!b!d~DznK4Cx& z?82uSE*tm^p9^fLR>+_`QnIpPTH*>2XsvSe<#KYu%pI~U4wD*|jw(wfyL~J{D=4N> z(_@v#+)Sv3FARK%uQ+7xT)Tbe=c{)v{c!jD%YR+@?(X&L8ooC04XzltifaZA<03(Z zv+|yk%)rCgAh4ruq~6C=66l;YOXo?ez>2D)u|ona)!VQM>aN0y5?E8^sst&FwZPUY zX})eG<1Dyyj(+yk1<&^7A!qz(u2jql?5^$jN{!F1=}6nrlB#-^Xwu5L!9;CqUzoWj zIPnzZTrF@c_(6-0dK?^F1Z}FjT38f)_0wb}tyCis&yy{6X}#B`WIs`(nhRW?j8v_| zk*Zql@i=UxRBz5Ka?Gr#vmacl@kE9&QQ^!}=ONQG^TpAb0xc2snHty?v87c{BK1wN zqF}dF=@GoyT518;*9>tfbs-M!mwF7bb9-x}5Z%_Ai7TNBCYEgt!#-EjRTiyQEES6! z1p<5KFw{QJ6pVLOZSTw!eVJ!{xFv4iXl1hChr$B#q?xDNVU^WibLRwAmg8ToRkcVe ziC2Gg&YE^kU^8>PkYhdA$UkrE`L9u+K}}bFC6Q1=hUZqE&hee#dv&_=Cd6Pz*KIU3 z;B?1rED|{VBPk8k0W1%=)*?lH&D6Mx+BWe%9ZKU7Z03o2umxLbO?_=c8>LfdK|A>t zp@X*x(mMI;!uANkFi(p}F*?gg%(B}Y&^A!66^n^P*=!B@W1B{7(?AA0sJCjVL9HBG zXk`d=%B3iOtfP$NK>8P?Xi^&#-HEO;8hP2opI*k|?!?+e7r%`%mUJiACU2qnhI*H= z{3onfzOsx}x3KyK)h*)=+Kr{ryCr%rBV{8ErJ?h=nIYfGptX^jrUM;xy^~U1*u$?L zLhdDK<=Am(yh#N*lcX-gV|*qR36)|9b!Ze2#8SC4en=Ia=x8yJed;QjQ!D=LM_ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/netty/nettyInitializer/NettyServerInitializer$1.class b/version1/target/classes/part3/Server/netty/nettyInitializer/NettyServerInitializer$1.class new file mode 100644 index 0000000000000000000000000000000000000000..35a2e4a7efadeadf30513beeadc95e3218af3fc7 GIT binary patch literal 1102 zcmbtT-)|B@5dIbpPp+pRYW-1vR0Tc2cvgK;2tG7z(u86nrtizK!q)3*Ah^D#IBw zmTC1dL%Vy-6Z16ei)1R2Pzhr`%;cVuM)FvGB)DhcnaK*=BA&J+vkt?{;50<_0|sYX z4+TT1E0yR?js_xm!v`@Tm9CC>e83ZF^*QL+3o!V5N{M7U=4mQO?VKWs>K5I{O+>2W zDMhUX-9tX*Va(Mi?3+ZYQLDZJWiiR47}?-Gew1bUmkWcp^F9*CMrxJ1sF6cojubbO zgdBqZ3DRzKD2~_HlOz(m(w1c7-wkM`?jp%(28OAQ-U$=-vt@4CvU8aatStSJ zAdSjfo!GY1%W~+6(OUp3mu-pZ@#W|*!XtEzb{*0!;x(FIz#3nX`<&VMB*}|p4d+O% z&#Z7BWzxt#V`F4-0TtvkuIHp#u0r!0@}Fpv!;&Ugp(!kA3b=?%$cflh?*E5^beV+ zjT(*5{se!FcxJnlLfeS3NoP9e@}2KoX8QB@m+t^B;6W0*U~-)0ILC2bd$YQ_szbwg zl9U%YF6rpSWsWO4bX?`Q#xbFz4_O@su5(N#um?AE^y8+Ey~^U2PLkUkIgTj?qu{#I z%Q?dLrO&X#m)?qP$vLmOVppWcaI#nvUNCN!NFhD57AeAWi{S)A(su12wxHH#6&k{EvoFcMv|eoX4j-c{1}GXouXvs zA{&C&r(amI7T8tS=a^>b$*S^9hK1Q$MO9%Acc@}(;Swc#!4<)>N3>?U(rQUO+iujc zE0ZdPQgzw0WZqVtIM}(6XO_f@Fff8V!_l@{MpW+#x8kT_8gE+AL@1GIQR6MMDBXo% zF>gz!a$ESalJ~@OIVF{nyarSZ(-H21S#SfnAUy*q+~K%upn!V}nZLu%d9o&5f>W;d z8P0ccq4^IdN2t!359XJo6->J!5#?F@H_v7Y*$plKr%@d_rvlHYWtQP=2cWfDh8=o1 zmupOWRCELTaX>kbF^o2ow#bLBX~!FB;2;h$TTU$Lq7GiD|}S5i7gR`r^4V`N>R9x z`k&WGAzW^`>T4Zs+>VVi8NSsIrC)XEJ*L+a$LT%aOMe#hq^VxhFAZ_kLpmR((=Q}R z0=&z724k2x75|1aH|@viL>Z9H zFy+bdnqHhyLOMaxI7v>@mqwgcmGLBLVzleTYG*q05d-USd&maZ9pdk4ST*tWuzsw6 ximI0;ox&QAuoCIa5A6Dc-JPL~5H=A(t<%zwA&?j)bvoS7U?1%|S@+RSpFh?iG*SQn literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/provider/ServiceProvider.class b/version1/target/classes/part3/Server/provider/ServiceProvider.class new file mode 100644 index 0000000000000000000000000000000000000000..de60431983f58a0764007a03ef2ebb1c678c9d78 GIT binary patch literal 1951 zcmaJ?TUQfT6#mXkl9S7D5ePI^t-YWSgj7LV38EHjO$}&`#iG)#Axy()NU|mqy6SU( zNniTfu2p2IYx&T}{-QorzcZIG0ottO%-NT-_qX@{&gAcZU%de^hab`y#zG21D5_;q z;%XW(U$Z1}Ee+`l*OlXqG`_&HT5e|WC2mQ4l}0~qXHde|N^?h|EU_YR!fv>h^P^d{ z?m5j}d&_bJ2Fg#(U9-?}?RsIwY!wAk6}#3j-Hu}kT<*0l`eNN|)Cv{Xu^Y8wM00oZ zsa180ON+lS&2(%f2g;bc zZMOx^_u^;;{R#nu{Ud;}z@`urS}AO?KsJgfXpRCDuhz}y&pD0=;N`m6ZZnz;D(-Dq za9AJ{m{-jm7SPw7r!NmZJ|^O5ZN=d9r zObeuImK)SBa4uSQFzU%ju5K~uO0(lsty{Jl#z=5J?Cgx9rGYcJYv3f_H}D>EY}o-> zZ=3CHqA@UntibI5(#GCt)eDdA1Svwc890U02JYb-iTegBcwpdLtVujH@Ez6#PI}oI zmRl%ssWhw4EceFNmSeTs3fTt|j|@D<69XIgUSPZj!+%jmV9*QeT_V31Ju1Ir0{VpF zN|K%RxFIk+5$$3~n1O>}fuH0NpAREFC%U(;j}Bd$lIwIkGIJ84@1WQ0GXb?ayvLtM zryGp&=y0P*yYs%#)1QFJ;V{CR70N8#>An>%Mw140_(_i)PEmDEXO)M@7$7+Y96scG zc9<{U7&JvF@O?r_!x(>Lp0_6ry(d}2r%oSofa_UGKT+2C9MA7VamC7nlX!xC?-~I%hz?=%H%15^@z6|xM K)ug=Vf8`xXd)Ui?P~wk*t6|>EFt7LH z31El0#7v?l6d`IK38Fcy&nzL1j*vIW)a`ip#_q3!B`i+PwAN47Z+bmx!piY*tA0#{ mZ>0Vu!ZOv=pl_WzUV3X{Ng!l=4`hNrAOO|^B@=>79MuO(X(T!T literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/server/impl/NettyRPCRPCServer.class b/version1/target/classes/part3/Server/server/impl/NettyRPCRPCServer.class new file mode 100644 index 0000000000000000000000000000000000000000..4925c1168f0a02fd1e4428431a014ad820584233 GIT binary patch literal 2316 zcma)8Yg61*7=8|WNmPjCON+2j+GvZHLNB(+O&5wR7VD*&&8BQ1Bs)nK#Brvh zAL>jUFF(L9e$p8~bn57K+Rmt-{T-tJLVZpWmZd<)naw#T?|Gl+ytnga|M=(8uK)&M zD>$Elz+f|maA6lNW^f6Y6}*~38iR7UqTs5WhZVfmj6)d7par8+GA4)d7EIuEIlR$= zJSHXCl!9v+?8kHl?HE+>rh*v-1%X!I^p-8doc7#ht7LitJ^7061?RK^H%w2f#2evz zgW`}t$`7b1kjzc=UgtFImP|6{EytXyE)`90RxjF=Wb>|}+t+o^lJBuFJlOQEx^CbH zo?a2?%3H4Hm_e|r71yP)6?HA1y4xu0j$_)R)u8H;{rCnf-qD5|H3$)*+Je5UYqsvp zYZFdjdS0~>n5B`A46_ngu0yqCP_}%5{>=f90b(4irHZXhN$X~&hxv=bBT*Gs20=^+ zG#6dpAM@NQy~%Ag%b|Z$mOHX+IzirbE1@PCnpa$JF^26f1iG;}saL`Iej${_*;esBZt~h}s@|xa!f}G(vUJ<}n8^$sk2o5{DxSe%>C{Uq zKEQ`6bQBdBDoQXV`z;0YD$4T3!h*oDr&pAUMGP=Mn+$qtH3_tBP+lu8m<9{$=yv#- ziV>MFux|r0TlUk0Rni^Ehx&}~v}ZX%A@EFniA5OEY!(YB6{%!9 z#N{Gjc!7wrocSSHQK|W;-pkt*{1cVF^+r6Q(7U0rV}a0AC9Vm9^NmIg+q&-$ZOd_` zD0_?%H1-kIC|h=ETz5*gYuOH~d*IP z29~WEu47a^kKIhG`_md0OxVO`B^aIjK(+G=)WN4oUNC;-5?mj_QI5v|@fng(DE;~| z#El1NnvCbEpODBVYe+ptnsQ|@*^%r&UBj+ya}Al_k$#Mp8+|`ReSqCH?3wFG9*emc5SvgQN*I&cFIl}kNeUEO*Rl|WsS#~hJ@!FC8?LN(F$4y@1{o#C@ zCN9E*oNwdPa8BS^zRgerbaNN=+URIIo$I7)L)^X0RURkF(*pxJc8^}NbYTh4k*fzQ zlzl?kZLaTd{RP)wp%2H&IL@$i;v%0Dv?Y%$dAg7yHbrzdWegf|InHv`OPrt;pW_tz z8SFN)p5`inGu%In#J@Z`sX!A7p63soUnnRzyN9rI{Ob|sgJ32_KKD5^g&w9uffib& vMw{`uLbl5oc!}Cg#ANy&;9%dWU!Xq8us38l7-`il&xB>cPbgjvPkiM+eTi|r literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/server/impl/SimpleRPCRPCServer.class b/version1/target/classes/part3/Server/server/impl/SimpleRPCRPCServer.class new file mode 100644 index 0000000000000000000000000000000000000000..bd2c8f6d9cb2538a73d38323d0dff2d4107d12a7 GIT binary patch literal 1396 zcmb7ETTc@~6#k|_m#zy)6{;dAqSzL2Rj4-*FL*=CC6s7*T-FV)w7Z+_g8B!1FfsAf z#226R&1e)7NqjZ&cUXUgQNP)((keW--OkRO^PTTp=FEKg@$nOY5lksKrb0kZ;5be+ zc?|ps5@XDbSdn%-rT@!j<-IdE2q3S4xYPKW{7+ zDM{vC(N#RjBuu9wtcZG(VtuX7`PEZJ#YKeRLC*m5hfZ|C|(V<;B>Y=be zw6dM0(Qs=GQ}z=H(wUkb{N1LbRkNDj{f`bv)jFM9aU6L%Lbq*UU}5vk`-W+umj}9? z=R3)NOzsKqfdbkk=?y3g8)#k_%DzWp z9qKxEtU-JAvob|>>syilI)5#s-NX4IULN2qfxUFxMK}8~h;AZ!c;_78CDcoeyo{Qt z>%=}{8i?*EuA3nqXD~g)#fZt_Akp&4k++Y&4s+g#*mtxmIPy~(DCp;rQ*e~pG&0qs z28ff9iMJeLVPNr4&>uS2B4w4H=MMu_!*QaeYc;!$w(P(MB>rYdh71fsqW%P^hP7oR JOjddv`UP+FPE7y+ literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/server/work/WorkThread.class b/version1/target/classes/part3/Server/server/work/WorkThread.class new file mode 100644 index 0000000000000000000000000000000000000000..05f64e6782a4dad9cfe18a01b9365ae622317a9c GIT binary patch literal 3143 zcma)8X?N6Q6n@gqG;Ihi1uB%aWo<<0MZ{qie-4ftNh165dw z0R@8?QXt_$8T-V`eg$znBrXSJ98{=tNGv}rE|17~RK{Zp9*3r&3d6!hO2G(p1*xe!BHF&>&JzQCuBS+<0%+H z)P(LzsO>(iO=?L~cawvjs6#@vquY~4O7FL=Nn=Epu(ms^+3xz}AmzH9%=&WMdoStP zG%dGtCa+D+`y|9VEn!^KZJ2s*E;Fp#L)vhflDXYhN=xt4Y(u;U!g9-UBrNga7*?`x z_^_UG`*LnJ=MK8Iu4ROK%b?QYo0PiDu#RG9Qv>>uobE8Z#sGQB%494v*`qs-Hl`;B ziYjzE%QJAYmgx}OiWw|?9hyi~tn*Q%HFGSv>sU(9x`t(PE#{63kgKDd2}()bQOll4 z?&oD_oFR=+efFTMr6zi`tjB|lX9#FacL($Wpj}NfAo9ZOXr4i%h`GWrC#?yOelO)7 zaGzzuXbMF$ppT}>y)mixWp!HGC*2;KZ#S3^*MGsz*P#;wfRi28M@ruxTRmDlXCSkeXGqRK{m2KF4|DEp60m4dznger}5U zM4)t~)B2c}-kD0Vqe3c)l9NJ;yI6K9uZV^;o0VPEW|n1qq2fz?#hGyZ?9bPKJahfz zg&XHj{dxM_jf)p$e68XeTu|{Xz7x!nqm_|CG<{P^m{UUG7dZWwL<2d~^aqj8c(j8f z)_yrlSXi5sVVyDL$IcIpYj4%W1&r z%>g%Lb6${J4{2n4M0Y9Svg-}ETXC7we}Mi@}wDqu7kMPBe{_uf%#H z+)QNcMA<>EGw;+@mOSZf*8++L|Y)|$sW3g`1*m&a}GvHDmmpBLn@ zusvQMzl!=x;-1ISAFyoh@;n-@qVW>l`G^(;_r<||NhIqH&}_mk?Dlv8 z7DM`*bj4-tk+D}smyG*l+z&}cHyPM1L0yjH{9Oh|7{nI&(fWG^-i$V#8suhP`AbIIgD7|7~k zHLp#tg=kH-!u@An@=u2_{GQkybJo5`AOy{AfI>nCVaw2M HFhK7KkGVXY literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/Server/serviceRegister/impl/ZKServiceRegister.class b/version1/target/classes/part3/Server/serviceRegister/impl/ZKServiceRegister.class new file mode 100644 index 0000000000000000000000000000000000000000..f281b3c325395a52ee8f8fd6779c7fddd00b6add GIT binary patch literal 3883 zcmbtX`*#z^75+wktSoJatq>q2F{Y)74GxQq2`Qumql%(NHmc=1g|to9tFgUU-c?sC z!0G#uG$l=%K1qQlO+uQ!Xp=ONap>!}p40!socss78z zFJNR`Z`v@6rZpoCtL&M+>lss?IVVrK-mH-fR}L>P>=)=5J9>2diR|$B5rIVJgn805 z3Z^q{zuU-3@1*pM68~&Vj>&1em9N9kUHb=6r_h`>E-si0qTzG=;ln8m;~tBx}=UiH$V(t&LSPL(h-_I;dP=q}}m&Gu5%2TlOq@ z*j5p+VHJftReb5#jUjvA^Mb}|C+h*YqUF1$p1<}_j|FyrgeVhe8<`)=CUyKo3HvF2reh}z4L{fM z3k+#EtK%j7lGZ)ty0cOirPuSpKVH82!W&ngeR1i`D;mz}IFAcDeub9>Hm=O5LuI>= zmmVX_(D4d>t>aa^rr~uR7x9LU-{4IRzt!#QH2g`&pYfK!fhI1iC%0L& zjp1ZQxop~V%T7Ma2p)Fwhvt1*QaPyOFg~N>ZCoOKbzHTOX3k!{bn)ti=aG%uYRgmA)P|>k~%L1DNDNRFD!=jG&aYeEASAovDzN3>Tq{Rs8 zUz43`9xT@c($bqwtHc~y(+Mjp++ovV31r34CYK$r)hN)@jw8Kf!7P;|tJ1;VzGh{m z?&0eQ-&PgKlJM|H0k?dfHNkR;$nwKf78q+%xNaF^Cygz!f{ojA(k=TVw0yWXeam9w zLGp&>SK!IsX0B|k(6_9x!(rVm@v38~X$#m@mHtDDC1($OD9)&hx1q=QZ3yYyJnyYJ zUWxQ)?Y^*GBg;EfktxkNDhhM%+GPf2QEe(XJlBkEMtq!?xiy2nct15Z@VAOY)gK<3-*R!~G+w5G^eXGFG;3?NrrAgqv8-NKb1wGep z(S<&FzA59A!RERRH%55P2^Q@@9owI*>G2*arKd)v%uBj&_5vSM5KtkKlL;)`&Y-P{h4`vlVA0nzv z;8(?F?7{%o2KgL89Ibq2!^3e8SDxcM!v9CMFF;&D$bm(b&I%N@GkC5bXAaeI}rXL$8KmGH&X0f=;Z8fY$2Q;JVK*ko91y6U4k1b3eVXrewEPzn|3OkiD#|ssQdLTibEYU=HlDuPMxzp+ z2>o_n1^3f+Z*fN?z`8Ebw})SJdvPy=qRvov4MR7MP_y8PG(KC?(-xfEv_pyR9l3(O zWBo0I{jGzS!D!l1*Py;;L54N*tEBgY=W5b7;nBcC4PD4!gu5dc4e%Ys5BMLW#tD85 IKZ}n41D$tcEC2ui literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/Message/RpcRequest$RpcRequestBuilder.class b/version1/target/classes/part3/common/Message/RpcRequest$RpcRequestBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..2b9369e8137d6128e551f3588da61a8c40164654 GIT binary patch literal 1979 zcmbVM>rN9v6#k~SZR=v8KmkRmg3^{tMeqtm0WFslOn{IOe{I{bENQoOyEWmhG(j+u z_y9hX@yyPq+uBA*fApL)({H|W-`{_J{sORsoiGNm5JD7Bg;*3~Nr-0(o`(^@3k5I3 z2x1|KS3AvM02Ow7cE`Zj8gi* zGIgW0%n+_{>!ezgh(Jvh!Kpc7{eWgiEAc6JblM7 z@~_M0NX@kPa!u#&MB930RJ=!)mTorgZd8UgVm2oUZhb?q{qtyj*N(S`=JT8$gj&$%wVoeguBNru+2^m2O5G_^C@ zO0~#&?XcPK>9(MT1m}(hbQ%wOb_BDTc5`y z#Cc9&J5J#>)}6?EVtzHG^4_!o|8%rqL?|j#KAUz;k%%=cAwh5=!@SO5V|CH)uZ`z8VEATA95< z@c0s;X!ruR1TU$mDs8W@`=ssrf!pF3kw?FC?5E=e2L9(g>v;Fj_=uK2!4&B*d5=;~ HlL-9neUw#E}6yHX% z2g_}U;A0s+k>RoopN4TIiV&8=Fr!?r$dDE7Rgo+iu12wjb&+y%a7~ui!^lSw$8rQ4 zG8ZB!Mo^NY8xfQvsK~AzMm3C^3cD6c*#+xH)vDMhtGWEDRaP*j3k9ouDsNUQRz;yB zSFo+}RWobNnH!cueCC>Y)6C?}!dhn0F6Rns;|kFY%U&<8x*DO9SvEIlx_jBDJHK+x z%G#pq9xvT0$!&fW$0s$~7ISL_)2^1O(6d8fB7K}Xp^01}XCGIXN&1|4fOhWqZ}E`$ zw_MMu3kuq);ws(7W^x5em6yzwyz}m2*34fp%Q;zlo0`3z<3sn&@J;rSOt!eO zQ7mL;txCmQvoej~5^(QKlRaPW-7){aJwPHOZwRl{a(OJ7dKR>y21<_t1lzS{+0)H= z@8(r4GT%YXSzq$oxIXXYzbBdU2f5Awv2k@=67XujUX2EQEwuC{1iA4uh zoA7a6!`GYiyY=AJjQjw5niLyk>EF3u%Rz`$W#-9^CSWxmmlRa7xt8kD(Tn!F)L~q> zHMFhzb~}gLcVmvKzXrQpJ^xn6qHSic&zdENckC-{0t%6=SvW0FDXyE9b(j9ZWNKPL zKff?Ndzw%whssu^nzt1?w>xhi@_UKcMYjl9=!?Z_IcrVjqA#ClA2R9Kr;%RI&=I3Ztz`Zby%3G!@6eQk@&ds`Z_lDxqCVe8wC`&$^hks7D(2~2tj$jO{!%K!LI=aybqqn@dd zmnntgt?vmw?>)jZiT&GnrxhOUdG8UH$UP@;l30ZSGo0)1+QGo5z02kKA==sG zG5-`ju)n!Tl|&^>&AY?t@1bk=hkr-pJLtjt!@nUiJCfc)o3o@4og3jWrj7oA_JsBb zyY9glO=w$auW1-#I#rCZP(l}-&?Cg}p(CLuLO!Jqs&xE}&YDq->sW2A-6s}*mAP*` z>td|u?k=WqhA-$r1!q}#0Y+{W)7%TPqA%kdC5`_l@E%7UvlwSA&#-c5dH;U2ha-QZ zGmN>%=nZ3@zleH_ephT$u^6rSHE?6Zwy&Hl=n@#~1G$%yopgln!G=@kih6PGJp;BWVkc}Sb zHHDgv*1SbE`s0Voi$RG#rAbXaM4T;ccf5NGJrW8|@m^OpMDBBCzO`SL33tiYI?Dkr ixA4ODcHxr6CH<85>Hsb}8M}nNoTKy};>Y48wEYYHJ-4C& literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/Message/RpcResponse$RpcResponseBuilder.class b/version1/target/classes/part3/common/Message/RpcResponse$RpcResponseBuilder.class new file mode 100644 index 0000000000000000000000000000000000000000..410842135037ec9801edd0f1c670db254b1ac323 GIT binary patch literal 1588 zcmb_cZBNrs6n^gBI%?&m3{XLxirS5rsvC;JhDu_xWNHG2gfAxDXs~2!m$vx3G=VLV z#2?^~GM>{GC~gQLe&{`?_nz~dbD!tr{`&pnCx9~E$WSpigfYzXvcSut1YJfNPb55* zAz?0yXKYKnl(SgM;yJr7vRG#OQo<_T|(F%Z_rqS9m zT#Nss&6NMe@(6gN)7&tV9Gtc)F!gu66M^G;EyjvQ0UD2IML`8s zUe*NU`Fu2|6&l(3JWpj1@S3K$px`kyfzm~N#mk=bGJ4u&D2{-p)%v-L?Hr3pL!U7^ z9n&U776wktDR!tsRF$Ne;o&_0_zc`}y>sJnk6r_n-iagNC$CU+f~-`WK18DUjokk9$uJ~J zr{JJ3t~!ASeL!=ENM0ImR^x-<|o!$1%5C<3a|Ys$Rjj*#9i9?u1wW2OKA literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/Message/RpcResponse.class b/version1/target/classes/part3/common/Message/RpcResponse.class new file mode 100644 index 0000000000000000000000000000000000000000..3321fd04e93e900ec8a261f9020bc69bde99ee17 GIT binary patch literal 3094 zcmbVOU2ha+6n@^_nVs3~w6tqWS*TdB>UP_*D3yyFHx zcQO^~jB-`rh_^i%@b&fmlSR8!*_O@}78eWo^py9QbRar`-{%IhW-^<14p$dvozgLT zHs=OY$k@5#b}1`o|57_=XLAaD$yH%Tc4zb1${vMeav~6(pIYFi9`JF-Q(4F|pUta@ z-I%SjyJHmr^#v05%OVucI~9+DaI&A(i1F+*rO-*(CM6M{aknbV4FYwkgKEi%er6Rb z2T;3$werajBZEdB>@tf0IT7b#)y|QgrUob3PXz_NP+4$0PMGXlYOYrIx^a%WYOlFs zp3Xb8&Q$Eog(7G6ZzLIqox>iw@iyZ7nW_pW|>@AEJI zymIaDD_8%zdDB84sut3?Bo5EZ@dfdENnzWQy1q#xDD*zb%fck~T6h)PE$qNf3vbAA z7e*{hVY@>2%0^il{fR0JLa7?UHE7?tE(2U6u0b~jDO;Yg^fXUV3}K58lp>J)#05zG zL!h``L&Qf?XdtbpRT^7;zti;7c+;7>4I{PT7R=P(Eksj8w-EcD_o0Ain;S#Qv&YML zg?f6riAoZkZmJSTryF6I5psI{C-wRfns?B0;x;VFFc?=GPaGuQI?Y`$_0$hAZ%_yZ z(h(p-_XANffK8mEE18Tpb>_@AagMEY?riEjirv2R2;&q2A}*CH32b$}*LoI91V(%U z6~?gV5u5>5W3@QaX+qm;c)c0UBL#h2Jknl*!?&4-qa-VXc~u8e-$2)H4E&1LFQJET z4E%!DsX;bvn|q|NW{`i^M8`w>VV>GYw4vY7lF;s=<2tONgjPdG-8?>`(S@l>u!rxn6lO^e^R>i(2-qY?D1|tyTXB?;h50t=#@m!Mmytuz9+DP~j3`AC zpwvSeHO?Wq=z?B1sM~1EuV}{S@r&i>e1^}I$sWFgPQC}a;%jT@mb7bF7f*O{JGc0H pPmb5HA>Ko|hG$ofqsO%ORvh+o3}J@oA-B>%jL&M}Yq=NE{{fm@1xW zP*Kj{Im;KktY=Wo;AIA{c=uYxhKfxA#cm2L9JH;^mg!h-%iMPZ*^+)uAk*(j|Iq44 zfn3btDDZ8!Mdyj0{4yT9>v@i}Tsli{*{&VzkW;aAERfvungla@V7v0L->FOgy;XMx zz+S_0jxFEjePm1qpX{E%%m>Q9+qa#j^ab>N*OmUBWA%EH4hsie%MaGghS%wMuG#h4 zp2_}&SP<2*S&UUaY^^k1>_$8`>Uzr1v9v>0ri@M1xn+Ud#eW6xYyvN=NWdV!%khn- zqaAsDzaih+Ommi5Sz|99H*rfx4huRA+|ZH7qCkE!ne6;VVDWGG(NK&5ZjADx-Q3nu z!xk^wG{eeLKe|PauIIM=H*#4MvJ z&~;2(-L76C5{?H!}=~2$pb4@^D#z|9{^noPaNv7$e zfq=$Mnn_ZSOqI_ezLBEf4z1~daTa$;*Fy)~!xHW2Wm1wbxJKRz+0^pNcPQnrq+Sir zhb~b#IS=aMtOk}R0VSpe;>H*#k4KY$l2ZdQGYnL~;|OSnern8%ae>rH`INdlMS{NM zIntB+3~4e(G|^>?us#w4j8(mWdUB3TE_()zG0!lQ(?dN$B6ls+lWf0E`Wa^bm#Z4( UQcxT)U%~^D8s(a!>hB}_2P*S7DgXcg literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/pojo/User.class b/version1/target/classes/part3/common/pojo/User.class new file mode 100644 index 0000000000000000000000000000000000000000..c6480d7b4b75ae196f1d7614916605e5202f5237 GIT binary patch literal 2753 zcma)8?Q&C96kR8|UrBCh3H>07TCrlAv_t^~Q;GDkr_w-;Ec~C;@bDzG&eDfFw8mo?z8qj>#VcSPXGGn*WUn~z?O|q(@P@_EC?muU=O*}+YjzmnmW1JA*lgR*?B3vStl zZ{ur)%xc50pKAq`b-%9Q&R45`{d~o1H2j7_B3M^Au(0KQ=M^hnb)z_6ZTcI2eOAF~ zF>cA*_7$=*z)G_oR5!SuZ1}gkW6#xU72m6J&0cHocVu#EVaKaCj~C0e?d@8%xKrDz z6@}77j2AQ`%S%FWv%$%Ndu6MD26I>Vbx zX>Vu`gzna!Jp1%o$1$+d^vd5XdOM-stXWnY6PLZ}1>s3^(`#(%D@{&L&6CFE<@v=6 zG8HWbChIyoQly!QU6(}iyr-ZSxdl?`i*{p}!*_eS*#2;IY2JM?<=@bBR3Vm{z{<0Lh@s{I@d~)13@m55lE06KKc|?B6a}3A(J&Mrc$zzf{7*2A zdxbw>{RlI8ukbsp#p(Pm?C_I@voy`2WX$}DOwM?W{deKcB8*(Vsa z@jm}M>In{NGZi(c$W8f^%mk*$C+we99OfQ-lbnUUlD?wTsH2Rt7`-|)d)k-_ zB|kJYyGg;Fp~79*GrMqai9cO3WFconD~?=)UdoiraEUh%201x1TsqWW)H8a+h*lEI zxIn?!_Hj9sE`c;V)kmb7 zfHubHc118N2J0Yuy#$jco2b?fH>sWUl@pIJz%H~eJGhG>k#HCLvsrCtIAsrLJ1zcU z+PfI(Z3epDbQ?MmNu%UfB-*Rf!yaO^_wDTudqHmxTfkBje1k*{5*^MnIP50*=?5_K xGY{~ecbpA#~^mdYEJUp0!Jz$JbqczZ8!mOoVavx6K`{{n~Z=w|=` literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/service/Impl/UserServiceImpl.class b/version1/target/classes/part3/common/service/Impl/UserServiceImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..181193155636a16b609a31201e53728613461930 GIT binary patch literal 1965 zcma)7TW=dh6#gc5vd(&FTIWijr70!YNz(;VXiG{9NeCF+q|`|u;kve`?uPZQwO&W< zJD>^)Q6YHYrBb9yNJwqrVH33yKY-ss9DW7j%&u=69NLFHvu9?`cfNC(nLqz|_y>S9 zD61HS){B?$vVvDsM4-hmEypubyc)x6ay+Zz9L_6vT}2$4iWyu`@dhqRL2H-rrW9|< z)masDn3w9?QY^&qj@o%4GP9v?>YAxrMJ;W)q9~l1R2Z~uZ`eKW1;V5C5!-CC_3Z;coc3{ODjQrv*jW+bPH@b<+WfCc{ws1q}ap zf6TQ5R4Q@uzrcjp?>h@KWKhbIuW3;T?G4{xNT+Wol$K_*k!h~c7IB%RW|Q!=WeI1_ z)GHN12XUO}bcQ(DW<~@LwVGsQB|Xoe2InSF5{;<*(`_FZX z@yXboZ#RA1eXuXGxFv45v$kytof1u#+B(CLR_&WB%BF5s#nLrOdUCzJi1i&5aik({ zFoei77N0Q9-G12^Mh~nDxrx{B!ys+lq{*9Suu+51rHC;+O)mw*GxTgkXr#-8m<+p@8pj tlPxhDX;D#qgQJwOW4`O50HEo5%y&bN3#NSfr|~h3DmlDFPv$y${{_vo3nBmj literal 0 HcmV?d00001 diff --git a/version1/target/classes/part3/common/service/UserService.class b/version1/target/classes/part3/common/service/UserService.class new file mode 100644 index 0000000000000000000000000000000000000000..a2e6fc6ea69bb56feb6a20f41f081588892737e8 GIT binary patch literal 269 zcmZ`!F$%&!5S-O$Gz$6zOH=3-+NHA)0s#y00cTu7LXrz-4EQw*AK;_JyC8_5&F(Tg zGdufu-tGX_7`Yg_@CcKH>%*D#=4xwrA}r=nCL1YoStcSZYfe}PepE?auSBehLY1OY znG#kI5XNa~hSuaQ|3meE_!7Lmy6Bj=(wLVv1!4B(X4ZDs-hT6p>XUbO c%s8(51VYC=3UnMo7Y<;04}F6WT#IAy0;+jTKmY&$ literal 0 HcmV?d00001