Aceptar análisis de código fuente
Servidor:
Importar Java.io.*;
Importar Java.net.*;
Importar Java.util.* ;
Clase pública ChatServer {
booleano iniciado = false
ServerSocket ss = null
List lt cliente gtclients = nuevo cliente ArrayList lt gt();
Public static void main(String[] args) {
Nuevo ChatServer(). start();
}
public void start() {
Prueba {
ss = new server socket(8888);
Start=True;
} catch (BindException e) {
System.out.println("El puerto está en uso...");
System.out.println("¡Cierre los programas relacionados y vuelva a ejecutar el servidor!");
system . (IOException e) {
e . printstacktrace();
}
Prueba {
cuando(inicio){
socket s = ss . Accept();
Cliente c = nuevo cliente;
System.out.println("¡El cliente está conectado!");
Nuevo hilo(c).
start();
clientes . add(c);
}
} catch (IOException e) {
e. ();
}Finalmente {
prueba {
ss . close()
} catch (IOException e) {
e. printstacktrace();
}
}
}
El cliente de clase implementa Runnable {< / p>
Socket privado s;
DataInputStream privado dis = null
flujo de salida de datos privados dos = null;
booleano privado b conectado = false;
Cliente público (socket) {
this.s = s
try {
dis = nuevos datos inputstream(s . getinputstream ());
dos = nuevo flujo de salida de datos(s. obtener flujo de salida());
bConnected = true
} catch (IOException e) {
e . printstacktrace();
}
}
envío vacío público (String str) {
Pruebe {
dos .escribir utf(str);
} catch (IOException e) {
e .
}
}
Ejecución de anulación pública(){
intenta{
mientras(b conectado){
string str = dis . leer utf();
system out . println(str); for(int I = 0 ; i ltclients . size() ; i ) {
cliente c = clientes . /p>
} catch (EOFException e) {
System.out.println("¡El cliente está cerrado! ");
} catch (IOException e) {
e . printstacktrace();
}Finalmente {
intenta {
Si (dis!= null)dis . close();
Si (dos!= null)dos .close();
Si (s! = nulo) {
s . close();
//s = nulo
}
} captura (IOException e1; ) {
e 1. printstacktrace();
}
}
}
}
}
Cliente, abre dos y podrás chatear...
importar java.awt.*;
importar java.awt.event.*;
importar java.io.*;
importar java.net *;
La clase pública ChatClient extiende el marco {
Socket s = null
DataOutputStream dos = null
DataInputStream dis = null
privado booleano b conectado = falso;
TextField TF txt = new TextField();
TextArea taContent = new TextArea();
Subproceso tRecv = new Thread(new RecvThread());
Public static void main(String[] args) {
Nuevo cliente de chat(). marco de lanzamiento();
}
Marco de lanzamiento de vacío público() {
setLocation(400, 300);
this.setSize (300, 300);
add(tfTxt, BorderLayout. Sur);
add(taContent, BorderLayout.
Norte);
pack();
this . addwindowlistener(nuevo adaptador de ventana(){
@overlay
ventana vacía pública cerrando(evento de ventana arg 0){
desconectar();
sistema de salida(0);
}
}) ;
TF txt . addactionlistener(new TF listener());
establecer visible(true);
connect();
trecv .start();
}
public void connect() {
prueba{
s = nuevo socket(" 127.0.0.1 ", 8888);
dos = nuevo flujo de salida de datos(s. get output stream());
dis = nuevo flujo de entrada de datos(s. getinputstream()) ;
System.out.println("conectado!");
bConnected = true
} catch (UnknownHostException e) {
e . printstacktrace();
} captura (IOException e) {
e .
Desconexión de vacío público() {
Prueba {
dos . p>
p>
s . close();
} captura (IOException e) {
e . }
}
La clase privada TFListener implementa ActionListener {
acción de anulación pública realizada (evento de acción e){
String str = tfTxt .getText().
trim();
TF txt . settext(" ");
Intenta {
dos . >dos .flush();
} captura (IOException e1) {
e 1 . }
}
La clase privada RecvThread implementa Runnable {
Public void run(){
Prueba {
mientras(b está conectado){
string str = dis . read utf();
tacontent . settext(tacontent . gettext() str ' \ n '); p> p>
}
} captura (SocketException e) {
System.out.println("¡Adiós!");
} captura (IOException e) {
e . printstacktrace();
}
}
}
}