【RPC注册发现框架实战】一个简易的RPC注册发现框架

Java实现 服务端起10个线程ID监听40-49这10个端口，这10个端口注册到注册中心，提供同一个服务，发个A，响应B，客户端起10个线程去注册中心请求
好的，我们可以通过实现一个简单的服务端、注册中心和客户端来达到这个目标。以下是详细的代码示例：
服务端代码

1. import java.io.*;
2. import java.net.*;
3. import java.util.concurrent.*;
5. public class MultiPortServer {
6.     private static final int PORT_START = 40;
7.     private static final int PORT_END = 49;
8.     private static final ExecutorService executor = Executors.newFixedThreadPool(PORT_END - PORT_START + 1);
10.     public static void main(String[] args) {
11.         for (int port = PORT_START; port <= PORT_END; port++) {
12.             int finalPort = port;
13.             executor.submit(() -> startServer(finalPort));
14.             RegistryCenter.registerService(finalPort, "localhost");
15.         }
16.     }
18.     private static void startServer(int port) {
19.         try (ServerSocket serverSocket = new ServerSocket(port)) {
20.             System.out.println("Server listening on port " + port);
21.             while (true) {
22.                 Socket clientSocket = serverSocket.accept();
23.                 handleClient(clientSocket);
24.             }
25.         } catch (IOException e) {
26.             e.printStackTrace();
27.         }
28.     }
30.     private static void handleClient(Socket clientSocket) {
31.         try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
32.              PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
33.             String message = in.readLine();
34.             if ("A".equals(message)) {
35.                 out.println("B");
36.             } else {
37.                 out.println("Unknown message");
38.             }
39.         } catch (IOException e) {
40.             e.printStackTrace();
41.         }
42.     }
43. }

复制代码

注册中心代码

1. import java.util.*;
2. import java.util.concurrent.*;
4. public class RegistryCenter {
5.     private static final Map<Integer, String> serviceRegistry = new ConcurrentHashMap<>();
7.     public static void registerService(int port, String address) {
8.         serviceRegistry.put(port, address);
9.         System.out.println("Service registered on port " + port + " at address " + address);
10.     }
12.     public static String lookupService(int port) {
13.         return serviceRegistry.get(port);
14.     }
16.     public static List<Integer> getAllServicePorts() {
17.         return new ArrayList<>(serviceRegistry.keySet());
18.     }
19. }

复制代码

客户端代码

1. import java.io.*;
2. import java.net.*;
3. import java.util.List;
4. import java.util.concurrent.ExecutorService;
5. import java.util.concurrent.Executors;
7. public class Client {
8.     private static final int CLIENT_COUNT = 10;
9.     private static final ExecutorService executor = Executors.newFixedThreadPool(CLIENT_COUNT);
11.     public static void main(String[] args) {
12.         List<Integer> servicePorts = RegistryCenter.getAllServicePorts();
14.         for (int i = 0; i < CLIENT_COUNT; i++) {
15.             executor.submit(() -> {
16.                 int portIndex = (int) (Math.random() * servicePorts.size());
17.                 int servicePort = servicePorts.get(portIndex);
18.                 queryService(servicePort);
19.             });
20.         }
22.         executor.shutdown();
23.     }
25.     private static void queryService(int servicePort) {
26.         String serviceAddress = RegistryCenter.lookupService(servicePort);
27.         if (serviceAddress != null) {
28.             try (Socket socket = new Socket(serviceAddress, servicePort);
29.                  PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
30.                  BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
31.                 out.println("A");
32.                 String response = in.readLine();
33.                 System.out.println("Response from server on port " + servicePort + ": " + response);
34.             } catch (IOException e) {
35.                 e.printStackTrace();
36.             }
37.         } else {
38.             System.out.println("No service found on port " + servicePort);
39.         }
40.     }
41. }

复制代码

运行步骤

• 启动服务端：
  
  
  
  • 运行 MultiPortServer 类。它将启动10个线程，每个线程监听一个端口（40-49），并将这些服务注册到注册中心。
    
  
  
• 启动客户端：
  
  
  
  • 运行 Client 类。它将启动10个客户端线程，每个线程随机选择一个服务端口，从注册中心获取该端口的服务地址，并发送消息 “A”。
    
  
  

阐明

• 服务端：
  
  
  
  • MultiPortServer 类创建一个线程池，每个线程监听一个特定端口，并将该端口的服务注册到 RegistryCenter。
    
  • 每个服务端口吸取到消息 “A” 后，响应消息 “B”。
    
  
  
• 注册中心：
  
  
  
  • RegistryCenter 类负责管理服务的注册和查询。
    
  • 提供了 registerService 方法用于注册服务，lookupService 方法用于查询服务地址，getAllServicePorts 方法用于获取所有注册的服务端口。
    
  
  
• 客户端：
  
  
  
  • Client 类创建一个线程池，启动10个客户端线程，每个线程随机选择一个服务端口，向服务端发送消息 “A”，并打印服务端的响应。
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。