JAVA基础深化提高(十) | 网络编程

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量78 收藏
点赞数
分类专栏： Java 文章标签： java 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65180200/article/details/132368293
版权

一、网络编程基本概念

1. 计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

  1. 计算机网络的作用：资源共享和信息传递。
  2. 计算机网络的组成：
    • 计算机硬件：计算机（大中小型服务器，台式机、笔记本等）、外部设备（路由器、交换机等）、通信线路（双绞线、光纤等）。
    • 计算机软件：网络操作系统（Windows 2000 Server/Advance Server、Unix、Linux等）、网络管理软件（WorkWin、SugarNMS等）、网络通信协议（如TCP/IP协议栈等）。

2. 网络通信协议

● 通信双方地址
○ IP
○ 端口号
● 网络通讯协议：即一定的规则（有两套参考模型）
○ OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
○ TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
在这里插入图片描述

网络协议的分层

虽然国际标准化组织制定了这样一个网络通信协议的模型，但是实际上互联网通讯使用最多的网络通信协议是TCP/IP网络通信协议。TCP/IP 模型，也是按照层次划分，共四层：应用层，传输层，网络
层，网络接口层（物理+数据链路层）。
OSI模型与TCP/IP模型的对应关系：
在这里插入图片描述

在这里插入图片描述
报文的封装和分用
在这里插入图片描述

3. 数据封装与解封

在这里插入图片描述
数据封装（Data Encapsulation）是指将协议数据单元（PDU）封装在一组协议头和协议尾中的过程。在OSI七层参考模型中，每层主要负责与其它机器上的对等层进行通信。该过程是在协议数据单元（PDU）中实现的，其中每层的PDU一般由本层的协议头、协议尾和数据封装构成。

  • 数据发送处理过程

    1. 应用层将数据交给传输层，传输层添加上TCP的控制信息（称为TCP头部），这个数据单元称
      为段（Segment），加入控制信息的过程称为封装。然后，将段交给网络层。

    2. 网络层接收到段，再添加上IP头部，这个数据单元称为包（Packet）。然后，将包交给数据链
      路层。

    3. 数据链路层接收到包，再添加上MAC头部和尾部，这个数据单元称为帧（Frame）。然后，
      将帧交给物理层。

    4. 物理层将接收到的数据转化为比特流，然后在网线中传送。

  • 数据接收处理过程

    1. 物理层接收到比特流，经过处理后将数据交给数据链路层。
    2. 数据链路层将接收到的数据转化为数据帧，再除去MAC头部和尾部，这个除去控制信息的过程称为解封，然后将包交给网络层。
    3. 网络层接收到包，再除去IP头部，然后将段交给传输层。
    4. 传输层接收到段，再除去TCP头部，然后将数据交给应用层。

接收方的每一层只把对该层有意义的数据拿走，或者说每一层只能处理发送方同等层的数据，然后把其余的部分传递给上一层，这就是对等层通信的概念。

数据封装

在这里插入图片描述

数据解封

在这里插入图片描述

4. IP地址

在这里插入图片描述

4.1 IP地址

IP是Internet Protocol Address，即"互联网协议地址"。
用来标识网络中的一个通信实体的地址。通信实体可以是计算机、路由器等。 比如互联网的每个服务器都要有自己的IP地址，而每个局域网的计算机要通信也要配置IP地址。路由器是连接两个或多个网络的网络设备。

IP地址分类：
在这里插入图片描述

目前主流使用的IP地址是IPV4，但是随着网络规模的不断扩大，IPV4面临着枯竭的危险，所以推出了IPV6。

IPV4，采用32位地址长度，只有大约43亿个地址，它只有4段数字，每一段最大不超过255。随着互联网的发展，IP地址不够用了，在2019年11月25日IPv4位地址分配完毕。

IPv6采用128位地址长度，几乎可以不受限制地提供地址。按保守方法估算IPv6实际可分配的地址，整个地球的每平方米面积上仍可分配1000多个地址。

IP地址实际上是一个32位整数（称为IPv4），以字符串表示的IP地址如 192.168.0.1 实际上是把32位整数按8位分组后的数字表示，目的是便于阅读。
IPv6地址实际上是一个128位整数，它是目前使用的IPv4的升级版，以字符串表示类似于 2001:0db8:85a3:0042:1000:8a2e:0370:7334

4.2 公有地址

公有地址（Public address）由Inter NIC（Internet Network Information Center互联网信息中心）负责。这些IP地址分配给注册并向Inter NIC提出申请的组织机构。通过它直接访问互联网。

私有地址
私有地址（Private address）属于非注册地址，专门为组织机构内部使用。
以下列出留用的内部私有地址
A类 10.0.0.0–10.255.255.255
B类 172.16.0.0–172.31.255.255
C类 192.168.0.0–192.168.255.255

注意事项
127.0.0.1 本机地址
192.168.0.0–192.168.255.255为私有地址，属于非注册地址，专门为组织机构内部使用

5. 端口port

端口号用来识别计算机中进行通信的应用程序。因此，它也被称为程序地址。
一台计算机上同时可以运行多个程序。传输层协议正是利用这些端口号识别本机中正在进行通信的应用程序，并准确地进行数据传输。
在这里插入图片描述

总结
IP地址好比每个人的地址（门牌号），端口好比是房间号。必须同时指定IP地址和端口号才能够正确的发送数据。
IP地址好比为电话号码，而端口号就好比为分机号。

5.1 端口分配

端口是虚拟的概念，并不是说在主机上真的有若干个端口。通过端口，可以在一个主机上运行多个网络应用程序。 端口的表示是一个16位的二进制整数，对应十进制的0-65535。

操作系统中一共提供了0~65535可用端口范围。
按端口号分类：
公认端口（Well Known Ports）：从0到1023，它们紧密绑定（binding）于一些服务。通常这些端口的通讯明确表明了某种服务的协议。例如：80端口实际上总是HTTP通讯。

注册端口（Registered Ports）：从1024到65535。它们松散地绑
定于一些服务。也就是说有许多服务绑定于这些端口，这些端口同
样用于许多其它目的。例如：许多系统处理动态端口从1024左右开
始。

6. URL

在这里插入图片描述
URL作用：
URL（Uniform Resource Locator），是互联网的统一资源定位符。用于识别互联网中的信息资源。通过URL我们可以访问文件、数据库、图像、新闻等。

在互联网上，每一信息资源都有统一且唯一的地址，该地址就叫URL，URL由4部分组成：协议 、存放资源的主机域名、资源文件名和端口号。如果未指定该端口号，则使用协议默认的端口。例如http 协议的默认端口为 80。 在浏览器中访问网页时，地址栏显示的地址就是URL。

在java.net包中提供了URL类，该类封装了大量复杂的涉及从远程站
点获取信息的细节。

7. Socket

在这里插入图片描述
我们开发的网络应用程序位于应用层，TCP和UDP属于传输层协议，在应用层如何使用传输层的服务呢？在应用层和传输层之间，则是使用套接字Socket来进行分离。

套接字就像是传输层为应用层开的一个小口，应用程序通过这个小口向远程发送数据，或者接收远程发来的数据；而这个小口以内，也就是数据进入这个口之后，或者数据从这个口出来之前，是不知道也不需要知道的，也不会关心它如何传输，这属于网络其它层次工作。

Socket实际是传输层供给应用层的编程接口。Socket就是应用层与传输层之间的桥梁。使用Socket编程可以开发客户机和服务器应用程序，可以在本地网络上进行通信，也可通过Internet在全球范围内通信。

8. TCP协议和UDP协议

8.1 TCP协议

TCP（Transmission Control Protocol，传输控制协议）。TCP方式就类似于拨打电话，使用该种方式进行网络通讯时，需要建立专门的虚拟连接，然后进行可靠的数据传输，如果数据发送失败，则客户端会自动重发该数据。

TCP在建立连接时又分三步走：
n 第一步，是请求端（客户端）发送一个包含SYN即同步（Synchronize）标志的TCP报文，SYN同步报文会指明客户端使用的端口以及TCP连接的初始序号。

n 第二步，服务器在收到客户端的SYN报文后，将返回一个SYN+ACK的报文，表示客户端的请求被接受，同时TCP序号被加一，ACK即确认（Acknowledgement）。

n 第三步，客户端也返回一个确认报文ACK给服务器端，同样TCP序列号被加一，到此一个TCP连接完成。然后才开始通信的第二步：数据处理。

n 这就是所说的TCP的三次握手（Three-way Handshake）。

8.2 UDP协议

UDP（User Data Protocol，用户数据报协议）

UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。 在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、 计算机的能力和传输带宽的限制； 在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。

UDP方式就类似于发送短信，使用这种方式进行网络通讯时，不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得。

UDP 因为没有拥塞控制，一直会以恒定的速度发送数据。即使网络条件不好，也不会对发送速率进行调整。这样实现的弊端就是在网络条件不好的情况下可能会导致丢包，但是优点也很明显，在某些实时性要求高的场景（比如电话会议）就需要使用 UDP 而不是 TCP

8.3 TCP和UDP区别

这两种传输方式都在实际的网络编程中使用，重要的数据一般使用TCP方式进行数据传输，而大量的非核心数据则可以通过UDP方式进行传递，在一些程序中甚至结合使用这两种方式进行数据传递。由于TCP需要建立专用的虚拟连接以及确认传输是否正确，所以使用TCP方式的速度稍微慢一些，而且传输时产生的数据量要比UDP稍微大一些。
在这里插入图片描述

总结

  • TCP是面向连接的，传输数据安全，稳定，效率相对较低。
  • UDP是面向无连接的，传输数据不安全，效率较高。

二、Java网络编程中的常用类

Java为了跨平台，在网络应用通信时是不允许直接调用操作系统接口的，而是由java.net包来提供网络功能。下面我们来介绍几个java.net包中的常用的类。

1. InetAddress的使用

作用：封装计算机的IP地址和DNS（没有端口信息）

注：DNS是Domain Name System，域名系统。

这个类没有构造方法。如果要得到对象，只能通过静态方法：
getLocalHost()、getByName()、 getAllByName()、getAddress()、getHostName()

1.2 获取本机信息

获取本机信息需要使用getLocalHost方法创建InetAddress对象。getLocalHost()方法返回一个InetAddress对象，这个对象包含了本机的IP地址，计算机名等信息。

public class InetTest {
    public static void main(String[] args)throws Exception {
        //实例化InetAddress对象
        InetAddress inetAddress = InetAddress.getLocalHost();
        //返回当前计算机的IP地址
        System.out.println(inetAddress.getHostAddress());
        //返回计算机名
        System.out.println(inetAddress.getHostName());
    }
}

1.3 根据域名获取计算机的信息

根据域名获取计算机信息时需要使用getByName(“域名”)方法创建InetAddress对象。

public class InetTest2 {
    public static void main(String[] args)throws Exception {
        //创建根据域名获取计算机信息的InetAddress对象
        InetAddress inetAddress = InetAddress.getByName("www.baidu.com");

        //返回IP地址
        System.out.println(inetAddress.getHostAddress());
        //返回计算机名
        System.out.println(inetAddress.getHostName());
    }
}

1.4 根据IP获取计算机的信息

根据IP地址获取计算机信息时需要使用getByName(“IP”)方法创建InetAddress对象。

public class InetTest3 {
    public static void main(String[] args) throws Exception{
        //创建根据IP地址获取计算机信息的InetAddress对象
        InetAddress inetAddress = InetAddress.getByName("14.215.177.38");

        //返回IP地址
        System.out.println(inetAddress.getHostAddress());
        //返回计算机名
        System.out.println(inetAddress.getHostName());

    }
}

2. InetSocketAddress的使用

**作用：**包含IP和端口信息，常用于Socket通信。此类实现 IP 套接字地址（IP 地址 + 端口号），不依赖任何协议。

InetSocketAddress相比较InetAddress多了一个端口号，端口的作用：一台拥有IP地址的主机可以提供许多服务，比如Web服务、FTP服务、SMTP服务等，这些服务完全可以通过1个IP地址来实现。

那么，主机是怎样区分不同的网络服务呢？显然不能只靠IP地址，因为IP 地址与网络服务的关系是一对多的关系。实际上是通过“IP地址+端口号”来区分不同的服务的。

public class InetSocketTest {
    public static void main(String[] args) {
        //创建InetSocketAddress对象
        InetSocketAddress inetSocketAddress = new InetSocketAddress("www.baidu.com",80);

        //返回ip地址
        System.out.println(inetSocketAddress.getAddress().getHostAddress());

        //返回计算机名
        System.out.println(inetSocketAddress.getHostName());
    }
}

3. URL的使用

IP地址标识了Internet上唯一的计算机，而URL则标识了这些计算机上的资源。 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

为了方便程序员编程，JDK中提供了URL类，该类的全名是java.net.URL，有了这样一个类，就可以使用它的各种方法来对URL对象进行分割、合并等处理。

public class UrlTest {
    public static void main(String[] args)throws Exception {
        //创建URL对象
        URL url  = new URL("https://www.itbaizhan.com/search.html?kw=java");

        System.out.println("获取与此URL相关协议的默认端口："+url.getDefaultPort());
        System.out.println("访问资源："+url.getFile());
        System.out.println("主机名："+url.getHost());
        System.out.println("访问资源的路径："+url.getPath());
        System.out.println("协议："+url.getProtocol());
        System.out.println("参数部分："+url.getQuery());
    }
}

3.1 通过URL实现最简单的网络爬虫

public class UrlTest2 {
    public static void main(String[] args)throws Exception {
        URL url = new URL("https://www.itbaizhan.com/");
        try(BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))){
            StringBuilder sb = new StringBuilder();
            String temp = "";
            while((temp = br.readLine()) != null){
                sb.append(temp);
            }
            System.out.println(sb);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

三、TCP通信的实现和项目案例

3.1 TCP通信实现原理

前边我们提到TCP协议是面向的连接的，在通信时客户端与服务器端必须建立连接。在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

“请求-响应”模式：

  • Socket类：发送TCP消息。
  • ServerSocket类：创建服务器。

套接字Socket是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在通过网络连接的不同机器上。换句话说，套接字起到通信端点的作用。单个套接字是一个端点，而一对套接字则构成一个双向通信信道，使非关联进程可以在本地或通过网络进行数据交换。一旦建立套接字连接，数据即可在相同或不同的系统中双向或单向发送，直到其中一个端点关闭连接。套接字与主机地址和端口地址相关联。主机地址就是客户端或服务器程序所在的主机的IP地址。端口地址是指客户端或服务器程序使用的主机的通信端口。

在客户端和服务器中，分别创建独立的Socket，并通过Socket的属性，将两个Socket进行连接，这样，客户端和服务器通过套接字所建立的连接使用输入输出流进行通信。TCP/IP套接字是最可靠的双向流协议，使用TCP/IP可以发送任意数
量的数据。

实际上，套接字只是计算机上已编号的端口。如果发送方和接收方计算机确定好端口，他们就可以通信了。

客户端与服务器端的通信关系图：
在这里插入图片描述
TCP/IP通信连接的简单过程：

位于A计算机上的TCP/IP软件向B计算机发送包含端口号的消息，B计算机的TCP/IP软件接收该消息，并进行检查，查看是否有它知道的程序正在该端口上接收消息。如果有，他就将该消息交给这个程序。

要使程序有效地运行，就必须有一个客户端和一个服务器。

通过Socket的编程顺序：

  1. 创建服务器ServerSocket，在创建时，定义ServerSocket的监听端口（在这个端口接收客户端发来
    的消息）
  2. ServerSocket调用accept()方法，使之处于阻塞状态。
  3. 创建客户端Socket，并设置服务器的IP及端口。
  4. 客户端发出连接请求，建立连接。
  5. 分别取得服务器和客户端Socket的InputStream和OutputStream。
  6. 利用Socket和ServerSocket进行数据传输。
  7. 关闭流及Socket。

3.2 TCP通信入门案例

3.2.1 创建服务端

public class BasicSocketServer {
    public static void main(String[] args) {
        System.out.println("服务器已启动，等待监听。。。。。");
        //创建ServerSocket对象
        try(ServerSocket serverSocket = new ServerSocket(8888);
            //监听8888端口，此时当前线程会处于阻塞状态。
            Socket socket = serverSocket.accept();
            //连接成功后会得到与客户端对应的Socket对象，并解除线程阻塞
            //通过客户端对应的Socket对象中的输入流对象，获取客户端发送过来的消息。
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){

            System.out.println(br.readLine());

        }catch(Exception e){
            e.printStackTrace();
            System.out.println("服务器启动失败。。。。。");
        }
    }
}

3.2.2 创建客户端

public class BasicSocketClient {
    public static void main(String[] args) {
        //创建Socket
        try(Socket socket = new Socket("127.0.0.1",8888);
        //创建向服务端发送消息的输出流对象。
            PrintWriter pw = new PrintWriter(socket.getOutputStream())){
            pw.println("服务端，您好！");
            pw.flush();

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

3.3 TCP单向通信

单向通信是指通信双方中，一方固定为发送端，一方则固定为接收端。

3.3.1 创建服务端

public class OneWaySocketServer {
    public static void main(String[] args) {
        System.out.println("服务器启动开始监听。。。。");
        try(ServerSocket serverSocket = new ServerSocket(8888);
           Socket socket = serverSocket.accept();
           //通过与客户端对应的Socket对象获取输入流对象
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //通过与客户单对应的Socket对象获取输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){
            System.out.println("连接成功！");

            while(true){
                //读取客户端发送的消息
                String str = br.readLine();
                System.out.println("客户端说："+str);
                if("exit".equals(str)){
                    break;
                }
                pw.println(str);
                pw.flush();
            }

        }catch(Exception e){
            e.printStackTrace();
            System.out.println("服务器启动失败。。。。。");
        }

    }
}

3.3.2 创建客户端

public class OneWaySocketClient {
    public static void main(String[] args) {
        try(Socket socket = new Socket("127.0.0.1",8888);
            //创建键盘输入对象
            Scanner scanner = new Scanner(System.in);
            //通过与服务端对应的Socket对象获取输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
            //通过与服务端对应的Socket对象获取输入流对象
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){

            while (true){
                //通过键盘输入获取需要向服务端发送的消息
                String str = scanner.nextLine();

                //发送到服务端
                pw.println(str);
                pw.flush();

                if("exit".equals(str)){
                    break;
                }

                //读取服务端返回的消息
                String serverInput = br.readLine();
                System.out.println("服务端返回的："+serverInput);
            }

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

3.4 TCP双向通信

双向通信是指通信双方中，任何一方都可为发送端，任何一方都可为接收端。

3.4.1 创建服务端

public class TwoWaySocketServer {
    public static void main(String[] args) {
        System.out.println("服务器启动！监听8888。。。。。");
        try(ServerSocket serverSocket = new ServerSocket(8888);
            Socket socket = serverSocket.accept();
            //创建键盘输入对象
            Scanner scanner = new Scanner(System.in);
            //通过与客户端对应的Socket对象，获取输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //通过与客户端对应的Socket对象，获取输出流
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while(true){
                //读取客户端发送的消息
                String str = br.readLine();
                System.out.println("客户端说："+str);

                String keyInput = scanner.nextLine();
                //发送到客户端
                pw.println(keyInput);
                pw.flush();
            }

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

3.4.2 创建客户端

public class TwoWaySocketClient {
    public static void main(String[] args) {
        try(Socket socket =new Socket("127.0.0.1",8888);
            //创建键盘输入对象
            Scanner scanner = new Scanner(System.in);
            //通过与服务端对应的Socket对象，获取输入流对象。
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //通过与服务端对应的Socket对象，后去输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while(true){
                //通过键盘输入获取信息
                String keyInput = scanner.nextLine();
                //向服务端发送消息
                pw.println(keyInput);
                pw.flush();

                //接收服务端发送的消息
                String str = br.readLine();
                System.out.println("服务端是："+str);
            }

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

3.5 创建点对点的聊天应用

3.5.1 创建服务端

/**
 * 发送消息的线程
 */
class Send extends Thread{
    //与客户端对应的Socket对象
    private Socket socket;
    public Send(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }

    /**
     * 发送消息
     */
    private void sendMsg(){
        try(Scanner scanner = new Scanner(System.in);
            //创建向对方发送消息的输出流
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }

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


/**
 * 接收消息的线程
 */
class Receive extends Thread{
    //与客户端对应的Socket对象
    private Socket socket;
    public Receive(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 用于接收对方消息的方法
     */
    private void receiveMsg(){
        try(BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){

            while(true){
                String msg = br.readLine();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

public class ChatSocketServer {
    public static void main(String[] args) {
        try(ServerSocket serverSocket = new ServerSocket(8888);){
            System.out.println("服务端启动，等待连接。。。。。。");
            Socket socket = serverSocket.accept();
            System.out.println("连接成功！");
            //将与客户端对应的Socket对象传递给发送消息的线程，并启动该线程。
            new Send(socket).start();
            //将与客户端对应的Socket对象传递给接收消息的线程，并启动该线程。
            new Receive(socket).start();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

3.5.2 创建客户端

/**
 * 用户发送消息的线程
 */
class ClientSend extends Thread{
    //与服务端对应的Socket对象
    private Socket socket;
    public ClientSend(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        try(Scanner scanner = new Scanner(System.in);
            PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 用于接收消息的线程
 */
class ClientReceive extends Thread{
    //与服务端对应的Socket对象
    private Socket socket;
    public ClientReceive(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.receiveMsg();
    }

    /**
     * 接收消息
     */
    private void receiveMsg(){
        //创建用于接收对方消息的流对象
        try(BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){
            while(true){
                String msg = br.readLine();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class ChatSocketClient {
    public static void main(String[] args) {
        try{
            Socket socket = new Socket("127.0.0.1",8888);
            System.out.println("连接成功！");
            new ClientSend(socket).start();
            new ClientReceive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

3.6 优化点对点聊天应用

/**
 * 发送消息
 */
class Send1 extends Thread{
    private Socket socket;
    private Scanner scanner;
    public Send1(Socket socket,Scanner scanner){
        this.socket = socket;
        this.scanner = scanner;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        try(PrintWriter pw = new PrintWriter(socket.getOutputStream());){

            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 接收消息的线程
 */
class Receive1 extends Thread{
    private Socket socket;
    public Receive1(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
       this.receiveMsg();
    }
    /**
     * 接收消息
     */
    private void receiveMsg(){
        try(BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){

            while(true){
                String msg = br.readLine();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class GoodTCP {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        try{
            //键盘输入对象
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String str = scanner.nextLine();
            String[] arr = str.split(",");
            //启动服务端
            if("server".equals(arr[0])){
                //启动服务端
                System.out.println("TCP Server Listen at "+arr[1]+".......");
                serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
                socket = serverSocket.accept();
            }else{
                //启动客户端
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            }
            //启动发送消息的线程
            new Send1(socket,scanner).start();
            //启动接收消息的线程
            new Receive1(socket).start();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.7 一对多应用

一对多应用设计
各socket对间独立问答，互相间不需要传递信息。
在这里插入图片描述

3.7.1 一对多应答型服务器

/**
 * 定义消息处理线程
 */
class Msg extends Thread{
    private Socket socket;
    public Msg(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.msg();
    }
    /**
     * 将从客户端读取到的消息写回给客户端
     */
    private void msg(){
        try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            PrintWriter pw = new PrintWriter(this.socket.getOutputStream())){
            while(true){
                pw.println(br.readLine()+" [ok] ");
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
            System.out.println(this.socket.getInetAddress()+" 断开连接");
        }
    }
}
public class EchoServer {
    public static void main(String[] args) {
        try(ServerSocket serverSocket = new ServerSocket(8888)){
           while(true){
               Socket socket =  serverSocket.accept();
                new Msg(socket).start();
           }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

3.8 一对多聊天服务器

服务器设计
在这里插入图片描述
服务器的线程设计
在这里插入图片描述

3.8.1 创建一对多聊天服务应用

/**
 * 接收客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }

    /**
     * 实现接收客户端消息
     */
    private void receiveMsg(){
        try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){

            while(true){
                    String msg = br.readLine();
                    synchronized ("abc"){
                        //把读取到的数据写入公共数据区
                        ChatRoomServer.buf = "["+this.socket.getInetAddress()+"] "+msg;
                        //唤醒发送消息的线程
                        "abc".notifyAll();
                    }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 向客户端发送消息的线程类
 */
class ChatSend extends Thread{
    private Socket socket;
    public ChatSend(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 向客户端发送消息
     */
    private void sendMsg(){

        try(PrintWriter pw = new PrintWriter(this.socket.getOutputStream())){

            while(true){
                synchronized ("abc"){
                    //让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoomServer.buf);
                    pw.flush();
                }
            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class ChatRoomServer {
    //定义公共数据去
    public static String buf;
    public static void main(String[] args) {
        System.out.println("Chat Server Version 1.0");
        System.out.println("Listen at 8888.......");
        try(ServerSocket serverSocket = new ServerSocket(8888)){
            while(true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到："+socket.getInetAddress());
                //将与客户端对应的Socket对象传递到接收消息的线程中
                new ChatReceive(socket).start();
                //将与客户端对应的Socket对象传递到发送消息的线程中
                new ChatSend(socket).start();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

四、UDP通信的实现和项目案例

1. UDP通信实现原理

UDP协议与之前讲到的TCP协议不同，是面向无连接的，双方不需要建立连接便可通信。UDP通信所发送的数据需要进行封包操作（使用DatagramPacket类），然后才能接收或发送（使用DatagramSocket类）。
在这里插入图片描述
DatagramPacket：数据容器（封包）的作用
此类表示数据报包。 数据报包用来实现封包的功能。

常用方法：
在这里插入图片描述
DatagramSocket：用于发送或接收数据报包

当服务器要向客户端发送数据时，需要在服务器端产生一个DatagramSocket对象，在客户端产生一个DatagramSocket对象。

服务器端的DatagramSocket将DatagramPacket发送到网络上，然后被客户端的DatagramSocket接收。

DatagramSocket有两种常用的构造函数。一种是无需任何参数的，常用于客户端；另一种需要指定端口，常用于服务器端。如下所示：

  1. DatagramSocket() ：构造数据报套接字并将其绑定到本地主机上任何可用的端口。
  2. DatagramSocket(int port) ：创建数据报套接字并将其绑定到本地主机上的指定端口。

常用方法：
在这里插入图片描述
UDP通信编程基本步骤：

  1. 创建客户端的DatagramSocket，创建时，定义客户端的监听端口。
  2. 创建服务器端的DatagramSocket，创建时，定义服务器端的监听端口。
  3. 在服务器端定义DatagramPacket对象，封装待发送的数据包。
  4. 客户端将数据报包发送出去。
  5. 服务器端接收数据报包。

2.UDP通信入门案例

2.1 创建服务端

public class UDPServer {
    public static void main(String[] args) {
        //创建服务端接收数据的DatagramSocket对象
        try(DatagramSocket datagramSocket = new DatagramSocket(9999)){
            //创建数据缓存区
            byte[] b = new byte[1024];

            //创建数据报包对象
            DatagramPacket datagramPacket = new DatagramPacket(b,b.length);

            //等待接收客户端所发送的数据
            datagramSocket.receive(datagramPacket);
            //取出数据
            String str = new String(datagramPacket.getData(),0,datagramPacket.getLength());
            System.out.println(str);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

2.2 创建客户端

public class UDPClient {
    public static void main(String[] args) {
        //创建发送数据的对象DatagramSocket，需要指定消息发送的端口。
        try(DatagramSocket datagramSocket = new DatagramSocket(8888)){
            //数据需要进行类型转换，转换为字节数组数据类型
            byte[] bytes = "百战程序员".getBytes();
            //创建数据报包对象DatagramPacket对象
            DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,new InetSocketAddress("127.0.0.1",9999));
            //发送消息
            datagramSocket.send(datagramPacket);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

3. 传递基本数据类型

3.1 创建服务端

public class BasicTypeUDPServer {
    public static void main(String[] args) {
        try(DatagramSocket datagramSocket = new DatagramSocket(9999)){
            byte[] bytes = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length);

            //等待接收客户端所发送的数据
            datagramSocket.receive(datagramPacket);

            //类型转换
            try(DataInputStream dis = new DataInputStream(new ByteArrayInputStream(datagramPacket.getData()))){
                System.out.println(dis.readLong());
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

3.2 创建客户端

public class BasicTypeUPDClient {
    public static void main(String[] args) {
        long n = 2000l;
        try(DatagramSocket datagramSocket = new DatagramSocket(9000);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DataOutputStream dos =new DataOutputStream(bos)){

            dos.writeLong(n);
            //将基本数据类型转换为数组
           byte[] arr =  bos.toByteArray();

           //将数据包装成DatagramPacket对象
            DatagramPacket datagramPacket = new DatagramPacket(arr,arr.length,new InetSocketAddress("127.0.0.1",9999));

            //发送数据
            datagramSocket.send(datagramPacket);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

4. 传递自定义对象类型

4.1 创建Person类

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.2 创建服务端

public class ObjectTypeUDPServer {
    public static void main(String[] args) {
        try(DatagramSocket datagramSocket = new DatagramSocket(9999)){

            byte[] bytes = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length);

            //接收数据
            datagramSocket.receive(datagramPacket);

            //类型转换
            try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(datagramPacket.getData()))){
                Person person = (Person) ois.readObject();
                System.out.println(person);
            }

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

4.3 创建客户端

public class ObjectTypeUDPClient {
    public static void main(String[] args) {
        try(DatagramSocket datagramSocket = new DatagramSocket(8888);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos)){

            //创建自定义对象
            Person p  = new Person();
            p.setName("Oldlu");
            p.setAge(18);

            oos.writeObject(p);

            byte[] bytes = bos.toByteArray();

            //将数据包装成DatagramPacket对象
            DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,new InetSocketAddress("127.0.0.1",9999));

            //发送数据
            datagramSocket.send(datagramPacket);

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

五、总结

  • 端口是虚拟的概念，并不是说在主机上真的有若干个端口。

  • 在www上，每一信息资源都有统一且唯一的地址，该地址就叫URL（Uniform Resource Locator），它是www的统一资源定位符。

  • TCP与UDP的区别

    • TCP是面向连接的，传输数据安全，稳定，效率相对较低。
    • UDP是面向无连接的，传输数据不安全，效率较高。

  • Socket通信是一种基于TCP协议，建立稳定连接的点对点的通信。

  • 网络编程是由java.net包来提供网络功能。

    • InetAddress：封装计算机的IP地址和DNS（没有端口信息！）。
    • InetSocketAddress：包含IP和端口，常用于Socket通信。
    • URL：以使用它的各种方法来对URL对象进行分割、合并等处理。

  • 基于TCP协议的Socket编程和通信

    • “请求-响应”模式：
      • Socket类：发送TCP消息。
      • ServerSocket类：创建服务器。

  • UDP通讯的实现

    • DatagramSocket：用于发送或接收数据报包。
    • 常用方法：send()、receive()、 close()。

  • DatagramPacket：数据容器（封包）的作用

    • 常用方法：构造方法、getAddrress(获取发送或接收方计算机的IP地址)、getData(获取发送或接收的数据)、setData(设置发送的数据)。
惊鸿化雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
第二阶段：JAVA基础深化与提高
SCORPICAT的博客
02-27 1037
文章目录2 第二阶段 JAVA深化和提高2.1 面向对象深化2.1.1 抽象类和抽象方法2.1.1.1 抽象方法概念2.1.1.2 什么情况下使用抽象方法和抽象类？2.1.2 接口详解2.1.2.1 接口的概念2.1.2.2 接口中可以包含什么？2.1.2.3 接口与类的关系2.1.3 接口的特征_使用接口的意义2.1.3.1 接口的传递性2.1.3.2 接口的继承性（多继承）2.1.3.3 使用...
java网络编程.zip
05-12
Java网络编程是软件开发中的重要领域，特别是在分布式系统和互联网应用中不可或缺。北邮的这组计算机网络编程课件...这是一份全面而实用的学习资源，对于想要在Java网络编程领域深化的人来说，无疑是一份宝贵的财富。
Java基础深化和提高 ---- 网络编程
11-21 875
通过计算机网络可以实现不同计算机之间的连接与通信，但是计算 机网络中实现通信必须有一些约定即通信协议，对速率、传输代 码、代码结构、传输控制步骤、出错控制等制定标准。国际标准化组织(ISO，即International Organization for Standardization)定义了网络通信协议的基本框架，被称为OSI （Open System Interconnect，即开放系统互联）模型。
JAVA基础深化提高(二) | IDEA 调试 debug
weixin_65180200的博客
07-27 40
在这篇博客中，将深入探讨如何使用 IntelliJ IDEA 的调试功能来进行 Java 程序的调试。将介绍如何设置断点、单步执行代码、查看变量和表达式的值，并了解如何使用调试工具解决常见的编程问题。通过本文的指导，您将能够更加高效地调试和排查 Java 程序中的 bug，提高开发效率。
java深化——网络编程三要素详解
weixin_45397671的博客
07-26 285
网络编程的三要素： 1）IP地址：唯一标识网络上的每一台计算机，两台计算机之 间通信的必备因素 2）端口号：计算机中应用的标号(代表一个应用程序)， 0-1024 系统使用或保留端口 ，端号口占 2 个字节，所以 有效端口0-65535 3）通信协议：TCP 、 UDP 一、IP 地址： IP 地址用于标识网络上的唯一一台计...
Java协议解析：探索网络编程的核心
weixin_51151534的博客
02-29 983
Java协议是指在Java编程语言中用于网络通信的规范和标准。它定义了数据在网络中的传输方式、通信协议、数据格式等规则，使得不同设备和系统之间可以进行可靠的数据交换。在Java中，协议通常由一系列的API（Application Programming Interface，应用程序编程接口）或库来实现，开发者可以利用这些API来构建网络应用程序。Java提供了丰富的网络编程API，如java.net包和java.nio包，用于实现各种协议的通信。
JAVA 基础深化和提高【上】
LiLi的博客
02-19 725
异常机制 导引问题 工作中，程序遇到的情况不可能完美。比如：程序要打开某个文件，这个文件可能不存在或者文件格式不对；程序在运行着，但是内存或硬盘可能满了等等。 软件程序在运行过程中，非常可能遇到刚刚提到的这些问题，我们称之为异常，英文是：Exception，意思是例外。遇到这些例外情况，或者叫异常，我们怎么让写的程序做出合理的处理，安全的退出，而不至于程序崩溃呢？我们这里就要讲解这些问题。 如果我们要拷贝一个文件，在没有异常机制的情况下，我们需要考虑各种异常情况，伪代码如下： 【示例】伪代码：使用 i
JAVA基础深化和提高【下】
LiLi的博客
03-17 937
IO流 主要内容 IO 简介 IO 流入门案例 File 类的使用 常用流对象 Apache IO 包 一、IO简介 1 什么是IO 对于任何程序设计而言，输入输出（Input/Output）系统都是非常核心的功能。程序运行需要数据，数据的获取往往需要跟外部系统进行通信，外部系统可能是文件、数据库、其他程序、网络、IO设备等等。外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异，从而实现更加便捷的编程。 输入（Input）指的是：可以让程序外部系统获得数据（核心含义是“读”，读取外部数
Java编程：网络请求与HttpClient的使用
Oruizn的博客
12-22 519
网络是用物理链路将各个孤立的工作站或主机相连在一起，组成数据链路，从而达到资源共享和通信的目的。通信是人与人之间通过某种媒体进行的信息交流与传递。网络通信是通过网络将各个孤立的设备进行连接，通过信息交换实现人与人，人与计算机，计算机与计算机之间的通信。按通信执行类型可以分为同步通信(请求)和异步通信(请求)，按建立通信的方式可以分为短连接通信和长连接通信。
JAVA小白初级到中级水平 经典编程练习题目30道！
qqrrjj2011的博客
03-11 1128
JAVA小白初级到中级水平 经典编程练习题目30道！
Java编程的终极导航：《Java核心技术》系列全面解读
热门推荐
hacker707的博客
04-26 1万+
在编程世界中，Java的位置无可替代，无论是企业级应用、移动应用开发，还是大数据处理，Java都扮演着重要的角色。对于刚刚踏入这个领域的新手来说，有一条清晰的路线图是非常必要的；而对于经验丰富的开发者而言，及时更新知识库、了解新技术同样重要。这时，`《Java核心技术 卷I：开发基础（原书第12版）》`与`《Java核心技术 卷II：高级特性（原书第12版）》`便是你的灯塔，为你的Java学习之旅指引方向
基础深化和提高-网络编程
11-11
Java网络编程是指使用Java编程语言进行网络通信和相关操作的技术。通过Java的网络编程能力，开发人员可以创建客户端-服务器应用程序、实现数据传输、远程调用等功能。 Java的网络编程通常涉及以下几个方面： ...
基础深化和提高-java函数式编程
11-11
Java函数式编程是指利用函数式编程的思想和特性来开发Java应用程序。函数式编程强调将计算过程视为数学函数的求值，侧重于函数的组合、映射、过滤等操作，同时避免了可变状态和可变数据。 在Java中，函数式编程主要...
基础深化和提高-IO流技术学习大全
11-11
Java的I/O流（Input/Output Stream）技术是Java编程中用于处理输入和输出的重要部分。它提供了一种灵活而统一的方式来与文件、网络连接、内存等进行数据交换。 I/O流主要分为两种类型：字节流和字符流。 字节流： ...
SnacgUtack.rar_网络编程_Java_
08-11
在Java编程领域，网络编程是不可或缺的一部分，而深入理解数据结构和算法对于提升程序效率至关...通过学习和实践这个案例，开发者不仅可以掌握Java网络编程的基本原理，还能深化对数据结构和算法的理解，提高编程技能。
配置Java开发环境
最新发布
Broken_x的博客
07-10 1099
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 372
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1890
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1335
在 Java 中，可以通过多种方法将一个Object转换为Integer。
Java基础课程习题汇总.docx
09-27
"这份《Java基础课程习题汇总.docx》是针对Java编程初学者和进阶者的宝贵资料，它包含了一系列从基础到高级的编程习题，覆盖了Java语言的核心概念，如数据类型、运算符、控制结构、面向对象编程、异常处理以及多线程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值