Java Socket编程

合集下载

java socket flush方法断开的管道 -回复

java socket flush方法断开的管道-回复java中的Socket类提供了一种在网络上进行通信的方式。

在实际应用中，我们经常会遇到断开通信管道的情况，也就是网络连接的断开。

为了应对这种情况，我们可以使用Socket类中的flush方法来确保数据发送成功并断开连接。

本文将一步一步详细解释Java Socket的flush方法以及如何处理断开的管道。

一、Socket类概述Socket类是Java提供的用于网络编程的类，它提供了建立客户端和服务器之间通信的能力。

通过Socket类，我们可以连接到远程主机，向远程主机发送数据，以及接收远程主机发送的数据。

二、Socket类的flush方法flush方法是Socket类中提供的一个用于刷新输出流的方法。

在网络通信中，客户端通过输出流向服务器发送数据，而服务器则通过输入流接收这些数据。

当调用flush方法时，它会强制将输出流中的数据发送到服务器，并清空输出流，以确保发送成功。

三、flush方法的使用在使用Socket进行网络通信时，我们通常会创建一个输出流用于发送数据，并调用flush方法来确保数据发送成功。

下面是一个示例代码：javaimport java.io.*;import .*;public class Client {public static void main(String[] args) {try {Socket socket = new Socket("127.0.0.1", 8000);OutputStream outputStream =socket.getOutputStream();BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));bufferedWriter.write("Hello Server!");bufferedWriter.flush();bufferedWriter.close();socket.close();} catch (IOException e) {e.printStackTrace();}}}在上面的示例代码中，我们创建了一个Socket对象，并指定了服务器的IP地址和端口号。

Java Socket编程(五) 简单的WEB服务器

Java Socket编程（五）简单的WEB服务器简单的WEB服务器一个简单的WEB服务器将由列表9.2这样构建.当然,还必须要对方法和回应事件进行改进.简单的服务器不会分析和存储请求头.新的WEB服务器将分析和存储请求,为以后的处理作准备.为了达到这个目的,你必须有一个包含HTTP请求的类.HTTPrequest类列表9.5列出了一个完整的HTTPrequest类.这个类必须包括一个请求头所需的所有信息.列表9.5.HTTPrequest类.import java.io.*;import java.util.*;import .*;import NameValue;/*** 这个类有一个HTTP请求的所有信息*/public class HTTPrequest{public String version;public String method;public String file;public Socket clientSocket;public DataInputStream inbound;public NameValue headerpairs[];/*** 建立一个这个类的实例*/public HTTPrequest(){version = null;method = null;file = null;clientSocket = null;inbound = null;inbound = null;headerpairs = new NameValue[0];}/*** 加入一个名称/值对到核心数组*/public void addNameValue(String name, String value){try{NameValue temp[] = new NameValue[ headerpairs.length + 1 ]; System.arraycopy(headerpairs, 0, temp, 0, headerpairs.length); temp[ headerpairs.length ] = new NameValue(name, value); headerpairs = temp;}catch (NullPointerException npe){System.out.println("NullPointerException while adding name-value: " + npe);}}/*** 以字符串的形式归还这个类*/public String toString(){String s = method + " " + file + " " + version + "\n";for (int x = 0; x < headerpairs.length; x++ )s += headerpairs[x] + "\n";return s;}}NameValue类简单地存储了两个字符串:name 和value.当一个新的对要被加入时,一个新的数组将被分配.新的数组接受了旧的数组和新的成员.旧的数组然后被一个新建的对象覆盖了。

【Java】Javasocket通信使用read,readline函数的阻塞问题

【Java】Javasocket通信使⽤read,readline函数的阻塞问题Socket通信是Java⽹络编程中⽐较基础的部分，其原理其实就是源ip，源端⼝和⽬的ip，⽬的端⼝组成的套接字通信。

其底层还设及到了TCP协议的通信。

Java中的Socket通信可以通过客户端的Socket与服务端的ServerSocket通信，同时利⽤IO流传递数据，也就是说Socket通信是⾯向流的使⽤的是BIO，并不同于后来的NIO通信⾯向缓冲。

Socket通信中使⽤的IO流的read，readline等函数都是阻塞的，这就导致了在通信过程中，双⽅不能确定什么时侯是流的结束，针对这种可以通过约定结束符的⽅式进⾏结束，也可以约定⼀次传输的字节流的长度。

下⾯通过代码进⾏说明客户端建⽴客户端线程，在run⽅法中不断对服务端进⾏发送消息，模拟多个客户端的通信，通过写⼊换⾏符，表明这次通信的结束。

1class Client implements Runnable {23private byte[] targetIp;4private int port;56 Client(byte[] ip, int port) {7this.targetIp = ip;8this.port = port;9 }1011 @Override12public void run() {13try {14 InetAddress inetAddress = InetAddress.getByAddress(targetIp);15 Socket socket = new Socket(inetAddress, port);16 System.out.println("client");17 BufferedReader socketInput = new BufferedReader(new InputStreamReader(socket.getInputStream()));18 BufferedWriter socketOutput = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));1920int i = 0;21 String NAME = "Client";22while (true) {23 socketOutput.write("This msg from " + NAME + " msg id is " + i);24 socketOutput.write("\n");//约定结束符表⽰流的结束25 i++;26 socketOutput.flush();27 System.out.println("here");28 String str = null;29if (!(str = socketInput.readLine()).equals("\n")) {30 System.out.println(str);31 }3233 }3435/*socket.shutdownInput();36 socket.shutdownOutput();*/37 } catch (IOException e) {38 e.printStackTrace();39 }4041 }42 }服务端服务端通过accept接受客户端的连接，这个操作是阻塞的，直到有客户端的连接才能进⾏下⼀步。

java socketioserver类的方法

Java中的Socket.IO是一个用于实现实时双向通信的库，它基于WebSocket协议，可以在客户端和服务器之间建立持久的连接。

在Java中，我们可以使用SocketIOServer类来创建和管理Socket.IO 服务器，通过该类的方法可以实现各种服务器端的功能。

本文将介绍SocketIOServer类的一些常用方法，帮助读者更好地了解和使用Socket.IO在Java中的实现。

一、创建Socket.IO服务器在使用Socket.IO之前，我们需要先创建一个Socket.IO服务器。

SocketIOServer类提供了创建服务器实例的方法，示例代码如下：```javaConfiguration config = new Configuration();config.setHostname("localhost");config.setPort(9092);SocketIOServer server = new SocketIOServer(config);```上述代码中，我们首先创建了一个Configuration实例来配置服务器的主机名和端口号，然后通过SocketIOServer类的构造函数创建了一个服务器实例。

通过这样的方式，我们就可以在Java中创建一个Socket.IO服务器，为后续的通信提供支持。

二、服务器端事件的处理在Socket.IO服务器上，我们通常需要处理一些事件，例如连接事件、断开事件、自定义事件等。

SocketIOServer类提供了一系列方法来注册和处理这些事件，示例代码如下：```javaserver.addConnectListener(client -> {System.out.println("客户端连接：" + client.getSessionId()); });server.addDisconnectListener(client -> {System.out.println("客户端断开连接：" + client.getSessionId()); });server.addEventListener("chat message", String.class, (client, data, ackRequest) -> {System.out.println("收到消息：" + data);});```上述代码中，我们使用addConnectListener方法和addDisconnectListener方法分别注册了客户端连接和断开连接的事件处理函数，使用addEventListener方法注册了一个名为"chat message"的自定义事件的处理函数。

socket建立tcp连接的java代码

socket建立tcp连接的java代码Socket是Java中常用的网络编程类，可以用于建立TCP连接，完成客户端和服务器间的通信。

下面是Socket建立TCP连接的Java代码：1. 建立Socket对象TCP协议在建立连接时，需要同时指定服务器的IP地址和端口号。

因此，在客户端程序中，需要先创建一个Socket对象来指定需要连接的服务器IP地址和端口号。

Socket socket=new Socke t(“192.168.1.1”, 8888);2. 获取输入输出流建立连接之后，客户端可以向服务器发送数据，还可以接收服务器返回的数据。

为了完成这些操作，需要获取输入输出流对象。

InputStream input=socket.getInputStream();OutputStream output=socket.getOutputStream();3. 发送数据客户端想要向服务器发送数据，可以通过输出流对象write()方法实现。

byte[] data=”Hello Server”.getBytes();output.write(data);4. 接收数据客户端从服务器接收数据，可以通过输入流对象read()方法实现。

byte[] buffer=new byte[1024];int len=input.read(buffer);5. 断开连接客户端和服务器通信结束之后，需要关闭连接。

input.close();output.close();socket.close();综上所述，以上代码实现了Socket建立TCP连接的过程，使得客户端和服务器能够互相通信，完成所需的业务操作。

java socket 实现原理

java socket 实现原理
Java的Socket是一种用于网络通信的编程接口。

它基于
TCP/IP协议，通过在不同计算机之间建立连接，实现了进程
之间的通信。

在Java中，Socket通信包括客户端和服务器端两个角色。

客
户端通过创建一个Socket对象来发起连接，服务器端通过创
建一个ServerSocket对象来监听连接请求。

具体实现原理如下：
1. 客户端创建一个Socket对象，指定服务器的IP地址和端口号。

Socket对象会封装了TCP/IP协议的相关信息，如IP地址
和端口号等。

2. 客户端通过Socket对象的connect()方法发起连接请求，向
服务器发送一个特定格式的数据包。

3. 服务器端创建一个ServerSocket对象，绑定到指定的IP地
址和端口号上。

4. 服务器端通过ServerSocket对象的accept()方法监听来自客
户端的连接请求。

当有连接请求到达时，accept()方法会返回
一个新的Socket对象，用于和客户端进行通信。

5. 客户端和服务器端通过各自的Socket对象进行数据的收发。

客户端通过输出流向服务器发送数据，服务器通过输入流接收
客户端发送的数据；服务器通过输出流向客户端发送数据，客户端通过输入流接收服务器发送的数据。

6. 当通信完成后，可以通过关闭Socket对象来结束连接。

通过以上步骤，客户端和服务器端能够通过Socket对象实现双向的数据传输。

Socket提供了简单、灵活和高效的网络通信方式，广泛应用于各种应用场景中。

java socket flush方法断开的管道 -回复

java socket flush方法断开的管道-回复Java Socket 是实现网络编程的一个重要组件，它允许应用程序通过网络进行通信。

Socket 提供了数据读取和数据写入操作，其中flush() 方法在Socket 编程中具有特殊的功能。

本文将深入研究flush() 方法，并探讨在断开的管道情况下它的行为和影响。

在开始之前，我们首先需要了解什么是Socket 以及它的工作原理。

Socket 是一种抽象概念，它提供了一个端点，允许应用程序通过网络与其他应用程序进行通信。

Socket 通过TCP/IP 协议栈与其他计算机建立连接，并实现数据的传输和读写操作。

在Socket 编程中，flush() 方法的作用是将输出流的缓冲区中的数据强制刷新到目标地址。

由于网络通信涉及到数据包的传输，发送端可能会将待发送的数据先存储在缓冲区中，在合适的时机再发送出去。

flush() 方法的调用可以强制将缓冲区中的数据发送出去，而不必等待缓冲区填满或者关闭输出流。

然而，当发生断开的管道情况时，flush() 方法的行为会有所不同。

断开的管道指的是连接两端之一关闭，导致通信链路中断。

在这种情况下，flush() 方法的调用可能会抛出异常，因为底层的网络连接已经失效。

具体的异常类型可能是IOException 或SocketException。

当发生这种异常时，应用程序可以选择如何处理。

一种常见的做法是捕获异常，并在出现异常时进行一些相应的处理操作，例如重新建立连接或者关闭资源。

当然，根据具体的业务需求，可以采用不同的解决方案。

除了异常处理，还有一种重要的情况需要考虑，即在正常情况下如何使用flush() 方法。

在正常情况下，flush() 方法可以确保数据被及时发送出去，而不必等待缓冲区填满。

这对于实时通信非常重要，因为及时的数据传输可以大大降低延迟。

另一个需要注意的细节是，Socket 编程中的flush() 方法需要正确的使用时机。

Java中的Socket用法

Java中的Socket⽤法转发链接：（1）Java中的Socket⽤法Java中的Socket分为普通的Socket和NioSocket。

（2）普通Socket⽤法创建ServerSocket。

ServerSocket的构造⽅法有5个，其中最⽅便的是ServerSocket(int port)，只需要⼀个port就可以了。

Java中的⽹络通信时通过Socket实现的，Socket分为ServerSocket和Socket两⼤类，ServerSocket⽤于服务器端，可以通过accept⽅法监听请求，监听请求后返回Socket，Socket⽤于完成具体数据传输，客户端也可以使⽤Socket发起请求并传输数据。

ServerSocket的使⽤可以分为三步：调⽤创建出来的ServerSocket的accept⽅法进⾏监听。

accept⽅法是阻塞⽅法，也就是说调⽤accept⽅法后程序会停下来等待连接请求，在接受请求之前程序将不会继续执⾏，当接收到请求后accept⽅法返回⼀个Socket。

使⽤accept⽅法返回的Socket与客户端进⾏通信如下代码，我们在服务器端创建ServerSocket，并调⽤accept⽅法监听Client的请求，收到请求后返回⼀个Socket。

public class Server {public static void main(String[] args) {// TODO Auto-generated method stubtry {//创建⼀个ServerSocket监听8080端⼝ServerSocket server = new ServerSocket(8080);//等待请求Socket socket = server.accept();//接受请求后使⽤Socket进⾏通信，创建BufferedReader⽤于读取数据BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));String line = is.readLine();System.out.println("received frome client:" + line);//创建PrintWriter，⽤于发送数据PrintWriter pw = new PrintWriter(socket.getOutputStream());pw.println("this data is from server");pw.flush();//关闭资源pw.close();is.close();socket.close();server.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} 然后我们再看看客户端的Socket代码，Socket的使⽤也是⼀样，⾸先创建⼀个Socket，Socket的构造⽅法⾮常多，这⾥⽤的是Socket(String host, int port)，把⽬标主机的地址和端⼝号传⼊即可（本实验代码中服务器和Client代码没有在同⼀台机器上，服务器的IP地址：192.168.6.42，所以如果读者在实验过程中ServerSocket和Client在同⼀主机下，那么Client中的IP地址需要更改为：127.0.0.1，Socket 创建的过程就会跟服务器端建⽴连接，创建完Socket后，再创建Writer和Reader来传输数据，数据传输完成后释放资源关闭连接。

java socket中客户端读取服务端的返回

java socket中客户端读取服务端的返回在Java中，可以使用Socket进行网络通信，实现客户端与服务端之间的数据交互。

当客户端向服务端发送请求后，服务端会返回相应的数据给客户端。

为了读取服务端返回的数据，需要在客户端代码中进行相应的操作。

首先，客户端需要建立与服务端的连接。

可以使用以下代码实现：```javaSocket socket = new Socket(serverIPAddress, serverPort);```其中，`serverIPAddress`是服务端的IP地址，`serverPort`是服务端监听的端口号。

通过`Socket`的构造函数可以建立与服务端的连接。

接下来，客户端可以通过`socket.getInputStream()`获取与服务端的输入流，从中读取服务端返回的数据。

可以使用`BufferedReader`进行读取操作，以下是一个示例：```javaBufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));String response = reader.readLine();```在上述代码中，`BufferedReader`用于读取字符流，`InputStreamReader`用于将字节流转换为字符流。

通过`readLine()`方法可以读取一行数据，并将其赋值给`response`变量。

读取完数据后，可以对数据进行相应的处理。

例如，打印在控制台上：```javaSystem.out.println(response);```如果服务端返回的是长文本或者多行数据，可以使用循环读取，直到读取完整个返回的数据：```javaStringBuilder response = new StringBuilder();String line;while ((line = reader.readLine()) != null) {response.append(line);}```在上述代码中，使用`StringBuilder`来拼接多行数据，通过循环读取并追加到`response`对象中。

JavaSocket编程题库

JavaSocket编程题库⼀、填空题1. ___ IP地址____⽤来标志⽹络中的⼀个通信实体的地址。

通信实体可以是计算机，路由器等。

2. 统⼀资源定位符URL是指向互联⽹“资源”的指针,由4部分组成：协议、存放资源的主机域名、__端⼝___和资源路径和⽂件名。

3. URL 是统⼀资源定位器的简称，它表⽰Internet上某⼀资源的地址。

4. 在Socket编程中，IP地址⽤来标志⼀台计算机，但是⼀台计算机上可能提供多种应⽤程序，使⽤端⼝来区分这些应⽤程序。

5. 在Java Socket⽹络编程中，开发基于TCP协议的服务器端程序使⽤的套接字是 ServerSocket 。

6. 在Java Socket⽹络编程中，开发基于UDP协议的程序使⽤的套接字是 DatagramSocket 。

⼆、选择题1.以下协议都属于TCP/IP协议栈，其中位于传输层的协议是（AD）。

（选择⼆项）A TCPB.HTTPC.SMTPD.UDP2.以下协议中属于TCP/IP协议栈中应⽤层协议的是（A）。

（选择⼀项）A HTTPB.TCPC.UDPD.IP3.以下说法中关于UDP协议的说法正确的是（AD）。

（选择⼆项）A.发送不管对⽅是否准备好，接收⽅收到也不确认B.⾯向连接C.占⽤系统资源多、效率低D.⾮常简单的协议，可以⼴播发送4.在基于TCP⽹络通信模式中，客户与服务器程序的主要任务是（BC）。

（选择⼆项）A 客户程序在⽹络上找到⼀条到达服务器的路由B.客户程序发送请求，并接收服务器的响应C.服务器程序接收并处理客户请求，然后向客户发送响应结果D.如果客户程序和服务器都会保证发送的数据不会在传输途中丢失5.在Java⽹络编程中，使⽤客户端套接字Socket创建对象时，需要指定（A）。

（选择⼀项）A 服务器主机名称和端⼝B.服务器端⼝和⽂件C.服务器名称和⽂件D.服务器地址和⽂件6.ServerSocket的监听⽅法accept( )⽅法的返回值类型是（A ）。

Javasocket长连接代码实现

Javasocket长连接代码实现服务器端程序：import java.io.*;import .*;import java.util.*;public class ChatServer {boolean started = false;ServerSocket ss = null;List<Client> clients = new ArrayList<Client>();public static void main(String[] args) {new ChatServer().start();}public void start() {try {ss = new ServerSocket(8888);started = true;System.out.println("端⼝已开启,占⽤8888端⼝号....");} catch (BindException e) {System.out.println("端⼝使⽤中....");System.out.println("请关掉相关程序并重新运⾏服务器！");System.exit(0);} catch (IOException e) {e.printStackTrace();}try {while (started) {Socket s = ss.accept();Client c = new Client(s);System.out.println("a client connected!");new Thread(c).start();clients.add(c);}} catch (IOException e) {e.printStackTrace();} finally {try {ss.close();} catch (IOException e) {e.printStackTrace();}}}class Client implements Runnable {private Socket s;private DataInputStream dis = null;private DataOutputStream dos = null;private boolean bConnected = false;public Client(Socket s) {this.s = s;try {dis = new DataInputStream(s.getInputStream());dos = new DataOutputStream(s.getOutputStream());bConnected = true;} catch (IOException e) {e.printStackTrace();}}public void send(String str) {try {dos.writeUTF(str);} catch (IOException e) {clients.remove(this);System.out.println("对⽅退出了！我从List⾥⾯去掉了！");}}public void run() {try {while (bConnected) {String str = dis.readUTF();System.out.println("------------来⾃本地服务器:" + str);for (int i = 0; i < clients.size(); i++) {Client c = clients.get(i);c.send(str);}}} catch (EOFException e) {System.out.println("Client closed!");} catch (IOException e) {e.printStackTrace();} finally {try {if (dis != null)dis.close();if (dos != null)dos.close();if (s != null) {s.close();}} catch (IOException e1) {e1.printStackTrace();}}}}}客户端程序：import java.awt.*;import java.awt.event.*;import java.io.*;import .*;/*** @author Michael Huang**/public class ChatClient extends Frame {Socket s = null;DataOutputStream dos = null;DataInputStream dis = null;private boolean bConnected = false;TextField tfTxt = new TextField();TextArea taContent = new TextArea();Thread tRecv = new Thread(new RecvThread());public static void main(String[] args) {new ChatClient().launchFrame(8888);}public void launchFrame(int port) {setLocation(400, 300);this.setSize(300, 300);add(tfTxt, BorderLayout.SOUTH);add(taContent, BorderLayout.NORTH);pack();this.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent arg0) {disconnect();System.exit(0);}});tfTxt.addActionListener(new TFListener());setVisible(true);connect(port);tRecv.start();}public void connect(int port) {try {s = new Socket("127.0.0.1", port);dos = new DataOutputStream(s.getOutputStream()); dis = new DataInputStream(s.getInputStream());System.out.println("~~~~~~~~连接成功~~~~~~~~!"); bConnected = true;} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}public void disconnect() {try {dos.close();dis.close();s.close();} catch (IOException e) {e.printStackTrace();}}private class TFListener implements ActionListener { public void actionPerformed(ActionEvent e) {String str = tfTxt.getText().trim();tfTxt.setText("");try {dos.writeUTF(str);dos.flush();} catch (IOException e1) {e1.printStackTrace();}}}private class RecvThread implements Runnable {public void run() {try {while (bConnected) {String str = dis.readUTF();taContent.setText(taContent.getText() + str + '\n'); }} catch (SocketException e) {System.out.println("退出了，bye!");} catch (EOFException e) {System.out.println("退出了，bye!");} catch (IOException e) {e.printStackTrace();}}}}。

Java网络编程（Socket基础，多线程socket，socket中文乱码问题）学习笔记

Java⽹络编程（Socket基础，多线程socket，socket中⽂乱码问题）学习笔记1.概念2.简单TCP通信代码，⽤两个java程序模拟客户端和服务器端。

客户端代码：TCP通信的客户端:向服务器发送连接请求,给服务器发送数据,读取服务器回写的数据表⽰客户端的类:.Socket:此类实现客户端套接字（也可以就叫“套接字”）。

套接字是两台机器间通信的端点。

套接字:包含了IP地址和端⼝号的⽹络单位构造⽅法:Socket(String host, int port) 创建⼀个流套接字并将其连接到指定主机上的指定端⼝号。

参数:String host:服务器主机的名称/服务器的IP地址int port:服务器的端⼝号成员⽅法:OutputStream getOutputStream() 返回此套接字的输出流。

InputStream getInputStream() 返回此套接字的输⼊流。

void close() 关闭此套接字。

实现步骤:1.创建⼀个客户端对象Socket,构造⽅法绑定服务器的IP地址和端⼝号2.使⽤Socket对象中的⽅法getOutputStream()获取⽹络字节输出流OutputStream对象3.使⽤⽹络字节输出流OutputStream对象中的⽅法write,给服务器发送数据4.使⽤Socket对象中的⽅法getInputStream()获取⽹络字节输⼊流InputStream对象5.使⽤⽹络字节输⼊流InputStream对象中的⽅法read,读取服务器回写的数据6.释放资源(Socket)注意:1.客户端和服务器端进⾏交互,必须使⽤Socket中提供的⽹络流,不能使⽤⾃⼰创建的流对象2.当我们创建客户端对象Socket的时候,就会去请求服务器和服务器经过3次握⼿建⽴连接通路这时如果服务器没有启动,那么就会抛出异常ConnectException: Connection refused: connect如果服务器已经启动,那么就可以进⾏交互了import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import .Socket;import java.util.Scanner;public class TCPClient {public static void main(String[] args) throws IOException {Scanner cin = new Scanner(System.in);Socket socket = new Socket("127.0.0.1",8888);InputStream is = socket.getInputStream();while(true){//给服务器端发数据System.out.println("请输⼊你要向服务器发送的数据：");String sendMessage = cin.nextLine();OutputStream os = socket.getOutputStream();os.write(sendMessage.getBytes());//接收服务器端发过来的数据byte[] getMessage = new byte[1024];int len = is.read(getMessage);String message = new String(getMessage,0,len);System.out.println("收到服务器端发来的数据为： "+message);}}}服务器端代码：TCP通信的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据表⽰服务器的类:.ServerSocket:此类实现服务器套接字。

java socket读取完整数据方法

java socket读取完整数据方法在Java中，使用Socket进行网络通信时，有时我们需要读取完整的数据流。

这可以通过以下方法实现：1. 使用InputStreamReader和BufferedReader读取数据流首先，我们需要获取到Socket的输入流，可以通过socket.getInputStream()方法来获取。

然后，我们可以使用InputStreamReader将字节流转换为字符流，再使用BufferedReader按行读取字符流。

```javaInputStream inputStream = socket.getInputStream();InputStreamReader inputStreamReader = new InputStreamReader(inputStream);BufferedReader bufferedReader = new BufferedReader(inputStreamReader);String line;StringBuilder stringBuilder = new StringBuilder();while ((line = bufferedReader.readLine()) != null) {stringBuilder.append(line);}String completeData = stringBuilder.toString();```通过使用InputStreamReader和BufferedReader，我们可以逐行读取数据，直到数据流结束。

2. 使用ByteArrayOutputStream读取数据流另一种方法是使用ByteArrayOutputStream来读取数据流。

在这种方法中，我们首先创建一个ByteArrayOutputStream来存储读取到的数据，然后使用一个字节数组作为缓冲区，逐段读取并写入到ByteArrayOutputStream中。

javasocket编程面试题

java socket编程面试题总结：1) 建立Socket连接2) 获得输入/输出流3)读/写数据4) 关闭输入/输出流5) 关闭Socket1. 编写一个网络应用程序，有客户端与服务器端，客户端向服务器端发送一个字符串，服务器收到该字符串后将其打印到命令行上，然后向客户端返回该字符串的长度，最后，客户端输出服务器端返回的该字符串的长度。

SockectServerTestJava代码import java.io.InputStream;  import java.io.OutputStream;  import .ServerSocket;  import .Socket;      public class SocketServerTest  {                  public static void m ain(String[] args) throws Exception      {          ServerSoc ket ss = new ServerSocket(9999); &nbsp ;        Socket&n bsp;socket = ss.accept();           &n bsp;        InputStrea m is = socket.getInputStream();          OutputStr eam os = socket.getOutputStream();           &n bsp;        byte[]&nb sp;buffer = new byte[100];           &n bsp;        int l ength = is.read(buffer);           &n bsp;        String&nb sp;content = new String(buffer,0,length); &nbs p;         &n bsp;        System.ou t.println(read from client: + content); & nbsp;         &n bsp;        int  strLength = content.length();           &n bsp;        String&nb sp;str = String.valueOf(strLength);           &n bsp;        os.write(st r.getBytes());           &n bsp;        is.close();          os.close();           socket.clo se();      }  }    import java.io.InputStream;import java.io.OutputStream;import .ServerSocket;import .Socket;public class SocketServerTest{public static void main(String[] args) throws Exception {ServerSocket ss = new ServerSocket(9999);Socket socket = ss.accept();InputStream is = socket.getInputStream(); OutputStream os = socket.getOutputStream();byte[] buffer = new byte[100];int length = is.read(buffer);String content = new String(buffer,0,length); System.out.println(read from client: + content);int strLength = content.length();String str = String.valueOf(strLength);os.write(str.getBytes());is.close();os.close();socket.close();}}ClientTestJava代码import java.io.InputStream;  import java.io.OutputStream;  import .Socket;    public class ClientTest  {        public static void m ain(String[] args) throws Exception      {          Socket&n bsp;socket = new Socket(localhost,9999); &nb sp;                  InputStrea m is = socket.getInputStream();           &n bsp;        OutputStr eam os = socket.getOutputStream();           &n bsp;        String&nb sp;content = This comes from client;&n bsp;         os.write(c ontent.getBytes());                     &n bsp;        byte[]&nb sp;b = new byte[100];          int l ength = is.read(b);          String&nb sp;str = new String(b,0,length);          System.ou t.println(string's  length: + str); &n bsp;         &n bsp;        is.close();          os.close();           socket.clo se();      }    }  import java.io.InputStream;import java.io.OutputStream;import .Socket;public class ClientTest{public static void main(String[] args) throws Exception {Socket socket = new Socket(localhost,9999); InputStream is = socket.getInputStream(); OutputStream os = socket.getOutputStream(); String content = This comes from client;os.write(content.getBytes());byte[] b = new byte[100];int length = is.read(b);String str = new String(b,0,length);System.out.println(string's length: + str); is.close();os.close();socket.close();}}。

JavaSocket实现聊天室附1500行源代码

JavaSocket实现聊天室附1500⾏源代码⽬录项⽬需求分析基础分析项⽬部分代码摘要Dao的链表存储实现ServerListenServerReceive再看⼀下客户端的ClientReceive项⽬问题选择框中出现的不是⽤户名服务端点击消息发送按钮没有反应不能显⽰在线⼈数服务端退出时没有消息Java养成计划（打卡第31，2天)内容管理：Sockect聊天室的实现Java界⾯使⽤了各种组件，对于这部分不了解的不⽤担⼼，⽬前掌握⼀个⼤概就OK项⽬需求分析需要完成⼀个简单聊天⼯具的界⾯及功能，实现服务器中转下的多客户端之间的通信，系统完成的功能有程序启动后能看到当前有那些机器上线，可弹出对话聊天框，可以在其中编辑要发送的聊天信息，并进⾏发送⼀旦某个⽹内的机器上线了，可即时通知，并能更新⽤户界⾯的⽤户列表双击某个列表项时，可弹出对话聊天框，可以在其中编辑要发送的信息并发送聊天界⾯⼈性化，下⾯时发送框，上⾯有已有聊天记录，并借助滚动条看到当次所有聊天记录当有⼈向本机器发送消息时，可显⽰⽤户接收到的信息，并且显⽰是谁所发，同时进⾏信息的回复基础分析⾸先这是⼀个聊天⼯具，使⽤的是C/S结构，要模拟就要使⽤net的Scocket和ServerSocket模拟客户端和服务端这⾥综合运⽤了多种知识，已经不再是简单的java SE知识，其中界⾯编程占据主要代码，这⾥可以贴⼏张图看看效果，这是我肝了2天才肝完的，这⾥已经可以实现多态设备的连接分为3个包Sever包主要是服务器的相关代码，主要是实现与⽤户的交互Dao包是模拟的数据库包，存储所有的⽤户信息，实现增删改的操作Client是客户代码包，只要在电脑上运⾏这⾥的代码，就可以出现客户端界⾯，约定好ip和端⼝号就可以通信了。

这⾥就真正实现了客户端型软件，只是软件功能简单，可以使⽤web编程实现另外⼀种架构可以来看⼀下界⾯再来看⼀下客户端和服务端的交流项⽬部分代码摘要Dao的链表存储实现package Dao;/*** 演⽰程序为了简化就不⽤数据库存储，使⽤单链表完成数据库各项功能* 这⾥⼀定要写测试代码检查各项功能是否可⽤* 最开开始我测试了add，del，find功能，却没有测试getCount功能，结果存在问题，后⾯突然放开测试才发现错误 */public class UserLinkList {private Node head;private int count;public boolean addUser(Node client){if(head == null){//头节点也存储数据head = client;count++;return true;}else {Node p = head;for(;p.next != null;p = p.next);{p.next = client;count++;return true;}}}public int getCount() {return count;}public Node findUser(String name){Node p = head;while(p != null )//p.next != null没有包含最后⼀个结点{if(ername.equals(name)){return p;}p = p.next;}return null;}public Node findUser(int index){int pos = 0;Node p = head;while(p != null&& pos < index){p = p.next;pos++;}if(p != null&& pos == index){return p;}return null;}public boolean delUser(Node client){//删除后长度也要减少Node p = head;if(ername.equals(ername)){//删除头结点head = head.next;count--;return true;}while(p != null){//忘记循环了if(ername.equals(ername)){p.next = p.next.next;count--;return true;}p = p.next;}return false;}/*** 这⾥可以设置⼀个显⽰的⽅法,供检查使⽤*/public void display() {Node p = head;int pos = 1;while(p != null){System.out.println("第"+pos + "个⽤户"+ername);p = p.next;pos++;}}}/*public static void main(String[] args) {//经过测试发现没有问题，可以正常使⽤ Node client1 = new Node();ername = "张三";Node client2 = new Node();ername = "李四";Node client3 = new Node();ername = "王五";//其他的就不测试了，反正该项就可以测试了UserLinkList userLinkList = new UserLinkList();//⾃动初始化userLinkList.addUser(client1);userLinkList.addUser(client2);userLinkList.addUser(client3);// userLinkList.display();Node node = userLinkList.findUser(0);userLinkList.delUser(node);userLinkList.display();System.out.println(userLinkList.getCount());}*/现在编写这段代码应当是⾮常简单的，注意⼀定要测试ServerListen简单看⼀下这个监听线程，可以监听⽤户是否上线package Server;/*** @author OMEY-PC*本程序的作⽤是实现服务器侦听的线程化，其中run⽅法通过client = new Node();创建⼀个客户端对象，通过client.socket = server.accept来设定接⼝，通过client.input *output来建⽴输⼊输出流*/import java.io.*;import .*;import Dao.*; //连接数据import javax.swing.*;public class ServerListen extends Thread{ServerSocket server;JComboBox combobox;JTextArea textarea;JTextField textfield;UserLinkList userLinkList;Node client;ServerReceive recvThread;public boolean isStop;/*** 聊天服务端的⽤户上下线侦听类*/public ServerListen(ServerSocket server,JComboBox combobox,JTextArea textarea,JTextField textField,UserLinkList userLinkList) {this.server = server;bobox = combobox;this.textarea = textarea;this.textfield = textField;erLinkList = userLinkList;isStop = false;}@Overridepublic void run() {while(!isStop && !server.isClosed())//没有停⽌服务{try {client = new Node();client.socket = server.accept();//⽤来指代所连接的客户端client.output = new ObjectOutputStream(client.socket.getOutputStream());client.output.flush();client.input = new ObjectInputStream(client.socket.getInputStream());ername = (String)client.input.readObject();//显⽰提⽰信息combobox.addItem(ername);//改成⽤户名userLinkList.addUser(client);textarea.append("⽤户" + ername+"上线"+"\n");textfield.setText("在线⽤户"+ userLinkList.getCount()+"⼈\n");recvThread = new ServerReceive(textarea,textfield,combobox,client,userLinkList);recvThread.start();//启动线程}catch (Exception e) {e.printStackTrace();}}}}ServerReceive该线程实现服务器与⽤户之间的信息交互package Server;/*** @author OMEY-PC*服务器收发消息的类*/import .ServerSocket;import javax.swing.*;import Dao.*;public class ServerReceive extends Thread{JTextArea textarea;//消息展⽰域JTextField textfield;//⽂本输⼊域JComboBox combobox; //复选框Node client;//⽤户UserLinkList userLinkList;public boolean isStop;public ServerReceive(JTextArea textarea, JTextField textfield, JComboBox combobox, Node client,UserLinkList userLinkList) {this.textarea = textarea;this.textfield = textfield;bobox = combobox;this.client = client;erLinkList = userLinkList;isStop = false;}@Overridepublic void run(){//向所有⼈发送⽤户的列表sendUserList();while(!isStop && !client.socket.isClosed()){try {//类型，对谁，状况，⾏为，信息String type = (String)client.input.readObject();if(type.equalsIgnoreCase("聊天信息")){String toSomebody =(String)client.input.readObject();//从客户端接收信息String status = (String)client.input.readObject();String action = (String)client.input.readObject();String message = (String)client.input.readObject();String msg = ername+" "+ action + "对"+ toSomebody +" 说 " + message + "\n";//接收的消息 if(status.equalsIgnoreCase("悄悄话")){msg = "[悄悄话]" + msg; //若为悄悄话，就在前⾯加上标识}textarea.append(msg);if(toSomebody.equalsIgnoreCase("所有⼈")){sendToAll(msg);//这⾥是接受的⽤户消息,和之前的向所有⼈发消息不⼀样}else {//向⽤户发消息try {client.output.writeObject("聊天信息");client.output.flush();//刷新流client.output.writeObject(msg);client.output.flush();}catch (Exception e) {e.printStackTrace();}Node node = userLinkList.findUser(toSomebody);if(node != null){node.output.writeObject("聊天信息");node.output.flush();node.output.writeObject(msg);//向选定信息发送信息node.output.flush();//刷新输出流缓冲区中的信息}}}else if(type.equalsIgnoreCase("⽤户下线")){Node node = userLinkList.findUser(ername);userLinkList.delUser(node);String msg = "⽤户"+ ername +"下线\n";int count = userLinkList.getCount();combobox.removeAllItems();combobox.addItem("所有⼈");int i = 0;while(i < count){node = userLinkList.findUser(i);if(node == null){i++;continue;}combobox.addItem(ername);i++;}combobox.setSelectedIndex(0);//选择第⼀个，所有⼈textarea.append(msg);textfield.setText("在线⽤户"+ userLinkList.getCount() +"⼈\n");sendToAll(msg);sendUserList();//重新发送⽤户列表break;}}catch (Exception e) {e.printStackTrace();}}}/*** 向所有⼈发送消息*/public void sendToAll(String msg){int count = userLinkList.getCount();int i = 0;while(i < count){//给⽤户列表中的每⼀个⼈都发送消息Node node = userLinkList.findUser(i);if(node == null){i++;continue;}try {//输出流node.output.writeObject("聊天信息");node.output.flush();node.output.writeObject(msg);//聊天消息写⼊输出流(to client)node.output.flush();}catch (Exception e) {e.printStackTrace();}i++;}}/*** 向所有⼈发送⽤户列表*/public void sendUserList() {String userList = "";int count = userLinkList.getCount();int i = 0;while(i < count){Node node = userLinkList.findUser(i);if(node == null){i++;continue;}userList += ername;userList += "\n";i++;}i = 0; //给每个⼈发送消息while(i < count){Node node = userLinkList.findUser(i);if(node == null){i++;continue;}try {node.output.writeObject("⽤户列表");node.output.flush();node.output.writeObject(userList);node.output.flush();}catch (Exception e) {e.printStackTrace();}}i++;}}/*** 本程序可以实现通过线程向所有⼈发送消息，⽤户列表，以及向选定的⼈发送聊天消息等，主要是是实现服务端收发消息的线程化，其中sendUserList()发送列表， * client.input.redObject()获取客户端发送到服务端的消息，通sendToAll()，将发送到发送到所有⼈的信息发送到各个客户端*/再看⼀下客户端的ClientReceive该线程是实现客户端与系统之间的信息交互，注解丰富package Client;import java.io.*;import .*;import javax.swing.*;public class ClientReceive extends Thread{private JComboBox combobox;private JTextArea textarea;Socket socket;ObjectOutputStream output;ObjectInputStream input;JTextField showStatus;public ClientReceive(JComboBox combobox, JTextArea textarea, Socket socket, ObjectOutputStream output,ObjectInputStream input, JTextField showStatus) {bobox = combobox;this.textarea = textarea;this.socket = socket;this.output = output;this.input = input;this.showStatus = showStatus;}@Overridepublic void run() {//从服务端获得消息while(!socket.isClosed()){try {String type = (String)input.readObject();//获得流，read读取信息if(type.equalsIgnoreCase("系统信息")){String sysmsg = (String)input.readObject();textarea.append("系统信息" + sysmsg);}else if(type.equalsIgnoreCase("服务关闭")){output.close();input.close();socket.close();textarea.append("服务器已经关闭!\n");break;}else if(type.equalsIgnoreCase("聊天信息")){String message = (String)input.readObject();textarea.append(message);}else if(type.equalsIgnoreCase("⽤户列表")){String userlist = (String)input.readObject();String[] usernames = userlist.split("\n"); //⽤换⾏符分隔combobox.removeAll();//先移出去int i = 0;combobox.addItem("所有⼈");while(i < usernames.length){combobox.addItem(usernames[i]);i++;}combobox.setSelectedIndex(0);showStatus.setText("在线⽤户"+ usernames.length +" ⼈");}}catch (Exception e) {e.printStackTrace();}}}}其余的界⾯的部分就不放出来了，代码太长，每个都有400多⾏，如果有兴趣，就到我的gitee上去浏览，后⾯会放上地址项⽬问题选择框中出现的不是⽤户名查找相应模块发现是因为addItem中添加的时结点，⽽不是结点中的username，修改后正常服务端点击消息发送按钮没有反应查找监听器部分，发现监听器监听该部分代码写错，将button⼜写成sysMessage不能显⽰在线⼈数查找侦听线程，启动客户端发现抛出异常Cannot invoke “javax.swing.JTextField.setText(String)” because “this.textfield” is nulltextfield为空，查找问题源头；发现在构造⽅法中：the assignmen to variable has no effect;这是因为单词拼写错误，编译器并没有报错服务端退出时没有消息系统报错Cannot read field “input” because “node” is null意识到问题出在链表上，系统要求从0开始，⽽链表中的序号是从1开始的，修该链表中的findUser中的pos为0就解决写这个程序写了两天，直接废了~~到此这篇关于Java Socket实现聊天室附1500⾏源代码的⽂章就介绍到这了,更多相关Java Socket内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

JAVA网络编程-客户端Socket

JAVA⽹络编程-客户端Socket使⽤Socketsocket是两台主机之间的⼀个连接。

它可以完成7个基本操作：连接远程机器；发送数据；接收数据；关闭连接；绑定端⼝；监听⼊站数据；在绑定端⼝上接收来⾃远程机器的连接。

前4个步骤对应的4个操作⽅法应⽤于客户端（Socket），后⾯三个操作仅服务器需要(ServerSocket)⼀旦建⽴了连接，本地和远程主机就从这个socket得到输⼊流和输出流，使⽤者两个流相互发送数据。

连接是全双⼯的，两台主机都可以同时发送和接收数据。

数据的含义取决与协议，发送给FTP服务器的命令与发送给HTTP服务器的命令有所不同。

⼀般先完成某种协议握⼿，然后再具体传输数据。

当数据传输结束后，⼀端或两端将关闭连接。

有些协议，如HTTP1.0要求每次请求得到服务器后都要关闭连接。

⽽FTP或者HTTP1.1则允许在⼀个连接上处理多个请求。

public static void main(String[] args) throws Exception {try (Socket socket = new Socket("127.0.0.1", 8888)) {} catch (Exception e) {System.out.println(e);}}// 客户端使⽤setSoTimeout(int m)⽅法为连接设置⼀个超时时间，超时时间的单位是毫秒。

⼀旦打开Socket并设置其超时时间后，可以调⽤getInputStream()返回⼀个InputStream,⽤它从socket中读取⼦节。

⼀般来讲，服务器可以发送任意⼦节。

确认读取完毕后调⽤shutdownInput()⽅法关闭输⼊流。

public static void main(String[] args) throws Exception {try (Socket socket = new Socket("127.0.0.1", 8888)) {socket.setSoTimeout(1000);InputStream in = socket.getInputStream();BufferedReader br = new BufferedReader(new InputStreamReader(in));String line = null;while ((line = br.readLine()) != null) {System.out.println(line);}socket.shutdownInput();} catch (Exception e) { System.out.println(e); } }// 客户端⽤Socket写⼊服务器getOutputStream();返回⼀个原始的OutputStream，可以⽤它从你的应⽤向Socket的另⼀端写数据。

java中的socket的native方法

【Java中的Socket的Native方法】一、引言Java作为一门跨评台的编程语言，广泛应用于网络编程领域。

而在网络编程中，Socket是一个重要的概念，它提供了一种机制，使得不同计算机之间可以进行通信。

在Java中，Socket的实现涉及到了native方法，这些方法是通过本地代码实现的，对于理解Socket的工作原理和性能优化是非常重要的。

本文将从深度和广度两个方面对Java中的Socket的native方法进行全面评估和探讨，并撰写一篇有价值的文章。

二、Socket的概念和作用在网络编程中，Socket是一种用于实现网络通信的编程接口。

它可以建立服务器和客户端之间的连接，并进行数据传输。

在Java中，Socket类提供了对通信端点的创建和操作，并且可以通过它来进行TCP和UDP通信。

三、Java中的Socket类Java中的Socket类是在包中提供的，它是网络编程的基本类之一。

通过Socket类，Java程序可以使用TCP协议进行网络通信。

在Socket类中，有一些native方法被用来实现底层的网络通信操作。

四、native方法的作用所谓的native方法，就是使用其他编程语言实现的方法，在Java中进行调用。

在Socket类中，一些复杂的网络通信操作需要调用底层的系统库来完成，因此使用native方法来实现这些操作是非常高效和灵活的。

五、native方法与Socket的性能由于native方法是通过本地代码实现的，因此它具有较高的性能。

在Socket的底层通信操作中，利用native方法可以充分发挥系统资源，提高通信效率和速度。

六、Java中Socket的native方法的问题和挑战尽管native方法在Socket的性能优化方面有很大的优势，但是它也存在一些问题和挑战。

跨评台兼容性、代码安全性等方面的考虑都需要进行充分的评估和处理。

七、总结和回顾通过对Java中Socket的native方法的深入探讨，我们可以更好地理解Socket的工作原理和性能优化。

第6讲Socket编程.ppt

Socket(InetAddress address, int port, boolean stream);
其中address、host和port分别是双向连接中另一方的IP地址、主机名和端口号， stream指明socket是流socket还是数据报socket
专业课件
14
注意
在选择端口时，必须小心。每一个端口提供一
line=sin.readLine();
while(!line.equals("bye")){
os.println(line);
os.flush();
System.out.println("服务器："+line);
System.out.println("客户端："+is.readLine());
line=sin.readLine();
关闭socket
专业课件
5
TCP
TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传
输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket （通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket
}
os.close();
is.close();
socket.close();
server.close();
} catch (IOException e) {
e.printStackTrace();
}
专业课件

java使用Socket类接收和发送数据

java使⽤Socket类接收和发送数据⽹络应⽤分为客户端和服务端两部分，⽽Socket类是负责处理客户端通信的Java类。

通过这个类可以连接到指定IP或域名的服务器上，并且可以和服务器互相发送和接受数据。

在本⽂及后⾯的数篇⽂章中将详细讨论Socket类的使⽤，内容包括Socket类基础、各式各样的连接⽅式、get和set⽅法、连接过程中的超时以及关闭⽹络连接等。

在本⽂中，我们将讨论使⽤Socket类的基本步骤和⽅法。

⼀般⽹络客户端程序在连接服务程序时要进⾏以下三步操作。

1. 连接服务器2. 发送和接收数据3. 关闭⽹络连接⼀、连接服务器在客户端可以通过两种⽅式来连接服务器，⼀种是通过IP的⽅式来连接服务器，⽽另外⼀种是通过域名⽅式来连接服务器。

其实这两种⽅式从本质上来看是⼀种⽅式。

在底层客户端都是通过IP来连接服务器的，但这两种⽅式有⼀定的差异，如果通过IP⽅式来连接服务端程序，客户端只简单地根据IP进⾏连接，如果通过域名来连接服务器，客户端必须通过DNS将域名解析成IP，然后再根据这个IP来进⾏连接。

在很多程序设计语⾔或开发⼯具中（如C/C++、Delphi）使⽤域名⽅式连接服务器时必须⾃⼰先将域名解析成IP，然后再通过IP进⾏连接，⽽在Java中已经将域名解析功能包含在了Socket类中，因此，我们只需象使⽤IP⼀样使⽤域名即可。

通过Socket类连接服务器程序最常⽤的⽅法就是通过Socket类的构造函数将IP或域名以及端⼝号作为参数传⼊Socket类中。

Socket类的构造函数有很多重载形式，在这⼀节只讨论其中最常⽤的⼀种形式：public Socket（String host， int port）。

从这个构造函数的定义来看，只需要将IP或域名以及端⼝号直接传⼊构造函数即可。

下⾯的代码是⼀个连接服务端程序的例⼦程序：package mysocket;import .*;public class MyConnection{public static void main(String[] args){try{if (args.length > 0){Socket socket = new Socket(args[0], 80);System.out.println(args[0] + "已连接成功!");}elseSystem.out.println("请指定IP或域名！");}catch (Exception e){System.err.println("错误信息：" + e.getMessage());}}}在上⾯的中，通过命令⾏参数将IP或域名传⼊程序，然后通过Socket socket = new Socket(args[0], 80)连接通过命令⾏参数所指定的IP或域名的80端⼝。

Java Socket编程

java socket flush方法 断开的管道 -回复

Java Socket编程(五) 简单的WEB服务器

【Java】Javasocket通信使用read,readline函数的阻塞问题

java socketioserver类的方法

socket建立tcp连接的java代码

java socket 实现原理

java socket flush方法 断开的管道 -回复

Java中的Socket用法

java socket中客户端读取服务端的返回

JavaSocket编程题库

Javasocket长连接代码实现

Java网络编程（Socket基础，多线程socket，socket中文乱码问题）学习笔记

java socket读取完整数据方法

javasocket编程面试题

JavaSocket实现聊天室附1500行源代码

JAVA网络编程-客户端Socket

java中的socket的native方法

第6讲Socket编程.ppt

java使用Socket类接收和发送数据

java socket flush方法断开的管道 -回复

java socket flush方法断开的管道 -回复