java socket客户端请求并获取响应数据

话不多说，直接入题，代码说明详细，菜鸡也能看懂，拒绝网上各种搬砖文章

---

什么是socket，自己百度了

---

 socket连接工具类

---

import com.example.demo.service.dto.SocketResponseDTO;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.Objects;

public class SocketClient {

    private final static Logger log = LoggerFactory.getLogger(SocketClient.class);

    /**
     * 错误消息
     * */
    private final static String HOST_OR_PROT_NULL = "socket连接信息不正确，ip: %s，port: %d";
    private final static String SOCKET_NOT_RESPONSE = "socket服务无响应数据，ip: %s，port: %d";
    private final static String SOCKET_LINK_FAIL = "socket连接失败，请检查相应socket服务是否已开启，ip: %s，port: %d";
    private final static String SOCKET_TIMEOUT = "socket请求超时，ip: %s，port: %d";
    private final static String SOCKET_EXCEPTION = "socket请求IO异常，ip: %s，port: %d";

    /**
     * socket请求
     * @return
     */
    public static SocketResponseDTO request(String host, int port) {
        return request(host, port, null);
    }

    /**
     * socket请求
     * @param host ip
     * @param port 端口
     * @param param 请求参数
     * @return
     */
    public static SocketResponseDTO request(String host, int port, byte[] param) {
        SocketResponseDTO socketResponse = new SocketResponseDTO();
        socketResponse.setRequest(param);
        if (StringUtils.isBlank(host) || Objects.isNull(port)) {
            socketResponse.setErrorMsg(String.format(HOST_OR_PROT_NULL, host, port));
            return socketResponse;
        }

        try (
            // 与服务端建立连接
            Socket socket = new Socket(host, port);
            // 输出数据流
            OutputStream socketOutputStream = socket.getOutputStream();
            // 输入数据流
            InputStream socketInputStream = socket.getInputStream();
        ){
            // 60s超时
            socket.setSoTimeout(60000);
            if (Objects.nonNull(param)) {
                // 建立连接后获得输出流，发送数据
                socketOutputStream.write(param);
            }
            // 通过shutdownOutput 告诉接收端已经发送完数据，客户端后续只能接受数据
            socket.shutdownOutput();
            socketResponse.setAlreadyResq(true);
            //读取服务器返回的消息
            if (socketInputStream != null && !socketInputStream.markSupported()) {
                int readIndex;
                byte[] bytes = new byte[1024];
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                while ((readIndex = socketInputStream.read(bytes)) > -1) {
                    byteArrayOutputStream.write(bytes, 0, readIndex);
                }
                socketResponse.setResponse(byteArrayOutputStream.toByteArray());
            } else {
                socketResponse.setErrorMsg(String.format(SOCKET_NOT_RESPONSE, host, port));
            }
        } catch (ConnectException e) {
            socketResponse.setErrorMsg(String.format(SOCKET_LINK_FAIL, host, port));
            log.error(socketResponse.getErrorMsg(), e);
        } catch (SocketTimeoutException e) {
            socketResponse.setAlreadyResq(true);
            socketResponse.setErrorMsg(String.format(SOCKET_TIMEOUT, host, port));
            log.error(socketResponse.getErrorMsg());
        } catch (IOException e) {
            socketResponse.setAlreadyResq(true);
            socketResponse.setErrorMsg(String.format(SOCKET_EXCEPTION, host, port));
            log.error(socketResponse.getErrorMsg(), e);
        }
        return socketResponse;
    }
}

---

响应DTO

---

import java.io.Serializable;

/**
 * socket请求响应DTO
 * */
public class SocketResponseDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 请求报文
     * */
    private byte[] request;

    /**
     * 错误信息
     * */
    private String errorMsg;

    /**
     * 是否已发送
     * */
    private boolean isAlreadyResq = false;

    /**
     * 响应报文
     * */
    private byte[] response;

    public byte[] getRequest() {
        return request;
    }

    public void setRequest(byte[] request) {
        this.request = request;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public boolean isAlreadyResq() {
        return isAlreadyResq;
    }

    public void setAlreadyResq(boolean alreadyResq) {
        isAlreadyResq = alreadyResq;
    }

    public byte[] getResponse() {
        return response;
    }

    public void setResponse(byte[] response) {
        this.response = response;
    }
}

---

测试使用 

---

先模拟一个socket服务端，并运行它

public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(15999);
            System.out.println("启动成功，等待客户端连接。。。。");
            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("客户端连接成功。。。");
                try(
                        InputStream inputStream = socket.getInputStream();
                        OutputStream outputStream = socket.getOutputStream();
                        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                        )
                {
                    int b;
                    byte[] bytes = new byte[1024];
                    while ((b = inputStream.read(bytes)) != -1) {
                        byteArrayOutputStream.write(bytes, 0, b);
                    }
                    System.out.println("接收客户端消息：" + new String(byteArrayOutputStream.toByteArray()));
                    outputStream.write("这是要返回客户端的消息".getBytes());
                }
                if (socket.isClosed()) {
                    System.out.println("客户端断开");
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

运行后会等待客户端连接 

然后再找另一个类也定义一个main方法，并运行它

public static void main(String[] args) {
        SocketResponseDTO response = SocketClient.request("127.0.0.1", 15999, "这是服务端要接收的消息".getBytes());
        if (StringUtils.isBlank(response.getErrorMsg())) {
            System.out.println("错误消息：" + response.getErrorMsg());
        } else {
            System.out.println("客户端收到消息：" + new String(response.getResponse()));
        }
    }

 运行之后，服务端的消息界面

客户端的消息界面

---

码字不易，于你有利，勿忘点赞