Rpc 框架Link 设计实现完毕(面试要知道)

ゞ浴缸里的玫瑰 2023-07-03 10:49 8阅读 0赞

### 目录 ###

*  一、创建项目
 *  二、设计目标
 *  三、设计注解和功能
 *  四、实现接口和工具
 *  五、完成和spring的整合（重点内容）
 *  六、代码的完善
 *  七、开始测试

# 一、创建项目 #

![在这里插入图片描述][20200205205628311.png]

# 二、设计目标 #

**2.1 概论**

设计一个基于接口的调用方式的远程调用框架，和spring 整合在一起

**2.2 形式**

2.2.1 导入spring的依赖

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.sxt</groupId>
        <artifactId>link</artifactId>
        <version>2.0</version>
        <properties>
           <spring.version>4.3.16.RELEASE</spring.version>
        </properties>
      <dependencies>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>${ spring.version}</version>
          </dependency>
      </dependencies>
    </project>

**2.2.2 服务的提供者的启动类和配置文件**

启动类：

/** * 服务提供者的启动类 */
    public class ProviderApp { 
    
        /** * 我们和spring 整合在了一起 * @param args */
        public static void main(String[] args) { 
            // 加载spring的容器
            ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("classpath:provider.xml");
            app.start();
    
            // 挂起jvm
            try { 
                System.in.read() ;
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

配置文件：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][20200205205836802.png]

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:component-scan base-package="com.sxt.test.service.impl"></context:component-scan>
    </beans>

**2.2.3 接口和实现类的准备**  
![在这里插入图片描述][20200205205923446.png]

**2.2.4 服务消费者的启动类和配置文件**  
启动类：

/** * 消费者 */
    public class ConsumerApp { 
    
        public static void main(String[] args) { 
            ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("consumer.xml");
            app.start();
    
            ConsumerService consumerService = app.getBean(ConsumerService.class);
            consumerService.consumer(); // consumer 底层会触发远程调用
            try { 
                // 挂起jvm
                System.in.read();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:component-scan base-package="com.sxt.test.consumer.service.impl"></context:component-scan>
    </beans>

**2.2.5 服务消费者的接口和实现类**  
![在这里插入图片描述][20200205210043742.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 1]

# 三、设计注解和功能 #

**3.1 对于服务的提供者**

要注册该服务，已经暴露该服务！  
在dubbo 里面使用@service来完成该功能  
对于link：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 3]  
使用该注解：  
![在这里插入图片描述][20200205210254427.png]

代表该服务以后将被暴露出去

**3.2 对于服务的消费者**

去远程调用一个服务  
![在这里插入图片描述][20200205210331118.png]

使用该注解：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 4]

**3.3 设计工具和接口**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 5]

**3.3.1 负载均衡的功能定义**  
![在这里插入图片描述][20200205210427140.png]

**3.3.2 注册中心的功能**  
![在这里插入图片描述][20200205210448658.png]

**3.3.3 编码器（影响性能的关键）**

我们在远程调用时，不可避免要把对象转换为字节去在socket 上面发送?  
我们昨天的Request 还实现序列化的接口了  
我们把对象->字节  
字节-> 对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 6]

**3.3.4 模型对象**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 7]  
**3.3.5 代理对象的工具类**

/** * 代理对象的工具类 */
    public class ProxyUtil { 
    
        /** * 通过接口创建代理对象 * @param interfacee * @param <T> * @return */
        public static <T> T createProxy(Class<T> interfacee){ 
           return (T) Proxy.newProxyInstance(
                    ProxyUtil.class.getClassLoader(),
                    new Class<?>[]{ interfacee},
                    new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            /** * 1 普通方法的处理 */
                            boolean isCommonMethod = false ;
                            if(isCommonMethod){ 
                                return commonInvoker(method.getName());
                            }
                            /** * 2 远程调用的方法的处理 */
                            Request request = new Request();
                            request.setInterfaceName(interfacee.getName());
                            request.setMethodName(method.getName());
                            request.setArgs(args);
    
                            return rpcInvoker(request); // 远程调用
                        }
                    }
            );
        }
    
        /** * 完成远程的调用 * @param request * @return */
        private static Object rpcInvoker(Request request) { 
            return  null ;
        }
    
        /** * 完成普通方法的调用 * @param name * @return */
        private static Object commonInvoker(String name) { 
            return  null ;
        }
    }

**3.3.6 方法的调用**  
![在这里插入图片描述][20200205212651187.png]

方法的调用在2 个场景发生：  
**1 服务提供者而言**  
需要一个本地的调用

**2 服务的消费者而言**  
需要远程的方法调用  
![在这里插入图片描述][20200205212755524.png]

使用起来：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 8]

![在这里插入图片描述][20200205212816515.png]

**3.3.7 网络的能力**

网络的能力无非就是输入和输出（IO）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 9]

# 四、实现接口和工具 #

牛逼的公司，做设计（标准），菜（实现）

**4.1 实现负载均衡**

/** * 随机的负载均衡实现 */
    public class RandomLoadBalance implements  LoadBalance{ 
    
        /** * 单例对象 */
        public static final  RandomLoadBalance INSTANCE =  new RandomLoadBalance();
    
        public Random rdm = new Random() ;
    
        private RandomLoadBalance(){ }
    
        @Override
        public String loadbalance(List<String> servers) { 
    
            if(servers==null || servers.isEmpty()){ 
                throw  new RuntimeException("输入的集合为null") ;
            }
            return servers.get(rdm.nextInt(servers.size()));
        }
    }

**4.2 实现注册中心的功能**  
注册中心不仅仅可以使用zk 吧，redis 也能实现？在dubbo 里面讲过吧  
使用zk 实现注册中心，需要导入zkclient的依赖

public class ZkRegister  implements  Register{ 
    
        private ZkClient zkClient = null ;
        private String zkUrl = "" ;
        private int connectionTime = 300000;
        private int sessionTime = 5000 ;
        { 
            zkClient = new ZkClient(zkUrl,sessionTime,connectionTime) ;
        }
        private Map<String,List<String>> cache = new HashMap<>();
    
        public static final ZkRegister INSTANCE = new ZkRegister() ;
    
       private ZkRegister (){ }
    
        @Override
        public void register(String serviceName, String serviceAddress) { 
            if(!zkClient.exists("/"+serviceName)){ 
                zkClient.createPersistent("/"+serviceName);
            }
            if(!zkClient.exists("/"+serviceName+"/"+serviceAddress)){ 
                zkClient.createEphemeral("/"+serviceName+"/"+serviceAddress);
                System.out.println("服务"+serviceName+"注册成功，地址为"+serviceAddress);
            }
    
        }
    
        @Override
        public List<String> discovery(String serviceName) { 
           if(cache.containsKey(serviceName)){ 
               return cache.get(serviceName) ;
           }
            List<String> servers = zkClient.getChildren("/" + serviceName);
           if(servers!=null && !servers.isEmpty()){ 
               cache.put(serviceName,servers);
               zkClient.subscribeChildChanges("/" + serviceName, new IZkChildListener() { 
                   @Override
                   public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception { 
                       System.out.println("服务"+serviceName+"的提供者有改变");
                       if(currentChilds==null || currentChilds.isEmpty()){ 
                           cache.remove(serviceName);
                       }else{ 
                           cache.put(serviceName,currentChilds) ;// 更新缓存
                           System.out.println("服务列表已经更新完毕");
                       }
                   }
               }) ;
               return  servers ;
           }
            return Collections.emptyList();
        }
    }

**4.3 实现编码器的功能**

/** * 利用jdk的序列化实现 */
    public class JDKCoder  implements  Coder{ 
    
        public static final JDKCoder INSTANCE = new JDKCoder() ;
        
        private JDKCoder(){ }
        /** * 将对象转为为字节 * @param object * @return */
        @Override
        public byte[] code(Object object) { 
    // 对象-> 字节 对象的流
            if(object==null){ 
                return  new byte[0] ;
            }
            byte[] bytes = new byte[0];
            ByteArrayOutputStream byteArrayOutputStream = null  ;
            ObjectOutputStream objectOutputStream = null ;
            try { 
                byteArrayOutputStream = new ByteArrayOutputStream();
                objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
                objectOutputStream.writeObject(object);
                objectOutputStream.flush();
                bytes = byteArrayOutputStream.toByteArray();
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                // 关闭资源的操作
            }
            return bytes ; // 将内存里面的字节读取出来
        }
    
        /** * 将字节转换为对象 * @param bs * @return */
        @Override
        public Object deCode(byte[] bs) { 
            if(bs==null || bs.length==0){ 
                return  null ;
            }
            Object object = null;
            ByteArrayInputStream byteArrayInputStream = null ;
            ObjectInputStream objectInputStream = null ;
            try { 
                 byteArrayInputStream = new ByteArrayInputStream(bs);
                 objectInputStream = new ObjectInputStream(byteArrayInputStream);
                 object = objectInputStream.readObject();
            } catch (IOException e) { 
                e.printStackTrace();
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            } finally { 
            }
            return object;
        }
    }

**4.4 方法的调用实现**

**4.4.1 远程方法调用的实现**

public class RpcMethodInvoker implements  MethodInvoker{ 
    
        private Net net ;
        
        private Coder coder ;
        
        /** * 远程调用的实现 * @param request * @return */
        
        @Override
        public Object invoker(Request request) { 
            
            net.write(coder.code(request)); // 发送请求对象给服务的提供者
    
            byte[] bs = net.read(); // 接受服务提供者的答案
            
            return coder.deCode(bs);
        }
    }

**4.4.2 本地方法调用的实现**

public class LocalMethodInvoker implements  MethodInvoker { 
    
        
        private ApplicationContext applicationContext  ;// 它就是ioc的容器
    
        /** * 完成真实方法的调用 * @param request * @return */
        @Override
        public Object invoker(Request request) { 
            String interfaceName = request.getInterfaceName();
            
            Object result = null;
            try { 
                Class<?> interfacee = Class.forName(interfaceName);
                // 怎么通过接口得到实现类的对象 我们现在位于ioc 里面
                Object bean = applicationContext.getBean(interfacee); // 真实对象
                String methodName = request.getMethodName();
                Object[] args = request.getArgs();
                Class<?> types[] = null ;
                if(args!=null && args.length > 0){  // 得到方法的参数类型
                    types = new Class[args.length] ;
                    for (int i = 0; i < args.length; i++) { 
                        types[i] = args[i].getClass() ;
                    }
                }
                Method method = interfacee.getMethod(methodName, types);
                result = method.invoke(bean, args);
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            } catch (NoSuchMethodException e) { 
                e.printStackTrace();
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            } catch (InvocationTargetException e) { 
                e.printStackTrace();
            }
            return result;
        }
    }

**4.5 网络能力的实现**  
实现io

public class SocketNet  implements  Net{ 
    
        @Override
        public void write(byte[] bs) { 
            OutputStream outputStream = null ;
            try { 
                outputStream.write(bs); // 可以直接写
            } catch (IOException e) { 
                e.printStackTrace();
            }finally { 
                // TODO 关闭资源的操作
            }
        }
    
        @Override
        public byte[] read() { 
            InputStream inputStream = null ;
            /** * 读取的操作 */
            byte[] buff = new byte[1024];
            int len = 0 ;
            byte[] bytes = new byte[0];
            try { 
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                while((len=inputStream.read(buff)) != -1){  // 从input 读取到buff ，长度为0-len
                    byteArrayOutputStream.write(buff,0,len);
                }
                bytes = byteArrayOutputStream.toByteArray();
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                //TODO 关闭资源的操作
            }
            return bytes;
        }
    }

**4.5.1 针对服务端**

ServerSockert

**4.5.2 针对客户端**  
Socket

public class ClientSocketNet extends  SocketNet{ 
    
        private Register register ;
    
        private LoadBalance loadBalance ;
    
    // private Socket socket ;
    // 答案是不行的，因为我们ClientSocketNet 是个单例对象，那单例对象里面的属性也是唯一的,若有线程给它赋值后，它就有值了
        // 和springmvc 里面的对象的变量是一个道理 // 怎么解决springMVC 里面变量的安全问题？
        /** * 输出流用于发送一个数据 * @return */
        @Override
        protected OutputStream getOutputStream() { 
            // 利用ThreadLocal 取出当前要调用的服务的名称
            //TODO
            String serviceName = "" ;
    
            /** * 服务的发现 */
            List<String> servers = register.discovery(serviceName);
    
            /** * 服务的负载均衡 */
            String server = loadBalance.loadbalance(servers);
            String[] serverAddress = server.split(":");
    
            OutputStream outputStream = null;
            Socket socket = null ;
            try { 
                socket = new Socket(serverAddress[0],Integer.valueOf(serverAddress[1])); //ip ：port ->服务的地址-> 服务的发现+ 负载均衡
                outputStream = socket.getOutputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            // 把Socket 存储起来 TODO
            // 使用ThreadLocal 做
    
            return outputStream;
        }
    
        @Override
        protected InputStream getInputStream() { 
            Socket socket = null ;// // 从ThreadLocal 里面获取Socket
            InputStream inputStream = null;
            try { 
                inputStream = socket.getInputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return inputStream;
        }
    }

**4.6 ThreadLocal 利用起来**

/** * ThreadLocal的工具类 */
    public class ThreadLocalUtil { 
    
        private static ThreadLocal<Map<String,Object>> threadLocal = new ThreadLocal<Map<String, Object>>(){ 
    
            @Override
            protected Map<String, Object> initialValue() { 
                return new HashMap<>();
            }
        };
    
        /** * 从ThreadLocal 里面取值 * @param name * @return */
        public static Object get(String name){ 
            Map<String, Object> objectMap = threadLocal.get();
            if(objectMap.containsKey(name)){ 
                return objectMap.get(name) ;
            }
            return  null ;
        }
    
        /** * 给ThreadLocal 里面保存值 * @param name * @param value */
        public static void set(String name,Object value){ 
            Map<String, Object> objectMap = threadLocal.get();
            objectMap.put(name,value) ;
        }
    
        /** * 清理ThreadLocal 里面的值 */
        public static void clear(){ 
            Map<String, Object> stringObjectMap = threadLocal.get();
            stringObjectMap.clear();
        }
    
    }

**4.6.1 利用ThreadLocal 在一个线程之间来共享值**

public class ClientSocketNet extends  SocketNet{ 
    
        private Register register ;
    
        private LoadBalance loadBalance ;
    
    // private Socket socket ;
    // 答案是不行的，因为我们ClientSocketNet 是个单例对象，那单例对象里面的属性也是唯一的,若有线程给它赋值后，它就有值了
        // 和springmvc 里面的对象的变量是一个道理 // 怎么解决springMVC 里面变量的安全问题？
        /** * 输出流用于发送一个数据 * @return */
        @Override
        protected OutputStream getOutputStream() { 
            // 利用ThreadLocal 取出当前要调用的服务的名称
            String serviceName = (String)ThreadLocalUtil.get("serviceName");
    
            /** * 服务的发现 */
            List<String> servers = register.discovery(serviceName);
    
            /** * 服务的负载均衡 */
            String server = loadBalance.loadbalance(servers);
            String[] serverAddress = server.split(":");
    
            OutputStream outputStream = null;
            Socket socket = null ;
            try { 
                socket = new Socket(serverAddress[0],Integer.valueOf(serverAddress[1])); //ip ：port ->服务的地址-> 服务的发现+ 负载均衡
                outputStream = socket.getOutputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            // 把Socket 存储起来 TODO
            // 使用ThreadLocal 做
             ThreadLocalUtil.set("client",socket); // 往线程里面设置值
            return outputStream;
        }
    
        @Override
        protected InputStream getInputStream() { 
            Socket socket = (Socket)ThreadLocalUtil.get("client") ;// // 从ThreadLocal 里面获取Socket
            InputStream inputStream = null;
            try { 
                inputStream = socket.getInputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return inputStream;
        }
    }

**4.7 ServerSocketNet的实现**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 10]

/** * serverSocket * ServerSocket 只需要一个就有可以了，不管有多少个客户端，只需要一个ServerSocket 就可以了 * 在服务端和客户不同的点，是服务端需要监听 * */
    public class ServerSocketNet extends  SocketNet{ 
    
        private Coder coder ;
    
        private ServerSocket serverSocket ;
    
        private MethodInvoker methodInvoker ;
    
        public ServerSocketNet(int port){ 
            try { 
                this.serverSocket = new ServerSocket(port) ;
                // 服务端一启动就需要监听，而且是死循环的监听
                while(true){ 
                    listener();
                }
    
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        public void listener(){ 
            Socket socket = null ;
            try { 
                socket  = this.serverSocket.accept(); // 代表监听
                // 该socket 就是客户端 ， 客户端会被请求对象发送过来，我们在本地调用成功后，又把该结果发个client
                ThreadLocalUtil.set("client",socket); // 把该变量放在线程里面
                byte[] read = read(); // 调用父类里面的读取数据的方法，因为服务的消费者要把请求对象发送过来
                Request request = (Request)coder.deCode(read);
                // 服务的提供者里面，需要本地调用
                Object result = methodInvoker.invoker(request);
                write(coder.code(result)); // 向服务的消费者写答案过去
                // 一次调用结束
                ThreadLocalUtil.clear(); // 调用结束，释放线程里面的数据
            } catch (IOException e) { 
                e.printStackTrace();
            }finally { 
                if(socket!=null){ 
                    try { 
                        socket.close();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }finally { 
                        socket = null ;
                    }
                }
            }
        }
    
        @Override
        protected OutputStream getOutputStream() { 
            Socket client =(Socket) ThreadLocalUtil.get("client");// 把该变量放在线程里面
            OutputStream outputStream = null;
            try { 
                outputStream = client.getOutputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return outputStream;
        }
    
        /** * 获取输入流 * @return */
        @Override
        protected InputStream getInputStream() { 
            Socket client = (Socket)ThreadLocalUtil.get("client");
            InputStream inputStream = null;
            try { 
                inputStream = client.getInputStream();
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return inputStream;
        }
    }

# 五、完成和spring的整合（重点内容） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 11]  
**5.1 使用ExposeService 注解标记的类，我们怎么获取到它**

**5.2.1 修改ExposeService 注解，让Spring 来管理该对象**

@Service @Controller  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 12]

**5.2.2 服务提供者和spring 整合的类**

public class ProviderSpringStater implements ApplicationContextAware , InitializingBean { 
    
        private ApplicationContext applicationContext ; // 这就是ioc
    
        private Register register ;
    
        private String ipAddr ;
    
        private int port ;
    
        Map<String,String> regiesters = new HashMap<>();
    
        /** * ioc 容器里面的对象已经创建完毕了 我们使用ExposeService 标记的类，它的对象也创建完毕了 * @param applicationContext * @throws BeansException */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
            this.applicationContext = applicationContext ;
            // 取出使用ExposeService 标记的对象
            /** * String 代表对象的名称 * Object：代表实例对象 * 使用ExposeService标记的类，我们需要把他注册到注册中心上面 * 注册时需要2 个属性 * 1 服务的名称 一般就是接口的名称 * 2 服务的地址 */
            Map<String, Object> beansWithAnnotation = this.applicationContext.getBeansWithAnnotation(ExposeService.class);
            if(!beansWithAnnotation.isEmpty()){ 
                beansWithAnnotation.forEach((name,object)->{ 
                    Class<?> interfacee = object.getClass().getInterfaces()[0];
                    regiesters.put(interfacee.getName(),ipAddr + ":" +port) ;// 把以后要注册到注册中心里面的服务都放在map 集合里面
                    /** * 为什么不直接注册呢？ * 因为现在对象的属性好没有注入，如果你的服务已经上线了，但是你的功能实现不了，那就是ppt的模型而已 * 那什么时候注册： * 我们完事具备后，才上线，让别人使用 */
                });
            }
    
        }
    
        /** * 就是当ioc 容器里面所以的属性都被注入完毕后执行的方法，那代表我们已经准备好了 * @throws Exception */
        @Override
        public void afterPropertiesSet() throws Exception { 
            if(!this.regiesters.isEmpty()){  // 不管你list 还是map ，都有foreach
                this.regiesters.forEach((serviceName,serviceAddress)->{ 
                    register.register(serviceName,serviceAddress); // 完成注册了
                });
            }
            /** * 服务注册完毕后干啥？ * 就开始要干活了，就有开始监听了 */
            new Thread(
                    ()->{ 
                        new ServerSocketNet(port); // 我们ServerSocketNet 有个死循环，代码还能往下走吗？不能走了，那有什么问题发生
                    }
            ).start();
    
        }
    }

老师，我们写代码的风格不一样，可以，只要你掌握思想，你怎么都行。我教你你的只是思想！

**5.2 @Ref的完成属性注入实现**  
@Autowired

代表属性的注入，那怎么注入属性，就有利用 BeanPostProcessor
    public class ConsumerProxyInject implements BeanPostProcessor { 
    
    
       /** * <bean init-method=""></bean> * 初始化方法之前执行 * @param bean * @param beanName * @return * @throws BeansException */
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
           return bean; // 这里不能返回null
       }
       /** * 我们注入代理对象就在init-method 方法之后执行 * 初始化方法之后 * @param bean * @param beanName * @return * @throws BeansException */
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
           // 只有使用@Ref 标记的属性，我们要给他注入一个代理的对象
           Class<?> clazz = bean.getClass();
           Field[] fields = clazz.getDeclaredFields();
           for (Field field : fields) { 
               Ref ref = field.getAnnotation(Ref.class);
               if(ref!=null){  // 该属性由ref 标记
                   field.setAccessible(true); // 暴力反射
                   Class<?> type = field.getType();
                   try { 
                       field.set(bean, ProxyUtil.createProxy(type)); // ref 注入的是代理对象
                   } catch (IllegalAccessException e) { 
                       e.printStackTrace();
                   }
                   field.setAccessible(false);// 开启安全策略
               }
           }
    
           return bean;
       }
    }

# 六、代码的完善 #

**6.1 本地调用获取ioc 容器LocalMethodInvoker**  
![在这里插入图片描述][20200205213933241.png]  
**6.2 远程方法的调用里面RpcMethodInvoker**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 13]  
**6.3 ClientSocketNet 里面**  
单例的实现：  
![在这里插入图片描述][202002052140028.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 14]

**6.4 ProxyUtil 里面**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 15]

**6.5 RpcMethodInvoker**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 16]

**6.6 使用ThreadLocal 获取服务名称的地方**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 17]

**6.7 ProviderSpringStater的补充**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 18]

**6.8 ServerSocketNet的补充**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 19]  
**6.9 LocaMethodInvoker的补充**  
![在这里插入图片描述][20200205214151492.png]

**6.10 LocalMethodInvoker 的ioc 的获取**

因为LocalMethodInvoker 是我们自己new ，导致，setApplicationContext不执行，我们获取不到ioc 容器。  
我们在ProviderSpringStater 添加一个：  
![在这里插入图片描述][20200205214234197.png]  
，就可以使用这里面的了  
![在这里插入图片描述][20200205214240319.png]

# 七、开始测试 #

**7.1 修改provider.xml 文件**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 20]

**7.2 启动测试**  
![在这里插入图片描述][20200205214313900.png]

服务提供者没有任何问题

**7.3 修改conusmer.xml**  
![在这里插入图片描述][20200205214335524.png]

**7.4 尝试远程调用的实现**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 21]

**7.5 bug的修复**  
![在这里插入图片描述][20200205214407366.png]

为啥长度只有288 个，已经读取完了，为啥还再次循环读了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 22]

读取的最后一个不是-1，导致又循环读取了  
我们需要给他添加一个结束的标记

![在这里插入图片描述][20200205214434470.png]

![在这里插入图片描述][20200205214446855.png]  
![在这里插入图片描述][2020020521445331.png]  
我多加了一个-1 ，对我反序列化又影响吗？  
没有影响，因为-1 在计算机是个非常特殊的标识，我们的程序读取到-1 ，一般任务它已经结束了，而且会把-1 去掉

[20200205205628311.png]: https://img-blog.csdnimg.cn/20200205205628311.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200205205825403.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205205836802.png]: https://img-blog.csdnimg.cn/20200205205836802.png
[20200205205923446.png]: https://img-blog.csdnimg.cn/20200205205923446.png
[20200205210043742.png]: https://img-blog.csdnimg.cn/20200205210043742.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200205210102765.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200205210226172.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200205210246318.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205210254427.png]: https://img-blog.csdnimg.cn/20200205210254427.png
[20200205210331118.png]: https://img-blog.csdnimg.cn/20200205210331118.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200205210344544.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200205210359679.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205210427140.png]: https://img-blog.csdnimg.cn/20200205210427140.png
[20200205210448658.png]: https://img-blog.csdnimg.cn/20200205210448658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200205212507928.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200205212530115.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205212651187.png]: https://img-blog.csdnimg.cn/20200205212651187.png
[20200205212755524.png]: https://img-blog.csdnimg.cn/20200205212755524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200205212802772.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205212816515.png]: https://img-blog.csdnimg.cn/20200205212816515.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200205212851789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200205213618430.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200205213705556.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200205213736663.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205213933241.png]: https://img-blog.csdnimg.cn/20200205213933241.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200205213944200.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[202002052140028.png]: https://img-blog.csdnimg.cn/202002052140028.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2020020521400778.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200205214024153.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200205214043549.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200205214056906.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20200205214110265.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20200205214134174.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205214151492.png]: https://img-blog.csdnimg.cn/20200205214151492.png
[20200205214234197.png]: https://img-blog.csdnimg.cn/20200205214234197.png
[20200205214240319.png]: https://img-blog.csdnimg.cn/20200205214240319.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20200205214259863.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205214313900.png]: https://img-blog.csdnimg.cn/20200205214313900.png
[20200205214335524.png]: https://img-blog.csdnimg.cn/20200205214335524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20200205214348424.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205214407366.png]: https://img-blog.csdnimg.cn/20200205214407366.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/2020020521441521.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjIzNDQ3,size_16,color_FFFFFF,t_70
[20200205214434470.png]: https://img-blog.csdnimg.cn/20200205214434470.png
[20200205214446855.png]: https://img-blog.csdnimg.cn/20200205214446855.png
[2020020521445331.png]: https://img-blog.csdnimg.cn/2020020521445331.png