¿Qué tipo de proyecto podemos hacer en la programación de sockets Java?

Puede escribir un chat cliente / servidor de usuario múltiple / único. Lo hice como mi proyecto de semestre universitario. Le informaría sobre cómo puede lograr eso.

Para un cliente-servidor de chat multiusuario, tendría que escribir dos componentes:

1. Servidor
2. Cliente

Servidor

En el servidor, abriría un ServerSocket que sondearía las solicitudes entrantes de diferentes clientes en un bucle infinito y cada vez que se conecte un nuevo cliente, cree un nuevo hilo para escuchar a ese cliente en particular.

Servidor de clase {

inicio público vacío () {
int portNo = 8000;
ServerSocket ss = nuevo ServerSocket (portNo);
while (verdadero) {
Socket s = ss.accept (); // esto bloquea hasta que un nuevo cliente se conecta
ServerThread st = new ServerThread (this, s);
Hilo t = nuevo Hilo (st);
t.start ();
}
}

public static void main (String args) {
Servidor s = nuevo Servidor ();
s.start ();
}
}

La clase ServerThread implementa Runnable {

servidor servidor privado;
toma de corriente privada;

Public ServerThread (servidor del servidor, socket de socket) {
this.server = servidor;
this.socket = socket;
// establece InputStream y OutputStream
}
…
public void run () {
…
}
}

Ahora cada instancia de ServerThread tiene un socket que se comunica con un usuario de chat. Además, cada uno de estos sockets tendrá un InputStream y un OutputStream para leer y escribir desde y hacia el cliente. El cliente tendría un socket similar y flujos similares de modo que el flujo de salida del cliente se conecte al flujo de entrada del servidor y viceversa.

Ahora digamos que Alice y Bob quieren usar el sistema de chat. Su servidor tendría dos instancias de ServerThread, llamémoslas STA y STB , Sockets correspondientes, SA y SB y transmisiones como ISA, ISB, OSA y OSB .

Ahora, Alice quiere enviar un mensaje a Bob (¡Oh, Dios mío! No creo estar escribiendo estas palabras hoy, que he leído innumerables veces en los libros de redes).

El ISA dentro de SA (dentro de STA) puede leer el mensaje enviado por Alice. Esto es muy facil. Pero el problema es que el servidor tiene que enviar este mensaje a Bob, que requiere acceso a OSB dentro de SB (dentro de STB). Para tener acceso al OSB dentro de STA, la clase del servidor central debe intervenir. Es por eso que se pasa a cada instancia de servidor de ServerThread para que se produzca la comunicación.

Agreguemos un Mapa a la clase de servidor que almacena todos los usuarios ServerThread en la clase de Servidor.

Vea los cambios de código a continuación en negrita:

[código]

Servidor de clase {
Mapa privado srvThrds =
nuevo HashMap <>;

inicio público vacío () {
int portNo = 8000;
ServerSocket ss = nuevo ServerSocket (portNo);
while (verdadero) {
Socket s = ss.accept (); // esto bloquea hasta que un nuevo cliente se conecta
ServerThread st = new ServerThread (this, s);
Hilo t = nuevo Hilo (st);
t.start ();
}
}

public Map getUserThreads () {
return srvThrds;
}

public static void main (String args) {
Servidor s = nuevo Servidor ();
s.start ();
}
}

La clase ServerThread implementa Runnable {

servidor servidor privado;
toma de corriente privada;

Public ServerThread (servidor del servidor, socket de socket) {
this.server = servidor;
this.socket = socket;
// establece InputStream y OutputStream
Cadena uName = // solicitar nombre de usuario
server.getUserThreads (). put (uName, esto);
}
…
public void run () {
…
}
}

[/código]

Ahora, STA (Alice’s ServerThread) debe buscar OSB (Bob’s OutputStream) de la instancia del servidor y escribir en él. Hecho. Bob recibe el mensaje. Entonces ahora necesita completar el método de ejecución de la clase ServerThread:

[código]
La clase ServerThread implementa Runnable {
…
…
public void run () {
while (verdadero) {
// Esto es solo un código de demostración, no real
Mensaje de cadena = socket.getInputStream (). ReadNextMessage ();
// El mensaje incluye el nombre de usuario y el texto del destinatario separados por:
Cadena destinatario = getRecipient (mensaje); // método privado
Texto de cadena = getText (mensaje); // método privado
OutputStream os = server.getUserThreads ()
.get (destinatario) .getSocket ()
.getOutputStream ();

os.write (mensaje);
}
}
}
[/código]

Eh !! Hecho con el servidor (Por supuesto, sería defectuoso y sin los mejores amigos).

Cliente

En el cliente, debe ejecutar dos subprocesos, uno que sigue sondeando la entrada del usuario y lo envía, lo escribe en el servidor y el otro que sigue sondeando los mensajes entrantes y los imprime al usuario. Escribamos una clase de cliente de inicio.

clase Cliente {
toma de corriente privada;
cadena estática privada SERVER_ADDRESS = “localhost”;
int estático privado PORT = 8000;
Cliente público (Socket s) {
this.socket = s;
// establece InputStream y OutputStream
}
inicio público vacío () {
Socket s = nuevo Socket (SERVER_ADDRESS, PORT);
Cliente c = nuevo Cliente (s);
Escritor w = nuevo escritor (este);
Hilo tw = nuevo Hilo (w);
Lector r = nuevo Lector (este);
Hilo tr = nuevo Hilo (r);
tw.start ();
tr.start ();
}
}

class Writer implementa Runnable {

Cliente cliente privado;

Escritor público (cliente cliente) {
this.client = cliente;
}

public void run () {
while (verdadero) {
Cadena m = // leer mensaje del usuario
client.getSocket (). getOutputStream (). write (m);
}
}
}

class Reader implementa Runnable {

Cliente cliente privado;
Consola de consola privada;

Lector público (Cliente cliente) {
this.client = cliente;
this.console = Console.getConsole ();
}

public void run () {
while (verdadero) {
Cadena m = client.getSocket (). GetInputStream (). Read ();
console.write (m);
}
}
}

Feliz chat !!!!