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
ATIVOAbaixo 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);
}
}
}