Notas de Aula - MAC 5755 - Sistemas Operacionais Distribuídos

Aula 8 - 31/8/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)
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.
• Mudanças feitas no objeto do lado do servidor não são refletidas do lado do cliente.

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 {

         public HelloImpl() throws RemoteException {
             super();
         }

         public String sayHello() {
             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 {
           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);
   }
}
 

Vantagens de Java RMI em relação a CORBA

• Não há IDL.
• Objetos podem ser passados por valor facilmente.
• Coleta de lixo é automática (pode-se obter o mesmo em CORBA usando Java ou Smalltalk, por exemplo).
• Objetos (e stubs) podem ser transferidos de servidores remotos para o cliente em tempo de execução de forma segura.

Desvantagens de Java RMI em relação a CORBA

• É limitado a Java.
• Muitas vezes é necessário implementar partes do sistema em C++ por questões de eficiência; a integração com java não é tão fácil.
• Não possui a possibilidade de chamadas geradas dinamicamente (DII de CORBA).
• Desempenho de RMI em geral é um pouco menor.
• A arquitetura de CORBA como um todo é mais abrangente.

Referências

• A página de Java RMI da Sun
• Um bom tutorial básico da Sun para Java RMI