【JAVA高级&网络编程】知识点整理

【JAVA高级&网络编程】知识点整理

164 次访问
· JAVA基础&高级

概述

通过本篇笔记的整理，对网络通讯相关的知识点进行整理，以及巩固对 JAVA 基础体系中 “网络编程” 相关的知识点。

目录

主要内容

0x01：概述

问题一：如何准确地定位网络上一台或多台主机；以及定位主机上的特定的应用

  • IP地址
  • 端口号

问题二：找到主机后，如何可靠、高效的进行数据传输

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

  • OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
  • TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
OSI参考模型TCP/IP参考模型TCP/IP参考模型各层对应协议
应用层应用层HTTP、FTP、Telnet、DNS…
表示层
会话层
传输层传输层TCP、UDP、…
网络层网络层IP、ICMP、ARP…
数据链路层物理+数据链路层Link

数据包的封装与解封过程

0x02：网络通讯的要素概述

要素一：IP地址和端口号

IP地址：InetAddress

  • 唯一的标识 Internet 上的计算机（通信实体）
  • 本地回环地址(hostAddress)：127.0.0.1 主机名(hostName)：localhost
  • IP地址分类方式一：IPV4和IPV6
    • IPV4：由4个字节组成，4个0-255。大概 42亿个，其中30亿都在北美，亚洲4亿。在2011年初就已经用尽。以点分十进制表示，如 192.168.0.1
    • IPV6：128位（16个字节），写成8个无符号整数，每个整数用 4 个十六进制位表示，数之间用冒号:分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
  • IP地址分类方式二：公网地址(万维网使用)和私有地址(局域网使用)。通常192.168.以及172.16.、10.开头的就是私有址址，范围即为192.168.0.0-192.168.255.255、172.16.0.0-172.16.255.255、10.0.0.0-10.255.255.255，专门为组织机构内部使用。

特点：不易记忆

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

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

应用使用端口进行通信，如下图

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

工具类：InetAddress

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地址"，这样才能和主机建立连接。这个过也称作为 "域名解析" 。

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)：

    测试是否可以达到该地址

使用例子

public static void main(String[] args) {

    try {
        //File file = new File("hello.txt");
        InetAddress inet1 = InetAddress.getByName("192.168.10.14");

        System.out.println(inet1);

        InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
        System.out.println(inet2);

        InetAddress inet3 = InetAddress.getByName("127.0.0.1");
        System.out.println(inet3);

        //获取本地ip
        InetAddress inet4 = InetAddress.getLocalHost();
        System.out.println(inet4);

        //getHostName()
        System.out.println(inet2.getHostName());
        //getHostAddress()
        System.out.println(inet2.getHostAddress());

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

}

输出结果

/192.168.10.14
www.atguigu.com/223.111.24.71
/127.0.0.1
DESKTOP-OE6FHSH/192.168.43.196
www.atguigu.com
223.111.24.71

Process finished with exit code 0

要素二：网络协议

概述

网络通信协议

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

问题：网络协议太复杂

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

通信协议分层的思想

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

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 协议进行通信的两个应用进程：客户端、 服务端。
  • 在连接中可进行大数据量的传输。
  • 传输完毕，需释放已建立的连接， 效率低。

常见的使用场景：对数据的可靠性较高，例如即时通讯（微信、QQ等）

TCP 三次握手过程

为什么不进行第四次握手?

经过三次握手后，基本就能保证这次连接是可靠的。再进行第四次握手的花对于可靠性提升较小，且会使整个握手流程的耗时增加，性价比低。

在TCP连接结束时需要经过四次挥手，过程如下图所示

UDP 协议：

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

使用场景：对数据的可靠性要求较低，允许一部分数据的丢失、追求性能，例如 网络视频、其他流媒体、游戏等。

Socket 套接字

概述

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

Socket的分类

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

Socket类的常用构造器：

  • public Socket(InetAddress address,int port)

    创建一个流套接字并将其连接到指定 IP 地址的指定端口号。

  • public Socket(String host,int port)

    创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket类的常用方法：

  • public InputStream getInputStream()

    返回此套接字的输入流。 可以用于接收网络消息

  • public OutputStream getOutputStream()

    返回此套接字的输出流。 可以用于发送网络消息

  • public InetAddress getInetAddress()

    此套接字连接到的 ”远程“ IP 地址；如果套接字是未连接的， 则返回 null。

  • public InetAddress getLocalAddress()

    获取套接字绑定的本地地址。 即本端的IP地址

  • public int getPort()

    此套接字连接到的远程端口号；如果尚未连接套接字， 则返回 0。

  • public int getLocalPort()

    返回此套接字绑定到的本地端口。 如果尚未绑定套接字， 则返回 -1。 即本端的端口号。

  • public void close()

    关闭此套接字。 套接字被关闭后， 便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和OutputStream。

  • public void shutdownInput()

    如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容， 则流将返回 EOF（文件结束符） 。 即不能在从此套接字的输入流中接收任何数据。

  • public void shutdownOutput()

    禁用此套接字的输出流。 对于 TCP 套接字， 任何以前写入的数据都将被发送， 并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。

0x03：TCP网络编程

基于Socket的TCP编程

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

客户端

客户端 Socket 的工作过程包含以下四个基本的步骤：

  • 创建 Socket： 根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
  • 打开连接到 Socket 的输入/出流： 使用 getInputStream() 方法获得输入流，使用 getOutputStream() 方法获得输出流，进行数据传输
  • 按照一定的协议对 Socket 进行读/写操作： 通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
  • 关闭 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 s = newSocket(“192.168.40.165” ,9999);
OutputStream out = s.getOutputStream();
out.write(" hello".getBytes());
s.close();

服务端

  • 服务器程序的工作过程包含以下四个基本的步骤：
  • 调用 ServerSocket(int port) ： 创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
  • 调用 accept()： 监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
  • 调用 该 Socket类对象的 getOutputStream() 和 getInputStream ()： 获取输出流和输入流，开始网络数据的发送和接收。
  • 关闭 ServerSocket 和 Socket 对象： 客户端访问结束，关闭通信套接字

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

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

ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept ();
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int num = in.read(buf);
String str = new String(buf,0,num);
System.out.println(s.getInetAddress().toString()+” :” +str);
s.close();
ss.close();

案例一：实现基本的字符串收发

需求：客户端向服务端发送一个字符串，服务端收到后输出到控制台。

客户端代码

@Test
public void client()  {
    Socket socket = null;
    OutputStream os = null;
    try {
        //1.创建Socket对象，指明服务器端的ip和端口号
        InetAddress inet = InetAddress.getByName("127.0.0.1");  //IP地址可以填自己的内网IP地址
        socket = new Socket(inet,8899);
        //2.获取一个输出流，用于输出数据
        os = socket.getOutputStream();
        //3.写出数据的操作
        os.write("你好，我是客户端mm".getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.资源的关闭
        if(os != null){
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        if(socket != null){
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

服务端代码

//服务端
@Test
public 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 = ss.accept();
        //3.获取输入流
        is = socket.getInputStream();

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

        //4.读取输入流中的数据
        baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[5];
        int len;
        while((len = is.read(buffer)) != -1){
            baos.write(buffer,0,len);
        }

        System.out.println(baos.toString());

        System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(baos != null){
            //5.关闭资源
            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();
            }
        }

    }
}

输出结果

案例二：文件的发送与接收

需求：客户端向服务端发送一个文件，服务端接收文件并且写入到本地

客户端代码

/*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //5.
    fis.close();
    os.close();
    socket.close();
}

服务端代码

/*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
@Test
public void server() throws IOException {
    //1.
    ServerSocket ss = new ServerSocket(9090);
    //2.
    Socket socket = ss.accept();
    //3.
    InputStream is = socket.getInputStream();
    //4.
    FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
    //5.
    byte[] buffer = new byte[1024];
    int len;
    while((len = is.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }

    System.out.println("文件接收成功！");

    //6.
    fos.close();
    is.close();
    socket.close();
    ss.close();

}

运行结果如下

并且将接收到的文件写入到了本地

在上述的代码基础上，我们增加一个功能：服务端接收到文件后， 向客户端返回一个 “接收成功” 的消息给客户端。

客户端代码，作出以下的修改

  • 完成文件的发送后，使用 shutdownOutput() 关闭输出流
  • 并构建一个"输入流"输入流，接收服务端的反馈信息
/*
        这里涉及到的异常，应该使用try-catch-finally处理
         */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //关闭数据的输出
    socket.shutdownOutput();

    //5.接收来自于服务器端的数据，并显示到控制台上
    InputStream is = socket.getInputStream();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] bufferr = new byte[20];
    int len1;
    while((len1 = is.read(buffer)) != -1){
        baos.write(buffer,0,len1);
    }

    System.out.println(baos.toString());

    //6.
    fis.close();
    os.close();
    socket.close();
    baos.close();
}

服务端代码，作出以下的修改

  • 在完成文件的接收后，创建一个输出流向客户端发送指定的字符串信息
/*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
    @Test
    public void server() throws IOException {
        //1.
        ServerSocket ss = new ServerSocket(9090);
        //2.
        Socket socket = ss.accept();
        //3.
        InputStream is = socket.getInputStream();
        //4.
        FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
        //5.
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

        System.out.println("图片传输完成");

        //6.服务器端给予客户端反馈
        OutputStream os = socket.getOutputStream();
        os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());

        //7.
        fos.close();
        is.close();
        socket.close();
        ss.close();
        os.close();

    }

输出结果

服务端

客户端

接收到的文件写入到本地

0x04：UDP网络编程

需求：发送端（客户端）向接收端你发送一段字符串信息，接收端（服务端）接收到数据后输出到控制台

发送端代码如下

//发送端
@Test
public void sender() throws IOException {

    DatagramSocket socket = new DatagramSocket();

    String str = "我是UDP方式发送的导弹";
    byte[] data = str.getBytes();
    InetAddress inet = InetAddress.getLocalHost();
    DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);

    socket.send(packet);

    socket.close();

}

接收端代码如下

//接收端
@Test
public void receiver() throws IOException {

    DatagramSocket socket = new DatagramSocket(9090);

    byte[] buffer = new byte[100];
    DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

    socket.receive(packet);

    System.out.println(new String(packet.getData(),0,packet.getLength()));

    socket.close();
}

输出结果如下

在以 UDP 方式进行传输数据时，发送端无需等待服务端的确认（无论是否连接成功），相对于以 TCP 的方式进行传输时，如果客户端无法连接到服务端，会抛出 ConnectException 异常 ，如下

0x05：URL编程

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

通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www， ftp 站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

URL 的基本结构由 5 部分组成：

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

例如:

http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

片段名：即锚点，例如看小说，直接定位到章节

参数列表格式：参数名=参数值&参数名=参数值....

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

  • public URL (String spec)：

    通过一个表示URL地址的字符串可以构造一个URL对象。

    例如： URL url = new URL ("http://www. atguigu.com/");

  • public URL(URL context, String spec)：

    通过 “基URL” 和 “相对 URL” 构造一个 "URL对象"。

    例如： URL downloadUrl = new URL(url, “download.html")

  • public URL(String protocol, String host, String file);

    例如： new URL("http","www.atguigu.com", “download. html");

  • public URL(String protocol, String host, int port, String file);

    例如： URL gamelan = newURL("http", "www.atguigu.com", 80, “download.html");

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 static void main(String[] args) {

    try {

        URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");

        //            public String getProtocol(  )     获取该URL的协议名
        System.out.println(url.getProtocol());
        //            public String getHost(  )           获取该URL的主机名
        System.out.println(url.getHost());
        //            public String getPort(  )            获取该URL的端口号
        System.out.println(url.getPort());
        //            public String getPath(  )           获取该URL的文件路径
        System.out.println(url.getPath());
        //            public String getFile(  )             获取该URL的文件名
        System.out.println(url.getFile());
        //            public String getQuery(   )        获取该URL的查询名
        System.out.println(url.getQuery());

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

}

输出结果

http
localhost
8080
/examples/beauty.jpg
/examples/beauty.jpg?username=Tom
username=Tom

Process finished with exit code 0

案例：将图片文件下载至本地

public static void main(String[] args) {

    HttpURLConnection urlConnection = null;
    InputStream is = null;
    FileOutputStream fos = null;
    try {
        URL url = new URL("https://uposs.codeyee.com/blog/chrome_sHWOX5JaYu.png");

        urlConnection = (HttpURLConnection) url.openConnection();

        urlConnection.connect();

        is = urlConnection.getInputStream();
        fos = new FileOutputStream("day10\\blog.png");

        byte[] 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 {
        //关闭资源
        if(is != null){
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fos != null){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(urlConnection != null){
            urlConnection.disconnect();
        }
    }


}

运行结果

成功将文件下载至本地

预览文件

总结

通过上述的内容的复习整理，巩固了 JAVA 的网络编程相关的知识点，例如通过编写 JAVA 代码来实现“文件、数据”在不同协议下的网络传输，以及其一些相关的理论知识。

Copyright: 采用 知识共享署名4.0 国际许可协议进行许可

Links: https://codeyee.com/archives/java-socket.html

【JAVA高级&反射】知识点整理