Java 读取时重置连接（）

我正在尝试基于web套接字技术实现服务器和客户端，但在运行TCPDataServer类时，出现以下错误：

java.io.IOException: connection reset
at java.io.DataInputStream.read(Unknown Source)
at org.server.ClientWorker.run(TCPDataServer.java:67)
at java.lang.Thread.run(Unknown Source)

我期望得到以下输出

你好，我是亚历克斯

TCPDataClient

package org.client;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPDataClient {

    public static void main(String[] args) {
        try {
            TCPDataClient obj = new TCPDataClient();
            Socket obj_client = new Socket(InetAddress.getByName("127.0.1"), 1000);
            DataInputStream din = new DataInputStream(obj_client.getInputStream());
            DataOutputStream dout = new DataOutputStream(obj_client.getOutputStream());
            byte[] buffer = obj.createDataPacket("Hello, I am Alex!".getBytes("UTF8"));
            dout.write(buffer);

        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    private byte[] createDataPacket(byte[] data) {

        byte[] packet = null;
        try {
            byte[] initialize = new byte[1];
            initialize[0] = 2;
            byte[] separator = new byte[1];
            separator[0] = 4;
            byte[] data_length = String.valueOf(data.length).getBytes("UIF8");
            packet = new byte[initialize.length + separator.length + data_length.length + data.length];

            System.arraycopy(initialize, 0, packet, 0, initialize.length);
            System.arraycopy(data_length, 0, packet, initialize.length, data_length.length);
            System.arraycopy(separator, 0, packet, initialize.length + data_length.length, separator.length);
            System.arraycopy(data, 0, packet, initialize.length + data_length.length + separator.length, data.length);


        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }
        return packet;

    }

}

TCPDataServer

package org.server;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.logging.Level;

import com.sun.istack.internal.logging.Logger;

public class TCPDataServer {

    public static void main(String[] args) {

        try {
            ServerSocket server_socket = new ServerSocket(1000);
            while (true) {
                new Thread(new ClientWorker(server_socket.accept())).start();
            }
        } catch (IOException e) {
              System.err.println("Error");
              System.err.println(e);
              System.err.println("\n2");
              System.err.println(e.getMessage());
              System.err.println("\n3");
              System.err.println(e.getLocalizedMessage());
              System.err.println("\n4");
              System.err.println(e.getCause());
              System.err.println("\n5");
              System.err.println(Arrays.toString(e.getStackTrace()));
              System.err.println("\n6");
              e.printStackTrace();
        }

    }

}

class ClientWorker implements Runnable {
    private Socket target_socket;
    private DataInputStream din;
    private DataOutputStream dout;

    public ClientWorker(Socket recv_scket) {

        try {
            target_socket = recv_scket;
            din = new DataInputStream(target_socket.getInputStream());
            dout = new DataOutputStream(target_socket.getOutputStream());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true) {
            byte[] initilize = new byte[1];
            try {
                din.read(initilize, 0, initilize.length);
                if (initilize[0] == 2) {
                    //This is line 67.
                    System.out.println(new String(readStream()));

                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    private byte[] readStream() {
        byte[] data_buff = null;

        try {
            int b = 0;
            String buff_length = "";
            while ((b = din.read()) != 4) {
                buff_length += (char) b;
            }
            int data_length = Integer.parseInt(buff_length);
            data_buff = new byte[Integer.parseInt(buff_length)];
            int byte_read = 0;
            int byte_offset = 0;
            while (byte_offset < data_length) {
                byte_read = din.read(data_buff, byte_read, data_length - byte_offset);
                byte_offset += byte_read;

            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return data_buff;

    }

}

package org.server；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.array；
导入java.util.logging.Level；
导入com.sun.istack.internal.logging.Logger；
公共类TCPDataServer{
公共静态void main（字符串[]args）{
试一试{
ServerSocket服务器\ U套接字=新的ServerSocket（1000）；
while（true）{
新线程（新ClientWorker（server_socket.accept（））.start（）；
}
}捕获（IOE异常）{
System.err.println（“错误”）；
系统错误println（e）；
系统错误println（“\n2”）；
System.err.println（e.getMessage（））；
System.err.println（“\n3”）；
System.err.println（e.getLocalizedMessage（））；
System.err.println（“\n4”）；
System.err.println（e.getCause（））；
System.err.println（“\n5”）；
System.err.println（Arrays.toString（e.getStackTrace（））；
System.err.println（“\n6”）；
e、 printStackTrace（）；
}
}
}
类ClientWorker实现Runnable{
专用套接字目标\ U套接字；
私有数据输入流；
私有数据输出流dout；
公共客户端工作者（套接字接收器）{
试一试{
目标插座=接收器插座；
din=新的DataInputStream（target_socket.getInputStream（））；
dout=新的DataOutputStream（target_socket.getOutputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
@凌驾
公开募捐{
while（true）{
字节[]初始化=新字节[1]；
试一试{
din.read（initilize，0，initilize.length）；
if（初始化[0]==2）{
//这是第67行。
System.out.println（新字符串（readStream（））；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
专用字节[]readStream（）{
字节[]数据\u buff=null；
试一试{
int b=0；
字符串buff_length=“”；
而（（b=din.read（））！=4）{
buff_length+=（char）b；
}
int data_length=Integer.parseInt（buff_length）；
data_buff=新字节[Integer.parseInt（buff_长度）]；
int byte_read=0；
int字节_偏移量=0；
while（字节偏移量<数据长度）{
字节读取=din.read（数据缓冲、字节读取、数据长度-字节偏移）；
字节\偏移量+=字节\读取；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回数据_buff；
}
}
您没有关闭套接字，因此当JVM退出时，您的操作系统正在重置它们。
应该是
127.0.0.1
而不是
127.0.1
？是的，我更改了它，但我现在得到了
java.net.SocketException:java.net.SocketInputStream.read的连接重置（未知源代码）java.net.SocketInputStream.read（未知源代码）在java.lang.Thread.run（未知源代码）的org.server.ClientWorker.run（TCPDataServer.java:65）的java.io.DataInputStream.read（未知源代码）
run（）方法中的这一行…din.read（initilize，0，initilize.length）；另一个被发现的问题是，只有
UTF-8
没有
UIF-8
。尽管如此，这仍然是不相关的。顺便说一句@pemapmoder，127.0.1是编写127.0.0.1的一种完全有效的替代方法。（其他方法包括127.1和2130706433）谢谢你的回答！我关闭了这个套接字，就像这样`byte[]buffer=obj.createDataPacket](“你好，我是Alex！”.getBytes（“UTF-8”）；dout.write（缓冲区）；din.close（）；dout.close（）；obj_client.close（）；`但我仍然得到
java.net.SocketException:java.net.SocketInputStream.read（未知源代码）的java.net.SocketInputStream.read（未知源代码）的java.io.DataInputStream.read（未知源代码）的连接重置org.server.ClientWorker.run（TCPDataServer.java:65）java.lang.Thread.run（未知源代码）