Si quieres que cada **productor** envíe mensajes exclusivamente a su **consumidor
asignado**, debes establecer una lógica de direccionamiento. Una opción elegante en
**Java** es usar un **mapa de asignación** en el servidor para garantizar que cada
mensaje llegue al destino correcto.
---
### **Código Mejorado**
Aquí está la versión optimizada, donde cada productor se enlaza con un consumidor
específico:
#### **1. Servidor de Sockets (Distribuye Mensajes)**
```java
import [Link].*;
import [Link].*;
import [Link].*;
public class SocketServer {
private static final Map<String, Socket> consumidores = new HashMap<>();
private static final Map<String, String> productorConsumidorMap = new
HashMap<>();
static {
// Estableciendo correspondencia entre productores y consumidores
[Link]("PRODUCTOR_1", "CONSUMIDOR_1");
[Link]("PRODUCTOR_2", "CONSUMIDOR_2");
}
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(5000)) {
[Link]("Servidor iniciado en el puerto 5000");
while (true) {
Socket socket = [Link]();
new Thread(() -> handleClient(socket)).start();
}
} catch (IOException e) {
[Link]();
}
}
private static void handleClient(Socket socket) {
try (BufferedReader in = new BufferedReader(new
InputStreamReader([Link]()));
PrintWriter out = new PrintWriter([Link](), true)) {
String identificador = [Link](); // Recibe el ID (productor o
consumidor)
if ([Link]("CONSUMIDOR_")) {
[Link](identificador, socket);
[Link]("Registrado como consumidor " + identificador);
} else if ([Link]("PRODUCTOR_")) {
String destinatario = [Link](identificador);
String mensaje = [Link](); // Recibe el mensaje
if (destinatario != null && [Link](destinatario))
{
PrintWriter consumidorOut = new
PrintWriter([Link](destinatario).getOutputStream(), true);
[Link]("Mensaje de " + identificador + ": " +
mensaje);
} else {
[Link]("Consumidor no disponible.");
}
}
} catch (IOException e) {
[Link]();
}
}
}
```
---
### **2. Productores (Envían Mensajes)**
```java
import [Link].*;
import [Link].*;
public class Productor {
public static void main(String[] args) {
enviarMensaje("PRODUCTOR_1", "Pago recibido por Cliente 1!");
enviarMensaje("PRODUCTOR_2", "Pago procesado para Cliente 2!");
}
public static void enviarMensaje(String productorId, String mensaje) {
try (Socket socket = new Socket("localhost", 5000);
PrintWriter out = new PrintWriter([Link](), true)) {
[Link](productorId); // Identificación del productor
[Link](mensaje); // Mensaje
} catch (IOException e) {
[Link]();
}
}
}
```
---
### **3. Consumidores (Reciben Mensajes)**
```java
import [Link].*;
import [Link].*;
public class Consumidor {
public static void main(String[] args) {
recibirMensaje("CONSUMIDOR_1");
recibirMensaje("CONSUMIDOR_2");
}
public static void recibirMensaje(String consumidorId) {
try (Socket socket = new Socket("localhost", 5000);
PrintWriter out = new PrintWriter([Link](), true);
BufferedReader in = new BufferedReader(new
InputStreamReader([Link]()))) {
[Link](consumidorId); // Registrarse como consumidor
[Link]("Esperando mensajes en " + consumidorId + "...");
while (true) {
[Link]("Recibido: " + [Link]());
}
} catch (IOException e) {
[Link]();
}
}
}
```
---
### **🔹 ¿Cómo Funciona?**
✔ **Mapa de asignación (`productorConsumidorMap`)** define la correspondencia entre
productores y consumidores.
✔ **El servidor de sockets** dirige los mensajes basándose en este mapa.
✔ **Cada productor solo envía mensajes a su consumidor asignado**.
✔ **Los consumidores reciben los mensajes que les corresponden**.
Así garantizamos que cada mensaje llega **exclusivamente** a su destinatario
correcto sin interferencias. ¿Te gustaría ver cómo podríamos mejorar esto con
RabbitMQ o WebSockets? 😏
---------------------------------------
Sí, este código es completamente compatible con **Java 8** y no requiere
dependencias adicionales como Maven. Todo se basa en clases estándar de `[Link]`
y `[Link]`, que vienen integradas con el **JDK**.
### **Consideraciones para Java 8**
✔ **No necesitas ninguna librería externa**, solo el JDK.
✔ **No usa anotaciones modernas como `@FunctionalInterface` o Streams**, lo cual
asegura compatibilidad con Java 8 puro.
✔ **Puede ejecutarse con `javac` y `java` desde consola** sin necesidad de ningún
gestor de dependencias.
### **Cómo Ejecutarlo**
1. Guarda cada clase en archivos separados (`[Link]`, `[Link]`,
`[Link]`).
2. Compila los archivos con:
```bash
javac [Link] [Link] [Link]
```
3. Ejecuta primero el servidor:
```bash
java SocketServer
```
4. Luego, inicia los productores y consumidores en **ventanas separadas**:
```bash
java Productor
java Consumidor
```
¿Quieres que optimicemos algo más en el código para un despliegue más estructurado?
😏