Tutorial passo a passo sobre RMI
-
Upload
simao-neto -
Category
Technology
-
view
6.624 -
download
7
description
Transcript of Tutorial passo a passo sobre RMI
Artigo sobre RMI
Sistema Paralelo Distribuído.
Artigo sobre RMI
Calculadora cliente servidor.
Autor: Simão Menezes
e-mail: [email protected]
twitter: @SimaoMenezes
github: github.com/tryonn
Autor: Simão Menezes
Artigo sobre RMI
Introdução
Com todo avanço da tecnologia e com sistemas modernos de alta conectividade não podemos deixa de cita os sistemas paralelos distribuídos (SPD) que ainda são muito usados como os sistemas de caixa eletrônicos, bancos etc.
Este tipo de sistema ajuda em processos multiusuário e o mesmo é transparente pe-rante ao usuário. Mais o que é um SPD, bem são tipo de sistemas desenvolvido em cima de protocolos que serão citados em seguida.
Protocolos: Remote Method Invocation (RMI), Remote Procedure Call (RPC).
Autor: Simão Menezes
Artigo sobre RMI
ObjetivoEste artigo tem como objetivo mostra de uma forma simples como desenvolver uma aplicação distribuída usando o protocolo Remot Method Invocation (RMI), nosso aplicação será uma calculadora que executa o calculo das quatro operações onde a aplicação cliente irá enviar os dados para serem processados pelo servidor e o servidor retorna o resultado para o cliente.
Autor: Simão Menezes
Artigo sobre RMI
“Meus caros leitores chega de bate papo e vamos coda ( codifica ).”
I Projeto cal-rmi-base.
Bem para criação desse artigo foram utilizados a IDE Eclipse, Java 7, SO Linux Mint. É isso ai vamos la, como todos já temos o eclipse e o java instalados vamos abrir o eclipse e criar um novo projeto como mostra a figura 1.
File → new → java Project
figura 1.
Com esse item selecionado ira aparecer uma janela para ser configurada com o nome do projeto como mostra a figura 2.
Autor: Simão Menezes
Artigo sobre RMI
figura 2.
Após entra com o nome do projeto basta clica em finish, pronto seu projeto esta cria-do. Nesse artigo iremos cria três projetos separados pois como se trata de uma aplicação distribuída temos que criar o projeto cliente e o servidor.
Vide figura 3.
Autor: Simão Menezes
Artigo sobre RMI
figura 3.
Crie os outros dois projetos como mostra a figura 3, você pode seguir os passos que foram usado para criar o primeiro projeto.
Explicando a estrutura dos projetos.
O projeto cal-rmi-base terá as classes que serão implementadas tanto pelo servidor quanto pelo cliente e também uma class que configura o acesso ao servidor rmi na cria-ção do mesmo isso será explicado mais a frente.
Projeto cal-rmi-server este terá a classe que cria a conexão e também a classe que im-plementa a interface do projeto cal-rmi-base e o método main que estarta o servidor.
Projeto cal-rmi-client este terá a class que ira iniciar o projeto class main e também irá implementa os métodos que fazem referencia as quatros operações da matemática.
Para que os projetos cal-rmi-server e cal-rmi-client possam enchegar as classes do projeto cal-rmi-base será feito uma configuração que é adicionalo ao build path do pro-jeto cal-rmi-server e cal-rmi-client como mostra a figura 4 figura 5.
Autor: Simão Menezes
Artigo sobre RMI
figura 4.
Iremos clica no projeto cal-rmi-server com o botão direito do mouse navegar até o menu Build Path e escolher o sub-menu configure Build Path irá abrir uma janela como mostra a figura 5.
Figura 5.
Na janela que abriu escolha a aba Projects e clique no botão add na próxima janela escolha o projeto a ser adicionado no nosso caso o projeto será o cal-rmi-base como mostra a figura 6.
Autor: Simão Menezes
Artigo sobre RMI
Figura 6.
Clique no botão ok, faça esse mesmo procedimento para o projeto cal-rmi-client.
Agora iremos implementa as classes do projeto cal-rmi-base, iremos criar um package como mostra a figura 7.
Autor: Simão Menezes
Artigo sobre RMI
Figura 7
Irá abrir uma janela ai você deverá coloca o nome do package como mostra a figura 8.
Figura 8
Após ter criado o package iremos criar a nossa interface que terá os métodos para as opera-ções como mostra a figura 9.
Autor: Simão Menezes
Artigo sobre RMI
Figura 9.
Após seleciona esse sub-menu Interface será aberta uma janela como mostra a figura 10.
Autor: Simão Menezes
Artigo sobre RMI
Figura 10.
Coloque o nome da Interface e clique em finish segue código da class interface.
package com.wordpress.tryonn.Interface;
import java.rmi.Remote; import java.rmi.RemoteException;
/** * @author Simão Menezes * * Interface com os métodos para a calculador * * Em um sistema distribuido utilizando RMI sempre a interface com os * métodos a serem implementados devem extends de Remote ( * java.rmi.Remote) */ public interface ICalculadora extends Remote {
/** * Método que espera dois parametros para serem somados. * * */
Autor: Simão Menezes
Artigo sobre RMI
public double sum(double x, double y) throws RemoteException;
/** * Método que espera dois parametros para serem subtraidos. * * */public double sub(double x, double y) throws RemoteException;
/** * Método que espera dois parametros para serem multiplicados. * * */public double mult(double x, double y) throws RemoteException;
/** * Método que espera dois parametros para serem Divididos. * * */public double div(double x, double y) throws RemoteException;
}
Explicando a interface:
Como estamos trabalhando com RMI nossa interface Icalculadora.java deve extends de Remote, todos os métodos são do tipo double e assinam o Re-moteException isso é um padrão.
Agora que temos nossa interface criada vamos criar mais um package vide figura 11, siga os passos da figura 7 e crie uma class com o nome Server-MainBase como mostra a figura 12.
Autor: Simão Menezes
Artigo sobre RMI
Figura 11
Criação da class ServerMainBase.java figura 12.
Figura 12
Sugirá uma janela para ser colocado o nome da class figura 13.
Autor: Simão Menezes
Artigo sobre RMI
Figura 13.
Essa class ServerMainBase.java será uma classe abstract, abaixo está todo código da mes-ma.
package com.wordpress.tryonn.main;
import com.wordpress.tryonn.util.PolicyFileLocator;
/** * @author Simão Menezes * * Esta class cria um SegurityManager, seta o caminho do codebase * para que seja possivel setar o caminho do arquivo (allow_all.policy) que tem as permissões para
Autor: Simão Menezes
Artigo sobre RMI
* acesso ao RMI do Java. * */public abstract class ServerMainBase {
@SuppressWarnings("rawtypes")public ServerMainBase(Class clazzToAddToServerCodebase) {
//TODO seta a propriedade do codebaseSystem.setProperty("java.rmi.server.codebase",
clazzToAddToServerCodebase.getProtectionDomain().getCodeSource().getLocation().toString());
//TODO seta o caminho do arquivo que configura as permissões para o protocolo RMI
System.setProperty("java.security.policy", PolicyFileLocator.getLocationOfPolicyFile());
//TODO se o gerenciador de segurança for == null ele cria um//TODO É um padrão usado pelo RMIif (System.getSecurityManager() == null) {
System.setSecurityManager(new SecurityManager());}
//TODO Método que será implementado pelo Service para cria a conexão do RMI
doCalcCustomRmiHandling();}//TODO Método que será implementado pelo Service para cria a conexão do
RMIpublic abstract void doCalcCustomRmiHandling();
}
Logo após esse processo da criação dessa classe ServerMainBase.java crie outro package como mostra a figura 14.
Autor: Simão Menezes
Artigo sobre RMI
Figura 14.
Dentro desse package será criada a class PolicyFileLocator.java classe que será responsá-vel pela leitura do arquivo allow_all.policy este arquivo é responsavel por forne-cer acesso / permissão a execução de serviço do protocolo RMI , segue códi-go da classe abaixo.
package com.wordpress.tryonn.util;
import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream;
/** * @author Simão Menezes * * Class para ler o arquivo .policy * que faz referencia sobre a permissão do RMI com o java * */public class PolicyFileLocator {
/* Atribuindo o valor do arquivo para uma variavel estatica */public static final String POLICY_FILE_NAME = "/allow_all.policy";
Autor: Simão Menezes
Artigo sobre RMI
/** * Método estatico para ler o arquvio encontrado * * */public static String getLocationOfPolicyFile() {
try {File tempFile = File.createTempFile("calc-rmi-base",
".policy");/* passa o nome do arquivo para o caminho encontrado */InputStream is =
PolicyFileLocator.class.getResourceAsStream(POLICY_FILE_NAME);
/* cria se uma tributo para ler o conteudo do arquivo */BufferedWriter writer = new BufferedWriter(new
FileWriter(tempFile));int read = 0;/* pecorre o conteudo do arquivo */while ((read = is.read()) != -1) {
writer.write(read);}writer.close();tempFile.deleteOnExit();System.out.println("MyPolicy: " + is);return tempFile.getAbsolutePath();
} catch (IOException e) {throw new RuntimeException(e);
}}
}
Com isso finalizamos o projeto cal-rmi-base, agora iremos criar o projeto cal-rmi-server, para cria esse projeto siga os passos como mostra a figura 1.
Caros leitores os outros dois projetos serão criados seguindo os passos anteriores para a criação do projeto cal-rmi-base, neste mometo será colo-cado a class dos projetos cal-rmi-server e cal-rmi-client e as mesmas serão explicadas.
II - Projeto cal-rmi-server.
Primeiro crie o projeto como mostra as figura 1, 2, depois configure/adi-cione o projeto cal-rmi-base no build path do projeto cal-rmi-server siga os passos das figura 4, 5, 6.
Agora crie um package com esse nome com.wordpress.tryonn.serverimpl ou um que você ache mais interesante siga os passos das figura 7, 8 logo em seguida segue a class CalcServiceImpl.java e sua explicação.
CalcServiceImpl.java
package com.wordpress.tryonn.serverimpl;
import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; import com.wordpress.tryonn.Interface.ICalculadora;
public class CalcServiceImpl extends UnicastRemoteObject implements
Autor: Simão Menezes
Artigo sobre RMI
ICalculadora{
/** * autor Simão Menenezes * Esta class será utilizada para implementa os método da interface que * foi criada no projeto cal-rmi-base. * * O servidor irá receber os dados e processar as operações e retorna * o resultado para o cliente. */private static final long serialVersionUID = -578077740786022145L;
/** * * Construct of class * * */protected CalcServiceImpl() throws RemoteException {
super();// TODO Auto-generated constructor stub
}
/** * Método que ira receber dois parametros e somar. * * */@Overridepublic double sum(double x, double y) throws RemoteException {
// TODO Auto-generated method stubreturn x + y;
}
/** * Método que ira receber dois parametros e subtrair. * * */@Overridepublic double sub(double x, double y) throws RemoteException {
// TODO Auto-generated method stubreturn x - y;
}
/** * Método que ira receber dois parametros e multiplicar. * * */@Overridepublic double mult(double x, double y) throws RemoteException {
// TODO Auto-generated method stubreturn x * y;
}
/** * Método que ira receber dois parametros e Dividir. * * */@Overridepublic double div(double x, double y) throws RemoteException {
// TODO Auto-generated method stubreturn x / y;
Autor: Simão Menezes
Artigo sobre RMI
}
}
Agora crie um package com esse nome com.wordpress.tryonn.main ou um que você ache mais interesante siga os passos das figura 7, 8 logo em se-guida segue a class ServerMainStart.java e sua explicação.
ServerMainStart.java
package com.wordpress.tryonn.main;
import java.rmi.registry.LocateRegistry;import java.rmi.registry.Registry;
import com.wordpress.tryonn.Interface.ICalculadora;import com.wordpress.tryonn.serverimpl.CalcServiceImpl;
/** * @author simao * * Está class será responsavel pelo start do servidor * ela quem irá cria a conexão para que o cliente possa requisita os métodos * que serão processados por ele. * * * */public class ServerMainStart extends ServerMainBase{
private static final int port = 1099;
/** * Construc * * recebe o super() * com a assinatura da Interface do projeto cal-rmi-base que tem os * métodos que foram implementados pale class CalcServiceImpl.java deste
projeto. * * */public ServerMainStart() {
super(ICalculadora.class);}
/** * * * */@Overridepublic void doCalcCustomRmiHandling() {
try {
/* * eu instancio um objeto da class ICalculadora.java e * digo que essa instancia será = a minha class
CalcServiceImpl.java * que foi quem ha implementou.
Autor: Simão Menezes
Artigo sobre RMI
* */ICalculadora calc = new CalcServiceImpl();/* * Agora instancio um objeto registry * para que eu possa está registrando meu servidor * e coloca a porta da minha preferencia. * */Registry registry = LocateRegistry.createRegistry(port);
/* * Aqui eu registro um bind tipo de marcação para que * meu cliente reconheça as ações que ele irá receber * após envia os dados para serem processados no servidor. * */registry.bind("calculo", calc);
System.out.println(calc + "\n");System.out.println(registry + "\n");
} catch (Exception e) {e.printStackTrace();System.err.println(e);
}}
/* * Aqui criei o método main para que minha class possa ser inicializada. * * */public static void main(String[] args) {
new ServerMainStart();}
}
com isso finalizamos o projeto cal-rmi-server iremos agora criar o projeto cal-rmi-client.
II - Projeto cal-rmi-client.
Primeiro crie o projeto como mostra as figura 1, 2, depois configure/adi-cione o projeto cal-rmi-base no build path do projeto cal-rmi-client siga os passos das figura 4, 5, 6.
Agora crie um package com esse nome com.wordpress.tryonn.client.main ou um que você ache mais interesante siga os passos das figura 7, 8 logo em seguida segue a class CalcStartClient.java e sua explicação.
package com.wordpress.tryonn.client.main;
import java.rmi.NotBoundException;import java.rmi.RemoteException;import java.rmi.registry.LocateRegistry;import java.rmi.registry.Registry;import java.util.Scanner;
import com.wordpress.tryonn.Interface.ICalculadora;
Autor: Simão Menezes
Artigo sobre RMI
import com.wordpress.tryonn.client.impl.ClientCalcImpl;import com.wordpress.tryonn.main.ServerMainBase;import com.wordpress.tryonn.serverimpl.CalcServiceImpl;
/** * @author Simao Menezes * */public class CalcStartClient extends ServerMainBase{
private Scanner write;private Registry registry;private ICalculadora calc;private double x;private double y;private String operacoes;
public CalcStartClient() {super(ICalculadora.class);
}
@Overridepublic void doCalcCustomRmiHandling() {
/* Menu da aplicação */menu();
try {
System.out.println("Digite sua Opção");operacoes = getWrite().next();
if (operacoes.equals("-")) {System.out.println("Operador de Subtração escolhido.");subtrair();
} else if (operacoes.equals("+")) {System.out.println("Operador de Adição escolhido.");soma();
} else if (operacoes.equals("/")){System.out.println("Operador de Divisão escolhido.");divide();
} else if (operacoes.equals("*")){System.out.println("Operador de Multiplicação
escolhido.");multiplica();
} else {System.out.println("Opção invalida.\n");reiniciaCalc();
}
} catch (Exception e) {e.printStackTrace();
}
}
private void subtrair() throws RemoteException, NotBoundException {// TODO Auto-generated method stubSystem.out.println("Digite o primeiro número:");
Autor: Simão Menezes
Artigo sobre RMI
this.x = getWrite().nextDouble();System.out.println("Digite o segundo número:");this.y = getWrite().nextDouble();double resultSub = getCalc().sub(x, y);
System.out.println("Subtração: " + resultSub);finalizaCalc();
}
private void multiplica() throws RemoteException, NotBoundException {// TODO Auto-generated method stubSystem.out.println("Digite o primeiro número:");this.x = getWrite().nextDouble();System.out.println("Digite o segundo número:");this.y = getWrite().nextDouble();double resultMult = getCalc().mult(x, y);
System.out.println("Multiplicação: " + resultMult);finalizaCalc();
}
private void divide() throws RemoteException, NotBoundException {// TODO Auto-generated method stubSystem.out.println("Digite o primeiro número:");this.x = getWrite().nextDouble();System.out.println("Digite o segundo número:");this.y = getWrite().nextDouble();double resultDiv = getCalc().div(x, y);
System.out.println("Divisão: " + resultDiv);finalizaCalc();
}
public void soma() throws RemoteException, NotBoundException {
System.out.println("Digite o primeiro número:");this.x = getWrite().nextDouble();System.out.println("Digite o segundo número:");this.y = getWrite().nextDouble();double resultSum = getCalc().sum(x, y);
System.out.println("Soma: " + resultSum);finalizaCalc();
}
/** * @return * @throws RemoteException * @throws NotBoundException */private ICalculadora getCalc() throws RemoteException, NotBoundException
{if (calc == null) {
calc = new CalcServiceImpl();// calc = new ClientCalcImpl();
calc = (ICalculadora) getResgistry().lookup("calculo");
Autor: Simão Menezes
Artigo sobre RMI
}return calc;
}
/** * @return * @throws RemoteException */private Registry getResgistry() throws RemoteException {
if (registry == null) {registry = LocateRegistry.getRegistry();
}return registry;
}
/** * @return/ */private Scanner getWrite() {
if (write == null) {write = new Scanner(System.in);
}return write;
}
public void menu() {
System.out.println("/*********************************************
****************************/");System.out.println("/* Sistema para pequenos calculos
*/");System.out.println("/* Cálculadora Distribuida
*/");System.out
.println("/*************************************************************************/\n");
System.out.println("Menu de opções:\n");System.out.println("/ para divisão");System.out.println("+ para adição");System.out.println("- para subtração");System.out.println("* para multiplicação");
}
public void finalizaCalc(){String sim = "sim";System.out.println("Deseja finaliza a cálculadora: SIM ou NÃO ?");sim = getWrite().next();if (sim.equals("sim")){
System.out.println("Cáculadora finalizada....");System.exit(0);
} else {doCalcCustomRmiHandling();
}}public void reiniciaCalc(){
String sim = "sim";System.out.println("Deseja reiniciar a cálculadora: SIM ou NÃO ?");sim = getWrite().next();
Autor: Simão Menezes
Artigo sobre RMI
if (sim.equals("sim")){doCalcCustomRmiHandling();
} else {System.out.println("Cáculadora finalizada....");System.exit(0);
}}
public static void main(String[] args) {new CalcStartClient();
}
}
Fim do projeto cal-rmi-client.
Autor: Simão Menezes
Artigo sobre RMI
Conclusão
Bem vimos como é bacana poder trabalhar com aplicações distribuida, isto da ao usuário uma maior flexibilidades na utilização de suas aplicações.
Mostramos também passo a passo como é fácil usa e entender o protocolo Remote Method Invocation (RMI), vimos com cria os projetos, packages, class's, interfaces etc e o esencial que foi entender o protocolo RMI e o funcionamento dos Sistemas Paralelos Distribuídos.
Autor: Simão Menezes