[quote=wellington.nogueira]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).[/quote]
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;
}
/**
* <b>mostrar todos os usuarios</b> <br/><br/>
*/
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;
}
/**
* <b>inserir usuario, e se não exisir, a pessoa relacionada a ele</b> <br/><br/>
*/
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;
}
/**
* <b>update de usuario e pessoa relacionada a ele</b> <br/><br/>
*/
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;
}
/**
* <b>deleta usuario</b> <br/><br/>
*/
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:
alias_Usuario.idUsuario
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
