Java基础——TCP通信

最新推荐文章于 2024-09-13 07:00:00 发布
最新推荐文章于 2024-09-13 07:00:00 发布
阅读量4.3k 收藏 22
点赞数 1
分类专栏： Java基础 文章标签： java tcp/ip 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61275790/article/details/130498272
版权
文章介绍了TCP协议的特点，如面向连接、可靠传输，并通过Java的Socket类展示了TCP的一发一收通信模式。接着讨论了单线程和多线程下的多发多收实现，以及如何通过线程池优化服务端处理多个客户端连接，以避免资源浪费。
摘要由CSDN通过智能技术生成

（1）TCP协议特点：

  • TCP是一种面向连接，安全，可靠的传输数据的协议
  • 传输前，采用“三次握手”方式，点对点通信，是可靠的
  • 在连接中可进行大数据量的传输

（2） TCP通信模式：（在java中只需使用java.net.Socket类实现通信，底层即是使用了TCP协议）

2.1：一发一收

客户端 （一发一收）

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

/**
   目标：完成Socket网络编程入门案例的客户端开发，实现1发1收。
 */
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);

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

            // 关闭资源。
            // socket.close();

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

服务端（一发一收）

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

/**
   目标：开发Socket网络编程入门代码的服务端，实现接收消息
 */
public class ServerDemo2 {
    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();
        }
    }
}

2.2：多发多收（单线程）

注意：目前的服务端不可以同时接收多个客户端的信息，因为目前服务端现在只有一个线程，只能与一个客户端进行通信。

客户端（多发多收：单线程，使用循环反复地发送消息）

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();
        }
    }
}

服务端（多发多收：单线程，使用循环反复的接收消息）

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

/**
   目标：开发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();
                // 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();
        }
    }
}

2.3：多发多收（多线程）

客户端（多发多收：多线程） 

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

/**
    目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ClientDemo3 {
    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();
        }
    }
}

服务端（多发多收：多线程） 

import java.net.ServerSocket;
import java.net.Socket;

/**
   目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo3 {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
                // 3、开始创建独立线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（定义一个线程类）

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
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() + "下线了！！！");
        }
    }
}

2.4：线程池

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

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

客户端（线程池：处理多个客户端消息，解决多线程N-N的关系，导致资源浪费的问题）

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

/**
    拓展：使用线程池优化：实现通信。
 */
public class ClientDemo4 {
    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", 6666);

            // 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();
        }
    }
}

 2.8服务端（线程池：处理多个客户端消息，解决多线程N-N的关系，导致资源浪费的问题）

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

/**
   目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo4 {

    // 使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(300,
            1500, 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(6666);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");

                // 任务对象负责读取消息。
                Runnable target = new ServerReaderRunnable(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（定义一个任务类） 

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() + "下线了！！！");
        }
    }
}

花楠拾
关注
专栏目录
Java网络编程之(一): TCP的简单连接
colwer的专栏
07-12 4136
Java网络编程之(一): TCP的简单连接 这是一组非常基本的连接， 局域网中电脑A用作服务端，IP为192.168,31.168 电脑B用作客户端，IP为192.168.31.132 一. 服务端TcpServer_1.java import java.net.*; import java.io.IOException; import java.io.PrintStr
Java网络通信TCP
weixin_57535054的博客
03-03 1238
ServerSocket 服务器使用socketScoket服务器和客户端都使用socket通过socket对象就可以进行发送接收数据。
Java网络编程：构建高性能的TCP/IP服务
最新发布
技术研究中心
09-13 460
大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java中，网络编程是一项基本而重要的技能。通过TCP/IP协议，Java能够实现高效的网络通信。本文将介绍如何使用Java构建高性能的TCP/IP服务。
java TCP通信
杨丙的博客
10-20 2809
java TCP通信 一、相关知识学习   TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能。基于TCP网络通讯实现的类主要有服务器端的ServerSocket用客户端的Socket。TCP类似于电话系统，建立双向的通信通道，确定连接，话音顺序接听。...
【Java 基础篇】Java TCP通信详解
繁依Fanyi的博客
09-21 8789
本文介绍了Java中如何使用TCP协议进行网络通信，包括TCP的基础知识、TCP编程的基本步骤、创建TCP服务器和客户端、数据传输等内容。通过学习本文，您可以开始使用TCP协议来构建自己的网络应用程序，实现可靠的数据传输。希望本文能够帮助您更好地理解和应用Java中的TCP通信。
java 实现 tcp_java实现TCP通信
weixin_31641077的博客
02-18 1795
1.概述通过ServerSocket与Socket实现的TCP的通信,这个例子配合了swing使用,其实作者之前发过一篇ServerSocker与Socket的通信,在这里,这边文章就是在这个例子上修改而成的.其实原理很简单的,就是一个服务端一个客户端,服务端这边创建好ServerSocket后,使用accept()堵塞一直等待客户端发送socket.好吧,不废话了.进正题.2.服务端swing的...
---随笔--Java实现TCP通信（双端通信接收与发送）
qq_41120902的博客
05-13 2365
设计一个基于最基本Socket的P2P“聊天软件”（文本互传），要求在同一个网关内可以通过任意常用端口建立会话并进行socket通讯、双向文本收发。
Java TCP通信
涂涂写写的笔记
06-25 441
Java：TCP通信 Socket：是网络驱动层提供给应用程序编程的接口和一种数据发送、接收机制。Socket由应用程序创建，与网络驱动层建立绑定机制，告诉网络驱动层当前应用程序所对应的IP地址和端口号。 Socket的方法： public Socket(String host, int port)：创建套接字并将其连接到指定主机上的指定端口号。 public Socket(InetAddress...
Java——TCP通信程序练习
smile4548656的博客
04-25 345
Java——TCP通信程序练习一、客户端接收反馈，服务器给出反馈二、客户端数据来自键盘输入三、服务器数据写入文本文件四、客户端数据来自文本文件五、上传文件服务器给出反馈六、多线程实现文件上传 一、客户端接收反馈，服务器给出反馈 1、需求 客户端：发送数据，接收服务器反馈 服务器：接收数据，给出反馈 2、代码实现 客户端 import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import j
Java网络编程——TCP通信
云雨澄枫的博客
11-08 2609
Java网络编程 第二章 TCP通信 2.1 概述 TCp通信实现两个计算机进行数据交互 ，通信的两端要严格区分服务器（Server）和客户端(Client) 通信步骤 ​ 1.先启动服务器端，然后等待客户端连接； ​ 2.客户端主动连接服务器端，连接成功才能通信。服务端不能主动连接客户端。 Java中提供了两个用于实现TCP通信的类 ​ 1.客户端：java.net.Socket类表示。创建Socket对象，向服务器端发出连接请求，服务器响应请求，两者建立连接； ​ 2.服务端：java.net.Se
Java入门第151课——TCP通信和UDP通信
Java学习博客
08-06 40
若想使一个服务端可以支持多客户端连接，我们需要解决以下问题：- 循环调用accept方法侦听客户端的连接- 使用线程来处理单一客户端的数据交互因为需要处理多客户端，所以服务端要周期性循环调用accept方法，但该方法会产生阻塞，所以与某个客户端的交互就需要使用线程来并发处理。
用Java实现TCP通信
06-12
要求客户机可以向服务器传送数据，服务器从客户端中读取数据。实际上，服务器也可以向客户机发送数据，只要像客户机那样建立输出流即可；客户机也可以接受服务器的数据，只要像服务器那样建立连接即可。
java建立TCP长链接
01-23
java建立TCP长链接，再加上心跳机制，下载后可以直接运行，包括server和client
JAVA——TCP编程
weixin_51345990的博客
01-10 747
【案例1】 (使用字节流) 编写一个服务器端，和一个客户端，服务器端在9999端口监听，客户端连接到服务器端，发送"hello,server"，然后退出4服务器端接收到客户端发送的信息，输出，并退出 客户端： import java.io.IOException; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; public class SocketTCP01Client { .
Java——TCP/IP超详细总结
用代码征服天下
12-24 2169
网络的基础知识 一、协议 1、简介： 在计算机网络与信息通信领域里，人们经常提及“协议”一词。互联网中常用的具有代表性的协议有IP、TCP、HTTP等。而LAN(局域网)中常用的协议有IPX/SPX”等。 下面通过通俗一点的方式来解释一下协议： 有三个人A、B、C。A只会说汉语、B只会说英语、而C既会说汉语又会说英语。现在A与B要聊天，他们之间该如何沟通呢？若A与C要聊天，又会怎样？这时如果我们...
Java tcp通信
A5865459的博客
04-19 2332
tcp实现服务端接收多个客户端消息，原理：主线程使用while死循环接收socket连接，为每个客户端的socket通信管道分配一个子线程接收 引入线程池（创建固定数量的线程，避免产生过多线程，消耗资源） 客户端 public class ClientDemo { public static void main(String[] args) { try { System.out.println("----客户端----"); .
JavaTCP连接
qq_43907296的博客
10-22 651
服务器端操作 import java.io.*; import java.net.ServerSocket; import java.net.Socket; public class Server { private static int port = 8002;//设置端口号 public static void main(String[] args)throws IOException { ServerSocket serverSocket = new ServerSo
Java中的TCP通信
Mafia的博客
04-11 561
客户端向服务端发起连接请求，如果服务端接收该请求，两者之间会建立起一个可靠的通信管道。（被称为端到端的通信管道）这个位置（服务端阻塞等待客户端发来消息的地方）通信双方事先会采用“三次握手“方式建立可靠连接，实现端到端的通信；如果客户端退出了，服务端仍然等客户端消息，通信管道突然断掉，服务端就会抛出异常。Java提供了一个java.net.Socket类来实现TCP通信。服务端启动，在accept的位置阻塞等待客户端请求；通信管道突然断掉，需要对异常进行处理。支持与多个客户端同时通信的。
Java网络通信深入解析：TCP、UDP与NIO实战
"这篇文章主要探讨了使用Java进行网络通信的各种方式，涵盖了TCP通信、UDP通信、多播以及非阻塞I/O（NIO）的概念和应用。通过实例展示了TCP通信的基本流程，包括客户端和服务器端的Socket编程。" 在Java中实现网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值