Modelo de mensagens de aglets

A comunicação entre aglets se dá por troca de mensagens. A recepção de uma mensagem por um aglet é especificada através do método handleMessage():

    public class MyAglet extends Aglet {
        public boolean handleMessage(Message msg) {
            if (msg.sameKind("doJob")) {
                doJob();
            } else if (msg.sameKind("shutdown")) {
                deactivate(0);
            }
        }
    }

O argumento para o método é um objeto da classe Message, que em sua criação recebe como argumento uma string que pode ser verificada na manipulação da mensagem através do método sameKind().

O handler pode enviar qualquer valor ou objeto como retorno para quem enviou originalmente a mensagem, usando para tanto o o método Message.sendReply(). Este método pode ser enviado uma única vez no corpo do tratamento da mensagem:

    public boolean handleMessage(Message msg) {
        if (msg.sameKind("accessDB")) {
            openDB();
            Object reply = accessDB(msg.getArg());
            msg.sendReply(reply);
            closeDB();
            return true; // i know this message...
        }
        return false; // otherwise
    }
    

Mensagens podem ser criadas com algum valor associado; há construtores para receber um valor de cada tipo básico da linguagem Java ou um Object. O método getArg() permite extrair esse valor da mensagem em seu tratamento.

O valor de retorno de handleMessage() indica se a mensagem foi ou não manipulada com sucesso pelo método handler. Caso esse valor seja falso, a exceção NotHandledException é gerada para quem originou a mensagem.

Mensagens não são enviadas diretamente para um aglet, mas sim para um objeto proxy correspondente. Um proxy é um escudo de proteção para um aglet, de forma que para interagir com o aglet o proxy deve ser inicialmente obtido:

    AgletProxy proxy = outroAglet.getProxy();
    

Outra forma de obter proxies para os aglets em um lugar é através do método getAgletProxies() da interface AgletContext(), que retorna uma enumeração de proxies de aglets no estado especificado:

    Enumeration proxies = 
      this.getAgletContext().getAgletProxies(ACTIVE | INACTIVE);
    proxy = (AgletProxy) proxies.nextElement();
    

A partir da referência para o proxy, há diversas possibilidades de envio que correspondem à invocação de diferentes métodos para a transmissão da mensagem:

now-type

Mensagem do tipo síncrona, que bloqueia a execução da thread corrente até que o receptor tenha completado a manipulação da mensagem:

     String answer = proxy.sendMessage(new Message("question"));
     System.out.println(answer);
	

O valor de retorno é o objeto retornado pelo aglet endereçado em resposta à mensagem enviada.

future-type

Mensagem assíncrona, não bloqueia execução corrente. O objeto da classe FutureReply que é retornado pode ser utilizado para obter o resultado da troca de mensagem posteriormente:

     FutureReply future =
         proxy.sendAsyncMessage(new Message("question"));
     int num_task = 10;
     // executa uma tarefa até 10 vezes antes de esperar resposta
     while(future.isAvailable() == false && num_task-- >0) {
         doPrivateJob();
     }
     System.out.println( (String)future.getReply() );
	

oneway-type

Mensagem assíncrona, que não bloqueia a execução corrente e não aguarda nenhum retorno da mensagem:

       proxy.sendOnewayMessage(new Message("question"));