【JavaSE 知识框架】12 网络编程

---

第12章 网络编程

创作日期：2021-11-14

---

1.网络编程概述

1.1 网络编程

• Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。
• Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在Java的本机安装系统里，由JVM进行控制。并且Java实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。

1.2 网络基础

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

---

2.网络通信要素概述

2.1 如何实现网络中的主机互相通信

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

2.2 网络通信协议模型

---

3.通信要素1：IP和端口号

3.1 IP的认识

• IP地址：InetAddress类         特点：不易记忆
  • 唯一的标识 Inetrnet上的计算机（通信实体）
  • 本地回环地址（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：公网地址（万维网使用）和私有地址（局域网使用）。192.168.开头的就是私有地址，范围即为192.168.0.0-192.168.255.255，专门为组织机构内部使用

//获取本地IP地址和主机名
public class IntAddressTest {
    public static void main(String[] args) throws UnknownHostException {

        //Inet4Address.getLocalHost() 获取主机名和主机IP地址
        InetAddress inet4Address = Inet4Address.getLocalHost();
        System.out.println(inet4Address);

        //getHostName() 获取主机名
        System.out.println(inet4Address.getHostName());

        //getHostAddress() 获取主机IP地址
        System.out.println(inet4Address.getHostAddress());
    }
}

3.2 端口号的认识

• 端口号标识正在计算机上运行的进程（程序）：
  • 不同的进程有不同的端口号
  • 被规定为一个16位的整数 0~65535
• 端口分类：
  • 公认端口：0~1023.被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，TeInet占用端口23）
  • 注册端口：1024~49151.分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）
• 动态/私有端口：49152~65535
• 端口号与IP地址的组合得出一个网络套接字：Socket

---

4.通信要素2：网络协议

4.1 网络通信协议

• 网络通信协议：计算机网络中实现通信必须有一些约定，即通信协议，对速率，传输代码，代码结构，传输控制步骤，出错控制等制定标准。
• 问题：网络协议太复杂：计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？
• 通信协议分层的思想：在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信，上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。

4.2 TCP/IP协议簇

• 传输层协议中有两个非常重要的协议：
  • 传输控制协议TCP（Transmission Control Protocol）
  • 用户数据报协议UDP（User Datagram Protocol）
• TCP/IP以其两个主要协议：传输控制协议（TCP）和网络互联协议（IP）而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。
• IP（Internet Protocol）协议是网络层的主要协议，支持网间互联的数据通信。
• TCP/IP协议模型从更实用的角度出发，形成了高校的四层体系结构，即物理链路层，IP层，传输层和应用层。

4.3 TCP和UDP

• TCP协议：
  • 使用TCP协议前，需先建立TCP连接，形成传输数据通道
  • 传输前，采用“三次握手”方式，点对点通信，是可靠的
  • TCP协议进行通信的两个应用进程：客户端，服务器端
  • 在连接中可进行大数据量的传输
  • 传输完毕，需释放已建立的连接，效率低

• UDP协议：
  • 将数据，源，目的封装成数据包，不需要建立连接
  • 每个数据报的大小限制在64K内
  • 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
  • 可以广播发送
  • 发送数据结束时无需释放资源，开销小，速度快

---

5.TCP网络编程

//TCP网络通信测试1
//客户端发送内容给服务器，服务器将内容打印到控制台上
public class TCPTest1 {
    //客户端
    @Test
    public void client() {
        OutputStream outputStream = null;
        Socket socket = null;
        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inetAddress, 8080);
            //2.获得一个输出流，用于输出数据
            outputStream = socket.getOutputStream();
            //3.写出数据的操作
            outputStream.write("你好".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            if (outputStream != null && socket != null) {
                try {
                    outputStream.close();
                    socket.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

    //服务器端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            //1.创建服务器端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8080);
            //2.调用accept()表示接收来自于客户端的socket
            Socket socket = serverSocket.accept();
            //3.获得输入流
            inputStream = socket.getInputStream();
            //4.读取输入流中的数据
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bytes = new byte[5];
            int len;
            while ((len = inputStream.read(bytes)) != -1) {
                byteArrayOutputStream.write(bytes, 0, len);
            }
            System.out.println("收到了客户端IP地址为："+socket.getInetAddress().getHostAddress()+
                    "，主机名为："+socket.getInetAddress().getHostName()+"的信息。\n信息："+byteArrayOutputStream.toString());
        } catch (IOException ioException) {
            ioException.printStackTrace();
        } finally {
            //5.关闭资源
            if (serverSocket != null
                    && inputStream != null && byteArrayOutputStream != null) {
                try {
                    serverSocket.close();
                    inputStream.close();
                    byteArrayOutputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }
}

//TCP网络通信测试2
//客户端发送文件给服务器，服务器将文件保存到本地
public class TCPTest1 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream outputStream = null;
        FileInputStream fileInputStream = null;
        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8080);
            //2.获得一个输出流，用于输出数据
            outputStream = socket.getOutputStream();
            //3.写出数据的操作
            fileInputStream = new FileInputStream("D:\\Java\\JavaFoundationUp\\src\\file\\b.txt");
            byte[] bytes = new byte[1024];
            int len;
            while ((len = fileInputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            if (fileInputStream != null && socket != null && outputStream != null) {
                try {
                    fileInputStream.close();
                    outputStream.close();
                    socket.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

    //服务器端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //1.创建服务器端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8080);
            //2.调用accept()表示接收来自于客户端的socket
            Socket socket = serverSocket.accept();
            //3.获得输入流
            inputStream = socket.getInputStream();
            //4.读取输入流中的数据
            fileOutputStream = new FileOutputStream("D:\\Java\\JavaFoundationUp\\src\\file\\c.txt");
            byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, len);
            }
            System.out.println("收到了客户端IP地址为：" + socket.getInetAddress().getHostAddress() +
                    "，主机名为：" + socket.getInetAddress().getHostName() + "的文件。");
        } catch (IOException ioException) {
            ioException.printStackTrace();
        } finally {
            //5.关闭资源
            if (serverSocket != null
                    && inputStream != null && fileOutputStream != null) {
                try {
                    serverSocket.close();
                    inputStream.close();
                    fileOutputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }
}

//TCP网络通信测试3
//从客户端发送文件给服务器，服务器将文件保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。
public class TCPTest1 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream outputStream = null;
        InputStream inputStream = null;
        FileInputStream fileInputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;

        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8080);
            //2.获得一个输出流，用于输出数据
            outputStream = socket.getOutputStream();
            //3.写出数据的操作
            fileInputStream = new FileInputStream("D:\\Java\\JavaFoundationUp\\src\\file\\b.txt");
            byte[] bytes = new byte[1024];
            int len;
            while ((len = fileInputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, len);
            }
            socket.shutdownOutput();
            //4.接收来自于服务器端的数据，并显示到控制台上
            inputStream = socket.getInputStream();
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bytes2 = new byte[5];
            int len2;
            while ((len2 = inputStream.read(bytes2)) != -1) {
                byteArrayOutputStream.write(bytes2, 0, len2);
            }
            System.out.println(byteArrayOutputStream.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源
            if (fileInputStream != null && socket != null && outputStream != null
                    && byteArrayOutputStream != null && inputStream != null) {
                try {
                    byteArrayOutputStream.close();
                    fileInputStream.close();
                    inputStream.close();
                    outputStream.close();
                    socket.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }

    //服务器端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        OutputStream outputStream = null;
        try {
            //1.创建服务器端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8080);
            //2.调用accept()表示接收来自于客户端的socket
            Socket socket = serverSocket.accept();
            //3.获得输入流
            inputStream = socket.getInputStream();
            //4.读取输入流中的数据
            fileOutputStream = new FileOutputStream("D:\\Java\\JavaFoundationUp\\src\\file\\c.txt");
            byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, len);
            }
            System.out.println("收到了客户端IP地址为：" +InetAddress.getLocalHost().getHostAddress()
            +"，主机名为：" + InetAddress.getLocalHost().getHostName() + "的文件。");
            //5.服务器端给予客户端反馈
            outputStream = socket.getOutputStream();
            outputStream.write("服务器端：客户端你好，文件已经收到！".getBytes());
        } catch (IOException ioException) {
            ioException.printStackTrace();
        } finally {
            //6.关闭资源
            if (serverSocket != null && outputStream != null
                    && inputStream != null && fileOutputStream != null) {
                try {
                    serverSocket.close();
                    outputStream.close();
                    inputStream.close();
                    fileOutputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }
}

---

6.UDP网络编程

6.1 UDP的认识

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

6.2 UDP网络编程测试

//UDP网络编程测试
public class UDPTest1 {

    //发送端
    @Test
    public void sender() {
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try {
            socket = new DatagramSocket();
            String s = new String("发送端：我是发送端");
            byte[] bytes = s.getBytes();
            datagramPacket = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getLocalHost(), 8080);
            socket.send(datagramPacket);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            socket.close();
        }
    }

    //接收端
    @Test
    public void receiver() {
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try {
            socket = new DatagramSocket(8080);
            byte[] bytes = new byte[1024];
            datagramPacket = new DatagramPacket(bytes,0,bytes.length);
            socket.receive(datagramPacket);
            System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            socket.close();
        }
    }
}

---

7.URL编程

7.1 URL的认识

• URL（Uniform Resource Locator）：统一资源定位符，它表示 Internet 上某一个资源的地址。
• 它是一种具体的URI，即 URL 可以用来标识一个资源，而且还指明了如何locate这个资源。
• 通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www，ftp站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。
• URL 的基本结构由5部分组成：<传输协议>://<主机名>：<端口号>/<文件名>#片段名？参数列表     

https://localhost:8080/mp_blog/creation/editor/a.txt?username=Tom

传输协议  主机名   端口号   资源地址                    参数列表

7.2 URL类构造器

• 为了表示 URL，java.net中实现了类 URL 。我们可以通过下面的构造器来初始化一个 URL 对象：
  • public URL(String spec)：通过一个表示 URL 地址的字符串可以构造一个URL对象。
  • public URL(URL context,String spec)：通过基 URL 和相对 URL 构造一个 URL 对象。
  • public URL(String peotocol,String host,String file)。
  • public URL(String peotocol,String host,int port,String file)。
• URL 类的构造器都声明抛出非运行时异常，必须要对这一异常进行处理，通常是用 try-catch 语句进行捕获。
• 一个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的查询名

public class URLTest1 {

    public static void main(String[] args) {
        URL url;
        {
            try {
                url = new URL("https://localhost:8080/mp_blog/creation/editor/a.txt?username=Tom");
                //url.getProtocol() 获取该URL的协议名
                System.out.println("该URL的协议名为："+url.getProtocol());

                //url.getHost() 获取该URL的主机名
                System.out.println("该URL的主机名为："+url.getHost());

                //url.getPort() 获取该URL的端口号
                System.out.println("该URL的端口号为："+url.getPort());

                //url.getPath() 获取该URL的文件路径
                System.out.println("该URL的文件路径为："+url.getPath());

                //url.getFile() 获取该URL的文件名
                System.out.println("该URL的文件名为："+url.getFile());

                //url.getQuery() 获取该URL的查询名
                System.out.println("该URL的查询名为："+url.getQuery());
                
                /* 输出结果
                * 该URL的协议名为：https
                * 该URL的主机名为：localhost
                * 该URL的端口号为：8080
                * 该URL的文件路径为：/mp_blog/creation/editor/a.txt
                * 该URL的文件名为：/mp_blog/creation/editor/a.txt?username=Tom
                * 该URL的查询名为：username=Tom
                * */
                
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
        }
    }
}

7.3 URL编程实现文件操作

//URL编程实现文件下载
public class URLTest2 {
    public static void main(String[] args) {

        URL url;
        URLConnection urlConnection;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            url = new URL("https://pics1.baidu.com/feed/ac345982b2b7d0a2bb167833154fe40049369aef.jpeg?token=cb9582da10ac5d0eb1ff7bed9b498d9e");
            urlConnection = url.openConnection();
            urlConnection.connect();

            inputStream = urlConnection.getInputStream();
            fileOutputStream = new FileOutputStream("D:/Java/JavaFoundationUp/src/file/c.jpeg");

            byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, len);
            }
            System.out.println("下载完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null && inputStream != null) {
                try {
                    inputStream.close();
                    fileOutputStream.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }

        }
    }
}

---

上一节：【JavaSE 知识框架】11 IO流

下一节：【JavaSE 知识框架】13 Java反射机制