RSS

JBoss e JPA – Configurando o acesso ao banco de dados

Em posts anteriores, configurei o acesso ao banco de dados utilizando o Hibernate e o JPA. Os links são:

Neste post, irei explicar como configurar o acesso ao banco de dados no servidor de aplicações JBoss Application Server 7 (JBoss AS 7). Para quem não conhece o JBoss AS 7 ou não sabe o que é um servidor de aplicações para o Java, é possível encontrar material em:

Este post não inclui a instalação do servidor, ou seja, é necessário instalar o JBoss AS 7 para depois conseguir seguir o exemplo que irei demonstrar aqui.

Primeiro escolha o banco de dados que irá utilizar, baixe o drive do banco para Java (JDBC). Entre na pasta de instalação do JBoss AS 7 e encontre a subpasta modules. No meu exemplo estou acessando um banco de dados Postgresql, então dentro de modules, encontre a subpasta org e se ainda não existir, crie dentro de org a subpasta postgresql. Entre na pasta postgresql e crie uma subpasta main. Copie para a pasta main o arquivo do drive JDBC para o Postgresql e crie o arquivo module.xml com o seguinte conteúdo:

<?xml version=”1.0″ encoding=”UTF-8″?>
<module xmlns=”urn:jboss:module:1.0″ name=”org.postgresql”>
<resources>
<resource-root path=”postgresql-9.1-902.jdbc4.jar”/>
</resources>
<dependencies>
<module name=”javax.api”/>
<module name=”javax.transaction.api”/>
</dependencies>
</module>

Crie o banco de dados e em seguida entre na pasta do JBoss AS 7, subpasta standalone, configuration e edite o arquivo standalone.xml. Dentro deste arquivo localize a tag datasources e adicione o drive para o banco de dados que irá utilizar. No meu exemplo foi adicionado o seguinte conteúdo:

<driver name=”postgresql-driver” module=”org.postgresql”>
<xa-datasource-class>org.postgresql.Driver</xa-datasource-class>
</driver>

Agora é necessário configurar o acesso ao banco de dados. Para isto, no mesmo arquivo e tag datasources do exemplo anterior, adicione o conteúdo para identificar o banco de dados conforme abaixo:

<datasource jta=”true” jndi-name=”java:/pgjOpenProject” pool-name=”pgjOpenProject” enabled=”true” use-java-context=”true”>
<connection-url>jdbc:postgresql://localhost:5432/jopenproject</connection-url>
<driver>postgresql-driver</driver>
<security>
<user-name>jproject</user-name>
<password>123456</password>
</security>
<statement>
<prepared-statement-cache-size>100</prepared-statement-cache-size>
<share-prepared-statements>true</share-prepared-statements>
</statement>
</datasource>

Pronto, sua configuração para o servidor JBoss AS 7 acessar o banco de dados foi criada. Agora, entre no seu projeto Java e configure o arquivo persistence.xml para utilizar esta conexão. Para isto, crie o arquivo persistence.xml dentro da pasta META-INF com o seguinte conteúdo:

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence version=”2.0″
xmlns=”http://java.sun.com/xml/ns/persistence&#8221; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221;
xsi:schemaLocation=”
http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd”&gt;
<persistence-unit name=”primary”>
<jta-data-source>java:/pgjOpenProject</jta-data-source>
<properties>
<property name=”hibernate.hbm2ddl.auto” value=”create-drop” />
<property name=”hibernate.show_sql” value=”true” />
</properties>
</persistence-unit>
</persistence>

Agora apenas crie suas classes Entities e suas classes para gerenciamento delas. Não é necessário ficar copiando arquivos do Hibernate ou outro framework ORM para o projeto, apenas o drive JDBC para o servidor JBoss. Também não é necessário controlar suas transações, pois o próprio servidor JBoss consegue fazer isto automático (mas isto não será explicado neste post). Ao criar uma Entity, não é necessário mapear elas dentro de nenhum arquivo, pois o servidor já vai entender que tem que fazer isto com as classes anotadas como Entity (não entraremos em mais detalhes). Também pode ser utilizado injeção de dependências com CDI para que o servidor crie nossa EntityManager, veja o exemplo de um método para persistir um objeto:

public void save(GrupoCliente obj) {
if (obj.getId() == null) {
try {
em.persist(obj);
log.info(“Grupo de Cliente ” + obj + ” cadastrado com sucesso!”);
} catch (Exception e) {
String erro = “Erro ao cadastrar registro com Grupo de Cliente! Registro ” + obj;
log.info(erro);
throw new RuntimeException(erro);
}
} else {
try {
em.merge(obj);
log.info(“Grupo de Cliente ” + obj + ” alterado com sucesso!”);
} catch (Exception e) {
String erro = “Erro ao alterar registro com Grupo de Cliente ” + obj;
log.info(erro);
throw new RuntimeException(erro);
}
}
grupoClienteEventSrc.fire(obj);
}

Pronto!

 
Deixe um comentário

Publicado por em 17 de setembro de 2012 em Java

 

Tags: , , , , , , , , , , , , ,

JPA – Configurando acesso ao banco

Fiz um post tentando explicar como configurar o Hibernate para acessar o banco de dados em uma aplicação. Para ver o post clique aqui. Agora vou tentar explicar como configurar o acesso ao banco de dados utilizando a especificação do próprio JPA com o Hibernate.

Após criar seu projeto, coloque os arquivos necessário para o Hibernate no projeto e crie uma Entity Produto que será persistida no banco de dados. Se não sabe como criar uma Entity, verificar o seguinte post: Java Persistence API – Entities. Se não sabe quais arquivos são necessários para utilizar o Hibernate, clique no post Configurando o Hibernate 4.0.1.

Depois de criado e configurado o projeto, crie um arquivo chamado “persistense.xml”. O arquivo deve estar localizado no diretório “META-INF”. O conteúdo do arquivo pode ser:

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence version=”2.0″
xmlns=”http://java.sun.com/xml/ns/persistence&#8221;
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221;
xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd”&gt;
<persistence-unit name=”aprendendojpa”>
<class>pacote.Produto</class>
<properties>
<property name=”javax.persistence.jdbc.url” value=”jdbc:postgresql://localhost:5432/teste” />
<property name=”javax.persistence.jdbc.driver” value=”org.postgresql.Driver” />
<property name=”hibernate.dialect” value=”org.hibernate.dialect.PostgreSQLDialect” />
<property name=”javax.persistence.jdbc.password” value=”teste” />
<property name=”javax.persistence.jdbc.user” value=”teste” />
<property name=”hibernate.hbm2ddl.auto” value=”create-drop” />
<property name=”hibernate.show_sql” value=”true” />
<property name=”hibernate.format_sql” value=”true” />
</properties>
</persistence-unit>
</persistence>

Pronto! Agora já é possível testar a persistência de dados com o padrão JPA.

Para testar, crie uma classe TesteProduto com um método “main” e adicione o seguinte conteúdo:

EntityManagerFactory emf = Persistence.createEntityManagerFactory(“aprendendojpa”);

EntityManager em = emf.createEntityManager();

Produto prod = new Produto();
prod.setNome(“Teste produto 1”);
prod.setUnidade(“UN”);
prod.setDescricao(“Qualquer coisa”);

prod.setStatus(true);

EntityTransaction tx = em.getTransaction();
tx.begin();

em.persist(prod);

tx.commit();

em.close();

Não vou entrar em detalhes de cada linha, mas a lógica é simples:

  1. Obter conexão – criar fábrica de conexões;
  2. Obter uma Entidade de Gerenciamento (EntityManager);
  3. Criar objeto;
  4. Iniciar transação;
  5. Persistir objeto (salvar);
  6. Confirmar alteração no banco de dados (commit);
  7. Fechar Entidade de Gerenciamento;

Claro que podemos melhorar muito este código criando uma frábrica de conexões, principalmente porque esta fábrica deve ser criada quando a aplicação é iniciada e se manter abertar durante a aplicação, de forma que o restante da aplicação deve apenas receber a EntityManager e gerenciar as transações.

Na minha opnião, o padrão JPA é muito mais simples de ser utilizado. O melhor de tudo é que ele é portável, ou seja, para mudar do Hibernate para outro framework ORM, temos que apenas alterar as bibliotecas e algumas propriedades que podem ter sido utilizadas no arquivo “persistence.xml”.

 
1 comentário

Publicado por em 13 de setembro de 2012 em Java

 

Tags: , , , , , , , , ,

Java Persistence API – Entities

No meu último post tentei explicar como configurar o Hibernate 4. Agora vamos tentar entender o que está por tráz desta tecnologia. Vou tentar falar um pouco de JPA (Java Persistence API). Para ser mais preciso, vou escrever explicar o que é uma Entity, mas antes vamos definir JPA.

O que é o JPA?

A documentação diz que o JPA fornece / oferece aos desenvolvedores Java, uma forma de mapear os objetos-relacionais para gerenciar seus dados relacionais em aplicações Java.

O JPA é na verdade uma especificação utilizada para persistência de dados, faz parte da API e pode ser implementada por Frameworks, como o Hibernate, para seguir um padrão de persistência. Assim, se você criar seu mapeamento utilizando o JPA, será possível criar sua aplicação utilizando os Frameworks que o utilizam em sua implementação, tais como: Hibernate, EclipseLink e outros.

Entities

Uma entidade (Entity) é uma classe que irá representar uma tabela no banco de dados, ou seja, é a classe que vamos persistir. Cada instancia de uma Entity é uma linha da tabela.

As Entities apresentam campos (fields) ou propriedades (properties) que são usadas para mapeamento dos objetos-relacionais, que por anotações (annotations) definem esta entidade e seus relacionamentos.

A documentação do Java EE 6, diz que para ser uma Entity, a classe precisa:

  • Ser anotada como javax.persistence.Entity;
  • A classe deve ter um construtor sem argumentos;
  • A classe, assim como os métodos ou instancias variáveis de persistências, não podem ser declaradas como “final”;
  • Se uma classe é “passada” como valor em um objeto individual, ela deve ser implementada como “Serializable Interface”;
  • Entities podem extender classes definidas ou não como Entities. Também é possível que classes que não são definidas como Entity extendam classes que são definidas como Entity;
  • As variáveis que serão persistidas no banco de dados devem ser declaradas como “private”, “protected” ou “package-private” e podem ser acessadas diretamente por seus métodos (getters e setters);

Veja o exemplo de uma Entity chamada “Produto”:

@Entity

public class Produto implements {

@Id
private Long id;

private String nome;
private String unidade;
private String descricao;
private boolean status;

public Produto() {
super();
}
public Long getId() {
return this.id;
}

public void setId(Long id) {
this.id = id;
}
public String getNome() {
return this.nome;
}

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

public void setUnidade(String unidade) {
this.unidade = unidade;
}

public String getDescricao() {
return this.descricao;
}

public void setDescricao(String descricao) {
this.descricao = descricao;
}

public boolean isStatus() {

  return status;

}

public void setStatus(boolean status) {
this.status = status;
}

}

 

No exemplo acima podemos ver que a Entity é nada mais que uma classe Java com suas propriedades e métodos que serão utilizadas pela aplicação.

As propriedades ou campos, podem ser declaradas como tipos primitivos, Strings ou outro tipo “Serializable” como:

  • BigInteger;
  • BigDecimal;
  • Date;
  • Calendar;
  • byte[];
  • outros;

Uma propriedade ou campo também pode usar “Collections” para definir seu tipo. Normalmente uma “Collection” é utilizada em relações entre Entities, como por exemplo uma classe de venda que contém uma listagem de itens para serem vendidos. Há outras formas de utilizar “Collections”, verificar documentação.

 
1 comentário

Publicado por em 13 de setembro de 2012 em Java

 

Tags: , , , , , , , ,

Configurando o Hibernate 4.0.1

No meu post Configurando o Hibernate 3.6.1 tentei explicar o que é o Hibernate e como configurar a aplicação utilizando o Eclipse. Agora vamos iniciar os trabalhos com a nova versão do Hibernate e para isto vamos ver como configurar a versão 4.0.1.

Ainda não tenho conhecimento de todas as mudanças desta versão. O que vou fazer neste post é apenas uma configuração para que todos possam utilizar. Logo na configuração vamos ter uma mudança no arquivo HibernateUtil, sendo que agora precisamos registrar o serviço. Você pode ler um pouco sobre ServiceRegistry neste link. Não irá explicar como implementar, mas vai dizer o que é pelo menos.

No meu post anterior eu dei mais detalhes sobre como configurar o Hibernate, então podemos seguir os mesmos passos. Primeiro crie um projeto Java e insira as bibliotecas do Hibernate. Para a versão 4.0.1 vamos precisar dos seguintes arquivos .jar:

  • antlr-2.7.7.jar
  • c3p0-0.9.1.jar
  • commons-collections-3.2.1.jar
  • dom4j-1.6.1.jar
  • ehcache-core-2.4.3.jar
  • hibernate-c3p0-4.0.1.Final.jar
  • hibernate-commons-annotations-4.0.1.Final.jar
  • hibernate-core-4.0.1.Final.jar
  • hibernate-ehcache-4.0.1.Final.jar
  • hibernate-entitymanager-4.0.1.Final.jar
  • hibernate-jpa-2.0-api-1.0.1.Final.jar
  • javassist-3.15.0-GA.jar
  • jboss-logging-3.1.0-CR2.jar
  • jboss-transaction-api_1.1_spec-1.0.0.Final.jar
  • log4j-1.2.16.jar
  • slf4j-api-1.6.1.jar
  • slf4j-log4j12-1.6.1.jar

Adicione estes arquivos na pasta “lib” de seu projeto e pelo Eclipse adicine no “Java Build Path” clicando com o botão direito no mouse no projeto –> properties. Eu sempre adiciono as bibliotecas em “User Libraries” do Eclipse e depois eu apenas adiciono elas ao projeto. Para isto você pode clicar no menu Windows –> Preferences, dentro da janela que irá abrir selecione Java -> Build Path -> User Libraries. Clique em New e de um nome para a biblioteca. Depois é só adicionar os arquivos .jar e utilizar esta biblioteca no projeto.

Dentro da pasta do Hibernate que foi feito Download, na subpasta Project, etc, tem o arquivo de configuração “hibernate.properties” que iremos utilizar neste exemplo. Para isto copie o arquivo para past “src/” do seu projeto e edite-o. O conteúdo deve ficar como abaixo:

## MySQL

hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
hibernate.connection.driver_class com.mysql.jdbc.Driver
hibernate.connection.url jdbc:mysql://192.168.1.4:3306/jopenproject
hibernate.current_session_context_class org.hibernate.context.ManagedSessionContext
hibernate.connection.autocommit false
hibernate.hbm2ddl.auto update
hibernate.show_sql true
hibernate.format_sql true
hibernate.connection.username dbopenproject
hibernate.connection.password dbopenproject

Agora é fácil, crie uma classe Client e faça as anotações necessárias para que ela seja uma entidade do banco de dados. Após isto vamos ter que configurar o arquivo HibernateUtil. Segue conteúdo do arquivo HibernateUtil:

import org.hibernate.SessionFactory;
import org.hibernate.SessionFactoryObserver;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

import com.gmail.gmantovani2005.jopenproject.entities.Client;

public class HibernateUtil {

private static final SessionFactory factory;
private static final ServiceRegistry registry;

static {
Configuration cf = new Configuration();

registry = new ServiceRegistryBuilder().applySettings(cf.getProperties()).buildServiceRegistry();

cf.setSessionFactoryObserver(new SessionFactoryObserver() {

/**
*
*/
private static final long serialVersionUID = 1L;

@Override
public void sessionFactoryCreated(SessionFactory arg0) {
// TODO Auto-generated method stub

}

@Override
public void sessionFactoryClosed(SessionFactory arg0) {
// TODO Auto-generated method stub

}
});

cf.addAnnotatedClass(Client.class);

factory = cf.buildSessionFactory(registry);
}

public static SessionFactory getSessionFactory() {
return factory;
}

}

Veja que este arquivo é um pouco diferente do HibernateUtil da versão 3.6.1. Neste arquivo registramos o serviço e criamos a factory utilizando este serviço. Agora podemos utilizar o arquivo.

No meu arquivo “hibernate.properties” eu adicionei uma linha de configuração para trabalhar com Open Session in View. Eu escrevi um post sobre este padrão em Aplicações Web + Hibernate + Padrões. Esta linha é:

hibernate.current_session_context_class org.hibernate.context.ManagedSessionContext

Segue abaixo minha classe de teste que grava um novo cliente no banco de dados:

import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.StaleObjectStateException;
import org.hibernate.context.internal.ManagedSessionContext;

import com.gmail.gmantovani2005.jopenproject.database.HibernateUtil;
import com.gmail.gmantovani2005.jopenproject.entities.Client;

public class TestClientAdd {

/**
* @param args
*/
public static void main(String[] args) {

SessionFactory sf = HibernateUtil.getSessionFactory();
Session currentSession;

try {
currentSession = sf.openSession();
currentSession.setFlushMode(FlushMode.MANUAL);

ManagedSessionContext.bind(currentSession);
currentSession.beginTransaction();

Client cli = new Client();
cli.setName(“Teste de Nome”);
cli.setCnpj(“11.111.111/0001-11”);
cli.setEmail(“teste@localhost.com”);

currentSession.save(cli);

ManagedSessionContext.unbind(sf);

currentSession.flush();
currentSession.getTransaction().commit();
currentSession.close();
} catch (StaleObjectStateException epse) {
throw epse;
} catch (Throwable ex) {
// fazer rollback
ex.printStackTrace();
try {
if (sf.getCurrentSession().getTransaction().isActive()) {
sf.getCurrentSession().getTransaction().rollback();
}
} catch (Throwable rbEx) {
rbEx.printStackTrace();
} finally {
currentSession = ManagedSessionContext.unbind(sf);
currentSession.close();
}
}

System.out.println(“Finalizado!”);
}

}

Apenas rode a aplicação e o sistema irá criar o banco de dados e gravar as informações conforme criada a classe Client.

Pretendo escrever sobre mais detalhes do Hibernate 4 posteriormente. No momento, queria apenas mostrar como começar a utilizar esta nova versão do Framework. Qualquer dúvida deixem comentários para que eu possa tentar ajudar.

 
3 Comentários

Publicado por em 18 de março de 2012 em Java

 

Tags: , , , , , ,

JBoss Tools

Hoje comecei a testar uma boa ferramenta para desenvolvimento Java: Jboss Tools.

Quem quiser maiores informações sobre a ferramenta, entra no site JBoss Tools Docs.

O site do Projeto fica em JBoss Tools.

Ainda tenho muito pouco para dizer desta ferramenta. Por enquanto posso adiantar que é uma ferramenta com vários recursos para se trabalhar em desenvolvimento para Web. Estou utilizando para JSF e para Hibernate, mas a ferramenta se estende para outros frameworks.

Alguns exemplos do que esta ferramenta faz:

  • Visual Web Tools;
  • Seam Development Tools;
  • Hibernate Tools;
  • Portal Tools;
  • JMX Tools;
  • JSF Tools;
  • JBoss AS Tools;
  • Archive Tools;
  • jBPM Tools;
  • ESB Tools;
  • Web Service Tools;
  • Drools Tools;
  • Eclipse Guvnor Tools;

O que gostei da ferramenta é que o Plugin funciona para o Eclipse, ou seja, já sei utilizar. Depois que instalei, abri uma página XHTML e pude utilizar os recursos de palletas do eclipse para os componentes do JSF e também visualizar a tela que estava criando como se estivesse utilizando o Dreamweaver.

Tem uma versão paga chamada JBoss Developer Studio que parece ser muito boa. Se quiser testar pode utilizar esta versão paga por 30 dias.

Toda a documentação pode ser encontrada no site da Red Hat. Deu até vontade de utilizar o sistema operacional, mas só de pensar em ter que instalar tudo novamente já me faz desistir.

Estarei estudando o JBoss Tools nestes dias e qualquer novidade interessante eu volto a postar. Vamos ver se realmente a ferramenta vai valer a pena. Até o momento acredito que sim.

Para instalar no Eclipse Indigo é muito simples, é só seguir os passos que está no site oficial: Instalação.

 
3 Comentários

Publicado por em 4 de março de 2012 em Java

 

Tags: , , , , , , , , ,

Aplicação Web + Hibernate + Padrões

Desenvolver aplicações Web não é complicado, principalmente se utilizar padrões de projetos (Design Patterns). Estes padrões foram criados para facilitar o desenvolvimento, sendo que já traz as melhores práticas para resolver determinadas tarefas. Hoje vou escrever sobre dois padrões de projetos, sendo um deles o Dao e outro o OpenSessionInView.

O Dao (Data Access Object) é um padrão de acesso aos dados, ou seja, ele irá desacoplar sua camada de negócios da camada de persistência. Quando trabalhamos com o Hibernate, temos a classe de persistência (@Entity) que irá descrever o Objeto a ser “gravado” (persistido) no banco de dados e a classe Dao deste objeto, que irá manipular esta persistência utilizando os métodos salvar, alterar, excluir, buscar, listar todos, entre outros. Podemos ter nesta classe Dao toda a regra de negócio.

O site do próprio Hibernate explica bem como utilizar o padrão Dao: Generic Data Access Object

OpenSessionInView veio para resolver um problema ligado a criação do Dao. Quando aprendi Dao pela primeira vez, aprendi também o que é injeção de dependências. A primeira classe que aprendi a criar utilizando Dao tinha um construtor que recebia a sessão do banco de dados aberta e utilizava esta sessão nos métodos para operações de salvar, alterar, excluir, buscar, listar, … O problema que o OpenSessionInView veio resolver: Onde abrir e onde fechar esta sessão?

Mais um vez, o próprio site do Hibernate tem como utilizar este padrão: Open Session In View

Tentando dar uma pequena explicação de como utilizar o padrão OpenSessionInView em uma aplicação Web, é necessário criar um Filtro (Filter) que irá abrir a sessão, iniciar a transação, tratar as exeções e fazer o Commit ou o Rollback. Se não conhece “Filters” você tem uma breve explicação no site do Guj (um pouco antiga o Post, mas explica bem): Filtros para servlets. No link que passei sobre o Open Session In View tem o filtro necessário para este padrão funcionar.

Também há uma mudança na classe Dao para que seja possível abrir a sessão no Filtro.

Construtor do Meu Primeiro Dao:

public ClienteDao(Session session) {

this.session = session;

}

Construtor Dao para utilizar OpenSessionInView:

public ClienteDao() {

this.session = HibernateUtil.getSessionFactory().getCurrentSession();

}

No construtor do meu primeiro Dao, eu recebo a sessão de algum lugar e utilizo ela nos meus métodos. Agora, para utilizar o OpenSessionInView, eu obtenho a sessão que está aberta pela aplicação.

Para que isto funcione, há uma propriedade do Hibernate que deve estar presente no hibernate.cfg.xml ou no hibernate.properties (de acordo com sua configuração). Esta propriedade define como a transação com o banco de dados irá funcionar. Por padrão, a aplicação irá criar uma transação por processo (Thread). Desta forma, ao iniciar uma transação no Filtro, quando a execução chega no Dao (passando por exemplo por um Servlet ou ManagedBean, que depois chama o Dao), não iremos conseguir recuperar (obter).

Tente entender melhor como as transações funcionam lendo no próprio site do Hibernate: Sessions and transactions.

No exemplo do Hibernate apresentado em Open Session in View, é definido a seguinte propriedade:

hibernate.current_session_context_class org.hibernate.context.ManagedSessionContext

Ao definir esta propriedade, é necessário também controlar o setFlushMode manual e definir / registrar o bind. Esta operação normalmente é feita automática pelo Hibernate, mas agora temos que controlar manualmente.

Não vou colocar as classes (Filters / Daos) neste Post, pois as páginas que citei já tem elas prontas. Para funcionar você pode copiar a classes no seu projeto.

Este trabalho do OpenSessionInView pode ser feito manualmente, como explica nos links acima, ou pode-se utilizar um framework como o Spring, que já tem tudo isto pronto.

 
Deixe um comentário

Publicado por em 26 de fevereiro de 2012 em Java

 

Tags: , ,

Configurando o Hibernate 3.6.1

Mesmo já tendo sido lançado o Hibernate 4, vou mostrar neste post como fazer a configuração para utilizar o Hibernate 3.6.1 no Eclipse. Em outro post, daqui alguns dias, irei mostrar como configurar o Hibernate 4, comparando então com o post de hoje.

A primeira coisa para o Hibernate é a definição. O que é o Hibernate? Muito fácil para alguns dizer que o Hibernate é um Framework ORM (Object-relational mapping ou Mapeamento Objeto-Relacional), mas o que isto significa? Não vou entrar em muitos detalhes, pois isto é um assunto muito longo. O que posso dizer que ORM é um técnica que sugere como devemos persistir o estado de um objeto. Muitos frameworks, em várias linguagens, fazem este trabalho, fazendo com que o usuário se preoculpe com as classes, seus atributos, relacionamentos e heranças, ou seja, que o usuário se preoculpe com os objetos que serão persistidos e não com os comandos SQLs que serão gerados.

Alguns exemplos de Frameworks ORM:

  • Hibernate -> para Java;
  • NHibernate -> para .NET;
  • JPA -> para Java;
  • ObjectSpace -> para .NET;
  • LINQ -> para .NET;
Alguns Links:

No material da Caelum (FJ-21 encontrado em http://www.caelum.com.br/) diz: “O Hibernate abstrai o seu código SQL, que será gerado em tempo de execução. Mais que isso, ele vai gerar o SQL que serve para um determinado banco de dados, já que cada banco fala um ‘dialeto’ diferente dessa linguagem. Assim há também a possibilidade de trocar de banco de dados sem ter de alterar código SQL, já que isso fica de responsabilidade da ferramenta.”

Para este post estou utilizando o Eclipse Indigo, com JDK 6 e Hibernate 3.6.1.

Criando um Projeto no Eclipse:

Vamos agora criar um projeto no Eclipse. Não vamos criar nenhum projeto específico para Web ou um projeto específico para o Hibernate ou persistência de dados. Para isto, clique em “File -> New -> Java Project”. O Eclipse irá abrir uma tela para você configurar a aplicação.

Insira o nome do Projeto e clique em Finalizar. Não vamos fazer nenhuma configuração adicional neste momento.

Ao finalizar, o Eclipse irá criar seu novo projeto vazio. A primeira coisa que vamos fazer é criar uma pasta “lib” no raiz do projeto e adicionar as bibliotecas (JARs) necessárias para o Hibernate funcionar. Estes JARs são:

  • antlr-2.7.6.jar
  • c3p0-0.9.1.jar
  • commons-collections-3.1.jar
  • dom4j-1.6.1.jar
  • ehcache-1.5.0.jar
  • hibernate3.jar
  • hibernate-jpa-2.0-api-1.0.0.Final.jar
  • javassist-3.12.0-GA.jar
  • jta-1.1.jar
  • log4j-1.2.16.jar
  • slf4j-api-1.6.1.jar
  • slf4j-log4j12-1.6.1.jar

O Hibernate você pode baixar no endereço http://www.hibernate.org/, descompactar o arquivo para obter os JARs. Na pasta raiz do arquivo descompactado você já encontra o hibernate3.jar. Depois disto, entre na pasta “lib” e pegue todos os JARs das subpastas encontradas, menos da pasta “optional”. Ainda irá faltar o SL4J que é a biblioteca de Logging que o Hibernate utiliza. Para baixar entre no endereço http://www.slf4j.org/download.html e baixe os arquivos.

Na lista acima ainda está faltando um arquivo. O Hibernate gera código SQL e para isto precisamos de um drive JDBC para fazer a comunicação e para que o Hibernate entenda qual código gerar. Isto irá depender do banco de dados que você irá utilizar. No meu exemplo estou utilizando um banco de dados MySQL e por isto entrei no site http://www.mysql.com/ e baixei o drive (JAR) necessário para a conexão.

Pronto, agora é fácil, copie tudo isto para a pasta “lib” do seu projeto e adicione ao Classpath do Eclipse para poder começar a configuração. Veja imagem abaixo.

Configurando Hibernate:

Agora temos que dizer para o Hibernate onde está nosso banco de dados e como ele irá conectar. Para isto, dentro da pasta do Hibernate (que foi descompactada anteriormente) tem uma subpasta “Project -> etc”. Há algumas formas de configurar esta conexão, sendo uma por um arquivo XML e outra por um arquivo de propriedades. Não sei dizer vantagens entre uma ou outra forma e também acho as duas formas muito fácil de utilizar. Por questões pessoais vou utilizar um arquivo de propriedade. Par isto copie o arquivo da pasta “etc” chamado “hibernate.properties” para a pasta raíz (src) da sua aplicação no Eclipse.

Edite o arquivo “hibernate.properties” deixando apenas o necessário para acessar o MySQL. Ao editar o arquivo você verá que já tem pronto o básico para conectar em vários banco de dados. Procure pela conexão do MySQL e apague o restante. O arquivo irá ficar assim:

## MySQL

# hibernate.dialect org.hibernate.dialect.MySQLDialect
hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
hibernate.connection.driver_class com.mysql.jdbc.Driver
hibernate.connection.url jdbc:mysql://localhost:3306/test
hibernate.connection.username myuser
hibernate.connection.password mypassword

Apenas um detalhe sobre os atributos do arquivo. O que está com ‘#’ é comentário. Você deve ter percebido que há 3 dialetos para o MySQL. Não vou entrar em detalhes sobre isto, mas saiba que se escolher “MySQLDialect” o MySQL não irá fazer algumas consistências de banco de dados, como “rollback” nos comandos de uma transação, ou ainda, consistência de relacionamentos, onde a chave do registro apagado está referenciado em outra tabela. Por este motivo eu escolhi “MySQLInnoDBDialect” que irá sim fazer estas consistências. Para entender melhor sobre a consistência do MySQL acho melhor uma pesquisa sobre a história do banco de dados e como ele funciona atualmente.

Agora vamos criar uma classe HibernateUtil que irá cuidar de obter uma Sessão, ou ainda, uma fabrica de sessões (SessionFactory). Crie esta classe em um pacote de sua preferência.

Agora é simples, podemos criar nossas classes e persistir os dados. O Hibernate permite que você utilize duas formas para mapear sua classe. Uma é através de arquivo XML (que não será tratado neste post) e outra por annotations (padrão JPA). Vamos criar uma simples classe de cliente e inserir sua informação de mapeamento no arquivo HibernateUtil.

Classe Cliente:

package database;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Cliente {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

private String nome;

public Long getId() {
return id;
}

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

public String getNome() {
return nome;
}

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

}

Repare na classe Cliente. É uma classe normal Java, seguindo padrão de um construtor sem argumentos (que pode também ser ocultado) e métodos getters e setters para acessar seus atributos.

A classe Cliente também tem algumas anotações para dizer ao Hibernate que a classe pode ser mapeada, ou ainda, que a classe representa uma entidade do banco de dados. Para isto temos a anotação “@Entity”. Como todo banco de dados tem uma chave, uma classe que será persistida através do Hibernate também deve informar sua chave primária. Para isto utilizamos a anotação “@Id”. E para dizermos que a chave primária é auto-incremento, utilizamos a anotação “@GeneratedValue(strategy = GenerationType.AUTO)”.

Não esqueça de alterar a classe HibernateUtil com a informação que a classe Cliente é uma entidade do banco de dados:

cfg.addAnnotatedClass(Cliente.class);

Testando:

Vamos criar uma classe de teste chamada ClienteTest e verificar se conseguimos gravar no banco de dados. O conteúdo desta classe é o seguinte:

package database;

import org.hibernate.Session;

import database.HibernateUtil;
import database.Cliente;

public class ClienteTest {

public static void main(String[] args) {

Cliente cli = new Cliente();
cli.setNome(“Teste de Cliente”);

Session s = new HibernateUtil().getSession();

s.beginTransaction();

s.save(cli);

s.getTransaction().commit();

System.out.println(“ID Cliente: ” + cli.getId());

s.close();

}

}

Execute a classe ClienteTest e veja o resultado. Se tudo estiver correto o Hibernate irá gravar a informação no banco de dados e apresentar o Id do cliente na mensagem final.

Espero ter ajudado!

 
Deixe um comentário

Publicado por em 21 de fevereiro de 2012 em Java

 

Aplicação JSF com Eclipse

Antes de iniciar falando sobre como criar uma aplicação Web utilizando o JSF e o Eclipse, gostaria de definir o JSF, ou JavaServer Faces. O JSF é um Framework Java para programação Web, feito para competir diretamente com ferramentas de desenvolvimento como Asp.NET (que facilita a criação de interfaces de usuário atraentes sem exigir um grande ou tedioso trabalho de programação). Podemos dizer também que o JSF faz sozinho todo o trabalho que é feito manualmente por desenvolvedores JSP, como navegação entre páginas e validação. Claro que por baixo do JSF temos os Servlets e JSP, que podemos pensar como a linguagem de montagem. Para quem já está acostumado com Struts, irá ver que temos com JSF um Framework com arquitetura semelhante, mas com muitos serviços adicionais.

Vamos separar as partes do JSF:

  • Um conjunto de componentes pré-fabricados de Interface de Usuário (IU);
  • Um modelo de programação orientado a eventos;
  • Um modelo de componentes que permite a desenvolvedores independentes fornecerem componentes adicionais;

Para quem utiliza a IDE Netbeans, irá ver que é muito simples o desenvolvimento utilizando JSF. O Netbeans traz quase tudo pronto e tem suporte ao JSF como nativo da ferramenta. Então por que utilizar uma IDE como o Eclipse, onde será necessário configurar algumas coisas para que o JSF funcione?

Para responder esta pergunta primeiro vou dizer que não é necessário tantas configurações assim, mas também mesmo que fosse, quantas vezes o usuário irá preparar o Eclipse para utilizar o JSF? Apenas uma é claro! Depois de preparar o Eclipse é apenas utilizar seus recursos com o JSF. Segundo, o Netbeans trabalha com um padrão e apresenta a forma básica para o JSF. Se o usuário quiser fazer telas mais ricas, utilizando templates, entre outros, terá que fazer isto manual também (ou com pouca diferença do Eclipse).

Estou utilizando o Eclipse Indigo, com servidor Tomcat e JDK6. Todo conteúdo postado aqui pode ser encontrado no site do Eclipse, em documentações: http://help.eclipse.org/indigo/index.jsp

Novo Projeto Web:

Crie um novo projeto Web no Eclipse, clicando em “File -> New -> Dynamic Web Project”. O Eclipse irá abrir uma página para configurar o projeto.

Informe o nome do projeto (Project Name), qual servidor irá utilizar (Target runtime) e altere o campo configuration para utilizar a configuração do JSF 2.0. Se a configuração não estiver disponível, clique em modificar (Modify) e insira uma biblioteca do usuário (Mojara como preferência).
Clique em próximo (Next) duas vezes. A primeira irá levá-lo para configurar o local onde ficará os fontes e a próxima tela irá mostrar a configuração do diretório onde ficarão as páginas. Agora também acho importânte pedir para gerar o “web.xml”, que neste ponto já vem com algumas configurações. Clique em próximo e esteja certo que a biblioteca o JSF está marcada. Clique em finalizar e o Eclipse irá criar um projeto Web, com as bibliotecas (JARs) do JSF.
Vamos começar o trabalho.

Templates:

Dento de WebContent -> WEB-INF, crie uma pasta chamada de “templates”. Dentro desta pasta vamos criar os seguintes arquivos:

  • TemplatePadrao.xhtml
  • header.xhtml
  • footer.xhtml

Para criar o TemplatePadrao.xhtml clique na pasta “templates” com o botão direito e selecione “New -> HTML File”. Informe o nome “TemplatePadrao.xhtml” e clique em próximo. Selecione a opção “New Facelet Template” e clique em finish. Veja imagem:

O Eclipse irá gerar um arquivo de Template com 3 divs:

  • header
  • content
  • footer

Agora precisamos criar as páginas para Header e Footer. Para isto, clique com o botão direito na pasta “templates” e selecione novamente “New -> HTML File”. De o nome para o primeiro de “header.xhtml” e clique em continuar. Selecione agora a opção “New Facelet Header” e clique em finalizar. Faça parecido para a página Footer, sendo que agora o nome será “footer.xhtml” e a opção “New Facelet Footer”.

Volte para a página “TemplatePadrao.xhtml” e edite as divs de header e footer, de forma que incluirão os arquivos criados. Veja imagem abaixo:

Pronto! Agora podemos criar uma página que utiliza os templates criados acima. Vamos para o próximo passo.

Primeira Página:

Clique no projeto com o botão direito e selecione “New -> HTML File”. Informe o nome da página como sendo “index.xhtml” e clique em próximo. Agora selecione a opção “New Facelet Composition Page” e clique em finalizar.

Ao editar a página criada, remova os “<ui:include…” referente Header e Footer, pois estes serão utilizados a partir do template que criamos anteriormente. Dentro da tag “<ui:composition…” informe o template que será utilizado “/WEB-INF/templates/TemplatePadrao.xhtml”. Na tag “<ui:define name=”content”>…</ui:define>” coloque seu código. Vamos colocar um simples título utilizando “<h1></h1>”. O arquivo ficará como a imagem abaixo:

Finalizando:

Pronto! Agora já é possível executar e ver o resultado. Antes disso eu sempre altero o arquivo “web.xml” para definir a primeira página a ser executada. Para isto abra o arquivo e insira o seguinte código:

<welcome-file-list>
<welcome-file>faces/index.xhtml</welcome-file>
</welcome-file-list>

Save e execute o projeto para ver o resultado.

 
2 Comentários

Publicado por em 21 de fevereiro de 2012 em Java

 

Aprendendo Java

Conversando com algumas pessoas sobre desenvolvimento vem sempre uma pergunta: por onde começar a aprender Java?

Se pensarmos em linguagens como Java, .Net, ou ainda, se pensarmos em desenvolvedores desktop que ainda utilizam modelo procedural de desenvolvimento querendo aprender Java para desenvolvimento Web, temos então uma mudança de conceito, na forma de pensar.

Talvez eu não seja a melhor pessoa para descrever qual é a melhor forma de aprender Java, mas vou tentar seguir o que tenho como experiência pessoal neste Post.

Para começar, a velocidade que você vai entender a linguagem Java depende muito do conhecimento que você tem sobre desenvolvimento de sistemas. Não estou dizendo que você tem que ter muita experiência desenvolvendo sistemas, mas quanto maior ela for, mais fácil será seus estudos. Parece óbvio isto, mas já vi muitas pessoas que não sabem algorítimo tentando aprender direto Java. Pode até ser que consigam, mas não vejo muito futuro nisto, ou ainda, vejo um caminho longo para seus estudos. Então, para o pessoal que está começando agora no mundo de desenvolvimento, entendam primeiro lógica, algorítimo, banco de dados. Tentem aprender um pouco de linguagem C, vejam como funciona a forma procedural de desenvolvimento (isto facilita a entender por que desenvolver orientado a objeto), ou seja, enteda os conceitos básicos de desenvolvimento.

O segundo passo é pegar a documentação, livros ou apostilas e começar seus estudos. Muitas pessoas vão dizer que deve-se primeiro entender Orientação a Objeto (OO) para iniciar seus estudos em Java. Não vou dizer que isto não é importânte, mas há materiais que já ensinam OO utilizando Java. Claro que, as pessoas que seguirem aprendendo OO com Java, devem depois procurar um material sobre OO e entender os conceitos mais amplos, não ligados a linguagem. Isto irá facilitar no aprendizado de Java e também irá ser mais fácil caso precisar utilizar outra linguagem orientada a objeto. Há muitos livros e documentação on-line sobre Java. Mas recomendo um material do pessoal da Caelum (http://www.caelum.com.br/). A Caelum tem algumas apostilas abertas, que podem ser baixadas no próprio sites deles. O primeiro material da Caelum que recomendo é o FJ-11 (para entender o que é o FJ-11, entrem no site e vejam a lista de material). A linguagem da Caelum é simples, muito mais fácil de entender do que qualquer livro comprado por ai.

Junto com o material da Caelum (ou depois, depende da preferência), não discarto os livros, que são a melhor referência para aprendizado, muito melhor do que blog, documentação oficial (que em muitos casos é complexo). Claro que para quem já viu a documentação do Java vai dizer que é muito simples. Concordo, mas os livros tráz também a experiência de um desenvolvedor e isto eu acho muito importânte. Como livro, estou recomendando Big Java, de Cay Horstmann.

Mas o que será estudado nestes materiais citados:

  1. O que é Java?
  2. Como instalar Java;
  3. Eclipse (uma IDE de desenvolvimento);
  4. Variáveis, controle de fluxos;
  5. Orientação a Objetos;
  6. Jar e Java-docs, Pacotes;
  7. Arrays;
  8. Padrões de Classes (modificadores de atributos – getters e setters);
  9. Herança, reescrita e polimorfismo;
  10. Classes Abstratas e Interfaces;
  11. Erros e Exceções;
  12. java.lang e java.io;
  13. Collections;
  14. Programação Concorrente e Threads;

Claro que muitos vão dizer que estou seguindo o índice da Caelum. Posso dizer apenas que foi o que eu segui e que muitos livros seguem a mesma estrutura. Claro que alguns livros utilizam outra IDE e ainda, muitos dizem que deve-se utilizar IDE depois de entender a linguagem, mas eu não concordo. Entender como compilar manual e usar uma classe no editor de texto é importânte sim para o primeiro “Hello World”, mas depois não vejo motivo para continuar utilizando editor de texto sem uma IDE.

Após entender os conceitos acima, podemos iniciar persistindo em um banco de dados. Para começar, tente utilizar mais de um banco para ver como o Java irá se comportar. Eu sempre utilizo MySQL e Postgresql. Tente utilizar outros. Agora eu iniciaria a apostila da Caelum (FJ-21) novamente onde irá explicar sobre JDBC e depois pularia para Hibernate no mesmo material. Não continuaria na apostila, pois ela já irá começar com desenvolvimento para Web. Acho importânte entender banco de dados neste momento, porque depois seus exemplos Web podem ser mais ricos, já utilizando banco de dados e iniciando um projeto.

  1. Persistindo com JDBC;
  2. Hibernate;

Como material do Hibernate acho legal pesquisarem na Web (no próprio site do Hibernate para ser mais claro – http://www.hibernate.org/), um material de Hibernate Anotacoes. É um PDF muito bom que explica passo a passo como utilizar este Framework, principalmente para quem estiver trabalhando com Postgresql (tem uns exemplos muito bons lá que são aproveitados neste banco de dados).

Mas o que estudar do Hibernate:

  1. Conceitos Gerais de Persistência;
  2. Mapeamento Objeto Relacional;
  3. Arquitetura;
  4. Classes Persistentes;
  5. Objetos Persistentes, Transientes e Detached;
  6. Hibernate Annotation;
  7. Configurando o Hibernate;
  8. Manipulando Objetos Persistêntes;
  9. Mapeando Atributos e Classes;
  10. Associações;
  11. Transações;

Tente montar um projeto, veja como o Hibernate está gerando seu banco de dados. Vamos tentar fazer “engenharia reversa”, ou seja, vamos pegar um banco pronto e transformar no Hibernate (tente fazer as IDEs gerar automático para você). O mais importânte: confie no Hibernate, ele gera sim seu banco de dados e correto. Se preoculpe com a orientação a objeto e depois vamos se preoculpar com o banco de dados.

Pronto, agora que você já sabe Java e já sabe como usar o Framework mais conhecido e utilizado para persistência de dados, vamos desenvolver para Web. Se você não conhece HTML, CSS e JavaScript. Acho melhor entender estes conceitos. HTML acredito que se aprenda muito rápido, sendo os mais complicados CSS e JavaScript. Posso recomendar os livros:

  • Construindo sites com CSS e (X)HTML – Maurício Samy Silva (Editora: Novatec);
  • SÓ JAVASCRIPT – Kevin Yank e Cameron Adams (Editora: Bookman);

Começando para Web, podemos voltar para o Material da Caelum (FJ-21). Com este material você pode seguir:

  1. O que é Java EE?
  2. Novo Projeto Web com Eclipse;
  3. Servlets;
  4. JavaServer Pages;
  5. Usando Taglibs e Taglibs Customizadas;
  6. Modelo de Desenvolvimento MVC;
  7. Filtros e Wars;

Tente criar um projeto com este conhecimento, com um pequeno controle de usuário. Isto vai ajudar a entender a linguagem, ver como desenvolvimento Web funciona.

Agora podemos focar nos Frameworks. Eu segui este caminho:

  1. Struts 2;
  2. JSF;

Tente também verificar um Framework como o Spring Segurity para controle de usuário e segurança de dados.

Alguns livros que ainda não foram citados:

  • A Arte do Java – Herbert Schildt / James Holmes (Editora: Campus);
  • Tutorial do J2EE – Apresentação de Kathy Walrath, Sun Microsystems, Inc. (Editora: Campus);
  • UML Essencial – Martin Fowler e Apresentações de Cris Kobryn, Grady Booch, Ivar Jacobson e Jim Rumbaugh (Editora: Bookman);
  • Begging Hibernate – Jeff Linwood and Dave Minter;
  • Core JavaServer Faces – David Geary, Cay Horstmann (Editora: Alta Books);

Vou finalizar dizendo apenas que aprender Java é simples, mas que desenvolver bem em Java necessita de muita dedicação.

 
Deixe um comentário

Publicado por em 19 de fevereiro de 2012 em Java

 

Programa, subprojeto e sistema

No meu último Post sobre Gerenciamento de Projetos foi definido “O que é um Projeto?”. Agora, entendendo o que é um projeto, podemos diferenciar o que é Programa, subprojeto e sistema.

Programa:

É um grupo ou conjunto de projetos que devem ser administrados de forma coordenada. Podemos ter como exemplo de programa a Copa do Mundo ou as Olimpiadas. Estes dois eventos tão importantes no mundo são formados de muitos projetos, que juntos, formam o evento final.

Subprojeto:

Como já vimos, um Programa pode apresentar vários projetos. Mas cada projeto pode também apresentar vários subprojetos. Para definir subprojeto, vamos dizer que é um projeto dentro de outro, ou ainda, uma parte de um projeto maior.

Como exemplo podemos ter um projeto de implantação de sistemas informatizados. Ao implantar um software de gestão, a empresa desenvolvedora pode se encontrar em situações, onde é necessário desenvolver uma parte específica que o sistema até então não atendia. Este desenvolvimento pode ser considerado um subprojeto, pois está dentro do projeto de implantação, mas é controlado por outra equipe que não é a de consultoria (implantação), mas é necessário para o projeto final.

Sistema:

Não consegui encontrar uma boa definição sobre o que é um sistema dentro deste contexto. Sistema pode ser considerado por algumas empresas como um subprojeto, mas na verdade tenta designar uma parte muito maior. O autor Antonio Cesar Amaru Maximiano, em seu livro Administração de Projetos, define sistema como “…para indicar um conjunto relativamente complexo de atividades ou subprojetos”. Ele também cita como exemplo um sistema de apoio a vida dentro de um projeto de astronave ou um sistema de propulsão de um veículo.

Tentando encaixar esta definição dentro da minha realidade, sistema pode ser o próprio software de gestão que tem como desenvolvimento um setor específico para novas funcionalidades ou manutenção.

 
Deixe um comentário

Publicado por em 12 de fevereiro de 2012 em Projetos