Você está aqui: Java ::: RMI - Remote Method Invocation ::: Passos Iniciais |
O que é RMI (Remote Method Invocation) e como usá-lo em suas aplicações JavaQuantidade de visualizações: 10274 vezes |
A tecnologia RMI (Remote Method Invocation) fornece um framework para o desenvolvimento de sistemas distribuídos em Java. Ao usarmos RMI, um objeto Java em um sistema pode chamar (invocar) um método de outro objeto em um outro sistema na rede. Um sistema distribuído em Java pode ser visto como uma coleção de objetos distribuídos pela rede e que colaboram entre si. O RMI (no pacote java.rmi) é uma API de alto-nível construída em cima de sockets. A programação a nível de soquetes permite a passagem de dados entre computadores através de soquetes. Aqui entra o ponto interessante do RMI. Conseguimos, por meio desta tecnologia, não somente passar dados entre diferentes sistemas, mas também invocar métodos em objetos remotos. Objetos remotos podem ser manipulados como se os mesmos residissem na máquina local. A transmissão de dados entre as diferentes máquinas é gerenciada pela JVM (Java Virtual Machine) de forma transparente. De alguma forma, o RMI é uma evolução da arquitetura cliente/servidor. Um cliente é um computador que efetua requisições por serviços, e um servidor é um componente que "entrega" os serviços solicitados. Assim como na arquitetura cliente/servidor, o RMI mantém a noção de clientes e servidores, mas a abordagem do RMI é mais flexível que o paradigma cliente/servidor. Assim, um componente RMI pode agir tanto como um cliente quanto como um servidor. Tudo dependerá do cenário da aplicação. O funcionamento do RMI se baseia em objetos remotos, ou seja, objetos que são acessíveis a partir de um servidor remoto. Para que um objeto possa ser invocado remotamente, ele deve ser definido em uma interface Java acessível tanto ao servidor quanto ao cliente. Além disso, a interface deve extender a interface java.rmi.Remote. Assim como acontece com a interface java.io.Serializable, a interface java.rmi.Remote é uma interface de marcação que não contém constantes nem métodos. Ela é usada somente para identificar objetos remotos. Listamos abaixo os componentes chaves da arquitetura RMI: Interface de objeto de servidor: Uma sub-interface de java.rmi.Remote que define os métodos para o objeto de servidor. Implementação de servidor: Uma classe que implementa a interface de objeto remoto. Objeto de servidor: Uma instância da implementação de servidor. Registro RMI (RMI registry): Um utilitário que registra os objetos remotos e fornece serviços de nomes (naming services) para a localização de objetos (lookup). Programa cliente: Um programa que invoca (chama) os métodos no objeto de servidor remoto. Stub (canhoto) de servidor: Um objeto que reside na máquina cliente e serve como um substituto para o objeto de servidor remoto. Esqueleto de servidor: Um objeto que reside na máquina servidor e comunica com o stub e o objeto de servidor real. O funcionamento do RMI se dá da seguinte forma: a) Um objeto de servidor é registrado com o RMI registry; b) Um cliente pesquisa (lookup) através do RMI registry um objeto remoto; c) Se o objeto remoto for localizado, seu stub é retornado para o cliente. O objeto remoto pode ser usado da mesma forma que um objeto local. A comunicação entre o cliente e o servidor é gerenciada por meio do stub e do esqueleto. A implementação da arquitetura RMI é complexa. A boa notícia é que ela fornece um mecanismo que nos libera da tarefa de ter que escrever código tedioso para gerenciar passagens de parâmetros e chamadas de métodos remotos. A idéia básica é usar duas classes auxiliares (helper classes) conhecidas como stub e esqueleto (skeleton) para gerenciar a comunicação entre o cliente e o servidor. O stub e o esqueleto são gerados automaticamente pelo JDK. O stub reside na máquina cliente. Ele contém todas as informações de referência que o cliente precisa saber a respeito do objeto servidor. Quando um cliente invoca um método em um objeto servidor, ele na verdade chama um método que está encapsulado no stub. O stub é responsável pelo envio de parâmetros para o servidor e pelo recebimento dos resultados do servidor e encaminhando-os para o cliente. O esqueleto comunica com o stub a partir do servidor. O esqueleto recebe parâmetros do cliente, passa-os para o servidor para execução, e retorna o resultado para o stub. |
![]() |
Java ::: Pacote java.lang ::: StringBuffer |
Curso completo de Java - Como usar a classe StringBuffer da linguagem JavaQuantidade de visualizações: 9120 vezes |
A classe StringBuffer, no pacote java.lang, representa uma sequencia de caracteres mutável e segura em relação a threads. Um objeto StringBuffer é parecido com uma String, com a diferença que um StringBuffer pode ser modificado in-place, ou seja, modificações em seu conteúdo não geram uma nova cópia, como acontece com objetos da classe String. Veja a posição desta classe na hierarquia de classes Java: java.lang.Object java.lang.StringBuffer A qualquer momento um StringBuffer contém uma sequencia de caracteres em particular, mas o tamanho e o conteúdo da sequencia pode ser alterado por meio de certas chamadas de métodos. Objetos StringBuffer são seguros para acesso em um ambiente de múltiplas threads. Os métodos são sincronizados (synchronized) onde necessário de forma a garantir que todas as operações em uma instância em particular se comportem como se estivessem em ordem serial, ou seja, sejam consistentes com a ordem das chamadas de métodos feitas por cada uma das threads envolvidas. As operações principais de um StringBuffer são os métodos append() e insert(), que são sobrecarregados para aceitar dados de qualquer tipo. Cada um destes métodos converte a informação fornecida em string e então acrescenta ou insere os caracteres desta string no string buffer. O método append() sempre adiciona os caracteres no final do buffer. O método insert(), por sua vez, adiciona os caracteres em um determinado ponto. Por exemplo, se z se refere a um objeto string buffer cujo conteúdo é "start", então a chamada de método z.append("le") faria com que o string buffer tivesse agora ""startle"", enquanto z.insert(4, "le") alteraria o conteúdo do string buffer para "starlet". Em geral, se sb se refere a uma instância de StringBuffer, então sb.append(x) tem o mesmo efeito que sb.insert(sb.length(), x). Sempre que uma operação ocorre envolvendo uma sequencia de fonte (por exemplo, adicionar ou inserir a partir de uma outra sequencia), esta classe sincroniza somente o string buffer no qual a operação está sendo feita. Todo string buffer possui uma capacidade (capacity). Enquanto o comprimento da sequencia de caracteres contida no string buffer não exceder a capacidade do mesmo, não há necessidade de alocar uma nova matriz interna de buffer. Se o buffer interno for sobrecarregado, ele será automaticamente expandido. A partir do Java 5, esta classe foi suplementada com uma classe equivalente criada para o uso em ambiente de thread única: StringBuilder. A classe StringBuilder deve ser usada em vez de StringBuffer, uma vez que ela suporta as mesmas operações mas é mais rápida por não executar sincronização. |
Java ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como criar e usar métodos estáticos em suas classes Java - Programação Orientada a Objetos em Java - Java OOPQuantidade de visualizações: 13483 vezes |
Como já vimos em outras dicas desta seção, uma classe Java possui propriedades (variáveis) e métodos (funções). Veja a seguinte declaração de uma classe Produto:---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; // declaração da classe Produto public class Produto { private String nome; private double preco; public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public double getPreco() { return preco; } public void setPreco(double preco) { this.preco = preco; } } Aqui cada instância da classe Produto terá suas próprias variáveis nome e preco e os métodos que permitem acesso e alteração destas variáveis também estão disponíveis a cada instância. Há, porém, situações nas quais gostaríamos que um determinado método estivesse atrelado à classe e não à cada instância individual. Desta forma, é possível chamar um método de uma classe sem a necessidade da criação de instâncias da mesma. O método main() presente em todas as aplicações Java é um bom exemplo deste tipo de método. Métodos estáticos em Java podem ser criados por meio do uso da palavra-chave static. É comum tais métodos serem declarados com o modificador public, o que os torna acessíveis fora da classe na qual estes foram declarados. Veja um exemplo: Código para Pessoa.java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; // classe Pessoa com duas variáveis privadas e // um método estático public class Pessoa { private String nome; private int idade; // um método estático que permite verificar a validade // de um número de CPF public static boolean isCPFValido(String cpf){ // alguns cálculos aqui return true; } } Veja agora como podemos chamar o método isCPFValido() sem a necessidade da criação de uma nova instância da classe Pessoa: Código para Main.java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; public class Main { public static void main(String[] args) { // vamos efetuar uma chamada ao método isCPFValido() sem // criar uma instância da classe Pessoa if(Pessoa.isCPFValido("12345")){ System.out.println("CPF Válido"); } else{ System.out.println("CPF Inválido"); } } } Note que o método estático isCPFValido() da classe Pessoa foi declarado assim: public static boolean isCPFValido(String cpf); Desta forma, podemos chamá-lo a partir de código externo à classe sem a necessidade de criar uma nova instância da mesma. Veja: if(Pessoa.isCPFValido("12345")){} É importante notar que métodos estáticos não possuem acesso a variáveis e métodos não estáticos da classe, tampouco ao ponteiro this (que só existe quando criamos instâncias da classe). Assim, o trecho de código abaixo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- // um método estático que permite verificar a validade // de um número de CPF public static boolean isCPFValido(String cpf){ // alguns cálculos aqui // vamos acessar a variável não estática nome nome = "Osmar J. Silva"; return true; } vai gerar o seguinte erro de compilação: Uncompilable source code - non-static variable nome cannot be referenced from a static context. Se usarmos this.nome a mensagem de erro de compilação será: Uncompilable source code - non-static variable this cannot be referenced from a static context. Métodos estáticos são úteis quando precisamos criar classes que atuarão como suporte, nas quais poderemos chamar funções (métodos) auxiliares sem a necessidade de criar novas instâncias a cada vez que estas funções forem necessárias. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição |
Exercícios Resolvidos de Java - Como converter de binário para decimal em Java usando o laço forQuantidade de visualizações: 6037 vezes |
Pergunta/Tarefa: Escreva um programa Java que usa o laço for para converter um número binário (como uma String) em sua representação decimal (como um int). Peça ao usuário para informar um número binário e mostre o mesmo em decimal (como um int). Sua solução deve obrigatoriamente usar o laço for. Sua saída deverá ser parecida com: Informe um número binário: 1100 A representação decimal do valor binário 1100 é 12 Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos{ public static void main(String[] args) { // vamos fazer a leitura usando a classe Scanner Scanner entrada = new Scanner(System.in); // vamos ler o número binário (como uma String) System.out.print("Informe um número binário: "); String bin = entrada.nextLine(); int decimal = 0; // guarda a representação decimal // vamos percorrer todos os dígitos do número binário começando do início for(int i = 0, exp = bin.length() - 1; i < bin.length(); i++, exp--){ // converte o caractere atual para inteiro int temp = Character.digit(bin.charAt(i), 10); decimal = decimal + (temp * (int)Math.pow(2, exp)); } System.out.println("A representação decimal do valor binário " + bin + " é " + decimal); } } |
Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como excluir um diretório em Java usando o método delete() da classe File - Curso de Java para iniciantesQuantidade de visualizações: 9611 vezes |
Em algumas situações nós precisamos excluir um ou mais diretórios a partir de nossos códigos Java. Para isso nós podemos usar o método delete() da classe File, no pacote java.io. Veja o código completo para o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; import java.io.*; public class Estudos{ public static void main(String[] args){ File diretorio = new File("c:\\java"); if(diretorio.delete()){ System.out.println("Diretorio excluido com sucesso."); } else{ System.out.println("Não foi possivel excluir o diretorio"); } } } Ao executarmos este código nós teremos o seguinte resultado (assumindo que você tem um diretório chamado "c:\\java"): Diretorio excluido com sucesso. Lembre-se de que o método delete() da classe File só permitirá a exclusão do diretório se este estiver vazio. |
Java ::: Dicas & Truques ::: Entrada e Saída em Arquivos (File Input/Output - IO) |
Como ler o conteúdo de um arquivo uma linha de cada vez usando o método readLine() da classe RandomAccessFile da linguagem JavaQuantidade de visualizações: 13218 vezes |
Uma das operações mais frequentes em um programa é a leitura do conteúdo de arquivos. A classe RandomAccessFile nos fornece o método readLine() que é muito útil quando precisamos ler as linhas de conteúdo em um arquivo. O método readLine() lê bytes consecutivos do arquivo, começando na posição atual do ponteiro de arquivos até alcançar um caractere marcador de final de linha ou o fim do arquivo. Cada byte é convertido em um caractere tomando-se o valor do byte para os oito bits de menor ordem do caractere e definindo os oito bits de ordem alta do caractere como zero. Desta forma, este método não suporta Unicode completamente. Uma linha de texto é finalizada por um caractere de retorno de carro ("\r"), um caractere de nova linha ("\n"), um caractere de retorno de carro seguido por um caractere de nova linha, ou o final do arquivo. Caracteres de final de linha não são incluídos na string retornada pelo método. É importante observar que, a cada chamada ao método readLine(), o ponteiro de arquivo é avançado e posicionado para a leitura subsequente. Veja o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- import java.io.*; public class Estudos{ public static void main(String[] args){ // uma instância de RandomAccessFile para leitura e escrita try{ RandomAccessFile arquivo = new RandomAccessFile("C:\\java\\conteudo.txt", "rw"); // vamos ler o conteúdo do arquivo uma linha de cada vez String linha; while((linha = arquivo.readLine()) != null){ System.out.println("Posição do ponteiro: " + arquivo.getFilePointer()); System.out.println(linha); } arquivo.close(); } catch(FileNotFoundException fnfe){ System.out.println(fnfe.getMessage()); } catch(IOException ioe){ System.out.println(ioe.getMessage()); } System.exit(0); } } Ao executar este exemplo nós teremos o seguinte resultado: Posição do ponteiro: 27 Primeira linha do arquivo Posição do ponteiro: 53 Segunda linha do arquivo Posição do ponteiro: 78 Terceira linha do arquivo |
Java ::: Coleções (Collections) ::: ArrayList |
Como testar se a ArrayList do Java está vazia usando a função isEmpty() - Java ArrayList para iniciantesQuantidade de visualizações: 18820 vezes |
Neste exemplo mostrarei como usar o método isEmpty() da classe ArrayList para verificar se a lista está vazia, ou seja, não contem nenhum elemento. Este método retorna true se a ArrayList estiver vazia e false em caso contrário. Veja o exemplo a seguir: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos_java; import java.util.ArrayList; public class Estudos{ public static void main(String[] args){ // cria uma ArrayList que conterá strings ArrayList<String> nomes = new ArrayList<>(); // adiciona itens na lista nomes.add("Carlos"); nomes.add("Maria"); nomes.add("Fernanda"); nomes.add("Osmar"); nomes.add("Maria"); // Verifica se a ArrayList está vazia if(nomes.isEmpty()){ System.out.println("A ArrayList está vazia."); } else{ System.out.println("A ArrayList não está vazia."); } System.exit(0); } } Ao executar este código Java nós teremos o seguinte resultado: A ArrayList não está vazia. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Ler dois números inteiros e informar se os dois possuem o mesmo dígito no final em JavaQuantidade de visualizações: 626 vezes |
Pergunta/Tarefa: Escreva um programa Java que pede para o usuário informar dois números inteiros e informe se os dois números informados possuem o último dígito igual, ou seja, terminam com o mesmo dígito. Sua saída deve ser parecida com: Informe o primeiro número: 28 Informe o segundo número: 4318 Os dois números possuem o último dígito igual. Informe o primeiro número: 39 Informe o segundo número: 93 Os dois números não possuem o último dígito igual. Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { // para ler a entrada do usuário Scanner entrada = new Scanner(System.in); // vamos pedir para o usuário informar dois inteiros System.out.print("Informe o primeiro número: "); int n1 = Integer.parseInt(entrada.nextLine()); System.out.print("Informe o segundo número: "); int n2 = Integer.parseInt(entrada.nextLine()); // agora vamos testar se os dois números terminam com // o mesmo último dígito if(Math.abs(n1 % 10) == Math.abs(n2 % 10)){ System.out.println("Os dois números possuem o último dígito igual."); } else{ System.out.println("Os dois números não possuem o último dígito igual."); } } } |
Java ::: Dicas & Truques ::: Data e Hora |
Como validar uma data em Java usando a classe GregorianCalendarQuantidade de visualizações: 13094 vezes |
Esta dica mostra a você como validar uma data em Java usando a classe GregorianCalendar. Veja que estamos usando o método set() para atribuir valores aos campos ano, mês e dia. Contudo, o valor para o dia está incorreto. Desta forma, ao chamarmos o método getTime() uma exceção do tipo IllegalArgumentException será lançada. Veja o código: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- import java.util.*; public class Estudos{ public static void main(String args[]){ try{ GregorianCalendar data = new GregorianCalendar(); data.setLenient(false); data.set(GregorianCalendar.YEAR, 2008); // ano data.set(GregorianCalendar.MONTH, 11); // mês // dia inválido data.set(GregorianCalendar.DATE, 32); // a validação da data ocorre aqui Date temp = data.getTime(); } catch(Exception e){ System.out.println("Data inválida."); e.printStackTrace(); } } } Ao executarmos este código teremos o seguinte resultado: Data inválida. java.lang.IllegalArgumentException: DAY_OF_MONTH at java.util.GregorianCalendar.computeTime(Unknown Source) at java.util.Calendar.updateTime(Unknown Source) at java.util.Calendar.getTimeInMillis(Unknown Source) at java.util.Calendar.getTime(Unknown Source) at Estudos.main(Estudos.java:14) |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
1º lugar: Java |