Diversos e estranhos SELECT no Hibernate

[Marcelo V. V. Magalhães]

Caros amigos,

Estou desenvolvendo minha primeira aplicação usando Hibernate e está acontecendo algo estranho. Tenho uma estrutura de classe de um sistema contábeil mais ou menos assim; três classes, conta sintética, conta analítica e lançamento, com as seguinte associações:

- uma conta sintética possui muitas contas sintéticas (auto-relacionamento não obrigatório);

- uma conta sintética possui um ou mais contas analiíticas;

- uma lançamento possui uma ou mais contas analíticas para débito e uma ou mais contas analíticas para crédito;

- uma conta analítica possui diversos lançamentos (de crédito e de débito);

Ou seja a associação entre conta analítica e lançamento é N para N duas vezes (de créditos e de débitos), sendo assim criei tabelas para este relacionamento muitos para muitos (mas não há classes para tais, visto que não há necessidade)

Estou usando o Hibernate 3 com PostGres 8.4.1.

A inclusão, recuperação, alteração, etc... está tudo ok, contudo estou tendo alguns probleminhas. Quando faço alguma operação de inclusão, alteração, etc.. o Hibernate faz alguns SELECTs em todas as minhas tabelas, ver log da console abaixo:

Criou o serviço da conta sintética  
22/08/2010 20:09:43-org.hibernate.cfg.annotations.Version <clinit>  
INFO: Hibernate Annotations 3.3.0.GA  
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit>  
INFO: Hibernate 3.2.5  
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit>  
INFO: hibernate.properties not found  
22/08/2010 20:09:43-org.hibernate.cfg.Environment buildBytecodeProvider  
INFO: Bytecode provider name : cglib  
22/08/2010 20:09:43-org.hibernate.cfg.Environment <clinit>  
INFO: using JDK 1.4 java.sql.Timestamp handling  
22/08/2010 20:09:43-org.hibernate.ejb.Version <clinit>  
INFO: Hibernate EntityManager 3.3.1.GA  
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass  
INFO: Binding entity from annotated class: modelo.Lancamento  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable  
INFO: Bind entity modelo.Lancamento on table Lancamento  
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass  
INFO: Binding entity from annotated class: modelo.ContaContabilSintetica  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable  
INFO: Bind entity modelo.ContaContabilSintetica on table ContaContabilSintetica  
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass  
INFO: Binding entity from annotated class: modelo.ContaContabilAnalitica  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable  
INFO: Bind entity modelo.ContaContabilAnalitica on table ContaContabilAnalitica  
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass  
INFO: Binding entity from annotated class: modelo.Reserva  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable  
INFO: Bind entity modelo.Reserva on table RESERVA  
22/08/2010 20:09:44-org.hibernate.cfg.AnnotationBinder bindClass  
INFO: Binding entity from annotated class: modelo.Cor  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.EntityBinder bindTable  
INFO: Bind entity modelo.Cor on table COR  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.CollectionBinder bindOneToManySecondPass  
INFO: Mapping collection: modelo.ContaContabilSintetica.contasContabeisAnaliticas -> ContaContabilAnalitica  
22/08/2010 20:09:44-org.hibernate.cfg.annotations.CollectionBinder bindOneToManySecondPass  
INFO: Mapping collection: modelo.ContaContabilSintetica.contasContabeisSinteticasFilhas -> ContaContabilSintetica  
22/08/2010 20:09:44-org.hibernate.validator.Version <clinit>  
INFO: Hibernate Validator 3.0.0.GA  
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure  
INFO: C3P0 using driver: org.postgresql.Driver at URL: jdbc:postgresql://127.0.0.1:5432/JavaDB  
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure  
INFO: Connection properties: {user=marcelo, password=****, autocommit=true, release_mode=auto}  
22/08/2010 20:09:45-org.hibernate.connection.C3P0ConnectionProvider configure  
INFO: autocommit mode: true  
22/08/2010 20:09:45-com.mchange.v2.log.MLog <clinit>  
INFO: MLog clients using log4j logging.  
22/08/2010 20:09:45-com.mchange.v2.c3p0.C3P0Registry banner  
INFO: Initializing c3p0-0.9.1 [built 16-January-2007 14:46:42; debug? true; trace: 10]  
22/08/2010 20:09:45-com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource getPoolManager  
INFO: Initializing c3p0 pool... com.mchange.v2.c3p0.PoolBackedDataSource@ef220090 [ connectionPoolDataSource -> com.mchange.v2.c3p0.WrapperConnectionPoolDataSource@690bc899 [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, debugUnreturnedConnectionStackTraces -> false, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hge13c8a17avx571dzw4fw|32d8ca48, idleConnectionTestPeriod -> 0, initialPoolSize -> 5, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 20, maxStatements -> 50, maxStatementsPerConnection -> 0, minPoolSize -> 5, nestedDataSource -> com.mchange.v2.c3p0.DriverManagerDataSource@3595583f [ description -> null, driverClass -> null, factoryClassLocation -> null, identityToken -> 1hge13c8a17avx571dzw4fw|3e0d1329, jdbcUrl -> jdbc:postgresql://127.0.0.1:5432/JavaDB, properties -> {user=******, password=******, autocommit=true, release_mode=auto} ], preferredTestQuery -> null, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false; userOverrides: {} ], dataSourceName -> null, factoryClassLocation -> null, identityToken -> 1hge13c8a17avx571dzw4fw|52205756, numHelperThreads -> 3 ]  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: RDBMS: PostgreSQL, version: 8.4.1  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: JDBC driver: PostgreSQL Native Driver, version: PostgreSQL 8.0 JDBC2 with NO SSL (build 310)  
22/08/2010 20:09:45-org.hibernate.dialect.Dialect <init>  
INFO: Using dialect: org.hibernate.dialect.PostgreSQLDialect  
22/08/2010 20:09:45-org.hibernate.transaction.TransactionFactoryFactory buildTransactionFactory  
INFO: Transaction strategy: org.hibernate.transaction.JDBCTransactionFactory  
22/08/2010 20:09:45-org.hibernate.transaction.TransactionManagerLookupFactory getTransactionManagerLookup  
INFO: No TransactionManagerLookup configured (in JTA environment, use of read-write or transactional second-level cache is not recommended)  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Automatic flush during beforeCompletion(): disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Automatic session close at end of transaction: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: JDBC batch size: 15  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: JDBC batch updates for versioned data: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Scrollable result sets: enabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: JDBC3 getGeneratedKeys(): disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Connection release mode: auto  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Default batch fetch size: 1  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Generate SQL with comments: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Order SQL updates by primary key: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Order SQL inserts for batching: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory createQueryTranslatorFactory  
INFO: Query translator: org.hibernate.hql.ast.ASTQueryTranslatorFactory  
22/08/2010 20:09:45-org.hibernate.hql.ast.ASTQueryTranslatorFactory <init>  
INFO: Using ASTQueryTranslatorFactory  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Query language substitutions: {}  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: JPA-QL strict compliance: enabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Second-level cache: enabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Query cache: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory createCacheProvider  
INFO: Cache provider: org.hibernate.cache.NoCacheProvider  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Optimize cache for minimal puts: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Structured second-level cache entries: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Echoing all SQL to stdout  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Statistics: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Deleted entity synthetic identifier rollback: disabled  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Default entity-mode: pojo  
22/08/2010 20:09:45-org.hibernate.cfg.SettingsFactory buildSettings  
INFO: Named query checking : enabled  
22/08/2010 20:09:45-org.hibernate.impl.SessionFactoryImpl <init>  
INFO: building session factory  
22/08/2010 20:09:46-org.hibernate.impl.SessionFactoryObjectFactory addInstance  
INFO: Not binding factory to JNDI, no JNDI name configured  
Hibernate:   
    select  
        contaconta0_.contaContabilSinteticaID as contaCon1_1_0_,  
        contaconta0_.contaContabilSinteticaPai as contaCon5_1_0_,  
        contaconta0_.grupoContabil as grupoCon2_1_0_,  
        contaconta0_.nome as nome1_0_,  
        contaconta0_.observacao as observacao1_0_   
    from  
        ContaContabilSintetica contaconta0_   
    where  
        contaconta0_.contaContabilSinteticaID=?  
Hibernate:   
    select  
        contascont0_.contaContabilSinteticaID as contaCon4_1_,  
        contascont0_.contaContabilAnaliticaID as contaCon1_1_,  
        contascont0_.contaContabilAnaliticaID as contaCon1_2_0_,  
        contascont0_.contaContabilSinteticaID as contaCon4_2_0_,  
        contascont0_.nome as nome2_0_,  
        contascont0_.observacao as observacao2_0_   
    from  
        ContaContabilAnalitica contascont0_   
    where  
        contascont0_.contaContabilSinteticaID=?  
Hibernate:   
    select  
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_,  
        lancamento0_.lancamentoID as lancamen2_1_,  
        lancamento1_.lancamentoID as lancamen1_0_0_,  
        lancamento1_.dataCadastro as dataCada2_0_0_,  
        lancamento1_.historico as historico0_0_,  
        lancamento1_.valor as valor0_0_   
    from  
        ContaCreditada lancamento0_   
    left outer join  
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where  
        lancamento0_.contaContabilAnaliticaID=?  
Hibernate:   
    select  
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_,  
        lancamento0_.lancamentoID as lancamen2_1_,  
        lancamento1_.lancamentoID as lancamen1_0_0_,  
        lancamento1_.dataCadastro as dataCada2_0_0_,  
        lancamento1_.historico as historico0_0_,  
        lancamento1_.valor as valor0_0_   
    from  
        ContaDebitada lancamento0_   
    left outer join  
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where  
        lancamento0_.contaContabilAnaliticaID=?  
Hibernate:   
    select  
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_,  
        lancamento0_.lancamentoID as lancamen2_1_,  
        lancamento1_.lancamentoID as lancamen1_0_0_,  
        lancamento1_.dataCadastro as dataCada2_0_0_,  
        lancamento1_.historico as historico0_0_,  
        lancamento1_.valor as valor0_0_   
    from  
        ContaCreditada lancamento0_   
    left outer join  
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where  
        lancamento0_.contaContabilAnaliticaID=?  
Hibernate:   
    select  
        lancamento0_.contaContabilAnaliticaID as contaCon1_1_,  
        lancamento0_.lancamentoID as lancamen2_1_,  
        lancamento1_.lancamentoID as lancamen1_0_0_,  
        lancamento1_.dataCadastro as dataCada2_0_0_,  
        lancamento1_.historico as historico0_0_,  
        lancamento1_.valor as valor0_0_   
    from  
        ContaDebitada lancamento0_   
    left outer join  
        Lancamento lancamento1_   
            on lancamento0_.lancamentoID=lancamento1_.lancamentoID   
    where  
        lancamento0_.contaContabilAnaliticaID=?  
Hibernate:   
    select  
        contascont0_.contaContabilSinteticaPai as contaCon5_1_,  
        contascont0_.contaContabilSinteticaID as contaCon1_1_,  
        contascont0_.contaContabilSinteticaID as contaCon1_1_0_,  
        contascont0_.contaContabilSinteticaPai as contaCon5_1_0_,  
        contascont0_.grupoContabil as grupoCon2_1_0_,  
        contascont0_.nome as nome1_0_,  
        contascont0_.observacao as observacao1_0_   
    from  
        ContaContabilSintetica contascont0_   
    where  
        contascont0_.contaContabilSinteticaPai=?  
Recuperou conta sintética ID = 5  
Conta sintética 1  
ATIVO

Abaixo está as minhas classes de modelo com as anotações: ContaSintetica

/** 
* As contas contábeis sintéticas servem somente para agrupar as contas contábeis 
* analíticas, não sendo permitido lançamentos nestas contas. Outra boa finalidade 
* para estas contas é a geração de relatórios sintéticos para niveis gerenciais 
* de uma empresa, visto que tais contas sintéticas possuem o seu saldo como sendo 
* o somatório dos saldos de suas contas analíticas. Toda conta contábil sintética 
* deve percenter a um grupo contábil, ativo, passivo ou de resultado, sendo esta 
* última dividida em 3 grupos, contas de receitas, contas de despesas e contas de 
* apuração de resultado. Estes 3 grupo deverão sempre ter seus saldos 
* transportados para as contas patrimonias, ativo e passivo, ficando assim com 
* saldo zero ao final de um exercício contábil. 
* @author Marcelo Magalhães 
* @version 1.0 
* @created 31-jul-2010 01:45:54 
*/  
package modelo;  
  
import java.io.Serializable;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.Set;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.FetchType;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.JoinColumn;  
import javax.persistence.ManyToOne;  
import javax.persistence.OneToMany;  
import javax.persistence.SequenceGenerator;  
import javax.persistence.Table;  
import javax.persistence.Transient;  
  
import org.hibernate.annotations.Cascade;  
import org.hibernate.annotations.CascadeType;  
import org.hibernate.annotations.Fetch;  
import org.hibernate.annotations.FetchMode;  
  
@Entity  
@Table(name="ContaContabilSintetica")  
  
@SequenceGenerator(name="CONTACONTABILSINTETICA_SEQ", sequenceName="CONTACONTABILSINTETICA_SEQ", allocationSize=1)  
public class ContaContabilSintetica implements Serializable   
{  
  
    private static final long serialVersionUID = 1;  
    private static final boolean TRUE = true;  
    private static final boolean FALSE = false;  
    /** 
     * Lista das contas analíticas pertencentes a esta conta sintética. 
     */  
    private Set<ContaContabilAnalitica> contasContabeisAnaliticas;  
    /** 
     * Identificador da conta sintética. Sequencia gerada pelo banco de dados. 
     */  
    private Long contaContabilSinteticaID;  
    /** 
     * Identificador da conta contábil sintética (pai) que contém esta conta contábil 
     * sintética (filho). 
     */  
    private ContaContabilSintetica contaContabilSinteticaPai;  
    /** 
     * Classificador do tipo de grupo ao qual pertence a conta contábil sintética. 
     * Este classificador é uma enumeração. 
     */  
    private int grupoContabil;  
    /** 
     * Nome da conta contábil. Alfanumérico de até 70 caracteres. 
     */  
    private String nome;  
    /** 
     * Campo destinado a observações sobre a conta. 
     */  
    private String observacao;  
    private Set<ContaContabilSintetica> contasContabeisSinteticasFilhas;  
  
    /** 
     * Construtor padrão 
     */  
    public ContaContabilSintetica()  
    {  
        this.contasContabeisAnaliticas = new HashSet<ContaContabilAnalitica>();  
        this.contasContabeisSinteticasFilhas = new HashSet<ContaContabilSintetica>();  
    }  
  
    /** 
     * Construtor com argumentos. 
     *  
     * @param contaContabilSinteticaID 
     * @param grupoContabil 
     * @param nome 
     * @param observacao 
     * @param contaContabilSinteticaPai 
     */  
    public ContaContabilSintetica(long contaContabilSinteticaID, GrupoContabil grupoContabil, String nome, String observacao, ContaContabilSintetica contaContabilSinteticaPai)  
    {  
        this.contaContabilSinteticaID = contaContabilSinteticaID;  
        this.grupoContabil = grupoContabil.getIdentificador();  
        this.nome = nome;  
        this.observacao = observacao;  
        this.contaContabilSinteticaPai = contaContabilSinteticaPai;  
      
        this.contasContabeisAnaliticas = new HashSet<ContaContabilAnalitica>();  
        this.contasContabeisSinteticasFilhas = new HashSet<ContaContabilSintetica>();  
    }  
  
    @Id  
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CONTACONTABILSINTETICA_SEQ")  
    @Column(name="contaContabilSinteticaID", unique=TRUE, nullable=TRUE, insertable=FALSE, updatable=FALSE)  
    public Long getContaContabilSinteticaID()  
    {  
        return this.contaContabilSinteticaID;  
    }  
  
    @Column(name="nome", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255)  
    public String getNome()  
    {  
        return this.nome;  
    }  
  
    @Column(name="observacao", unique=FALSE, nullable=TRUE, insertable=TRUE, updatable=TRUE, length=255)  
    public String getObservacao()  
    {  
        return this.observacao;  
    }  
  
    @Column(name="grupoContabil", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE)  
    public GrupoContabil getGrupoContabil()  
    {  
            int i;    
            for (GrupoContabil g : GrupoContabil.values())  
            {  
                i = g.getIdentificador();  
                if (i == grupoContabil)  
                {  
                return g;  
                }  
            }  
            return null;  
    }  
  
    @OneToMany(mappedBy="contaContabilSintetica", fetch = FetchType.LAZY)  
    //@Fetch(FetchMode.SELECT)  
    @Cascade(CascadeType.DELETE_ORPHAN)  
    public Set<ContaContabilAnalitica> getContasContabeisAnaliticas()  
    {  
        return this.contasContabeisAnaliticas;  
    }  
      
    @OneToMany(mappedBy="contaContabilSinteticaPai",fetch=FetchType.LAZY)  
    @Fetch(FetchMode.SELECT)  
    @Cascade(CascadeType.DELETE_ORPHAN)  
    public Set<ContaContabilSintetica> getContasContabeisSinteticasFilhas()  
    {  
        return this.contasContabeisSinteticasFilhas;  
    }  
      
    @ManyToOne(fetch = FetchType.LAZY)  
    @JoinColumn(name="contaContabilSinteticaPai")  
    @Fetch(FetchMode.SELECT)  
    public ContaContabilSintetica getContaContabilSinteticaPai()  
    {  
        return this.contaContabilSinteticaPai;  
    }  
  
    /** 
     *  
     * @param contaContabilSinteticaID 
     */  
    public void setContaContabilSinteticaID(Long contaContabilSinteticaID)  
    {  
        this.contaContabilSinteticaID = contaContabilSinteticaID;  
    }  
  
    /** 
     *  
     * @param nome 
     */  
    public void setNome(String nome)  
    {  
        this.nome = nome;  
    }  
  
    /** 
     *  
     * @param observacao 
     */  
    public void setObservacao(String observacao)  
    {  
        this.observacao = observacao;  
    }  
  
    /** 
     *  
     * @param grupoContabil 
     */  
    public void setGrupoContabil(GrupoContabil grupoContabil)  
    {  
        this.grupoContabil = grupoContabil.getIdentificador();  
    }  
  
    /** 
     *  
     * @param contasContabeisAnaliticas 
     */  
    public void setContasContabeisAnaliticas(Set<ContaContabilAnalitica> contasContabeisAnaliticas)  
    {  
        Iterator<ContaContabilAnalitica> iterator = contasContabeisAnaliticas.iterator();  
      
        while (iterator.hasNext())  
        {  
            ContaContabilAnalitica contaAnalitica = (ContaContabilAnalitica)iterator.next();  
            this.adicionarContaContabilAnalitica(contaAnalitica);  
        }   
    }  
  
    /** 
     *  
     * @param contaContabilSinteticaPai 
     */  
    public void setContaContabilSinteticaPai(ContaContabilSintetica contaContabilSinteticaPai)  
    {  
        this.contaContabilSinteticaPai = contaContabilSinteticaPai;  
    }  
  
    /** 
     *  
     * @param contasContabeisSinteticasFilhas 
     */  
    public void setContasContabeisSinteticasFilhas(Set<ContaContabilSintetica> contasContabeisSinteticasFilhas)  
    {  
        Iterator<ContaContabilSintetica> iterator = contasContabeisSinteticasFilhas.iterator();  
      
        while (iterator.hasNext())  
        {  
            ContaContabilSintetica contaSintetica = (ContaContabilSintetica)iterator.next();  
            this.adicionarContaContabilSinteticaFilha(contaSintetica);  
        }   
    }  
  
    /** 
     *  
     * @param contaContabilAnalitica 
     */  
    @Transient  
    public void adicionarContaContabilAnalitica(ContaContabilAnalitica contaContabilAnalitica)  
    {  
        if (!this.getContasContabeisAnaliticas().contains(contaContabilAnalitica))  
        {  
            this.contasContabeisAnaliticas.add(contaContabilAnalitica);  
            contaContabilAnalitica.adicionarContaContabilSintetica(this);  
        }  
    }  
  
    /** 
     *  
     * @param contaContabilAnalitica 
     */  
    @Transient  
    public void removerContaContabilAnalitica(ContaContabilAnalitica contaContabilAnalitica)  
    {  
        if (this.getContasContabeisAnaliticas().contains(contaContabilAnalitica))  
        {  
            this.contasContabeisAnaliticas.remove(contaContabilAnalitica);  
            contaContabilAnalitica.removerContaContabilSintetica(this);  
        }  
    }  
  
    /** 
     *  
     * @param contaContabilSinteticaFilha 
     */  
    @Transient  
    public void adicionarContaContabilSinteticaFilha(ContaContabilSintetica contaContabilSinteticaFilha)  
    {  
        if (!this.getContasContabeisSinteticasFilhas().contains(contaContabilSinteticaFilha))  
        {  
            this.contasContabeisSinteticasFilhas.add(contaContabilSinteticaFilha);  
        }  
    }  
  
    /** 
     *  
     * @param contaContabilSinteticaFilha 
     */  
    @Transient  
    public void revomerContaContabilSinteticaFilha(ContaContabilSintetica contaContabilSinteticaFilha)  
    {  
        if (this.getContasContabeisSinteticasFilhas().contains(contaContabilSinteticaFilha))  
        {  
            this.contasContabeisSinteticasFilhas.remove(contaContabilSinteticaFilha);  
        }  
    }  
  
    /** 
     * Saldo total da conta contábil. Nas contas contábeis analíticas é a diferença 
     * entre os lançamento de crédito e os de débito. Já nas contas contábies 
     * sintéticas, o saldo, é o somatório dos saldos das contas contábeis analí ticas 
     * pertencentes a esta conta. 
     */  
    @Transient  
    public float getSaldo()  
    {  
        Iterator<ContaContabilAnalitica> iterator = contasContabeisAnaliticas.iterator();  
      
        float saldoTotal = 0;  
      
        while (iterator.hasNext())  
        {  
            saldoTotal = saldoTotal + iterator.next().getSaldo();  
        }  
      
        return saldoTotal;  
    }  
  
}

ContaAnalitica

** 
* Nas contas contábeis analíticas é que são feitos os lançamentos contábeis que 
* ocorrem no dia a dia de uma entidade. Esta conta não pode possuir sub-contas 
* associadas a ela e o seu saldo é definido como a diferença entre os lançamentos 
* de crédito e de débito. 
* @author Marcelo Magalhães 
* @version 1.0 
* @created 31-jul-2010 01:45:52 
*/  
package modelo;  
  
import java.io.Serializable;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.Set;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.FetchType;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.JoinColumn;  
import javax.persistence.JoinTable;  
import javax.persistence.ManyToMany;  
import javax.persistence.ManyToOne;  
import javax.persistence.SequenceGenerator;  
import javax.persistence.Table;  
import javax.persistence.Transient;  
  
import org.hibernate.annotations.Cascade;  
import org.hibernate.annotations.CascadeType;  
import org.hibernate.annotations.Fetch;  
import org.hibernate.annotations.FetchMode;  
  
@Entity  
@Table(name="ContaContabilAnalitica")  
  
@SequenceGenerator(name="CONTACONTABILANALITICA_SEQ", sequenceName="CONTACONTABILANALITICA_SEQ", allocationSize=1)  
public class ContaContabilAnalitica implements Serializable   
{  
  
    private static final long serialVersionUID = 1;  
    private static final boolean TRUE = true;  
    private static final boolean FALSE = false;  
    private Set<Lancamento> lancamentosDebito;  
    private Set<Lancamento> lancamentosCredito;  
    /** 
     * Identificador da conta analítica. Sequencia gerada pelo banco de dados. 
     */  
    private Long contaContabilAnaliticaID;  
    /** 
     * Identificador da conta contábil sintética (pai) que contém esta conta contábil 
     * analítica. 
     */  
    private ContaContabilSintetica contaContabilSintetica;  
    /** 
     * Nome da conta contábil. Alfanumérico de até 70 caracteres. 
     */  
    private String nome;  
    /** 
     * Campo destinado a observações sobre a conta. 
     */  
    private String observacao;  
  
    /** 
     * Construtor padrão 
     */  
    public ContaContabilAnalitica()  
    {  
        this.lancamentosDebito = new HashSet<Lancamento>();  
        this.lancamentosCredito = new HashSet<Lancamento>();  
    }  
  
    /** 
     * Construtor padrão com argumentos 
     *  
     * @param contaContabilAnaliticaID 
     * @param contaContabilSintetica 
     * @param nome 
     * @param observacao 
     */  
    public ContaContabilAnalitica(Long contaContabilAnaliticaID, ContaContabilSintetica contaContabilSintetica, String nome, String observacao)  
    {  
        this.contaContabilAnaliticaID = contaContabilAnaliticaID;  
        this.contaContabilSintetica = contaContabilSintetica;  
        this.nome = nome;  
        this.observacao = observacao;  
      
        this.lancamentosDebito = new HashSet<Lancamento>();  
        this.lancamentosCredito = new HashSet<Lancamento>();  
    }  
  
    @Id  
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CONTACONTABILANALITICA_SEQ")  
    @Column(name="contaContabilAnaliticaID", unique=TRUE, nullable=TRUE, insertable=TRUE, updatable=TRUE)  
    public Long getContaContabilAnaliticaID()  
    {  
        return this.contaContabilAnaliticaID;  
    }  
  
    @Column(name="nome", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255)  
    public String getNome()  
    {  
        return this.nome;  
    }  
  
    @Column(name="observacao", unique=FALSE, nullable=TRUE, insertable=TRUE, updatable=TRUE, length=255)  
    public String getObservacao()  
    {  
        return this.observacao;  
    }  
  
    @ManyToMany(fetch=FetchType.LAZY)  
    @JoinTable(name="ContaDebitada", joinColumns = {@JoinColumn(name="contaContabilAnaliticaID", nullable=TRUE)}, inverseJoinColumns = {@JoinColumn(name="lancamentoID", nullable=TRUE)})  
    @Fetch(FetchMode.SELECT)  
    @Cascade(CascadeType.DELETE_ORPHAN)  
    public Set<Lancamento> getLancamentosDebito()  
    {  
        return this.lancamentosDebito;  
    }  
  
    @ManyToMany(fetch=FetchType.LAZY)  
    @JoinTable(name="ContaCreditada", joinColumns = {@JoinColumn(name="contaContabilAnaliticaID", nullable=TRUE)}, inverseJoinColumns = {@JoinColumn(name="lancamentoID", nullable=TRUE)})  
    @Fetch(FetchMode.SELECT)  
    @Cascade(CascadeType.DELETE_ORPHAN)  
    public Set<Lancamento> getLancamentosCredito()  
    {  
        return this.lancamentosCredito;  
    }  
  
    @ManyToOne(fetch = FetchType.LAZY)  
    @JoinColumn(name="contaContabilSinteticaID", insertable=TRUE, updatable=TRUE)  
    @Fetch(FetchMode.SELECT)  
    public ContaContabilSintetica getContaContabilSintetica()  
    {  
        return this.contaContabilSintetica;  
    }  
  
    /** 
     *  
     * @param contaContabilAnaliticaID 
     */  
    public void setContaContabilAnaliticaID(Long contaContabilAnaliticaID)  
    {  
        this.contaContabilAnaliticaID = contaContabilAnaliticaID;  
    }  
  
    /** 
     *  
     * @param nome 
     */  
    public void setNome(String nome)  
    {  
        this.nome = nome;  
    }  
  
    /** 
     *  
     * @param observacao 
     */  
    public void setObservacao(String observacao)  
    {  
        this.observacao = observacao;  
    }  
  
    /** 
     *  
     * @param lancamentosDebito 
     */  
    public void setLancamentosDebito(Set<Lancamento> lancamentosDebito)  
    {  
        Iterator<Lancamento> iterator = lancamentosDebito.iterator();  
      
        while (iterator.hasNext())  
        {  
            Lancamento lancamento = (Lancamento)iterator.next();  
            this.adicionarLancamentoDebito(lancamento);  
        }   
    }  
  
    /** 
     *  
     * @param lancamentosCredito 
     */  
    public void setLancamentosCredito(Set<Lancamento> lancamentosCredito)  
    {  
        Iterator<Lancamento> iterator = lancamentosCredito.iterator();  
      
        while (iterator.hasNext())  
        {  
            Lancamento lancamento = (Lancamento)iterator.next();  
            this.adicionarLancamentoCredito(lancamento);  
        }   
    }  
  
    /** 
     *  
     * @param contaContabilSintetica 
     */  
    public void setContaContabilSintetica(ContaContabilSintetica contaContabilSintetica)  
    {  
        this.contaContabilSintetica = contaContabilSintetica;  
    }  
  
    /** 
     *  
     * @param lancamento 
     */  
    @Transient  
    public void adicionarLancamentoDebito(Lancamento lancamento)  
    {  
        if (!this.getLancamentosDebito().contains(lancamento))  
        {  
            this.lancamentosDebito.add(lancamento);  
            lancamento.adicionarContaDebito(this);  
        }  
    }  
  
    /** 
     *  
     * @param lancamento 
     */  
    @Transient  
    public void adicionarLancamentoCredito(Lancamento lancamento)  
    {  
        if (!this.getLancamentosCredito().contains(lancamento))  
        {  
            this.lancamentosCredito.add(lancamento);  
            lancamento.adicionarContaCredito(this);  
        }  
    }  
  
    /** 
     *  
     * @param lancamento 
     */  
    @Transient  
    public void removerLancamentoDebito(Lancamento lancamento)  
    {  
        if (this.getLancamentosDebito().contains(lancamento))  
        {  
            this.lancamentosDebito.remove(lancamento);  
            lancamento.removerContaDebito(this);  
        }  
    }  
  
    /** 
     *  
     * @param lancamento 
     */  
    @Transient  
    public void removerLancamentoCredito(Lancamento lancamento)  
    {  
        if (this.getLancamentosCredito().contains(lancamento))  
        {  
            this.lancamentosCredito.remove(lancamento);  
            lancamento.removerContaCredito(this);  
        }  
    }  
  
    /** 
     *  
     * @param contaContabilSintetica 
     */  
    @Transient  
    public void adicionarContaContabilSintetica(ContaContabilSintetica contaContabilSintetica)  
    {  
        this.contaContabilSintetica = contaContabilSintetica;  
        contaContabilSintetica.adicionarContaContabilAnalitica(this);  
    }  
  
    /** 
     *  
     * @param contaContabilSintetica 
     */  
    @Transient  
    public void removerContaContabilSintetica(ContaContabilSintetica contaContabilSintetica)  
    {  
        if (this.contaContabilSintetica.equals(contaContabilSintetica))  
        {  
            this.contaContabilSintetica = null;  
            contaContabilSintetica.removerContaContabilAnalitica(this);  
        }  
    }  
  
    /** 
     * Saldo total da conta contábil. Nas contas contábeis analíticas é a diferença 
     * entre os lançamento de crédito e os de débito. Já nas contas contábies 
     * sintéticas, o saldo, é o somatório dos saldos das contas contábeis analí ticas 
     * pertencentes a esta conta. 
     */  
    @Transient  
    @Column(name="saldo", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, precision=2)  
    public float getSaldo()  
    {  
        float saldo = 0;  
        //1 - recuperar o vetor de lançamentos de crédito e somar os valores doa lançamentos  
        //2 - recuperar o vetor de lançamentos de débito e somar os valores doa lançamentos  
        //3 - subtrair um resultado do outro (créditos - débitos)  
        return saldo;  
    }  
  
}

Lancamento

/** 
* Os lançamentos contábes são feitos somente nas contas contábeis analíticas e na 
* forma de partidas dobradas, ou seja, para cada lançamento de crédito existe um 
* lançamento de débito correspondente. Na conta onde é feito o lançamento de 
* crédito é chamada de conta de crédito e a conta que recebe o lançamento de 
* débito tem o nome de conta de débito. Pode existir mais de uma conta de crédito 
* e de débito no mesmo lançamento, contudo não podendo ser a mesma para o crédito 
* e para o débito 
* @author Marcelo Magalhães 
* @version 1.0 
* @created 31-jul-2010 01:45:53 
*/  
package modelo;  
  
import java.io.Serializable;  
import java.util.Date;  
import java.util.Calendar;  
import java.util.HashSet;  
import java.util.Set;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.FetchType;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.JoinColumn;  
import javax.persistence.JoinTable;  
import javax.persistence.ManyToMany;  
import javax.persistence.SequenceGenerator;  
import javax.persistence.Table;  
import javax.persistence.Temporal;  
import javax.persistence.TemporalType;  
import javax.persistence.Transient;  
  
import org.hibernate.annotations.Fetch;  
import org.hibernate.annotations.FetchMode;  
  
@Entity  
@Table(name="Lancamento")  
  
@SequenceGenerator(name="LANCAMENTO_SEQ", sequenceName="LANCAMENTO_SEQ", allocationSize=1)  
public class Lancamento implements Serializable   
{  
  
    private static final long serialVersionUID = 1;  
    private static final boolean TRUE = true;  
    private static final boolean FALSE = false;  
    /** 
     * Identificador da(s) conta(s) de débito do lançamento. 
     */  
    private Set<ContaContabilAnalitica> contasDebito;  
    /** 
     * Identificador da(s) conta(s) de crédito do lançamento. 
     */  
    private Set<ContaContabilAnalitica> contasCredito;  
    /** 
     * Identificador do lançamento. Sequence gerada pelo banco de dados. 
     */  
    private long lancamentoID;  
    /** 
     * Data da cadastro do lançamento. O valor padrão é data corrente. Formato: yyyy- 
     * mm-dd hh:mm:ss 
     */  
    private Calendar dataCadastro;  
    /** 
     * Valor do lançamento 
     */  
    private float valor;  
    /** 
     * Histórico ou descrição do lançamento 
     */  
    private String historico;  
  
    /** 
     * Construtor padrão 
     */  
    public Lancamento()  
    {  
        this.dataCadastro = Calendar.getInstance();  
        dataCadastro.setTime(new Date());  
          
        this.contasDebito = new HashSet<ContaContabilAnalitica>();  
        this.contasCredito = new HashSet<ContaContabilAnalitica>();  
    }  
  
    /** 
     * Construtor padrão com argumentos 
     *  
     * @param lancamentoID 
     * @param valor 
     * @param historico 
     * @param contasDebito 
     * @param contasCredito 
     */  
    public Lancamento(long lancamentoID, float valor, String historico, Set<ContaContabilAnalitica> contasDebito, Set<ContaContabilAnalitica> contasCredito)  
    {  
        this.lancamentoID = lancamentoID;  
        this.valor = valor;  
        this.historico = historico;  
        this.contasDebito = contasDebito;  
        this.contasCredito = contasCredito;  
          
        this.dataCadastro = Calendar.getInstance();  
        dataCadastro.setTime(new Date());  
    }  
  
    @Id  
    @Column(name="lancamentoID", unique=TRUE, nullable=TRUE, insertable=TRUE, updatable=TRUE)  
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="LANCAMENTO_SEQ")  
    public long getLancamentoID()  
    {  
        return this.lancamentoID;  
    }  
  
    @Temporal(TemporalType.TIMESTAMP)  
    @Column(name="dataCadastro", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE)  
    public Calendar getDataCadastro()  
    {  
        return this.dataCadastro;  
    }  
  
    @Column(name="valor", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255, precision=2)  
    public float getValor()  
    {  
        return this.valor;  
    }  
  
    @Column(name="historico", unique=FALSE, nullable=FALSE, insertable=TRUE, updatable=TRUE, length=255)  
    public String getHistorico()  
    {  
        return this.historico;  
    }  
  
    @ManyToMany(fetch=FetchType.LAZY)  
    @JoinTable(name="ContaDebitada", joinColumns = {@JoinColumn(name="lancamentoID")},inverseJoinColumns = {@JoinColumn(name="contaContabilAnaliticaID")})  
    @Fetch(FetchMode.SELECT)  
    public Set<ContaContabilAnalitica> getContasDebito()  
    {  
        return this.contasDebito;  
    }  
  
    @ManyToMany(fetch=FetchType.LAZY)  
    @JoinTable(name="ContaCreditada", joinColumns = {@JoinColumn(name="lancamentoID")},inverseJoinColumns = {@JoinColumn(name="contaContabilAnaliticaID")})  
    @Fetch(FetchMode.SELECT)  
    public Set<ContaContabilAnalitica> getContasCredito()  
    {  
        return this.contasCredito;  
    }  
  
    /** 
     *  
     * @param lancamentoID 
     */  
    public void setLancamentoID(long lancamentoID)  
    {  
        this.lancamentoID = lancamentoID;  
    }  
  
    public void setDataCadastro(Calendar data)  
    {         
        this.dataCadastro = data;  
    }  
  
    /** 
     *  
     * @param valor 
     */  
    public void setValor(float valor)  
    {  
        this.valor = valor;  
    }  
  
    /** 
     *  
     * @param historico 
     */  
    public void setHistorico(String historico)  
    {  
        this.historico = historico;  
    }  
  
    /** 
     *  
     * @param contasDebito 
     */  
    public void setContasDebito(Set<ContaContabilAnalitica> contasDebito)  
    {  
        this.contasDebito = contasDebito;  
    }  
  
    /** 
     *  
     * @param contasCredito 
     */  
    public void setContasCredito(Set<ContaContabilAnalitica> contasCredito)  
    {  
        this.contasCredito = contasCredito;  
    }  
  
    /** 
     *  
     * @param contaDebito 
     */  
    @Transient  
    public void adicionarContaDebito(ContaContabilAnalitica contaDebito)  
    {  
        if (!this.getContasDebito().contains(contaDebito))  
        {  
            this.contasDebito.add(contaDebito);  
            contaDebito.adicionarLancamentoDebito(this);  
        }  
    }  
  
    /** 
     *  
     * @param contaCredito 
     */  
    @Transient  
    public void adicionarContaCredito(ContaContabilAnalitica contaCredito)  
    {  
        if (!this.getContasCredito().contains(contaCredito))  
        {  
            this.contasCredito.add(contaCredito);  
            contaCredito.adicionarLancamentoCredito(this);  
        }  
    }  
  
    /** 
     *  
     * @param contaDebito 
     */  
    @Transient  
    public void removerContaDebito(ContaContabilAnalitica contaDebito)  
    {  
        if (!this.getContasDebito().contains(contaDebito))  
        {  
            this.contasDebito.remove(contaDebito);  
            contaDebito.removerLancamentoDebito(this);  
        }   
    }  
  
    /** 
     *  
     * @param contaCredito 
     */  
    @Transient  
    public void removerContaCredito(ContaContabilAnalitica contaCredito)  
    {  
        if (!this.getContasCredito().contains(contaCredito))  
        {  
            this.contasCredito.remove(contaCredito);  
            contaCredito.removerLancamentoCredito(this);  
        }   
    }  
}