TCP协议

最新推荐文章于 2023-04-23 11:23:48 发布
最新推荐文章于 2023-04-23 11:23:48 发布
阅读量643 收藏 1
点赞数
分类专栏： 网络通信 Java 文章标签： tcp/ip 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58000391/article/details/125322472
版权

1、什么是TCP协议呢？

1.TCP是一种面向连接，安全、可靠的传输数据的协议。

2.传输前，采用“三次握手”方式，点对点通信，是可靠的 。

3.在连接中可进行大数据量的传输。

注意： 如果在java中只要是使用java.net.Socket类实现通信，底层即是使用了TCP协议。

Socket

构造器

说明

public Socket(String host , int port)​

创建发送端的Socket对象与服务端连接，参数为服务端程序的ip和端口。

Socket类成员方法

方法

说明

OutputStream getOutputStream()

获得字节输出流对象（发）

InputStream getInputStream()

获得字节输入流对象（收）

需求：服务端实现

实现步骤：

 1.创建ServerSocket对象，注册服务端端口。

2.调用ServerSocket对象的accept()方法，等待客户端的连接，并得到Socket管道对象。

3.通过Socket对象调用getInputStream()方法得到字节输入流、完成数据的接收。

4.释放资源：关闭socket管道

ServerSocket代码实现服务端：

服务端代码：

public static void main(String[] args) {
        try {
            System.out.println("===========服务端启动了==========");
            //1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            //2、必须调用accept方法，等待接受用户的Socket链接请求，建立Socket通信管道
            Socket socket = serverSocket.accept();
            //3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //4、把字节输入流包装缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //5、按照行读取消息
            String msg;
            if ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress()+"说了："+msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

需求：客户端实现

实现步骤：

1.创建客户端的Socket对象，请求与服务端的连接。

2.使用socket对象调用getOutputStream()方法得到字节输出流。

3.使用字节输出流完成数据的发送。

4.释放资源：关闭socket管道。

客户端代码：

 public static void main(String[] args) {
        try {
            System.out.println("==========客户端启动了============");
            //1、创建Socket通信管道请求与服务端链接
            //public Socket (String host , int port)
            //参数一：服务端的IP地址
            //参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1",7777);

            //2、从socket通信管道中得到一个字节输出流  负责发送数据
            OutputStream os = socket.getOutputStream();

            //3、把低级的字节流打包成打印流
            PrintStream ps = new PrintStream(os);

            //4、发送消息
            ps.println("我是TCP的客户端，我已经与你对接，并发出邀请：约吗？");
            ps.flush();

            //关闭资源(不建议关闭)
            socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

实现结果：

 注意：一定要服务端先启动，客户端才可以启动，否则就会报错。

 ServerSocket(服务端)

构造器

说明

public ServerSocket(int port)

注册服务端端口

 ServerSocket类成员方法

方法

说明

public Socket accept()

等待接收客户端的Socket通信连接

连接成功返回Socket对象与客户端建立端到端通信

 注意：如果客户端和服务端一方出了问题，另一方也会失效或者出错。

需求：使用TCP通信实现：多发多收消息、

实现步骤：

1.可以使用死循环控制服务端收完消息继续等待接收下一个消息。

2.客户端也可以使用死循环等待用户不断输入消息。

3.客户端一旦输入了exit，则关闭客户端程序，并释放资源。

服务端代码：

public static void main(String[] args) {
        try {
            System.out.println("===========服务端启动了==========");
            //1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            //2、必须调用accept方法，等待接受用户的Socket链接请求，建立Socket通信管道
            Socket socket = serverSocket.accept();
            //3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //4、把字节输入流包装缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress()+"说了："+msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

客户端代码：

public static void main(String[] args) {
        try {
            System.out.println("==========客户端启动了============");
            //1、创建Socket通信管道请求与服务端链接
            //public Socket (String host , int port)
            //参数一：服务端的IP地址
            //参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1",7777);

            //2、从socket通信管道中得到一个字节输出流  负责发送数据
            OutputStream os = socket.getOutputStream();

            //3、把低级的字节流打包成打印流
            PrintStream ps = new PrintStream(os);


            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                //4、发送消息
                ps.println(msg);
                ps.flush();
            }

            //关闭资源(不建议关闭)
//            socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

实现结果：

这次多发多收是如何实现的呢？

通过客户端使用循环反复地发送消息，服务端使用循环反复地接收消息。从而实现多发多收。

注意：目前服务端是单线程的，每次只能处理一个客户端的消息。


 

使用多线程——同时接受多个客户端消息（优化多发多收）

客户端代码：

package com.wfl.d7_socket3;

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    目标： 多发多收
 */
public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            System.out.println("==========客户端启动了============");
            //1、创建Socket通信管道请求与服务端链接
            //public Socket (String host , int port)
            //参数一：服务端的IP地址
            //参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1",7777);

            //2、从socket通信管道中得到一个字节输出流  负责发送数据
            OutputStream os = socket.getOutputStream();

            //3、把低级的字节流打包成打印流
            PrintStream ps = new PrintStream(os);


            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                //4、发送消息
                ps.println(msg);
                ps.flush();
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端启动代码：

package com.wfl.d7_socket3;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
    目标： 实现服务端可以同时处理多个客户端消息
 */
public class ServerDemo2 {
    public static void main(String[] args) {
        try {
            System.out.println("===========服务端启动了==========");
            //1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                //2、必须调用accept方法，等待接受用户的Socket链接请求，建立Socket通信管道
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+"上线了~~");
                //3、开始创建独立的线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

服务端线程代码：

package com.wfl.d7_socket3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread (Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            //3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //4、把字节输入流包装缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress()+"说了："+msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+"下线了~~");
        }
    }
}

重点：

1.主线程定义了循环负责接收客户端Socket管道连接

2.每接收到一个Socket通信管道后分配一个独立的线程负责处理它。

 

使用线程池优化（引入线程池）

客户端代码：

package com.wfl.d8_socket4;

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    拓展： 使用线程池优化：实现通信。
 */
public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            System.out.println("==========客户端启动了============");
            //1、创建Socket通信管道请求与服务端链接
            //public Socket (String host , int port)
            //参数一：服务端的IP地址
            //参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1",7777);

            //2、从socket通信管道中得到一个字节输出流  负责发送数据
            OutputStream os = socket.getOutputStream();

            //3、把低级的字节流打包成打印流
            PrintStream ps = new PrintStream(os);


            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                //4、发送消息
                ps.println(msg);
                ps.flush();
            }

            //关闭资源(不建议关闭)
//            socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端代码：采用线程池。

package com.wfl.d8_socket4;

import com.wfl.d7_socket3.ServerReaderThread;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

/**
    目标： 实现服务端可以同时处理多个客户端消息
 */
public class ServerDemo2 {
    //使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(3,
            5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(2),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
    public static void main(String[] args) {
        try {
            System.out.println("===========服务端启动了==========");
            //1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                //2、必须调用accept方法，等待接受用户的Socket链接请求，建立Socket通信管道
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+"上线了~~");
               //任务对象负责读取消息
                Runnable srr = new ServerReaderRunnable(socket);
                pool.execute(srr);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

package com.wfl.d8_socket4;


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerReaderRunnable implements Runnable {
    private Socket socket;
    public ServerReaderRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            //3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //4、把字节输入流包装缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress()+"说了："+msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+"下线了~~");
        }
    }
}

使用线程池的优势：

服务端可以复用线程处理多个客户端，可以避免系统瘫痪。

适合客户端通信时长较短的场景。

即时通信是啥？

即时通信，是指一个客户端的消息发出去，其他客户端可以接收到。

要咋设计？

1.即时通信需要进行端口转发的设计思想。

2.服务端需要把在线的Socket管道存储起来

3.一旦收到一个消息要推送给其他管道

实例：微信群发，就是即时通信的思想！

TCP通信如何实现BS请求网页信息回来呢？

1.客户端使用浏览器发起请求（不需要开发客户端）

2.服务端必须按照浏览器的协议规则响应数据。

꧁༺๑小王不是程序员๑༻꧂
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java网络编程详解（三）TCP通信程序
筱寒小记
06-28 761
一、什么是TCP通信？ TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务器（Server） 两端通信时步骤： 服务端程序，需要事先启动，等待客户端的连接。 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。 在Java中，提供了两个类用于实现TCP通信程序： 3. 客户端：java.net.Socket类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。 4. 服务端：java.net.Server.
Java中的TCP通信简单使用
TheCalm的博客
08-04 2212
在Java中，一般使用SocketServer和Socket这两个类实现TCP通信，前者为服务端的一个实体，而后者可以认为是一种对连接的封装。一般来说，需要先启动服务端，然后客户端才能向服务端发送连接请求，连接成功后，两端就可以互相通信了。
TCP 通信程序学习
InterestAndFun的博客
12-01 2106
1. TCP通信原理 ​ TCP 通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象，从而在通信的两端形成网络虚拟链路，一旦建立了虚拟的网络链路，两端的程序就可以通过虚拟链路进行通信。 ​ Java对基于TCP协议的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。 ​ Java为客户端提供了Socket类，为服务器端提供了 ServerSocket类。 2. TCP发送数据 ​ 发送数据的步骤 1. 创建客户端的Socket对象
Java实现TCP
weixin_51597979的博客
04-23 662
实现的功能是Client向Server发送“你好你好”消息。用Java编写的客户端代码如下；用Java编写的服务端代码如下；从连接通道中获取输入流的数据。从连接通道中获取输出流。
javaTCP协议通信
m0_48844699的博客
08-31 1209
Tcp通信有两个特点分别是面向连接,具有可靠性.面向连接:指的是客户端与服务端之间的连接,在通信之前会有三次握手的机制来确保连接的可靠性.tcp有状态:tcp会精确的纪录哪些数据是发送了的,哪些是没有被发送的,他保证数据包是按序到达的,不允许存在半点差错tcp是可以控制的:如果存在丢包或者网络不好的时候,会根据具体情况对数据包进行发送速度的控制或者对数据包进行重新发送....
modbus tcp协议解析
04-08
Modbus TCP协议是一种广泛应用于工业自动化领域的通信协议，它基于标准的TCP/IP协议栈，使得设备能够通过以太网进行数据交换。这个协议允许不同制造商的设备之间进行简单且有效的通信，大大增强了系统的互操作性。 ...
TCP协议实验1
08-03
【TCP协议实验1】实验旨在帮助学生深入理解TCP协议的工作原理，掌握其连接状态控制、可靠传输机制，并涉及拥塞控制算法。实验的核心是实现TCP协议的状态机，特别是客户端的“停-等”模式，以及Socket接口的编程。TCP...
ModbusTCP协议报文详细分析
08-24
ModbusTCP协议报文详细分析是一种基于TCP/IP协议的Modbus协议实现，ModbusTCP协议报文格式与ModbusUDP协议报文格式相同，唯一的区别在于ModbusTCP协议使用TCP协议，而ModbusUDP协议使用UDP协议。ModbusTCP协议报文...
tcp协议分析
03-19
tcp协议
Thingsboard gateway 3.4 接入TCP协议单设备改多设备
最新发布
10-13
总结来说，"Thingsboard gateway 3.4 接入TCP协议单设备改多设备"涉及到的关键知识点包括TCP协议、Thingsboard Gateway的工作原理、多设备并发处理策略、代码修改与调试，以及系统性能和安全性的考量。通过这一改造...
Java实现基于TCP协议的Socket通信
08-11
（1）实现了服务器和客户端之间的连接通信 （2）实现了客户端与客户端之间的连接通信
Java利用TCP协议实现客户端与服务器通信(附通信源码)
08-18
主要介绍了Java利用TCP协议实现客户端与服务器通信(附通信源码),文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
tcp协议格式
08-12
TCP数据协议格式 TCP数据协议格式 TCP数据协议格式 TCP数据协议格式
基于TCP协议网上聊天程序
12-01
本次计算机网络课程设计是基于TCP协议网上聊天程序，程序中用到了套接字socket、多线程thread和Python自带的图形界面库Tkinter，在密码保存和传递方面用到了MD5算法，该程序的功能：用户注册、用户登录、显示在线...
Java之TCP编程
m0_59340907的博客
07-17 482
使用Java进行TCP编程时，需要使用Socket模型；服务器用ServerSocket监听指定接口；客户端使用Socket(InetAddress,port)连接服务器；服务器端用accept()接受连接并返回Socket实例；双方通过Socket打开InputStream/OutputStream读写数据；https。...
java实现TCP协议文件传输
我的博客
10-18 2075
java实现TCP协议文件传输
java tcp套接字实现一个简单回显的网络通信
青红造了个大白之成长记
07-03 2147
编写一个简单回显的网络通信程序：服务器将接收到的客户端数据原封不动返回给客户端步骤一：创建服务器类：SimpleEchoServer,完成服务器套接字的创建和监听import java.io.DataInputStream; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; i...
C#编写OMRON Fins TCP协议与OMRON PLC通讯实例源码
01-06
【亲测实用】C#编写OMRON Fins TCP协议与OMRON PLC通讯源码 文件类型：程序源代码 主要功能： 本实例基于OMRON Fins TCP协议，采用C#语言编写上位机软件实现Socket与OMRON CP系列PLC通讯，实例中通过发送指令实现与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

꧁༺๑小王不是程序员๑༻꧂

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

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

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

打赏作者

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

抵扣说明：

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

余额充值