Gerenciamento de Transações com EJB - Parte 2

Olá pessoal, continuando a falar sobre transações, agora iremos ver como aplicar transações nos objetos EJB.

Visão Geral sobre EJB

Os EJBs são objetos que tem seu ciclo de vida gerenciados pelo Container, ou seja, ele é o responsável por criar, gerenciar, e encerrar este tipo de objeto, o Container prove vários serviços para objetos EJBs, tais como: transações, segurança, acesso concorrente, acesso remoto, entre outros.

Os EJBs estão divididos basicamente em 2 tipo:

Session Beans: Este tipo expõem métodos para serem acessados local ou remotamente, eles são divididos em 3 subtipos:
  • Stateless: Este não armazena estado entre as chamadas, ou seja, quando o cliente faz uma chamada a um método de um EJB Stateless, a instância que será disponibilizada pelo Container veem de um pool de objetos, onde a cada chamada um objeto diferente pode atender a solicitação;
  • Stateful: Este armazena estado entre as chamadas, ou seja, quando um cliente faz uma chamada a um método de um EJB Stateful, a instância que irá atender as solicitações será sempre a mesma, com isso o cliente poderá armazenar estado entre as chamadas;
  • Singleton: Este foi introduzido a partir do Java EE 6, ele segue o design pattern do GOF, onde é criado apenas uma instância do objeto, ou seja, só existirá uma instância daquele EJB no container.
Exemplo de Session Bean Stateless.
Message Driven Beans: Este tipo é responsável por processar mensagens assíncronas, ou seja, ele não é invocado diretamente pelo cliente, e sim acionado pelo Container quando uma fila possui mensagens a serem processadas, em Java a API de fila de mensagens é a JMS (Java Message Service).

Tipos de Transações

Ao trabalhar com transações em objetos EJBs, podemos gerenciar o contexto transacional de 2 formas:

Container (CMT): Este tipo marca a transação para ser gerenciada pelo Container, ou seja, ele será o responsável pelo gerenciamento e execução da transação;

Bean (BMT): Este tipo marca a transação para ser gerenciada manualmente, ou seja, a transação será gerenciada de forma programática.

Por padrão, caso não seja definido nenhum tipo de Transação, é assumido o tipo Container (CMT).

Exemplo da configuração do tipo de transação.

Níveis de Propagação

Um ponto importante ao lidarmos com transações, é saber usar corretamente os níveis de propagação, com EJB, ao trabalhar com transações do tipo CMT, podemos gerenciar uma mesma transação dentro de várias chamadas de métodos distintos.

Vamos analisar os níveis de propagação disponíveis:

REQUIRED: Se existir uma transação, participa da mesma, senão existir, será criada uma nova transação;

REQUIRES_NEW: Cria uma nova transação para o método mesmo que já exista uma transação corrente;

SUPPORTS: Se existir uma transação, participa da mesma, senão existir, o método é executado normalmente sem transação;

MANDATORY: Se existir uma transação, participa da mesma, senão existir, será lançada uma javax.ejb.EJBTransactionException, pois com esse tipo é obrigatório que já exista uma transação corrente;

NOT_SUPPORTED: Se existir uma transação, a mesma será suspensa e o método será executado sem transação, senão existir, o método é executado normalmente sem transação;

NERVER: Se existir uma transação, será lançada uma javax.ejb.EJBException, pois com esse tipo não pode haver transação corrente, senão existir, o método é executado normalmente sem transação;

Exemplo de um método definindo o nível de propagação.

Commit e Rollback de Transações

Como sabemos o commit e rollback são as operações mais importantes quando lidamos com transações, o commit é o processo que efetiva com sucesso as operações realizadas dentro de uma transação, e o rollback é o processo que desfaz as operações realizadas dentro de uma transação.

Com transações do tipo CMT, o commit é realizado quando a chamada de um método transacionado é encerrada, em transações do tipo BMT, o commit deve ser realizado manualmente, invocando o método commit() da interface javax.transaction.UserTransaction.

Tratamento de Exceptions em Transações

Os EJB tratam as exceptions em duas categorias:

Application Exceptions: Para o Container, essas são aquelas cujo o cliente precisa saber tratar, ou seja, caso sejam lançadas o cliente deve realizar um tratamento de erro adequado, por padrão, as Applications Exceptions quando lançadas dentro de um método transacionado em beans do tipo CMT, não ocorre o rollback automático.

Exemplo de rollback com uma Application Exception.

System Exceptions: Esse tipo de exception são aquelas cujo o cliente não precisa saber realizar o tratamento, ou seja, são todas as exceptions que herdam de java.lang.RuntimeException ou java.rmi.RemoteException, por padrão, as System Exceptions quando lançadas dentro de um método transacionado em beans do tipo CMT, ocorre o rollback automático.

Rollback em Beans CMT

Para mudar o comportamento de uma Application Exception, devemos configura lá com a anotação @javax.ejb.ApplicationException, setando o atributo rollback com o valor true, assim quando esta exception for lançada em um método transacionado em um bean do tipo CMT,  o Container irá realizar o rollback automaticamente, não havendo mais necessidade de realizar o processo manual.

Exemplo da marcação de uma Application Exception para rollback automático.
Ao desenvolver sistemas corporativos é muito importante saber lidar com transações, quase todos os sistemas acabam utilizando para alguma finalidade e para garantir a integridade das operações.

Até a próxima.

Gerenciamento de Transações com EJB - Parte 1

Olá pessoal, hoje iremos abordar um assunto muito importante dentro do mundo de aplicativos corporativos, que é o gerenciamento de transações.

Todo sistema de informação pode ter ou não necessidades de contextos transacionais, a adição de transações depende muito dos requisitos do sistema.

O que é uma Transação ?

O conceito de transação é muito amplo e possui várias definições,  uma transação é quando precisamos garantir que algumas operações que façam parte de um mesmo contexto sejam executadas em conjunto, assim é possível garantir a integridade dos dados e o sucesso de uma operação, as transações possuem 4 características: 
  • Atomicidade: Todo o fluxo de execução da transação deve ser realizado com sucesso, caso algum item venha a falhar, a transação deve ser desfeita;
  • Consistência: A transação deve garantir a integridade dos dados manipulados, os dados devem ser consistentes no começo e fim da transação;
  • Isolamento: Os dados de uma transação não podem afetar rotinas que não fazem parte da transação;
  • Durabilidade: As modificações realizadas dentro do escopo da transação, deve ser refletidas nos recursos envolvidos.
O fluxo de uma transação é o abaixo:
  1. A transação é iniciada;
  2. As operações são executadas;
  3. A transação é finalizada com:
    • Commit: Caso todas as operações sejam executadas com sucesso;
    • Rollback: Caso aconteça algo inesperado, fazendo com que a transação seja desfeita.
Para exemplificar o uso de transações vamos simular um cenário de venda, o processo consiste nas seguintes etapas: 
  1. Gerar o pedido;
  2. Encaminhar para lista de entrega;
  3. Realizar baixa no estoque.
Como exemplo, vamos simular que os passos 1 e 2 foram executados com sucesso, mas ao executar o passo 3, acontece algum erro no aplicativo, fazendo com que a operação não possa ser concluída.

Sem transação: Para este cenário a falta de transação seria muito problemático,  pois com a falha da etapa 3, teríamos a integridade e confiabilidade dos dados comprometida.

Com transação: A utilização de transação para este cenário é a forma mais indicada, pois com a falha da etapa 3, toda a transação seria desfeita, garantindo a integridade e a confiabilidade dos dados manipulados na operação.

Vale lembrar que a adoção de uma transação depende muito dos requisitos do sistema, a cenários onde não precisamos utilizar, e que caso seja utilizada de maneira indevida, podem prejudicar outros requisitos, como performance.

Transações Distribuídas

Transações distribuídas é um ponto com grande destaque na plataforma Java EE, com esse recurso podemos ter transações que envolvem mais de um recurso de persistência ou negócio, esse tipo de transação é dividido de 2 formas:

Local: Transação com apenas um recurso, ex:  uma base da dados, uma fila de mensagem, etc.
Global: Transação com mais de um recurso, ex: uma operação onde o contexto transacional pode envolver duas bases de dados, uma base de dados e uma fila de mensagem, etc.

A especificação EJB contempla a transação distribuída utilizando o protocolo de commit em duas fases, este protocolo permite que o gerenciador de transações consiga tratar uma transação com mais de um recurso e gerencie as operações de commit e rollback.

Isolamento de dados transacionais

Os níveis de isolamento de dados transacionais são disponibilizados pelas base de dados e tentam garantir como, onde, e quando os dados podem ser acessados.

Este isolamento deve ser analisado com muito detalhe, porque depende muito das regras de negócio, e a utilização de um nível inadequado, pode comprometer as funcionalidades de todo sistema.

Os isolamentos estão divididos basicamente em 4 níveis:
  • Read uncommited: Este nível é o mais baixo, ele permite que transações com este isolamento leia dados de outras transações que ainda não foram commitados;
  • Read commited: Este nível é o mais utilizado, ele permite que transações com este isolamento leia somente dados já commitados por outras transações.
  • Repeatable read: Este nível garante que uma transação leia sempre o mesmo conjunto de dados até o fim da transação, mesmo que neste tempo os dados sejam alterados em outras transações. 
  • Serializable: Este nível é o mais restritivo, ele bloqueia a tabela utilizada na transação até que a mesma seja concluída, com isso, é garantido que a tabela não tenha seus dados alterados no decorrer da transação, este nível deve ser usado com muito cuidado, pois pode trazer grandes problemas de performance no sistema.
Para mais detalhes sobre o suporte de transações com Java, veja o link oficial da Oracle sobre a Java Transaction API.

Agora que sabemos características de como uma transação funciona, podemos entrar em detalhes da utilização de transações com objetos EJB.

Até a próxima.

JBoss AS 7 - Instalação e Configuração

Olá pessoal, hoje iremos ver como instalar e configurar o JBoss AS 7, este é um dos Containers Java EE mais utilizados no mercado.

O que são Containers? 

Toda aplicação Java EE roda em cima de um Container, este é responsável pelo processamento e execução dos recursos que a especificação Java EE fornece, como por exemplo Servlet API, EJB, JMS, entre outros recursos da especificação.

No mercado basicamente existe 2 categorias de Containers, que são elas:
  • Java EE Containers: Estes dão suporte a toda especificação Java EE, são servidores robustos e com alta capacidade de execução, os mais populares e difundidos são: JBoss AS, Weblogic, IBM Webshepre, Apache Geronimo e Glassfish.
  • Web Containers: Estes são voltados para execução de aplicações web, os mais populares e difundidos são: Apache Tomcat e Jetty.
O JBoss AS

O JBoss AS é um Container Java EE e possui 2 segmentos de distribuição, um OpenSource e outro mantido pela RedHat, para maiores informações sobre ambas as distribuições visite os links abaixo:

http://www.jboss.org/

http://br.redhat.com/products/jbossenterprisemiddleware/

Neste tutorial iremos utilizar o JBoss AS 7 OpenSource.

Instalação e Configuração

Antes de tudo temos que efetuar o download  do JBoss, para isto, vamos acessar a página oficial do Container http://www.jboss.org/jbossas, e ir na opção Download, as seguintes páginas serão exibidas:


Página oficial do JBoss AS 7.


Página de Download com todas as versões disponíveis.

Atualmente a última versão estável do JBoss AS é a 7.1.1.Final, o JBoss segue o padrão de muitos outros softwares de desenvolvimento, onde basta efetuar o download e descompactar em um local desejado.

Após descompactar o arquivo, teremos um diretório chamado jboss-as-7.1.1.Final com o seguinte conteúdo:

Diretório de instalação do JBoss AS 7.
O próximo passo é configurar a variável de ambiente JBOSS_HOME, a tela de configuração de variáveis de ambiente é como a abaixo:
Tela de configuração de variáveis de ambiente no Windows.

Após todos os passos de instalação e configuração, agora iremos subir o serviço e analisar o funcionamento do Application Server, no Windows, basta executar o arquivo %JBOSS_HOME%/bin/standalone.bat, um prompt de comando será exibido:


Prompt de comando exibindo mensagens de log de inicialização do JBoss AS.

O JBoss como a maioria dos servidores web aloca uma porta para receber as solicitações, por default, esta porta é a 8080, então caso já exista outro serviço funcionando nesta porta, devemos especificar uma outra que esteja disponível, ou parar o serviço atual para que o JBoss posso alocar a 8080.

Para testar o funcionamento iremos acessar a tela inicial do JBoss, que é http://localhost:8080/, a seguinte tela será exibida:

Tela incial do JBoss AS 7.
Para acessar a tela de administração, basta clicar na opção Administration Console,  no primeiro acesso, será exibido uma tela fornecendo passos para criação de um usuário para a utilização, a tela exibida é como a abaixo:

Tela com passos para criação de usuário para a utilização do Administration Console.

Após a criação do usuário devemos acessar novamente o Administration Console,  e fornecer os dados de autenticação, agora a tela de administração será exibida:

Tela inicial do Administration Console do JBoss AS 7.
Com todos estes passos executados, o JBoss AS 7 esta pronto para a utilização e execução de aplicativos Java EE.

Até a próxima.

Criando arquivos de log com Log4J


Olá pessoal, hoje iremos ver como criar logs em aplicações Java com a ferramenta Apache Log4j.

O que é um arquivo de log ? 

Um arquivo de log, é um arquivo geralmente em formato texto onde as aplicações escrevem informações sobre seu funcionamento, erros, etc. 

É muito importante um aplicativo ter um arquivo de log, porque com ele conseguimos monitorar a execução e também diagnosticar os locais exatos quando um erro é gerado.

O maior exemplo de geração de logs, e que praticamente todo desenvolvedor já utilizou, são os logs de execução dos Containers Java, com estes arquivos é possível analisar todo o funcionamento do Container e também achar os métodos que lançam algum tipo de Exception na execução dos aplicativos.

O Log4J

O Log4j é uma ferramenta desenvolvida e mantida pela Fundação Apache, com ela podemos criar arquivos de log de maneira fácil e padronizada, sem dúvida o log4j é a ferramenta de log mais utilizada em aplicações Java, vários projetos open source a utilizam, entre elas estão Hibernate e Spring Framework.

O site oficial onde podemos efetuar o download e ter exemplos da utilização é o abaixo:

http://logging.apache.org/log4j/1.2/

Níveis de log

Um ponto importante a ser compreendido ao trabalhar com Log4J são os níveis de log, eles estão divididos em 4 níveis, que são eles:

DEBUG: é o maior nível de log, geralmente utilizado para detalhamento completo das operações realizadas no sistema.

INFO: nível utilizado para mostrar informações importantes, este nível geralmente é o mais utilizado.

WARNING: é geralmente utilizado para mostrar algo que requer atenção, mas não é considerado um erro no sistema.

ERROR: nível para rastreamento de erro, onde podemos exibir uma mensagem e também a exceção gerada.

Arquivo de configuração

Para utilizar o log4j devemos ter um arquivo de configuração onde descrevemos toda característica da geração de log, este arquivo pode ser um arquivo properties ou xml, neste tutorial iremos utilizar um arquivo no formato properties.

Aplicação de exemplo

Para mostrar o funcionamento do log4j, temos uma aplicação que irá gerar os arquivos de logs estruturados da seguinte forma:
  • Criar 2 arquivos, com isso cada parte do sistema poderia ter seu arquivo de log separado, por exemplo: separar o log de persistência do log de domínio;
  • Quebrar os arquivos de log por dia, assim cada dia teria seu arquivo de log, oque no momento de leitura dos arquivos ficaria mais fácil de encontrar uma informação.
O projeto ficou estruturado da seguinte forma:


Estrutura do projeto de exemplo.

Abaixo as 3 classes e o arquivo de configuração dos logs:

Classe de execução do aplicativo e responsável por carregar o arquivo de configuração de log4J.

Classe que escreve no arquivo app_one.log.

Classe que escreve no arquivo app_two.log.

Arquivo de configuração do log4J.

No arquivo de configuração, determinamos todas as configurações para gerar os arquivos de log, em nosso exemplo, as configurações são as seguintes:
  • Log ajustado para o nível de DEBUG;
  • Configurado para que o log seja exibido no console de execução da aplicação, isso á feito através do appender CONSOLE;
  • Criados appenders para salvar os logs em 2 arquivos de separados, estes appenders são ARQUIVO_APP_ONE ARQUIVO_APP_TWO;
  • Ajustado para que em ambos os arquivos, a quebra seja feita por dia, ou seja, a cada dia será gerado um arquivo diferente, com isso fica mais fácil a rastreabilidade de erros ao analisar os arquivos de log da aplicação.
Ao executar o aplicativo de exemplo, os arquivos de logs serão salvos no diretório logs, este diretório é determinado no arquivo de configuração, após a execução os arquivos terão o seguinte conteúdo:

Arquivos de logs gerados: app_one.log e app_two.log.

Agora para testar o funcionamento do log4J, altere o nível de log e veja o resultado nos arquivos gerados.

Até a próxima.

Integração entre o Eclipse IDE e o Tomcat

Olá pessoal, hoje iremos ver como integrar o Eclipse IDE ao Tomcat, assim ganhamos maior produtividade no desenvolvimento de sistemas Web com Java.

O Eclipse IDE

O Eclipse é uma IDE para desenvolvimento de sistemas muito utilizada, com ela podemos desenvolver sistemas com diferentes linguagens, como Java, PHP, C, C++, etc.

Para desenvolvimento Java, atualmente o Eclipse é a IDE mais utilizada no mercado, isso se deve a sua facilidade de uso, plugins e recursos que ajudam na produtividade.

O download do Eclipse, pode ser realizado através do link oficial, atualmente o Eclipse esta na versão 4.2 chamada de Juno:


A versão que iremos utilizar neste tutorial é a Eclipse for Java EE Developers, que é uma versão que além dos recursos do Eclipse Classic, possui recursos específicos para o desenvolvimento Java EE (Servlets, JPA, EJB, etc), o link para download é o abaixo:


O Tomcat

O Tomcat é um Web Conteiner desenvolvido pela Apache Foundation, atualmente é um dos Conteiners mais utilizados e possui um amplo suporte pela comunidade de desenvolvimento Java.

O download do Tomcat pode ser realizado através do link abaixo, atualmente esta na versão 7.0.37:

http://tomcat.apache.org/download-70.cgi

Deploy de Projetos Java

Para entendermos como e porque da integração entre Eclipse e Tomcat, vamos recapitular como que funciona a publicação de aplicativos Java em um Conteiner, este processo de publicação é chamado de deploy.

Existem algumas formas de realizar o processo de deploy, uma das mais conhecidas, é através da  geração do arquivo WAR (Web Archive), este arquivo agrupa toda a estrutura comum de um projeto web facilitando o processo de deploy.

Para realizar o deploy de um war existem várias formas, no Tomcat, podemos realizar por meio de upload na área de administrativa ou copiá-lo direto para o diretório webapps, mas este processo em um ambiente de desenvolvimento torna-se improdutivo, pois temos alterações contantes no projeto.

Para contornar todo este processo, podemos integrar a IDE com o Conteiner, assim ganhamos em produtividade no desenvolvimento, pois não temos que a cada alteração realizar todo o processo tradicional de deploy.

O Processo de Integração

A integração entre o Eclipse e o Tomcat é muito simples, basta seguir o wizard que a própria IDE fornece, como teste criei um pequeno projeto web com a seguinte estrutura:



Criamos também uma Servlet para acessar pelo browser interno da IDE:


Agora temos nosso projeto criado e os recursos prontos, vamos analisar como realizar a publicação do projeto no Tomcat dentro da IDE:
  1. Botão direto no projeto;
  2. Ir em Run on Server.
Após, devemos selecionar o Tomcat v7, como na tela abaixo:


Após, devemos adicionar o diretório de instalação do Tomcat, como na tela abaixo:


Agora para executar o projeto no Conteiner,  basta realizar o seguinte procedimento:
  1. Botão direto no projeto;
  2. Ir em Run on Server;
  3. Selecionar o Tomcat 7.
Será aberta uma janela com o browser interno do Eclipse, onde esta sendo realizada uma requisição a Servlet de exemplo, como mostrado na tela abaixo:



Um ponto interessante, é que toda configuração pode ser gerenciada por uma tela administrativa, onde podemos configurar Portas, Timeout, Tempo de Publicação, entre outras configurações:



A integração entre IDE e Conteiner é uma coisa muito comum, esta integração pode ser realizada com vários tipos de IDE e Conteiners diferentes.

Até a próxima.

Monitorando o Tomcat com Java VisualVM

Olá pessoal, hoje iremos ver como monitorar o serviço do Tomcat utilizando o aplicativo Java VisualVM, onde podemos analisar consumos de CPU, Memória, Threads, entre outros.

O Java VisualVM


O java VisualVM é um aplicativo que acompanha o JDK que permite o monitoramento dos serviços que estão sendo executados na JVM, com ele podemos analisar consumo de CPU, Mémoria (Heap, Stack, PermGen), Classes inicializadas, Threads, etc.

Por default esta localizado sobe o seguinte diretório:

JAVA_HOME/bin/jvisualvm.exe


O Tomcat 

O Tomcat é um Web Container desenvolvido pela Apache, é um dos conteiners mais utilizados e difundidos no mercado, atualmente esta na versão 7.0.35, segue links para download e informações:

http://tomcat.apache.org/download-70.cgi
http://tomcat.apache.org/tomcat-7.0-doc/index.html

Configurando o Tomcat

Para realizar a configuração do monitoramento do Tomcat através do Java VisualVM, temos que realizar algumas configurações na propriedade Java Options, para isso, vamos acessar o Tomcat Monitor e ir na aba Java, lá devemos adicionar as seguintes linhas:

-Dcom.sun.management.jmxremote.port=8086
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false

Estas linhas de configurações são necessárias para o monitoramento do serviço através de JMX, sendo elas a porta de acesso, se a conexão deve ser por SSL e se temos autenticação para realizar o acesso, de acordo com a imagem abaixo:



Configurando o Java VisualVM

Após toda configuração no Tomcat ser realizada, vamos analisar o Java VisualVM para entender seu funcionamento, sua interface de inicialização é a abaixo:


A configuração para acessar o serviço é muito simples, tudo é feito através de uma conexão JMX, para isso vamos no menu File e em Add JMX Connection, a seguinte interface será exibida e devemos informar os dados de conexão e o display name (este opcional)


Após isso já temos o serviço do Tomcat sendo monitorado pelo Java VisualVM, de acordo com a tela abaixo:


A principal aba de recursos de monitoramento é a Monitor, onde podemos analisar o consumo de CPU, Memória, Classes que estão inicializadas e as Threads que estão rodando no momento, abaixo podemos analisar esta tela:


Um outro recurso interessante é o monitoramento das Threads, localizado na aba Threads, de acordo com a tela abaixo:

O Java VisualVM é uma ferramenta interessante para dimensionar o consumo de nossas aplicações dentro do servidor de aplicação, ela possui vários recursos interessantes que podem ser usados para diagnosticar gargalos e evitar consumos excessivos de Mémoria, CPU, entre outros.

Para mais detalhes e funcionalidades desta ferramenta, consulte a documentação oficial da Oracle:


Até a próxima.

Métodos Utilitários da Classe String

Olá pessoal, hoje iremos abordar dicas de utilização de alguns métodos utilitários da classe String, estes ajudam muito no desenvolvimento de rotinas onde manipulamos Strings diversas.

Iremos abordar os seguintes métodos:
  • charAt(int index);
  • concat(String str);
  • contains(String str);
  • equals(String str);
  • length().

charAt(int index)
Este método é utilizado para recuperar um determinado char dentro de uma String, vamos simular a criação de uma String para analisar como este método funciona:


concat(String str)

Em Java é muito comum unir os valores de várias Strings em apenas uma, esta operação chamamos de concatenação, a classe String possui um método utilitário que ajuda a realizar esta operação, vamos analisar seu funcionamento:


contains(String str)

O método contains é muito utilizado quando manipulamos Strings, com ele podemos analisar se um determinado trecho de texto esta ou não dentro da String, este método retorna um valor boolean onde diz se a String possui ou não a sequência de chars passada como parâmetro, vamos analisar seu funcionamento:
















equals(String str)

Sem dúvida este é um dos métodos mais importantes para qualquer classe, este método é herdado da classe Object, que é a superclasse de qualquer hierarquia de classes Java.

Na classe Object a implementação de equals(Object obj) é muito simples e compara apenas se as referências apontam para o mesmo objeto, já na classe String temos uma implementação pronta onde oque é avaliado é o conteúdo do objeto.

A criação de objetos Strings em Java possui algumas particularidades que ajudam no desenvolvimento e desempenho do sistema, um que devemos entender é o conceito de Pool de Strings.

Ao criar Strings de forma literal e com o mesmo conteúdo, a JVM consegue manipular o uso dos objetos fazendo com que várias referências apontem para uma única instância de String, isso é possível pois todo objeto String é imutável, oque garante que a alteração de conteúdo não cause impacto nas outras referências que usem o mesmo objeto, este recurso de reaproveitamento de instâncias, é conhecido como Pool de Strings.

Vamos analisar um código onde iremos utilizar o operador == para avaliar Strings, segue o código:


























Agora vamos analisar as mesmas comparações com o método equals da classe String, segue o código:
























length()

Este método retorno um int contendo o total de chars que uma determinada String possui, com isto podemos navegar em cada char e manipular da forma que desejamos, vamos analisar o funcionamento do método:




















A classe String é uma das mais utilizadas ao desenvolver sistemas utilizando a linguagem Java, acima pudemos analisar o funcionamento de alguns métodos utilitários que a compõem, mas esta classe possui muito outros métodos interessantes, para mais detalhes consulte o JavaDoc no site da Oracle:

http://docs.oracle.com/javase/7/docs/api/java/lang/String.html

Até a próxima.