Categoria: Hibernate

Criteria Hibernate na Prática

olá Pessoal,

Se você está iniciando com Hibernate um dia vai ser apresentado ao Criteria. Realmente quem usa Criteria não quer voltar ao SQL para as funções mais básicas, e sim para os casos extremos onde o Criteria não atende a um requisito que só temos no SQL. Então neste post, vou mostrar um pouco o que se pode fazer com o Criteria nas suas aplicações Java. Farei uma breve introdução ao Criteria neste primeiro post, no próximo, vamos colocar mão na massa de fato. Mas, por enquanto quero que conheçam um pouco a sintaxe.

Lets go…

Criteria

Criteria Query API permite construir query expression em Java permitindo assim a checagem em tempo de compilação, ao contrário do HQL ou SQL que não permite. Criteria API permite de forma programática construir objetos query a partir da interface org.hibernate.Criteria. Esta interface define os métodos disponíveis que precisamos trabalhar com Criteria.

Para persistir um objeto da classe, usamos o método createCriteria() que retorna um objeto Criteria que permite ter acesso a instância de persistência da classe. O createCriteria() pertence a interface Session. Então se preciso retornar todas propriedades de uma classe com Criteria, seria assim:

Criteria critera = session.createCriteria(Produto.class)

List lista = criteria.list();

Mais simples que HQL. Este é o mesmo resultado com o from Produtos que executamos no HQL e que fazemos no SQL: SELECT * from mytable.

Vamos dizer que precisamos obter os produtos que tenham no nome “smart phone” então precisamos conhecer o método add() da classe Criteria que tem como objetivo adicionar uma restrição em seu argumento. Uma outra classe importante é Restrictions class do pacote org.hibernate.Criterion que possui métodos static para as condições de restrições que precisamos. Veja o trecho do código:

Criteria crit = sesion.createCriteria(Produto.class)

crti.add(Resctrictions.eq(“nome”, “smart phone”);

List list = crit.list();

Explicando o código:

Na primeira linha criamos o objeto Criteria que fez a persistência em nossa entidade. Na linha dois costumo ler da seguinte forma para facilitar a compreensão: “adicionando uma restrição a class persistida”. Na linha 3 é o resultado da restrição.

Um ponto importante é que não podemos fazer uma restrição de resultado usando o método eq/ne para propriedades com o valor null. Para isso há um método static especifico o isNull() e o isNotNull().

Para realizar busca temos os métodos like() e ilike() estes servem quando precisamos buscar algo fornecendo “meia duzia” de informação para o buscador. Exemplo: traga todos os produtos que tem na palavra “smart”. A diferença é que o ilike é case-insensitive.

Outro detalhe importante que podemos informar aonde buscaremos a palavra, ou seja, no inicio, no final, ser exato, ou em qualquer lugar. Exemplo:

Criteria crit = session.createCriteria(Produto.class)

crit.add(Restrictions.like(“nome”, “smart%”));

List list = crit.list();

% informa que busca por partes da string. No exemplo a seguir digo para buscar no final da String.

Crit.add(Restrictions.like(“nome”, “smart”, MatchMode.end));

MatchMode é um tipo de enumeration que possui 4 tipos diferentes de match: anywhere, end, exact, start.

Done! E assim finalizo o primeiro post sobre Criteria, no próximo veremos mais algumas restrições interessantes.

Espero que tenham gostado do post.

Abracos, see you next post! 🙂

Iniciando com Hibernate

olá Pessoal,

Estarei dando inicio à uma série de posts sobre o Hibernate. O motivo é que sofri no inicio como todo iniciante. Principalmente nos princípios básicos.E ainda tenho meus sofrimentos quando preciso de algo mais avançado e bem especifico a um problema ou sistema legado onde o Hibernate está presente, dai vem o nosso amigo google, consultando os colegas mais vividos com a tecnologia etc. Mas, nos posts vou buscar dar uma luz para quem acha que está na escuridão, nesse inicio com o framework. Apesar que já temos alguns posts usando o Hibernate que podem ser visto aqui. Hoje veremos como usar Hibernate e para não ficar um post grande e cansativo, vou limitar a recursos simples do framework. Então veremos como configurar o Hibernate em um projeto java e depois ver o “brinquedo” funcionando.

Lets go…

Requisitos

  • Instalação Mysql 5 ou superior
  • Instalação Java 5 ou superior
  • Eclipse (qualquer versão)

Note

Usarei o Hibernate 3.2.x, pois é que tenho aqui nos meus projetos. Como ainda não tive a necessidade baixar a versão mais recente, mas para o que vamos fazer aqui, não precisa ser a versão mais recente.

Não usarei annotations nest post, até pq temos um post já sobre o assunto, então vou usar mapeamento, o motivo é que na minha opinião todos que vão iniciar com Hibernate precisar conhecer os mapeamentos XML, antes de ir para os Annotations. Os mapeamentos ainda é uma realidade em sistema legado, e vale lembrar que sistema legado eles representam uma boa parcela de oportunidades no mercado Java que pedem o Hibernate como framework. Não esqueça disso. Pois, um dia você vai precisar entender o mapeamento que alguém fez há alguns anos atras.


Preparação do ambiente

  1. primeiro passo é baixar o hibernate core no site www.hibernate.org para esse exemplo estou usando a versao Hibernate 3.2.1.GA e o Hibernate tools 3.24.ga
  2. Descompacte os arquivos
  3. abra o eclipse
  4. vá em windows preferences e digite user no campo de filter do eclipse
  5. Clique em New e em nome coloque Hibernate 3.2
  6. Agora vamos adicionar os .jars a essa biblioteca clique em add external jars.
  7. Bem, eu poderia simplesmente dizer selecione todos os arquivos da pasta lib do hibernate, mas não é necessário pois muitos arquivos nem serão executados. Veja na imagem abaixo os arquivos que vc precisa adicionar
  8. Mas, como vc sabe que sao esses arquivos Camilo? Simples, tem um arquivo chamado _README.txt na pasta lib do hibernate e lá ele informa quais arquivos são required. Se tiver dúvida dar uma olhada.
  9. Detalhe importante o arquivo hibernate3.jar não fica em lib e tb não consta na lista de arquivo required no _README.txt, mas vc deve adiciona-lo ele é essencial. Esta informação você consegue na documentação do Hibernate.
  10. Uma vez pronto a library com o Hibernate, faça o mesmo para o Driver MySql. Crie uma nova library e adicione o .jar do Banco de Dados. Obtenha o Driver do site da MySQL: http://www.mysql.com/downloads/connector/j/5.1.html
  11. Crie um Java Project no Eclipse
  12. adicione as bibliotecas no seu projeto. Clique com o botão direito e vá em propriedades ==> Java Build, na aba escola libraries e clique em add library ==> user library e marque as library que acabamos de criar.

Desenvolvimento

  1. Chegamos na parte mais divertida – “desenvolvimento”. Crie um package em src chamado br.com.bean
  2. E crie uma classe chamada de Message (sem o metodo main). Agora deixe a classe conforme abaixo. 
    package br.com.bean;

public class Message {
	private String message;

	public Message() {
		// TODO Auto-generated constructor stub
	}
	public Message(String message) {
		this.message = message;
	}
	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}

}
  3. Crie uma classe chamada TesteMessage (com o método main) e deixe conforme abaixo.
    4. 
package br.com.bean;



import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;



public class PopulaMessage {



	/**

	 * @param args

	 */

	public static void main(String[] args) {

		SessionFactory factory = new Configuration().configure().buildSessionFactory();

			Session session = factory.openSession(); 

			session.beginTransaction(); 

		Message m1 = new Message("lopes"); 

			session.save(m1);//salvando o objetos persistenced 

			session.getTransaction().commit();

			session.close();

		System.out.println("Salvo com sucesso no banco de dados");

	}


}
  4. por enquanto s isso, vamos agora criar os arquivos de configuração do hibernate com o BD + o mapeamento com classe.

Configuração Hibernate

  1. Abra a perspective Hibernate e depois vá em File ==> New ==> e escolha a opção conforme a imagem abaixo:
  2. clique em next.Escolha a classe que será mapeada, ou seja, Message. clique em add class
  3. clique em finish
  4. E agora adicione os codes abaixo(tive que colocar no formato de imagem, para evitar que o código fosse quebrado pelo plugin):
  5. Vamos criar o arquivo de configuracao Hibernate com o BD para isso faça o mesmo processo do passo 1, porem escolha a opcao conforme a imagem a seguir:
  6. Deixe o nome padrao sugerido e clique em next
  7. agora escolha o projeto e o package. No meu caso será MessageEx/src .
  8. Na próxima tela precisamos configurar o BD.Então deixe conforme a imagem a seguir:
  9. Apos ter configurado clique em finish
  10. Adicione o code a seguir no arquivo de configuração (hibernate.cfg.xml). É apenas o mapeamento da classe que representa nossa table no BD. Afinal de contas o hibernate precisa saber em que tabela ele deve obter/inserir informações, por isso usamos o mapeamento.

    <mapping resource=”mapping.hbm.xml”/>

    Ficando assim todo o codigo:

Testando

  1. para testar é bem simples. Vá na classe TesteMessage.java e clique em Run==> Java Application.
  2. Em seguida verifique se a informação foi inserida no BD. Não esqueça de dar um start no BD. Caso contrario receberá várias exceções.

Bom, vou ficando por aqui espero que o post tenha ajudado e motivado aqueles que estão iniciando com Hibernate. Abracos e até o proximo post. 🙂

Relatório Ireport + JasperReport com Hibernate

olá Pessoal,

Neste post vou mostrar como gerar um relatório usando Ireport de onde as informações vem do BD. Além disso usaremos o Hibernate para conexão. É bem comum uma aplicação o cliente querer algum tipo de relatório. Para gerar os relatorios vamos usar Ireport e o JasperReport. Fiz uma pesquisa rapida na internet e vi alguns posts eram limitados à criar relatórios sem banco de dados, alguns com banco de dados, porem confusos de entender eu sentir dificuldade de compreender,levando em conta que nunca tivesse visto o assunto. E no “mundo real”, se gera relatório de uma base de dados, que na maioria das vezes é um banco de dados. Bom eu tentarei ser pratico no post e a teorica abordada aqui será o suficiente para saber o que significa se deseja se aprofundar no assunto sugiro usar o velho Google e participar das comunidades ou comprar um livro.

Outro ponto  é que neste post será um Java Project normal, em outro post veremos como fazer isso em JEE em um projeto JSF.

Lets go..

Iniciando

Vou levar em conta, que você já tem um BD e uma tabela de onde deseja extrair a informação. Essa é a minha:

ireportbdus

Requisitos:

Você precisa fazer o download do Ireport. A versão mais recente é 3.7.6 neste momento que escrevo o post.


Configuração

copiar os .jars que estã na pasta ext do Ireport para o projeto Java . Se for JEE, adicionar na pasta lib. Não esquecer do .jar para o banco de dados caso os dados relatório venha de um banco de dados, que é o mais real e comum.

  • commons-beanutils

  • commons-collections

  • commons-digester

  • commons-logging

  • groovy-all

  • iText

  • poi

  • jasperreports


Veja o que é Ireport & JasperReport (de forma simples e direta):

Ireport = é uma especie de IDE para criação do layout do seu relatório, ou seja, que cara vai ter e o que vai ter no seu relatório. E é aqui que fazemos a conexão com o banco de dados e consequentemente as tabelas e onde informamos quais colunas de uma tabela vai aparecer no relatório. Ele gera um arquivo .jrxml que será lido por JasperReport.


JasperReport = É uma API que permite nossa classe Java estabelecer uma “conversa” com o nosso layout-relatório. Isso vem a ser util para que sua aplicação Java, gere relatórios em um único ambiente. O usuário não percebe que foi gerado por algo “fora” Java(isso para aqueles que sabem o que é Java).

Na pratica como acontece:

– o desenvolvedor vai lá e cria o layout do relatório com base no proposito deste e põe logomarca da empresa e os dados que devem aparecer. Não precisa ser um webdesigner para desenhar o layout. E é no Ireport que falamos de onde vem a info se será de um BD ou não.

-No JasperReport apenas setamos onde está o layout .jrxml do Ireport e em seguida informamos e é aqui que informamos para qual tipo vamos exportar o relatório: PDF,XML, HTML, TEXT. Podemos dizer que será gerado um arquivo em um local especifico ou se for um JEE, que vai ser carregado pelo Browser.

Note: os nomes das variaveis da classe devem estar iguais aos nomes dos campos (fields) no layout do relatório.

Mão na massa

Vamos colocar mão na massa por partes:

Parte 1: ir para o Ireport (não vou enumerar porque vai ficar zuado a formatação)

vamos primeiro criar um arquivo no Ireport e seguir as instruções do assistente que é bem simples:

ireportimg1

Na parte de banco de dados basta informar os de conexão do banco.

ireportimg2

Feito isso temos o o relatório na tela e podemos edita-lo. Observe que já foi montando com os dados do banco de dados, ou seja, com os nomes da coluna e nos devidos locais, isso acontece no Ireport mais recente, as vezes antigas não faziam isso.

ireportimg3

Parte 2: No Eclipse

Agora no Eclipse precisamos criar um projeto. Este será um Java Project.

Passos:

-Crie o Bean (os nomes entre o bean e os fields no layout devem ser os mesmos)

-Crie conexão com banco de dados (usamos o Hibernate)

-Crie um método List na classe DAO usando HQL com a query que deseja;

-importar para o projeto do eclipse o arquivo jrxml

-crie a classe main com exportando o relatório


Abaixo veja a estrutura do meu projeto

ireportprojectbdmain

note: é recomendavel colocar o .jrxml em um package para terceiro não ter acesso, mas coloquei fora só para mostrar que é possível rodar fora sem problemas algum.

A classe Bean

  1. @Entity
  2. @Table(name=“tusuario”)
  3. public class Usuario {
  4. @Column
  5. private String nome;
  6. @Column
  7. private String email;
  8. @Id
  9. private int id;
  10. //gets/sets omitidos

Gerando o relatório

Essa é a classe principal que de fato faz gerar o relatório em PDF, pegando o layout definido no Ireport o JasperReport faz a conversão, veja:

  1. public class GerarRelatorio {
  2. public static void main(String[] args) throws JRException,SQLException {
  3. System.out.println(“Gerando relatório…”);
  4. UsuarioDAO usuarioDAO = new UsuarioDAO();
  5. List listaUs = usuarioDAO.listaTodos();
  6. JasperReport pathjrxml = JasperCompileManager.compileReport(“relatorio/reportex.jrxml”);
  7. JasperPrint printReport = JasperFillManager.fillReport(pathjrxml, null, new JRBeanCollectionDataSource(listaUs));
  8. JasperExportManager.exportReportToPdfFile(printReport, “relatorio/reportex.pdf”);
  9. System.out.println(“Relatorio gerado”);
  10. }

Entendendo o código acima

Minha classe UsuarioDAO: ela retorna todos os usuarios atraves de uma query HQL.

  1. public List listaTodos(){
  2. Query query = getSession().createQuery(“from Usuario”);
  3. List listaUs = query.list();
  4. return listaUs;
  5. }

Note: Informando o JRXML: Link interessante

Na classe relatório precisamos informar onde está o arquivo jrxml(nao esqueca de criar o folder)

  1. JasperReport report = JasperCompileManager.compileReport(“relatorio/reportcamilo.jrxml”);

Dica:

Se o jrxml estiver no mesmo package que a classe que gera o relatório o código acima é valido do contrario, deve ser conforme abaixo:

  1. “../relatorio/reportblog.jrxml”

Passando o DATA SOURCE

O data source nada mais eh que uma lista com os dados que serao inseridos no relatorio.

  1. JasperPrint print = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(listaUS));

obs. No primeiro argumento temos o caminho do layout do relatorio gerado pelo ireport, parametro pode ser null e criamos um data source com o conteudo da lista que tem o resultado HQL

  1. class dao
  2. public List listaUsuario(){
  3. Query query = getSession().createQuery(“from Tusuario”);
  4. List lista = query.list();
  5. return lista;

em outra classe ….
TUsuarioDAO tusuariodao = new TUsuarioDAO();
List listaUS = tusuariodao.listaUsuario();

em outra classe …

  1. TUsuarioDAO tusuariodao = new TUsuarioDAO();
  2. List listaUS = tusuariodao.listaUsuario();

Exportando para um Formato

Para exportar temos metodos para cada formato de exportacao

  1. JasperExportManager.exportReportToPdfFile(print,“relatorio/RelatorioUser.pdf”);

obs. No primeiro argumento temos a variavel que tem o relatorio preenchido e o caminho que deve ser exportado .So rodar a classe main, agora.

Download do Projeto

Vou ficando por aqui espero que tenham gostado do post.

See you next post. 🙂

JNDI com Hibernate – Ambiente de Test

Olá Pessoal,

No post de hoje, vou apresentar como usar JNDI dentro do seu arquivo hibernate.cfg.xml dentro de um ambiente de teste. Em outro post falarei como usar em um ambiente de produção e ver que fica mais fácil realizar mudanças nas conexões de modo mais fácil, uma vez que normalmente o ambiente de teste possui configurações levemente diferente do ambiente de produção desde nome do usuário, até o path do BD.

Lets go…

Starting/Nosso Cenário

Eu já falei aqui no blog sobre pool de conexão no TomCat e JNDI, porém não falei como usar o JNDI dentro do Hibernate.

Aqui veremos isso com um framework bem utilizado no mercado que é o Hibernate.

Mas, a pergunta que você pode está fazendo: “Camilo, por que eu usaria isso?”, “Qual a diferença na pratica?”

Como sempre gostei de ser mais pratico e menos teorico, eu também tive essa dúvida rs. Porém, descobrir a grande produvidade quando tive 6 projetos diferentes para Produção e sempre quando tinhamos um release, era fato de esquecer de mudar o hibernate.cfg.xml, para as conexões de produção, fora que toda vez já era um saco, porque tinha que configurar sempre no ambiente de desenvolvimento antes de enviar para prod.

Enfim, na pratica você só vai configurar em um lugar as config de conexão, em um único arquivo e mais nada. E o melhor, quando for pra PRODUÇÃO, veremos que lá temos outro arquivo JNDI só para PROD, que normalmente não tem porque mudar com frequência. E nos desenvolvedores precisamos apenas saber o JNDI correto, e o administrador do Servidor que se vire lá com as configs, do arquivo de conexão em produção. Isso é extremamente importante, trabalhei em um projeto do qual nos desenvolvedores não tinhamos acesso as senhas, pw de produção, somente os administradores, para nos o que importava era apenas o path do JNDI e mais nada. Para quem trabalha fazendo todos os papeis (isso lembra meu tempo de freelance rs) desenvolvedor,administrador, DBA, isso parece ser estranho, mas em projetos grandes que participei na IBM , não é assim que funciona. Desenvolvedor é desenvolvedor,Testador é testador e por ai vai. E em ambiente teste você tem até acesso ao BD, PW etc. Mas, em produção. Not.

Hoje estarei limitado ao ambiente de teste, porque no ambiente de produção há algumas mudanças significativas e quero deixar o post focado à um assunto.

Nosso projeto

Criei um projeto muito simples, pois a funcionalidade está no uso de JNDI com Hibernate em teste. Não passa de um projeto com JSF + Hibernate. Porém,vc pode configurar isso em qualquer projeto com Hibernate para que ele funcione com JNDI.


Primeiro passo:

É configurar o arquivo web.xml do seu projeto com o nome do JNDI que deseja, pode ser o nome do seu cachorro, da sua namorada, o que você quiser.

<resource-ref>

<res-ref-name>jdbc/lpjava</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

Segundo passo:

Após ter configurado o web.xml, informando que a conexão para o BD estará naquele path. Vamos configurar o nosso JNDI, com os dados de conexão. Em ambiente de teste, vamos configurar o arquivo context.xml que está na pasta Server do Eclipse. É nele que vai estar as config locais. Insira dentro da tag Context o Resource abaixo:

<Resource auth=“Container”

name=“jdbc/lpjava”

driverClassName=“com.mysql.jdbc.Driver”

maxActive=“20” maxIdle=“10” maxWait=“-1”

type=“javax.sql.DataSource”

url=“jdbc:mysql://localhost/apptestes”

password=“lpjava”

username=“camilolopes”

validationQuery=“SELECT 1”

testOnBorrow=“true”

testWhileIdle=“true”

timeBetweenEvictionRunsMillis=“10000”

minEvictableIdleTimeMillis=“60000” />

Observe que informamos o nome do JNDI, que este tem referencia.

Terceiro passo:

Feito isso, vamos informar ao Hibernate que ele vai usar uma conexão JNDI, para o Hibernate o que importa é o path, se amanha você muda a senha de conexão vai precisar alterar apenas o arquivo context.xml que está na pasta Server dentro do Eclipse, lembrando que isso em ambiente de teste. Abaixo como ficou meu arquivo hibernate.cfg.xml

<hibernate-configuration>

<session-factory name=“hibernate/SessionFactory”>

<property name=“hibernate.connection.datasource”>java:/comp/env/jdbc/lpjava</property>

<property name=“hibernate.current_session_context_class”>thread</property>

<property name=“hibernate.transaction.factory_class”>org.hibernate.transaction.JDBCTransactionFactory</property>

<property name=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect</property>

<property name=“hibernate.jdbc.batch_size”>0</property>

<mapping class=“br.com.camilolopes.bean.TUsuario”/>

</session-factory>

</hibernate-configuration>

Quem usa o Hibernate ou está começando vai ver que não temos mais a property para o password ou user, uma vez que há uma referencia para um path, onde este tem referencia para um arquivo (context.xml) onde está de fato nossa conexão.

Finalizando

Teste sua aplicação, mande executar e faça uma persistencia, porem não deixe de verificar se já deu um start no banco de dados, se todos os .jars referente ao Hibernate estão no projeto e no caso do Eclipse olhe se está fisicamente na pasta lib do projeto.

Vou ficando por aqui, espero que tenham gostado do post.

Abracos, see ya guys!!! 🙂

Uma simples aplicação Hibernate + JSF + poolConexao

olá Pessoal,

Bem, hoje resolvi fazer um post, do qual eu já tive problemas e acredito que alguém já passou ou passa por isso. Vc nunca ficou perdido nos passos de como desenvolver uma nova aplicação usando um conjunto de frameworks? Tipo, por onde começar? Quando você faz isso com frequência não tem como esquecer, mas não é a realidade, nem todo dia estamos criando novas aplicações e alguns processos base, “dão branco”. Eu sofria com isso, quando precisava iniciar uma nova app do zero. Claro que hoje temos ferramentas que nos ajuda. Mas, vamos esquecer essas ferramentas de auxilio e pensar em um ambiente que não temos ela disponível.

O objetivo deste post, é documentar tópicos  para que você possa montar uma pequena estrutura para o ambiente de produção e ao mesmo tempo ir reelembrando aquilo que seu cerebro deixou no “pool” dele. Usarei o Hibernate + JSF tendo o pool de conexão implementado.

note: Claro em projetos reais e grandes não fazemos isso, para não perder tempo e tb não é nada legal. Porém, se você está começando agora a fazer aplicações sem muita experiência, procure sempre lembrar a funcionalidade de cada framework dentro do projeto e quando eles aparecem no desenvolvimento isto é tão importante qto saber usar cada um deles.

Lets go…

note: vou considerar os passos abaixo para um ambiente de produção, pois em testes raramente temos problemas. Um deles é o open session view que só descobrir ele quando subir minha app.

Steps

  1. Ter o BD e tabelas criadas

  2. criar a estrutura do projeto JSF Project

  3. Adicionar as bibliotecas dos frameworks

  4. criar o bean e fazer os annotations (não queira usar xml )

  5. criar o JNDI META-INF/context.xml

  6. criar o pool de conexao com o JNDI em web.xml (Resources)

  7. atualizar o hibernate.cfg.xml com o JNDI/Pool de conexão.

    current_session_context_class: thread

    connection.datasource: java:com/env/jdbc/nomejndi

    transaction.factory_class:org.hibernate.transaction.JDBCTransactionFactory

    jdbc.batch_size:0

  8. criar o DAO Generico com Hibernate no package dao

  9. Criar a classeDAO para fazer a persistencia no BD

  10. criar o managebean e controlador para JSF

  11. iniciar a construção do front end com JSF.

  12. Implementar o SpringSecurity (optional)

  13. Implementar o Filter para evitar o open session view

Claro que nesses passos há temos apenas  os pontos chaves que acabam reativando o conhecimento que está la no “pool de string” do seu cerebro.

Visite a nossa as categorias abaixo no blog que boa parte dos assuntos listados nos passos estão nas respectivas categorias:

https://blog.camilolopes.com.br/category/hibernate/

https://blog.camilolopes.com.br/category/java/

https://blog.camilolopes.com.br/category/javaee/

https://blog.camilolopes.com.br/category/jpa/

https://blog.camilolopes.com.br/category/jsf/

Abracos, see you next post. 🙂