here

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á um 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:

Code:

 
 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;
 		
 	}
 }

Code:

 
 public void init(Context application) {
 
      ioc("session", MySQLBeanSession.class);
 
 public void loadBeans() {
 
       bean(hello.User.class, "Users")
 		.pk("id", DBTypes.AUTOINCREMENT)
 		.field("name", DBTypes.STRING)
 		.field("age", DBTypes.INTEGER);
 
        // ou
 
        BeanConfig bc = new BeanConfig(User.class, "Users");
        bc.addField("id", DBTypes.AUTOINCREMENT, true); // true = PK
        bc.addField("name", DBTypes.STRING);
        bc.addField("age", DBTypes.INTEGER);
        addBeanConfig(bc);
     
 	
 }

Code:

 
 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:

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.

Code:

 
 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...

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:

Code:

 
 User u = new User(1);
 
 // não estamos dando load() !!!
 
 u.setAge(44);
 
 session.update(u); // vai gerar update users set age = ? where id = ?

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:

Code:

 
 public class TimestampType extends DBType {
 	
 	public TimestampType() {
 		
 		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!");
 		}		
 	}
 }

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.

Code:

 
 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());

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:

Code:

 
 public void loadBeans() {
 
       bean(hello.User.class, "Users")
 		.pk("id", "user_id", DBTypes.AUTOINCREMENT)
 		.field("name", DBTypes.STRING, "USER_NAME")
 		.field("age", DBTypes.INTEGER, "USER_AGE")
 	
 }

Em muito breve:

Suporte a tranções. Até lá vc pode simplesmente pegar a connection da session e fazer a transação com JDBC.

Suporte a carregamento de listas de objetos, ou seja:

Code:

 
 User u = new User();
 
 u.setAge(33);
 
 List users = session.loadList(u); // retorna uma lista de todos os usuários que possuem 33 anos...

Se estou utilizando MentaBean na minha Action, a transação também funciona?

Quero fazer um sistema o mais robusto possível, por isso quero saber se também usa-se transação com Beans, ou isso é só para operações diretamente feitas com a Connection "manualmente" na Action.

Funciona sem problemas... Vc pode usar a Transaction do Mentawai ou a transaction da connection (faz na mão a transação)...

Pessoal,

Gostaria de usar o mentabean configurando os beanConfig dentro do próprio POJO. Como pode ser feito com hibernate annotations.

É possível? Como fazer?

A implementação padrão do MentaBeans que vem com o Mentawai usa JDBC puro e não hibernate. Logo não tem como fazer isso via Hibernate Annotations.

Nada impede que alguém implementa o MentaBeans com o Hibernate por trás. O MentaBeans é uma especificação (interface) assim como o JPA.

Forum Read-Only! Check the new site and forum here!