Java-TCP通信（实现多发多收、群聊功能），BS通信源码

最新推荐文章于 2024-07-23 15:33:42 发布
最新推荐文章于 2024-07-23 15:33:42 发布
阅读量1.9k 收藏 9
点赞数 3
分类专栏： JAVA基础学习 文章标签： 网络协议 java tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65049289/article/details/124500133
版权

个人简介

  • 大家好，我是韩慧腾。一名正在努力学JAVA的大一小白，本文章为初学的笔记，希望各位多多指教。💙
  • 欢迎点赞+收藏+留言💜
  • 只要你跑得快，风声自然会盖过闲言碎语🧡

一、TCP通信

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

TCP通信的基本原理：

  • 客户端怎么发，服务端就怎么收
  • 客户端如果没有消息，服务端会进入阻塞等待
  • Socket一方关闭或者出现异常，对方Socket也会失效或者出错

客户端/发送端：

 服务端/接收端：

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 17:16
 * 努力已经来不及了，你得拼命
 * TCP通信客户端/发送端(一来一收)
 */
public class ClientDemo_0 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端请求成功");
        //创建Socket通信管道请求与服务端的连接
        Socket s = new Socket(InetAddress.getLocalHost(),7777);
        //从Socket通信管道得到一个字节输出流，负责发送数据
        OutputStream os = s.getOutputStream();
        //把低级的流包装成打印流
        PrintStream p = new PrintStream(os);
        //发送消息
        p.println("我是TCP客户端");
        os.flush();
        //提醒：不要轻易关闭管道（s.close()）
    }
}

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 17:42
 * 努力已经来不及了，你得拼命
 * TCP通信服务端/接收端(一来一收)
 */
public class ServerDemo_0 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动成功");
        //注册端口
        ServerSocket s = new ServerSocket(7777);
        //调用accept方法，等待接收客户端的Socket连接请求，建立Socket管道
        Socket ss=s.accept();
        //从Socket通信管道中得到一个字节输入流
        InputStream i = ss.getInputStream();
        //把字节输入流包装成缓冲字符输入流
        BufferedReader b = new BufferedReader(new InputStreamReader(i));
        String s1;
        if((s1=b.readLine())!=null){
            System.out.println(ss.getRemoteSocketAddress()+"说:"+s1);
        }

    }
}

二、TCP通信——多发多收消息

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 22:16
 * 努力已经来不及了，你得拼命
 * TCP通信客户端/发送端(多发多收)
 */
public class ClientDemo_01 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端请求成功");
        Scanner sc = new Scanner(System.in);
        //创建Socket通信管道请求与服务端的连接
        Socket s = new Socket(InetAddress.getLocalHost(),7778);
        //从Socket通信管道得到一个字节输出流，负责发送数据
        OutputStream os = s.getOutputStream();
        //把低级的流包装成打印流
        PrintStream p = new PrintStream(os);
        while (true) {
            System.out.println("请输入弹幕：");
            String ss=sc.nextLine();
            //发送消息
            p.println(ss);
            os.flush();
        }
        //提醒：不要轻易关闭管道（s.close()）
    }
}

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 22:17
 * 努力已经来不及了，你得拼命
 * TCP通信服务端/接收端(多发多收)
 */
public class ServerDemo_01 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动成功");
        //注册端口
        ServerSocket s = new ServerSocket(7778);
        //调用accept方法，等待接收客户端的Socket连接请求，建立Socket管道
        Socket ss=s.accept();
        //从Socket通信管道中得到一个字节输入流
        InputStream i = ss.getInputStream();
        //把字节输入流包装成缓冲字符输入流
        BufferedReader b = new BufferedReader(new InputStreamReader(i));
        String s1;
        while (true) {
            if((s1=b.readLine())!=null){
                System.out.println(ss.getRemoteSocketAddress()+"说:"+s1);
            }
        }
    }
}

由于现在的服务端只有一个线程，只能与一个客户端进行通信

服务端同时接收多个客户端的消息

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 23:33
 * 努力已经来不及了，你得拼命
 * 实现一个服务端接收多个客户端消息，服务端
 */
public class ServerDemo_02 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动成功");
            //注册端口
            ServerSocket s = new ServerSocket(7779);
            //定义一个死循环由主线程负责不断的接收客户端的Socket管道连接
            while (true) {
                //调用accept方法，等待接收客户端的Socket连接请求，建立Socket管道
                Socket ss=s.accept();
                System.out.println(ss.getRemoteSocketAddress()+"上线了");
                //每接收到一个客户端Socket管道，就交给一个独立的子线程负责读取消息
                new SeverDemo_02ReaderThread(ss).start();

        }
    }
    }
class SeverDemo_02ReaderThread extends Thread{
    private Socket socket;

    public SeverDemo_02ReaderThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
//从Socket通信管道中得到一个字节输入流
            InputStream i = socket.getInputStream();
            //把字节输入流包装成缓冲字符输入流
            BufferedReader b = new BufferedReader(new InputStreamReader(i));
            String s1;
            while (true) {
                if ((s1 = b.readLine()) != null) {
                    System.out.println(socket.getRemoteSocketAddress() + "说:" + s1);
                }
            }
        } catch (IOException e) {
            System.out.println(socket.getRemoteSocketAddress()+"离线了！");
        }
    }
}

 

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/29 23:32
 * 努力已经来不及了，你得拼命
 * 实现一个服务端接收多个客户端消息，客户端
 */
public class ClientDemo_02 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端请求成功");
        Scanner sc = new Scanner(System.in);
        //创建Socket通信管道请求与服务端的连接
        Socket s = new Socket(InetAddress.getLocalHost(),7779);
        //从Socket通信管道得到一个字节输出流，负责发送数据
        OutputStream os = s.getOutputStream();
        //把低级的流包装成打印流
        PrintStream p = new PrintStream(os);
        while (true) {
            System.out.println("请输入弹幕：");
            String ss=sc.nextLine();
            //发送消息
            p.println(ss);
            os.flush();
        }
        //提醒：不要轻易关闭管
    }
}

三、TCP同时接收多个多个客户端消息（用线程池优化）

上述多线程实现存在的问题

  • 客户端与服务端 的线程模型是：N-N（即多少个客户端就创建多少线程，而线程又很耗费CPU资源）
  • 客户端存在的越多，系统越容易瘫痪

        

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/30 8:54
 * 努力已经来不及了，你得拼命
 * 接收多个客户端消息（线程池版本）
 */
public class ServerDemo_03 {
    //创建一个线程池对象
    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) throws Exception {
        System.out.println("服务端启动成功");
        //注册端口
        ServerSocket s = new ServerSocket(7775);
        //定义一个死循环由主线程负责不断的接收客户端的Socket管道连接
        while (true) {
            //调用accept方法，等待接收客户端的Socket连接请求，建立Socket管道
            Socket ss=s.accept();
            System.out.println(ss.getRemoteSocketAddress()+"上线了");
            Runnable r = new ServerReaderRunnable(ss);
            pool.execute(r);
        }
    }
}
class ServerReaderRunnable implements Runnable{
    private Socket socket;

    public ServerReaderRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //从Socket通信管道中得到一个字节输入流
            InputStream i = socket.getInputStream();
            //把字节输入流包装成缓冲字符输入流
            BufferedReader b = new BufferedReader(new InputStreamReader(i));
            String s1;
            while (true) {
                if ((s1 = b.readLine()) != null) {
                    System.out.println(socket.getRemoteSocketAddress() + "说:" + s1);
                }
            }
        } catch (IOException e) {
            System.out.println(socket.getRemoteSocketAddress() + "离线了！");
        }
    }
}

 

package com.itheima.TCP;

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

/**
 * @author hanhan
 * date 2022/4/30 8:53
 * 努力已经来不及了，你得拼命
 * 接收多个客户端消息（线程池版本）
 */
public class ClientDemo_03 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端请求成功");
        Scanner sc = new Scanner(System.in);
        //创建Socket通信管道请求与服务端的连接
        Socket s = new Socket(InetAddress.getLocalHost(),7775);
        //从Socket通信管道得到一个字节输出流，负责发送数据
        OutputStream os = s.getOutputStream();
        //把低级的流包装成打印流
        PrintStream p = new PrintStream(os);
        while (true) {
            System.out.println("请输入弹幕：");
            String ss=sc.nextLine();
            //发送消息
            p.println(ss);
            os.flush();
        }
        //提醒：不要轻易关闭管
    }
}

使用线程池的优势：

  • 服务端可以复用线程处理多个客户端，可以避免系统瘫痪
  • 适合客户端通信时长较短的场景

四、TCP通信实战案例——即时通信

即时通信含义：

  • 即时通信是指一个客户端的消息发出去，其他客户端可以接收到
  • 即时通信需要进行端口转发的设计思想
  • 服务端需要把在线的Socket管道存储起来
  • 一旦接收到一个消息要推送给其他管道

群聊：

package com.itheima.Case_;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * @author hanhan
 * date 2022/4/30 10:15
 * 努力已经来不及了，你得拼命
 * 实战案例——即时通信（服务端）
 */
public class ServerDemo_00 {
    //定义一个静态的List集合存储当前全部在线的Socket管道
    public static List<Socket> all_Sockets=new ArrayList<>();
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动成功");
        //服务端注册端口
        ServerSocket ss = new ServerSocket(7771);
        while(true){
            //开始等待接收客户端的Socket管道
            Socket s = ss.accept();
            System.out.println(s.getRemoteSocketAddress()+"上线了");
            all_Sockets.add(s);
            //创建一个独立的线程来单独处理Socket管道
            new ServerDemo_00Thread(s).start();
        }
    }
}
class ServerDemo_00Thread extends Thread {
    private Socket socket;

    public ServerDemo_00Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
//从Socket通信管道中得到一个字节输入流
            InputStream i = socket.getInputStream();
            //把字节输入流包装成缓冲字符输入流
            BufferedReader b = new BufferedReader(new InputStreamReader(i));
            String s1;
            while ((s1 = b.readLine()) != null) {
                System.out.println(socket.getRemoteSocketAddress() + "说:" + s1);
                //把这个消息进行端口转发给全部客户Socket管道
                sendMessage(s1);

            }
        } catch (IOException e) {
            System.out.println(socket.getRemoteSocketAddress() + "离线了！");
            ServerDemo_00.all_Sockets.remove(socket);
        }
    }
private void sendMessage(String s1) throws IOException {
    for (Socket s : ServerDemo_00.all_Sockets) {
        OutputStream o = s.getOutputStream();
        PrintStream p = new PrintStream(o);
        p.println(s1);
        p.flush();
    }
}
}

 

package com.itheima.Case_;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

/**
 * @author hanhan
 * date 2022/4/30 9:52
 * 实战案例——即时通信（）
 * 1.客户端发送消息
 * 2.客户端随时可能收到消息
 */
public class ClientDemo_00 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端启动");
        //创建与服务端连接的Socket管道
        Socket s = new Socket(InetAddress.getLocalHost(), 7771);
        //创建一个独立的线程专门负责这个客户端的读消息
        new ClientReaderThread(s).start();
        //从Socket管道得到一个字节输出流管道
        OutputStream o = s.getOutputStream();
        //包装成高级的打印流
        PrintStream p = new PrintStream(o);
        Scanner sc=new Scanner(System.in);
        while (true){
            System.out.println("请输入：");
            String s1=sc.nextLine();
            p.println(s1);
            p.flush();
        }
    }
}
class ClientReaderThread extends Thread{
    private Socket socket;

    public ClientReaderThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //从Socket通信管道中得到一个字节输入流
            InputStream i = socket.getInputStream();
            //把字节输入流包装成缓冲字符输入流
            BufferedReader b = new BufferedReader(new InputStreamReader(i));
            String s1;
            while (true) {
                if ((s1 = b.readLine()) != null) {
                    System.out.println("收到消息"+ s1);
                }
            }
        } catch (IOException e) {
            System.out.println("服务端把你踢出群聊");
        }
    }
}

五、BS架构模拟

之前的都是CS架构，客户端需要我们自己开发实现。而BS结构是浏览器访问服务端，不需要开发客户端。

注意：服务器必须给浏览器响应HTTP协议格式的数据 ，否则浏览器不识别

package com.itheima.BS;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @author hanhan
 * date 2022/4/30 11:27
 * 努力已经来不及了，你得拼命
 */
public class ServerDemo_00 {
    public static void main(String[] args) throws UnknownHostException {
        System.out.println(InetAddress.getLocalHost());
        try {
            //注册一个端口
            ServerSocket s = new ServerSocket(9091);
            while (true){
                Socket ss=s.accept();
                new ServerDemo_00Thread(ss).start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class ServerDemo_00Thread extends Thread{
    private Socket socket;

    public ServerDemo_00Thread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //从Socket通信管道中得到一个字节输出流
            OutputStream i = socket.getOutputStream();
            //把输出流包装成打印输出流
            PrintStream p=new PrintStream(i);
            //必须响应HTTP协议格式数据，否则浏览器不认识消息
            p.println("HTTP/1.1 200 OK");
            p.println("Content-Type:text/html;charset=UTF-8");
            p.println();
            p.println("<span style='color:red;font-size:80px'>生日快乐</span>");
            p.close();
        } catch (IOException e) {

        }
    }
}

凌晨四点半sec
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java: tcp通讯(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-18 139
java: tcp通讯(附完整源码)
JAVA Socket实现实时接收TCP消息，让你的服务端通信更高效！
猿小白的博客
06-04 4218
本文主要介绍如何利用socket实现实时接收服务端发送的TCP消息。
暑期JAVA学习（41.1）TCP通信——多发多收消息
xjl243636988的博客
08-06 422
一、使用TCP通信实现：多发多收消息案例 （1）需求 （2）具体要求 （3）具体实现 （4）总结 ①本案例实现了多发多收，那么是否可以同时接收多个客户端的消息？ ②本次多发多收是如何实现的呢？ ③现在服务端为什么不可以同时接收多个客户端的消息呢？...
Netty框架：java实现TCP协议服务端，接收处理数据信息
最新发布
qq_33651286的博客
07-23 312
【代码】Netty框架：java实现TCP协议服务端，接收处理数据信息。
Java-TCP/IP编程-03 消息群发功能
chen412115725的博客
09-02 349
Client端 package com.qf.demo10; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Font; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import jav
TCP服务器端多发多收
qq_39812064的博客
03-10 526
客户端可以多次向服务器端发送消息。服务器端在接收到消息以后，也可以多次向客户端发送消息 服务器端： package com.tcp; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketAddress; /* TCP协议服务器端 */ .
java202303java学习笔记第三十九天TCP协议(综合练习多发多送)
qq_41632427的博客
04-08 97
java
java源码包---java 源码 大量 实例
04-18
　Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程技能的提升很有帮助。 Java聊天程序，包括服务端和...
STM32F107实现DP83848-UDP-TCP通信程序
12-20
在实现通信程序时，我们还需要考虑错误处理、中断服务程序、多线程（如果使用 lwIP 的话）以及可能的网络时间同步。对于温湿度数据的传输，可以设计一个简单的协议，如在数据前添加标识符，以便PC端能够正确解析。 ...
Java利用TCP协议实现客户端与服务器通信【附通信源码】
m0_64383449的博客
12-08 1610
对于如何进行客户端和服务器端数据的通信，就要用到数据的输入流和输出流了，**服务器端的Socket对象使用getOutputStream()方法获取到的输出流，将指向客户端的Socket对象使用getInputStream()方法获取到的输入流。由此就实现在服务器向客户端发送数据的一个过程，**同样的道理，客户端端的Socket对象使用getOutputStream()方法获取到的输出流，将指向服务器端的Socket对象使用getInputStream()方法获取到的输入流。从而实现由客户端向服务器发送数据
如何在Java实现TCP方式发送和接收Socket消息（多线程模式）
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-19 8326
详细叙述了如何在Java实现TCP方式发送和接收Socket消息（多线程模式）。欢迎点赞收藏。
TCP聊天室群聊+私聊
12-24
可以学习TCP服务器转发数据，和建立socket一对一聊天。
TCP简易群聊网络聊天室
09-10
基于TCP/IP的简易群聊网络聊天室，一个客户端向服务器发送信息，服务器再接受信息后转发给所有连接的客户端。
TCP/IP聊天室（群聊MFC版）
04-11
能够群聊的一个程序，基于MFC的TCP/IP聊天室，希望给大家带来帮助。
java服务器如何群发消息,java TCP编程简单实现一个消息群发功能
weixin_42356292的博客
08-12 714
client：packagecom.lzs.net;importjava.io.*;importjava.net.Socket;/***Createdbyzaishon2016-3-20.*/publicclassMyTCPClient{publicstaticvoidmain(String[]args)throwsIOException{//1创建服务器指定...
105-Java网络编程：TCP通信：快速入门、实现多发多收消息、实现可以同时接收多个客户端
yelitoudu的博客
10-12 1861
Java网络编程：TCP通信：快速入门、实现多发多收消息、实现可以同时接收多个客户端
20220525_Java_TCP_线程池即时消息群发
ClarkGable的博客
05-25 150
服务端，包括Runnable类 import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; public class GroupServerDemo1 { public static ExecutorService pool = new ThreadPo
JAVA网络编程（二）（TCP&UDP实现通信）
weixin_48882711的博客
02-17 403
在可能的情况下，一个新建的DatagramSocket有SO_BROADCAST套接字选项已启用，以便允许广播数据报传输。在一些实施方案中，广播包，也可以接受当一个DatagramSocket绑定到一个更具体的地址。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。创建一个绑定的数据报套接字， 与指定的datagramsocketimpl相关（一般不使用）创建一个数据报套接字，绑定到。
TCP通信---实现 群聊
weixin_45881192的博客
01-27 973
群聊： 当有 客户机 给 服务器 发消息时， 这个消息必须 同时被发送到 其他的客户机。（注意：并不是直接让客户机之间进行连接，而是服务器在中间传） 一、构想： 1.QQ怎么运作？ 首先，用户需要 通过验证 加入到某一个群； 加入之后，每个用户都会有自己的一个聊天室界面， 这个界面中实时更新所有群成员发送的消息。 2.框架图： 2.1.整体：2.2.服务器和单一客户机交互图： 2.2.1...
Java实现Modbus TCP通信与PLC数据交互详解
在Java项目中实现Modbus TCP通信与工业控制器(PLC)的数据交互，通常用于监控和控制自动化系统中的设备。PLC通常采用Modbus协议进行数据交换，这是一种广泛应用于工业环境的通信标准。在这个场景中，我们关注的是如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

凌晨四点半sec

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

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

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

打赏作者

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

抵扣说明：

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

余额充值