Home-theater-designers
RMI apoia invocação de método remoto e, como o nome indica, é um protocolo para um programa Java invocar um método de um objeto em execução em outro computador. Ele fornece uma API (Interface de Programação de Aplicativo) para exportar um objeto de um programa (chamado de servidor) e invocar os métodos desse objeto de outro programa (chamado de cliente), possivelmente em execução em um computador diferente.
O Java Registro RMI é um componente-chave do sistema Java RMI e fornece um diretório centralizado para que os servidores registrem serviços e para que os clientes consultem esses serviços. Neste artigo, aprendemos como implementar um servidor para expor um objeto e um cliente para invocar um método no servidor, bem como registrar e consultar o serviço no Registro RMI.
como executar um diagnóstico do sistema
Declarando a interface do servidor
Para aprender as complexidades de como o sistema Java RMI funciona, vamos implementar um objeto de servidor simples que fornece um método para aceitar um nome e retornar uma saudação. Aqui está a definição da interface do objeto:
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Greeting extends Remote
{
public String greet(String name) throws RemoteException;
}
O nome da interface é chamado Saudações . Ele fornece um único método chamado saudar() que aceita um nome e retorna uma saudação adequada.
Para marcar esta interface como exportável, é necessário estender o java.rmi.Remote interface. Além disso, o método precisa declarar um arremessa lista de cláusulas java.rmi.RemoteException além de quaisquer exceções específicas do aplicativo. Isso é para que o código do cliente possa manipular (ou propagar) erros de invocação de método remoto, como host-não-encontrado , falha na conexão etc.
Implementando o Objeto de Servidor
Depois de declarar a interface (que é usada pelos clientes), implementamos o objeto do lado do servidor e fornecemos o saudar() método como mostrado. Ele usa uma string de formato simples para formatar a saudação.
public class GreetingObject implements Greeting
{
private String fmtString = 'Hello, %s';
public String greet(String name)
{
return String.format(this.fmtString, name);
}
}
O Método Principal do Servidor
Vamos agora agrupar todas essas peças e implementar o a Principal() método do servidor. Vamos passar por cada uma das etapas relevantes.
- A primeira etapa é criar a implementação do objeto de servidor.
Greeting greeting = new GreetingObject(); - Em seguida, obtemos um stub para o objeto do servidor no tempo de execução do RMI. O stub implementa a mesma interface do objeto do servidor. No entanto, o método implementa a comunicação necessária com o objeto de servidor remoto. Este stub é usado pelo cliente para invocar de forma transparente o método no objeto do servidor.
Greeting stub = (Greeting)UnicastRemoteObject.exportObject(greeting, 0); - Depois que o stub é obtido, passamos esse stub para o registro RMI para vinculá-lo a um serviço nomeado especificado. Quando o cliente solicita uma implementação deste serviço, ele recebe o stub que sabe como se comunicar com o objeto servidor. A seguir, o método estático LocateRegistry.getRegistry () é usado para obter a referência do registro local. o religar () método é então usado para vincular o nome ao stub.
String name = 'Greeting';
Registry registry = LocateRegistry.getRegistry(port);
registry.rebind(name, stub);
O método principal completo.
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class Main
{
static public void main(String[] args) throws Exception
{
if ( args.length == 0 ) {
System.err.println('usage: java Main port#');
System.exit(1);
}
int index = 0;
int port = Integer.parseInt(args[index++]);
String name = 'Greeting';
Greeting greeting = new GreetingObject();
Greeting stub = (Greeting)UnicastRemoteObject.exportObject(greeting, 0);
Registry registry = LocateRegistry.getRegistry(port);
registry.rebind(name, stub);
System.out.println('Greeting bound to '' + name + ''');
}
}
Construindo o Servidor
Vamos agora dar uma olhada na construção do servidor. Para manter as coisas simples, construímos usando a linha de comando no Linux em vez de usar uma ferramenta de construção como o Maven.
O seguinte compila os arquivos de origem para arquivos de classe em um diretório de destino.
rm -rf target
mkdir target
javac -d target src/server/*.java
Colete os arquivos de classe em um arquivo JAR para execução.
jar cvf target/rmi-server.jar -C target server
Também coletamos os arquivos de interface necessários para compilar o cliente em uma biblioteca JAR.
jar cvf target/rmi-lib.jar -C target server/Greeting.class
Implementando o Cliente
Vamos agora dar uma olhada na implementação do cliente usado para invocar os métodos do objeto do servidor.
- Assim como acontece com o servidor, obtenha uma referência ao registro, especificando o nome do host em que o registro está sendo executado e o número da porta.
Registry registry = LocateRegistry.getRegistry(host, port); - Em seguida, procure o serviço no registro. o olho para cima() método retorna um stub que pode ser usado para chamar serviços.
Greeting greeting = (Greeting) registry.lookup(name); - E invoque o método passando os argumentos necessários. Aqui, obtemos a saudação passando o nome e imprimindo-o.
System.out.println(name + ' reported: ' + greeting.greet(myName));
O código completo do cliente:
package client;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import server.Greeting;
public class Client
{
static public void main(String[] args) throws Exception
{
if ( args.length != 3 ) {
System.err.println('usage: java Client host port myName');
System.exit(1);
}
int index = 0;
String host = args[index++];
int port = Integer.parseInt(args[index++]);
String myName = args[index++];
String name = 'Greeting';
Registry registry = LocateRegistry.getRegistry(host, port);
Greeting greeting = (Greeting) registry.lookup(name);
System.out.println(name + ' reported: ' + greeting.greet(myName));
}
}
O Registro RMI
Vamos agora executar o programa do servidor para que ele possa começar a atender às solicitações.
java -cp target/rmi-server.jar server.Main 1099
# throws
Exception in thread 'main' java.rmi.ConnectException: Connection refused to host: xxx; nested exception is:
java.net.ConnectException: Connection refused
O que é esta exceção ? Ligação recusada .
O motivo de você obter essa exceção é: observe no código do servidor que ele tenta se conectar ao registro local na porta 1099. Se isso falhar, você terá essa exceção.
A solução é executar o Registro RMI. O RMI Registry é um programa fornecido com a Java Virtual Machine e é chamado rmiregistry . Deve estar localizado no sou diretório de instalação da Java Virtual Machine. Executá-lo é tão simples como:
/usr/lib/jvm/jdk1.8.0_71/bin/rmiregistry
Por padrão, o registro escuta na porta 1099. Para fazer com que ele escute em outra porta, especifique o número da porta da seguinte maneira:
/usr/lib/jvm/jdk1.8.0_71/bin/rmiregistry 1100
Verifique se realmente há um ouvinte na porta especificada com o comando netstat :
como baixar um vídeo online
netstat -an -t tcp -p | grep LISTEN
...
tcp6 0 0 :::1100 :::* LISTEN 23450/rmiregistry
Executando o servidor
Vamos agora tentar rodar o servidor novamente.
java -cp target/rmi-server.jar server.Main 1100
# throws
java.rmi.UnmarshalException: error unmarshalling arguments
...
Caused by: java.lang.ClassNotFoundException: server.Greeting
...
Uma exceção novamente! O que é desta vez?
O servidor não consegue carregar a classe de interface servidor.Greeting . Isso acontece porque o Registro RMI não consegue carregar a classe necessária. Portanto, você precisa especificar a localização das classes necessárias. Uma maneira de fazer isso é especificar a variável de ambiente CLASSPATH:
CLASSPATH=../../junk/target/rmi-lib.jar /usr/lib/jvm/jdk1.8.0_71/bin/rmiregistry 1100
Tentar executar o servidor novamente dá:
java -cp target/rmi-server.jar server.Main 1100
# prints
Greeting bound to 'Greeting'
Agora o servidor está funcionando.
Executando o Cliente
Depois que todas as peças estão montadas e em execução, executar o cliente é simples. Ele precisa dos JARs apropriados para execução. Isso inclui a classe que contém o a Principal() método e a classe de interface. Ele aceita argumentos que indicam onde o registro RMI está sendo executado e um nome para a saudação.
java -cp target/rmi-client.jar:target/rmi-lib.jar client.Client localhost 1100 Peter
# prints
Greeting reported: Hello, Peter
Resumo
Java RMI fornece uma API e ferramentas para facilitar a execução remota de código. Você pode implementar um servidor que registra um objeto de serviço com o Java RMI Registry. Os clientes podem consultar o registro e obter o stub do objeto de serviço para chamar os métodos de serviço. Como este exemplo ilustra, tudo é muito simples.
Você está usando Java RMI em seu projeto? Qual tem sido sua experiência? Existem alternativas que você investigou? Por favor, deixe-nos saber nos comentários abaixo.
Compartilhado Compartilhado Tweet O email Um guia para iniciantes em animação de discursoAnimar a fala pode ser um desafio. Se você estiver pronto para começar a adicionar diálogo ao seu projeto, vamos dividir o processo para você.
Leia a seguir Tópicos relacionados- Programação
- Java
Assine a nossa newsletter
Junte-se ao nosso boletim informativo para dicas de tecnologia, análises, e-books grátis e ofertas exclusivas!
Clique aqui para se inscrever