Notas de Aula - MAC 5759 - Sistemas de Objetos Distribuídos

Aula 10 - 11/4/2001

Java - um Ambiente para Sistemas Distribuídos

• Máquina virtual (JVM) elimina heterogeneidade, permite migração de código
• Linguagem com tipagem forte, sem ponteiros garante isolamento e segurança
• Linguagem híbrida (compilada e interpretada)
• Compilação para byte-code e JIT aumenta desempenho
• Coleção de Serviços Distribuídos aumenta funcionalidade: registry, Jini, JNDI, JNLP, Jiro, [Enterprise] Javabeans, etc.
• Comunicação entre processos:
1. soquetes
2. CORBA (incluso na distribuição padrão da Sun a partir de Java 1.3). Na versão 1.3 havia alguns problemas na implementação e não havia suporte para várias coisas como, por exemplo, interceptadores. A versão 1.4 já traz interceptadores e parece ser mais madura.
3. Java RMI

Java RMI - Remote Method Invocation

• É similar a CORBA mas mais simples pois não precisa lidar com diferentes linguagens de programação.
• Como tudo é Java, não necessita de IDL, as interfaces são definidas usando interface de Java.

• Para declarar uma interface como remota basta herdar da classe java.rmi.Remote e adicionar uma exceção do tipo RemoteException a todos os seus métodos:
interface Impressora extends java.rmi.Remote {
           void print (Arquivo arq) throws SemPapel, EnroscouPapel, RemoteException;
}
• O arquivo .java contendo a interface deve passar por um programa (rmic) para gerar os stubs (.class).

• Clientes obtém referências para objetos remotos através do registry que é um servidor de nomes.
• Para o cliente, chamadas a métodos locais são iguais a chamadas a métodos remotos. Mas:
• chamadas locais: passagem de parâmetros por referência
• chamdas remotas: passagem por valor se o objeto estiver do lado do cliente (copia o objeto)
• Classes que são passadas como parâmetro em Java RMI devem implementar java.io.Serializable. Isto permite que a JVM faça a seriação do estado dos objetos de forma que ele possa ser transferido através da rede.
• Mudanças feitas no objeto do lado do servidor não são refletidas do lado do cliente.
• A implementação do objeto deve herdar de um protocolo de transporte, por exemplo através de um extends UnicastRemoteObject. A classe java.rmi.server.UnicastRemoteObject implementa a comunicação RMI através de soquetes TCP/IP e faz com que os objetos continuem em execução contínua a espera de chamadas de clientes remotos.

Exemplo

1. Definição da interface  (Hello.java)

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

    public interface Hello extends Remote {
        String sayHello() throws RemoteException;
    }
 

2. Implementação do servidor (HelloImpl.java)

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

     public class HelloImpl extends UnicastRemoteObject implements Hello {

         // precisamos definir um construtor pois o default não gera RemoteException

         public HelloImpl() throws RemoteException {
             super(); // opcional, vai ser chamado mesmo que não o coloquemos aqui
         }

         public String sayHello() { // note que não tem o throws aqui. A exceção é gerada pela super-classe se for o caso
             return "Hello World!";
         }

         public static void main(String args[]) {

             // Create and install a security manager
             if (System.getSecurityManager() == null) {
                 System.setSecurityManager(new RMISecurityManager());
             }

             try {
                 HelloImpl obj = new HelloImpl();

                 // Bind this object instance to the name "HelloServer"
                 Naming.rebind("//myhost/HelloServer", obj);

                 System.out.println("HelloServer bound in registry");
             } catch (Exception e) {
                 System.out.println("HelloImpl err: " + e.getMessage());
                 e.printStackTrace();
             }
         }
     }
 

3. Compilação dos stubs

rmic HelloImpl

gera os arquivos:

              HelloImpl_Stub.class
              HelloImpl_Skel.class
 

4. Implementação do cliente (neste caso, uma applet  HelloApplet.java)

import java.applet.Applet;
import java.awt.Graphics;
import java.rmi.Naming;
import java.rmi.RemoteException;

public class HelloApplet extends Applet {

   String message = "blank";
 
   // "obj" is the identifier that we'll use to refer
   // to the remote object that implements the "Hello"
   // interface
   Hello obj = null;

   public void init() {
      try {
          // o lookup carrega o HelloImpl_Stub do CLASSPATH ou do applet code base
           obj = (Hello)Naming.lookup("//" +
                 getCodeBase().getHost() + "/HelloServer");
           message = obj.sayHello();
      }
      catch (Exception e) {
        System.out.println("HelloApplet exception: " + e.getMessage());
         e.printStackTrace();
      } 
   }

   public void paint(Graphics g) {
      g.drawString(message, 25, 50); // mostra a mensagem nas coordenadas dadas
   }
}