java socket通讯
平时日常开发用得最多是Http通讯，接口调试也比较简单的，也有比较强大的框架支持（OkHttp）。
socket是基于TCP/IP通讯，但使用socket通讯问题不少，一般有两个难点：
- 1.socket通讯层要自己写及IO流不正确使用，遇到读取不到数据或者阻塞卡死现象或者数据读取不完整
- 2.请求和响应报文格式多变（json,xml,其它），解析麻烦，如果是前面两种格式都简单，有对应框架处理，其它格式一般都需要自己手动处理。
第1点问题归根结底是使用read()或readLine()导致的问题
Socket使用流程
- 创建socket
- 连接socket
- 获取输入输出流
字节流：
InputStream mInputStream = mSocket.getInputStream();
OutputStream mOutputStream = mSocket.getOutputStream();
字符流：
BufferedReader mBufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream(), "UTF-8"));
PrintWriter mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(mSocket.getOutputStream(), "UTF-8")), true);
至于实际使用字节流还是字符流，看实际情况使用。如果返回是字符串及读写与报文结束符(/r（0x0A）或/n（0x0D）或/r/n)有关，使用字符流读取，否则字节流。
-
读写数据
-
关闭socket
如果是Socket短连接，上面五个步骤都要走一遍；
如果是Socket长连接，只需关注第4点即可，第4点使用不慎就会遇到上面出现的问题。
实际开发中，长连接使用居多，一次连接，进行多次收发数据。
特别注意：使用长连接不能读完数据后立马关闭输入输出流，必须再最后不使用的时候关闭
Socket数据读写
当socket阻塞时，必须设置读取超时时间，防止调试时，socket读取数据长期挂起。
mSocket.setSoTimeout(10* 1000); //设置客户端读取服务器数据超时时间
使用read()读取阻塞问题
日常写法1：
mOutputStream.write(bytes);
mOutputStream.flush();
byte[] buffer = new byte[1024];
int n = 0;
ByteArrayOutputStream output = new ByteArrayOutputStream();
while (-1 != (n = mInputStream .read(buffer))) {
output.write(buffer, 0, n);
}
//处理数据
output.close();
byte[] result = output.toByteArray();
上面看似没有什么问题，但有时候会出现mInputStream .read(buffer)阻塞，导致while循环体里面不会执行
日常写法2：
mOutputStream.write(bytes);
mOutputStream.flush();
int available = mInputStream.available();
byte[] buffer = new byte[available];
in.read(buffer);
上面虽然不阻塞，但不一定能读取到数据，available 可能为0，由于是网络通讯，发送数据后不一定马上返回。
或者对mInputStream.available()修改为：
int available = 0;
while (available == 0) {
available = mInputStream.available()；
}
上面虽然能读取到数据，但数据不一定完整。
而且，available方法返回估计的当前流可用长度，不是当前通讯流的总长度，而且是估计值；read方法读取流中数据到buffer中，但读取长度为1至buffer.length，若流结束或遇到异常则返回-1。
最终写法（递归读取）：
/**
* 递归读取流
*
* @param output
* @param inStream
* @param timeout 单位毫秒，看实际情况定义（如果socket通讯超时时间略长，如果用于硬件串口数据读取则略短），可以指定200毫秒，10*1000或20*1000
* @return
* @throws Exception
*/
public void readStreamWithRecursion(ByteArrayOutputStream output, InputStream inStream, int timeout) throws Exception {
long start = System.currentTimeMillis();
while (inStream.available() == 0) {
if ((System.currentTimeMillis() - start) > timeout) {//超时退出
throw new SocketTimeoutException("超时读取");
}
}
byte[] buffer = new byte[2048];
int read = inStream.read(buffer);
output.write(buffer, 0, read);
SystemClock.sleep(100);//需要延时以下，不然还是有概率漏读
int a = inStream.available();//再判断一下，是否有可用字节数或者根据实际情况验证报文完整性
if (a > 0) {
LogUtils.w("========还有剩余：" + a + "个字节数据没读");
readStreamWithRecursion(output, inStream,timeout);
}
}
/**
* 读取字节
*
* @param inStream
* @param timeout
* @return
* @throws Exception
*/
private byte[] readStream(InputStream inStream, int timeout) throws Exception {
ByteArrayOutputStream output = new ByteArrayOutputStream();
readStreamWithRecursion(output, inStream,timeout);
output.close();
int size = output.size();
LogUtils.i("本次读取字节总数：" + size);
return output.toByteArray();
}
上面流读取的时候给定一个读超时时间，并在读取完成一次后，固定等待时间，等待完不一定有数据，若没有有数据，响应时间过长，会影响用户体验。我们可以再优化一下：
/**
* 递归读取流
*
* @param output
* @param inStream
* @param timeout
* @return
* @throws Exception
*/
public void readStreamWithRecursion(ByteArrayOutputStream output, InputStream inStream, int timeout) throws Exception {
long start = System.currentTimeMillis();
while (inStream.available() == 0) {
if ((System.currentTimeMillis() - start) >timeout) {//超时退出
throw new SocketTimeoutException("超时读取");
}
}
byte[] buffer = new byte[2048];
int read = inStream.read(buffer);
output.write(buffer, 0, read);
int wait = readWait();
long startWait = System.currentTimeMillis();
boolean checkExist = false;
while (System.currentTimeMillis() - startWait <= wait) {
int a = inStream.available();
if (a > 0) {
checkExist = true;
// LogUtils.w("========还有剩余：" + a + "个字节数据没读");
break;
}
}
if (checkExist) {
readStreamWithRecursion(output, inStream, timeout);
}
}
/**
* 二次读取最大等待时间，单位毫秒
*/
protected int readWait() {
return 100;
}
/**
* 读取字节
*
* @param inStream
* @param timeout
* @return
* @throws Exception
*/
private byte[] readStream(InputStream inStream, int timeout) throws Exception {
ByteArrayOutputStream output = new ByteArrayOutputStream();
readStreamWithRecursion(output, inStream,timeout);
output.close();
int size = output.size();
LogUtils.i("本次读取字节总数：" + size);
return output.toByteArray();
}
上面这种延迟率大幅降低，目前正在使用该方法读取，再也没有出现数据读取不完整和阻塞现象。不过这种，读取也要注意报文结束符问题，何时读取完毕问题。
上面适合于客服端主动向服务端发起请求响应处理（一问一答），不适合做监听服务端数据处理，监听还得轮询阻塞方式处理
上面字节流readStreamWithRecursion方法使用备注：
- 如果是socket通讯建议设置mSocket.setSoTimeout读超时时间，
readStreamWithRecursion方法读取超时时间小于SoTimeout - 如果是用于硬件通讯流数据读取，非常合适，可以对发送的任意指令设置读取超时间时间
补充
如果你实际Socket通讯数据包格式是有一定规则的，可以把InputStream、OutputStream 分别装饰成 DataOutputStream、DataOutputStream：
public DataInputStream(InputStream in) { super(in);}
public DataOutputStream(OutputStream out) { super(out); }
这样更方便读写数据，边读边解析数据，转成相应的基本Java数据类型。这与上面使用read()一次性读取数据到ByteArrayOutputStream ，然后根据byte[]提取相应的数据。不过这两种方式各有优缺点，看具体情况使用。
关于这两个DataOutputStream、DataOutputStream的具体用法参考文章
全网最全的Java Socket通讯例子:https://blog.csdn.net/u011082160/article/details/119464306
使用readreadLine()读取阻塞问题
日常写法：
mPrintWriter.print(sendData+ "\r\n");
mPrintWriter.flush();
String msg = mBufferedReader.readLine();
//处理数据
发送数据时添加了结束符，如果不加结束符，导致readLine()阻塞，读不到任何数据，最终抛出SocketTimeoutException异常
特别注意：
报文结束符：根据实际服务器规定的来添加，必要时问后端开发人员或者看接口文档是否有说明
不然在接口调试上会浪费很多宝贵的时间，影响后期功能开发。
使用readLine()注意事项：
-
读入的数据要注意有/r或/n或/r/n
这句话意思是服务端写完数据后，会打印报文结束符/r或/n或/r/n；
同理，客户端写数据时也要打印报文结束符，这样服务端才能读取到数据。 -
没有数据时会阻塞，在数据流异常或断开时才会返回null
-
使用socket之类的数据流时，要避免使用readLine()，以免为了等待一个换行/回车符而一直阻塞
上面长连接是发送一次数据和读一次数据，保证了当次通讯的完整性，必须要时需要同步处理。
也有长连接，客户端开线程循环阻塞等待服务端数据发送数据过来，比如：消息推送。平时使用长连接都是分别使用不同的命令发送数据且接收数据，来完成不同的任务。
总结
实际开发中，长连接比较复杂，还要考虑心跳，丢包，断开重连等问题。使用长连接时，要特别注意报文结束符问题，结束符只是用来告诉客户端或服务端数据已经发送完毕，客户端或服务端可以读取数据了，否则客户端或服务端会一直阻塞在read()或者readLine()方法。
创建socket服务
package com.z.socket;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Component
@Slf4j
public class ServerSocketConfig {
public static ServerSocket serverSocket = null;
private static final ThreadPoolExecutor threadpool = new ThreadPoolExecutor(15, 15,
10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
@Bean
public void socketCreate() {
// 使用多线程创建，accept() 会阻塞程序执行（后面代码不能被执行）
Runnable socketRun = new Thread() {
@Override
public void run() {
log.info("创建socket线程");
try {
serverSocket = new ServerSocket(514);
log.info("socket服务端开启");
while (true) {
Socket socket = serverSocket.accept();
log.info("接收到客户端socket" + socket.getRemoteSocketAddress());
threadpool.execute(new ServerReceiveThread(socket));
}
} catch (IOException e) {
log.info("socket服务启动异常");
e.printStackTrace();
}
}
};
new Thread(socketRun).start();
}
}
监听数据
package com.z.config.socket;
import lombok.extern.slf4j.Slf4j;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
@Slf4j
public class ServerReceiveThread implements Runnable {
private Socket socket;
public ServerReceiveThread(Socket socket) {
this.socket = socket;
}
/**
* 解析为十六进制数据
*/
private String getCode(byte[] req) {
String HEXES = "0123456789ABCDEF";
final StringBuilder hex = new StringBuilder(2 * req.length);
for (int i = 0; i < req.length; i++) {
byte b = req[i];
hex.append(HEXES.charAt((b & 0xF0) >> 4))
.append(HEXES.charAt((b & 0x0F))).append(" ");
}
return hex.toString();
}
@Override
public void run() {
try {
// 接收客户端信息
InputStream inputStream = socket.getInputStream();
// 发送客户端信息
OutputStream outputStream = socket.getOutputStream();
ByteArrayOutputStream out = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(out);
byte[] b = new byte[1024];
int len = 0;
while ((len = inputStream.read(b)) != -1) {
dout.write(b, 0, len);
}
String data = getCode(out.toByteArray());
log.info("服务器收到消息：{}", data);
log.info("服务器解析消息: {}", out.toString());
String msg = "server response success";
outputStream.write(msg.getBytes());
# 关闭流
dout.close();
out.close();
inputStream.close();
outputStream.close();
socket.close();
} catch (Exception e) {
log.info("接收数据异常socket关闭");
e.printStackTrace();
} finally {
log.info("数据异常数据要怎么保留");
}
}
}
socket监听多个端口
创建
package com.z.socket;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Component
@Slf4j
public class ServerSocketConfig {
private static final ThreadPoolExecutor threadpool = new ThreadPoolExecutor(15, 15,
10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
@Bean
public void socketCreate() {
List<Integer> list = ListUtil.toList(514, 515);
for (Integer port : list) {
// 使用多线程创建，accept() 会阻塞程序执行（后面代码不能被执行）
Runnable socketRun = new Thread() {
@Override
public void run() {
log.info("创建socket线程");
try {
// 每个socket监听端口对应一个对象
ServerSocket serverSocket = new ServerSocket(port);
log.info("socket服务端开启");
while (true) {
Socket socket = serverSocket.accept();
log.info("接收到客户端socket" + socket.getRemoteSocketAddress());
threadpool.execute(new ServerReceiveThread(socket));
}
} catch (IOException e) {
log.info("socket服务启动异常");
e.printStackTrace();
}
}
};
new Thread(socketRun).start();
}
}
}
监听
@Override
public void run() {
// 监听到的端口号
int port = socket.getLocalPort();
if (port == 514) {
// do ...
}else if(port == 515){
// do ...
}
}
原文章地址：
https://blog.csdn.net/u011082160/article/details/100779231
