Tabla de contenido
1. Prefacio: Introducción a los principios del PCT
Dos, comunicación de programación de socket
3. Lado del servidor TCP (código específico)
Cuatro, cliente TCP (código específico)
5. Demostración del efecto de comunicación
6. Robot "creativo": código central AI (código específico) por valor de 100 millones
Cero, 1024 regalos especiales
1024, 1GB, genial, ¡vamos!
1. Prefacio: Introducción a los principios del PCT
En primer lugar, para garantizar la integridad del artículo, los principios teóricos de TCP aún deben ser resumidos, lo cual es un poco aburrido.
TCP (Protocolo de control de transmisión, Protocolo de control de transmisión) es un protocolo de comunicación de capa de transporte confiable, orientado a la conexión y basado en flujo de bytes . TCP está diseñado para adaptarse a la jerarquía de protocolos en capas que admite múltiples aplicaciones de red. En otras palabras, TCP es un protocolo de transmisión especialmente diseñado para proporcionar flujos de bytes confiables de extremo a extremo en redes de Internet no confiables . Los procesos emparejados en computadoras host conectadas a redes de comunicación de computadoras diferentes pero interconectadas se basan en TCP para proporcionar servicios de comunicación confiables.
Las características anteriores de TCP son también las diferencias obvias de UDP. UDP (User Datagram Protocol) es un protocolo de comunicación no confiable y sin conexión que no transmite flujos de bytes . Las diferencias específicas se pueden comparar con el artículo anterior:
[ Programación de Network Socket basada en el protocolo UDP (caso de comunicación C / S en java) ] [ https://blog.csdn.net/Charzous/article/details/109016215 ]
A continuación, el "protocolo de enlace de tres vías" es una palabra bien conocida y un proceso importante para establecer una conexión TCP. Muchos artículos tienen interpretaciones detalladas, y este artículo es un registro detallado de este principio, utilizando Java para lograr la comunicación de red TCP Socket, incluida la programación de la arquitectura de software C / S, sesgada a la práctica, ¡y más interesante!
Dos, comunicación de programación de socket
Este artículo utiliza Java para la programación de sockets. La programación de sockets TCP / IP de Java encapsula los detalles subyacentes. El modelo de programación se muestra en la figura:
Observamos de arriba a abajo, la comunicación basada en TCP debe tener un servidor servidor y un cliente cliente.
Primero, establezca una conexión . Hay un enchufe hembra en cada extremo para la comunicación entre los dos. El cliente envía una solicitud al servidor para crear un socket para conectarse. El servidor monitorea la solicitud iniciada por el cliente en cualquier momento, recibe y crea un Socket roto.
En segundo lugar, inicie la comunicación . Los flujos de entrada y salida del servicio y el cliente se comunican entre sí. Lógicamente, se puede entender que los dos lados del proceso de comunicación tienen dos flujos (flujo de salida y flujo de entrada). Lógicamente, dos flujos pueden entenderse como un modo de comunicación full-duplex de dos conductos de comunicación , uno se usa para enviar datos al otro lado y el otro se usa para recibir datos del otro lado.
Finalmente, finalice la comunicación . El cliente finaliza al acceder al servidor, se desconecta, cierra Socket y los recursos relacionados (flujos de entrada y salida, etc.). El servidor monitorea el estado del cliente y cierra conexiones como Socket.
Establece reglas de comunicación:
El servidor y el cliente deben acordar las mismas reglas para garantizar una comunicación normal. Después del diseño del programa, acordamos:
-
El cliente se conecta al servidor. Después de que la conexión es exitosa, el servidor primero envía un mensaje de bienvenida al cliente;
-
Cada vez que el programa del cliente envía una información al servidor, el servidor recibe y envía la información al cliente, y el cliente recibe y muestra la información;
-
Cuando el cliente envía "adiós", la conversación termina.
3. Lado del servidor TCP (código específico)
El primer paso es crear un socket de servidor.
Variables de miembro de clase: ServerSocket serverSocket, monitor de número de puerto puerto;
private int port =8008;//服务器监听窗口
private ServerSocket serverSocket;//定义服务器套接字
public TCPServer() throws IOException{
serverSocket =new ServerSocket(port);
System.out.println("服务器启动监听在"+port+"端口...");
}El segundo paso es definir el método de flujo de entrada y salida:
private PrintWriter getWriter(Socket socket) throws IOException{
//获得输出流缓冲区的地址
OutputStream socketOut=socket.getOutputStream();
//网络流写出需要使用flush，这里在printWriter构造方法直接设置为自动flush
return new PrintWriter(new OutputStreamWriter(socketOut,"utf-8"),true);
}
private BufferedReader getReader(Socket socket) throws IOException{
//获得输入流缓冲区的地址
InputStream socketIn=socket.getInputStream();
return new BufferedReader(new InputStreamReader(socketIn,"utf-8"));
}El tercer paso, el núcleo del servidor:
//单客户版本，每次只能与一个用户建立通信连接
public void Service(){
while (true){
Socket socket=null;
try {
//此处程序阻塞，监听并等待用户发起连接，有连接请求就生成一个套接字
socket=serverSocket.accept();
//本地服务器控制台显示客户连接的用户信息
System.out.println("New connection accepted:"+socket.getInetAddress());
BufferedReader br=getReader(socket);//字符串输入流
PrintWriter pw=getWriter(socket);//字符串输出流
pw.println("来自服务器消息：欢迎使用本服务！");
String msg=null;
//此处程序阻塞，每次从输入流中读入一行字符串
while ((msg=br.readLine())!=null){
//如果用户发送信息为”bye“，就结束通信
if(msg.equals("bye")){
pw.println("来自服务器消息：服务器断开连接，结束服务！");
System.out.println("客户端离开。");
break;
}
pw.println("来自服务器消息："+msg);
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if (socket!=null)
socket.close();//关闭socket连接以及相关的输入输出流
}catch (IOException e){
e.printStackTrace();
}
}
}
}El análisis clave del código es muy claro y fácil de entender. Se puede ver que el servicio proporcionado por el servidor se coloca en un while (verdadero). Esto se debe a que el programa del servidor debe ejecutarse todo el tiempo, por lo que el código de procesamiento generalmente se coloca en un bucle infinito, como while (verdadero). El TCPServer se ejecuta una vez y no puede terminar por sí mismo. Ejecutar, para terminar su operación, solo se puede forzar a cerrar (por ejemplo, en el entorno IDE).
Cuatro, cliente TCP (código específico)
El primer paso es crear un conector de cliente, definir métodos de construcción de clases e implementar flujos de entrada y salida.
private Socket socket;
private PrintWriter pw;
private BufferedReader br;
public TCPClient(String ip, String port) throws IOException{
//主动向服务器发起连接，实现TCP三次握手
//不成功则抛出错误，由调用者处理错误
socket =new Socket(ip,Integer.parseInt(port));
//得到网络流输出字节流地址，并封装成网络输出字符流
OutputStream socketOut=socket.getOutputStream();
//参数true表示自动flush数据
pw=new PrintWriter(new OutputStreamWriter(socketOut,"utf-8"),true);
//得到网络输入字节流地址，并封装成网络输入字符流
InputStream socketIn=socket.getInputStream();
br=new BufferedReader(new InputStreamReader(socketIn,"utf-8"));
}El segundo paso es implementar métodos de envío y recepción de comunicaciones de red.
public void send(String msg){
//输出字符流，由socket调用系统底层函数，经网卡发送字节流
pw.println(msg);
}
public String receive(){
String msg=null;
try {
//从网络输入字符流中读取信息，每次只能接受一行信息
//不够一行时（无行结束符），该语句阻塞
//直到条件满足，程序往下运行
msg=br.readLine();
}catch (IOException e){
e.printStackTrace();
}
return msg;
}El tercer paso es definir un método para cerrar la conexión de red para llamadas externas.
public void close(){
try {
if (socket!=null)
socket.close();
}catch (IOException e){
e.printStackTrace();
}
}La liberación de una conexión TCP también tiene un "protocolo de enlace de cuatro vías", que debe liberarse después de 2MSL. El proceso específico es el siguiente:
5. Demostración del efecto de comunicación
Demostración de animación GIF:
6. Robot "creativo": código central AI (código específico) por valor de 100 millones
En esta parte, queremos implementar un "bot de chat" con el siguiente efecto:
¡No puedo esperar a saber cómo lograrlo! Se le puede llamar "código central de IA por valor de cien millones". ! ? ?
¡Eso es!
No lo venda, ¡solo una línea de código!
msg=msg.replace("?","!").replace("？","!").replace("吗","").replace("吗？","");Específicamente, si desea darse cuenta de cómo responde el robot, puede ajustar el código por sí mismo.
Siete, finalmente
Este artículo es un registro detallado de este principio, utilizando Java para lograr la comunicación de red TCP Socket, incluida la programación de la arquitectura de software C / S, práctica sesgada y más interesante. Los amigos que lean con atención pueden encontrar que en la parte central del lado del servidor, hay una línea de comentarios que indica que el programa solo admite comunicación de un solo usuario, es decir, de un solo subproceso. Puede probarlo. Si abre otro cliente para conectarse al servicio, ¿es debido al bloqueo de un solo subproceso El programa está atascado.
La clave de este problema radica en el hecho de que el servidor y el cliente acuerdan las reglas de comunicación entre sí; de lo contrario, puede haber problemas. Por ejemplo, si el servidor no envía un mensaje al cliente después de que la conexión del cliente es exitosa, el cliente lee la declaración del mensaje de bienvenida. Si el contenido no se puede leer, se bloqueará. Debido a que es un solo hilo, incluso todo el programa se bloqueará. Para resolver este problema, ¡espere la próxima actualización!
Además, el diseño de la interfaz de usuario puede consultar el blog anterior: [ Programación de sockets de red basada en el protocolo UDP (caso de comunicación C / S en Java) ] [ https://blog.csdn.net/Charzous/article/details/109016215 ]
Mi blog de CSDN: https://blog.csdn.net/Charzous/article/details/109260488