Java SE基础知识详解第[18]期—网络编程（通信）

最新推荐文章于 2024-07-04 09:24:51 发布
最新推荐文章于 2024-07-04 09:24:51 发布
阅读量334 收藏 1
点赞数
分类专栏： Java学习 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuafeng222/article/details/126697691
版权

写在前面：

        每一个不曾起舞的日子，都是对生命的辜负。

        希望看到这里的每一个人都能努力学习，不负韶华，成就更好的自己。

        以下仅是个人学习过程中的一些想法与感悟，Java知识博大精深，作为初学者，个人能力有限，哪里写的不够清楚、明白，还请各位不吝指正，欢迎交流与讨论。如果有朋友因此了解了一些知识或对Java有了更深层次的理解，从而进行更进一步的学习，那么这篇文章的意义也就达到了。

目录

1.网络通信三要素

1.1三要素概述、要素一：IP地址

1.2IP地址操作类-InetAddress

1.3要素二：端口号

1.4要素三：协议

2.UDP通信-快速入门

2.1UDP通信：快速入门

2.2UDP通信：多发多收

3.UDP通信-广播、组播

4.TCP通信-快速入门

5.TCP通信-多发多收消息

6.TCP通信-同时接受多个客户端消息

7.TCP通信-使用线程池优化

8.TCP通信实战案例-即时通信

9.TCP通信实战案例-模拟BS系统

网络编程（通信）

1.网络通信三要素

1.1三要素概述、要素一：IP地址

实现网络编程关键的三要素

        IP地址：设备在网络中的地址，是唯一的标识。

        端口：应用程序（进程）在设备中唯一的标识。

        协议：数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。

IP地址

        IP(Internet Protocol)：全称”互联网协议地址”，是分配给上网设备的唯一标志。

        常见的IP分类为：IPv4和IPv6

IP地址基本寻路

        ①计算机通过访问域名地址向DNS服务器发出请求，DNS服务器中存储此域名地址所对应的IP地址，并将IP地址返回。

        ②计算机获取到IP地址后，访问该IP地址，并将获取数据返回到浏览器中并展示出来。

IP地址形式

        公网地址和私有地址(局域网使用)。

        192.168. 开头的就是常见的局域网地址，范围即为192.168.0.0--192.168.255.255，专门为组织机构内部使用。

IP常用命令

        ipconfig：查看本机IP地址。

        ping IP地址：检查网络是否连通。

特殊IP地址

        本机IP: 127.0.0.1或者localhost：称为回送地址也可称本地回环地址，只会寻找当前所在本机。

1.2IP地址操作类-InetAddress

InetAddress 的使用

        此类表示Internet协议（IP）地址。

InetAddress 常用API

方法名

说明

public static InetAddress getLocalHost()

返回本主机的地址对象

public static InetAddress getByName

(String host)

得到指定主机的IP地址对象，

参数是域名或者IP地址

public String getHostName ()

获取此IP地址的主机名

public String getHostAddress ()

返回IP地址字符串

public boolean isReachable(int timeout)

在指定毫秒内连通该IP地址对应的主机，

连通返回true

        示例代码如下：

public class InetAddressDemo1 {
    public static void main(String[] args) throws Exception {
        /*
            public static InetAddress getLocalHost()	返回本主机的地址对象
            public static InetAddress getByName (String host)	得到指定主机的IP地址对象，参数是域名或者IP地址
            public String getHostName ()	获取此IP地址的主机名
            public String getHostAddress ()	返回IP地址字符串
            public boolean isReachable(int timeout)	在指定毫秒内连通该IP地址对应的主机，连通返回true
         */
        // 1.获取本地地址对象
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1); // WIN-BCV5B84VJCS/10.23.247.25
        System.out.println(ip1.getHostAddress()); // 10.23.247.25
        System.out.println(ip1.getHostName()); // WIN-BCV5B84VJCS

        // 2.获取域名ip对象
        InetAddress ip2 = InetAddress.getByName("www.baidu.com");
        System.out.println(ip2.getHostAddress()); // 220.181.38.149
        System.out.println(ip2.getHostName()); // www.baidu.com

        // 3.获取公网IP对象
/*        InetAddress ip3 = InetAddress.getByName("220.181.38.149");
        System.out.println(ip3.getHostAddress()); // 220.181.38.149
        System.out.println(ip3.getHostName()); // 220.181.38.149*/

        // 4.判断是否能通：ping 5s之前测试是否可通
        System.out.println(ip2.isReachable(5000)); // false (太慢了！)
    }
    
}

1.3要素二：端口号

端口号

        端口号：标识正在计算机设备上运行的进程（程序），被规定为一个 16 位的二进制，范围是 0~65535。

端口类型

        周知端口：0~1023，被预先定义的知名应用占用（如：HTTP占用 80，FTP占用21）

        注册端口：1024~49151，分配给用户进程或某些应用程序。（如：Tomcat占 用8080，MySQL占用3306）

        动态端口：49152到65535，之所以称为动态端口，是因为它 一般不固定分配某种进程，而是动态分配。

        注：自己开发的程序选择注册端口，且一个设备中不能出现两个程序的端口号一样，否则出错。

1.4要素三：协议

通信协议

        连接和通信数据的规则被称为网络通信协议。

网络通信协议有两套参考模型

        OSI参考模型：世界互联协议标准，全球通信规范，由于此模型过于理想化，未能在因特网上进行广泛推广。

        TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。

网络通信协议两套参考模型

OSI参考模型

TCP/IP参考模型

各层对应

面向操作

应用层

应用层

HTTP、FTP、DNS、SMTP…

应用层  应用程序需要关注的：浏览器， 邮箱。程序员一般在这一层开发

表示层

会话层

传输层

传输层

TCP、UDP…

选择使用的TCP , UDP协议

网络层

网络层

IP、ICMP…

封装源和目标IP，进行路径选择

数据链路层

数据链路层+物理

物理寻址、

比特流…

物理设备中传输

物理层

传输层的2个常见协议

        TCP(Transmission Control Protocol)：传输控制协议

        UDP(User Datagram Protocol)：用户数据报协议

TCP协议特点

        使用TCP协议，必须双方先建立连接，它是一种面向连接的可靠通信协议。

        传输前，采用“三次握手”方式建立连接，所以是可靠的。

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

        连接、发送数据都需要确认，且传输完毕后，还需释放已建立的连接，通信效率较低。

TCP协议通信场景

        对信息安全要求较高的场景，例如：文件下载、金融等数据通信。

UDP协议特点

        UDP是一种无连接、不可靠传输的协议。

        将数据源IP、目的地IP和端口封装成数据包，不需要建立连接。

        每个数据包的大小限制在64KB内。

        发送不管对方是否准备好，接收方收到也不确认，故是不可靠的。

        可以广播发送，发送数据结束时无需释放资源，开销小，速度快。

UDP协议通信场景

        语音通话，视频会话等。

2.UDP通信-快速入门

2.1UDP通信：快速入门

UDP协议的特点

        UDP是一种无连接、不可靠传输的协议。

        将数据源IP、目的地IP和端口以及数据封装成数据包，大小限制在64KB内，直接发送出去即可。

DatagramSocket：发送端和接收端对象构造器

方法名

说明

public DatagramSocket()

创建发送端的Socket对象，系统会随机分配一个端口号。

public DatagramSocket(int port)

创建接收端的Socket对象并指定端口号

DatagramSocket类成员方法

方法名

说明

public void send(DatagramPacket dp)

发送数据包

public void receive(DatagramPacket p)

接收数据包

public void close()

发关闭送端/接收端对象

DatagramPacket：数据包对象构造器

方法名

说明

public DatagramPacket(byte[] buf, int length, InetAddress address, int port)

创建发送端数据包对象

buf：要发送的内容，字节数组

length：要发送内容的字节长度

address：接收端的IP地址对象

port：接收端的端口号

public DatagramPacket(byte[] buf, int length)

创建接收端的数据包对象

buf：用来存储接收的内容

length：能够接收内容的长度

DatagramPacket常用API

方法名

说明

public int getLength()

获得实际接收到的字节个数

public synchronized SocketAddress getSocketAddress()

获取对方IP地址

public synchronized int getPort()

获取对方端口号

客户端实现步骤 

        ① 创建DatagramSocket对象（发送端对象）。

        ② 创建DatagramPacket对象封装需要发送的数据（数据包对象）。

        ③ 使用DatagramSocket对象的send方法传入DatagramPacket对象 开始抛出数据。

        ④ 释放资源。

接收端实现步骤

        ① 创建DatagramSocket对象并指定端口（接收端对象）。

        ② 创建DatagramPacket对象接收数据（数据包对象）。

        ③ 使用DatagramSocket对象的receive方法传入DatagramPacket对象开始接收数据。

        ④ 释放资源。

        示例代码如下：

接收端

public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("接收端已启动-------");
        // 1.创建接收端对象，注册端口
        DatagramSocket socket = new DatagramSocket(666);

        // 2.创建一个数据包对象接收数据
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 3.等待接收数据
        socket.receive(packet);

        int len = packet.getLength(); // 接收了的数据的长度
        String rs = new String(buffer, 0, len);
        System.out.println("接收数据：" + rs);

        // 获取发送端的IP和端口
        String ip = packet.getSocketAddress().toString();
        System.out.println("对方地址：" + ip);

        int port = packet.getPort();
        System.out.println("对方端口：" + port);

        socket.close();
    }
    
}

发送端

public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("发送端已启动------");
        // 1.创建发送端对象,发送端自带随机的默认端口号
        DatagramSocket socket = new DatagramSocket();

        // 2.创建数据包对象封装数据
        /**
         public DatagramPacket(byte buf[], int length,
         InetAddress address, int port)
         参数一：封装要发送的数据
         参数二：发送数据的大小
         参数三：服务端的IP地址
         参数四：服务端的主机IP地址
         */
        byte[] buffer = "我爱你中国".getBytes();
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getLocalHost(), 666);

        // 3.发送数据
        socket.send(packet);

        socket.close();
    }
    
}

发送端程序运行结果如下：

发送端已启动------

对方地址：WIN-BCV5B84VJCS/10.23.247.25:666

对方端口：666

接收端程序运行结果如下：

接收端已启动-------

接收数据：我爱你中国

对方地址：/10.23.247.25:52734

对方端口：52734

2.2UDP通信：多发多收

需求

        使用UDP通信方式开发接收端和发送端。

分析

        ① 发送端可以一直发送消息。

        ② 接收端可以不断的接收多个发送端的消息展示。

        ③ 发送端输入了exit则结束发送端程序。

客户端实现步骤

        ① 创建DatagramSocket对象（发送端对象）。

        ② 使用while死循环不断的接收用户的数据输入，如果用户输入的exit则退出程序。

        ③ 如果用户输入的不是exit, 把数据封装成DatagramPacket。

        ④ 使用DatagramSocket对象的send方法将数据包对象进行发送开始抛出数据。

        ⑤ 释放资源

接收端实现步骤

        ① 创建DatagramSocket对象并指定端口（接收端对象）。

        ② 创建DatagramPacket对象接收数据（数据包对象）。

        ③ 使用while死循环不断的进行第4步。

        ④ 使用DatagramSocket对象的receive方法传入DatagramPacket对象开始接收数据。

        示例代码如下：

接收端

public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("接收端已启动-------");
        // 1.创建接收端对象，注册端口
        DatagramSocket socket = new DatagramSocket(666);
        // 2.创建一个数据包对象接收数据
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        while (true) {
            // 3.等待接收数据
            socket.receive(packet);

            int len = packet.getLength(); // 接收了的数据的长度
            String rs = new String(buffer, 0, len);
            System.out.println("接收来自IP地址为" + packet.getAddress() + "，端口号为" + packet.getPort() + "的数据：" + rs);
        }
    }

}

发送端

public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("发送端已启动------");
        // 1.创建发送端对象,发送端自带随机的默认端口号
        DatagramSocket socket = new DatagramSocket();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入要发送的数据：");
            String msg = sc.nextLine();
            if ("exit".equals(msg)) { // 按照阿里巴巴开发公约，equals方法中确定数据应该放在前面
                System.out.println("离线成功！");
                socket.close();
                break;
            }
            // 2.创建数据包对象封装数据
            byte[] buffer = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getLocalHost(), 666);
            // 3.发送数据
            socket.send(packet);
        }
    }

}

        接收端程序运行结果如下：

接收端已启动-------

接收来自IP地址为/10.23.247.25，端口号为57289的数据：123

接收来自IP地址为/10.23.247.25，端口号为57289的数据：你好，全聚德在逃烤鸭、

        发送端程序运行结果如下：

发送端已启动------

请输入要发送的数据：

123

请输入要发送的数据：

你好，全聚德在逃烤鸭、

请输入要发送的数据：

exit

离线成功！

        注：按照阿里巴巴开发公约，equals方法中确定数据应该放在前面，如if ("exit".equals(msg))。

3.UDP通信-广播、组播

UDP的三种通信方式

        单播：单台主机与单台主机之间的通信。

        广播：当前主机与所在网络中的所有主机通信。

        组播：当前主机与选定的一组主机的通信。

UDP如何实现广播

        使用广播地址：255.255.255.255

具体操作：

        ① 发送端发送的数据包的目的地写的是广播地址、且指定端口。 （255.255.255.255 , 9999）

        ② 本机所在网段的其他主机的程序只要注册对应端口就可以收到消息了。（9999）

UDP如何实现组播

        使用组播地址：224.0.0.0 ~ 239.255.255.255

具体操作：

        ① 发送端的数据包的目的地是组播IP (例如：224.0.1.1, 端口：9999)

        ② 本机所在网段的其他主机的程序接收端必须绑定（joinGroup）该组播IP(224.0.1.1)，端口还要注册发送端的目的端口9999 ，这样即可接收该组播消息。

        ③ DatagramSocket的子类MulticastSocket可以在接收端绑定组播IP。

4.TCP通信-快速入门

TCP协议回顾

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

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

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

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

Socket常用构造器

方法名

说明

public Socket(String host , int port)

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

Socket类成员方法

方法名

说明

OutputStream getOutputStream()

获得字节输出流对象

InputStream getInputStream()

获得字节输入流对象

客户端实现步骤

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

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

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

        ④ 释放资源：关闭socket管道。

ServerSocket常用构造器

方法名

说明

public ServerSocket(int port)

注册服务端端口

ServerSocket类成员方法

方法名

说明

public Socket accept()

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

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

public SocketAddress getRemoteSocketAddress()

获取连接的客户端的IP地址

服务端实现步骤

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

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

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

        ④ 释放资源：关闭socket管道。

        示例代码如下：

客户端

public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端已启动------");
        // 1.创建Socket通信管道请求与服务端的连接
        Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(), 666);
//        Socket socket = new Socket("127.0.0.1", 666);

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

        // 3.把低级的字节流包装为高级的打印流
        PrintStream ps = new PrintStream(os);

        // 4.发送消息
        ps.println("我是TCP客户端");
        ps.flush();

        // 5.关闭资源
//        socket.close();
    }

}

服务器端

public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);

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

        客户端程序运行结果如下：

客户端已启动------

        服务器端程序运行结果如下：

服务器端已启动------

/10.23.247.25:60566:我是TCP客户端

注：TCP通信的基本原理？

        客户端怎么发，服务端就应该怎么收。

        客户端如果没有消息，服务端会进入阻塞等待。

        Socket一方关闭或者出现异常、对方Socket也会失效或者出错。

5.TCP通信-多发多收消息

        需求：使用TCP通信方式实现：多发多收消息。

具体要求：

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

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

        示例代码如下：

服务器端

public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);
        // 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);
        }
    }

}

客户端

public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端已启动------");
        // 1.创建Socket通信管道请求与服务端的连接
        Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(), 666);
//        Socket socket = new Socket("127.0.0.1", 666);
        // 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();
        }
    }

}

        服务器端程序运行结果如下：

服务器端已启动------

/10.23.247.25:59781:法外狂徒张三

/10.23.247.25:59781:天唱星刘欢

        客户端程序运行结果如下：

客户端已启动------

请输入要发送的数据:

法外狂徒张三

请输入要发送的数据:

天唱星刘欢

请输入要发送的数据:

        注：本案例只允许接收一个客户端的消息，不允许接收多个客户端的消息，因为服务端现在只有一个线程，只能与一个客户端进行通信，UDP允许多发一收是因为UDP直接发包，不会建立一对一的通信连接管道。

6.TCP通信-同时接受多个客户端消息

如何才可以让服务端可以处理多个客户端的通信需求？

        引入多线程。

实现服务端接收多个客户端的消息的具体步骤

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

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

        示例代码如下：

客户端类同5.TCP通信-多发多收消息中客户端类代码。

处理socket管道的自定义线程类

public class ServerReaderThread extends Thread{
    private Socket socket;

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

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

服务端类

public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);
        // a.定义一个死循环，由主线程不断的接收客户端的Socket管道连接
        while (true) {
            // 2.每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
            Socket socket = serverSocket.accept();
            // 3.创建独立的线程处理socket管道
            new ServerReaderThread(socket).start();
        }
    }

}

        程序运行结果如下：

        客户端一程序运行结果

客户端已启动------

请输入要发送的数据:

生活就像一盒巧克力

请输入要发送的数据:

阳光撒肩头，仿佛自由人

请输入要发送的数据:

进程已结束，退出代码 -1

        客户端二程序运行结果

客户端已启动------

请输入要发送的数据:

Job is not done

请输入要发送的数据:

进程已结束，退出代码 -1

        服务端程序运行结果

服务器端已启动------

/10.23.247.25:49472:生活就像一盒巧克力

/10.23.247.25:61200:Job is not done

/10.23.247.25:49472:阳光撒肩头，仿佛自由人

/10.23.247.25:49472下线了

/10.23.247.25:61200下线了

        注：IDEA默认不允许程序并行运行，新开启一个java应用程序时需要首先停止当前正在运行的该程序。

修改默认为允许并行运行步骤如下：

        ①在IDEA主页面右上角找到该程序（如没有则先运行一次该程序，后在倒三角中选择），点击倒三角中的“编辑配置”选项。

        ②在弹出的对话框中，将该对应文件对话框右侧的“允许并行运行”选项勾选，即可并行该java程序。

7.TCP通信-使用线程池优化

使用线程池优化

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

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

        示例代码如下：

客户端类同5.TCP通信-多发多收消息中客户端类代码。

处理socket管道的自定义线程任务类

public class ServerReaderRunnable implements Runnable {
    private Socket socket;

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

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

}

服务端类

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) throws Exception {
        System.out.println("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);
        // a.定义一个死循环，由主线程不断的接收客户端的Socket管道连接
        while (true) {
            // 2.每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
            Socket socket = serverSocket.accept();
            // 3.创建独立的线程处理socket管道(Runnable任务类形式)
            Runnable target = new ServerReaderRunnable(socket);
            pool.execute(target);
        }
    }

}

8.TCP通信实战案例-即时通信

即时通信是什么含义，要实现怎么样的设计？

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

        之前我们的消息都是发给服务端的，即时通信需要进行端口转发的设计思想。

        客户端与客户端之间互相收发消息，原理：客户端将消息发送至服务端，服务端接收后，进行端口转发，将消息转发至另一服务端。

        端口转发具体方式：服务端把在线的Socket管道存储起来，一旦收到一个消息要推送给其他管道。

        示例代码如下：

客户端类（两个子线程分别处理收、发消息）

public class ClientDemo1 {
    // 使用静态变量定义一个线程池对象
    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("客户端已启动------");
        // 创建Socket通信管道请求与服务端的连接
        Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(), 666);
//        Socket socket = new Socket("127.0.0.1", 666);

        // 创建一个独立的线程专门负责此客户端的读消息功能
        pool.execute(new ClientReaderRunnable(socket));

        // 创建一个独立的线程专门负责此客户端的发消息功能
        pool.execute(new ClientWriterRunnable(socket));

    }

}

客户端收消息自定义线程任务类

public class ClientReaderRunnable implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        try {
            // 1.从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 2.把字节输入流包装为缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 3.按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null) {
                System.out.println(socket.getRemoteSocketAddress() + "给您发来消息:" + msg);
            }
        } catch (Exception e) {
            System.out.println("群聊已解散");
        }
    }

}

客户端发消息自定义线程任务类

public class ClientWriterRunnable implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        try {
            // 1.从socket通信管道中得到一个字节输出流，负责发送数据
            OutputStream os = socket.getOutputStream();
            // 2.把低级的字节流包装为高级的打印流
            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) {
            System.out.println("群聊已解散");
        }
    }

}

服务端类

public class ServerDemo2 {
    /*
        客户端与客户端之间互相收发消息，原理：客户端将消息发送至服务端，服务端接收后，进行端口转发，将消息转发至另一服务端。
     */
    // 定义一个静态的List集合存储当前全部在线的socket管道，方便以后转发消息
    public static List<Socket> allOnlineStockets = new ArrayList<>();
    // 使用静态变量定义一个线程池对象
    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("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);
        // a.定义一个死循环，由主线程不断的接收客户端的Socket管道连接
        while (true) {
            // 2.每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
            Socket socket = serverSocket.accept();
            System.out.println(socket.getRemoteSocketAddress() + "上线了！");
            allOnlineStockets.add(socket); // 上线完成
            // 3.创建独立的线程处理socket管道(Runnable任务类形式)
            Runnable target = new ServerReaderRunnable(socket);
            pool.execute(target);
        }
    }

}

服务端收消息自定义线程任务类

public class ServerReaderRunnable implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        try {
            // 1.从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 2.把字节输入流包装为缓冲字符输入流进行消息接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 3.按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null) {
                System.out.println(socket.getRemoteSocketAddress() + ":" + msg);
                // 把收到的消息转发给全部在线客户端的socket管道（发消息的管道除外）
                sendMsgToAll(socket, msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了");
            ServerDemo2.allOnlineStockets.remove(socket);
        }
    }

    /**
     * 把收到的消息转发给全部在线客户端的socket管道（发消息的管道除外）
     *
     * @param socket
     * @param msg
     * @throws Exception
     */
    private void sendMsgToAll(Socket socket, String msg) throws Exception {
        for (Socket onlineStocket : ServerDemo2.allOnlineStockets) {
            if (socket.equals(onlineStocket)) continue; // 自己不能向自己发消息
            PrintStream ps = new PrintStream(onlineStocket.getOutputStream());
            ps.println(msg);
            ps.flush();
        }
    }

}

程序运行结果如下：

        服务端：

服务器端已启动------

/10.23.247.25:55875上线了！

/10.23.247.25:55882上线了！

/10.23.247.25:55888上线了！

/10.23.247.25:55875:有朋自远方来，不亦乐乎

/10.23.247.25:55882:To be, or not to be, this is a question

/10.23.247.25:55888:君子慎独

/10.23.247.25:55875下线了

        客户端一：

客户端已启动------

请输入要发送的数据:

有朋自远方来，不亦乐乎

请输入要发送的数据:

/10.23.247.25:666给您发来消息:To be, or not to be, this is a question

/10.23.247.25:666给您发来消息:君子慎独

        客户端二：

客户端已启动------

请输入要发送的数据:

/10.23.247.25:666给您发来消息:有朋自远方来，不亦乐乎

To be, or not to be, this is a question

请输入要发送的数据:

/10.23.247.25:666给您发来消息:君子慎独

群聊已解散

        客户端三：

客户端已启动------

请输入要发送的数据:

/10.23.247.25:666给您发来消息:有朋自远方来，不亦乐乎

/10.23.247.25:666给您发来消息:To be, or not to be, this is a question

君子慎独

请输入要发送的数据:

群聊已解散

9.TCP通信实战案例-模拟BS系统

BS结构是什么样的，需要开发客户端吗？

        浏览器访问服务端，不需要开发客户端。

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

HTTP响应数据的协议格式：就是给浏览器显示的网页信息。

TCP通信如何实现BS请求网页信息返回

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

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

        示例代码如下：

服务端类

public class BSserverDemo {
    /*
        客户端与客户端之间互相收发消息，原理：客户端将消息发送至服务端，服务端接收后，进行端口转发，将消息转发至另一服务端。
     */
    // 定义一个静态的List集合存储当前全部在线的socket管道，方便以后转发消息
    public static List<Socket> allOnlineStockets = new ArrayList<>();
    // 使用静态变量定义一个线程池对象
    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("服务器端已启动------");
        // 1.注册端口
        ServerSocket serverSocket = new ServerSocket(666);
        // a.定义一个死循环，由主线程不断的接收客户端的Socket管道连接
        while (true) {
            // 2.每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
            Socket socket = serverSocket.accept();
            // 3.创建独立的线程处理socket管道(Runnable任务类形式)
            Runnable target = new ServerWriterRunnable(socket);
            pool.execute(target);
        }
    }

}

服务端向浏览器输出消息自定义线程任务类

public class ServerWriterRunnable implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        try {
            // 浏览器已经与本线程建立了Socket管道
            // 响应消息给浏览器显示
            PrintStream ps = new PrintStream(socket.getOutputStream());
            // 必须响应HTTP协议格式数据，否则浏览器不识别
            ps.println("HTTP/1.1 200 OK"); // 协议类型和版本响应成功的消息
            ps.println("Content-Type:text/html;charset=UTF-8"); // 响应的数据类型：文本/网页
            ps.println(); // 必须发送一个空行
            // 才可以响应数据回去给浏览器
            ps.println("<span style='color:red;font-size:90px'>关关雎鸠，在河之洲</span>");
            ps.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

写在最后：

        感谢读完！

        纵然缓慢，驰而不息！加油！

全聚德在逃烤鸭、
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java网络编程UDP
leilei7407的博客
08-19 884
UDP是基于广播数据报的传输协议，是一种无连接，不可靠的协议。 UDP编程中主要用到两个类： java.net.DatagramSocket ：客户端 客户端用来发送或接收报文 java.net.DatagramKet：数据报 UDP编程代码示例如下： 发送端代码 package send; import java.io.IOException; import java.net.Datagr...
java udp 多播 广播_简单讲解Java的Socket网络编程的多播与广播实现
weixin_39887577的博客
02-13 190
在Java中，我们可以有很多种方法来发送和接收数据。有的方法比较靠近底层，有些问题就需要程序员自己去解决，而有些方法抽象层次比较高，很方便地就可以拿来使用。这些处理数据的方法根据抽象层次由低到高分别有：1.手动编码：使用位运算逐个自己编码和解析。2.利用流来自动编码：组合使用OutputStream和ByteArrayOutputStream。3.序列化：将数据放入一个数据对象中，直接将这个对象序...
Day22Java学习笔记——认识网络编程
u013583756的博客
12-02 165
网络编程 1、1概述 计算机网络： 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程目的： 传播交流信息，数据交换。通信 想要达到这个效果需要什么： 如何准确定位网络上的一台主机，端口；定位到计算机上某个资源 找到了这个主机，如何传输数据？ ...
网络通信【UDP】【TCP】
weixin_60475929的博客
01-25 694
网络编程 网络编程可以让程序与网络上的其他设备中的程序进行数据交互 网络通信的基本模式 常见的通信模式有两种：Client-Server（CS），Browser/Server(BS) 网络通信的三要素 IP地址：设备在网络中的地址，是唯一的标识 端口：应用程序在设备中的唯一的标识 协议：数据在网络中传输的规则，常见的协议有UDP协议和TCP协议 IP地址 IP（Internet Protocal）；全称“互联网协议地址”，是分配给上网设备的唯一标志 ...
服务器端和客户端互发消息,客户端和服务器互发消息编程
weixin_32058239的博客
08-11 583
客户端和服务器互发消息编程 内容精选换一换华为云帮助中心，为用户提供产品简介、价格说明、购买指南、用户指南、API参考、最佳实践、常见问题、视频帮助等技术文档，帮助您快速上手使用华为云服务。假定某个Flink业务每秒就会收到1个消息记录。基于某些业务要求，开发的Flink应用程序实现功能：实时输出带有前缀的消息内容。Flink样例工程的数据存储在Kafka组件中。向Kafka组件发送数据(需要有K...
JAVA SE应用详解
05-29
本篇将深入探讨Java SE中的关键知识点，帮助读者全面理解和掌握Java编程。 1. **Java语法基础** - **变量与数据类型**：Java支持基本数据类型（如int, double, boolean等）以及引用数据类型（如对象和数组）。理解...
amazon-viewer:Platzi-Java SE基础和高级-Amazon Viewer
05-09
1. **Java基础知识**：包括变量、数据类型、运算符、控制结构（条件语句和循环）、方法定义和调用、类与对象的创建等。这些是编写任何Java程序的基础。 2. **异常处理**：Java的异常处理机制使得程序在遇到错误时能...
java2编程详解(special_edition_using_java)3.rar
07-29
在Java编程的世界里，了解基础知识是至关重要的。Java2（也被称为Java 2 Platform Standard Edition，J2SE）是Java平台的基础，它包括了运行Java应用程序所需的运行时环境和API。本书会涵盖以下几个关键知识点： 1....
java2 sdk 类库详解.rar
05-11
11. **Java标准版和企业版**：Java 2 SDK分为Standard Edition (SE) 和Enterprise Edition (EE)，SE是基础版本，适用于大多数桌面应用；而EE则包含更多的企业级功能，如Java EE服务器和分布式计算的支持。 12. **...
103-Java网络编程：网络三要素：IP及其类InetAddress、端口、协议
yelitoudu的博客
10-12 478
Java网络编程：网络三要素：IP及其类InetAddress、端口、协议
java Socket简单聊天实现 —— 实现服务器端向客户端广播内容
Hello World
03-01 6039
重构聊天室案例，使服务端可以将用户的信息转发给所有客户端，并在每个客户端控制台上显示。通信过程如表－2所示： 服务器端：定义一个集合类型的属性，用于存储所有客户端的输出流。在Server的内部类中run方法的最开始处将客户端的输出流存入该集合，之后，每当客户端发送信息后就遍历集合，将信息写入集合中所有的输出流中(相当于将信息转发给所有的客户端)。 package TCPUDP; im
Java---网络通信三要素与UDP通信
weixin_65440201的博客
07-14 370
目录1.网络通信三要素三要素概述、要素一：IP地址总结：IP地址操作类-InetAddressInetAddress API如下总结：要素二：端口号总结：要素三：协议TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。TCP协议特点UDP协议：总结：2.UDP通信2.1UDP通信基础知识案例：使用UDP通信实现：发送消息、接收消息总结：2.2UDP通信：多发多收案例：使用UDP通信实现：多发多收消息总结：2.3UDP通信-广播、组播总结：什么是网络编程？网络编程可以让程序与网络上的其他设备中的程
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 517
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 328
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 642
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
三两肉的博客
07-03 1038
缓存是指将文件或数据的副本存储在缓存或临时存储位置中，以便未来对该数据的请求可以更快地提供服务。当从存储中检索数据时，会在缓存中创建该数据的副本。如果再次需要该数据，可以从缓存中比从主存储器中更快地检索到该数据，主存储器可能涉及复杂的计算或较慢的访问速度。如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
maven配置使用nexus仓库
ApexPredator的博客
07-03 216
maven配置使用nexus仓库
2023年Java编程基础知识点汇总及习题集答案.docx
11-05
"2023年Java编程基础知识点汇总及习题集答案.docx" 在Java编程领域，基础知识是构建复杂系统的关键。本资源详细总结了2023年Java编程的基础知识点，并包含了相关习题及答案，帮助学习者巩固理解。以下是各个章节的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值