Mensagens enviadas por: Lavieri

Uso Hibernate (mais estou deixando minha aplicação livre, onde posso a qualquer hora trocar a comunicação com o banco de dados)

em primeiro lugar queria mostrar meu banco para esses objetos em particular,

Eu tenho portanto Interfaces DAO, que tenho q Implementar a depender de qual é minha comunicação com o Banco de Dados, vou mandar o print do eclipse de como ficou a interface depois de juntar os 3 objetos no mesmo DAO

Então eu tenho 1 uma interface IDAOFactory, nela eu tenho a lista de todos os DAOs, e tenho os metodos de Tranzação, assim não preciso saber como converso com o baco de dados...

Tenho a classe que eu realmente converso que é estatica DAOFactory, e carrega o meu framework que conversa com o banco de dados

Posteriormente pretendo fazer o carregamento do "IDAOFactory minhaDAO = new HibernateDAOFactory()" atraves de XML podendo ser configurado e modificado, pra rodar com cada tipo de framework pra conversar com o banco de dados...

No meu HibernateDAOFactory eu implemento IDAOFactory, assim, eu posso chamar ele depois estaticamente atravez do DAOFactory, que carrega o Hibernate, neste caso apartir do DAOFacotry eu desconheço que se trata de hibernate

e cada DAO que eu tenho do hibernate implementa a interface, nas formas do Hibernate ... eu troquei pra 1 unico DAO para os 3 objetos

O meu CidadeDAO implementado para o Hibernate ficou assim

package br.com.aportepb.dao.hibernate;

import java.util.List;

import br.com.aportepb.dao.CidadeDAO;
import br.com.aportepb.entidade.Cidade;
import br.com.aportepb.entidade.Estado;
import br.com.aportepb.entidade.Pais;

public class HibernateCidadeDAO implements CidadeDAO {
	@Override
	public void deleteCidade(Cidade cidade) throws Exception {
		HibernateHelper.currentSession()
							.delete(cidade);
	}
	@Override
	public void deleteCidade(Integer idDoCidade) throws Exception {
		HibernateHelper.currentSession().getNamedQuery("Cidade.deleteFromId")
							.setInteger("id", idDoCidade)
							.executeUpdate();
	}
	@Override
	public void deleteEstado(Estado estado) throws Exception {
		HibernateHelper.currentSession()
							.delete(estado);
	}
	@Override
	public void deleteEstado(Integer idDoEstado) throws Exception {
		HibernateHelper.currentSession().getNamedQuery("Estado.deleteFromId")
							.setInteger("id", idDoEstado)
							.executeUpdate();
	}
	@Override
	public void deletePais(Pais pais) throws Exception {
		HibernateHelper.currentSession()
							.delete(pais);
	}
	@Override
	public void deletePais(Integer idDoPais) throws Exception {
		HibernateHelper.currentSession().getNamedQuery("Pais.deleteFromId")
							.setInteger("id", idDoPais)
							.executeUpdate();
	}
	@Override
	public Cidade getCidade(Integer idDoCidade) throws Exception {
		return (Cidade)HibernateHelper.currentSession()
										.get(Cidade.class, idDoCidade);
	}
	@Override
	public Cidade getCidade(String nomeDoCidade) throws Exception {
		return (Cidade)HibernateHelper.currentSession()
										.getNamedQuery("Cidade.fromNome")
										.setString("nome", nomeDoCidade)
										.uniqueResult();
	}
	@Override
	public Estado getEstado(Integer idDoEstado) throws Exception {
		return (Estado)HibernateHelper.currentSession()
										.get(Estado.class, idDoEstado);
	}
	@Override
	public Estado getEstado(String nomeDoEstado) throws Exception {
		return (Estado)HibernateHelper.currentSession()
										.getNamedQuery("Estado.fromNome")
										.setString("nome", nomeDoEstado)
										.uniqueResult();
	}
	@Override
	public Pais getPais(Integer idDoPais) throws Exception {
		return (Pais)HibernateHelper.currentSession()
										.get(Pais.class, idDoPais);
	}
	@Override
	public Pais getPais(String nomeDoPais) throws Exception {
		return (Pais)HibernateHelper.currentSession()
										.getNamedQuery("Pais.fromNome")
										.setString("nome", nomeDoPais)
										.uniqueResult();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Cidade> getCidades() throws Exception {
		return HibernateHelper.currentSession()
								.createCriteria(Cidade.class)
								.list();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Cidade> getCidades(Estado estado) throws Exception {
		return HibernateHelper.currentSession()
		.getNamedQuery("Cidade.fromEstado")
		.setEntity("estado", estado)
		.list();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Cidade> getCidades(Pais pais) throws Exception {
		return HibernateHelper.currentSession()
						.getNamedQuery("Cidade.fromPais")
						.setEntity("pais", pais)
						.list();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Estado> getEstados() throws Exception {
		return HibernateHelper.currentSession()
								.createCriteria(Estado.class)
								.list();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Estado> getEstados(Pais pais) throws Exception {
		return HibernateHelper.currentSession()
						.getNamedQuery("Estado.fromPais")
						.setEntity("pais", pais)
						.list();
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Pais> getPaises() throws Exception {
		return HibernateHelper.currentSession()
								.createCriteria(Pais.class)
								.list();
	}
	@Override
	public void saveCidade(Cidade cidade) throws Exception {
		
		HibernateHelper.currentSession()
						.save(cidade);
	}
	@Override
	public void saveEstado(Estado estado) throws Exception {
		HibernateHelper.currentSession()
						.save(estado);
	}
	
	@Override
	public void savePais(Pais pais) throws Exception {
		HibernateHelper.currentSession()
						.save(pais);
	}
	@Override
	public void updateCidade(Cidade cidade) throws Exception {
		HibernateHelper.currentSession()
						.update(cidade);
	}
	@Override
	public void updateEstado(Estado estado) throws Exception {
		HibernateHelper.currentSession()
						.update(estado);
	}
	@Override
	public void updatePais(Pais pais) throws Exception {
		HibernateHelper.currentSession()
						.update(pais);
	}
	@Override
	public void loadCidade(Cidade cidade, Long id) {
		HibernateHelper.currentSession()
							.load(cidade, id);
	}
}

Para quem kizer visualizar o HibernateHelper segue abaixo

Note que nenhum método é publico, pois ninguem fora do pacote br.com.aportepb.dao.hibernate necessita manusiar o HibernateHelper, visto que ele é acessado apenas as classes Hibernate...DAO (por exemplo HibernateCidadeDAO e HibernatePessoaDAO) e HibernateDAOFactory ...

Abaixo segue o código do HibernateHelper

package br.com.aportepb.dao.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateHelper {
	private static final SessionFactory sessionFactory;
	@SuppressWarnings("unchecked")
	private static final ThreadLocal sessionThread = new ThreadLocal();
	@SuppressWarnings("unchecked")
	private static final ThreadLocal transactionThread = new ThreadLocal();

static {
		try {
			sessionFactory = new AnnotationConfiguration().configure()
					.buildSessionFactory();
		} catch (RuntimeException e) {
			e.printStackTrace();
			throw e;
		}
	}
	@SuppressWarnings("unchecked")
	static Session currentSession() {
		if (sessionThread.get() == null) {
			Session session = sessionFactory.openSession();
			sessionThread.set(session);
		}
		return (Session) sessionThread.get();
	}
	@SuppressWarnings("unchecked")
	static void beginTransaction() {
		if (transactionThread.get() == null) {
			Transaction transaction = currentSession().beginTransaction();
			transactionThread.set(transaction);
		}
	}
	@SuppressWarnings("unchecked")
	static void commitTransaction() {
		Transaction transaction = (Transaction) transactionThread.get();
		if (transaction != null && !transaction.wasCommitted()
				&& !transaction.wasRolledBack()) {
			transaction.commit();
			transactionThread.set(null);
		}
		closeSession();
	}
	@SuppressWarnings("unchecked")
	static void rollbackTransaction() {
		Transaction transaction = (Transaction) transactionThread.get();
		if (transaction != null && !transaction.wasCommitted()
				&& !transaction.wasRolledBack()) {
			transaction.rollback();
			transactionThread.set(null);
		}
		closeSession();
	}
	@SuppressWarnings("unchecked")
	private static void closeSession() {
		Session session = (Session) sessionThread.get();
		if (session != null) {
			session.close();
		}
		sessionThread.set(null);
	}
}

Note que o método CloseSession é private, e é chamado apos fazer um rollback ou um commit ... sendo assim, é facil a utilizacao, e é fechado sempre no momento correto, e não no meio de tranzações....

Bom acredito que no fim ficou bem facil, vai no post seguinte

Bom, minha duvida é muito basica.... eu tenho 3 objetos, persistentes, que se relacionam entre se ....

Cidade
Estado
Pais

a cidade tem um método getEstado() ... e o estado tem um método getPais()

minha duvida é basica... eu faço 3 DAOs, um para cada Objeto? ou posso fazer um unico DAO para os 3 objetos ??

atualmente tenho CidadeDAO, EstadoDAO, PaisDAO ... porem acho que não é necessario....

c for fazer uma unica DAO, qual seria o melhor nome ???

CidadeEstadoPaisDAO ??? ou tem algum q fike melhor ??

eu acabei de fazer aki, com chaves compostas estrangeiras, e funciona tb... o fato é q chave primária não deve ser modificada, e se há itenção de modificação a melhor solução é a criação de 1 chave interna, e se a unica intenção é que não haja replicas, fazer um unique ...

O que vc tava kerendo fazer, pelo q entendi, era alterar a chave primaria atravez do hibernate, o que nunca iria acontecer, visto q ele cria a codição WHERE do update de acordo com a chave primária ....

então renzonuccitelli, foi exatamente o q sugeri pra ele...

o problema ate onde ele tinha me dito, era q não keria replicas no registro (quando os 4 campos q ele ta usnado como chave são iguais), neste caso sugerir pra ele fazer um UNIQUE na tabela pros campos, e criar 1 chave primaria, assim ele poderia alterar normalmente seus dados.

Só pra especificar, o que to querendo, é poder dizer para o hibernate que um campo quando nulo não deve aparecer no código SQL quando o campo for NOT NULL

Eu também estou programando com Hibernate, com annotation, uma coisa que esta me ajudando d + é que configurei o seguinte

vc pode fazer isso no hibernate.cfg.xml tb, e setar essa propriedade, que vai fazer o hibernate soltar no console toda linha SQL que ele usa...

Fora isso, pelo que entendi, vc ta tentando recuperar dados do banco, e tua chaves estão vindo como nulas...

Isso ocorreu comigo quando eu tentava criar novos dados no banco, ai as chaves se mantinham nulas, e depois disso não era possivel fazer updates resolvi isso botando o seguinte campo no ID...

package com.jujuba.api.modelo.comum;

import java.io.Serializable;
import java.util.Collection;

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

import com.jujuba.api.controle.RegistroGenerico;

@Entity
@Table(name="pessoa")
public class Pessoa extends RegistroGenerico {
	/**
	 * Número interno do banco de dados de identificação da pessoa.
	 */
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="pessoa_id")
	private int identificacao;
	/**
	 * Nome da pessoa.
	 */
	@Column(name="pessoa_nome",nullable=false,unique=true)
	private String nome;
	//private Collection<Telefone> telefones;
	/**
	 * Modifica o número de identificação iterno da pessoa
	 * @param identificacao número interno de identificação da 
	 * pessoa no banco de dados.
	 */
	public void setIdentificacao(int identificacao) {
		this.identificacao = identificacao;
	}
	/**
	 * Busca o número de identificação interno da pessoa no banco de dados.
	 * @return o número de identificação interno da pessoa no banco de dados.
	 */
	public int getIdentificacao() {
		return identificacao;
	}
	/**
	 * Modifica o nome da pessoa
	 * @param nome nome da pessoa
	 */
	public void setNome(String nome) {
		this.nome = nome;
	}
	/**
	 * Busca o nome da pessoa
	 * @return o nome da pessoa.
	 */
	public String getNome() {
		return nome;
	}
	@Override
	protected Serializable getRegistroGenericoID() {
		return this.getIdentificacao();
	}
	
	public String toString()
	{
		return this.getNome();
	}
	
}

Note essa parte do código...

Com ela eu aviso ao Hibernate, que minha chave é gerada pela tabela, de forma automática, e quando eu faço algo como session.save(pessoa) ai ele adciona no banco, e ja seta a minha chave primaria....

Não sei o motivo exato de tuas chaves estarem vindo nulas, mais pode ser isso...

Oi pessoal, estou com um problema bem simples... mais não consegui achar a solução ...

Estou usando Hibernate, e estou kerendo adcionar 1 objeto a minha tabela, só que os campos na tabale são NOT NULL, e quero manter isso, porem, quando vou inserir dados na tabela, eu gostaria que se o campo fosse nulo, ele seguisse o valor padrão setado na tabela da tabela.

mesmo quando as propriedades do objetos são nulas ele tenta inserir como nulo, segue o pekeno código abaixo

A saida do hibernate foi

porem a minha intenção é que quando os valores sejam nulos no momento do insert, ele simplismente subtraia esses campos do insert eu esperava algo como:

pois ai nesse caso os valores padrões seriam assumidos pelos campos nulos no momento do INSERT. queria q não fosse necessario setar valores para outras propriedades do telefone.

estou usando Hibernate Annotation, porem se alguem sober a solução sem Annotation sem problemas, só queria saber a solução para ele suprimir, apenas no momento do insert, os valores nulos, pelos valores no banco de dados.

abaixo segue os códigos de criação da tabela, um screen da tabela, e o código do objeto Telefone

Ps.: Desde já agradeço qualquer ajuda

CREATE  TABLE IF NOT EXISTS `simrenta_myfactory`.`telefone` (
  `telefone_id` BIGINT NOT NULL AUTO_INCREMENT ,
  `telefone_fax` INT(3) NOT NULL DEFAULT 1 ,
  `telefone_mobilidade` INT(3) NOT NULL DEFAULT 1 ,
  `telefone_DDI` VARCHAR(5) NOT NULL DEFAULT '55' ,
  `telefone_DDD` VARCHAR(5) NOT NULL DEFAULT '83' ,
  `telefone_numero` VARCHAR(20) NOT NULL ,
  PRIMARY KEY (`telefone_id`) ,
  UNIQUE INDEX `u_telefone_DDI_DDD_numero` (`telefone_DDI` ASC, `telefone_DDD` ASC, `telefone_numero` ASC) ,
  INDEX `fk_telefone_telefoneFax` (`telefone_fax` ASC) ,
  INDEX `fk_telefone_telefoneMobilidade` (`telefone_mobilidade` ASC) ,
  CONSTRAINT `fk_telefone_telefoneFax`
    FOREIGN KEY (`telefone_fax` )
    REFERENCES `simrenta_myfactory`.`telefoneFax` (`telefoneFax_id` )
    ON DELETE RESTRICT
    ON UPDATE CASCADE,
  CONSTRAINT `fk_telefone_telefoneMobilidade`
    FOREIGN KEY (`telefone_mobilidade` )
    REFERENCES `simrenta_myfactory`.`telefoneMobilidade` (`telefoneMobilidade_id` )
    ON DELETE RESTRICT
    ON UPDATE CASCADE)
ENGINE = InnoDB

Objeto Telefone

package com.tomazlavieri.myfactory.dominio.util;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="telefone")
public class Telefone {
	/**
	 * Número de identificacao interno do telefone no banco de dados
	 */
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="telefone_id")
	private int identificacao;
	/**
	 * 
	 */
	@ManyToOne
	@JoinColumn(name="telefone_mobilidade")
	private TelefoneMobilidade mobilidade;
	@ManyToOne
	@JoinColumn(name="telefone_fax")
	private TelefoneFax fax;
	@Column(name="telefone_DDI")
	private String codigoDDI;
	@Column(name="telefone_DDD")
	private String codigoDDD;
	@Column(name="telefone_numero")
	private String telefone;
	public Telefone() {}
	/**
	 * @param identificacao the identificacao to set
	 */
	public void setIdentificacao(int identificacao) {
		this.identificacao = identificacao;
	}
	/**
	 * @return the identificacao
	 */
	public int getIdentificacao() {
		return identificacao;
	}
	/**
	 * @param mobilidade the mobilidade to set
	 */
	public void setMobilidade(TelefoneMobilidade mobilidade) {
		this.mobilidade = mobilidade;
	}
	/**
	 * @return the mobilidade
	 */
	public TelefoneMobilidade getMobilidade() {
		return mobilidade;
	}
	/**
	 * @param fax the fax to set
	 */
	public void setFax(TelefoneFax fax) {
		this.fax = fax;
	}
	/**
	 * @return the fax
	 */
	public TelefoneFax getFax() {
		return fax;
	}
	/**
	 * @param codigoDDI the codigoDDI to set
	 */
	public void setCodigoDDI(String codigoDDI) {
		this.codigoDDI = codigoDDI;
	}
	/**
	 * @return the codigoDDI
	 */
	public String getCodigoDDI() {
		return codigoDDI;
	}
	/**
	 * @param codigoDDD the codigoDDD to set
	 */
	public void setCodigoDDD(String codigoDDD) {
		this.codigoDDD = codigoDDD;
	}
	/**
	 * @return the codigoDDD
	 */
	public String getCodigoDDD() {
		return codigoDDD;
	}
	/**
	 * @param telefone the telefone to set
	 */
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
	/**
	 * @return the telefone
	 */
	public String getTelefone() {
		return telefone;
	}
}

Alguem ai sabe como criar um tab pane... com icone pra fechar o tab Pane??

semelhante akele do eclipse??

Bom galera... meu problema esta no seguinte....
não estou sabendo bem onde encaixar cada parte do meu código...

Model-> 1 - esta parte deve conter tanto beans como a parte de acesso a DB ??? 2 - ou apenas os bens que eu for utilizar??

Contro -> 1 - esta parte deve conter apenas a ligação entre o view e o model, passando dados de um lado pro outro 2- esta parte deve contar tanto o acesso ao DB como a ligação entre um modelo que contenha os beans e a View??

View - > no meu caso especifico eu estou fazendo um GUI...

bom... c eu utilizar o modelo 1, sei que para trocar a view só preciso escrever um novo control / view.... enquanto a opção numero 2... além disso ... eu preciso rescrever partes de código onde vai ta o acesso ao DB... o que axo xato....

qual das 2 formas está correta.... ou ta tudo errado ... e eu devo fazer de uma outra forma???

grato

eu naum queria o ntaivo naum... queria akele look and fell q está na imagem grato

Como eu aplico esse Look and Feel... isso q eu estou precisando saber

como eu faço pra a Arvore ficar identica a esta?

que açao eu ponho para um botão Cancelar fechar minha janela...

eu tentei this.finalize(); mas deu errado.... c alguem souber... por favor me informe... tnks

o meu pronlema é q não sei como montar a JTree...
e nem como deixar ela com esse visual ai...=]

ou seja... tenho todos os problemas

that is may problem => :n00b:

Preciso fazer este tipo de janela, alguem me ajude
Achei que poderia ser com JTree, mas não consegui descobrri como fazer um desse ou algo parecido... por favor... alguem me ajuda ai?!?

o que preciso exatamente é saber fazer a akela arvore a esquerda... e como mudar os paineis a direita

grato

Muito obrigado... me salvou ai ^^

Notícias, artigos e o maior fórum brasileiro sobre Java