Introdução

MentaBean é um framework ORM (Mapeamento Objeto-Relacional) para aqueles que querem trabalhar com SQL sem os clichês do JDBC. Ao contrário de outros ORMs, ele mantém a mágica ao mínimo, então você saberá sempre o que está acontecendo por baixo dos panos.

Com MentaBean você está no controle, e não o framework!

MentaBean automatiza operações CRUD sem qualquer SQL, e você não terá que aprender uma nova linguagem de query quando for necessário escrever o SQL na mão. Ao invés disso, ele te ajuda a construir suas consultas sem as partes entediantes e repetitivas do SQL e do JDBC.

Com MentaBean você não tem que aprender nenhuma outra linguagem de consulta baseada em SQL!

Para aquelas queries longas e complexas, que possuem muitas variações e condições, você pode utilizar o nosso simples QueryBuilder e descrever a sua SQL query através de uma fluent API.

Com MentaBean você pode escrever suas SQL queries de forma programática através de uma fluent API de forma que as suas variações e condições se tornam mais fáceis de manter.

Ele também faz o mapeamento de forma programática através de uma fluent API. Com MentaBean você não precisa se preocupar com XMLs ou Annotations pois as configurações são feitas usando código Java.

Com MentaBean você não tem que fazer os mapeamentos usando a "lógica" dos XMLs ou das Annotations!

Então se você gosta, entende SQL e está cansado da longa curva de aprendizado e dos inesperados comportamentos oferecidos por outros frameworks, você deveria experimentar o MentaBean.

Quick Start

Note como seu bean está intacto. Não há qualquer dependência do framework ou anotações sujando o seu código:

public class User {

	public static enum Status {
		BASIC, PREMIUM, GOLD
	}

	private long id;
	private String username;
	private Date birthdate;
	private Status status;
	private boolean deleted;
	private Date insertTime;

	public User() {
		// obrigatório
	}

	public User(long id) {
		this.id = id;
	}

	public User(String username, Date birthdate, Status status) {
		this.username = username;
		this.birthdate = birthdate;
		this.status = status;
	}

	// getters and setters
}




A tabela no banco de dados:

create table Users(
        id integer primary key auto_increment,
        username varchar(25),
        bd datetime,
        status varchar(20),
        deleted tinyint,
        insert_time timestamp
);




Agora o mapeamento em código Java utilizando API fluente. Novamente, nenhuma "magia negra" com Annotations ou XML:

		BeanManager mgr = new BeanManager();
		
		BeanConfig userCfg = new BeanConfig(User.class, "Users") // "Users" é o nome da tabela
			.pk("id", DBTypes.AUTOINCREMENT) // a chave primária!
			.field("username", DBTypes.STRING)
			.field("birthdate", "bd", DBTypes.DATE) // repare que o nome do atributo é diferente do nome da coluna
			.field("status", DBTypes.ENUMVALUE.from(Status.class)) // o status será salvo como VARCHAR no banco
			.field("deleted", DBTypes.BOOLEANINT) // 0 para falso e 1 para verdadeiro no banco
			.field("insertTime", "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP); // novamente o nome da coluna é diferente
		
		mgr.addBeanConfig(userCfg);

E você também pode fazer o mapeamento usando um proxy para facilitar a refatoração:

BeanManager mgr = new BeanManager();

User userProps = PropertiesProxy.create(User.class);

BeanConfig userCfg = new BeanConfig(User.class, "Users")
	.pk(userProps.getId(), DBTypes.AUTOINCREMENT)
	.field(userProps.getUsername(), DBTypes.STRING)
	.field(userProps.getBirthdate(), "bd", DBTypes.DATE) // note that the database column name is different
	.field(userProps.getStatus(), DBTypes.ENUMVALUE.from(Status.class))
	.field(userProps.isDeleted(), DBTypes.BOOLEANINT)
	.field(userProps.getInsertTime(), "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);

mgr.addBeanConfig(userCfg);




Operações CRUD simples sem SQL:

		Connection conn = getConnection();
		BeanSession session = new MySQLBeanSession(mgr, conn);
		
		// INSERT:
		
		User u = new User("saoj", toDate(1983, 1, 20), Status.BASIC);
		session.insert(u);
		
		System.out.println("O novo id criado para o usuário: " + u.getId());
		
		// SELECT:
		
		User loadedUser = new User(u.getId());
		if (session.load(loadedUser)) {
			System.out.println("Usuário carregado: " + loadedUser.getUsername());
		} else {
			System.err.println("Usuário não encontrado no banco de dados: " + loadedUser.getId());
		}
		
		// UPDATE:
		
		loadedUser.setUsername("soliveira");
		session.update(loadedUser); // somente o campo username é atualizado!
		
		// DELETE:
		
		session.delete(loadedUser); // bye




Construindo qualquer consulta sem as partes repetitivas do JDBC:

		Connection conn = getConnection();
		BeanSession session = new MySQLBeanSession(mgr, conn);
		
		PreparedStatement stmt = null;
		ResultSet rset = null;
		
		try {
			
			StringBuilder sql = new StringBuilder(1024);
			sql.append("select ");
			sql.append(session.buildSelect(User.class));
			sql.append(" from Users");
			sql.append(" where status = ? and deleted = ?");

			stmt = SQLUtils.prepare(conn, sql.toString(), Status.GOLD.toString(), 1); // varargs for params
			
			rset = stmt.executeQuery();
			
			List<User> users = new LinkedList<User>();
			
			while(rset.next()) {
				User u = new User();
				session.populateBean(rset, u);
				users.add(u);
			}

			System.out.println("Total de usuários carregados: " + users.size());
			
		} finally {
			SQLUtils.close(rset, stmt, conn); // vc tb pode importar staticamente SQLUtils.*
		}

NOTA: Queries simples como esta acima podem ser feitas sem o uso de SQL, através do método session.loadList(Object bean). Veja o link Loading Lists para mais detalhes.