Java基础学习——第十四章 网络编程

一、网络编程概述

  1. 计算机网络：

    • 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。
  2. 网络编程的目的：
    • 直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯
  3. 网络编程两个主要的问题：
    • 问题一：如何准确地定位网络上一台或多台主机；定位主机上的特定的应用程序
    • 问题二：找到主机后如何可靠高效地进行数据传输

二、网络通信要素

1. 网络通信要素概述

  1. 通信双方地址（对应问题一）：

    • IP：用于定位网络上一台或多台主机
    • 端口号：用于定位主机上特定的应用程序
  2. 网络通信协议（对应问题二）：
    • OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
    • TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准

2. 通信要素一：IP和端口号

2.1 IP地址

  1. 唯一的标识 Internet 上的计算机（通信实体）
  2. Java中使用InetAddress类的对象来表示IP地址，一个InetAddress类的对象就对应一个IP地址
  3. IP地址分类(方式1)：IPV4 和 IPV6
    • IPV4：4个字节组成，4个0-255。以点分十进制表示，如192.168.0.1
    • IPV6：128位(16个字节)，写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
  4. IP地址分类(方式2)：公网地址(万维网使用)和私有地址(局域网使用)
    • 192.168.开头的就是私有址址，范围即为192.168.0.0–192.168.255.255，专门为组织机构内部使用
  5. Internet上的主机有两种方式表示地址：
    • 域名(hostName)：www.atguigu.com
    • IP 地址(hostAddress)： 202.108.35.210
  6. 域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接——域名解析
  7. 本地回环地址：127.0.0.1；对应着：localhost(本地主机)
2.1.1 InetAddress类
  1. InetAddress类主要表示IP地址， 两个子类：Inet4Address 和 Inet6Address
  2. InetAddress类的对象有两个属性：① IP地址：hostAddress；② 主机名（域名）：hostName
2.1.2 InetAddress类的实例化和常用方法
  1. InetAddress类没有提供公共的构造器，而是提供了如下几个静态方法来获取InetAddress对象

    • public static InetAddress getByName(String host)：获取指定IP或指定域名对应的InetAddress对象。形参host既可以是具体的IP地址，也可以是域名
    • public static InetAddress getLocalHost()：获取本机IP地址对应的InetAddress对象
  2. InetAddress提供了如下几个常用的方法：
    • public String getHostAddress()：返回当前InetAddress对象对应的IP地址
    • public String getHostName()：返回当前InetAddress对象对应的IP地址的主机名（域名）
    • public boolean isReachable(int timeout)：测试是否可以达到该地址
import java.net.InetAddress;
import java.net.UnknownHostException;public class InetAddressTest {public static void main(String[] args) {try {//1. 实例化InetAddress类的对象：调用InetAddress类的静态方法getByName(String host)//直接将IP地址作为参数传递给getByName()，返回的InetAddress对象对应一个具体的IP地址InetAddress inet1 = InetAddress.getByName("192.168.10.14");System.out.println(inet1); // /192.168.10.14//将域名作为参数传递给getByName()，域名服务器(DNS)会将域名转化成IP地址InetAddress inet2 = InetAddress.getByName("www.baidu.com");System.out.println(inet2); // www.baidu.com/180.97.34.94//2. 获取本机IP地址对应的InetAddress对象：调用InetAddress类的静态方法getLocalHost()InetAddress inet3 = InetAddress.getLocalHost();System.out.println(inet3); // DESKTOP-5GE4Q2Q/192.168.197.1//也可以通过getByName(String host)获取本机IP对应的InetAddress对象InetAddress inet4 = InetAddress.getByName("localhost");System.out.println(inet4); // localhost/127.0.0.1//3. getHostAddress()：返回当前InetAddress对象对应的IP地址System.out.println(inet2.getHostAddress());//4. getHostName()：返回当前InetAddress对象对应的IP地址的主机名（域名）System.out.println(inet2.getHostName());} catch (UnknownHostException e) {e.printStackTrace();}}
}

2.2 端口号

  1. 端口号标识正在计算机上运行的进程（程序）

    • 不同的进程有不同的端口号
    • 被规定为一个16位的整数0~65535
    • 端口分类：
      • 公认端口：0~1023。被预先定义的服务通信占用。如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23
      • 注册端口：1024~49151。分配给用户进程或应用程序。如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等
      • 动态/私有端口：49152~65535
  2. 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字：Socket

3. 通信要素二：网络通信协议

3.1 TCP/IP协议簇

  1. 传输层协议中有两个非常重要的协议：

    • 传输控制协议TCP(Transmission Control Protocol)
    • 用户数据报协议UDP(User Datagram Protocol)
  2. TCP/IP以其两个主要协议：**传输控制协议(TCP)和网络互联协议(IP)**而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议
  3. IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信
  4. TCP/IP协议的四层体系结构：应用层、传输层、网络层、物理+数据链路层

3.2 对比传输层协议：TCP 和 UDP

  1. TCP协议：

    • TCP协议进行通信的两个应用进程：客户端、服务端
    • 使用TCP协议传输前，必须先建立TCP连接(“三次握手”)，形成传输数据通道
      • 三次握手：点对点通信，是可靠的
    • 在连接中可进行大数据量的传输
    • 传输完毕，必须释放连接(“四次挥手”)，效率较低
    • 使用情境：打电话
  2. UDP协议：
    • 将数据、源、目的封装成数据报，无需建立连接
    • 每个数据报的大小限制在64K内
    • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
    • 可以广播发送
    • 传输完毕，无需释放资源，开销小，速度快
    • 使用情境：发送短信、发送电报
3.2.1 TCP协议建立连接：三次握手
  • 左边为客户端，右边为服务端

3.2.2 TCP协议释放连接：四次挥手

三、Socket(套接字)

1. Socket的概述

  1. 利用==套接字==(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准
  2. 网络上具有唯一标识的==IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字：Socket==
  3. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。通信的两端都要有Socket，是客户端和服务端间通信的==端点==，网络通信其实就是Socket间的通信
  4. Socket允许程序把网络连接当成一个流， 数据在两个Socket间通过IO传输
  5. Socket的分类：
    • 流套接字(stream socket)：使用TCP提供可依赖（可靠）的字节流服务
    • 数据报套接字(datagram socket)：使用UDP提供“尽力而为”（不可靠）的数据报服务

2. Socket类的常用构造器和方法

2.1 Socket类的常用构造器

  1. public Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号
  2. public Socket(String host,int port)：创建一个流套接字并将其连接到指定域名的主机上的指定端口号

2.2 Socket类的常用方法

  1. public InputStream getInputStream()：返回此套接字的输入流。可以用于接收网络消息
  2. public OutputStream getOutputStream()：返回此套接字的输出流。可以用于发送网络消息
  3. public InetAddress getInetAddress()：返回此套接字连接的远程IP地址对应的InetAddress对象；如果套接字未连接，则返回 null
  4. public InetAddress getLocalAddress()：获取套接字绑定的本地地址。即本端的IP地址
  5. public int getPort()：此套接字连接到的远程端口号；如果尚未连接套接字， 则返回 0
  6. public int getLocalPort()：返回此套接字绑定到的本地端口号。如果尚未绑定套接字，则返回 -1
  7. public void close()：关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字InputStream和OutputStream
  8. public void shutdownInput()：如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据
  9. public void shutdownOutput()：禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。即不能通过此套接字的输出流发送任何数据

四、TCP网络编程

1. 基于Socket的TCP编程

  • Java语言的基于Socket(套接字)编程分为==服务端编程和客户端编程==，其通信模型如图所示：

  • 客户端：

    • 自定义
    • 浏览器
  • 服务端
    • 自定义
    • Tomcat服务器

1.1 客户端Socket的工作过程

  1. 创建客户端套接字(Socket对象)：使用构造器Socket(InetAddress address, int port)，根据服务端的IP地址和端口号创建Socket类对象。若服务端响应，则建立客户端Socket到服务端Socket的通信线路
InetAddress inet = InetAddress.getByName("127.0.0.1"); //创建对应服务端IP地址的InetAddress对象
Socket socket = new Socket(inet,8899); //构造器：Socket(InetAddress address,int port)
  1. 获取客户端Socket的输出/入流(字节流)，用于网络数据的发送和接收：
  • 输出流：调用客户端Socket对象的**getOutputStream()**方法，返回一个OutputStream对象
OutputStream os = socket.getOutputStream(); //字节输出流
  • 输入流：调用客户端Socket对象的**getInputStream()**方法，返回一个InputStream对象
InputStream is = socket.getInputStream(); //字节输入流
  1. 通过输入/出流进行数据的读/写操作：
  • 通过输入流读入服务端写出到通信线路中的数据(但不能读取自己写出到通信线路中的内容)
  • 通过输出流将数据写出到通信线路中
  1. 手动关闭流和Socket资源：断开客户端Socket到服务端Socket的连接，释放线路
//为确保资源一定可以执行关闭操作，应把close()方法放在finally块中，并在调用close()前进行空指针判断
os.close(); //is.close();
socket.close();
1.1.1 客户端创建Socket对象
  1. 客户端程序可以使用Socket类创建对象，创建的同时会自动向服务器方发起连接。Socket的构造器是：

    • Socket(InetAddress address, int port) throws IOException：向服务端(IP地址为InetAddress对象address所对应的IP，端口号为port)发起TCP连接。若成功，则创建Socket对象；否则抛出异常
    • Socket(String host,int port) throws UnknownHostException, IOException：向服务端(域名是host，端口号为port)发起TCP连接。若成功，则创建Socket对象；否则抛出异常
  2. 客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求

1.2 服务端Socket的工作过程

  1. 创建服务端套接字(ServerSocket对象)：根据服务端的端口号创建ServerSocket对象，用于监听(等待)该端口是否有客户端请求建立套接字连接
ServerSocket ss = new ServerSocket(8899); //创建服务端套接字，构造器：ServerSocket(int port)
  1. 调用ServerSocket对象的accept()方法：监听客户端的套接字连接请求。如果客户端Socket请求连接, 则接受连接请求，并在服务端创建一个与客户端进行通信的Socket对象。此时客户端和服务端各有一个Socket对象
Socket socket = ss.accept();
  1. 获取服务端Socket的输出/入流(字节流)，用于网络数据的发送和接收：
  • 输出流：调用服务端Socket对象的**getOutputStream()**方法，返回一个OutputStream对象
OutputStream os = socket.getOutputStream(); //字节输出流
  • 输入流：调用服务端Socket对象的**getInputStream()**方法，返回一个InputStream对象
InputStream is = socket.getInputStream(); //字节输入流
  1. 通过输入/出流进行数据的读/写操作：
  • 通过输入流读入客户端写出到通信线路中的数据
  • 通过输出流将数据写出到通信线路中
  1. 手动关闭流、ServerSocket和Socket资源：客户端访问结束，关闭通信套接字
//为确保资源一定可以执行关闭操作，应把close()方法放在finally块中，并在调用close()前进行空指针判断
os.close(); //is.close();
socket.close();
1.2.1 服务端创建Socket对象
  1. ServerSocket对象负责等待客户端请求建立套接字连接，类似邮局某个窗口中的业务员。也就是说，服务器必须事先建立一个等待客户请求建立套接字连接的ServerSocket对象
  2. 所谓“接收”客户的套接字请求，就是accept()方法会返回一个与客户端进行通信的Socket对象

例1：客户端发送内容给服务端，服务端将该内容打印在控制台上

import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;/*** TCP网络编程* 例1：客户端发送内容给服务端，服务端将接受到的内容打印在控制台上*/public class TCPTest1 {//客户端@Testpublic void client() {Socket socket = null;OutputStream os = null;try {//1. 创建客户端套接字：根据指定服务端的IP地址和端口号创建Socket类对象//创建对应服务端IP地址的InetAddress对象InetAddress inet = InetAddress.getByName("127.0.0.1");socket = new Socket(inet, 8899);//2. 获取客户端Socket的输出流(字节流)：调用getOutputStream()，返回一个OutputStream对象os = socket.getOutputStream();//3. 通过输出流将数据写出到通信线路中os.write("你好，我是客户端！".getBytes());} catch (IOException e) {e.printStackTrace();} finally {//4. 手动关闭流和Socket资源：断开客户端到服务器的连接，释放线路if (os != null) {try {os.close();} catch (IOException e) {e.printStackTrace();}}if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}//服务端@Testpublic void server() {ServerSocket ss = null;Socket socket = null;InputStream is = null;ByteArrayOutputStream baos = null;try {//1. 创建服务端套接字：创建ServerSocket对象，并绑定到指定端口上，用于监听客户端的请求ss = new ServerSocket(8899);//2. 调用accept()方法：监听连接请求。若客户端请求连接，则创建一个与客户端通信的Socket对象//此时客户端和服务端各有一个Socket对象socket = ss.accept();//3. 获取服务端Socket的输入流(字节流)：调用getInputStream()，返回一个InputStream对象is = socket.getInputStream();//4. 通过输入流读入客户端写出到通信线路中的数据//每次都读入到字节数组中的字节转换成字符串输出：由于是字节流，输出中文可能会出现乱码(UTF-8：一个中文字符占3个字节)//byte[] buffer = new byte[20];//int len;//while ((len = is.read(buffer)) != -1) {//    String str = new String(buffer, 0 , len);//}//使用ByteArrayOutputStream：底层有一个byte型数组，调用其write()方法往底层数组写入字节，会自动扩容baos = new ByteArrayOutputStream();byte[] buffer = new byte[5];int len;while ((len = is.read(buffer)) != -1) {//先把每次读入到字节数组中的字节写到ByteArrayOutputStream类对象的底层数组中，等全部写完了再转化成字符串输出baos.write(buffer, 0, len);}System.out.println(baos.toString());//public InetAddress getInetAddress()：返回此套接字连接的远程IP对应的InetAddress对象System.out.println("客户端的IP地址为：" + socket.getInetAddress().getHostAddress());} catch (IOException e) {e.printStackTrace();} finally {//5. 手动关闭流、ServerSocket和Socket资源：客户端访问结束，关闭通信套接字if (baos != null) {try {baos.close();} catch (IOException e) {e.printStackTrace();}}if (is != null) {try {is.close();} catch (IOException e) {e.printStackTrace();}}if (socket != null) {try {socket.close();} catch (IOException e) {e.printStackTrace();}}if (ss != null) {try {ss.close();} catch (IOException e) {e.printStackTrace();}}}}
}

例2：客户端发送文件给服务端，服务端将该文件保存到本地

import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;/*** TCP网络编程* 例2：客户端发送文件给服务端，服务端将接受到的文件保存到本地* 涉及到的异常，应使用try-catch-finally进行处理*/public class TCPTest2 {//客户端@Testpublic void client() throws IOException {//1. 创建客户端套接字：根据指定服务端的IP地址和端口号创建Socket类对象Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8899);//2. 获取客户端Socket的输出流(字节流)：调用getOutputStream()，返回一个OutputStream对象OutputStream os = socket.getOutputStream();//3. 创建一个节点输入流，用于将本地文件中的字节型数据读入到内存中FileInputStream fis = new FileInputStream("Figure1.png");//4. 通过节点输入流将本地文件中的字节型数据读入到内存中，然后再通过客户端Socket的输出流将数据写出到通信线路中byte[] buffer = new byte[20];int len;while ((len = fis.read(buffer)) != -1) {os.write(buffer, 0, len);}//5. 手动关闭流和Socket资源：断开客户端到服务器的连接，释放线路fis.close();os.close();socket.close();}//服务端@Testpublic void server() throws IOException {//1. 创建服务端套接字：创建ServerSocket对象，并绑定到指定端口上，用于监听客户端的请求ServerSocket ss = new ServerSocket(8899);//2. 调用accept()方法：监听连接请求。若客户端请求连接，则创建一个与客户端通信的Socket对象//此时客户端和服务端各有一个Socket对象Socket socket = ss.accept();//3. 获取服务端Socket的输入流(字节流)：调用getInputStream()，返回一个InputStream对象InputStream is = socket.getInputStream();//4. 创建一个节点输出流，用于将字节型数据写出到本地文件中FileOutputStream fos = new FileOutputStream("Figure11.png");//5. 通过服务端Socket的输入流将客户端写出到通信线路中的数据读入到内存中，然后再通过节点输出流将数据写出到本地文件中byte[] buffer = new byte[20];int len;while ((len = is.read(buffer)) != -1) {fos.write(buffer, 0, len);}//6. 手动关闭流、ServerSocket和Socket资源：客户端访问结束，关闭通信套接字fos.close();is.close();socket.close();ss.close();}
}

例3：在例2的基础上，服务端返回"已接收"给客户端

import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;/*** TCP网络编程* 例3：客户端发送文件给服务端，服务端将接受到的文件保存到本地，并返回“发送成功”给客户端* 涉及到的异常，应使用try-catch-finally进行处理*/public class TCPTest3 {//客户端@Testpublic void client() throws IOException {//1. 创建客户端套接字：根据指定服务端的IP地址和端口号创建Socket类对象Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8899);//2. 获取客户端Socket的输出流(字节流)：调用getOutputStream()，返回一个OutputStream对象OutputStream os = socket.getOutputStream();//3. 创建一个节点输入流，用于将本地文件中的字节型数据读入到内存中FileInputStream fis = new FileInputStream("Figure1.png");//4. 通过节点输入流将本地文件中的字节型数据读入到内存中，然后再通过客户端Socket的输出流将数据写出到通信线路中byte[] buffer = new byte[20];int len;while ((len = fis.read(buffer)) != -1) {os.write(buffer, 0, len);}//禁用客户端Socket(套接字)的输出流，给服务端一个指示：客户端Socket不再发送数据socket.shutdownOutput();//5. 将服务端的返回的数据读入到内存中，并打印到控制台上//获取客户端Socket的输入流(字节流)：调用getInputStream()，返回一个InputStream对象InputStream is = socket.getInputStream();//使用ByteArrayOutputStream：底层有一个byte型数组，调用其write()方法往底层数组写入字节，会自动扩容ByteArrayOutputStream baos = new ByteArrayOutputStream();byte[] buffer1 = new byte[20];int len1;while ((len1 = is.read(buffer1)) != -1) {//先把每次读入到数组中的字节写到ByteArrayOutputStream类对象的底层数组中，等全部写完了再转化成字符串输出baos.write(buffer1, 0, len1);}System.out.println(baos.toString());//6. 手动关闭流和Socket资源：断开客户端到服务器的连接，释放线路baos.close();is.close();fis.close();os.close();socket.close();}//服务端@Testpublic void server() throws IOException {//1. 创建服务端套接字：创建ServerSocket对象，并绑定到指定端口上，用于监听客户端的请求ServerSocket ss = new ServerSocket(8899);//2. 调用accept()方法：监听连接请求。若客户端请求连接，则创建一个与客户端通信的Socket对象//此时客户端和服务端各有一个Socket对象Socket socket = ss.accept();//3. 获取服务端Socket的输入流(字节流)：调用getInputStream()，返回一个InputStream对象InputStream is = socket.getInputStream();//4. 创建一个节点输出流，用于将字节型数据写出到本地文件中FileOutputStream fos = new FileOutputStream("Figure22.png");//5. 通过服务端Socket的输入流将客户端写出到通信线路中的数据读入到内存中，然后再通过节点输出流将数据写出到本地文件中byte[] buffer = new byte[20];int len;while ((len = is.read(buffer)) != -1) {fos.write(buffer, 0, len);}//6. 服务端返回"已接收"给客户端//获取服务端Socket的输出流(字节流)：调用getOutputStream()，返回一个OutputStream对象OutputStream os = socket.getOutputStream();os.write("已接收".getBytes());//7. 手动关闭流、ServerSocket和Socket资源：客户端访问结束，关闭通信套接字os.close();fos.close();is.close();socket.close();ss.close();}
}

五、UDP网络编程

  1. DatagramSocket 和 DatagramPacket 类实现了基于 UDP 协议的网络通信
  2. UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
  3. DatagramPacket对象封装了UDP数据报，在数据报中包含了**发送端的IP地址和端口号以及接收端**的IP地址和端口号
  4. UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样
import org.junit.Test;
import java.io.IOException;
import java.net.*;/*** UDP网络编程* 例：发送端发送内容给接收端，接收端将接受到的内容打印在控制台上* 涉及到的异常，应使用try-catch-finally进行处理*/public class UDPTest {//发送端@Testpublic void sender() throws IOException {//1. UDP数据报通过数据报套接字 DatagramSocket 发送和接收DatagramSocket socket = new DatagramSocket();//2. DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号byte[] data = "我是UDP方式发送的导弹".getBytes(); //字节数据//使用public DatagramPacket(byte[] buf,int length,InetAddress address,int port)//构造UDP数据报，用来将长度为 length 的数据报发送到指定主机上的指定端口号DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("127.0.0.1"), 8899);//3. 通过套接字发送数据报给指定IP地址的主机的指定端口号socket.send(packet);//4. 关闭Socket资源socket.close();}//接收端@Testpublic void receiver() throws IOException {//1. UDP数据报通过数据报套接字 DatagramSocket 发送和接收，接收端需要指定端口号DatagramSocket socket = new DatagramSocket(8899);byte[] buffer = new byte[100];//public DatagramPacket(byte[] buf,int length)构造 DatagramPacket//2. 用来接收长度为 length 的数据报，length 参数必须小于等于 buf.lengthDatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//3. 通过套接字接收数据报socket.receive(packet);System.out.println(new String(packet.getData(), 0, packet.getLength()));//4. 关闭Socket资源socket.close();}
}

六、URL编程

1. URL类

  1. URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址
  2. 它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源
  3. 通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www， ftp站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源
  4. URL的基本结构由5部分组成：<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表
    • 例如：http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123
    • #片段名：即锚点，例如看小说，直接定位到章节
    • 参数列表格式：参数名=参数值&参数名=参数值…

2. URL类的构造器

  • 为了表示URL， java.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象：
  1. public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象
URL url = new URL ("http://www.atguigu.com/");
  1. public URL(URL context, String spec)：通过基 URL 和相对 URL 构造一个 URL 对象
URL downloadUrl = new URL(url, “download.html")
  1. public URL(String protocol, String host, String file)
URL url2 = new URL("http","www.atguigu.com", “download.html");
  1. public URL(String protocol, String host, int port, String file)
URL gamelan = new URL("http", "www.atguigu.com", 80, “download.html");
  • URL类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获

3. URL类的常用方法

  • 一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性：
  1. public String getProtocol()：获取该URL的协议名
  2. public String getHost()：获取该URL的主机名
  3. public String getPort()：获取该URL的端口号
  4. public String getPath()：获取该URL的文件路径
  5. public String getFile()：获取该URL的文件名
  6. public String getQuery()：获取该URL的查询名
import java.net.MalformedURLException;
import java.net.URL;/*** URL网络编程*/public class URLTest {public static void main(String[] args) {try {URL url = new URL("http://localhost:8080/examples/myTest.txt");System.out.println(url.getProtocol()); // http 协议名System.out.println(url.getHost());  // localhost 主机名System.out.println(url.getPort()); // 8080 端口号System.out.println(url.getPath()); // /examples/myTest.txt 文件路径System.out.println(url.getFile()); // /examples/myTest.txt 文件名System.out.println(url.getQuery()); // null 查询名} catch (MalformedURLException e) {e.printStackTrace();}}
}

4. URL网络编程实现Tomcat服务端数据下载

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;public class URLTest1 {public static void main(String[] args) {HttpURLConnection urlConnection = null;InputStream is = null;FileOutputStream fos = null;try {URL url = new URL("http://localhost:8080/examples/myTest.txt");//调用该URL对象的openConnection()方法，生成对应的URLConnection对象，即与服务器之间的连接对象//将该连接对象强转为URLConnection的子类——HttpURLConnection类urlConnection = (HttpURLConnection) url.openConnection();//开启与服务器的连接urlConnection.connect();//获取当前连接对象的输入流，用于将服务器的数据读入到内存中is = urlConnection.getInputStream();//创建一个节点输出流，用来将读入的服务器的数据写出到本地文件中fos = new FileOutputStream("myTest1.txt");//将服务器的数据读入到内存中，并写出到本地文件中byte[] buffer = new byte[1024];int len;while ((len = is.read(buffer)) != -1) {fos.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {//关闭资源if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (is != null) {try {is.close();} catch (IOException e) {e.printStackTrace();}}if (urlConnection != null) {try {urlConnection.disconnect(); //断开连接} catch (Exception e) {e.printStackTrace();}}}}
}//关闭资源if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (is != null) {try {is.close();} catch (IOException e) {e.printStackTrace();}}if (urlConnection != null) {try {urlConnection.disconnect(); //断开连接} catch (Exception e) {e.printStackTrace();}}}}
}

Java基础学习——第十四章 网络编程相关推荐

  1. Java基础学习——第十六章 Java8新特性

    Java基础学习--第十六章 Java8 新特性 Java8(JDK8.0)较 JDK7.0 有很多变化或者说是优化,比如 interface 里可以有静态方法和默认方法,并且可以有方法体,这一点就颠 ...

  2. Java基础学习总结（18）——网络编程

    一.网络基础概念 首先理清一个概念:网络编程 != 网站编程,网络编程现在一般称为TCP/IP编程. 二.网络通信协议及接口 三.通信协议分层思想 四.参考模型 五.IP协议 每个人的电脑都有一个独一 ...

  3. 基础复习第二十四天  网络编程

    网络编程 软件结构 C/S结构 :全称为Client/Server结构,是指客户端和服务器结构.常见程序有QQ.红蜘蛛.飞秋等软件. B/S结构 :全称为Browser/Server结构,是指浏览器和 ...

  4. Web前端开发精品课HTML CSS JavaScript基础教程第十四章课后编程题答案

    编程题: 下面有一段代码,请在这段代码的基础上使用正确的选择器以及这两章学到的字体样式.文本样式来实现图14-13所示的效果. <!DOCTYPE html> <html> & ...

  5. JavaScript高级程序设计第四版学习--第二十四章

    title: JavaScript高级程序设计第四版学习–第二十四章 date: 2021-5-31 10:46:01 author: Xilong88 tags: JavaScript 本章内容: ...

  6. 第二十四章 并发编程

    第二十四章 并发编程 爱丽丝:"但是我不想进入疯狂的人群中" 猫咪:"oh,你无能为力,我们都疯了,我疯了,你也疯了" 爱丽丝:"你怎么知道我疯了&q ...

  7. 鸟哥的Linux私房菜(基础篇)- 第二十四章、 X Window 配置介绍

    第二十四章. X Window 配置介绍 最近升级日期:2009/08/07 在 Linux 上头的图形介面我们称之为 X Window System,简称为 X 或 X11 罗!为何称之为系统呢?这 ...

  8. 【JAVA SE】第十四章 集合框架、语法糖和泛型

    第十四章 集合框架.语法糖和泛型 文章目录 第十四章 集合框架.语法糖和泛型 一.集合框架 1.概念 2.接口 二.语法糖 1.概念 2.解语法糖 三.泛型 1.概念 2.泛型类 3.泛型接口 4.泛 ...

  9. 第十一、十二、十三、十四章 网络配置管理、归档和远程复制同步文件、软件包管理、创建访问linux文件系统

    第十一章 网络配置管理 网络地址获取方式: 1)DHCP自动获取 2)手动配置 1.网卡配置文件: /etc/sysconfig/network-scripts/ [root@server0 Desk ...

最新文章

  1. MyBatis中#{}和${}的区别
  2. python lambda_Python 匿名函数 lambda
  3. python3.8.1安装教程-python3.8.1 安装
  4. java中抽象类 接口_java中的抽象类与接口
  5. 当年我是如何死磕 MySQL 数据库的
  6. Eclipse中手动清理项目缓存，
  7. 13 Tensorflow机制（翻译）
  8. oracle高资源消耗sql,Oracle高资源消耗SQL语句定位
  9. 安卓学习笔记43：初试开源框架Volley
  10. java null布局_Java中的null布局
  11. 关于div的定位属性问题
  12. JavaScript 原型对象和原型链
  13. 机器学习、神经网络中不懂的函数及功能实现
  14. 隔壁宿舍的都哭了，单片机最小应用系统不懂你都毕不了业
  15. iOS开发经验总结(二)
  16. Mybatis之分表设计与分表插入
  17. 计算机接口cad图,贴片机CAD图纸
  18. MySQL连接navicat出现 2059 - authentication plugin ‘caching_sha2_password解决方法
  19. vmware克隆centos修改mac地址
  20. 一个很好的看电子书的软件

热门文章

  1. EXCL模板报盘数据导入
  2. c语言入门高级教学（下）
  3. 初学者C语言练习题-入门
  4. windows 本地搭建git仓库_Windows平台下Github远程仓库的搭建-Go语言中文社区
  5. 面向对象程序设计php,php面向对象的程序设计
  6. django 注册登录邮箱验证功能
  7. Python使用numpy获取列表行数与列数
  8. android 原生分享文件,Android原生文件分享
  9. p8刷原生android,【EMUI3.1全局】原生Android M + IOS 7完美结合，听说跟P8更配哦
  10. WIN10 家庭版 安装DOCKER 遇到问题：THIS COMPUTER DOESN'T HAVE VT-X/AMD-V ENABLED