Este exemplo é um serviço de microblog, “semelhante” ao twitter. O mesmo utiliza o JavaSpaces.

JavaSpaces – examplo

Espero que seja util,
Matheus

Neste exemplo é demonstrado a criação de um Cliente para um Web Services. O exemplo de um Web Service que também é Cliente (Collector), e um Web Service que é somente Web Service. (Store).

O programa utilizado para criação utilizado foi o NetBeans com o GlassFish. A versão do netbeans foi netbeans-6.9.1-ml-java.

Cliente, Coletor, Lojas – Exemplo de WebServices

Espero que o exemplo seja útil a você.
Matheus

CORBA (Common Object Request Broker Architecture) é um padrão definido pelo grupo OMG (Object Management Group), este permite a interação entre Objetos Distribuídos, em diferentes linguagens e sistemas. Ele também proporciona total transparência na comunicação entre os objetos distribuídos. A localização de objetos é feito via suas referências, que são resolvidas pelo ORB. A linguagem IDL (Interface Definition Language) é a tecnologia utilizada para descrever as interfaces dos objetos. Esta é uma linguagem puramente declarativa. Ela possui seus próprios tipos de dados, que são mapeados para tipos de dados nas linguagens suportadas. Existe o Compilador IDL que gera os códigos responsáveis pela comunicação entre objetos, mapeia os tipos de dados, se encarrega de fazer a serialização dos dados.

Mas na prática como funciona? Bom, possuimos as definições em um arquivo .idl, neste caso o arquivo Bank-idl (lembre-se de renomea-lo para bank.idl).

Acessando esse arquivo vocês verão diversas definições como:

Definição do modulo

module banco {

Definição do tipo valor

typedef double valor;

Definição da estrutura de dados Transação

struct transacao {
unsigned long data; // Formato: ddmmyyyy
string<12> descricao;
valor quantia;
};

Definição da interface, seus métodos, variaveis, excessões

interface auto_atendimento {
readonly attribute string boas_vindas;
valor saldo ( in conta c )
raises ( conta_inval );
void extrato ( in conta c,
out transacoes t, out valor saldo )
raises ( conta_inval );
void transferencia ( in conta origem,
in conta destino, in valor v )
raises ( conta_inval, saldo_insuf );
void investimento ( in conta c,
in aplicacao apl, in valor v )
raises ( conta_inval, saldo_insuf );
};

Com este arquivo, você pode criar as diversas interfaces com diferentes compiladores para diferentes linguagens. Para gerar as interfaces utilize

idlj -fall bank.idl

O mesmo irá gerar diversos arquivos dentro da pasta banco, com arquivos .java, com interfaces, métodos e exceções. Os mesmos devem ser ainda implementados para funcionar como você desejar.

Um exemplo de implementação de um Servidor de Banco e um Cliente em Java, utilizando CORBA com IDL

Matheus

PS: Isto foi apenas uma breve introdução. O CORBA utiliza diversas outras definições como o OMA e outras.

Java RMI (Remote Method Invocation), é um mecanismo que permite ao usuário, criar aplicações distribuídas utilizando Java. Sem ter muitas preocupações com Protocolo, sockets entre outros. Mas como ele funciona? Bom toda a mágica é feita pelo próprio RMI. O mesmo possui um servidor chamado RMIREGISTRY, onde o seu Servidor se conecta e diz que está ali. A partir desse momento os Clientes conseguem invocar o servidor.

Um exemplo de um Servidor de Veiculo onde os Clientes podem pesquisar e adicionar novos Veículos.

Interface Servidor:

Os métodos nessa interface serão implementados por nosso servidor, essa interface extend Remote que é uma Classe necessária para fazer o RMI funcionar. Se sua interface não extende-la não irá funcionar. Todos os métodos devem possuir o tratamento de exceção, para garantir o que vai acontecer caso o servidor não seja encontrado.

Servidor:

Classe extende nossa interface e implementa os métodos (não irei mostra-los aqui).

Para criar o servidor utilizei o seguinte:

Bom no main criamos um novo ServerAn(), exportamos o nosso Servidor, registramos com o bind o nosso Servidor.

Cliente Enviador:

Basicamente, procuramos o RMIREGISTRY em “localhost” e procuramos pelo nosso servidor nomeado “Server”, com referencia para o mesmo adicionamos um novo Veículo. Para procurar é a mesma coisa porém receberemos uma Lista de veículos ao invés de não receber nada.

Para o objeto poder ser transmitido ele deve ser “serializable”.

Java RMI – Anúncios de Carros (Exemplo)

Lembrando que, o rmiregistry procura no seu Java PATH e no diretório que o mesmo foi executado pelas interfaces. Então neste exemplo, para simplicidade, acesse o diretório com os códigos fontes, compile-os execute o RMIREGISTRY no mesmo. E em seguida o Servidor, após isso em outro prompt execute o(s) Clientes. O nome do programa é RMIREGISTRY, execute-o com seu nome.

Espero que seja util,
Matheus

PS: Java ME não vem com o RMI

Referencias:
http://infolab.stanford.edu/CHAIMS/Doc/Details/Protocols/rmi/rmi_description.html
http://www.oracle.com/technetwork/java/javase/tech/index-jsp-136424.html

Hoje o Jorge me perguntou se eu sabia como enviar arquivos via XML-RPC. Pensando no assunto não me recordava como devia ser feito, resolvi dar uma rápida pesquisada para ensina-lo. Acabei me entretendo e resolvi modificar o Cliente e Servidor Java XML-RPC para fazer o mesmo.

Implementei o mesmo e não foi complexo só olhei a documentação do Apache XML-RPC para ver como eram enviados bytes. Os mesmos eram enviados codificando o array de bytes (byte[]) em Base64. Pesquisei um pouco como fazer isso e achei uma Biblioteca Java de Base64 em dominio publico. Também procurei por como pegar o array de bytes de um arquivo e como criar um novo arquivo apartir de um array de bytes (byte[]).

Esses sites onde peguei ambos os métodos estão como comentarios no arquivo.

XML-RPC-Transferencia-De-Arquivo

Espero que seja útil,
Matheus

PS: Da maneira como eu implementei qualquer arquivo do sistema que o Cliente XML-RPC pedir o Servidor irá enviar, isso criaria uma possivel brecha de segurança.

PS2: Caso deseja que o Cliente envie arquivos para o Servidor, o Cliente deve pegar o array de bytes do Arquivo, codifica-lo em base64 e passa-lo como parametro. O Servidor irá receber este parametro, decodificar após isso manipu-le o array de bytes como você desejar.

Nas aulas de programação concorrente o professor passou uma introdução de Programação Distribuida e pediu que nós criassemos algo que utilizasse ela. Então eu sugeri ao meu colega Olav para implementarmos um “quebrador” de senha por força bruta. O mesmo funciona da seguinte maneira, existe um master onde os slaves se conectam, o master informa a string a ser quebrada e qual faixa de caracteres o slave deve tentar. Após terminar aquela faixa caso ele não obtenha sucesso o slave recebe uma nova faixa, caso ele encontre, ele informa o master qual a string utilizada para gerar tal MD5.

Implementação do “MD5 Decrypter”

Existem muitas coisas que ainda podem ser aperfeiçoadas nesse programa como:
- Não precisar um número fixo de Slaves. Aceitar todos que forem se conectando em tempo real.
- Melhor distribuição de faixas.

Ele pode ser praticamente o inicio de um programa de Força Bruta Distribuida, que já devem existir vários por ai.

Espero que goste,
Matheus

Semana passada fiz a última prova de Programação Concorrente deste semestre. O problema que devia se solucionar era o seguinte:

O estacionamento de uma universidade possui 30 vagas. Enquanto o mesmo possue vagas, não existe prioridade para quem estaciona. Quando o mesmo está cheio, forma-se uma fila, onde professores possuem a mais alta prioridade, seguido pelos funcionarios e após os alunos. Utilize java com Threads para “simular” este problema. Utilize 10 professores, 15 funcionários, 30 alunos.

O Professor Mazzucco, disponibilizou uma implementação do mesmo que vou disponibilizar para vocês.

Implementação problema estacionamento em Java

Matheus

Como havia comentado a algum tempo atrás, estava trabalhando com um cliente XML-RPC em Java, durante a fase de desenvolvimento do mesmo tive que criar um servidor XML-RPC hipotetico para testar as funcionalidades do cliente, enquanto o servidor certo ainda não estava disponivel para minha pessoa.

Resumidamente para você que não conhece XML-RPC ele é um “formato” , um “jeito”, não sei ao certo a palavra certa para definir agora, onde você cria um servidor e o mesmo quando requisitado faz as operações necessarias e retorna um resultado. Um exemplo seria, você tem um código de criptografia que funciona MUITO bem em C, mas seu sistema é todo em Java, você poderia criar um Cliente JAVA e um Servidor C onde o Java faria requisição para Criptografar as coisas. Talvez utilizar XML-RPC de Java para Java possa ser meio estranho, mas quando os serviços estão distantes, pode ser algo util.

Para começar a mexer com o XML-RPC no Java eu utilizei o apache xml-rpc. Após isso apenas desenvolvi.

Baixe os exemplos cliente e servidor xml-rpc em java.

Servidor:

package xmlrpc;

import org.apache.xmlrpc.server.PropertyHandlerMapping;
import org.apache.xmlrpc.server.XmlRpcServer;
import org.apache.xmlrpc.webserver.WebServer;

public class ServidorXMLRPCParaTestes {

private static ServidorXMLRPCParaTestes euMesmo = null;

private ServidorXMLRPCParaTestes() {
try {
WebServer server = new WebServer(8185); // Cria um servidor na porta 8185
XmlRpcServer servidor = server.getXmlRpcServer(); // Pega o servidor XmlRpc
PropertyHandlerMapping phm = new PropertyHandlerMapping();
phm.addHandler(“Calc”, Calculadora.class); // Adiciona um novo “handler” ao PHM
servidor.setHandlerMapping(phm); // Define o handler no servidor
server.start(); // inicia o servidor.
} catch (Exception exception) {
System.err.println(“JavaServer: ” + exception);
}
}

public static ServidorXMLRPCParaTestes obterInstância() {
if (euMesmo == null)
euMesmo = new ServidorXMLRPCParaTestes();
return euMesmo;
}
}

- Eu utilizeo o obterInstancia para não poder existir mais de um ServidorXMLRPC
- O handler faz o seguinte, quando for chamado Calc.METODO no servidor ele irá buscar dentro do Calculadora.class

Handler Calculadora:

package xmlrpc;

public class Calculadora {

public int soma(int x, int y) {
return x + y;
}
public int subtracao(int x, int y) {
return x – y;
}

}

Cliente XML-RPC generico:

package xmlrpc;

import java.net.URL;
import org.apache.xmlrpc.*;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

public class ClienteXmlRpc {

private static final String urlServidor = “http://localhost:8185″; //DEFINE A URL DO SERVIDOR
private XmlRpcClient xmlrpc;

public ClienteXmlRpc() {
try {
XmlRpcClientConfigImpl configuraçãoCliente = new XmlRpcClientConfigImpl();
configuraçãoCliente.setServerURL(new URL(urlServidor));

xmlrpc = new XmlRpcClient();
xmlrpc.setConfig(configuraçãoCliente);

} catch (Exception exception) {
exception.printStackTrace();
}
}

public Object executar(String comando, Object[] parametros) {
try {
Object resposta = xmlrpc.execute(comando, parametros);
return resposta;
} catch (XmlRpcException e) {
e.printStackTrace();
return null;
}
}

}

- Acredito que o Cliente XML-RPC e o Cliente são auto-explicativos. Qualquer duvida entre em contato.

CalculadoraCliente:

package cliente;

import xmlrpc.ClienteXmlRpc;

public class CalculadoraCliente {
private ClienteXmlRpc cliente;

public CalculadoraCliente() {
cliente = new ClienteXmlRpc();
}

public int soma(int x, int y) {
Object[] parametros = new Object[]{new Integer(x), new Integer(y)};
Integer resultado = (Integer) cliente.executar(“Calc.soma”, parametros);
return resultado;
}

public int subtracao(int x, int y) {
Object[] parametros = new Object[]{new Integer(x), new Integer(y)};
Integer resultado = (Integer) cliente.executar(“Calc.subtracao”, parametros);
return resultado;
}
}

Para rodar os mesmos e testar gerei 2 classes com main e executei as mesmas (executando primeiro o servidor é claro)

RodarServidor:

import xmlrpc.ServidorXMLRPCParaTestes;

public class RodarServidor {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ServidorXMLRPCParaTestes Servidor = ServidorXMLRPCParaTestes.obterInstância();
}

}

RequisicaoCliente:

import cliente.CalculadoraCliente;

public class RequisicaoCliente {

/**
* @param args
*/
public static void main(String[] args) {
CalculadoraCliente x = new CalculadoraCliente();
System.out.println(x.soma(1, 1));
}

}

Abraços,
Matheus