Invocação de Métodos Remotos - RMI, por Dayvid Lima

As aplicações do RMI compreendem frequentemente dois programas separados, um servidor e um cliente. Um programa servidor cria alguns objetos remotos, faz referência a esses objetos, e aguarda os "clients" invocarem os métodos desses objetos. Enquanto que um programa cliente obtém uma referência remota ao objetos criados pelo servidor e invoca os métodos desses objetos.

Entendendo o funcionamento

A seguinte ilustração descreve uma aplicação distribuída RMI que utiliza o "RMI registry" para obter uma referência a um objeto remoto. O servidor chama o "registry" para associar (bind) um nome com um objeto remoto. O cliente olha o objeto remoto por seu nome no "registry" do servidor, e invoca então um método nele. A ilustração mostra também que o sistema do RMI utiliza um web server existente para carregar definições da classe, do servidor ao cliente e do cliente ao servidor, para objetos quando necessário.

Criando aplicações distribuídas usando o RMI

Utilizar RMI para desenvolver uma aplicação distribuída envolve estas etapas gerais:
1 - Projetando e implementando os componentes de sua aplicação distribuída.
2 - Compilando o código fonte.
3 - Fazendo com que as classes sejam acessíveis via rede.
4 - Iniciando a aplicação.

1 - Projetando e implementando os componentes de sua aplicação distribuída.

Para nossa aplicação modelo iremos criar uma classe servidora que irá conter um método que será invocado remotamente através da utilização de RMI, para isso iremos precisar de alguns arquivos:
- Ola.java (interface que será implementada tanto pelo server quando pelo client)
- OlaImpl.java (implementação do servidor)
- Cliente.java (client que fará uso de métodos do OlaImpl - server)

Como sempre vamos aos códigos fontes, para esse as explicações serão inseridas na forma de comentários dentro dos próprios arquivos (assim pouparemos espaço aqui).

Ola.java
Interface que será utilizada tanto pelo servidor quanto pelo cliente, é necessária para fazer a integração de ambos.

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Ola extends Remote {
String showMsg(String msg) throws RemoteException;
}

OlaImpl.java
Classe que será acessada remotamente pelo Client.java

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class OlaImpl extends UnicastRemoteObject implements Ola {

    // precisamos definir um construtor pois o default não
    // gera RemoteException
    public OlaImpl() throws RemoteException {
        // opcional, vai ser chamado mesmo que não
        // o coloquemos aqui
        super();
    }

    public String showMsg(String msg) {
        // note que não tem o throws aqui.
        // A exceção é gerada pela super-classe se for o caso

        System.out.println("msg: " + msg);
        return("msg enviada");
    }

public static void main(String args[]) {

        try {
            // aqui criamos o objeto que sera acessado
            // remotamente
            OlaImpl obj = new OlaImpl();

            // Aqui registramos o objeto obj como "OlaServidor"
            // no servidor
            Naming.rebind("OlaServidor", obj);

            System.out.println("Servidor carregado no registry");
        } catch (Exception e) {
            System.out.println("OlaImpl erro: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Client.java
Classe que irá rodar do lado do cliente e utilizará o método "showMsg" da classe OlaImpl que estará rodando do lado do servidor.

import java.rmi.Naming;

public class Client {

    public static void main(String[] args) {

        /*
         * obj é o identificados que iremos utilizar para fazer
         * referencia ao objeto remoto que será implementado
         */
        Ola obj = null;

        String msg = "minha mensagem";
        String retorno = null;

        try {
            /*
             * - o lookup carrega o OlaImpl_Stub do CLASSPATH
            * - 127.0.0.1 é o IP da máquina onde o server
             * está rodando, no nosso caso é a mesma máquina
             * - OlaServidor é o nome que utilizamos para fazer
             * referencia ao objeto no servidor
             */

            // aqui instanciamos o objeto remoto
            obj = (Ola)Naming.lookup("//127.0.0.1/OlaServidor");

            // agora executamos o metoro showMsg no
            // objeto remoto
            retorno = obj.showMsg(msg);
            System.out.println(retorno);
        }
        catch (Exception e) {
            System.out.println("Client exception: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

2 - Compilando o código fonte.

Agora vamos compilar os códigos fonte, para isso basta digitar:
javac *.java

Além da compilação básica devemos criar uma classe do tipo Stub para a classe que será acessada remotamente, para criar essa classe devemos rodar o comando:
rmic OlaImpl

3 - Fazendo com que as classes sejam acessíveis via rede.

Para que as classes possam ser acessadas via rede, precisamos inicializar o servidor de rmi através do comando:
start rmiregistry (para linux/unix normalmente é somente rmiregistry)

4 - Iniciando a aplicação.

Agora vamos rodar nossa aplicação, vamos abrir dois prompts do DOS, no primeiro colocamos o server para rodar com o comando:
java OlaImpl

Com o servidor rodando vamos para a outra janela do DOS e rodamos o client com o comando:
java Client

Basicamente o que fizemos foi, criar um objeto chamado "OlaImpl" com um método chamado "showMsg" do lado do servidor, e do lado do cliente criamos um objeto chamado "Client" que instancia "OlaImpl" e executa o método "showMsg" via RMI.

Veja aqui alguns "screen shots" do Server e do Client rodando em minha máquina:

Server

Client

Essa é uma forma muito utilizada para criar aplicações distribuídas, embora esse artigo pareça simples, ele demonstra a base para esse tipo de comunicação.

Mais uma vez espero que tenham gostado do artigo e aproveito para agradecer a todos pelos comentários e o apoio em meus artigos, abraços.

Dayvid