Java网络编程（JavaWeb的基础）

文章目录

- Java网络编程（JavaWeb的基础）
- 前言
- 一、网络编程概述
- - [1.1 软件架构&网络基础](#1.1 软件架构&网络基础)
  - [1.2 网络通信要素:IP/端口/通信协议](#1.2 网络通信要素:IP/端口/通信协议)
  - [1.3 传输层协议:tcp/udp](#1.3 传输层协议:tcp/udp)
- 二、网络编程API
- - [2.1 InetAddress类](#2.1 InetAddress类)
  - [2.2 Socket类&相关API](#2.2 Socket类&相关API)
- 三、网络编程实现
- - [3.1 TCP网络编程](#3.1 TCP网络编程)
  - [3.2 UDP网络编程](#3.2 UDP网络编程)
  - [3.3 URL编程](#3.3 URL编程)
- 四、企业真题

前言

区分网络中的不能主机：唯一的IP地址
常用的网络应用程序模型：客户端－服务器。
- 服务器：是一个为其客户端提供某种特定服务的硬件或软件。
- 客户机是一个用户应用程序，用于访问某台服务器提供的服务。端口号是对一个服务的访问场所，它用于区分同一物理计算机上的多个服务。套接字用于连接客户端和服务器，客户端和服务器之间的每个通信会话使用一个不同的套接字。TCP协议用于实现面向连接的会话。
Java 中有关网络方面的功能都定义在 java.net 程序包中。Java 用 InetAddress 对象表示 IP 地址，该对象里有两个字段：主机名(String) 和 IP 地址(int)。
类 Socket 和 ServerSocket 实现了基于TCP协议的客户端－服务器程序。Socket是客户端和服务器之间的一个连接，连接创建的细节被隐藏了。这个连接提供了一个安全的数据传输通道，这是因为 TCP 协议可以解决数据在传送过程中的丢失、损坏、重复、乱序以及网络拥挤等问题，它保证数据可靠的传送。
类 URL 和 URLConnection 提供了最高级网络应用。URL 的网络资源的位置来同一表示 Internet 上各种网络资源。通过URL对象可以创建当前应用程序和 URL 表示的网络资源之间的连接，这样当前程序就可以读取网络资源数据，或者把自己的数据传送到网络上去。

一、网络编程概述

1.1 软件架构&网络基础

1、Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的支持，能开发常见的网络应用程序。

Java提供的网络类库，调用相关API即可实现通信。联网的底层细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。

2、软件架构

C/S架构：全称为Client/Server结构，是指客户端和服务器结构。常见程序有QQ、美团app、360安全卫士等软件。

B/S架构：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有IE、谷歌、火狐等。

3、计算机网络：

把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。

4、网络编程的目的：直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

网络编程中有三个主要的问题：------如何实现网络中的主机相互通信？

问题1：如何准确地定位网络上一台或多台主机------IP地址
问题2：如何定位主机上的特定的应用------端口号
问题3：找到主机后，如何可靠、高效地进行数据传输------tcp连接（流量控制、拥塞控制、确认、重试）

1.2 网络通信要素:IP/端口/通信协议

网络的通信本质上是两个进程（应用程序）的通信。

1、通信双方的地址，即网络通信要素：

IP：唯一标识网络中的设备，即网络地址，可以动态分配。全称是互联网协议地址（Internet Protocol Address）。与MAC区别：MAC唯一标识计算机的物理地址，不可变。
端口号：唯一标识设备中的进程（应用程序）
网络通信协议：不同的硬件、操作系统之间的通信，所有的这一切都需要一种规则

2、Internet上的主机地址表示方式：

域名(hostName)：www.atguigu.com

IP地址(hostAddress)：2.2.108.35.210

DNS：域名------》IP地址，DNS查找IP地址的查询过程可以是递归、迭代

DNS分类：本地、权威、顶级、根

3、IP地址分类一：IPv4、IPv6

IPv4：32位二进制数，即4个字节，表示方式：点分十进制，范围0~255。最多42亿个（30亿在北美，亚洲4亿，中国2.9亿，11年用尽）。
- 网络地址：标识计算机或网络设备所在的网段
- 主机地址：标识特定主机或网络设备
IPv6：128位二进制，即16个字节，8个无符号整数，冒分16进制。比如："ABCD:EF01:2345:6789:ABCD:EF01:2345:6789"。
额外优点：端到端IP连接、服务质量（QoS）、安全性、多播、移动性、即插即用等。

IP地址分类二：

公网地址( 万维网使用）
私有地址( 局域网使用）：192.168.开头，范围即为192.168.0.0--192.168.255.255，专门为组织机构内部使用。
特殊的：本地回环地址(hostAddress)：127.0.0.1、主机名(hostName)：localhost

如何查看IP地址

powershell 复制代码

# 查看本机IP地址
ipconfig
# 检查网络是否连通
ping 空格 IP地址
ping 220.181.57.216

4、端口号：唯一标识设备中的进程（应用程序）。16位二进制，即2个字节，取值范围是0~65535。

公认端口：0~1023。被预先定义的服务通信占用，如：HTTP（80），FTP（21），Telnet（23）
注册端口：1024~49151。分配给用户进程或应用程序。如：Tomcat（8080），MySQL（3306），Oracle（1521）。
动态/ 私有端口：49152~65535。

说明：如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

5、网络通信协议：在计算机网络中，连接和通信的规则，它规定了数据的传输格式、传输速率、传输步骤、出错控制等，通信双方必须同时遵守才能完成数据交换。

计算机网络通信涉及内容：比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？

答：采用通信协议分层思想。同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。

OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
- TCP/IP协议：传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。

6、TCP/IP协议中的四层介绍：

应用层：决定了向用户提供应用服务时通信的活动。主要协议有：HTTP协议、FTP协议、SNMP（简单网络管理协议）、SMTP（简单邮件传输协议）和POP3（Post Office Protocol 3的简称,即邮局协议的第3个版）等。
传输层：主要使网络程序进行通信，可以采用TCP协议、UDP协议。
- TCP（Transmission Control Protocol）协议，即传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。
  确认、重试机制、流量控制（滑动窗口）、拥塞控制（慢开始和拥塞避免）
- UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务。
网络层：支持网间互连的数据通信。它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
- IP（internet protocal）又称为互联网协议，网络层非常重要的一种协议。作用：把数据从源传送到目的地。它在源地址和目的地址之间传送一种称之为数据包的东西，它还提供对数据大小的重新组装功能，以适应不同网络对包大小的要求。
物理+数据链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。

1.3 传输层协议:tcp/udp

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

适用于发送端、接收端2个应用进程，无需建立连接，无论对方是否准备好，接收方收到也不确认，不能保证数据的完整性，因此是不可靠的。发送接收时无需释放资源，开销小，通信效率高。

传输的基本单位：数据、源、目的封装成数据包，大小限制64k。

适用场景：音频、视频和普通数据的传输。例如视频会议

例如生活中的发送短信、发电报

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

必须先"三次握手"建立连接，形成基于字节流的传输数据通道，点对点通信，可靠的。传输结束需要释放连接，效率低。通信双方：客户端、服务端。

保证可靠性：重发、确认机制、流量控制

例如下载文件、浏览网页等。

例如生活中的场景：打电话。

（1）三次握手：在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

第一次握手，客户端向服务器端发起TCP连接的请求
第二次握手，服务器端发送针对客户端TCP连接请求的确认
第三次握手，客户端发送确认的确认

step1：客户端会随机一个初始序列号seq=x，设置SYN=1 ，表示这是SYN握手报文。向服务端发起连接，之后客户端处于同步已发送状态。

step2：服务端收到客户端的 SYN 报文后，也随机一个初始序列号(seq=y)，设置ack=x+1，表示收到了客户端的x之前的数据，希望客户端下次发送的数据从x+1开始。SYN=1 和 ACK=1：表示SYN握手和ACK确认应答报文，把该报文发给客户端，该报文也不包含应用层数据，之后服务端处于同步已接收状态。

step3：客户端收到服务端报文后，向服务端回应最后一个应答报文（ACK=1，ack=y+1 ，表示收到了服务器的y之前的数据，希望服务器下次发送的数据从y+1开始。）。把报文发送给服务端，这次报文可以携带数据，之后客户端处于连接已建立状态。服务器收到客户端的应答报文后，也进入连接已建立状态。

握手报文------》确认应答报文------》应答报文

（2）四次挥手：在发送数据结束后，释放连接时需要经过四次挥手。

第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。

1、客户端打算断开连接，向服务器发送FIN报文(FIN标记位被设置为1，1表示为FIN，0表示不是)，FIN报文中会指定一个序列号，之后客户端进入FIN_WAIT_1状态。也就是客户端发出连接释放报文段(FIN报文)，指定序列号seq = u，主动关闭TCP连接，等待服务器的确认。

2、服务器收到连接释放报文段(FIN报文)后，就向客户端发送ACK应答报文，以客户端的FIN报文的序列号 seq+1 作为ACK应答报文段的确认序列号ack = seq+1 = u + 1。接着服务器进入CLOSE_WAIT(等待关闭)状态，此时的TCP处于半关闭状态(下面会说什么是半关闭状态)，客户端到服务器的连接释放。客户端收到来自服务器的ACK应答报文段后，进入FIN_WAIT_2状态。

3、服务器也打算断开连接，向客户端发送连接释放(FIN)报文段，之后服务器进入LASK_ACK(最后确认)状态，等待客户端的确认。服务器的连接释放(FIN)报文段的FIN=1，ACK=1，序列号seq=m，确认序列号ack=u+1。

4、客户端收到来自服务器的连接释放(FIN)报文段后，会向服务器发送一个ACK应答报文段，以连接释放(FIN)报文段的确认序号 ack 作为ACK应答报文段的序列号 seq，以连接释放(FIN)报文段的序列号 seq+1作为确认序号ack。

之后客户端进入TIME_WAIT(时间等待)状态，服务器收到ACK应答报文段后，服务器就进入CLOSE(关闭)状态，到此服务器的连接已经完成关闭。客户端处于TIME_WAIT状态时，此时的TCP还未释放掉，需要等待2MSL后，客户端才进入CLOSE状态。

二、网络编程API

java.net 包中包含的类和接口，它们提供低层次的通信细节。可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

提供了两种常见的网络协议的支持：UDP、TCP

网络编程：需要ip地址、建立tcp/udp连接

2.1 InetAddress类

1、InetAddress类：实例代表一个具体的ip地址------万事万物皆对象。

两个子类：Inet4Address、Inet6Address。

获取InetAddress 实例方法，没有提供公共的构造器；InetAddress的常用方法

java 复制代码

/** 获取InetAddress实例
*/
//法1: 获取指定IP对应的InetAddress的实例, "127.0.0.1"也是表示本地
InetAddress inet1 = InetAddress.getByName("192.168.23.31");///192.168.23.31
InetAddress inet2 = InetAddress.getByName("www.atguigu.com");//www.atquiqu.com/122.228.95.175

//法2: 获取本机IP地址对应额InetAddress实例
InetAddress inet3 = InetAddress.getLocalHost();//DESKTOP-QCP2QPI/192.168.21.107

//法3: public static InetAddress getByAddress(byte[] addr)

/** InetAddress常用的方法
*/
String hostAddress = inet1.getHostAddress();//获取IP地址
String hostName = inet1.getHostName();//获取主机名, 没有就显示域名
boolean bol = inet1.isReachable(int timeout);//测试是否可以达到该地址

2.2 Socket类&相关API

1、套接字Socket：IP+端口号=唯一能识别的标识符套接字（Socket）。

建立TCP连接的两端就是套接字。网络通信其实就是Socket间的通信。

通信的两端都要有Socket，是两台机器间通信的端点。
Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

2、Socket分类：

流套接字（stream socket）：使用TCP提供可依赖的字节流服务
- ServerSocket：此类实现TCP服务器套接字。服务器套接字等待请求通过网络传入。
- Socket：此类实现客户端套接字（也可以就叫"套接字"）。套接字是两台机器间通信的端点。
数据报套接字（datagram socket）：使用UDP提供"尽力而为"的数据报服务
- DatagramSocket：此类表示用来发送和接收UDP数据报包的套接字。

三、网络编程实现

TCP：ServerSocket、Socket

UDP：DatagramSocket、DatagramPacket

客户端：自定义、浏览器(browser --- server)
服务端：自定义、Tomcat服务器

3.1 TCP网络编程

1、TCP通信模型：

2、开发整体步骤：Java语言的基于套接字TCP编程分为服务端编程和客户端编程。

客户端程序：
- Step1：创建 Socket ：服务端的 IP+端口号构造 Socket 类对象（套接字）。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
- Step2：打开连接到 Socket 的输入/ 出流：使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输。
- Step3：按照一定的协议对 Socket 进行读/ 写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线路。
- Step4：关闭 Socket ：断开客户端到服务器的连接，释放线路
服务器端程序：
- Step1：创建服务端套接字，并绑定到指定端口上，用于监听客户端的请求：调用 ServerSocket(int port)
- Step2：监听客户端连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象：调用 accept()
- Step3：获取输出流和输入流，开始网络数据的发送和接收：调用该Socket 类对象的 getOutputStream() 和 getInputStream ()
- Step4：关闭Socket 对象：客户端访问结束，关闭通信套接字。

注意点：如果客户端发送完数据没有关闭，服务端会认为他还要发送就不会将数据输出。

TCP提供可依赖的字节流服务：ServerSocket、Socket

1、ServerSocket类
（1）构造方法：
ServerSocket(int port) ：创建绑定到特定端口的服务器套接字。

（2）常用方法：
Socket accept()：侦听并接受到此套接字的连接。

2、Socket类
（1）常用构造方法：
- public Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
- public Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。

（2）常用方法：------可以发送、接收数据
- public InputStream getInputStream()：返回此套接字的输入流，可以用于接收消息
- public OutputStream getOutputStream()：返回此套接字的输出流，可以用于发送消息
- public InetAddress getInetAddress()：此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
- public InetAddress getLocalAddress()：获取套接字绑定的本地地址。
- public int getPort()：此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
- public int getLocalPort()：返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1。
- public void close()：关闭此套接字。套接字被关闭后，无法重新连接/绑定，对应的输入/输出流也会被关闭。 
- public void shutdownInput()：从套接字输入流读取内容，将返回 EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
- public void shutdownOutput()：可以理解为客户端不再继续发送数据。

注意：先后调用Socket的shutdownInput()和shutdownOutput()方法，仅仅关闭了输入流和输出流，并不等于调用Socket的close()方法。在通信结束后，仍然要调用Scoket的close()方法，因为只有该方法才会释放Socket占用的资源，比如占用的本地端口号等。

题目1：客户端连接服务器，连接成功后给服务发送"lalala"，服务器收到消息后，给客户端返回"欢迎登录"，客户端接收消息后，断开连接

以下两个分别是服务端、客户端代码

java 复制代码

package com.atguigu.tcp.one;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
    public static void main(String[] args)throws Exception {
        //1、准备一个ServerSocket对象，并绑定8888端口
        ServerSocket server =  new ServerSocket(8888);
        System.out.println("等待连接....");

        //2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
        Socket socket = server.accept();
        InetAddress inetAddress = socket.getInetAddress();
        System.out.println(inetAddress.getHostAddress() + "客户端连接成功！！");

        //3、获取输入流，用来接收该客户端发送给服务器的数据
        InputStream input = socket.getInputStream();
        //接收数据
        byte[] data = new byte[1024];
        StringBuilder s = new StringBuilder();
        int len;
        while ((len = input.read(data)) != -1) {
            s.append(new String(data, 0, len));
        }
        System.out.println(inetAddress.getHostAddress() + "客户端发送的消息是：" + s);

        //4、获取输出流，用来发送数据给该客户端
        OutputStream out = socket.getOutputStream();
        //发送数据
        out.write("欢迎登录".getBytes());
        out.flush();
        //5、关闭socket，不再与该客户端通信
        //socket关闭，意味着InputStream和OutputStream也关闭了
        socket.close();
        //6、如果不再接收任何客户端通信，可以关闭ServerSocket
        server.close();
    }
}

java 复制代码

package com.atguigu.tcp.one;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
    public static void main(String[] args) throws Exception {
        // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);

        // 2、获取输出流，用来发送数据给服务器
        OutputStream out = socket.getOutputStream();
        // 发送数据
        out.write("lalala".getBytes());
        //会在流末尾写入一个"流的末尾"标记，对方才能读到-1，否则对方的读取方法会一致阻塞
        socket.shutdownOutput();

        //3、获取输入流，用来接收服务器发送给该客户端的数据
        InputStream input = socket.getInputStream();
        // 接收数据
        byte[] data = new byte[1024];
        StringBuilder s = new StringBuilder();
        int len;
        while ((len = input.read(data)) != -1) {
            s.append(new String(data, 0, len));
        }
        System.out.println("服务器返回的消息是：" + s);
        //4、关闭socket，不再与服务器通信，即断开与服务器的连接
        //socket关闭，意味着InputStream和OutputStream也关闭了
        socket.close();
    }
}

聊天室的实现：ServerSocket充当接收数据、将数据分发目标给对象。Socket客户端有几个人聊天就是几个，服务端只负责接收、分发。

客户端可以发送也可以接受------两个线程

服务端：主线程接收，针对每个客户端开启分线程处理数据

java 复制代码

package com.atguigu.tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class TestChatServer {
	//这个集合用来存储所有在线的客户端
	static ArrayList<Socket> online = new  ArrayList<Socket>();
	
	public static void main(String[] args)throws Exception {
		//1、启动服务器，绑定端口号
		ServerSocket server = new ServerSocket(8989);
		
		//2、接收n多的客户端同时连接
		while(true){
			Socket accept = server.accept();
			
			online.add(accept);//把新连接的客户端添加到online列表中
			
			MessageHandler mh = new MessageHandler(accept);
			mh.start();//
		}
	}
	
	static class MessageHandler extends Thread{
		private Socket socket;
		private String ip;
		
		public MessageHandler(Socket socket) {
			super();
			this.socket = socket;
		}

		public void run(){
			try {
				ip = socket.getInetAddress().getHostAddress();
				
				//插入：给其他客户端转发"我上线了"
				sendToOther(ip+"上线了");
				
				//(1)接收该客户端的发送的消息
				InputStream input = socket.getInputStream();
				InputStreamReader reader = new InputStreamReader(input);
				BufferedReader br = new BufferedReader(reader);
				
				String str;
				while((str = br.readLine())!=null){
					//(2)给其他在线客户端转发
					sendToOther(ip+":"+str);
				}
				
				sendToOther(ip+"下线了");
			} catch (IOException e) {
				try {
					sendToOther(ip+"掉线了");
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}finally{
				//从在线人员中移除我
				online.remove(socket);
			}
		}
		
		//封装一个方法：给其他客户端转发xxx消息
		public void sendToOther(String message) throws IOException{
			//遍历所有的在线客户端，一一转发
			for (Socket on : online) {
				OutputStream every = on.getOutputStream();
				//为什么用PrintStream？目的用它的println方法，按行打印
				PrintStream ps = new PrintStream(every);
				
				ps.println(message);
			}
		}
	}
}

java 复制代码

package com.atguigu.tcp;

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

public class TestChatClient {
	public static void main(String[] args)throws Exception {
		//1、连接服务器
		Socket socket = new Socket("127.0.0.1",8989);
		
		//2、开启两个线程
		//(1)一个线程负责看别人聊，即接收服务器转发的消息
		Receive receive = new Receive(socket);
		receive.start();
		
		//(2)一个线程负责发送自己的话
		Send send = new Send(socket);
		send.start();
		
		send.join();//等我发送线程结束了，才结束整个程序
		
		socket.close();
	}
}
class Send extends Thread{
	private Socket socket;
	
	public Send(Socket socket) {
		super();
		this.socket = socket;
	}

	public void run(){
		try {
			OutputStream outputStream = socket.getOutputStream();
			//按行打印
			PrintStream ps = new PrintStream(outputStream);
			
			Scanner input = new Scanner(System.in);
			
			//从键盘不断的输入自己的话，给服务器发送，由服务器给其他人转发
			while(true){
				System.out.print("自己的话：");
				String str = input.nextLine();
				if("bye".equals(str)){
					break;
				}
				ps.println(str);
			}
			
			input.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}
class Receive extends Thread{
	private Socket socket;
	
	public Receive(Socket socket) {
		super();
		this.socket = socket;
	}
	
	public void run(){
		try {
			InputStream inputStream = socket.getInputStream();
			Scanner input = new Scanner(inputStream);
			
			while(input.hasNextLine()){
				String line = input.nextLine();
				System.out.println(line);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

3.2 UDP网络编程

1、UDP通信模型

定义：UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务，类似于短信。

面向非连接的协议，尽最大努力交付，不保证可靠交付，即不管对方状态直接发送，发送完也不管对方是否可以接收到。好处：快、节省内存空间、流量，因为维护连接需要大量的数据结构。没有TCP的确认、重传机制。
UDP协议是面向数据报文的信息传送服务。UDP在发送端没有缓冲区，对于应用层交付下来的报文在添加了首部之后就直接交付于ip层，不会进行合并，也不会进行拆分，而是一次交付一个完整的报文。
UDP协议没有拥塞控制，所以当网络出现的拥塞不会导致主机发送数据的速率降低。虽然UDP的接收端有缓冲区，但是这个缓冲区只负责接收，并不会保证UDP报文的到达顺序是否和发送的顺序一致。因为网络传输的时候，由于网络拥塞的存在是很大的可能导致先发的报文比后发的报文晚到达。如果此时缓冲区满了，后面到达的报文将直接被丢弃。这个对实时应用来说很重要，比如：视频通话、直播等应用。
因此UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境，数据报大小限制在64K以下。

2、开发步骤
发送端：
- 创建DatagramSocket ：默认使用系统随机分配端口号。
- 创建DatagramPacket数据报文：将要发送的数据用字节数组表示，并指定要发送的数据长度，接收方的IP地址和端口号。
- 调用该DatagramSocket 类对象的 send方法：发送数据报DatagramPacket对象。
- 关闭DatagramSocket 对象：发送端程序结束，关闭通信套接字。
接收端：
- 创建DatagramSocket ：指定监听的端口号。
- 创建DatagramPacket：指定接收数据用的字节数组，起到临时数据缓冲区的效果，并指定最大可以接收的数据长度。
- 调用该DatagramSocket 类对象的receive方法：接收数据报DatagramPacket对象。。
- 关闭DatagramSocket ：接收端程序结束，关闭通信套接字。

UDP提供"尽力而为"的数据报服务：DatagramSocket、DatagramPacket

DatagramSocket对象作为基于UDP协议的Socket，使用DatagramPacket代表DatagramSocket发送、接收的数据报。

1、DatagramSocket类------常用方法
- public DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择。
- public DatagramSocket(int port,InetAddress laddr)创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址，IP 地址由内核选择。 
- public void close()关闭此数据报套接字。 
- public void send(DatagramPacket p)从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。 
- public void receive(DatagramPacket p)从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。 此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。 
- public InetAddress getLocalAddress()获取套接字绑定的本地地址。
- public int getLocalPort()返回此套接字绑定的本地主机上的端口号。 
- public InetAddress getInetAddress()返回此套接字连接的地址。如果套接字未连接，则返回 null。
- public int getPort()返回此套接字的端口。如果套接字未连接，则返回 -1。

2、DatagramPacket类------常用方法
- public DatagramPacket(byte[] buf,int length)构造 DatagramPacket，用来接收长度为 length 的数据包。 length 参数必须小于等于 buf.length。
- public DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。length 参数必须小于等于 buf.length。
- public InetAddress getAddress()返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
- public int getPort()返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
- `public byte[] getData()`返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续 length 长度。
- `public int getLength()`返回将要发送或接收到的数据的长度。

基于UDP协议的网络编程仍然需要在通信实例的两端各建立一个Socket，但这两个Socket之间并没有虚拟链路，这两个Socket只是发送、接收数据报的对象。

java 复制代码

package com.atguigu.udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;

public class Send {
    public static void main(String[] args)throws Exception {
//		1、建立发送端的DatagramSocket
        DatagramSocket ds = new DatagramSocket();
        //要发送的数据
        ArrayList<String> all = new ArrayList<String>();
        all.add("尚硅谷让天下没有难学的技术！");
        all.add("学高端前沿的IT技术来尚硅谷！");
        all.add("尚硅谷让你的梦想变得更具体！");
        all.add("尚硅谷让你的努力更有价值！");

        //接收方的IP地址
        InetAddress ip = InetAddress.getByName("127.0.0.1");
        //接收方的监听端口号
        int port = 9999;
        //发送多个数据报
        for (int i = 0; i < all.size(); i++) {
//			2、建立数据包DatagramPacket
            byte[] data = all.get(i).getBytes();
            DatagramPacket dp = new DatagramPacket(data, 0, data.length, ip, port);
//			3、调用Socket的发送方法
            ds.send(dp);
        }
//		4、关闭Socket
        ds.close();
    }
}

java 复制代码

package com.atguigu.udp;

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

public class Receive {
    public static void main(String[] args) throws Exception {
//		1、建立接收端的DatagramSocket，需要指定本端的监听端口号
        DatagramSocket ds = new DatagramSocket(9999);
        //一直监听数据
        while(true){
            //2、建立数据包DatagramPacket
            byte[] buffer = new byte[1024*64];
            DatagramPacket dp = new DatagramPacket(buffer,buffer.length);
            //3、调用Socket的接收方法
            ds.receive(dp);
            //4、拆封数据
            String str = new String(dp.getData(),0,dp.getLength());
            System.out.println(str);
        }
//        ds.close();
    }
}

3.3 URL编程

1、URL：统一资源定位符，表示Internet上某一资源的地址。

应用层协议的组成

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表   ---> "万事万物皆对象"

2、java.net.url类：表示URL，通过这个可以初始化一个URL对象。

3、URL类的构造器

注意：URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获。

public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象。例如：
public URL(URL context, String spec)：通过基 URL 和相对 URL 构造一个 URL 对象。例如：
public URL(String protocol, String host, String file); 例如：
public URL(String protocol, String host, int port, String file); 例如:

4、URL中的常用方法：一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性

public String getProtocol( ) 获取该URL的协议名
public String getHost( ) 获取该URL的主机名
public String getPort( ) 获取该URL的端口号
public String getPath( ) 获取该URL的文件路径
public String getFile( ) 获取该URL的文件名
public String getQuery( ) 获取该URL的查询名
URL的方法 openStream()：能从网络上读取数据

java 复制代码

/** 构造方法
*/
URL url = new URL("http://www. atguigu.com/"); 
URL downloadUrl = new URL(url, "download.html")
URL url = new URL("http", "www.atguigu.com", "download. html");
URL gamelan = new URL("http", "www.atguigu.com", 80, "download.html");
/** 常用方法
*/
URL url = new URL("http://localhost:8080/examples/myTest.txt");
System.out.println("getProtocol() :"+url.getProtocol());
System.out.println("getHost() :"+url.getHost());
System.out.println("getPort() :"+url.getPort());
System.out.println("getPath() :"+url.getPath());
System.out.println("getFile() :"+url.getFile());
System.out.println("getQuery() :"+url.getQuery());

5、针对HTTP协议的URLConnection类

建立URL连接：客户端（请求端）输出数据，例如向服务器端的 CGI （公共网关接口-Common Gateway Interface，是用户浏览器和服务器端的应用程序进行连接的接口）程序发送一些数据。必须先与URL建立连接，然后才能对其进行读写。

URLConnection：表示到URL所引用的远程对象的连接。通过URLConnection对象获取的输入流和输出流，即可以与现有的CGI程序进行交互。
- 获取URLConnection对象：即与一个URL建立连接，URL对象的openConnection()。如果连接过程失败，将产生IOException.
- public Object getContent( ) throws IOException
- public int getContentLength( )
- public String getContentType( )
- public long getDate( )
- public long getLastModified( )
- public InputStream getInputStream ( ) throws IOException
- public OutputSteram getOutputStream( )throws IOException

生成URL对象，建立URL连接

java 复制代码

public void testl(){
	try{
		//1. 获取url实例
		URL url = new URL("http://127.0.0.1:8080/examples/abcd.jpg");//得到URL对象
		//2. 建立与服务器端的连接
		HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();//生成URLConnection对象,建立URL连接
		//3. 获取输入流\创建输出流
		InputStream is =urlConnection.getInputStream();
		File file = new File("dest.jpg");
		File0utputStream fos =new File0utputStream(file);
		//4. 读写数据: 读到内存再从内存写出去
		bytel] buffer = new byte[1024];
		int len;
		while((len = is.read(buffer))!=-1){
			fos.write(buffer, 0,len);
		}
		System.out.println("文件读写完成!");
	}catch(IOException e){
		e.printStackTrace();
	}finally{
		//5. 关闭连接
		try{
			if(fos != null)
				fos.close();
		}catch(IOException e){
			e.printStackTrace();
		}
		try{
			if(is != null)
				is.close();
		}catch(IOException e){
			e.printStackTrace();
		}
		if(urlConnection != null)
			urlConnection.disconnext();
	}
	
}

四、企业真题

1、TCP协议和UDP协议的区别

TCP可靠：三次握手+四次挥手；确认+重传机制；流量控制、拥塞控制

UDP：使用数据报传输（限制64kb以内），不保证数据是否能被接收到

2、简单说说TCP协议的三次握手与四次挥手机制

略