RELATÓRIO TP RPC RMI SISTEMAS DISTRIBUÍDOS

Prévia do material em texto

Universidade Federal de Ouro Preto 
Instituto de Ciências Exatas e Aplicadas 
 Departamento de Computação e Sistemas 
 Campus João Monlevade 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CSI433 – SISTEMAS DISTRIBUÍDOS 
Relatório – Trabalho Prático – RPC/RMI 
 
TEMA: “Aplicação JavaDesktop 
 – Sistema de Pedidos de Lanche – 
utilizando JavaRMI” 
 
 
 
 
 
 
 
 
Discente – Guilherme A. R. Gomes 
Professora – Carla Lara 
 
 
 
 
João Monlevade 
28 de Setembro de 2018 
2 
 
 
Sumário 
 
 
 
 
1. Introdução ............................ Página 3 
 
 
2. Desenvolvimento ................... Página 3 
 
 
3. Sequência de Atividades ....... Página 5 
 
 
4. Dificuldades............................ Página 10 
 
 
5. Referências .............................Página 12 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3 
 
 
1. INTRODUÇÃO 
 
O trabalho prático proposto na disciplina CSI433 – Sistemas Distribuídos tem como 
objetivo implementar chamadas de métodos remotos: Java RMI, gerando os 
respectivos stubs. Para isso, será usada aplicação de um sistema de pedidos de 
lanche para exemplificar a utilização. 
 
O uso de chamadas de métodos remotos possibilita que programas utilizem, de 
forma remota, os objetos achados remotamente, sendo possível a partilha de 
recursos entre os componentes. O RMI trabalha a partir da Arquitetura Cliente-
Servidor, é imprescindível a criação de dois programas, sendo que não é necessário 
que estejam na mesma máquina. Aliando essa breve introdução sobre o objeto de 
análise e o que já foi estudado na disciplina, as próximas seções tratarão do 
desenvolvimento do projeto bem como as dificuldades enfrentadas e os passos 
seguidos para a elaboração do mesmo. 
 
 
 
2. DESENVOLVIMENTO 
 
Para o desenvolvimento do trabalho prático, foi preciso definir as aplicações a serem 
criadas. Dessa forma, as principais partes do projeto são os programas: 
ServicoRMI.java; Servidor.java; Cliente.java; que serão abordados respectivamente. 
 
 ServicoRMI.java 
 
package rmi; 
 
import java.rmi.Remote; 
import java.rmi.RemoteException; 
 
public interface ServicoRMI extends Remote{ 
 
public String setArea(String gf) throws RemoteException; 
} 
 Quadro 1: Interface ServicoRMI.java 
 
Um objeto remoto é uma instância da classe que implementa a interface remota. 
Uma interface remota, por sua vez, extende – com o comando extends – a interface 
Remote, a partir da importação de java.rmi.Remote e, dessa forma, pode declarar 
uma série de métodos remotos. 
 
Cada método remoto deve lançar – com a cláusula throws – a exceção 
RemoteException e, para isso, deve-se importar java.rmi.RemoteException. 
 
No quadro acima (Quadro 1), está a forma como foi implementada a interface RMI 
nesse trabalho prático. Ela declara apenas um método remoto, que passa um tipo 
String como parâmetro. 
 
 
4 
 
 
Servidor.java 
package servidor; 
 
import java.rmi.Naming; 
import java.rmi.RemoteException; 
import java.rmi.registry.LocateRegistry; 
import java.rmi.server.UnicastRemoteObject; 
import javax.swing.JOptionPane; 
import rmi.ServicoRMI; 
 
public class Servidor extends UnicastRemoteObject implements 
ServicoRMI { 
 private static TelaServidor frame; 
 private static Servidor server; 
 
 protected Servidor() throws RemoteException { 
 super(); 
 } 
 public static void main(String[] args) { 
 try { 
 server = new Servidor(); 
 LocateRegistry.createRegistry(3306); 
 frame = new TelaServidor(server); 
 frame.setLocationRelativeTo(null); 
 frame.setVisible(true); 
 } catch (Exception e) { 
 JOptionPane.showMessageDialog(null, "não inicia frame"); 
 } 
 } 
 @Override 
 public String setArea(String gf) throws RemoteException { 
 frame.setAarea(gf); 
 return null; 
 } 
 void Inicia() throws RemoteException { 
 try { 
 Naming.rebind("//127.0.0.1:3306 /Guilherme", server); 
 JOptionPane.showMessageDialog(null, "server iniciou"); 
 } catch (Exception dsa) { 
 JOptionPane.showMessageDialog(null, "server não iniciou"); 
 } 
 } 
} 
 Quadro 2: Programa Servidor.java 
 
 
Uma classe “Servidor”, nesse contexto, possui um método principal no qual é criado 
uma instância na implementação dos objetos remotos. A classe principal utiliza 
– com o comando extends – UnicastRemoteObject, a partir da importação de 
java.rmi.server.UnicastRemoteObject., uma classe usada para exportar um objeto 
remoto com JRMP e obter uma stub de comunicação com o objeto remoto. 
 
A instância criada é ligada a um nome lançado no registro Java RMI, passando a 
porta que será aberta para a conexão. O método estático LocateRegistry (Quadro 2) 
retorna uma stub, que utiliza uma interface remota e envia solicitações de registro ao 
host na porta destacada na implementação acima 3306. Caso a aplicação não 
consiga iniciar o servidor com sucesso, será exibido uma 
JOptionPane.showMessageDialog, com a exceção tratada. 
 
 
 
5 
 
Cliente.java 
package Cliente; 
 
import java.net.MalformedURLException; 
import java.rmi.Naming; 
import java.rmi.NotBoundException; 
import java.rmi.RemoteException; 
import javax.swing.JOptionPane; 
import rmi.ServicoRMI; 
 
public class Cliente { 
 private static TelaCliente frame; 
 private static ServicoRMI serv; 
 
 public static void main(String[] args) { 
 try { 
 serv = (ServicoRMI) 
Naming.lookup("//127.0.0.1:3306/Guilherme"); 
 JOptionPane.showMessageDialog(null, "cliente 
conectado "); 
 } catch (MalformedURLException e) { 
 JOptionPane.showMessageDialog(null, "cliente: "+e); 
 e.printStackTrace(); 
 } catch (RemoteException e) { 
 JOptionPane.showMessageDialog(null, "cliente"+e); 
 e.printStackTrace(); 
 } catch (NotBoundException e) { 
 JOptionPane.showMessageDialog(null, "cliente "+e); 
 e.printStackTrace(); 
 } 
 Cliente gui = new Cliente(); 
 frame = new TelaCliente(gui); 
 frame.setVisible(true); 
 } 
 void setTeste(String gui) { 
 try { 
 serv.setArea(gui); 
 } catch (RemoteException e) { 
 JOptionPane.showMessageDialog(null, "Erro”); 
 e.printStackTrace(); 
 } 
 } 
} 
 Quadro 3: Programa Cliente.java 
 
O programa Cliente obtém uma stub para o registro no host do servidor, procura a 
stub do objeto remoto pelo nome no registro e, então, chama o método setArea no 
objeto remoto, utilizando a stub, como mostrado no Quadro 3. 
 
A stub para o registro obtida pelo cliente é tida chamando o método estático 
LocateRegistry, a partir do nome especificado na linha de comando de entrada da 
porta. Caso não haja nenhum nome especificado, então a constante null será usada 
como o hostname, indicando que o endereço deve ser usado. 
 
O próximo passo é chamar o método remoto lookup, a fim de obter a stub para o 
objeto remoto oriundo do registro do servidor. 
 
 
6 
 
Os programas Cliente.java e Servidor.java implementam interfaces, utilizando – com 
o comando extends – Javax.swing.JFrame, os códigos porém não serão 
destacados aqui, visto que o intuito é a demonstração da conexão realizada. 
 
 
3. SEQUÊNCIA DE ATIVIDADES 
 
Nessa seção, serão relatados os passos seguidos para gerar as stubs bem com 
para compilar os arquivos. Os códigos fontes foram compilados utilizando comandos 
integrados com o prompt de comando do sistema operacional Windows – CMD – 
seguindo algumas ações.Figura 1: Utilização dos comandos javac e rmic no projeto 
 
Para compilar os arquivos fonte, usa-se como na Figura 1: 
 
javac -d (destino do diretório) <arquivo fonte .java> 
 
A execução desse comando faz com que as classes sejam lidas e compiladas em 
bytecodes, gerando classes de teste que podem ser colocadas no diretório desejado 
através de -d. 
Com as classes geradas, o próximo passo é gerar a classe stub, usa-se: 
 
rmic <options> <nome das classes> 
 
A execução desse comando irá gerar a classe stub Servidor_Stub.class. 
 
 
 Figura 2: Utilização do comando rmiregistry no projeto 
 
Para iniciar o registro, o comando rmiregistry (Figura 2) é utilizado. A partir desse 
momento, o servidor será iniciado e estará pronto pra ser usado na porta destacada. 
Dessa forma, o passo sucessivo será trabalhar com o programa Cliente para que 
seja possível utilizar o host do servidor. 
7 
 
Com o registro criado, é necessário iniciar o servidor. Tanto o Servidor como o 
cliente serão compilados usando, como na (Figura 3) e (Figura 5): 
 
Java -classpath <diretório> <arquivo fonte> 
 
 
Figura 3: Iniciação do servidor no projeto 
 
 
Caso o Windows Defender Firewall esteja ativo (ocorreu no projeto), irá bloquear 
alguns recursos do Java(TM), então será necessário que o administrador da 
máquina conceda acesso ao host do servidor, como mostrado na imagem (Figura 4) 
abaixo: 
 
 
Figura 4: Solicitação de permissão de acesso no projeto 
 
Nas caixas de opção mostradas pelo firewall, foi selecionado tanto rede privada 
quanto rede pública. Para um projeto pessoal, porém, selecionar só rede privada já é 
o bastante. 
 
 
 Figura 5: Iniciar aplicação Cliente no projeto 
 
 
8 
 
O botão “Iniciar Servidor” servidor foi acionado e iniciou e compilou o programa 
servidor, como ilustrado na imagem (Figura 6) acima. Caso o servidor seja iniciado 
com sucesso, uma JOptionPane.shoMessageDialog com a mensagem “server 
iniciou” será mostrada, caso contrário será exibida uma mensagem com o erro de 
iniciação do servidor. 
 
 
 
 Figura 6: Tela do Servidor no projeto 
 
 
Com o servidor iniciado com sucesso, o próximo passo é o programa cliente. Como 
na imagem (Figura 5) acima, o programa cliente foi iniciado da mesma forma que o 
servidor e Caso o cliente seja iniciado com sucesso, uma caixa de diálogo do java 
JOptionPane.shoMessageDialog (Figura 7) com a mensagem “Cliente conectado” 
será mostrada, caso contrário será exibida uma mensagem com o erro de iniciação 
do servidor. 
 
 
 Figura 7: Cliente conectado com sucesso 
 
9 
 
Após pressionar o botão “Ok”, será exibida a interface do cliente(Figura 8): 
 
 
Figura 8: Interface do cliente no projeto 
 
 
Exibida a GUI do cliente, o primeiro passo é entrar com o nome na caixa de texto e 
pressionar o botão “ok”. Posteriormente, a escolha será feita clicando na imagem do 
Sanduíche, será exibida uma caixa de diálogo JOptionPane.showMessageDialog 
com a mensagem “Trabalho de Sistemas Distribuídos – Profa. Carla Lara”, o nome 
do cliente e o pedido feito. A partir do método remoto que o cliente tem acesso, será 
passado um tipo String pelo método remoto setArea, que, por sua vez, será 
impresso na tela do servidor, concretizando a conexão. 
 
Um possível teste a ser feito é tentar iniciar a aplicação cliente sem lançar um 
registro e colocar o servidor em modo de operação. Esse teste foi feito no projeto e, 
como esperado, gerou um erro: 
 
ERRO: cliente: java.rmi.ConnectException: Connection refused to host;nested 
exception is: java.net.ConnectException: Connection refused: Connect 
 
 
Outro teste possível é tentar iniciar algum outro servidor na mesma porta que o atual 
que já esteja em operação. Esse teste também foi feito e gerou o seguinte erro: 
 
ERRO: java.rmi.server.ExportException: Port already in use: 1099; nested 
exception is: java.net.BindException: Address already in use: JVM_Bind 
 
 
10 
 
4. DIFICULDADES 
 
 
Durante o desenvolvimento do trabalho, surgiram algumas dificuldades. A principal 
dificuldade foi descobrir a razão pela qual o prompt de comando (cmd) não aceitava 
os comandos para geração de stubs. 
 
 
Figura 9: warning gerado ao executar o comando rmic 
 
O comando rmic fazia com que o seguinte warning(Figura 9) fosse acusado no 
prompt de comando: 
“generation and use of skeletons and static stubs for JRMP is deprecated. 
Skeletons are unnecessary, and static stubs have been superseded by dynamically 
generated stubs. Users are encouraged ti migrate away from using rmic to generate 
skeletons and static stubs. See the documentation for 
java.rmi.server.UnicastRmoteObject.” 
 
A solução encontrada, após consultar alguns fóruns de discussão, documentações 
da Oracle sobre as classes de utilização, foi configurar as varáveis de ambiente para 
que fosse possível gerar stubs. 
 
Tomando o seguinte caminho no sistema operacional Windows: 
Computador > Propriedades > Configurações avançadas do sistema. 
 
 
 
 Figura 10: Propriedades do Sistema 
 
11 
 
Acessando “Variáveis de ambiente”, o primeiro passo seguido foi criar duas variáveis 
do sistema: “CLASS_PATH”, passando como valor o diretório da pasta lib do JDK. 
Posteriormente, foi criado “JAVA_HOME”, passando como valor o diretório da pasta 
do JDK no sistema. 
 
 
Figura 11: Propriedades do Sistema 
 
O próximo passo foi editar a variável de ambiente do usuário “Path”. Foram criados 
dois valores: “%JAVA_HOME%” e o diretório da pasta bin do JDK (Figura 12). Com 
as alterações devidamente feitas, o prompt de comando aceitou os comandos 
necessários para gerar os arquivos do trabalho prático. 
 
 
Figura 12: Editar Varável de ambiente 
 
 
12 
 
5. REFERÊNCIAS 
 
<Livro> 
 
COULOURIS, George; DOLLIMORE, Jean; KINDBERG, Tim; BLAIR, Gordon. 
Sistemas Distribuídos: Conceitos e Projetos. Editora Bookman. Porto Alegre – 
RS, 2013. 
 
 
 
<Documentações> 
 
Getting Started Using Java(TM) RMI. 
Link: https://docs.oracle.com/javase/7/docs/technotes/guides/rmi/hello/hello-
world.html 
 
Class UnicastRemoteObject. 
Link:https://docs.oracle.com/javase/8/docs/api/java/rmi/server/UnicastRemoteObject.
html 
 
javac – Java programming language compiler. 
Link: https://docs.oracle.com/javase/6/docs/technotes/tools/windows/javac.html 
 
 
 
<Fóruns> 
 
Configurar javac: 
Link: http://www.guj.com.br/t/como-configurar-o-javac/53490/11 
 
Erro na aplicação RMI ao tentar gerar stub: 
Link: http://www.guj.com.br/t/erro-na-aplicacao-rmi-ao-tentar-compilar-o-stub/139769 
 
RMI: 
Link: http://guj.com.br/38311-servidor-rmi-java-como-identificar