Hibernate e JPA por que?

Hmm... dei uma olhada no teu exemplo, e acho que entendi o que você fez. Só achei que tudo ficou um pouco espalhado demais. Para sistemas pequenos é tranquilo e até para sistemas médios pode ser controlável, mas a medida que um sistema cresce, pode-se criar uma dificuldade bem indesejável.

No construtor das classes que herdam de Alias, tentaria fazer algo com reflection para evitar o mapeamento que seria obrigado a fazer ali (ou melhor, transferiria essa responsabilidade para o construtor do Alias).

wellington.nogueira wrote:Hmm... dei uma olhada no teu exemplo, e acho que entendi o que você fez. Só achei que tudo ficou um pouco espalhado demais. Para sistemas pequenos é tranquilo e até para sistemas médios pode ser controlável, mas a medida que um sistema cresce, pode-se criar uma dificuldade bem indesejável.

No construtor das classes que herdam de Alias, tentaria fazer algo com reflection para evitar o mapeamento que seria obrigado a fazer ali (ou melhor, transferiria essa responsabilidade para o construtor do Alias).

Eu mudei um pouco os metodos. Vi que existiam algumas redundancias e resolvi tirar.
Existem 2 formas de se utilizar o SQL:
pela criação de um novo Context - ideal para obter listas e campos específicos. Exemplo visto no metodo mostrar_todos
apartir de algum aliase - aqui trabalhamos com objetos das entidades. com um UsuarioAliase podemos realizar um CRUD em uma tabela Usuario.

Não existe Lazzy ou Eager, por enquanto.
Usuo o setAutoCommit nas transações.

package testeorm.business;

import testeorm.Implementeds.*;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List; 
import orm.syntaxe.*;

/**
 * @author Luiz Augusto S. Prado (www.codigorapido.com.br - 2011)
 */
public class UsuarioBu
{
	Connection con;

// minha conexao
	public UsuarioBu(Connection con)
	{
		this.con=con;
	}

/**
	* mostrar todos os usuarios 
	*/
	public List<Usuario> mostrarTodos() throws Exception
	{
		//====================================================================================================
		//	1 - Criar os Aliases
		//====================================================================================================
		UsuarioAliase alias_Usuario = new UsuarioAliase("user") ;
		PessoaAliase alias_Pessoa = new PessoaAliase("person") ;
		 
		//====================================================================================================
		//	2 - Criar as restries
		//====================================================================================================
		Restrictions on = new Restrictions()
				.Equal(alias_Usuario.idPessoa, alias_Pessoa.idPessoa) 
				.getRestrictions();
		// poderia inserir mais esta busca por exemplo
		// Restrictions where = new Restrictions()
		//		.Equal(a.login, "teste")
		//		.getRestrictions();

//====================================================================================================
		//	3 - Construir Query
		//====================================================================================================
		Context contexto = new Context();

String str = contexto
			.Select( alias_Usuario.idUsuario, alias_Pessoa.nome, alias_Pessoa.cpfcnpj )
			.From(alias_Usuario)
			.Join(Join.INNER, alias_Pessoa)
			.On(on)
			//.Where(where) // poderia inserir mais esta busca por exemplo
			.getQueryString();

//System.out.println(str);

//====================================================================================================
		//	4 - Executar query
		//====================================================================================================
 		PreparedStatement prepStmt = con.prepareStatement(str);
		ResultSet resultSet = prepStmt.executeQuery();

//====================================================================================================
		//	5 -Popular Value Objects
		//====================================================================================================
		List<Usuario> usuarios = new ArrayList<Usuario>();
		while (resultSet.next())
		{
			Usuario usuario = alias_Usuario.populeObject( resultSet, alias_Usuario.idUsuario );
			Pessoa pessoa = alias_Pessoa.populeObject(resultSet, alias_Pessoa.nome, alias_Pessoa.cpfcnpj );
			usuario.setPessoa(pessoa);
			usuarios.add(usuario);
		}

//====================================================================================================
		//	6 - fechar resultset e PreparedStatement
		//====================================================================================================
		resultSet.close();
		prepStmt.close();
		return usuarios; 
	}

/**
	* inserir usuario, e se não exisir, a pessoa relacionada a ele 
	*/
	public Usuario inserir(Usuario usuario) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException,SQLException
	{
		//========================================================================================================
		// cria aliases de cada tabela
		//========================================================================================================
		UsuarioAliase alias_Usuario = new UsuarioAliase("user");
		PessoaAliase alias_Pessoa = new PessoaAliase("person");

con.setAutoCommit(false);

//====================================================================================================
		// Criar a restricao
		//====================================================================================================
		Restrictions where = new Restrictions()
				.Equal(alias_Pessoa.cpfcnpj, usuario.getPessoa().getCpfcnpj())
				.getRestrictions();

//====================================================================================================
		// Construir Query
		//====================================================================================================
		Context contexto = new Context();

String str = contexto
				.Select(alias_Pessoa)
				.From(alias_Pessoa)
				.Where(where)
				.getQueryString();

//====================================================================================================
		// buscar
		//====================================================================================================
		List<Pessoa> listPessoas = alias_Pessoa.select(str, con);

//========================================================================================================
		// se não encontrar insere. se não update.
		//========================================================================================================
		if (listPessoas.size() == 0)
		{
			//========================================================================================================
			// insere pessoa
			//========================================================================================================
			List<Object> listKeysPessoas = alias_Pessoa.insert(usuario.getPessoa(), con);
			//========================================================================================================
			// atualiza objeto com as novas chaves geradas
			//========================================================================================================
			usuario.setIdPessoa(Integer.parseInt(listKeysPessoas.get(0).toString()));
			usuario.getPessoa().setIdPessoa(Integer.parseInt(listKeysPessoas.get(0).toString()));
		}
		else
		{
			//========================================================================================================
			// atualiza objeto com as novas chaves geradas
			//========================================================================================================
			usuario.setIdPessoa(listPessoas.get(0).getIdPessoa());
			usuario.getPessoa().setIdPessoa(listPessoas.get(0).getIdPessoa());
			//========================================================================================================
			// update da pessoa
			//========================================================================================================
			alias_Pessoa.update(usuario.getPessoa(), con) ;
		}

//========================================================================================================
		// verifica se a existe um usuario com o mesmo login
		// Criar a restricao
		//====================================================================================================
		Restrictions where2 = new Restrictions()
				.Equal(alias_Usuario.login, usuario.getLogin())
				.getRestrictions();

//====================================================================================================
		// Construir Query
		//====================================================================================================
		Context contexto2 = new Context();

String str2 = contexto2
				.Select(alias_Usuario)
				.From(alias_Usuario)
				.Where(where2)
				.getQueryString();

//====================================================================================================
		// buscar
		//====================================================================================================
		List<Usuario> listUsuarios = alias_Usuario.select(str2, con);

if (listUsuarios.size() == 0)
		{
			List<Object> t = alias_Usuario.insert(usuario, con);
			usuario.setIdUsuario(Integer.parseInt(t.get(0).toString()));
		}
		else
		{
			con.rollback();
			con.setAutoCommit(true);
			throw new SQLException("Já existe um usuario com este login.");
		}

con.commit();
		con.setAutoCommit(true);

return usuario;
	}

/**
	* update de usuario e pessoa relacionada a ele 
	*/
	public Usuario update(Usuario usuario) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException,SQLException
	{
		//========================================================================================================
		// cria aliases de cada tabela
		//========================================================================================================
		UsuarioAliase alias_Usuario = new UsuarioAliase("user");
		PessoaAliase alias_Pessoa = new PessoaAliase("person");

con.setAutoCommit(false);

try
		{
			alias_Pessoa.update(usuario.getPessoa(), con);
			alias_Usuario.update(usuario, con);
		}
		catch(SQLException ex)
		{
			con.rollback();
			con.setAutoCommit(true);
			throw new SQLException("Não foi possivel atualizar o usuario.");
		}

con.commit();
		con.setAutoCommit(true);

return usuario;
	}

/**
	* deleta usuario 
	*/
	public void delete(Usuario usuario) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException,SQLException
	{
		UsuarioAliase alias_Usuario = new UsuarioAliase("user") ;
		try
		{ 
			alias_Usuario.Delete( usuario, con);
		}
		catch (SQLException ex)
		{
			throw new SQLException("Não foi possivel excluir o usuario. " + ex.getMessage());
		}
	}

public static void main(String[] args)
	{
		MyConnections ds = new MyConnections();

Usuario us = new Usuario();
		us.setIdUsuario(26);
		us.setAtivo(true);

try
		{
			new UsuarioBu(ds.getConnectionByDriver()).delete(us);
		}
		catch (Exception ex)
		{
			System.out.println(ex.getMessage());
		}

Pessoa pessoa = new Pessoa();
		pessoa.setCpfcnpj("00000000001");
		pessoa.setEndereco("endereco abc");
		pessoa.setNome("nome teste");
		pessoa.setTelefone("06200000000");

Usuario usuario =  new Usuario();
		usuario.setAtivo(true);
		usuario.setDataEntrada("2011-11-2");
		usuario.setDataSaida(null);
		usuario.setLogin("teste3");
		usuario.setSenha("teste");
		usuario.setPessoa(pessoa);

try
		{
			new UsuarioBu(ds.getConnectionByDriver()).inserir(usuario);
		}
		catch (Exception ex)
		{
			System.out.println(ex.getMessage());
		}

List<Usuario> usuarios;
		try
		{
			usuarios = new UsuarioBu(ds.getConnectionByDriver()).mostrarTodos();
			for (Usuario u : usuarios)
			{
				System.out.println(u.getIdUsuario() + " " + u.getPessoa().getNome() + " " + u.getPessoa().getCpfcnpj());
			}
		}
		catch (Exception ex)
		{
			System.out.println(ex.getMessage());
		}
	}

}

Eu aproveito que por reflection podemos ler também uma interface e desta foma fazer o mapeamento:

package testeorm.Interfaces;

import testeorm.DialectMySQL;
import orm.generators.Annotations.*;

@Table( DataBase="db_condominio", Nome="Usuario"  )
public interface Usuario
{
	@Column(SqlDataType=DialectMySQL.DataType_INT, Key=DialectMySQL.KeyType_PRIMARY, AutoIncrement=true, Nullable=true, lengthMax=11, lengthMin=1)
	public int idUsuario();

@Column(SqlDataType=DialectMySQL.DataType_VARCHAR, Key=DialectMySQL.KeyType_UNIQUE, Nullable=false, lengthMax=16, lengthMin=8)
	public String login();

@Column(SqlDataType=DialectMySQL.DataType_VARCHAR, Nullable=false, lengthMax=32, lengthMin=8)
	public String senha();

@Column(SqlDataType=DialectMySQL.DataType_BOOLEAN, Nullable=false, lengthMax=3)
	public boolean ativo();

@Column(SqlDataType=DialectMySQL.DataType_DATE, Nullable=false, lengthMax=8)
	public String dataEntrada();

@Column(SqlDataType=DialectMySQL.DataType_DATE, Nullable=true, lengthMax=8)
	public String dataSaida();

@Column(SqlDataType=DialectMySQL.DataType_INT, Key=DialectMySQL.KeyType_INDEX, Nullable=false, lengthMax=11, lengthMin=1)
	@Foreign(ForeignKeyOf=testeorm.Interfaces.Pessoa.class, ForeignKeyName="idPessoa")
	public int idPessoa();
}

Postei um PDF para outros detalhes.

Os VOs e os VoAliases não precisam nem ser vistos.
Só é necessario escrever as interfaces com os mapeamentos e suas classes de negocios.
O mapeamento ficou isolado na interface enquanto seus VOs são gerados sem nenhuma annotation.
Fica a seu criterio inserir annotations ou não em seus VOs.

respondendo a sua pergunta anteriror...
é apartir da alias_Usuario que pego o nome dos campos que preciso em um select:

Desta forma o autocompletar me ajuda muito na hora de pegar os campos que preciso

Por favor, não se incomode em levantar criticas (boas ou ruim).
Para mim elas serão muito contrutivas se existirem um "porque".
Por eu ter experiência em muitas linguagens as vezes esqueço as normas
de escrita do java, por isso, se encontrar algo que poderia ficar melhor, por favor me mostre.

Quando se acostuma com um perfume não se sabe que ele não agrada a todos até que nos alertem

This message was edited 1 time. Last update was at 08/11/2011 21:07:42

O que a curiosidade não nos leva a fazer heim?

GUJ Master Membro desde: 21/06/2007 23:27:21 Mensagens: 1850 Offline

Mas por questão de gosto pessoal, eu perfiro utilizar algo mais simples e menos dependente como
JDBC.

Acho que você está se contradizendo na sua proposta de não usar Hibernate ou JPA.

Onde está o JDBC e onde está o simples no código?

rogelgarcia wrote://Aliases aliases = new Aliases(); //aliases.add(new TableAliases("a", Usuario.class)) //aliases.add(new TableAliases("b", Pessoa.class)) //declaro minha aliases e jogo elas aqui: context .SELECT( aliases.get("a").Field(Usuario.idUsuario), aliases.get("b").Field(Pessoa.nome) ) .FROM("a") .INNER_JOIN("b") .ON( aliases.get("a").Field(Usuario.idPessoa) .EQUAL( aliases.get("b").Field(Pessoa.idPessoa) ) .AND( aliases.get("b").Field(Pessoa.nome) .equal( STRINGNAMEQUALQUER ) ) .WHERE( aliases.get("b").Field(Pessoa.nome) .equal( STRINGNAMEQUALQUER ) );

Mas por questão de gosto pessoal, eu perfiro utilizar algo mais simples e menos dependente como
JDBC.

Acho que você está se contradizendo na sua proposta de não usar Hibernate ou JPA.

Onde está o JDBC e onde está o simples no código?

Tá aqui :
Eu mudei um pouco os metodos. Vi que existiam algumas redundancias e resolvi tirar.
http://www.guj.com.br/posts/downloadAttach/7496.java
http://www.codigorapido.com.br/testeOrm.zip

Luiz,

Acho que a iniciativa de criar algo das proporções que você esta tentando é válida quando se tem um propósito específico.

Eu já fiz algo parecido também a alguns anos, e o propósito que eu tinha era unicamente entender melhor como estes fw de orm trabalhavam ... o objetivo era unicamente educacional.

Sobre o JPA e Hibernate, acho que não é por marketing ou qq outra estratégia que são bem utilizados e conhecidos. E sim porque a JPA é uma especificação oficial ( originado da JSR 317 ) que por sua vez, foi idealizado com a mesma direção do hibernate e também pelos mesmo idealizadores.

Acho que a adoção deste conjunto começa por ai ...

Boa sorte no seu projeto =)

This message was edited 1 time. Last update was at 28/01/2012 19:12:59

marciobarroso wrote:Luiz,

Acho que a iniciativa de criar algo das proporções que você esta tentando é válida quando se tem um propósito específico.

Eu já fiz algo parecido também a alguns anos, e o propósito que eu tinha era unicamente entender melhor como estes fw de orm trabalhavam ... o objetivo era unicamente educacional.

Sobre o JPA e Hibernate, acho que não é por marketing ou qq outra estratégia que são bem utilizados e conhecidos. E sim porque a JPA é uma especificação oficial ( originado da JSR 317 ) que por sua vez, foi idealizado com a mesma direção do hibernate e também pelos mesmo idealizadores.

Acho que a adoção deste conjunto começa por ai ...

Boa sorte no seu projeto =)

Olá Marciobarroso!

Muito obrigado pelas dicas.
Claro que tenho um proposito especício. Um deles é o estudo.
Conheço que JPA já possui Criteria.
Perdoem-me se eu falar bobeira aqui e se eu falar, por favor me corrijam.
Mas em se tratando de Hibernate e JPA ainda não consegui entender algumas coisas e acho estranho outras, como por exemplo:
Por que para a criação de chaves compostas temos que ter uma classe aparte (Embeddable) da tabela ?

Pra mim esse é o exemplo mais estranho que vejo:

Outra coisa é por exemplo um select:

Veja que a minha query é construida com strings: "new Grupo(id,nome)"
Aqui o id e o nome são string que só serão verificadas quando o programa for testado.
Suponha que vc escreva "nomee" e não ve o erro.

Minha tentativa é excluir essas strings da construção das queries. Isso é possivel em JPA e Hibernate?
Se for, por favor, me mostre o link que quero aprender como fazer isso.

Outro exemplo de select:
http://www.guj.com.br/java/234333-problema-com-select-jpa
veja
"SELECT usuario, senha FROM Usuario WHERE usuario = :usuario and senha = :senha"

Esse exemplo é muitissimo legal:
http://blog.werneckpaiva.com.br/2012/01/queries-com-a-nova-jpa2-criteria-api/
Mas ainda existem as strings como nome de campos.
Exemplo. Procure a linha :
builder.gt(from.get("price"), price)

String "price"

[]'s

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