RMI Calculadora Cliente-Servidor

Artigo sobre RMI

Sistema Paralelo Distribuído.

Artigo sobre RMI

Calculadora cliente servidor.

Autor: Simão Menezes
e-mail: simaomenezesneto@gmail.com
twitter: @SimaoMenezes
github: github.com/tryonn


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).


Artigo sobre RMI

Objetivo
Este 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.


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.


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.


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.


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.


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.


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.


Artigo sobre RMI

Figura 9.
Após seleciona esse sub-menu Interface será aberta uma janela como mostra a figura 10.


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.
*
* */


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.


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.


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;

/**
*
* 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


Artigo sobre RMI

* acesso ao RMI do Java.
*
*/
public abstract class ServerMainBase {

@SuppressWarnings("rawtypes")
public ServerMainBase(Class clazzToAddToServerCodebase) {

//TODO seta a propriedade do codebase
System.setProperty("java.rmi.server.codebase",
clazzToAddToServerCodebase.getProtectionDomain().getCodeSource().getLocation().t
oString());
//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 RMI
if (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
RMI
public abstract void doCalcCustomRmiHandling();
}

Logo após esse processo da criação dessa classe ServerMainBase.java crie outro package
como mostra a figura 14.


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;

/**
*
* 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";


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.server.UnicastRemoteObject;
import com.wordpress.tryonn.Interface.ICalculadora;

public class CalcServiceImpl extends UnicastRemoteObject implements


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.
*
* */
@Override
public double sum(double x, double y) throws RemoteException {
// TODO Auto-generated method stub
return x + y;
}

/**
* Método que ira receber dois parametros e subtrair.
*
* */
@Override
public double sub(double x, double y) throws RemoteException {
return x - y;
}

/**
* Método que ira receber dois parametros e multiplicar.
*
* */
@Override
public double mult(double x, double y) throws RemoteException {
return x * y;
}

/**
* Método que ira receber dois parametros e Dividir.
*
* */
@Override
public double div(double x, double y) throws RemoteException {
return x / y;


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.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);
}

/**
*
*
* */
@Override
public 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.


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.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Scanner;



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);
}

@Override
public 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 {
System.out.println("Digite o primeiro número:");


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 {
double resultMult = getCalc().mult(x, y);

System.out.println("Multiplicação: " + resultMult);
finalizaCalc();

}

private void divide() throws RemoteException, NotBoundException {
double resultDiv = getCalc().div(x, y);

System.out.println("Divisão: " + resultDiv);
finalizaCalc();

}

public void soma() throws RemoteException, NotBoundException {

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");


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 {
}
}
public void reiniciaCalc(){
String sim = "sim";
System.out.println("Deseja reiniciar a cálculadora: SIM ou NÃO ?");
sim = getWrite().next();


Artigo sobre RMI

if (sim.equals("sim")){
} else {
System.out.println("Cáculadora finalizada....");
System.exit(0);
}
}

public static void main(String[] args) {
new CalcStartClient();
}

}

Fim do projeto cal-rmi-client.


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.


RMI Calculadora Cliente-Servidor

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (10)

Semelhante a RMI Calculadora Cliente-Servidor

Semelhante a RMI Calculadora Cliente-Servidor (20)

RMI Calculadora Cliente-Servidor