Day40 网络编程（二） InetAddress类, Socket ,TCP编程，UDP编程

Day40 网络编程（二） InetAddress类, Socket ,TCP编程，UDP编程

一、 InetAddress类

1、概念：

InetAddress类是Java中用于表示 IP 地址的类，它提供了一些方法来操作 IP 地址，包括获取主机名、IP 地址、进行主机名解析等功能。InetAddress类位于java.net包中。

理解：用来表示主机的信息

2、主要方法：

1. 获取本地主机地址：getLocalHost()方法可以获取本地主机的InetAddress对象。

public static InetAddress getLocalHost() throws UnknownHostException
    //返回本地主机。
1
2

​ 2.根据主机名获取 IP 地址：getByName(String host)方法根据主机名获取对应的InetAddress对象。

public static InetAddress getByName(String host) throws UnknownHostException
    //在给定主机名的情况下确定主机的 IP 地址
1
2

注意：主机名可以是机器名（如 “java.sun.com”），也可以是其 IP 地址的文本表示形式。如果提供字面值 IP 地址，则仅检查地址格式的有效性。

​ 3.根据 IP 地址获取主机名：getHostName()方法可以获取 IP 地址对应的主机名。

​ 4.获取 IP 地址的字节数组：getAddress()方法可以获取 IP 地址的字节数组形式。

​ 5.判断 IP 地址的类型：isReachable(int timeout)方法可以判断该 IP 地址是否可达。

​ 6.其他方法：还有一些其他方法用于比较 IP 地址、获取主机名等操作。

3、示例：

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

public class Test01 {
	/**
	 * 知识点：InetAddress 
	 * 理解：表示主机类
	 */
	public static void main(String[] args) throws UnknownHostException {
		
		//获取本机的IP地址
//		InetAddress localHost = InetAddress.getLocalHost();
//		System.out.println(localHost);
		
		//获取域名对应的服务器地址
//		InetAddress byName = InetAddress.getByName("www.baidu.com");
//		System.out.println(byName);
		
		//获取域名对应的所有的服务器地址
		InetAddress[] allByName = InetAddress.getAllByName("www.baidu.com");
		for (InetAddress inetAddress : allByName) {
			System.out.println(inetAddress);
		}
		
		/**
		 * 一个域名 对应 多个IP地址
		 */
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

二、 Socket

1、概念：

Socket是Java中用于实现网络通信的基本类，它提供了客户端和服务器之间的双向通信机制。通过Socket类，可以在客户端和服务器之间建立连接，并进行数据的传输和通信 。

2、经验：

Scoket也叫套接字，其表示的是IP地址和端口号的组合。

网络编程主要就是指Socket编程，网络间的通信其实就是Socket间的通信，数据就通过IO流在两个Scoket间进行传递。

3、主要特性

1. 基于TCP协议：Socket基于TCP协议实现，提供可靠的、面向连接的通信。
2. 客户端-服务器模型：Socket类支持客户端和服务器之间的通信，客户端通过Socket与服务器建立连接。
3. 双向通信：Socket类提供了输入流和输出流，可以实现双向数据传输。
4. 阻塞式通信：默认情况下，Socket是阻塞式的，即在进行读写操作时会阻塞当前线程，直到操作完成或超时。
5. 多线程支持：可以在多线程环境下使用Socket，实现并发的网络通信。

4、基本用法：

1. 创建Socket对象：在客户端，使用Socket类创建一个Socket对象，并指定服务器的IP地址和端口号。
2. 建立连接：调用Socket对象的connect()方法与服务器建立连接。
3. 发送和接收数据：通过Socket对象的输入流和输出流进行数据的发送和接收。
4. 关闭连接：通信结束后，调用Socket对象的close()方法关闭连接。

5、示例：

客服端：

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

public class Client {
    public static void main(String[] args) {
        try {
            // 创建Socket对象，指定服务器地址和端口号
            Socket socket = new Socket("127.0.0.1", 8080);

            // 获取输出流，向服务器发送数据
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter out = new PrintWriter(outputStream, true);
            out.println("Hello, Server!");

            // 获取输入流，接收服务器返回的数据
            InputStream inputStream = socket.getInputStream();
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
            String response = in.readLine();
            System.out.println("Server response: " + response);

            // 关闭连接
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

三、TCP编程

1、概念：
TCP是一种面向连接的、可靠的、基于字节流的传输层协议，用于在网络中实现可靠的数据传输。在Java中，可以通过Socket和ServerSocket类来实现TCP编程，建立客户端和服务器之间的TCP连接，进行数据的传输和通信。

2、基本步骤：

1. 创建服务器端：
   • 创建ServerSocket对象，指定服务器端口。
   • 调用accept()方法接受客户端连接，返回Socket对象。
   • 使用Socket对象的输入流和输出流进行数据传输。
2. 创建客户端：
   • 创建Socket对象，指定服务器地址和端口。
   • 使用Socket对象的输入流和输出流进行数据传输。

3、示例：

服务器端：

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

public class TCPServer {
    public static void main(String[] args) {
        try {
            // 创建ServerSocket对象，指定端口号
            ServerSocket serverSocket = new ServerSocket(8080);

            // 等待客户端连接
            System.out.println("Server waiting for client...");
            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected.");

            // 获取输入流，接收客户端数据
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String clientMessage = in.readLine();
            System.out.println("Client message: " + clientMessage);

            // 发送响应给客户端
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            out.println("Hello, Client!");

            // 关闭连接
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

客服端：

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

public class TCPClient {
    public static void main(String[] args) {
        try {
            // 创建Socket对象，指定服务器地址和端口号
            Socket socket = new Socket("127.0.0.1", 8080);

            // 发送数据给服务器
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            out.println("Hello, Server!");

            // 接收服务器响应
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String serverResponse = in.readLine();
            System.out.println("Server response: " + serverResponse);

            // 关闭连接
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

四、UDP编程

1、概念：

UDP是一种无连接的、不可靠的传输层协议，它提供了数据包的无序传输，适用于对实时性要求较高、数据丢失可以容忍的场景。在Java中，可以通过DatagramSocket和DatagramPacket类来实现UDP编程，实现客户端和服务器之间的UDP通信。

2、基本步骤：

1. 创建服务器端：
   • 创建DatagramSocket对象，指定服务器端口。
   • 创建DatagramPacket对象用于接收客户端数据。
   • 使用receive()方法接收客户端数据，处理数据并发送响应。
2. 创建客户端：
   • 创建DatagramSocket对象。
   • 创建DatagramPacket对象用于发送数据到服务器。
   • 使用send()方法发送数据到服务器。

3、示例：

服务器端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPServer {
    public static void main(String[] args) {
        try {
            // 创建DatagramSocket对象，指定端口号
            DatagramSocket serverSocket = new DatagramSocket(9876);

            // 接收客户端数据
            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            serverSocket.receive(receivePacket);

            String clientMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Client message: " + clientMessage);

            // 发送响应给客户端
            byte[] sendData = "Hello, Client!".getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, receivePacket.getAddress(), receivePacket.getPort());
            serverSocket.send(sendPacket);

            // 关闭连接
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

客服端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient {
    public static void main(String[] args) {
        try {
            // 创建DatagramSocket对象
            DatagramSocket clientSocket = new DatagramSocket();

            // 发送数据给服务器
            String message = "Hello, Server!";
            byte[] sendData = message.getBytes();
            InetAddress serverAddress = InetAddress.getByName("127.0.0.1");
            int serverPort = 9876;
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
            clientSocket.send(sendPacket);

            // 接收服务器响应
            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            clientSocket.receive(receivePacket);

            String serverResponse = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Server response: " + serverResponse);

            // 关闭连接
            clientSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34