Java 高级_网络编程IP地址分类方式2：公网地址（万维网使用）和私有地址（局域网使用）；192.168. 开头的就

网络编程

网络编程概述

网络基础

计算机网络

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

网络编程的目的

直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯

网络编程中有两个主要的问题：

如何准确地定位网络上一台或多台主机：定位主机上的特定应用（进程）
找到主机后如何可靠高效地进行数据传输

网络通信要素概述

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

通信双方地址

IP：网络中唯一定位的一台主机
端口号：区分主机上不同的应用程序

一定的规则（即：网络通信协议；有两套参考模型）

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

通信要素1：IP和端口号

IP地址：InetAddress类

唯一的标识 Internet上的计算机（通信实体）
本地回路地址（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个无符号整数，每个整数用4个十六进制位表示，数之间用冒号（：）隔开，如：3ffe:3201:1402:1280:c8ff:db39:1984
IP地址分类方式2：公网地址（万维网使用）和私有地址（局域网使用）；192.168. 开头的就是私有地址，范围为 192.168.0.0 - 192.168.255.255；专门为组织机构内部使用
特定：不易记忆
域名：www.baidu.com、www.mi.com

package com.atguigu.java1;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @author lv
 * @create 2021-02-18 23:05
 */
public class InetAddressTest {
    public static void main(String[] args) {
        /**
         * 实例化 InetAddress：getByName()，getLocalHost()
         *
         * 两个常用方法：getHostName()、getHostAddress()
         */
        InetAddress ia;
        InetAddress ia2;
        InetAddress ia3;
        InetAddress localHost;
        try {
            ia = InetAddress.getByName("192.168.10.16");
            System.out.println("IP: " + ia); // IP: /192.168.10.16
            byte[] iaAddress = ia.getAddress();
//            System.out.println("IP: " + iaAddress);

            ia2 = InetAddress.getByName("www.baidu.com");
            System.out.println(ia2); // www.baidu.com/110.242.68.4

            ia3 = InetAddress.getByName("127.0.0.1");
            System.out.println(ia3); // /127.0.0.1
            // 获取本机 IP
            localHost = InetAddress.getLocalHost();
            System.out.println(localHost); // DESKTOP-SKGMJ7J/192.168.18.197

            // getHostName()：获取域名
            String hostName = ia2.getHostName();
            System.out.println(hostName); // www.baidu.com

            // getHostAddress()：获取 IP地址
            String hostAddress = ia2.getHostAddress();
            System.out.println(hostAddress); // 110.242.68.3

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

    }
}

端口号

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

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

网络通信协议

计算机网络中实现通信必须有一写约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准

问题：网络协议太复杂

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

通信协议分层的思想

在制定协议时，将复杂成份分解成一些简单的成份，再将它们复合起来；最常见的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系；各层互补影响，利于系统的开发和扩展

TCP/IP协议簇

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

TCP 和 UDP

TCP协议：

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

UDP协议

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

TCP三次握手：

客户端：我是小明
服务端：我知道你是小明，我是小亮
客户端：我知道你知道我是小明你是小亮

TCP四次挥手：

客户端：我现在想断开连接了
服务端：我接收到你想要断开连接的信息了
服务端：（断开连接后）我现在已经断开连接了
客户端：你断开连接了吗（没有收到服务端的反馈，表示断开了）

TCP网络编程

实例

package com.atguigu.java1;

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;
import java.net.UnknownHostException;

/**
 * @author lv
 * @create 2021-02-19 23:22
 *
 * 实现 TCP的网络编程
 *
 * 例1：客户端发送数据给服务端，并显示
 *
 */
public class TCPTest1 {

    /**
     * 客户端：
     *
     */
    @Test
    public void client () {

//
        InetAddress inet;
        Socket socket = null;
        OutputStream os = null;
        try {
//            1.创建 Socket对象，指明服务器端的 IP和端口号
            inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet, 8899);
//            2.创建输出流，获取流对象
            os = socket.getOutputStream();
//            3.写出数据
            os.write("你好，我是粑粑".getBytes());

        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            4.资源关闭
            try {
                if (null != os)
                    os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != socket)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 服务端
     */
    @Test
    public void server () {
        ServerSocket ss = null;
        Socket accept = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
//            1.创建服务器端 ServerSocket，指明自己的端口号
             ss = new ServerSocket(8899);
//            2.调用 accept()，表示接收来自于客户端的 socket
            accept = ss.accept();
//            3.获取输入流对象
            is = accept.getInputStream();

//            方式1.不建议这样写，可能会乱码
//            byte[] bytes = new byte[1024];
//            int len;
//            while ((len = is.read(bytes)) != -1) {
//                String str = new String(bytes, 0, len);
//                System.out.println(str);
//            }

//            方式2.使用 ByteArrayOutputStream
//            4.读取输入流中的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
//            5.处理获取的数据
            System.out.print(accept.getInetAddress().getHostAddress() + " : ");
            // 127.0.0.1 :
            System.out.println(baos.toString());
            // 你好，我是粑粑
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            6.资源的关闭
            try {
                if(null != baos)
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != is)
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != accept)
                accept.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != ss)
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

----------------------------------------
package com.atguigu.java1;

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author lv
 * @create 2021-02-23 18:52
 *
 * 实例2：客户端发送文件到服务端后并将其保存
 */
public class TCPTest2 {
    @Test
    public void client () {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        try {
//            创建 socket对象，指明对方的 ip地址和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8800);
            os = socket.getOutputStream();
            fis = new FileInputStream(new File("io流体系.png"));
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fis)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != os)
                    os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != socket)
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void server () {
//        1.指定 server端的端口号
        ServerSocket ss = null;
//        2.获取客户端的 socket
        Socket socket = null;
//        3.获取客户端的输入流
        InputStream is = null;
//        4.创建本地的文件流
        FileOutputStream fos = null;
        try {
            ss = new ServerSocket(8800);
            socket = ss.accept();
            is = socket.getInputStream();
            fos = new FileOutputStream(new File("io流体系2.png"));
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fos)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != is)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != socket)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != ss)
                    ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
-------------------------------------------
package com.atguigu.java1;

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author lv
 * @create 2021-02-23 19:46
 *
 * 实例：客户端发送文件到服务端，服务端保存后，返回客户端 ‘发送成功’
 */
public class TCPTest3 {
    @Test
    public void client () {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
//            创建 socket对象，指明对方的 ip地址和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8800);
            os = socket.getOutputStream();
            fis = new FileInputStream(new File("io流体系.png"));
            byte[] buffer = new byte[1024];
            int len;
//            read() 是阻塞式的操做
            while ((len = fis.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
//            通知服务端，数据已经传输完毕，关闭数据的输出
            socket.shutdownOutput();
//            获取服务端返回的数据
            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[1024];
            int len1;
            while ((len1 = is.read(buffer1)) != -1) {
                baos.write(buffer1, 0, len1);
            }
            System.out.println(baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fis)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != os)
                    os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != socket)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != is)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != baos)
                    baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void server () {
//        1.指定 server端的端口号
        ServerSocket ss = null;
//        2.获取客户端的 socket
        Socket socket = null;
//        3.获取客户端的输入流
        InputStream is = null;
//        4.创建本地的文件流
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(8800);
            socket = ss.accept();
            is = socket.getInputStream();
            fos = new FileOutputStream(new File("io流体系22.png"));
//            5.读写数据
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
//            客户端 socket.shutdownOutput()进行此操作后，表示数据以传输完毕，上边的循环结束

//            6.服务器端向客户端反馈数据
            os = socket.getOutputStream();
            os.write("保存成功".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fos)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != is)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != socket)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != ss)
                    ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != os)
                    os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端 - 服务端

客户端
- 自定义
- 浏览器
服务端
- 自定义
- Tomcat 服务器

UDP网络编程

UDP网络通信

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

实例：

package com.atguigu.java1;

import org.junit.Test;

import java.io.IOException;
import java.net.*;

/**
 * @author lv
 * @create 2021-02-24 19:12
 *
 * UDP的网络编程：
 *
 */
public class UDPTest1 {
//    发送端：
    @Test
    public void sender () {

        DatagramSocket socket = null;
        DatagramPacket packet = null;

        try {
//            创建一个 socket
            socket = new DatagramSocket();

            String str = "UDPSenders info";
            byte[] datas = str.getBytes();
//            InetAddress inet = InetAddress.getByName("127.0.0.1");
            InetAddress inet = InetAddress.getLocalHost();
//            封装一个数据报
            packet = new DatagramPacket(datas, 0, datas.length, inet, 9090);

//            发送数据报
            socket.send(packet);

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            关闭资源
            socket.close();
        }

    }
//    接收端：
    @Test
    public void receiver () {
        DatagramSocket socket = null;
        try {
//            创建 socket对象
            socket = new DatagramSocket(9090);
            byte[] datas = new byte[100];
//            创建 packet，接收发送端的数据
            DatagramPacket packet = new DatagramPacket(datas, datas.length);
            socket.receive(packet);

            String str = new String(packet.getData(), 0, packet.getLength());
            System.out.println("datas: " + str);

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
    }
}

URL编程

URL类

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

URL类构造器

为了表示 URL，java.net中实现了类 URL；我们可以通过下面的构造器来初始化一个 URL对象

public URL(String spec)：通过一个表示 URL地址的字符串可以构造一个 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的查询名

实例：

package com.atguigu.java1;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.HttpURLConnection;

/**
 * @author lv
 * @create 2021-02-24 20:10
 */
public class URLTest1 {
    public static void main(String[] args) {
        URL url = null;
        HttpURLConnection uc = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            url = new URL("https://v3.cn.vuejs.org/logo.png");

            String protocol = url.getProtocol();
            String host = url.getHost();
            int port = url.getPort();
            String path = url.getPath();
            String file = url.getFile();
            String query = url.getQuery();

            System.out.println("protocol: " + protocol);
            System.out.println("host: " + host);
            System.out.println("port: " + port);
            System.out.println("path: " + path);
            System.out.println("file: " + file);
            System.out.println("query: " + query);
//            创建 HttpURLConnection对象
            uc = (HttpURLConnection)url.openConnection();
//            获取连接（访问服务器）
            uc.connect();
//            获取输入流
            is = uc.getInputStream();
            fos = new FileOutputStream(new File("day10\\picture1.png"));

            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fos)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (null != is)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (null != uc)
                uc.disconnect();
        }
    }
}

问题：

一个 IP对应着那个类的对象，实例化此类的方法是，两个常用的方法是

InetAddress
InetAddress.getByName(String host); / InetAddress.getLocalHost();
getHostName() / getHostAddress()

传输层的 TCP协议和 UDP协议的主要区别是

TCP：

可靠的数据传输（三次握手）
可进行大数据量的传输
效率低

UDP：

只负责发送数据，数据传输不可靠
每次都以数据报的形式发送，大小限定为 64kb
效率高

URL

统一资源定位符
new URL("http://192.168.14.110:8899/xx/xxx/hei.txt?a=123")

谈谈你对对象序列化的理解

将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；然后在需要的时候，可以读取字节流中的信息来重构一个相同的对象

允许把内存中的 Java对象转换成与平台无关的二进制流，从而把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点；当其它程序获取了这种二进制流，就可以恢复原来的 Java对象

序列化过程

反序列化过程

对象要想实现序列化，需满足的条件

实现接口：Serializable
对象所在的类提供一个常量（序列版本号）：public static final long serivalVersionUID = 4854196574585642353L;
要求对象的属性也必须是可序列化的（基本数据类型、String、自定义类...）

Java 高级_网络编程