Utilizando o padrão Java Bean \ POJO em suas Classes Java

Classe JavaBean

Uma Classe Java Bean é um  POJO significa Plain Old Java Object, ou seja, o bom e velho objeto escrito em Java puro, mais ou menos é este o significado.


Por que utilizar um Java Bean?

Tal Classe segue o padrão da Oracle para Classes Java e que pode ser utilizada como entidades e que são mundialmente aceitas e permitidas em qualquer projeto. Caso você, nobre e caríssimo leitor, chegar em uma entrevista ou mesmo em uma prova destas de RH, um processo seletivo, e criar tal classe de forma correta, pode ser que o emprego não seja seu, mas pelo menos você estará sendo visto com outros olhos pelo técnico que irá fazer a entrevista com você.


Como é estruturado um Java Bean?

Um Java Bean precisa ser Serializado. Em caso de transferência da Entidade em um ambiente de cliente/servidor, ele possa ser transferido e resgatado com facilidade sem problemas em suas threads, onde ele possa ser sincronizado.

Um Java Bean precisa conter atributos privados. Estas Classes precisam respeitar o encapsulamento protegendo seus atributos e se comunicando com o mundo exterior através de mensagens, ou seja, através de métodos de leitura e escrita nestes atributos, os chamados Getters/Setters.

Um Java Bean precisa conter um construtor vazio. Como padrão, tal Classe precisa de um construtor padrão criado para que seja criada. Esta é a forma mais primária para se inicializar tal classe, muitos frameworks, tais como Hibernate, nos obriga a ter pelo menos um construtor Default em nossa Entidade, se suas Classes sempre forem Java Beans, isso não será problema, por isso que devemos sempre utilizar este padrão.

Um Java Bean precisa conter um construtor com parâmetros. Para receber todos os valores dos atributos dentro do domínio da Classe, não é preciso colocar os relacionamentos, apenas os atributos padrão. Este construtor serve para que quando instanciamos a Classe já possamos passar todos os valores diretamente para ela sem a necessidade de usar os métodos para passar as mensagens.

Um Java Bean precisa conter métodos publicos Getters\Setters. Estes métodos servem de entrada\saída para acesso aos atributos pelas classes externas ao pacote.

Um Java Bean precisa sobrescrever o método ToString(). Este método deve imprimir o conteúdo do objeto, a forma correta é o método retornar todos os valores dos atributos, no modo padrão, quando o objeto é impresso, ele apenas mostra o caminho do objeto e não o seu conteúdo. Tal método é oriundo da Super Classe java.lang.Object.

Um Java Bean precisa sobrescrever o método HashCode(). Este método serve para controlar as instâncias em memória, com ela é possível verificar quais são e quando equals() é acionado, HashCode ajuda na diferenciação dos objetos. Tal método é oriundo da Super Classe java.lang.Object.

Um Java Bean precisa sobrescrever o método Equals(). Este método verifica se objetos são idênticos, o padrão é uma forma muito pobre de verificação e um tanto fraca, também é importante a sobrescrita deste método.

Um Java Bean precisa conter uma identificação única. Este atributo é opcional, mas ter um id é muito importante para controlar a ocorrência de tais entidades e objetos.

Tal método é oriundo da Super Classe java.lang.Object.
Abaixo, vemos na prática uma Classe JavaBean POJO.

package com.blogger.peripeciasdesenvolvedor.entidade;

import java.io.Serializable;

public class JavaBeanPadrao implements Serializable{

private static final long serialVersionUID = 8982198782797245834L;

 //Atributos 
 private Integer id;
 private String nome;
 private String sobrenome;
 private String email;
  
 //Construtor Padrão
 public JavaBeanPadrao() {
  
 }

 //Construtor com Parâmetros
 public JavaBeanPadrao(Integer id, String nome, String sobrenome,
   String email) {
  super();
  this.id = id;
  this.nome = nome;
  this.sobrenome = sobrenome;
  this.email = email;
 }

 //Getters e Setters
 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getNome() {
  return nome;
 }

 public void setNome(String nome) {
  this.nome = nome;
 }

 public String getSobrenome() {
  return sobrenome;
 }

 public void setSobrenome(String sobrenome) {
  this.sobrenome = sobrenome;
 }

 public String getEmail() {
  return email;
 }

 public void setEmail(String email) {
  this.email = email;
 }
 
 //Sobrescritas de java.lang.Object
 @Override
 public boolean equals(Object obj) {
  
  if (obj instanceof JavaBeanPadrao){
   JavaBeanPadrao pojo = (JavaBeanPadrao) obj;
   
   if (pojo.id != null && this.id != null){
    return pojo.getId().equals(id);
   }
  }
  
  return false;
 }

 @Override
 public int hashCode() {
  
  return this.id != null ? this.id.hashCode():0;
 }

 @Override
 public String toString() {
  
  return this.id + ", " + this.nome + ", " + this.sobrenome + ", " + this.email;
 }

}

Vamos agora para a implementação deste nosso Java Bean.
O exemplo abaixo,ilustra o uso do construtor padrão, setters e impressão com ToString().

package com.blogger.peripeciasdesenvolvedor.principal;

import com.blogger.peripeciasdesenvolvedor.entidade.JavaBeanPadrao;

public class Principal {

 public static void main(String[] args) {
  
  //Instancia do POJO construtor padrão
  JavaBeanPadrao pojo = new JavaBeanPadrao();
  
  //Populando os atributos através do encapsulamento
  pojo.setId(1);
  pojo.setNome("Gabriel");
  pojo.setSobrenome("Simas");
  pojo.setEmail("gabrielsimas@gmail.com");
  
  //Imprimindo via ToString()
  System.out.println(pojo);
  
 }

}

A saída do exemplo acima é:

1, Gabriel, Simas, gabrielsimas@gmail.com
Como podemos notar no código anterior, a saída e justamente o nosso método ToString() modificado corretamente, veja que existe uma diferença, posto que o resultado está totalmente transparente e também demonstra como o nosso setter é eficiente de forma que passou os valores para os atributos corretamente, sem a necessidade de acessá-los diretamente. O próximo trecho de código ilustra o uso do construtor com parâmetros e sua posterior Impressão.

package com.blogger.peripeciasdesenvolvedor.principal;

import com.blogger.peripeciasdesenvolvedor.entidade.JavaBeanPadrao;

public class Principal {

 public static void main(String[] args) {
  
  //Instancia do POJO com construtor com parametros
  JavaBeanPadrao pojo = new JavaBeanPadrao(1, "Gabriel", "Simas", "gabrielsimas@gmail.com");
  
  //Imprimindo via ToString()
  System.out.println(pojo);
  
 }

}

O resultado deste código será
1, Gabriel, Simas, gabrielsimas@gmail.com
O resultado é o mesmo, sendo que escrevemos bem menos para atingir o mesmo resultado, este tipo de modificação se chama refatoração ou refactoring, onde executamo as mesmas tarefas de forma otimizada.
Neste artigo vimos como se constrói um Java Bean simples e funcional, o que nos dará uma boa base para os próximos artigos, lembre-se que neste Blog, a informação é sempre sequencial, ou seja, um artigo complementa o artigo anterior de forma a sempre utilizar o que já fora mostrado aqui. Lembre-se sempre de fortalecer o trabalho em equipe, afinal de contas, não se vence sozinho. Forte Abraço, muito obrigado por sua visita e até a próxima.