Java网络编程的基本概念 - 摩柯技术社区

网络编程基础概念

在深入探讨Java网络编程之前，我们先来理解一些网络编程的基本概念。

网络通信协议

网络通信协议是网络中计算机之间进行数据交换而建立的规则、标准或约定的集合。常见的网络协议有TCP/IP协议族，它包含了众多协议，其中TCP（传输控制协议）和IP（网际协议）是最为核心的两个协议。

IP协议：负责在网络层将数据包从源主机发送到目标主机。它主要解决的是网络地址的分配和数据包的路由问题。每个连接到网络的设备都有一个唯一的IP地址，类似于现实生活中的家庭住址，用于标识网络中的设备。例如，IPv4地址是由32位二进制数组成，通常以点分十进制的形式表示，如192.168.1.1。而IPv6则是为了解决IPv4地址枯竭问题而诞生，采用128位二进制数表示。
TCP协议：建立在IP协议之上，位于传输层。TCP提供可靠的、面向连接的数据传输服务。在数据传输之前，需要在发送端和接收端建立一条连接，就像打电话一样，先拨号建立连接，然后才能通话。TCP通过序列号、确认应答、重传机制等保证数据的可靠传输。例如，当发送方发送数据后，接收方会返回一个确认应答，表示数据已成功接收。如果发送方在规定时间内没有收到确认应答，就会重传数据。
UDP协议：同样位于传输层，但与TCP不同，UDP是无连接的、不可靠的数据传输协议。它不需要建立连接就可以直接发送数据，就像寄信一样，把信投进邮箱就不管了，不确保对方是否能收到。UDP的优点是传输速度快，开销小，适用于对实时性要求较高但对数据准确性要求相对较低的场景，如视频流、音频流的传输。

端口号

端口号是传输层协议（如TCP和UDP）用于标识应用程序的逻辑地址。IP地址标识了网络中的一台主机，而端口号则标识了主机上的一个应用程序。可以把IP地址比作一栋大楼的地址，端口号就是大楼里的各个房间号。端口号是一个16位的无符号整数，范围从0到65535。其中，0到1023为知名端口号，被一些常用的网络服务占用，例如HTTP协议默认使用80端口，HTTPS使用443端口，FTP使用21端口等。1024到65535为动态端口号，可供应用程序在运行时动态分配使用。

Java网络编程概述

Java提供了强大的网络编程支持，通过一系列的类库可以方便地实现基于TCP和UDP协议的网络通信。Java的网络编程主要涉及以下几个包：

java.net包：这是Java网络编程的核心包，包含了用于实现网络通信的各种类和接口。例如，Socket类用于实现TCP连接，DatagramSocket类用于实现UDP通信，InetAddress类用于表示IP地址等。
java.nio包及其子包：Java NIO（New I/O）提供了一种基于缓冲区和通道的非阻塞I/O操作方式，相比于传统的I/O方式，具有更高的效率和灵活性，适用于高性能网络编程场景。

TCP编程基础

Socket概念

在Java网络编程中，Socket（套接字）是一个重要的概念。它是应用层与传输层之间的接口，通过Socket可以实现不同主机上应用程序之间的通信。Socket通常由IP地址和端口号组成，用于唯一标识网络中的一个通信端点。在TCP编程中，有两种类型的Socket：

客户端Socket：客户端程序通过创建Socket对象来连接到服务器端。客户端Socket在创建时需要指定服务器的IP地址和端口号，通过这个Socket对象，客户端可以向服务器发送数据，并接收服务器返回的数据。
服务器端Socket：服务器端程序通过创建ServerSocket对象来监听指定的端口。当有客户端连接请求到达时，ServerSocket会接受这个请求，并创建一个新的Socket对象与客户端进行通信。服务器端可以通过这个Socket对象与客户端进行数据的收发。

TCP客户端编程示例

下面是一个简单的TCP客户端程序示例，该程序连接到本地服务器的8888端口，并向服务器发送一条消息，然后接收服务器返回的消息：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 8888)) {
            // 创建输出流，向服务器发送数据
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            // 创建输入流，接收服务器返回的数据
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("Echo: " + in.readLine());
            }
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: localhost.");
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for the connection to: localhost.");
            System.exit(1);
        }
    }
}

在上述代码中：

首先通过new Socket("localhost", 8888)创建一个客户端Socket对象，连接到本地主机的8888端口。
使用socket.getOutputStream()获取输出流，并包装成PrintWriter，用于向服务器发送数据。true参数表示自动刷新缓冲区，即每次调用println方法时会立即将数据发送出去。
使用socket.getInputStream()获取输入流，并包装成BufferedReader，用于接收服务器返回的数据。
通过System.in获取用户输入，将用户输入的数据发送给服务器，并接收服务器返回的响应数据并打印。

TCP服务器端编程示例

接下来是对应的TCP服务器端程序示例，该程序监听本地的8888端口，接收客户端连接，读取客户端发送的消息，并返回一条响应消息：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            System.out.println("Server started on port 8888...");
            while (true) {
                try (Socket clientSocket = serverSocket.accept()) {
                    // 创建输入流，读取客户端发送的数据
                    BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    // 创建输出流，向客户端发送数据
                    PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                    String inputLine;
                    while ((inputLine = in.readLine()) != null) {
                        System.out.println("Received from client: " + inputLine);
                        out.println("Message received by server.");
                    }
                } catch (IOException e) {
                    System.err.println("Accept failed.");
                    System.exit(1);
                }
            }
        } catch (IOException e) {
            System.err.println("Could not listen on port: 8888.");
            System.exit(1);
        }
    }
}

在上述代码中：

通过new ServerSocket(8888)创建一个ServerSocket对象，监听本地的8888端口。
使用serverSocket.accept()方法进入阻塞状态，等待客户端的连接请求。当有客户端连接时，会返回一个新的Socket对象，用于与该客户端进行通信。
通过clientSocket.getInputStream()获取输入流，并包装成BufferedReader，用于读取客户端发送的数据。
通过clientSocket.getOutputStream()获取输出流，并包装成PrintWriter，用于向客户端发送数据。
服务器端循环读取客户端发送的数据，打印出来，并返回一条响应消息。

UDP编程基础

DatagramSocket与DatagramPacket概念

在UDP编程中，Java使用DatagramSocket类来实现UDP通信，DatagramSocket用于发送和接收UDP数据包。而DatagramPacket类则用于表示UDP数据包，它包含了要发送或接收的数据、数据的长度、目标主机的IP地址和端口号等信息。

UDP客户端编程示例

下面是一个简单的UDP客户端程序示例，该程序向本地服务器的9999端口发送一条消息，并接收服务器返回的消息：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UDPClient {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket()) {
            InetAddress serverAddress = InetAddress.getByName("localhost");
            String message = "Hello, UDP Server!";
            byte[] sendData = message.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, 9999);
            socket.send(sendPacket);

            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            socket.receive(receivePacket);
            String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received from server: " + response);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中：

首先通过new DatagramSocket()创建一个DatagramSocket对象，用于发送和接收UDP数据包。
使用InetAddress.getByName("localhost")获取本地服务器的IP地址。
将待发送的消息转换为字节数组sendData，并创建一个DatagramPacket对象sendPacket，指定要发送的数据、数据长度、目标主机的IP地址和端口号。
使用socket.send(sendPacket)方法发送UDP数据包。
创建一个字节数组receiveData用于接收服务器返回的数据，再创建一个DatagramPacket对象receivePacket，指定接收数据的缓冲区。
使用socket.receive(receivePacket)方法接收UDP数据包，将接收到的数据转换为字符串并打印。

UDP服务器端编程示例

以下是对应的UDP服务器端程序示例，该程序监听本地的9999端口，接收客户端发送的消息，并返回一条响应消息：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(9999)) {
            System.out.println("UDP Server started on port 9999...");
            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            socket.receive(receivePacket);
            String message = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received from client: " + message);

            String response = "Message received by UDP server.";
            byte[] sendData = response.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, receivePacket.getAddress(), receivePacket.getPort());
            socket.send(sendPacket);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中：

通过new DatagramSocket(9999)创建一个DatagramSocket对象，监听本地的9999端口。
创建一个字节数组receiveData用于接收客户端发送的数据，并创建一个DatagramPacket对象receivePacket，指定接收数据的缓冲区。
使用socket.receive(receivePacket)方法接收UDP数据包，将接收到的数据转换为字符串并打印。
创建响应消息，将其转换为字节数组sendData，并根据客户端发送数据包的源地址和端口号创建一个新的DatagramPacket对象sendPacket。
使用socket.send(sendPacket)方法向客户端发送响应消息。

网络地址与域名解析

InetAddress类

在Java网络编程中，InetAddress类用于表示IP地址。它提供了一些静态方法来获取本地主机或远程主机的IP地址，并且可以通过主机名解析出对应的IP地址。InetAddress类没有构造函数，需要通过静态方法来获取实例。

以下是一些常用的方法：

InetAddress.getByName(String host)：根据主机名获取对应的InetAddress对象，如果主机名是IP地址格式，则直接返回对应的InetAddress对象。例如：

try {
    InetAddress address = InetAddress.getByName("www.example.com");
    System.out.println("IP Address: " + address.getHostAddress());
} catch (UnknownHostException e) {
    e.printStackTrace();
}

InetAddress.getLocalHost()：获取本地主机的InetAddress对象。例如：

try {
    InetAddress localAddress = InetAddress.getLocalHost();
    System.out.println("Local Hostname: " + localAddress.getHostName());
    System.out.println("Local IP Address: " + localAddress.getHostAddress());
} catch (UnknownHostException e) {
    e.printStackTrace();
}

域名系统（DNS）

域名系统（DNS）是互联网的一项核心服务，它作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。当我们在浏览器中输入一个域名，如www.example.com，计算机首先会向本地DNS服务器查询该域名对应的IP地址。如果本地DNS服务器没有缓存该域名的IP地址，它会向根DNS服务器、顶级域名（TLD）DNS服务器、权威DNS服务器等依次查询，直到获取到该域名对应的IP地址，然后才能建立与服务器的连接。

在Java网络编程中，当我们使用InetAddress.getByName(String host)方法时，如果传入的是域名，实际上就是在进行域名解析，通过DNS服务器获取对应的IP地址。

网络编程中的异常处理

在网络编程过程中，由于网络环境的复杂性，很容易出现各种异常情况。常见的异常有：

UnknownHostException：当指定的主机名无法解析为IP地址时抛出，例如使用InetAddress.getByName(String host)方法时，如果主机名不存在或网络配置有问题，就会抛出该异常。
IOException：这是一个通用的I/O异常类，在网络编程中，很多操作如读取或写入Socket流、操作DatagramSocket等都可能抛出该异常。例如，当Socket连接中断、网络故障等情况下，读写操作就可能引发IOException。
BindException：在服务器端使用ServerSocket或DatagramSocket绑定端口时，如果指定的端口已经被其他程序占用，就会抛出BindException。

在编写网络程序时，需要合理地处理这些异常，以增强程序的健壮性。例如，在前面的TCP和UDP编程示例中，我们通过try - catch块捕获异常，并在捕获到异常时进行相应的处理，如打印错误信息、退出程序等。

总结

通过以上内容，我们详细介绍了Java网络编程的基本概念，包括网络通信协议、端口号，深入探讨了TCP和UDP编程的原理及实现方式，并介绍了网络地址与域名解析以及异常处理等方面的知识。掌握这些基本概念和编程技巧是进行更复杂网络应用开发的基础，无论是开发简单的客户端 - 服务器应用，还是构建分布式系统、网络爬虫等，都离不开这些基础知识。在实际应用中，还需要根据具体的需求和场景，选择合适的网络编程方式，并不断优化代码以提高性能和可靠性。