0votos

Programacion Distribuida en Java

por josejuan hace 3 meses

Hay muchas formas de hacer RPC, en java RMI, EJB, messaging, ... serían los canónicos, pero suelen requerir de configuraciń específica (rmi, app server, mqs, ...); por lo que para aplicaciones simples suele mejor algo adhoc. Kryonet permite hacer RPC de forma simple.

Desarrollar una aplicación en java donde se tenga un Cronometro con un hilo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package foo.bar; 
 
import com.esotericsoftware.kryonet.Client; 
import com.esotericsoftware.kryonet.Connection; 
import com.esotericsoftware.kryonet.Listener; 
import com.esotericsoftware.kryonet.Server; 
import com.esotericsoftware.minlog.Log; 
 
import java.io.IOException; 
 
import static com.esotericsoftware.minlog.Log.LEVEL_NONE; 
 
 
public class Main { 
    public static void main(final String... args) throws IOException, InterruptedException { 
        Log.set(LEVEL_NONE); 
        if (args.length < 2) 
            usage(); 
        else { 
            final int port = Integer.parseInt(args[0]); 
            switch (args[1]) { 
                case "client": 
                    if (args.length != 4) 
                        usage(); 
                    else 
                        runClient(port, Integer.parseInt(args[2]), args[3]); 
                    break; 
                case "server": 
                    runServer(port); 
                    break; 
                default: 
                    throw new IllegalArgumentException(); 
 
    private static void runServer(int port) throws IOException { 
        final Server server = new Server(); 
        server.bind(port); 
        server.addListener(new Listener() { 
            @Override 
            public void received(Connection connection, Object o) { 
                super.received(connection, o); 
                System.out.printf("Server received: %s%n", o); 
        }); 
        server.start(); 
 
        System.out.printf("Server running...%n"); 
        System.in.read(); 
        server.stop(); 
        System.out.printf("Server terminado.%n"); 
 
    private static void runClient(int port, int seconds, String message) throws IOException, InterruptedException { 
        final Thread thread = new Thread(() -> { 
            try { 
                Thread.sleep(1000 * seconds); 
 
                final Client client = new Client(); 
                client.start(); 
                client.connect(5000, "127.0.0.1", port); 
                client.sendTCP(message); 
                client.close(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
                Thread.interrupted(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
        }); 
        thread.start(); 
 
        System.out.printf("Cliente '%s' esperando %d segundos...%n", message, seconds); 
        while (thread.isAlive()) { 
            // hace algo aquí 
            Thread.sleep(100); 
        System.out.printf("Cliente '%s' terminado.%n", message); 
 
    private static void usage() { 
        System.err.printf("usage: rmiexample <port> [ client <seconds> <message> | server ]%n"); 
 
 
/* 
Tras compilar y ejecutar obtenemos: 
 
[josejuan@centella rmiexample]$ ( sleep 1; for i in `seq 1 5`; do java -jar rmi.jar 9181 client $((1+RANDOM%10)) "MESSAGE #$i" & done ) & java -jar rmi.jar 9181 server 
Server running... 
Cliente 'MESSAGE #2' esperando 10 segundos... 
Cliente 'MESSAGE #1' esperando 2 segundos... 
Cliente 'MESSAGE #3' esperando 7 segundos... 
Cliente 'MESSAGE #5' esperando 2 segundos... 
Cliente 'MESSAGE #4' esperando 7 segundos... 
Server received: MESSAGE #1 
Server received: MESSAGE #5 
Cliente 'MESSAGE #1' terminado. 
Cliente 'MESSAGE #5' terminado. 
Server received: MESSAGE #3 
Server received: MESSAGE #4 
Cliente 'MESSAGE #3' terminado. 
Cliente 'MESSAGE #4' terminado. 
Server received: MESSAGE #2 
Cliente 'MESSAGE #2' terminado. 
 
Server terminado. 
 
*/ 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.