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.
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
}
}
Importando do contexto:
Através desse import, os tipos e métodos necessários para utilizar o Activate estarão no escopo.
Definindo algumas entidades:
[code]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[/code]
Criando e alterando uma entidade:
transactional {
val person = new NaturalPerson("John", "Marie")
person.name = "John2"
println(person.name)
}
Consultas:
[code]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)
}
}[/code]
