Introducción a esta sección:
Esta sección les trae la última parte de Socket: la comunicación Socket basada en el protocolo UDP. En la primera sección ya comparamos en detalle las diferencias entre ambos. La mayor diferencia entre TCP y UDP es si se necesita establecer una conexión entre el cliente y el servidor antes de poder realizar la transferencia de datos. Si has aprendido las dos secciones anteriores sobre TCP, antes de la transmisión primero se inicia el servidor, se llama a accept, se espera la conexión del cliente, luego se obtiene el socket del cliente y se realizan operaciones de IO. En cambio, UDP no lo necesita. UDP utiliza datagramas como medio de transmisión de datos. Al transmitir, primero se deben definir los datos a transmitir como un datagrama (Datagram), indicando en el datagrama el Socket al que deben llegar los datos (dirección del host y número de puerto), y luego se envían los datos en forma de datagrama. Y luego no hay más; no sé si el servidor lo recibe o no, a menos que el servidor, después de recibirlo, me devuelva un datagrama de confirmación. Debido al tiempo, no escribiré un ejemplo de Android aparte; directamente iré al código Java.
1. Pasos de implementación del servidor:
Step 1: Crear DatagramSocket, especificar el número de puerto
Step 2: Crear DatagramPacket
Step 3: Recibir los datos enviados por el cliente
Step 4: Leer los datos
Código de ejemplo:
public class UPDServer {
public static void main(String[] args) throws IOException {
/*
* 接收客户端发送的数据
*/
// 1.创建服务器端DatagramSocket,指定端口
DatagramSocket socket = new DatagramSocket(12345);
// 2.创建数据报,用于接收客户端发送的数据
byte[] data = new byte[1024];// 创建字节数组,指定接收的数据包的大小
DatagramPacket packet = new DatagramPacket(data, data.length);
// 3.接收客户端发送的数据
System.out.println("****服务器端已经启动,等待客户端发送数据");
socket.receive(packet);// 此方法在接收到数据报之前会一直阻塞
// 4.读取数据
String info = new String(data, 0, packet.getLength());
System.out.println("我是服务器,客户端说:" + info);
/*
* 向客户端响应数据
*/
// 1.定义客户端的地址、端口号、数据
InetAddress address = packet.getAddress();
int port = packet.getPort();
byte[] data2 = "欢迎您!".getBytes();
// 2.创建数据报,包含响应的数据信息
DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
// 3.响应客户端
socket.send(packet2);
// 4.关闭资源
socket.close();
}
}
2. Pasos de implementación del cliente:
Step 1: Definir la información a enviar
Step 2: Crear DatagramPacket, que contiene la información que se va a enviar
Step 3: Crear DatagramSocket
Step 4: Enviar datos
public class UDPClient {
public static void main(String[] args) throws IOException {
/*
* 向服务器端发送数据
*/
// 1.定义服务器的地址、端口号、数据
InetAddress address = InetAddress.getByName("localhost");
int port = 8800;
byte[] data = "用户名:admin;密码:123".getBytes();
// 2.创建数据报,包含发送的数据信息
DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
// 3.创建DatagramSocket对象
DatagramSocket socket = new DatagramSocket();
// 4.向服务器端发送数据报
socket.send(packet);
/*
* 接收服务器端响应的数据
*/
// 1.创建数据报,用于接收服务器端响应的数据
byte[] data2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
// 2.接收服务器响应的数据
socket.receive(packet2);
// 3.读取数据
String reply = new String(data2, 0, packet2.getLength());
System.out.println("我是客户端,服务器说:" + reply);
// 4.关闭资源
socket.close();
}
}
Resumen de esta sección:
Step 1: Definir la información a enviar
Step 2: Crear DatagramPacket, que contiene la información que se va a enviar
Step 3: Crear DatagramSocket
Step 4: Enviar datos
El contenido de esta sección es relativamente simple; no es más que convertir los datos en bytes y luego ponerlosDatagramPacket(en el paquete de datagramas). Al enviar, se incluye la dirección IP y el número de puerto del destinatario; al recibir, se utiliza un arreglo de bytes como búfer. Al enviar, es necesario crear unDatagramSocketobjeto (de la clase de comunicación de extremo a extremo), y luego llamar al método send para enviar el paquete de datagramas al destinatario. El código de esta sección proviene de un tutorial de Java Socket en el sitio web Muke. Si te interesa, puedes echarle un vistazo:Aplicación de Java Socket: así se practica la comunicación