Olá,
Sempre usei os arquivo hbm. Vejo que alguns usam annotations. É Melhor ? Gostaria da experiência de vocês para iniciar ou não o estudo de anotações no Hibernate.
Obrigado,
Márcio
Acho que vai do gosto primeiramente.
No meu caso eu prefiro usar annotations, não gosto muito de mexar em arquivos XML, apesar de existirem fechamentas/plugins que facilitam a geração e manutenção desses arquivos.
Eu acho válido estudar assim você pode escolher o que achar mais fácil e produtivo.
Eu estou usando Hibernate + Spring e estou trabalhando da seguinte forma.
Olha um exemplo de annotations.
Classe ProjetoBean:
[code]package br.mt.abaco.scap.model;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table (name=“scaptb02_projeto”)
public class ProjetoBean extends BaseObject
{
private static final long serialVersionUID = 1L;
/** Referente ao indentificador primário do projeto */
@Id
@Column (name="id_scaptb02_projeto", nullable=false, length=5)
private String idProjeto;
/** Referente ao nome projeto. */
@Column (name="nome_projeto", nullable=false, length=50)
private String nomeProjeto;
/** Referente a sigla do projeto */
@Column (name="sigla_projeto", nullable=false, length=8)
private String siglaProjeto;
/** Referente a lista de módulos do projeto. */
@OneToMany (mappedBy="moduloBean")
private Set<ModuloBean> moduloBeans;
}[/code]
Classe ModuloBean:
[code]package br.mt.abaco.scap.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table (name=“scaptb03_modulo”)
public class ModuloBean extends BaseObject
{
private static final long serialVersionUID = 1L;
/** Referente ao indentificador primário do módulo */
@Id
@Column (name="id_scaptb03_modulo", nullable=false, length=5)
private String idModulo;
@ManyToOne (fetch=FetchType.LAZY)
@JoinColumn (name="id_projeto_fk")
public ProjetoBean moduloBean;
/** Referente a nome do modulo */
@Column (name="nome_modulo", nullable=false, length=8)
private String nomeModulo;
}[/code]
E ainda defino no arquivo applicationContext.xml, que o SPRING faça o controle de transação do HIBERNATE.
Arquivo applicationContext.xml :
[code]<?xml version="1.0" encoding="UTF-8"?>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
<property name="url" value="jdbc:hsqldb:file:/C:/Des/Java/bd/scap"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
<property name="initialSize" value="1"/>
<property name="maxActive" value="2"/>
<property name="maxIdle" value="5"/>
<property name="defaultAutoCommit" value="true"/>
<property name="poolPreparedStatements" value="true"/>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="annotatedClasses">
<value>
br.mt.abaco.scap.model.ProjetoBean,
br.mt.abaco.scap.model.ModuloBean
</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.use_sql_comments">true</prop>
<prop key="hibernate.generate_statistics">true</prop>
</props>
</property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
<!-- Defini que será usado a classe HibernateTransactionManager do Spring para fazer controle de transação -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
......
[/code]
Na minha opinião vale apena estudar SIM!!! rssssss. :lol: :lol: :lol:
Sei que existe algumas ferramentas para gerar os mapeamentos das classes por exemplo, mas o annotations é uma forma interessante.
Abraços, Fuiiiiiiiiiiiiiiii.
Eu acho que vale a pena, mas seria ainda melhor você já estudar JPA logo de cara!
Thiago,
O que JPA ?
Márcio
JPA (Java Persistence API) é a especificação para persistência com EJB 3. É essa a especificação que o Hibernate e TopLink implementam para prover suporte ao EJB 3.
Para o seu caso, é essa a especificação que define a utilização das annotations. No caso do hibernate-annotations, nada mais é do que uma implementação dessa especificação.
Bom, essa especificação vai um pouco além de usar apenas annotations, mas é o ponta pé inicial para EJB 3 ou até mesmo continuar com o bom e velho hibernate.
Segue alguns links só para matar curiosidade logo do que é isso na prática.
http://www.netbeans.org/kb/articles/hibernate-javaee.html
http://www.netbeans.org/kb/55/persistence.html
Livros
http://www.apress.com/book/bookDisplay.html?bID=10093
Abraços
Thiago
Você deveria fazer o contrário: estude primeiro e decida você mesmo se vale a pena. Mas já adianto, estudar Hibernate SEM olhar annotations, hoje, é perder tempo.
Valeu galera,
Vou cair dentro do annotations do hibernate. Quando ao JPA, vou deixar para depois. Para usar EJB3 não é preciso um servidor Java EE ?
Obrigado,
Márcio
[quote=marcioa1]Valeu galera,
Vou cair dentro do annotations do hibernate. Quando ao JPA, vou deixar para depois. Para usar EJB3 não é preciso um servidor Java EE ?
Obrigado,
Márcio[/quote]
Não, o JPA não força você a usar um container JEE. O JSE é suficiente.
Como as annotations do hibernate são as mesmas do JPA, a viagem não será perdida.
Boa Sorte!
Abraços
Isso é excelente né. 
Do JPA só acho que vale a pena usar os annotations. Usar o EntityManager do hibernate pra fazer uma implementação em JPA não vale a pena, tu perde um monte de funcionalidades do hibernate. Até o annotations não são tão poderosos quantos os .hbm, mas ainda acho vale a pena usar quando der.
Pessoal, estou no mesmo caso que o Márcio, acostumada a fazer mapeamentos com xml mesmo, direto. Gostaria de aprender a usar annotations. Como o material que eu adquiri aqui na internet está muito solto (vago), eu achei meio confuso o uso de annotations, mas pode ser porque eu esteja acostumada a lidar com outro tipo de mapeamento. Alguém poderia me sugerir um material bom de introdução as anotações?
Bom, quem gosta de ficar editando aquele tanto de arquivo xml?
Onde você coloca nome da classe (pacote.classe) depois faz um refactor e tem q sair alterando nos xmls?
Arquivo Descritor é uma porcaria, quanto menos você tiver melhor, com annotation é lindo, é tudo código java.
XML é muito bom pra algumas coisas mas chega uma hora que enche o saco. Sem contar da produtividade que cai se tiver muitos arquivos descritores pra gerenciar.
Obrigada Luiz, vai me ajudar muito
Casmeiron, eu concordo contigo, annotations facilita muito. Mas acho que o código fica sujinho quando a complexidade do programa é maior, cheio de anotações misturados com o código java hehehe
Bom, vamos ver se eu me convenço.
Obrigada de qualquer forma!
[quote=beks]Obrigada Luiz, vai me ajudar muito
Casmeiron, eu concordo contigo, annotations facilita muito. Mas acho que o código fica sujinho quando a complexidade do programa é maior, cheio de anotações misturados com o código java hehehe
Bom, vamos ver se eu me convenço.
Obrigada de qualquer forma![/quote]
Fica misturado não, annotation é código java.
E você acostuma, melhor olhar em 1 lugar soh do que em dois