Esta é a continuação do post anterior.
Uma vez que já criamos o servidor RMI basta consumi-lo. Vou mostrar de duas formas para ficar bem entendido.
A primeira é já na sua aplicação web, maneira mais simples de todas. No seu application context .xml ou arquivo que o valha adicione o seguinte bean:
<bean id="rmiService"> <property name="serviceUrl" value="rmi://192.168.224.75:1099/rmi-service"/> <property name="serviceInterface" value="com.app.sys.rmiclient.FileManagement"/> </bean>
Neste bean podemos notar algums coisinhas simples. Ele cria um bean chamado rmiService e configura-o para o endereço onde o nosso servidor RMI está rodando, no meu caso é
este IP configurado aí.
Este codigo especifica uma interface também, para o Spring saber exatamente o que está criando. Note que nossa interface é exatamente a mesma interface que criamos no servidor RMI. DEVE ser a mesma interface
se puder copiar e colar melhor ainda.
Creio que tenha ficado bem claro que nosso cliente deve ter uma versão da Interface do RMI, né?
Agora que o bean está no seu application context, sempre que sua aplicação “subir” vai tentar fazer a conexão e se o RMI não estiver rodando no servidor vai retornar um erro.
Quando a aplicação subir é só fazer o @Autowired utilizando o rmiService do tipo FileManagement e usar os métodos da interface.
Simples, simples.
Para quem quer um pouco mais de detalhes eu criei um outro JAR chamado client-rmi, o contrário do server-rmi que criei no post anterior, mas volta lá e pegue a definição do POM
e pegue também a estrutura de pastas do resources por exemplo.
<?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"> <property name="serviceUrl" value="rmi://192.168.224.75:1099/rmi-service"/> <property name="serviceInterface" value="com.app.sys.rmiclient.FileManagement"/> </bean> </beans>
Veja que a criação do bean aqui é exatamente a mesma que usamos no nosso container web, isto mostra legal o quão parrudo o Spring é para criar o seu próprio contexto.
Como já descrevi você cola a interface FileManagement no seu client.
E agora o simples e fácil Main.
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Scanner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) throws IOException {
ApplicationContext ctx = new ClassPathXmlApplicationContext("com/app/sys/rmiclient/rmi-server-context.xml");
FileManagement management = (FileManagement) ctx.getBean("rmiService");
System.out.println("Digite o arquivo:");
java.util.Scanner s = new Scanner(System.in);
String arquivo = s.next();
byte[] file = management.getFile(arquivo);
InputStream is = new ByteArrayInputStream(file);
System.out.println(file.length);
if (is != null) {
Writer writer = new StringWriter();
char[] buffer = new char[1024];
try {
Reader reader = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
int n;
while ((n = reader.read(buffer)) != -1) {
writer.write(buffer, 0, n);
}
} finally {
is.close();
}
System.out.println(writer.toString());
}
System.out.println("Deseja excluir: (s/n)");
if(s.next().equals("s"))
System.out.println(management.deleteFile(arquivo));
System.out.println("FIM EXEC");
}
}
Veja que carregamos o contexto do Spring mostrando o endereço do arquivo e deste contexto apenas pegamos o bean que ele mesmo criou.
A partir daí é só rodar nosso métodos e é o nosso bom e velho código Java.
Simples assim.
Qualquer dúvida é só escrever.
