Java程序设计--网络编程（十九）

已于 2023-11-28 22:47:27 修改
阅读量878 收藏 9
点赞数 2
分类专栏： Java 文章标签： java IP UDP TCP 网络通信
于 2022-04-15 10:39:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASHIYI66/article/details/123762135
版权

网络编程

1、网络通信三要素

  • IP地址:设备在网络中的地址，是唯一的标识。
  • 端口:应用程序在设备中唯一的标识。
  • 协议:数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。

在这里插入图片描述

1.1 IP地址

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

常见的IP分类为:IPv4和IPv6。

在这里插入图片描述

在这里插入图片描述

IP地址形式:

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

IP常用命令:

  • ipconfig:查看本机IP地址
  • ping lP地址:检查网络是否连通

特殊IP地址:

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

IP地址操作类- - InetAddress

InetAddress的使用

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

lnetAddress 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 InetAddressDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.获取本机地址对象。
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1.getHostName());
        System.out.println(ip1.getHostAddress());

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

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

        // 4.判断是否能通： ping  5s之前测试是否可通
        System.out.println(ip3.isReachable(5000));
    }
}

1.2 端口号

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

端口类型

  • 周知端口:0~1023，被预先定义的知名应用占用(如:HTTP占用80，FTP占用21)
  • 注册端口:1024~49151，分配给用户进程或某些应用程序。(如: Tomcat占用8080，MySQL占用3306)
  • 动态端口:49152到65535，之所以称为动态端口，是因为它一般不固定分配某种进程，而是动态分配

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

1.3 通信协议

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

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

  • OSI参考模型:世界互联协议标准，全球通信规范，由于此模型过于理想化，未能在因特网上进行广泛推广
  • TCP/IP参考模型(或TCP/IP协议):事实上的国际标准
OSI参考模型TCP/IP参考模型各层对应面向操作
应用层应用层HTTP、FTP、DNS、SMTP…应用程序需要关注的：浏览器，邮箱、程序员一般在这一层开发
表示层应用层HTTP、FTP、DNS、SMTP…应用程序需要关注的：浏览器，邮箱、程序员一般在这一层开发
会话层应用层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.1 UDP通信 - - 快速入门

UDP协议的特点

  • UDP是一种无连接、不可靠传输的协议。
  • 将数据源IP、目的地IP和端口以及数据封装成数据包，大小限制在64KB内，直接发送出去即可。

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常用方法

方法说明
public int getLength()获得实际接收到的字节个数

DatagramSocket:发送端和接收端对象

构造器说明
public DatagramSocket()创建发送端的Socket对象，系统会随机分配一个端口号。
public DatagramSocket(int port)创建接收端的Socket对象并指定端口号

DatagramSocket类成员方法

方法说明
public void send(DatagramPacket dp)发送数据包
public void receive(DatagramPacket p)接收数据包
使用UDP通信实现：发送消息、接受消息
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

/**
  发送端  一发 一收
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket(6666);
        // 2、创建一个数据包对象封装数据（韭菜盘子）
        byte[] buffer = "我是一颗快乐的韭菜，你愿意吃吗？".getBytes();
        DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                InetAddress.getLocalHost() , 8888);

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

        socket.close();
    }
}


import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/**
  接收端
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);
        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        // 3、等待接收数据。
        socket.receive(packet);
        // 4、取出数据即可
        // 读取多少倒出多少
        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();
    }
}

使用UDP通信实现：多发多收消息

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner;

/**
  发送端  多发 多收
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket(7777);
        

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getLocalHost() , 8888);

            // 3、发送数据出去
            socket.send(packet);
        }

    }
}


import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
  接收端
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);

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

        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

2.2 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)
    - 接收端必须绑定该组播IP(224.0.1.1)，端口还要注册发送端的目的端口9999，这样即可接收该组播消息。
    - DatagramSocket的子类MulticastSocket可以在接收端绑定组播IP。
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
  发送端  多发 多收
 */
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)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            // 注意：只要目的地IP是 255.255.255.255 这个消息将以广播的形式对外发送
//            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
//                    InetAddress.getByName("255.255.255.255") , 8888);

            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getByName("224.0.1.1") , 9898);

                    // 3、发送数据出去
            socket.send(packet);
        }

    }
}


import java.net.*;

/**
  接收端
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        MulticastSocket socket = new MulticastSocket(9898);

        // 注意：绑定组播地址（加群）
        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1") , 9898),
                NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));

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


        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

3、TCP通信

3.1 TCP通信 - - 快速入门

在这里插入图片描述

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

编写客户端代码

Socket

构造器说明
public Socket(String host , int port)创建发送端的Socket对象与服务端连接，参数为服务端程序的ip和端口。
Socket类成员方法
方法说明
:-::-:
outputStream getoutputstream()获得字节输出流对象
InputStream getInputstream()获得字节输入流对象

客户端发送消息

需求:客户端实现步骤

  1. 创建客户端的Socket对象，请求与服务端的连接。
  2. 使用socket对象调用getOutputStream()方法得到字节输出流。
  3. 使用字节输出流完成数据的发送。
  4. 释放资源:关闭socket管道。

编写服务端代码

ServerSocket(服务端)

构造器说明
public ServerSocket(int port)注册服务端端口。

ServerSocket类成员方法

方法说明
public Socket accept()等待接收客户端的socket通信连接。连接成功返回socket对象与客户端建立端到端通信。

服务端实现接收消息

需求:服务端实现步骤

  1. 创建ServerSocket对象，注册服务端端口。
  2. 调用ServerSocket对象的accept()方法，等待客户端的连接，并得到Socket管道对象。
  3. 通过Socket对象调用getlnputStream()方法得到字节输入流、完成数据的接收。
  4. 释放资源:关闭socket管道
import java.io.IOException;
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.IOException;
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();
        }
    }
}

3.2 TCP通信 - - 多发多收

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

具体要求:

  1. 可以使用死循环控制服务端收完消息继续等待接收下一个消息。
  2. 客户端也可以使用死循环等待用户不断输入消息。
  3. 客户端一旦输入了exit，则关闭客户端程序，并释放资源。
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();
        }
    }
}

本例实现了多发多收（客户端循环反复地发送消息，服务端循环反复地接收消息），但是不能同时接受多个客户端的消息，因为服务端现在只有一个线程，只能与一个客户端进行通信。

3.3 TCP通信 - - 多接受

引入多线程可以让服务端处理多个客户端的通信需求

在这里插入图片描述

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;

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

3.4 TCP通信 - - 使用线程池优化

多接受客户端与服务端的线程模型是：N-N的关系，客户端并发越多，系统瘫痪的越快。

在这里插入图片描述

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


import demo.ServerReaderThread;

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

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

    // 使用静态变量记住一个线程池对象
    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() + "下线了！！！");
        }
    }
}

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

3.5 TCP通信 - - 即使通信

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

在这里插入图片描述

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

/**
    拓展：即时通信

    客户端：发消息的同时，随时有人发消息过来。
    服务端：接收消息后，推送给其他所有的在线socket
 */
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", 6868);

            // 马上为客户端分配一个独立的线程负责读取它收到的消息
            new ClientReaderThread(socket).start();

            // 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.io.PrintStream;
import java.net.Socket;

public class ClientReaderThread extends Thread{
    private Socket socket;
    public ClientReaderThread(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("服务端把你踢出去了~~");
        }
    }

}


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

/**
   目标: 即时通信
 */
public class ServerDemo2 {

    public static List<Socket> onLineSockets = new ArrayList<>();

    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(6868);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
                // 把当前客户端管道Socket加入到在线集合中去
                onLineSockets.add(socket);

                // 3、开始创建独立线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


import java.io.*;
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);
                // 把这个消息发给当前所有在线socket
                sendMsgToAll(msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
            // 从在线集合中抹掉本客户端socket
            ServerDemo2.onLineSockets.remove(socket);
        }
    }

    private void sendMsgToAll(String msg) {
        try {
            // 遍历全部的在线 socket给他们发消息
            for (Socket onLineSocket : ServerDemo2.onLineSockets) {
                // 除了自己的socket，其他socket我都发！！
                if(onLineSocket != socket){
                    PrintStream ps = new PrintStream(socket.getOutputStream());
                    ps.println(msg);
                    ps.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.6 TCP通信 - - 模拟BS系统

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

在这里插入图片描述

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

public class BSserverDemo {
    // 使用静态变量记住一个线程池对象
    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 {
            // 1.注册端口
            ServerSocket ss = new ServerSocket(8080);
            // 2.创建一个循环接收多个客户端的请求。
            while(true){
                Socket socket = ss.accept();
                // 3.交给一个独立的线程来处理！
                pool.execute(new ServerReaderRunnable(socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



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

public class ServerReaderRunnable implements Runnable{
    private Socket socket;
    public ServerReaderRunnable(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'>《最牛的149期》 </span>");
            ps.close();
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

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

在这里插入图片描述

会思想的苇草i
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java网络编程：UDP套接字程序设计，UDP实现Socket通信（附完整代码实现）
Viper的程序员修炼手册
11-08 2117
Java UDP套接字程序设计 UDP特点: （1）UDP有别于TCP，有自己独立的套接字(IP+PORT)，它们的端口号不冲突。和TCP编程相比，UDP在使用前不需要进行连接，没有流的概念。如果说TCP协议通信与电话通信类似，那么UDP通信就与邮件通信类似：不需要实时连接，只需要目的地址； （2）UDP 通信前不需要建立连接，只要知道地址（ip地址和端口号）就可以给对方发送信息； （3）基于用户数据报文（包）读写； （4）UDP通信一般用于线路质量好的环境，如局域网内，如果是互联网，往往应用于对数据完整性
Java——IO流
LYQ
06-01 4547
IO流它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。
Java开发面试之网络协议
单线程的Daniel的博客
04-06 598
参考：牛客网Java开发岗高频面试专栏 1. OSI七层协议模型 参考文章：https://www.cnblogs.com/wxd0108/p/7597216.html 1.1 物理层 主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）...
【Java网络编程】TCP通信（Socket 与 ServerSocket）和UDP通信的三种数据传输方式
最新发布
m0_65277261的博客
04-22 1098
TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象 通信之前要保证连接已经建立（注意TCP是一定要建立连接的） TCP是通过Socket产生I0流来进行网络通信的，所以发送端和接收端的两个流的方向是不一样的，比如客户端和服务器进行通信（通信前要确保建立了连接），然后客户端向服务器发送了“你好帅”，这一次发送数据的过程，它们流的方向是不一样的，针对客户端来说，它是往外发所以用的是输出流，而针对服务器来说，它是接收数据所以用的是输入流。
【JavaEE】基于TCP的客户端服务器程序
冲击大厂之路!!!
01-16 1564
基于TCP版本的客户端服务器程序！
Java利用UDP协议建立广播组通信【附通信源码】
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
07-12 4259
UDP （用户数据报协议）是OSI(Open System Interconnection，开放式系统互联) 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。 目录 什么是UDP协议？ UDP协议数据传输原理 DatagramPacket类 DatagramSocket类 UDP协议网络通信客户端服务器程序 服务器端程序 客户端程序 Hello！大家好！我是灰小猿。 之前和大家分享了使用TCP协议进行网络通信的过程，想了解的小伙伴可以看我的这篇文章《Java利.
深圳大学-java程序设计--网络编程应用.docx
10-01
本实验报告的主要目的是掌握网络通信协议及相关程序设计。实验要求完成两个任务：（1）利用数据报通信方式编写程序，生成两个客户端，一个服务器端，两个客户端可以相互进行简短的文字交流；（2）编写 Java 应用程序...
JAVA程序设计-课程标准.doc
11-29
Java 程序设计是计算机类专业的核心课程，旨在培养学生程序设计技术和 OOP 设计思想，涉及计算机体系构造、面向对象编程、多线程处理、网络通信以及程序设计等内容。通过本课程的学习，学生能够了解 Java 语言特征、...
Java-语言程序设计线程编程入门PPT.ppt
10-31
Java-语言程序设计线程编程入门PPT.ppt
Java程序设计之网络编程PPT.ppt
10-31
Java程序设计之网络编程PPT.ppt
Java程序设计之网络编程
09-16
Java程序设计之网络编程
Java实现基于TCP协议的Socket通信
08-11
（1）实现了服务器和客户端之间的连接通信 （2）实现了客户端与客户端之间的连接通信
Java_TCPIP_Socket经典网络编程
10-22
Java_TCPIP_Socket经典网络编程 最好的java网络编程资料,现低分奉献. 目录： ...8 1.4 客户端和服务器.8 1.5 什么是套接字..........9 1.6 练习..........10 第2章基本套接字..........10 2.1 套接字地址..........10 2.2 TCP套接字..........17 2.2.1 TCP客户端..........17 2.2.2 TCP服务器端..........22 2.2.3 输入输出流..........26 2.3 UDP套接字..........28 2.3.1 DatagramPacket类..........28 2.3.2 UDP客户端..........30 2.3.3 UDP服务器端..........36 2.3.4 使用UDP套接字发送和接收信息..........38 2.4 练习..........40 第3章发送和接收数据
Java对接TCP接口--数据报文通信
aiguoguo000的博客
09-06 791
第一次整这东西，感谢大佬: 参考:https://www.cnblogs.com/liudalei/p/11942464.html?ivk_sa=1024320u
javaTCP协议通信
m0_48844699的博客
08-31 1203
Tcp通信有两个特点分别是面向连接,具有可靠性.面向连接:指的是客户端与服务端之间的连接,在通信之前会有三次握手的机制来确保连接的可靠性.tcp有状态:tcp会精确的纪录哪些数据是发送了的,哪些是没有被发送的,他保证数据包是按序到达的,不允许存在半点差错tcp是可以控制的:如果存在丢包或者网络不好的时候,会根据具体情况对数据包进行发送速度的控制或者对数据包进行重新发送....
java TCP编程
热门推荐
司天宏的博客
01-04 1万+
* 需求：完成网络登录功能： 用户输入用户名密码，服务器给出登录成功或失败的提示 TCP编程基于 请求—响应 在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序 第一次通讯中等待连接的程序被称作服务器端(Server)程序 利用IO流实现数据的传输 单向 :只有请求 双向:请求—响应 循环双向:持续（请求—响应） 客户端Socket 此类实现客户端套接字（...
java发送接收组播（多播）数据包（UDP包）
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
10-08 1万+
全栈工程师开发手册 （作者：栾鹏） java教程全解 java发送组播（多播）数据包。首先要加入组播组，然后才能向组播组发送组播数据包和接收组播数据包。以下代码，在局域网中测试有效。测试代码public static void main(String[] args) { final MulticastSocket socket=createMulticastGroupAndJo
Java干货之Socket自定义传输协议，可用于一般即时通讯
Odboy
03-15 6248
原型客户端 Clientpackage me.mxzf;import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.File; import java.io
java 通信 协议_Java——通信协议
weixin_35684578的博客
02-22 542
一、基于socket通信——TCP客户端输入一个hello，服务端进行输出这个传输过程就是先建立一个会话，然后有一个流，基于TCP的套接字完成//基于socket通信的服务端public class ServerSocket_Server {public static void main(String[] args) throws IOException {//ServerSocket serve...
深圳大学-java程序设计--网络编程应用 - 百度文库
12-04
深圳大学的Java程序设计课程中涉及到了网络编程应用。网络编程是指通过网络进行数据交互的程序设计方式。 在网络编程中，我们需要使用Java提供的一些类库和API来实现网络通信。Java中提供了一套完善的网络编程工具，包括Socket编程、ServerSocket编程、URL编程等。 Socket编程是实现网络通信的基本方式之一，它是一种面向连接的通信方式。通过创建一个Socket对象，程序可以与远程服务器进行连接，并进行数据的发送和接收。使用Socket编程，我们可以实现客户端和服务器之间的通信，实现从客户端向服务器发送请求，服务器处理请求并返回结果的功能。 ServerSocket编程是一种服务器端的网络编程方式，它可以接收客户端的连接请求并与之建立连接。通过创建一个ServerSocket对象，并调用其accept()方法，服务器可以等待客户端的连接请求，并将连接请求转交给一个新的Socket对象进行处理。使用ServerSocket编程，我们可以实现服务器的功能，接收来自多个客户端的请求，并处理这些请求。 URL编程是一种用于访问远程资源的网络编程方式。通过创建一个URL对象，并调用其openConnection()方法，我们可以建立与远程服务器的连接，并获取服务器返回的数据。使用URL编程，我们可以实现通过HTTP协议获取网页内容、下载文件等功能。 在深圳大学的Java程序设计课程中，我们将学习如何使用这些网络编程的工具和技术，并实践一些网络应用的开发。通过这门课程的学习，我们可以掌握网络编程的基本原理和常用技术，提升自己的Java程序设计能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

会思想的苇草i

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

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

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

打赏作者

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

抵扣说明：

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

余额充值