Java实现TCP通信程序

最新推荐文章于 2024-08-22 16:45:55 发布
最新推荐文章于 2024-08-22 16:45:55 发布
阅读量2.8k 收藏 6
点赞数 1
分类专栏： Java 文章标签： socket java TCP 客户端 服务端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sc179/article/details/109540021
版权

目录

1 概述

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

  1. 服务端程序先启动，等待客户端的连接。
  2. 客户端请求连接服务端，连接成功才能通信。服务端不可以主动连接客户端。

在Java中，提供了两个类用于实现TCP通信程序：

  1. 服务端：java.net.ServerSocket 类。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。
  2. 客户端：java.net.Socket 类。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接，开始通信。

2 ServerSocket类（服务端）

ServerSocket类：实现了服务器套接字，该类对象等待通过网络的请求。

套接字指的是两台设备之间通讯的端点。

2.1 构造方法

  • public ServerSocket(int port) ：创建一个ServerSocket对象，并将其绑定到一个指定的端口号上，参数port就是端口号。

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666);

2.2 成员方法

  • public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

3 Socket类（客户端）

Socket 类：该类实现客户端套接字。

3.1 构造方法

  • public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。
    如果指定的host是null ，则相当于指定地址为回送地址。

    小贴士：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

Socket client = new Socket("127.0.0.1", 6666);

3.2 成员方法

1 public InputStream getInputStream() ： 返回此套接字的输入流。

  • 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
  • 关闭生成的InputStream也将关闭相关的Socket。

2 public OutputStream getOutputStream() ： 返回此套接字的输出流。

  • 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
  • 关闭生成的OutputStream也将关闭相关的Socket。

3 public void close() ：关闭此套接字。

  • 一旦一个socket被关闭，它不可再使用。
  • 关闭此socket也将关闭相关的InputStream和OutputStream 。

4 public void shutdownOutput() ： 禁用此套接字的输出流。

  • 任何先前写出的数据将被发送，随后终止输出流。

4 简单的TCP通信程序

4.1 TCP通信步骤解析

  1. 【服务端】启动,创建ServerSocket对象，等待连接。
  2. 【客户端】启动,创建Socket对象，请求连接。
  3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
  4. 【客户端】Socket对象获取OutputStream，向服务端写出数据。
  5. 【服务端】Scoket对象获取InputStream，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

自此，服务端向客户端回写数据。

  1. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
  2. 【客户端】Scoket对象，获取InputStream，解析回写数据。
  3. 【客户端】释放资源，断开连接。

在这里插入图片描述

4.2 客户端向服务器发送数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
      	// 4.1 创建字节数组
        byte[] b = new byte[1024];
      	// 4.2 据读取到字节数组中.
        int len = is.read(b);
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
        //5.关闭资源.
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
	public static void main(String[] args) throws Exception {
		System.out.println("客户端 发送数据");
		// 1.创建 Socket ( ip , port ) , 确定连接到哪里.
		Socket client = new Socket("localhost", 6666);
		// 2.获取流对象 . 输出流
		OutputStream os = client.getOutputStream();
		// 3.写出数据.
		os.write("你好么? tcp ,我来了".getBytes());
		// 4. 关闭资源
		os.close();
		client.close();
	}
}

在这里插入图片描述
在这里插入图片描述

4.3 服务器向客户端回写数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
      	// 4.1 创建字节数组
        byte[] b = new byte[1024];
      	// 4.2 据读取到字节数组中.
        int len = is.read(b);
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
      	// =================回写数据=======================
      	// 5. 通过 socket 获取输出流
      	 OutputStream out = server.getOutputStream();
      	// 6. 回写数据
      	 out.write("我很好,谢谢你".getBytes());
      	// 7.关闭资源.
      	out.close();
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
	public static void main(String[] args) throws Exception {
		System.out.println("客户端 发送数据");
		// 1.创建 Socket ( ip , port ) , 确定连接到哪里.
		Socket client = new Socket("localhost", 6666);
		// 2.通过Scoket,获取输出流对象 
		OutputStream os = client.getOutputStream();
		// 3.写出数据.
		os.write("你好么? tcp ,我来了".getBytes());
      	// ==============解析回写=========================
      	// 4. 通过Scoket,获取 输入流对象
      	InputStream in = client.getInputStream();
      	// 5. 读取数据数据
      	byte[] b = new byte[100];
      	int len = in.read(b);
      	System.out.println(new String(b, 0, len));
		// 6. 关闭资源 .
      	in.close();
		os.close();
		client.close();
	}
}

在这里插入图片描述
在这里插入图片描述

5 综合案例

5.1 文件上传案例

5.1.1 文件上传基本步骤

  1. 【客户端】输入流，从硬盘读取文件数据到程序中。
  2. 【客户端】输出流，写出文件数据到服务端。
  3. 【服务端】输入流，读取文件数据到服务端程序。
  4. 【服务端】输出流，写出文件数据到服务器硬盘中。

在这里插入图片描述

基本实现

服务端实现：

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
      	ServerSocket serverSocket = new ServerSocket(6666);
  		// 2. 建立连接 
        Socket accept = serverSocket.accept();
      	// 3. 创建流对象
      	// 3.1 获取输入流,读取文件数据
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        // 3.2 创建输出流,保存到本地 .
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
		// 4. 读写数据
        byte[] b = new byte[1024 * 8];
        int len;
        while ((len = bis.read(b)) != -1) {
            bos.write(b, 0, len);
        }
        //5. 关闭 资源
        bos.close();
        bis.close();
        accept.close();
        System.out.println("文件上传已保存");
    }
}

客户端实现：

public class FileUPload_Client {
	public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件  
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端 
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据. 
        byte[] b  = new byte[1024 * 8 ];
        int len ; 
        while (( len = bis.read(b))!=-1) {
            bos.write(b, 0, len);
            bos.flush();
        }
        System.out.println("文件发送完毕");
        // 3.释放资源

        bos.close(); 
        socket.close();
        bis.close(); 
        System.out.println("文件上传完毕 ");
	}
}

5.1.2 文件上传优化

  1. 文件名称写死的问题

    服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一，代码如下：

FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
BufferedOutputStream bos = new BufferedOutputStream(fis);

  1. 循环接收的问题

    服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：

// 每次接收新的连接,创建一个Socket
while（true）{
    Socket accept = serverSocket.accept();
    ......
}

  1. 效率问题

    服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：

while（true）{
    Socket accept = serverSocket.accept();
    // accept 交给子线程处理.
    new Thread(() -> {
      	......
        InputStream bis = accept.getInputStream();
      	......
    }).start();
}
优化实现
public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
      	// 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/* 
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                      bos.write(b, 0, len);
                    }
                    //4. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                  	e.printStackTrace();
                }
            }).start();
        }
    }
}

5.1.3 信息回写步骤

前四步与基本文件上传一致.

  1. 【客户端】输入流，从硬盘读取文件数据到程序中。
  2. 【客户端】输出流，写出文件数据到服务端。
  3. 【服务端】输入流，读取文件数据到服务端程序。
  4. 【服务端】输出流，写出文件数据到服务器硬盘中。
  1. 【服务端】获取输出流，回写数据。
  2. 【客户端】获取输入流，解析回写数据。
    在这里插入图片描述
回写实现
public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/*
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                ) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                        bos.write(b, 0, len);
                    }

                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================

                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端实现：

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据.
        byte[] b  = new byte[1024 * 8 ];
        int len ;
        while (( len  = bis.read(b))!=-1) {
            bos.write(b, 0, len);
        }
      	// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================

        // 4.释放资源
        socket.close();
        bis.close();
    }
}

5.2 模拟B\S服务器

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

5.2.1 案例分析

  1. 准备页面数据：web文件夹。
    在这里插入图片描述

  2. 我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问；

  3. 服务器程序中字节输入流可以读取到浏览器发来的请求信息：GET /web/index.html HTTP/1.1是浏览器的请求消息。而web/index.html才是浏览器想要请求的服务器端的资源，因此使用字符串切割方式获取到请求的资源。

//取出请求资源的路径
String[] strArr = requst.split(" ");
//去掉web前面的/
String path = strArr[1].substring(1);
System.out.println(path);

5.2.2 案例实现

服务端实现：

public class SerDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端  启动 , 等待连接 .... ");
        // 创建ServerSocket 对象
        ServerSocket server = new ServerSocket(8888);
        Socket socket = server.accept();
        // 转换流读取浏览器的请求消息
        BufferedReader readWb = new
        BufferedReader(new InputStreamReader(socket.getInputStream()));
        String requst = readWb.readLine();
        // 取出请求资源的路径
        String[] strArr = requst.split(" ");
        // 去掉web前面的/
        String path = strArr[1].substring(1);
        // 读取客户端请求的资源文件
        FileInputStream fis = new FileInputStream(path);
        byte[] bytes= new byte[1024];
        int len = 0 ;
        // 字节输出流,将文件写会客户端
        OutputStream out = socket.getOutputStream();
        // 写入HTTP协议响应头,固定写法
        out.write("HTTP/1.1 200 OK\r\n".getBytes());
        out.write("Content-Type:text/html\r\n".getBytes());
        // 必须要写入空行,否则浏览器不解析
        out.write("\r\n".getBytes());
        while((len = fis.read(bytes))!=-1){
            out.write(bytes,0,len);
        }
        fis.close();
        out.close();
        readWb.close();	
        socket.close();
        server.close();
    }
}

5.2.3 访问效果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8fjhns2M-1604715867192)(img/效果图1.png)]

小贴士：不同的浏览器，内核不一样，解析效果有可能不一样。

发现浏览器中出现很多的叉子,说明浏览器没有读取到图片信息导致。

浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while(true){
            Socket socket = server.accept();
            new Thread(new Web(socket)).start();
        }
    }
    static class Web implements Runnable{
        private Socket socket;
        public Web(Socket socket){
            this.socket=socket;
        }
        public void run() {
            try{
                //转换流,读取浏览器请求第一行
                BufferedReader readWb = new
                        BufferedReader(new InputStreamReader(socket.getInputStream()));
                String requst = readWb.readLine();
                //取出请求资源的路径
                String[] strArr = requst.split(" ");
                System.out.println(Arrays.toString(strArr));
                String path = strArr[1].substring(1);
                System.out.println(path);

                FileInputStream fis = new FileInputStream(path);
                System.out.println(fis);
                byte[] bytes= new byte[1024];
                int len = 0 ;
                //向浏览器 回写数据
                OutputStream out = socket.getOutputStream();
                out.write("HTTP/1.1 200 OK\r\n".getBytes());
                out.write("Content-Type:text/html\r\n".getBytes());
                out.write("\r\n".getBytes());
                while((len = fis.read(bytes))!=-1){
                    out.write(bytes,0,len);
                }
                fis.close();
                out.close();
                readWb.close();
                socket.close();
            }catch(Exception ex){

            }
        }
    }
}

访问效果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-enUDj7Kc-1604715867195)(img/效果图2.png)]图解：

[GET, /web/index.html, HTTP/1.1]
web/index.html
java.io.FileInputStream@2ca8d431
[GET, /web/img/logo2.png, HTTP/1.1]
web/img/logo2.png
java.io.FileInputStream@5a192d2d
[GET, /web/img/header.jpg, HTTP/1.1]
web/img/header.jpg
java.io.FileInputStream@7c342073
[GET, /web/img/1.jpg, HTTP/1.1]
web/img/1.jpg
java.io.FileInputStream@2c646036
[GET, /web/img/big01.jpg, HTTP/1.1]
web/img/big01.jpg
java.io.FileInputStream@368c7249
[GET, /web/img/ad.jpg, HTTP/1.1]
web/img/ad.jpg
java.io.FileInputStream@7416eadc
[GET, /web/img/small03.jpg, HTTP/1.1]
web/img/small03.jpg
java.io.FileInputStream@22ddcd01
[GET, /web/img/middle01.jpg, HTTP/1.1]
web/img/middle01.jpg
java.io.FileInputStream@43c75dac
[GET, /web/img/footer.jpg, HTTP/1.1]
web/img/footer.jpg
java.io.FileInputStream@3c0a01ac
[GET, /web/img/title2.jpg, HTTP/1.1]
web/img/title2.jpg
java.io.FileInputStream@1403ada2
[GET, /favicon.ico, HTTP/1.1]
favicon.ico
hellosc01
关注
专栏目录
基于java的TCP通信程序
12-28
本篇文章将深入探讨“基于Java的TCP通信程序”以及如何实现点对点的多通道通信。 TCP是一种面向连接的、可靠的传输协议，它确保了数据的顺序传输和错误检查。在Java中，我们主要使用`java.net`包中的`Socket`和`...
【Java 基础篇】Java TCP通信详解
繁依Fanyi的博客
09-21 8878
本文介绍了Java中如何使用TCP协议进行网络通信，包括TCP的基础知识、TCP编程的基本步骤、创建TCP服务器和客户端、数据传输等内容。通过学习本文，您可以开始使用TCP协议来构建自己的网络应用程序，实现可靠的数据传输。希望本文能够帮助您更好地理解和应用Java中的TCP通信。
在Java中实现通过TCP方式发送和接收Socket消息，包含在多线程状态下的实现
最新发布
sbxjhvdddjdjd的博客
08-22 1775
公司的代码，本来客户端client是前端的unity发送请求的，后面自己写的时候需要在本地进行测试，所以也用Java实现了前端，就写出来记录一下。本文主要展示客户端client跟服务端server基础代码，里面的一些业务逻辑没有进行展示。
HTTP in iOS你看我就够
赵坪生的博客
03-25 961
HTTP in iOS你看我就够HTTP属于老话题了，在项目中我们经常需要往服务端发POST或者GET请求，但是对于HTTP的了解不应只局限于此。千里之行，始于足下。越想走的远，基本原理就应该了解的透彻全面一些，仅仅停留在使用ASIHttpRequest或者AFNetWorking传个参数发个请求的程度上是不够的。这篇文章就是带你全方面回顾一下HTTP。通过本文你能收获哪些内容： 完整HTTP请求与
Java Socket Server TCP服务端向指定客户端发送消息
GY的的专栏
02-02 1591
首先我们可以知道只有有客户端连接服务器就会生成一个socket对象，socket对象中获取对应的输入输出流读取和写入就可以实现发送消息；也就是只要咱们把每次连接的socket保存起来，发送和接收数据就直接获取对应的socket就可以实现。也就是需要循环调用 server.accept()阻塞方法，对每个连接的socket保存起来。并且对于每一个连接的客户端单独创建一个线程进行读写操作。提示：注意server.accept()方法调用会阻塞，只有新的客户端连接后才返回一个新的socket对象。
Java教程：如何基于Tcp/Ip协议发送Socket请求并接收响应
wfeil211的博客
08-31 2478
如何基于Tcp/Ip协议发送Socket请求并接收响应
java实现简单TCP聊天程序
08-27
java实现简单TCP聊天程序 本文主要介绍了java实现简单TCP聊天程序的知识点，包括服务端和客户端的代码实现。下面是详细的知识点解释： TCP协议 TCP（Transmission Control Protocol）是一种可靠的、面向连接的...
基于java的modbus TCP通信
06-13
在 Java 中，可以使用 Socket 编程来实现 Modbus TCP 通信。首先，需要创建一个 Socket 对象，用于连接到 Modbus 设备。然后，需要根据 Modbus TCP 协议的报文格式编码报文，发送到设备端。设备端将回复响应报文，...
java使用TCP实现聊天小程序开发
06-19
利用java提供的ServerSocket和socket套接字进行网络通信。同时为了让多个用户同时连接发消息，使用多线程技术，但没有使用线程池。使用了Javaswing技术来进行图形化编程，让用户像qq聊天一样进行网聊，同时为了存储...
Java 网络编程TCP协议之发送数据和接收数据的详解
热门推荐
路宇的博客
11-27 1万+
TCP协议: 传输控制协议(Transmission Control Protocol) TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端和服务器端，由客户端向服务器端发出连接请求，每次连接的创建都要经历“三次握手”。 三次握手： TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。 第一握手，客户端向服务器发出连接请求，等待服务器确认。 第二次握手，服务
如何在Java实现TCP方式发送和接收Socket消息（多线程模式）
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-19 8608
详细叙述了如何在Java实现TCP方式发送和接收Socket消息（多线程模式）。欢迎点赞收藏。
（Java）TCP，客户端发送数据与服务器接收数据
weixin_43100266的博客
03-18 3174
TCP，客户端发送数据与服务器接收数据 客户端：数据来自于文本文件，接收服务器反馈 服务端：接收到的数据写入文本文件，给出反馈 获取自己电脑的IP： 使用快捷键：Windows+R，打开小窗口，输入cmd，打开黑色窗口，输入ipconfig回车，即可。 端口号取值范围为0~65535，其中0–1023之间的端口号用于一些知名的网络服务，普通用户程序使用1024以上的。 客户端代码： package Test_16; import java.io.*; import java.net.Socket;
Java基础十八：TCP发送数据、TCP接收数据、TCP通信6个案例练习
分享Java技术知识，共同成长进步！
08-03 1809
7、TCP通信程序 注：java为客户端提供了Socket类，为服务器端提供了ServerSocket类 8、TCP发送数据 TCP发送数据步骤： 1、创建客户端的Socket对象(Socket) 2、获取输出流，写数据 3、释放资源 //TCP发送数据: 需要进行三次握手，所以单独一个发送数据是不会成功的 public classClientDemo1{ public static voidmain(String[]args)throwsIOException{ ...
java实现socket tcp实时接收数据
weixin_36352023的博客
07-20 260
socket相关学习资料：https://edu.51cto.com/video/18.htmlJava实现Socket TCP实时接收数据 在网络编程中，Socket是一种常用的通信方式，可以用于实现客户端和服务器之间的数据传输。本文将介绍如何使用Java实现基于Socket的TCP实时数据接收。 什么是Socket？...
Java初级入门_网络编程TCP发送和接收数据代码
weixin_44539906的博客
07-21 543
入门小白网络编程TCP代码实现
Java中TCP通信的实现
QQ156881887的专栏
04-24 5050
传输控制协议（，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的通信协议，如果使用了 WireShark 工具，可以看到一次TCP连接建立时的整个过程。
java tcp demo_Java网络编程之TCP通信完整代码示例
weixin_28710999的博客
02-13 982
一、概述Socket类是Java执行客户端TCP操作的基础类，这个类本身使用代码通过主机操作系统的本地TCP栈进行通信。Socket类的方法会建立和销毁连接，设置各种Socket选项。ServerSocket类是Java执行服务器端操作的基础类，该类运行于服务器，监听入站TCP连接，每个socket服务器监听服务器的某个端口，当远程主机的客户端尝试连接此端口时，服务器就被唤醒，并返回一个表示两台主...
Java实现TCP网络通信程序设计
这篇文档详细介绍了使用Java进行TCP网络通信程序设计的课程设计，包括TCP/IP协议的基础理论和技术，以及Java网络编程的应用。TCP/IP协议是互联网上最广泛使用的通信协议，它由IP层和TCP层构成，前者负责主机定位和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hellosc01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值