========= Disponível para testes no jar beta e no SVN: http://www.mentaframework.org/beta/mentawai.jar
O Mentawai agora oferece uma solução simples para persistência de beans (POJOs) em banco de dados. Para fazer o mapeamento Tabela -> Objeto utilizamos configuração programática ao invés de XML ou Annotations.
A idéia aqui não é competir com Hibernate, JPA ou iBatis, mas sim oferecer uma solução simples, fácil e eficiente para fazer CRUDs de beans em seus projetos que utilizam o Mentawai.
Acreditamos que em muitos casos simples o MentaBean será uma mão-na-roda para vc persistir os seus Beans sem ter que depender do Hibernate/iBatis/JPA, etc e suas configurações.
Veja como é simples:
package hello;
public class User {
private int id;
private String name;
private int age;
public User(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public void init(Context application) {
ioc("session", MySQLBeanSession.class);
filter(new IoCFilter());
filter(new ConnectionFilter(connHandler));
filter(new DIFilter("conn", Connection.class));
}
public void loadBeans() {
bean(hello.User.class, "Users")
.field("id", DBTypes.AUTOINCREMENT, true)
.field("name", DBTypes.STRING)
.field("age", DBTypes.INTEGER);
// ou
BeanConfig bc = new BeanConfig(User.class, "Users");
bc.addField("id", DBTypes.AUTOINCREMENT, true);
bc.addField("name", DBTypes.STRING);
bc.addField("age", DBTypes.INTEGER);
addBeanConfig(bc);
}
public class HelloMentaBean extends BaseAction {
public String execute() throws Exception {
BeanSession session = (BeanSession) input.getValue("session");
User u = new User(1);
if (session.load(u)) {
System.out.println("Bean carregado!");
}
System.out.println("Username: " + u.getName());
// update a bean...
u.setName("Azenha");
session.update(u);
// delete a bean...
session.delete(u);
// inserindo...
User u = new User(2);
u.setAge(19);
u.setName("Pedro");
session.insert(u);
return SUCCESS;
}
}
Pontos importantes:
:arrow: Os updates gerados são inteligentes para fazer apenas o update nas colunas que foram alteradas, ou seja, se vc faz o load() de um bean com 20 colunas, altera uma coluna e faz um update(), apenas a coluna alterada sofrerá um update ao invés de todas.
User u = new User(1);
session.load(u); // 100 campos foram carregados aqui...
u.setAge(44);
session.update(u); // vai gerar apenas update users set age = ? where id = ? e não um update gigantesco dos 100 campos...
:arrow: Se vc deseja fazer um update num registro sem carregá-lo em memória antes, tudo que vc tem que fazer é construir um objeto, não fazer o load, setar os campo que vc deseja fazer o update, e chamar update:
User u = new User(1);
// não estamos dando load() !!!
u.setAge(44);
session.update(u); // vai gerar update users set age = ? where id = ?
:arrow: Suporta a criação de outros tipos de coluna para o banco de dados, isto é, se vc precisar vc pode criar novos tipos de dados para a inserção no seu bd isso é muito fácil de se fazer:
public class MyType extends DBType {
public MyType() {
super("MEUTIPO");
}
public Object getFromResultSet(ResultSet rset, int index) throws SQLException {
return '<' + rset.getString(index) + '>';
}
public Class<? extends Object> getTypeClass() {
return java.lang.String.class;
}
public void bindToStmt(PreparedStatement stmt, int index, Object value) throws SQLException {
if (value instanceof String) {
String s = (String) value;
stmt.setString(index, s);
} else {
throw new IllegalArgumentException("value is not a string!");
}
}
}
:arrow: Suporta AUTOINCREMENT do MySQL, ou seja, automaticamente recupera o ID gerado pelo MySQL e coloca no seu bean quando vc faz um INSERT. Suporta SEQUENCE do Oracle, ou seja, automatimcamente utiliza uma sequence do Oracle para gerar a chave primária do seu bean.
User u = new User(); // sem ID, o id será criado pelo banco...
u.setAge(33);
u.setName("Pela");
session.insert(u);
System.out.println("ID do objeto inserido: " + u.getId());
:arrow: Se o nome da variável do seu bean for diferente do nome do seu campo na tabela do banco de dados, basta fazer assim:
public void loadBeans() {
bean(hello.User.class, "Users")
.field("id", DBTypes.AUTOINCREMENT, "USER_ID", true)
.field("name", DBTypes.STRING, "USER_NAME")
.field("age", DBTypes.INTEGER, "USER_AGE")
}
Em muito breve:
:arrow: Suporte a tranções. Até lá vc pode simplesmente pegar a connection da session e fazer a transação com JDBC.
:arrow: Suporte a carregamento de listas de objetos, ou seja:
User u = new User();
u.setAge(33);
List users = session.loadList(u); // retorna uma lista de todos os usuários que possuem 33 anos...
“Já nasceu morto.”
