Java socket编程学习笔记

已于 2024-01-14 13:15:10 修改
阅读量487 收藏 10
点赞数 9
文章标签： java 学习 笔记
于 2024-01-07 16:57:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48460141/article/details/135441201
版权

一、初步了解

1、简易代码(存在socket提前关闭问题)

服务端代码:
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 创建一个serverSocket，监听一个端口号并创建通信socket
        ServerSocket serverSocket = new ServerSocket(8888);
        // 当有客户端连接时创建一个通信socket,没有连接时会阻塞
        Socket socket = serverSocket.accept();
        // 打印客户端信息
        System.out.println("客户端" + socket.getInetAddress().getLocalHost() + "连接到服务器");
        // 输入流，用于读取客户端信息
        InputStream in = socket.getInputStream();
        // 良好习惯,关闭输出流
        in.close();
        // 输出流，用于给客户端返回信息
        OutputStream out = socket.getOutputStream();
        /* 读取客户端信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 打印从客户端收到的信息
        System.out.println("服务端接收到消息:" + msgBuilder.toString());
        // 给客户端返回信息
        out.write(("服务端收到消息:" + msgBuilder.toString()).getBytes(StandardCharsets.UTF_8) );
        // 输出缓冲数据
        out.flush();
        // 关闭输出流
        out.close();
    }
}
客户端代码
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Date;

public class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 指定ip和端口号，创建socket连接
        Socket socket = new Socket("127.0.0.1", 8888);
        /* 发送消息 */
        String msg = "客户端发送了一条消息,现在是北京时间" + new Date();
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        out.write(msg.getBytes(StandardCharsets.UTF_8));
        out.flush();
        // 关闭输出流
        out.close();
        /* 读取信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 打印收到信息
        System.out.println("客户端收到服务端回信：" + msgBuilder);
        // 关闭输入流
        in.close();
    }
}
运行结果

  1、步骤：先启动服务端，再启动客户端
  2、服务端打印：

客户端LAPTOP-EECN3AOI/192.168.31.39连接到服务器
Exception in thread "main" java.net.SocketException: Socket is closed
	at java.net.Socket.getOutputStream(Socket.java:943)
	at MySocketServer.main(MySocketServer.java:19)

 3、客户端打印：

Exception in thread "main" java.net.SocketException: socket closed
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at java.net.SocketInputStream.read(SocketInputStream.java:127)
	at MySocketClient.main(MySocketClient.java:24)

  4、错误分析：socket被关闭
  5、原因：分析代码，未对socket进行关闭，但是客户端在通信完成前提前关闭了out流，服务端提前关闭了in流，查询资料得知关闭流会导致socket关闭

2、将所有关闭流操作去掉，存在读取阻塞问题

服务端
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 创建一个serverSocket，监听一个端口号并创建通信socket
        ServerSocket serverSocket = new ServerSocket(8888);
        // 当有客户端连接时创建一个通信socket,没有连接时会阻塞
        Socket socket = serverSocket.accept();
        // 打印客户端信息
        System.out.println("客户端" + socket.getInetAddress().getLocalHost() + "连接到服务器");
        // 输入流，用于读取客户端信息
        InputStream in = socket.getInputStream();
        // 输出流，用于给客户端返回信息
        OutputStream out = socket.getOutputStream();
        /* 读取客户端信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 打印从客户端收到的信息
        System.out.println("服务端接收到消息:" + msgBuilder.toString());
        // 给客户端返回信息
        out.write(("服务端收到消息:" + msgBuilder.toString()).getBytes(StandardCharsets.UTF_8) );
    }
}
客户端
public class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 指定ip和端口号，创建socket连接
        Socket socket = new Socket("127.0.0.1", 8888);
        /* 发送消息 */
        String msg = "客户端发送了一条消息,现在是北京时间" + new Date();
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        out.write(msg.getBytes(StandardCharsets.UTF_8));
        out.flush();
        /* 读取信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 打印收到信息
        System.out.println("客户端收到服务端回信：" + msgBuilder);
    }
}
运行结果

 1、服务端：打印连接信息后无响应

客户端LAPTOP-EECN3AOI/192.168.31.39连接到服务器

  2、客户端：无响应
  3、原因：分析代码，服务端没有打印出客户端发送消息，猜测是以下代码陷入死循环。

        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }

  查资料得知，在普通流当中，这个方法可行。但是在socket中，只有当对方将输出流关闭后才会以-1作为结束标志，故而陷入死循环，推断正确。
  4、解决方法：需要关闭流的同时，不关闭socket，可使用Socket::shutdownOutput()方法和Socket::shutdownInput()方法实现

3、使用正确方法关闭流，通信成功

服务端
public class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 创建一个serverSocket，监听一个端口号并创建通信socket
        ServerSocket serverSocket = new ServerSocket(8888);
        // 当有客户端连接时创建一个通信socket,没有连接时会阻塞
        Socket socket = serverSocket.accept();
        // 打印客户端信息
        System.out.println("客户端" + socket.getInetAddress().getLocalHost() + "连接到服务器");
        // 输入流，用于读取客户端信息
        InputStream in = socket.getInputStream();
        // 输出流，用于给客户端返回信息
        OutputStream out = socket.getOutputStream();
        /* 读取客户端信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 关闭输入流
        socket.shutdownInput();
        // 打印从客户端收到的信息
        System.out.println("服务端接收到消息:" + msgBuilder.toString());
        // 给客户端返回信息
        out.write(("服务端收到消息:" + msgBuilder.toString()).getBytes(StandardCharsets.UTF_8) );
        // 关闭输出流同时关闭socket
        out.close();
    }
}

客户端

public class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 指定ip和端口号，创建socket连接
        Socket socket = new Socket("127.0.0.1", 8888);
        /* 发送消息 */
        String msg = "客户端发送了一条消息,现在是北京时间" + new Date();
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        out.write(msg.getBytes(StandardCharsets.UTF_8));
        out.flush();
        // 关闭输出流
        socket.shutdownOutput();
        /* 读取信息 */
        byte[] buffer = new byte[1024];
        int len;
        StringBuilder msgBuilder = new StringBuilder();
        while ((len = in.read(buffer)) != -1) {
            msgBuilder.append(new String(buffer, 0, len));
        }
        // 打印收到信息
        System.out.println("客户端收到服务端回信：" + msgBuilder);
        // 关闭输入流同时关闭socket
        in.close();
    }
}
输出结果

  1、服务端

客户端LAPTOP-EECN3AOI/192.168.31.39连接到服务器
服务端接收到消息:客户端发送了一条消息,现在是北京时间Sun Jan 07 16:46:26 GMT+08:00 2024

  2、客户端

客户端收到服务端回信：服务端收到消息:客户端发送了一条消息,现在是北京时间Sun Jan 07 16:46:26 GMT+08:00 2024

4、心得

（1）关闭socket的 输入/输出流 时，会将socket连接一起关闭，当socket还需要继续工作时，需要使用内置方法shutdownOutput和shutdownInput关闭流
（2）输入流只有当对方输出流关闭时，才会以-1作为结束标志

二、多次通信

  之前的代码，只进行了一次通信就将输出流关闭，实际应用中会存在多次通信，需要进行进一步优化。要进行多次通信，就需要制定每次发送消息的结束标识，有以下两种方式可以实现：
（1） 仅使用字符通信，制定一个结束标识，比如 “END” 字符串。当读取到"EDN"字符串时，就说明读取到了一个完整的消息，但有一个弊端，就是消息里可能存在与结束标识同样的内容，会干扰消息的接收，解决方法可以是在与结束标识相同内容前，加入转义字符，但处理起来比较麻烦，因此本次不此本方法实践
（2）在消息头部，加入n个字节，用于表示本次发送消息大小。通信双方约定好这个规范，接收方先读取前n个字节获取大小，再从输入流中读取对应数目的字节，就可以读取到对应的消息。本次实践使用此方法

1、第一版代码，存在信息缺漏问题

客户端代码
    public static void main(String[] args) throws IOException {
        // 指定ip和端口号，创建socket连接
        Socket socket = new Socket("127.0.0.1", 8888);
        /* 发送消息 */

        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        for (int i = 1; i <= 3; i++) {
            String msg = "客户端发送第"+ i +"条消息,现在是北京时间" + new Date();
            byte[] msgBytes = msg.getBytes(StandardCharsets.UTF_8);
            // 发送本次消息长度
            out.write(msgBytes.length);
            // 发送本次消息
            out.write(msgBytes);
        }
        out.flush();
        socket.shutdownOutput();
        // 关闭输入流同时关闭socket
        in.close();
        socket.close();
    }
服务端代码
public static void test01() throws IOException{
        // 创建一个serverSocket，监听一个端口号并创建通信socket
        ServerSocket serverSocket = new ServerSocket(8888);
        // 当有客户端连接时创建一个通信socket,没有连接时会阻塞
        Socket socket = serverSocket.accept();
        // 打印客户端信息
        System.out.println("客户端" + socket.getInetAddress().getLocalHost() + "连接到服务器");
        // 输入流，用于读取客户端信息
        InputStream in = socket.getInputStream();
        // 初始化大于消息最大字节数数组,可以复用
        byte[] buffer = new byte[1024];
        while (true) {
            // 读取第一个字节获取消息长度
            int len = in.read();
            // 当客户端关闭输出流时停止读取
            if (len == -1) break;
            // 读取数据
            int readLen = in.read(buffer);
            if (readLen == -1) break;
            // 打印读取到的数据
            System.out.println(new String(buffer, 0, len));
        }
        // 关闭输入流
        socket.shutdownInput();
        socket.close();
    }
运行结果：部分消息缺漏
客户端LAPTOP-EECN3AOI/192.168.31.39连接到服务器
客户端发送第1条消息,现在是北京时间Sun Jan 14 12:54:57 GMT+08:00 2024
客户端发送第2条消息,现在是北京时间Sun Jan 14 12:54:57 GMT+08:00 2024
原因分析

 由于TCP是可靠传输，因此可以排除消息传输丢失的可能性，那么问题就出现在服务端读取上面：

while (true) {
            // 读取第一个字节获取消息长度
            int len = in.read();
            // 当客户端关闭输出流时停止读取
            if (len == -1) break;
            // 读取数据
            int readLen = in.read(buffer);
            if (readLen == -1) break;
            // 打印读取到的数据
            System.out.println(new String(buffer, 0, len));
}

 在读取完一条消息的大小后，将输入流中数据全部读入数组，而实际上此时后续消息可能也已经到达，也一并被读取到buffer中，而打印数据的代码只截取了一条消息的大小的数据，剩余后续数据在下次读取中被舍弃，因此出现了信息缺漏
 解决方法，应该在读取进buffer时只截取对应长度的数据，再将数据输出

2、第二版代码

 只对服务端进行修改，客户端代码保持和之前一致

服务端代码
    public static void test02() throws IOException {
        // 创建一个serverSocket，监听一个端口号并创建通信socket
        ServerSocket serverSocket = new ServerSocket(8888);
        // 当有客户端连接时创建一个通信socket,没有连接时会阻塞
        Socket socket = serverSocket.accept();
        // 打印客户端信息
        System.out.println("客户端" + socket.getInetAddress().getLocalHost() + "连接到服务器");
        // 输入流，用于读取客户端信息
        InputStream in = socket.getInputStream();
        // 初始化大于消息最大字节数数组,可以复用
        byte[] buffer = new byte[1024];
        int len;
        // 每次读取一字节获取消息长度，直至客户端关闭输出流
        while ((len = in.read()) != -1) {
            // 只读取消息长度的数据
            int readLen = in.read(buffer, 0, len);
            // 客户端关闭输出流时停止读取
            if (readLen == -1) break;
            System.out.println(new String(buffer, 0, len));
        }
        // 关闭输入流
        socket.shutdownInput();
        socket.close();
    }
运行结果

 读取到所有数据：

客户端LAPTOP-EECN3AOI/192.168.31.39连接到服务器
客户端发送第1条消息,现在是北京时间Sun Jan 14 13:14:30 GMT+08:00 2024
客户端发送第2条消息,现在是北京时间Sun Jan 14 13:14:30 GMT+08:00 2024
客户端发送第3条消息,现在是北京时间Sun Jan 14 13:14:30 GMT+08:00 2024
木星mx
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java socket 编程学习笔记
lvchang
04-12 325
 1. Socket 通信简介及模型 　　Java Socket 可实现客户端--服务器间的双向实时通信。java.net包中定义的两个类socket和ServerSocket，分别用来实现双向连接的client和server端。 2. Socket 通信实现方法 2.1 服务器端（非多线程） 　 /** * 基于TCP协议的Socket通信，实现用户登录，...
JAVA Socket 编程学习笔记（一）
疯猫
01-04 631
Java Socket 可实现客户端--服务器间的双向实时通信。java.net包中定义的两个类socket和ServerSocket，分别用来实现双向连接的client和server端。
Java Socket 编程学习笔记(一)
春风十里不如你。
07-29 93
最近面试的时候面试官问了我好几次关于Socket编程的知识，QAQ。一直没有深入学习过网络编程的内容。今天去图书馆借了一本孙卫琴老师的网络编程的书，这几周下了决心要好好学学。 Socket是什么 Socket一般翻译成中文叫套接字，wiki是这么说的，network socket 是通过计算机网络的进程间通信(IPC)的端点。现在大部分的OS都实现了socket interface，也就...
JAVA socket编程学习笔记
黄彪博客
12-04 457
Socket是网络编程，而不是简单的网页编程，它与J2EE编写网页代码还是有很大的区别的，Socket更接近底层一点，所以难度稍稍大一点。   编写一个群发的demo，该例子是在《疯狂JAVA中找的》   server端： package hb.thread.server; import java.io.*; import java.net.*; //负责处理每个线程通信的
Socket 编程学习笔记
一个好知识的传播者
11-26 88
连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。TCP 是一个双向的通信协议，因此数据可以通过两个数据流在同一时间发送.以下是一些类提供的一套完整的有用的方法来实现 socket。在服务器端，accept() 方法返回服务器上一个新的 socket 引用，该 socket 连接到客户端的 socket。
socket connect java_java网络编程学习笔记（二）：socket详解
weixin_35988836的博客
02-21 2957
1.Socket有多种构造方法，大多数构造方法在构造的时候就指定了连接的主机和端口号。当客户端的构造方法与服务器连接的时候，可能需要等待一段时间，因为需要建立连接。默认情况下，Socket的构造方法会一直等待下去，直到连接成功或者是出现异常。Socket的构造方法请求连接的时候，受到底层网络传输速度的影响，可能长时间处于等待状态。如果希望限定等待时间，就需要一个无参的构造方法，可以如下做：Sock...
Java学习笔记——网络编程
weixin_41072833的博客
03-19 265
一、网络基础知识1、两台计算机之间的通行需要有相同的协议（TCP/IP协议），相同的端口号，各自唯一标识的IP地址。【端口号范围：0~65535，其中0~1023为系统所保留】2、IP地址和端口号组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础。3、两台计算机相互通信需要知道两台计算机的IP地址和端口号。4、常用的协议端口号。（超文件传输协议...
15Java网络编程学习笔记
tangguanlin2008的博客
01-31 1118
Java网络编程学习笔记 文章目录1 网络基础1.1 网络通信1.2 网络1.3 IP地址1.5 域名1.6 端口号1.7 网络通信协议1.8 TCP协议1.9 UDP协议2 IntetAddress IP地址2.1 getLocalHost()2.2 getByName()2.3 getHostAddress()2.4 getHostName()3 Socket4 TCP编程4.1 基本介绍4.2 应用案例1(使用字节流)4.3 应用案例2(使用字节流)4.4 应用案例3(使用字...
java网络编程笔记_java网络编程学习笔记（一）
weixin_34797773的博客
02-26 74
1.进程之间的通信进程是指运行中的程序，进程的任务就是执行程序中的代码。存在计算机网络上的两个进程只需要关注它们通信的具体内容，而不需关注消息在网络上传输的具体细节。2.计算机网络的概念Internet提供的服务包括www服务，电子邮件服务，文件传输服务(FTP)，远程登录服务(Telnet)。全球用户可以通过或这些服务来获取Internet上的信息，或者开展各种业务。3.udp和tcp两个进程...
学习笔记：多线程Java Socket编程示例
08-17
其中采用Java 的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求....注意，此为学习笔记，可以作为参考学习使用，不建议商业使用或生产使用。 废话不多说，直接上代码。
java深入学习笔记.pdf
11-29
* Socket编程：java中的Socket编程可以实现客户端与服务器端的通信。 * TCP/IP协议：java中的TCP/IP协议可以实现可靠的网络通信。 * 网络Socket：java中的网络Socket可以实现基于TCP/IP协议的网络通信。 八、java...
java学习笔记-Scokect.pdf
11-29
Java学习笔记-Scoket.pdf是关于Java编程语言中Socket编程的学习笔记，涵盖了Socket编程的基础知识、Java中Socket的使用、Socket通信的原理及应用等方面的内容。 Socket编程的基础知识 在Java编程语言中，Socket是...
[Java]详解Socket和ServerSocket学习笔记
09-15
在进行Socket编程时，会遇到几种常见的异常，包括UnknownHostException（主机名或IP错误）、ConnectException（服务器拒绝连接、服务器未启动或超出连接队列限制）、SocketTimeoutException（连接超时）和...
java内部学习笔记.docx
02-18
Java技术基础 4 1.1编程语言 4 1.2 Java的特点 4 1.3 Java开发环境 4 1.4 Java开发环境配置 5 1.5 Linux命令与相关知识 5 1.6 Eclipse/Myeclipse程序结构 6 ...5.13 Socket网络编程 65 5.14线程池 67 5.15双缓冲队列 68
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 786
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
日常工作记录目录
与海
06-21 154
EasyExcel实现二维码下载与展示
Day43
m0_67496588的博客
06-20 1059
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 258
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值