2个springboot项目，通过socket连接以后，如何互相访问controller

如果两个Spring Boot项目之间建立了Socket连接，它们可以通过自定义协议来进行通信。在协议中，可以定义一些请求的格式和响应的格式，以及相应的处理逻辑。具体来说，可以在每个Spring Boot项目中定义一个接口，用来处理其他项目发送过来的请求。在接口的实现类中，可以调用本地的Controller来处理请求，并将处理结果封装成响应发送回去。

举个例子，假设A项目想要调用B项目中的UserController，可以定义一个类似下面的请求格式：

{
    "action": "getUserInfo",
    "params": {
        "userId": "123"
    }
}

其中，`action`表示要执行的操作，`params`表示操作需要的参数。B项目在接收到这个请求后，可以解析出`action`和`params`，然后调用本地的UserController处理请求，最后将处理结果封装成响应格式发送回去。

需要注意的是，这种方式存在一定的安全风险，因为任何其他项目都可以通过Socket连接来访问你的Controller。因此，在使用时需要注意数据的安全性和合法性，防止出现安全漏洞。

相关问题

2个springboot项目，通过socket连接以后，如何互相访问controller方法，给一个案例

好的，下面给一个简单的案例。

假设我们有两个Spring Boot项目，分别是A项目和B项目。现在我们要实现A项目调用B项目中的UserController的getUserInfo方法。

首先，在B项目中定义一个UserController，如下：

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/{userId}")
    public User getUserInfo(@PathVariable String userId) {
        // 根据userId查询用户信息
        User user = new User();
        user.setUserId(userId);
        user.setUserName("张三");
        user.setAge(20);
        return user;
    }

}

这个Controller的作用是根据userId查询用户信息。

接下来，在A项目中定义一个类，用于向B项目发送请求并获取响应。我们可以使用Java自带的Socket类来实现。

public class SocketClient {

    public static void main(String[] args) throws IOException {
        // 连接B项目的Socket服务器
        Socket socket = new Socket("127.0.0.1", 8888);
        // 发送请求
        String request = "{\"action\": \"getUserInfo\", \"params\": {\"userId\": \"123\"}}";
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(request.getBytes());
        outputStream.flush();
        // 接收响应
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
        }
        String response = baos.toString();
        System.out.println(response);
        // 关闭资源
        baos.close();
        inputStream.close();
        outputStream.close();
        socket.close();
    }

}

这个类的作用是向B项目发送一个请求，请求B项目中的UserController的getUserInfo方法，并将响应打印出来。

最后，在B项目中定义一个类，用于监听A项目的请求并调用UserController的相应方法。

public class SocketServer {

    public static void main(String[] args) throws IOException {
        // 启动Socket服务器
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true) {
            // 监听客户端的连接
            Socket socket = serverSocket.accept();
            // 处理请求
            new Thread(() -> {
                try {
                    InputStream inputStream = socket.getInputStream();
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    byte[] buffer = new byte[1024];
                    int len;
                    while ((len = inputStream.read(buffer)) != -1) {
                        baos.write(buffer, 0, len);
                    }
                    String request = baos.toString();
                    // 解析请求
                    JSONObject jsonObject = JSONObject.parseObject(request);
                    String action = jsonObject.getString("action");
                    JSONObject params = jsonObject.getJSONObject("params");
                    // 调用UserController的方法
                    if ("getUserInfo".equals(action)) {
                        String userId = params.getString("userId");
                        UserController userController = new UserController();
                        User user = userController.getUserInfo(userId);
                        // 封装响应
                        String response = JSON.toJSONString(user);
                        OutputStream outputStream = socket.getOutputStream();
                        outputStream.write(response.getBytes());
                        outputStream.flush();
                        // 关闭资源
                        outputStream.close();
                    }
                    baos.close();
                    inputStream.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

}

这个类的作用是启动一个Socket服务器，监听A项目的请求，并根据请求调用UserController的相应方法，并将处理结果封装成响应发送给A项目。

这样，当我们运行SocketClient类时，就可以从B项目中的UserController获取到用户信息，并将信息打印出来。

提供一个springboot项目客户端通过socket连接服务端并且互相发送信息的方法，

下面是一个简单的Spring Boot项目，演示如何使用Socket建立客户端和服务端之间的连接并发送消息：

首先，创建一个Spring Boot项目，并添加以下依赖项：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

接下来，在项目中创建一个WebSocketController类，该类负责处理WebSocket连接和消息：

import org.springframework.stereotype.Component;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

@Component
@EnableWebSocket
public class WebSocketController implements WebSocketConfigurer {
    
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new SocketHandler(), "/socket").setAllowedOrigins("*");
    }

    public class SocketHandler extends TextWebSocketHandler {

        @Override
        public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
            System.out.println("Received message: " + message.getPayload());
            session.sendMessage(new TextMessage("Hello, " + message.getPayload() + "!"));
        }

    }

}

在上面的代码中，我们实现了WebSocketConfigurer接口，并在registerWebSocketHandlers()方法中注册了一个SocketHandler处理程序，用于处理WebSocket连接和消息。在SocketHandler类中，我们实现了handleTextMessage()方法来处理接收到的文本消息，并发送一个回复。

然后，在客户端代码中，我们可以使用Java的Socket类来连接WebSocket服务器，并发送和接收消息：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class SocketClient {

    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);

            // 发送消息到服务器
            writer.println("World");

            // 接收服务器的响应
            String response = reader.readLine();
            System.out.println("Received response: " + response);

            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

在上面的代码中，我们创建了一个Socket对象并连接到WebSocket服务器。然后，我们使用PrintWriter对象向服务器发送消息，并使用BufferedReader对象接收服务器的响应。

最后，我们需要运行Spring Boot应用程序，并运行SocketClient类来测试客户端和服务器之间的通信。