Voy a explicar TCP:
El concepto básico es que debe ejecutar un "Servidor" en una máquina. Ese servidor acepta clientes que esperan una conexión. Cada conexión pasa por un puerto (ya sabes, espero ...).
Siempre use los puertos por encima de 1024 debido a los puertos inferiores a 1025 son la mayor parte del tiempo reservado para protocolos estándar (como HTTP (80), FTP (21), Telnet, ...)
Sin embargo, la creación de un servidor en Java se hace de esta manera:
ServerSocket server = new ServerSocket(8888); // 8888 is the port the server will listen on.
"Socket" es la palabra que probablemente esté buscando si quiere investigar.
Y para conectar su cliente a un servidor que tiene que escribir esto:
Socket connectionToTheServer = new Socket("localhost", 8888); // First param: server-address, Second: the port
Pero ahora, no existe todavía una conexión.El servidor tiene que aceptar al cliente en espera (como noté aquí arriba):
Socket connectionToTheClient = server.accept();
¡Hecho! ¡Tu conexión está establecida! La comunicación es como File-IO. Lo único que debe tener en cuenta es que debe decidir cuándo quiere vaciar el búfer y realmente enviar los datos a través del zócalo.
El uso de un PrintStream para el texto-escritura es muy práctico:
OutputStream out = yourSocketHere.getOutputStream();
PrintStream ps = new PrintStream(out, true); // Second param: auto-flush on write = true
ps.println("Hello, Other side of the connection!");
// Now, you don't have to flush it, because of the auto-flush flag we turned on.
Un BufferedReader para el texto, la lectura es la buena (mejor *) Opción:
InputStream in = yourSocketHere.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line = br.readLine();
System.out.println(line); // Prints "Hello, Other side of the connection!", in this example (if this would be the other side of the connection.
Esperamos que usted puede comenzar con la creación de redes con esta ¡información!
PD: Por supuesto, todo el código de red debe ser try-catched para IOExceptions.
EDIT: Olvidé escribir por qué no siempre es la mejor opción. Un BufferedReader utiliza un búfer y lee todo lo que puede en el búfer. Pero a veces no quiere que el BufferedReader robe los bytes después de la nueva línea y los coloque en su propio búfer.
ejemplo corto:
InputStream in = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
// The other side says hello:
String text = br.readLine();
// For whatever reason, you want to read one single byte from the stream,
// That single byte, just after the newline:
byte b = (byte) in.read();
Pero el BufferedReader ya tiene ese byte, que desea leer, en su memoria intermedia. Entonces, al llamar al in.read() se devolverá el siguiente byte en el último byte en el búfer del lector.
Por lo tanto, en esta situación, la mejor solución es usar DataInputStream y administrarlo a su manera para saber cuánto tiempo va a ser la cadena y leer solo ese número de bytes y convertirlos en una cadena. O: Se utiliza
DataInputStream.readLine()
Este método no utiliza un búfer y lee byte a byte y comprueba si hay una nueva línea. Entonces este método no roba los bytes del InputStream subyacente.
EDIT: Usted puede desarrollar su propio protocolo en el que se puede solicitar una llamada al método utilizando Java reflexión. Por ejemplo:
String className = ...;
String methodName = ...;
Class[] methodParamTypes = ...;
Object[] methodParams = ...;
Class cl = Class.forName(className);
Method me = cl.getDelcaredMethod(methodName, methodParamTypes);
Object returnValue = me.invoke(this, methodParams);
vez que tenga su objeto lo puede enviar al otro lado de la conexión con la serialización: ObjectOuputStreams y ObjectInputStreams. Con estas dos clases, puede escribir y leer objetos a través de una secuencia.
Object obj = ...; // Your object you want to write through the stream. (Needs to implement java.io.Serializable)
ObjectOutputStream oos = new ObjectOuptputStream(socket.getOutputStream());
oos.writeObject(oos);
oos.reset(); // (***)
// Don't close it! Otherwise the connection will be closed as well.
Y en el otro lado de la conexión:
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Object object = ois.readObject(); // Read the object
// Don't close it!
// Then cast it to whatever you want.
(***): Salida my question para más información sobre reset() y cuándo usarlo.
Iba a sugerir probar el enfoque JMS Producer/Consumer, pero quiere algo sencillo. –