Qualquer um que já precisou rodar alguma de suas classes Java remotamente já precisou fazer um servidor RMI.
Para quem não conhece vai um resumão BEM básico.
O RMI no Java, do Inglês, Remote Method Invocation é exatamente o que o seu nome diz, uma chamada de métodos de uma classe de forma remota.
Imagine que por algum motivo você está em uma máquina e precisa executar operações em outra máquina, apagar um arquivo, recuperar outro arquivo, tanto faz, a questão é que você precisa executar um comando na outra máquina. O que você faz?
Ou cria um container web todo ferrado na máquina e apela para um web-service ou faz um bom e velho RMI.
Até um tempo atrás fazer um servidor RMI era um trampo danado para falar a verdade, e até assustava um pouco os desenvolvedores para esta simples solução. A questão é que o Spring veio com tudo e resolveu toda esta complexidade.
Vamos lá.
Lá no meu trabalho me deparei com a seguinte situação:
Temos uma aplicação web com mensagens (parecido com uma mensagem de e-mail) salvas em um banco de dados. Estas mensagens vieram de um web-service, que salvou as mesmas no banco com o endereço dos anexos de um outro servidor, o repositório do cliente.
A questão é que este servidor não tem acesso ao mundo lá fora, portanto não dá pra fazer acesso direto de jeito nenhum.
O que precisamos fazer?
Montamos um servidor RMI nesta máquina repositório, este servidor RMI tem dois papéis, retornar um Array de Byte com o arquivo da máquina e excluir um arquivo passado.
Então nossa aplicação web simplesmente consome este servidor RMI, e passa um Path para pegar os arquivos, excluí-los e ser feliz para sempre.
Vamos lá para a criação do SERVIDOR RMI:
A primeira coisa que fiz foi um novo projeto Maven simples do eclipse.
Meu pom ficou com as seguintes dependências:
<dependencies> <dependency> <groupId>org.springframework.integration</groupId> <artifactId>spring-integration-rmi</artifactId> <version>2.0.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>3.0.5.RELEASE</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies>
Não podemos esquecer que iremos empacotar esta aplicação em um jar executável com as dependências já resolvidas, portanto, os seguintes plugins serão necessários no Maven:
<build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <version>2.2-beta-5</version> <configuration> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> <archive> <manifest> <mainClass>com.sys.app.rmiserver.Main</mainClass> </manifest> </archive> </configuration> <executions> <execution> <id>make-assembly</id> <phase>package</phase> <goals> <goal>single</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
Feito isto podemos partir para o código de verdade. 
A primeira coisa é a nossa classe Main, executável, meio que um EntryPoint do programa, como qualquer iniciante Java conhece nos seus sistemas de console.
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* A classe <code>Main</code> inicia o serviço RMI ao carregar o Spring Application Context
*
* @author Leonardo Machado Moreira
*/
public class Main
{
public static void main( String[] args )
{
new ClassPathXmlApplicationContext("com/app/sys/rmiserver/rmi-server-context.xml");
}
}
Como podemos ver esta classe Main é ridícula. Na iremos apenas iniciar um contexto simples do Spring utilizando como configuração padrão o arquivo passado.
Esta localização é dentro da pasta resouces como qualquer recurso do Java, então, dentro de /src/main/resources/com/app/sys/rmiserver/rmi-server-context.xml
Este arquivo contém o seguinte conteúdo:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <bean id="rmiService" class="com.app.sys.rmiserver.DefaultFileManagement"/> <bean> <property name="serviceName" value="rmi-service"/> <property name="service" ref="rmiService"/> <property name="serviceInterface" value="com.app.sys.rmiserver.FileManagement"/> <property name="registryPort" value="1099"/> </bean> </beans>
A primeira coisa que este arquivo faz é criar um bean chamado rmiService baseado na nossa classe DefaultFileManagement, que abordaremos daqui a pouco.
Na linha de baixo criamos outro bean da classe RmiServiceExporter responsável por abrir a porta de comunicação com o mundo e nomear um label do serviço.
Nossa codificação agora é bem simples.
Primeiro criamos uma Interface com todos os métodos que serão consumidos pelos clientes. Esta interface é a porta com o mundo, portanto deve ser exatamente o que você
implementou. No meu caso a interface FileManagement ficou assim:
/**
* A interface <code>FileManagement</code> é utilizada pelo Spring RMI para acesso remoto
*
* @author Leonardo Machado Moreira
*/
public interface FileManagement {
byte[] getFile(String path);
boolean deleteFile(String path);
}
Tão simples quanto poderia ser.
Agora é que vem onde a magia acontece. A implementação desta classe é exatamente o que nosso servidor fará e exatamente o que o Spring utilizou para criar o bean.
A classe DefaultFileManagement está desta forma:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* A classe <code>DefaultFileManagement</code> implementa FileManagement e
* realiza as ações de arquivo no servidor
*
* @author Leonardo Machado Moreira
*
* Retornado em Byte array para que a referencia exata seja passada, caso contrário o java não encontra o arquivo
*/
public class DefaultFileManagement implements FileManagement {
public byte[] getFile(String path) {
try {
File file = new File(path);
InputStream is = new FileInputStream(file);
long length = file.length();
if (length > Integer.MAX_VALUE)
throw new IllegalArgumentException("Arquivo muito grande");
byte[] bytes = new byte[(int) length];
int offset = 0;
int numRead = 0;
while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
offset += numRead;
}
if (offset < bytes.length)
throw new IllegalArgumentException("Erro ao ler o arquivo");
is.close();
return bytes;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public boolean deleteFile(String path) {
return new File(path).delete();
}
}
De RMI mesmo esta classe não tem absolutamente nada, veja o método delefeFile por exemplo, tão ridículo quanto nosso Java IO permite ser.
Agora é a parte mais simples.
Utilizando o Maven faça um build.
Em pacote rodando um mvn package na pasta e pegue o jar com todas as dependências.
Cole-o na pasta do servidor e rode-o utilizando o comando
java -jar rmi-service.jar
Pronto, seu servidor RMI está criado.
No próximo posto mostro como consumir.
