javajavase
尚硅谷宋红康第14章_网络编程.pdf

概述

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

网络基础

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

网络通讯要素

通信双方地址

  • IP
  • 端口号

网络通信协议

  • OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
  • TCP/IP协议：事实上的国际标准

12 网络编程 - 图1
通讯过程
image.pngimage.png

通讯要素一：IP 和 端口号

IP的理解

  • IP：唯一的标识 Internet 上的计算机（通信实体）
  • 在Java中使用 InetAddress 类代表IP
  • 本地回环地址(hostAddress)：127.0.0.1；主机名(hostName)：localhost
  • IP分类1：IPv4和IPv6
    • IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1
    • IPV6：128位(16个字节)，写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号分开，如3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
  • IP分类2：万维网和局域网
  • 域名: 通过域名解析服务器将域名解析为IP地址 www.baidu.com www.mi.com www.jd.com

  • 域名解析：域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。

    端口号

    用于标识正在计算机上运行的进程

  • 要求：不同的进程不同的端口号

  • 范围：被规定为一个16位的整数0~65535
  • 分类
    • 公认端口：0~1023，被预先定义的服务通信占用（如HTTP端口80，FTP端口21，TeInet端口23）
    • 注册端口：1024~49151.分配给用户进程或应用程序（如Tomcat端口8080，MySQL端口3306，Oracle端口1521等）
    • 动态私有端口：49152~65535

端口号与IP地址的组合得出一个网络套接字：Socket

InetAddress类

此类的一个对象就代表着一个具体的IP地址

  • Internet上的主机有两种方式表示地址
    • 域名(hostName)：www.atguigu.com
    • IP地址(hostAddress)：202.108.35.210
  • InetAddress类主要表示IP地址，两个子类：Inet4Address、Inet6Address
  • InetAddress类对象含有一个 Internet 主机地址的域名和IP地址，www.atguigu.com 和 202.108.35.210
  • 域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。 ———-域名解析

image.png
InetAddress类没有提供公共的构造器，而是提供了如下几个静态方法来获取InetAddress实例
**public static InetAddress getLocalHost()**获取本机地址
**public static InetAddress getByName(String host)**
InetAddress提供了如下几个常用的方法
**public String getHostAddress()**返回IP地址字符串（以文本表现形式）
**public String getHostName()**获取此IP地址的主机名
**public boolean isReachable(int timeout)**测试是否可以达到该地址

  1. public static void main(String[] args) {
  2.     try {
  3.         //File file = new File("hello.txt");
  4.         InetAddress inet1 = InetAddress.getByName("192.168.10.14");
  5.         System.out.println(inet1);    // /192.168.10.14
  6.         InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
  7.         System.out.println(inet2);    // www.atguigu.com/112.18.202.218
  8.         InetAddress inet3 = InetAddress.getByName("127.0.0.1");
  9.         System.out.println(inet3);    // /127.0.0.1
  11.         // 获取本地ip
  12.         InetAddress inet4 = InetAddress.getLocalHost();
  13.         System.out.println(inet4);    // cessdeMacBook-Pro.local/192.168.1.8
  15.         // getHostName()
  16.         System.out.println(inet2.getHostName());    // www.atguigu.com
  18.         // getHostAddress()
  19.         System.out.println(inet2.getHostAddress());    // 112.18.202.218
  21.     } catch (UnknownHostException e) {
  22.         e.printStackTrace();
  23.     }
  24. }

套接字Socket

端口号与IP地址的组合得出一个网络套接字：Socket
利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准

  • 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字
  • 通信的两端都要有 Socket，是两台机器间通信的端点
  • 网络通信其实就是 Socket 间的通信
  • Socket 允许程序把网络连接当成一个流，数据在两个 Socket 间通过 IO 传输
  • 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

Socket 分类

  • 流套接字（stream socket）：使用 TCP 提供可依赖的字节流服务
  • 数据报套接字（datagram socket）：使用 UDP 提供“尽力而为”的数据报服务

12 网络编程 - 图5

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

TCP和UDP的区别

  • TCP协议
    • 使用TCP协议前，须先建立TCP连接，形成传输数据通道
    • 传输前，采用“三次握手”方式，点对点通信，是可靠的
    • TCP协议进行通信的两个应用进程：客户端、服务端
    • 在连接中可进行大数据量的传输
    • 传输完毕，需释放已建立的连接，效率低
  • UDP协议
    • 将数据、源、目的封装成数据包，不需要建立连接
    • 每个数据报的大小限制在64K内
    • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
    • 可以广播发送
    • 发送数据结束时无需释放资源，开销小，速度快
  • TCP三次握手和四次挥手

12 网络编程 - 图6
第一步，是请求端(客户端)发送一个包含SYN即同步(Synchronize)标志的TCP报文，SYN同步报文会指明客户端使用的端口以及TCP连接的初始序号
第二步，服务器在收到客户端的SYN报文后，将返回一个SYN+ACK的报文，表示客户端的请求被接受，同时TCP序号被加一，ACK即确认(Acknowledgement)
第三步，客户端也返回一个确认报文ACK给服务器端，同样TCP序列号被加一，到此一个TCP连接完成。然后才开始通信的第二步：数据处理
12 网络编程 - 图7

TCP 网络编程

Java语言的基于套接字 Socket 编程分为客户端和服务端
基于TCP的Socket通信模型
12 网络编程 - 图8
客户端 Socket 的工作过程

  1. 创建 Socket：根据指定服务端的IP地址、端口号构造 Socket 类对象

若服务器端响应则建立客户端到服务器的通信线路。若连接失败会出现异常

  1. 打开连接到 Socket 的输入出流：使用 getInputstream() 方法获得输入流，使用 getOutputStream() 方法获得输出流，进行数据传输
  2. 按照一定的协议对Socket进行读/写操作：通过输入流读取服务器放入线路的信息（不能读取自己放入线路的信息），通过输出流将信息写入线程
  3. 关闭Socket：断开客户端到服务器的连接，释放线路

说明

  • 客户端程序可以使用 Socket 类创建对象，创建的同时会自动向服务器方发起连接
  • Socket的构造器是

**Socket(String host，int port) throws UnknownHostException，IOEXCeption**
向服务器(域名是 host，端口号为 port)发起 TCP 连接，若成功则创建 Socket 对象，否则抛出异常
**Socket(InetAddress address，int port)throws IOException**
根据 InetAddress 对象所表示的 IP 地址以及端口号 port 发起连接

  • 客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求

服务器端 Socket 的工作过程

  1. 调用**ServerSocket(int port)**创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求
  2. 调用**accept()**监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象
  3. 调用该Socket类对象的**getOutputStream()和getInputStream()**获取输出流和输入流，开始网络数据的发送和接收
  4. 关闭ServerSocket和Socket对象，客户端访问结束，关闭通信套接字

说明

  • ServerSocket 对象负责等待客户端请求建立套接字连接，类似邮局某个窗口中的业务员。也就是说服务器必须事先建立一个等待客户请求建立套接字连接的 ServerSocket 对象

  • 所谓“接收”客户的套接字请求，就是 accept() 方法会返回一个 Socket 对象

    1. public class TCPTest1 {
    2.   //客户端
    3.   @Test
    4.   public void client()  {
    5.       Socket socket = null;
    6.       OutputStream os = null;
    7.       try {
    8.           // 1.创建Socket对象，指明服务器端的ip和端口号
    9.           InetAddress inet = InetAddress.getByName("192.168.14.100");
    10.           socket = new Socket(inet, 8899);
    12.           // 2.获取一个输出流，用于输出数据
    13.           os = socket.getOutputStream();
    15.           //3.写出数据的操作
    16.           os.write("你好，我是客户端mm".getBytes());
    18.       } catch (IOException e) {
    19.           e.printStackTrace();
    20.       } finally {
    21.           // 4.资源的关闭
    22.           if(os != null){
    23.               try {
    24.                   os.close();
    25.               } catch (IOException e) {
    26.                   e.printStackTrace();
    27.               }
    28.           }
    29.           if(socket != null){
    30.               try {
    31.                   socket.close();
    32.               } catch (IOException e) {
    33.                   e.printStackTrace();
    34.               }
    35.           }
    36.       }
    37.   }
    39.   // 服务端
    40.   @Test
    41.   public void server() {
    42.       ServerSocket ss = null;
    43.       Socket socket = null;
    44.       InputStream is = null;
    45.       ByteArrayOutputStream baos = null;
    46.       try {
    47.           //1.创建服务器端的ServerSocket，指明自己的端口号
    48.           ss = new ServerSocket(8899);
    50.           //2.调用accept()表示接收来自于客户端的socket
    51.           socket = ss.accept();
    53.           //3.获取输入流
    54.           is = socket.getInputStream();
    56.           //不建议这样写，可能会有乱码
    57.           //        byte[] buffer = new byte[1024];
    58.           //        int len;
    59.           //        while((len = is.read(buffer)) != -1){
    60.           //            String str = new String(buffer, 0, len);
    61.           //            System.out.print(str);
    62.           //        }
    64.           //4.读取输入流中的数据
    65.           baos = new ByteArrayOutputStream();
    66.           byte[] buffer = new byte[5];
    67.           int len;
    68.           while((len = is.read(buffer)) != -1) {
    69.               // ByteArrayOutputStream内部有一个数组，接收write的数据
    70.               baos.write(buffer, 0, len);
    71.           }
    72.           System.out.println(baos.toString());
    73.           System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
    75.       } catch (IOException e) {
    76.           e.printStackTrace();
    77.       } finally {
    78.           if(baos != null){
    79.               // 5.关闭资源
    80.               try {
    81.                   baos.close();
    82.               } catch (IOException e) {
    83.                   e.printStackTrace();
    84.               }
    85.           }
    86.           if(is != null){
    87.               try {
    88.                   is.close();
    89.               } catch (IOException e) {
    90.                   e.printStackTrace();
    91.               }
    92.           }
    93.           if(socket != null){
    94.               try {
    95.                   socket.close();
    96.               } catch (IOException e) {
    97.                   e.printStackTrace();
    98.               }
    99.           }
    100.           if(ss != null){
    101.               try {
    102.                   ss.close();
    103.               } catch (IOException e) {
    104.                   e.printStackTrace();
    105.               }
    106.           }
    107.       }
    108.   }
    109. }

    客户端发送文件给服务端，服务端将文件保存在本地

    1. public class TCPTest2 {
    2.   //这里涉及到的异常，应该使用try-catch-finally处理
    3.   @Test
    4.   public void client() throws IOException {
    5.       Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
    6.       OutputStream os = socket.getOutputStream();
    7.       FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    9.       byte[] buffer = new byte[1024];
    10.       int len;
    11.       while((len = fis.read(buffer)) != -1){
    12.           os.write(buffer,0,len);
    13.       }
    15.       fis.close();
    16.       os.close();
    17.       socket.close();
    18.   }
    20.   //这里涉及到的异常，应该使用try-catch-finally处理
    21.   @Test
    22.   public void server() throws IOException {
    23.       ServerSocket ss = new ServerSocket(9090);
    24.       Socket socket = ss.accept();
    25.       InputStream is = socket.getInputStream();
    26.       FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
    28.       byte[] buffer = new byte[1024];
    29.       int len;
    30.       while((len = is.read(buffer)) != -1){
    31.           fos.write(buffer,0,len);
    32.       }
    34.       fos.close();
    35.       is.close();
    36.       socket.close();
    37.       ss.close();
    38.   }
    39. }

    从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端

    1. public class TCPTest3 {
    2.   //这里涉及到的异常，应该使用try-catch-finally处理
    3.   @Test
    4.   public void client() throws IOException {
    5.       Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    6.       OutputStream os = socket.getOutputStream();
    7.       FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    9.       byte[] buffer = new byte[1024];
    10.       int len;
    11.       while((len = fis.read(buffer)) != -1){
    12.           os.write(buffer,0,len);
    13.       }
    15.       // 关闭数据的输出
    16.       socket.shutdownOutput();
    18.       //5.接收来自于服务器端的数据，并显示到控制台上
    19.       InputStream is = socket.getInputStream();
    20.       ByteArrayOutputStream baos = new ByteArrayOutputStream();
    21.       byte[] bufferr = new byte[20];
    22.       int len1;
    23.       while((len1 = is.read(buffer)) != -1){
    24.           baos.write(buffer,0,len1);
    25.       }
    26.       System.out.println(baos.toString());
    28.       fis.close();
    29.       os.close();
    30.       socket.close();
    31.       baos.close();
    32.   }
    34.   // 这里涉及到的异常，应该使用try-catch-finally处理
    35.   @Test
    36.   public void server() throws IOException {
    37.       ServerSocket ss = new ServerSocket(9090);
    38.       Socket socket = ss.accept();
    39.       InputStream is = socket.getInputStream();
    40.       FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
    42.       byte[] buffer = new byte[1024];
    43.       int len;
    44.       while((len = is.read(buffer)) != -1){
    45.           fos.write(buffer,0,len);
    46.       }
    47.       System.out.println("图片传输完成");
    49.       OutputStream os = socket.getOutputStream();
    50.       os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
    52.       fos.close();
    53.       is.close();
    54.       socket.close();
    55.       ss.close();
    56.       os.close();
    57.   }
    58. }

UDP 网络编程

简述

  • 类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序
  • UDP 数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证 UDP 数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
  • DatagramPacket 对象封装了 UDP 数据报，在数据报中包含了发送端的 IP 地址和端口号以及接收端的 IP 地址和端口号
  • UDP 协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样

DatagramSocket类常用方法
12 网络编程 - 图9
12 网络编程 - 图10
DatagramSocket类的使用
流程

  1. DatagramSocket 与 DatagramPacket
  2. 建立发送端，接收端
  3. 建立数据包
  4. 调用 Socket 的发送、接收方法
  5. 关闭 Socket

注意：发送端与接收端是两个独立的运行程序

  1. // 发送端
  2. @Test
  3. public void sender() throws IOException {
  4.     DatagramSocket socket = new DatagramSocket();
  5.     String str = "我是UDP方式发送的导弹";
  6.     byte[] data = str.getBytes();
  7.     InetAddress inet = InetAddress.getByName("127.0.0.1");
  8.     DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9090);
  9.     socket.send(packet);
  10.     socket.close();
  11. }
  13. // 接收端
  14. @Test
  15. public void receiver() throws IOException {
  16.     DatagramSocket socket = new DatagramSocket(9090);
  17.     byte[] buffer = new byte[100];
  18.     DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
  19.     socket.receive(packet);
  20.     System.out.println(new String(packet.getData(), 0, packet.getLength()));
  21.     socket.close();
  22. }

URL 编程

URL Uniform Resource Locator：统一资源定位符，它表示Internet上某一资源的地址

  • 它是一种具体的 URI，即 URL 可以用来标识一个资源，而且还指明了如何 locate 这个资源。
  • 通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的www，ftp站点。浏览器通过解析给定的URL 可以在网络上查找相应的文件或其他资源
  • URL 的基本结构由5部分组成

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表
例如： http://192.168.1.100:8080/helloworld/indexjsp#a?username=shkstart&password=123
#片段名：即锚点，例如看小说，直接定位到章节
参数列表格式：参数名=参数值&参数名=参数值…
URL 类

  • 构造器

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

  • 方法

**public String getProtocol( )**获取该URL的协议名
**public String getHost( )**获取该URL的主机名
**public String getPort( )**获取该URL的端口号
**public String getPath( )**获取该URL的文件路径
**public String getFile( )**获取该URL的文件名
**public String getQuery( )**获取该URL的查询名

  1. public class URLTest {
  2.     public static void main(String[] args) {
  3.         try {
  4.             URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");
  5. //            public String getProtocol(  ) 获取该URL的协议名
  6.             System.out.println(url.getProtocol()); //http
  7. //            public String getHost(  )     获取该URL的主机名
  8.             System.out.println(url.getHost()); //localhost
  9. //            public String getPort(  )     获取该URL的端口号
  10.             System.out.println(url.getPort()); //8080
  11. //            public String getPath(  )     取该URL的文件路径
  12.             System.out.println(url.getPath()); ///examples/beauty.jpg
  13. //            public String getFile(  )     获取该URL的文件名
  14.             System.out.println(url.getFile()); ///examples/beauty.jpg?username=Tom
  15. //            public String getQuery(   )   获取该URL的查询名
  16.             System.out.println(url.getQuery()); //username=Tom
  17.         } catch (MalformedURLException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

通过URL下载

  1. public class URLTest1 {
  2.     public static void main(String[] args) {
  3.         HttpURLConnection urlConnection = null;
  4.         InputStream is = null;
  5.         FileOutputStream fos = null;
  6.         try {
  7.             URL url = new URL("http://localhost:8080/examples/beauty.jpg");
  8.             urlConnection = (HttpURLConnection) url.openConnection();
  9.             urlConnection.connect();
  10.             is = urlConnection.getInputStream();
  11.             fos = new FileOutputStream("day10\\beauty3.jpg");
  12.             byte[] buffer = new byte[1024];
  13.             int len;
  14.             while((len = is.read(buffer)) != -1){
  15.                 fos.write(buffer,0,len);
  16.             }
  17.             System.out.println("下载完成");
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             //关闭资源
  22.             if(is != null){
  23.                 try {
  24.                     is.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.             if(fos != null){
  30.                 try {
  31.                     fos.close();
  32.                 } catch (IOException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             if(urlConnection != null){
  37.                 urlConnection.disconnect();
  38.             }
  39.         }
  40.     }
  41. }