Notícia: Activate Persistence Framework 1.0

Lançada a versão 1.0 do Activate. Conheça mais sobre esse framework de persistência que promete simplicidade, consistência e escalabilidade utilizando-se de um paradigma de persistência baseado em Software Transactional Memory.

[url]http://activate-framework.org[/url]

O Activate é um framework LGPL de persistência em Scala. Ele é um STM (Software Transactional Memory) durável, com persistência plugável. Seu núcleo é o RadonSTM, que provê um poderoso para controle de transações em memória, analogo às transações nos bancos de dados, para fazer controle de concorrência otimista. A durabilidade das transações é plugável com bancos de dados relacionais (JDBC), prevalente (Prevayler) e não relacional (MongoDB).

Principais benefícios do Activate:

- Transações atômicas, consistentes e duráveis. Você pode usar entidades sem se preocupar com problemas de concorrência.
- Persistêcia transparente. As alterações e criações de entidades são automaticamente persistidas. Não são necessários métodos como save, merge, update, etc.
- As entidades estão sempre consistentes em memória e na camada de persistência. Por exemplo, se houver um rollback, as entidades em memória continuam consistentes.
- Refinado controle de propagação de transações, incluindo transações aninhadas.
- As entidades são carregadas de forma lazy e inicializadas quando necessário.
- As consultas são type-safe e consistentes, mesmo com os objetos novos criados na transação. Uma entidade criada na mesma transação pode ser retornada em uma consulta.
- A memória disponível é utilizada de forma eficiente através de soft references, minimizando a conversa com o banco de dados e maximizando a performance.

O framework também possui:

- Mecanismo de migrations padronizado para evolução de schema do Banco de Dados
- Validação baseada em Design by Contract
- Integração com o Play Framework

Exemplo de aplicação utilizando o Activate:

Configuração (contexto de persistência):

object postgresqlContext extends ActivateContext {
	def contextName = "postgresqlContext"
	val storage = new PooledJdbcRelationalStorage {
		val jdbcDriver = "org.postgresql.Driver"
		val user = "USER"
		val password = "PASS"
		val url = "jdbc:postgresql://127.0.0.1/postgres"
		val dialect = postgresqlDialect
	}
}

import postgresqlContext._

Através desse import, os tipos e métodos necessários para utilizar o Activate estarão no escopo.

Definindo algumas entidades:

trait Person extends Entity {
	var name: String

	// Invariantes são predicados de validação verificados automaticamente 
	// no ciclo de vida da entidade. São métodos especiais:
	def invariantNameMustNotBeEmpty = invariant {
		name != null && name.nonEmpty
	}
}
class NaturalPerson(var name: String, var motherName: String) extends Person
class LegalPerson(var name: String, var director: NaturalPerson) extends Person

Criando e alterando uma entidade:

transactional {
	val person = new NaturalPerson("John", "Marie")
	person.name = "John2"
	println(person.name)
}

Consultas:

transactional {

	// Retorna todas as pessoas
	all[Person]

	// Retorna as pessoas de acordo com os critérios
	allWhere[NaturalPerson](_.name :== "John2", _.motherName :== "Marie")

	// Consulta utilizando join (from = LegalPerson, Natural Person)
	query {
		(company: LegalPerson, director: NaturalPerson) => where(company.director :== director) select (company, director)
	}

	// Consulta utilizando propriedade aninhada
	 query {
		(company: LegalPerson) => where(company.director.name :== "John2") select (company)
	}
}