Tentei começar a usar o Hibernate aqui. Não consegui. Muito XML, muita configuração. Muita complicação.
Eu sei: é poderoso, é legal, é o padrão, resolve um milhão de problemas mas vou tentar nadar contra a correnteza mais uma vez.
Pensando nas palavras do mestre Maurício:
Quando penso em persistencia, penso em CRUD (Create/Update/Delete) para meus beans. Tenho um objeto User e quero salvar ele no banco de dados sem chateações. Qualquer outra operação diferente de um CRUD, que involva join e/ou um where mais complexo será feita com JDBC puro. Acho que para essas situações, não é um crime usar JDBC e é até uma vantagem dos DAOs, já que podemos ter um DAO para qualquer query.
Então para os CRUDS, terei algo assim:
public class DBInviteImpl extends DBPersistent implements Invite {
private IntField id = new AutoIncrementField(this, "id", true); // true = PK
private StringField email = new StringField(this, "email");
private DateTimeField senddate = new DateTimeField(this, "senddate");
public static Invite getInstance() {
return new DBInviteImpl();
}
protected DBInviteImpl() { }
// isso aqui pode virar injection...
public ConnectionHandler getConnectionHandler() {
return DefaultConnectionHandler.getInstance();
}
public String getTableName() { return "invites"; }
public void setId(int id) { this.id.setValue(id); }
public int getId() { return id.getValue(); }
public void setEmail(String email) { this.email.setValue(email); }
public String getEmail() { return email.getValue(); }
public void setSendDate(Date senddate) { this.senddate.setValue(senddate); }
public Date getSendDate() { return senddate.getValue(); }
}Note que as únicas funções abstratas de DBPersisten é getConnectionHandler e getTablename().
E para usar o bean:
Invite inv = DBInviteImpl.getInstance();
// carrega por id
inv.setId(10);
if (inv.load()) {
inv.setEmail("aaa@bbb.com");
inv.update();
}
// insere um novo no banco...
inv.insert();
System.out.println("NOVO ID: " + inv.getId());
// deleta
inv.delete();
// carrega por username
Invite inv = DBInviteImpl.getInstance();
inv.setUsername("aaaa");
if (inv.load()) {
System.out.println("O ID é: " + inv.getId());
}
// e qualquer outra coisa com update, insert, delete.O que falta aí:
-> Transação (isso é mole)
-> Cache (isso não é tão mole mais dá para fazer)
Quais os problemas pratícos que eu terei se usar essa solução ?
-
Não terei que fazer a persistencia na mão, pois isso tudo já está feito pela classe DBPersistent, que gera as queries, etc e tal. (Note que a DBPersistent é uma classe genérica para persistir qualquer POJO)
-
Não terei que fazer tunning da persistencia. (Só terei que tunar o cache, claro!)
-
Isso seria bem produtivo para CRUD, certo?
E tudo que não for CRUD eu faria com JDBC mesmo.
Dessa maneira bye bye XML e configurações do Hibernate!
Já embarquei nessa algumas vezes, e não tive muito do que reclamar.
E aí? Embarco de novo ou tento mais uma vez mexer com o Hibernate?
