USANDO DESIGN PATTERN (PADRÃO DE PROJETO)
PARA CALLBACK

Resumo: O papel de um objeto-servidor é frequentemente realizar alguma lógica de negócio que 
não pode ser realizada por um objeto-cliente. Assumindo que este processamento toma um tempo 
significativo para ser executado, um cliente pode não ser hábil pra simplesmente esperar por 
um método de requisição do servidor (ou seja, a execução da resposta do servidor) completar.

Como Uma alternativa, o objeto-servidor pode imediatamente retornar "void", a partir de um 
método de "request" que realiza os cálculos em uma única thread, e então passar os resultados ao 
cliente quando pronto.

Problema:  É comum para um objeto-cliente requerer algum dado do servidor.
Assumindo que o processamento somente toma um segundo ou dois, o cliente necessita não se preocupar 
com ele próprio, quanto ao tempo de processamento envolvido. Se, contudo, o processamento do servidor tomar 
10, 15, 120 ou mais segundos, o cliente poderia finalizar a espera demais longa para um método retornar algum valor.
Tendo o cliente que esperar o valor de retorno demais longo, causa threads no cliente bloquear, o que é obviamente uma 
situação não desejável. Adicionalmente, dependendo da tecnologia usada para computação distribuída, um timeout
poderia ocorrer, se o objeto-servidor leva tempo demais longo para retornar um valor requisitdado pelo objeto-cliente.

Contexto: O design pattern se aplica em qualquer ambiente onde o processamento do servidor, em resposta ao 
"request" do cliente, levará uma extrema quantidade de tempo.

Exemplo de Aplicação: A programação que uma operadora de telefonia tem para o despertador automático.
Quando uma solicitação chega ao sistema de despertador automático, uma programação é registrada e uma resposta,
"Sua programação foi aceita e será atendida, amanhã, às 05.00 horas ..." é emitida, para avisar ao cliente da operadora
o momento requisitado.

Solução:  A função do design pattern do Callback permitirá o cliente emitir um "request" ao servidor e então
ter o servidor de registrar o pedido do serviço, mas sem imediatamente processar o "request". O objeto-servidor, então, 
processa o pedido, e passa os resultados, com "certo atraso" ao objeto-cliente, no moneto que este requistou o serviço.
Por exemplo, o telefone toca às 05.00 h da manhã.

Design Pattern:

/**
* A classe CallbackClient se ligará (bind) a um objeto-servidor
* o qual processará um pedido, e então
* responderá o resultado, quando entregue pelo objeto-servidor.
*/
public final class CallbackClient {

    public CallbackClient {
        CallbackServer server = // bind to server
        server.<nome do método do servidor chamado para os serviço de callback> (parâmetros);
    }
    /**
     * Esta parte é invocada pelo objeto-servidor quando a resposta da invocação remota do método acima referido e encontrada.
     * Aceita um "long object" e não um "long base-type" para permitir a passagem de um valor "null", se for impossivel o 
     * "request" ser processado e retornado o valor desejado.
    */
    public void <nome do método que tratará a resposta do objeto-servidor> (Long lValue) {
        if (lValue == null) System.out.println ("programação não executada, nenhuma respota lhe será remetida");
        else System.out.println("O telefone do usuário tocará e uma mensagem lh será emitida");
    }
}


/** A classe CalbackServer realiza o serviço.
 * Desde que a resposta do processamento não deve vir imediatamente, clientes não requerem esperar
 * para um valor retornado. Ao invés disto, a classe CallbackServer notificará o cliente quando o valor de retorno 
 * tenha sido processado. Todos os "requests" são realizados em uma unica thread para permitir um processamento de 
 * informação máximo".
*/
public final CallbackServer {
    public CallbackServer() {
    }

    public void <nome do método do servidor chamado para os serviço de callback> (long lBase, CallbackClient client) {
         CallbackProcessor processor = new CallbackProcessor (lBase, client);
         processor.start();
         // imediatamente retorna
    }
    /**
     * Classe interna usada para processar "requests" em uma única thread.
    */
    class CallbackProcessor extends Thread {
        private long           _lBase;
        private CallbackClient _Client;

        public CallbackProcessor (long lBase, CallbackClient client) {
             _lBase = lBase;
             _client = client;

        }
    
        
        public void run() {
              long lFoundValue = // leva uma porção de tempo para processar o pedido no tempo programado
              _client.<nome do método que tratará a resposta do objeto-servidor> (new Long(lFoundValue));
        }
    }
}


Usar Java RMI para implementar o caso do serviço de despertador automático. Programe o relógio como achar melhor.
Você pode simplesmente usar variáveis para simular um relógio que marcará o tempo no servidor para a execução do serviço.
Ou pode até usar o relógio do processador do seu computador, se souber como se usa este.

Prazo Final:  Terça-feira, 04 de Julho (sem adiamento, pois já terei que fazer as notas).

Nota:  As notas da segunda prova, só serão fornecidas, após a entrega desta tarefa.