Atividade de Laboratório - JavaSpaces

As instruções abaixo descrevem como criar programas que compartilhem memória utilizando o JavaSpaces.

Será utilizada a implementação do JavaSpaces do Jini, que pode ser baixada aqui.

Será utilizada uma classe auxiliar para conectar ao serviço JavaSpace, que pode ser baixada aqui.

Definindo o Formato das Mensagens

Os objetos publicados no espaço de tuplas devem implementar a interface net.jini.core.entry.Entry. A classe abaixo, que contém apenas um atributo do tipo String, será usada no exemplo. Outros atributos e métodos podem ser definidos, caso necessário.

import net.jini.core.entry.Entry;

public class Message implements Entry {
    public String content;

    public Message() {
    }
}

Escrevendo no Espaço de Tuplas

A classe abaixo cria uma caixa de diálogo na qual podem ser digitadas mensagens que serão escritas no espaço de tuplas. O tempo de vida das mensagens é de um minuto. 

import net.jini.space.JavaSpace;
import java.util.Scanner;

public class WriteMessage {

    public static void main(String[] args) {
        try {
            System.out.println("Procurando pelo serviço JavaSpace...");
            Lookup finder = new Lookup(JavaSpace.class);
            JavaSpace space = (JavaSpace) finder.getService();
            if (space == null) {
                    System.out.println("O serviço JavaSpace não foi encontrado. Encerrando...");
                    System.exit(-1);
            } 
            System.out.println("O serviço JavaSpace foi encontrado.");
            
            Scanner scanner = new Scanner(System.in);

            while (true) {
                System.out.print("Entre com o texto da mensagem (ENTER para sair): ");
                String message = scanner.nextLine();
                if (message == null || message.equals("")) {
                    System.exit(0);
                }
                Message msg = new Message();
                msg.content = message;
                space.write(msg, null, 60 * 1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Lendo Mensagens do Espaço de Tuplas

A classe abaixo remove mensagens escritas no espaço de tuplas e as imprime na tela. O tempo de espera máximo é de um minuto. 

import net.jini.space.JavaSpace;

public class ReadMessage {

    public static void main(String[] args) {
        try {
            System.out.println("Procurando pelo serviço JavaSpace...");
            Lookup finder = new Lookup(JavaSpace.class);
            JavaSpace space = (JavaSpace) finder.getService();
            if (space == null) {
                    System.out.println("O serviço JavaSpace não foi encontrado. Encerrando...");
                    System.exit(-1);
            } 
            System.out.println("O serviço JavaSpace foi encontrado.");

            while (true) {
                Message template = new Message();
                Message msg = (Message) space.take(template, null, 60 * 1000);
                if (msg == null) {
                    System.out.println("Tempo de espera esgotado. Encerrando...");
                    System.exit(0);
                }
                System.out.println("Mensagem recebida: "+ msg.content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Compilando e Executando a Aplicação

Primeiramente você deve se certificar de que os serviços do Jini estejam em execução. No Windows isso é feito executando o comando:

> <jini-path>\installverify\support\launch-all.exe

onde <jini-path> é o local de instalação do Jini.

Caso esteja usando uma IDE, adicione as seguintes bibliotecas ao projeto:

<jini-path>/lib/jini-core.jar
<jini-path>/lib/jini-ext.jar
<jini-path>/lib/reggie.jar
<jini-path>/lib/outrigger.jar

Feito isso, basta compilar o projeto, executar primeiramente a classe ReadMessage, em seguida executar a classe WriteMessage e entrar com as mensagens de texto que serão enviadas para o espaço de tuplas.

Se preferir executar o programa em linha de comando, vá até o local no qual foram salvos os códigos acima e execute o compilador Java, especificando as bibliotecas do Jini no Classpath::

> javac -cp <jini-path>/lib/jini-core.jar;<jini-path>/lib/jini-ext.jar;<jini-path>/lib/reggie.jar;<jini-path>/lib/outrigger.jar *.java

Em seguida, execute a classe ReadMessage em uma nova janela com o comando:

> start java -cp <jini-path>/lib/jini-core.jar;<jini-path>/lib/jini-ext.jar;<jini-path>/lib/reggie.jar;<jini-path>/lib/outrigger.jar;. ReadMessage

Por fim, execute a classe WriteMessage e escreva mensagens de texto que serão enviadas para o espaço de tuplas:

> java -cp <jini-path>/lib/jini-core.jar;<jini-path>/lib/jini-ext.jar;<jini-path>/lib/reggie.jar;<jini-path>/lib/outrigger.jar;. WriteMessage