Código fuente aceptado
Servidor:
Importar Java.io.*;
Importar Java.net.*;
Importar Java.util.* ;
Clase pública ChatServer {
booleano iniciado = false
ServerSocket ss = null
List & ltclients & gtclients = new ArrayList & ltClient& 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 exit(0);
} catch. (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
prueba {
dis = nuevo flujo de entrada de datos(s. getinputstream ());
dos = nuevo flujo de salida de datos(s. obtener flujo de salida());
bConnected = true
} catch (IOException e) {
e . printstacktrace();
}
}
envío público vacío (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); i++) {
cliente c = clientes . get(I);
enviar(cadena);
}
}
} 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 . evento
. *;
Importar Java .io *;
Importar Java net *. >Socket s = null
DataOutputStream dos = null
DataInputStream dis = null
privado booleano b conectado = false;
TextField TF txt = new TextField();
TextArea taContent = new TextArea();
Subproceso tRecv = new Thread(new RecvThread());
público estático void main(String[] args) {
Nuevo ChatClient(). 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 pública vacía cerrando(evento de ventana arg 0){
desconectar();
sistema de salida(0);
}
}) ;
TF txt . addactionlistener(nuevo oyente TF());
establecer visible(true); >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() {
Pruebe {
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 ');
}
} captura (SocketException e) {
System.out.println("¡Adiós!");
} captura ( IOException e) {
e . printstacktrace();
}
}
}
}