TOC

Guia para Ebean ORM

Guia para Ebean ORM

1. Introdução

Ebean é uma ferramenta de mapeamento objeto-relacional escrita em Java.

Ele suporta as anotações JPA padrão para declarar entidades. No entanto, ele fornece uma API muito mais simples para persistir. De fato, um dos pontos que vale a pena mencionar sobre a arquitetura Ebean é que ela não possui sessões, o que significa que não gerencia totalmente as entidades.

Além disso, ele também vem com uma API de consulta e suporta a gravação de consultas no SQL nativo. O Ebean suporta todos os principais provedores de banco de dados, como Oracle, Postgres, MySql, H2 etc.

Neste tutorial, vamos dar uma olhada em como podemos criar, persistir e consultar entidades usando Ebean e H2.

2. Configuração

Para começar, vamos obter nossas dependências, bem como algumas configurações básicas.

2.1. Dependências do Maven

Antes de começar, vamos importar as dependências necessárias: 


    io.ebean
    ebean
    11.22.4


    com.h2database
    h2
    1.4.196


    ch.qos.logback
    logback-classic
    1.2.3

As versões mais recentes deEbean,H2 eLogback podem ser encontradas no Maven Central.

2.2. Aprimoramentos

O Ebean precisa modificar os beans de entidade para que eles possam ser gerenciados pelo servidor. Portanto, vamos adicionar um plugin Maven para fazer esse trabalho: 


    io.ebean
    ebean-maven-plugin
    11.11.2
    
        
            main
            process-classes
            
                debug=1
            
            
                enhance

Também precisamos fornecer ao plugin Maven os nomes dos pacotes que contêm as entidades e classes que usam transações. Para fazer isso, criamos o arquivoebean.mf: 

entity-packages: com.example.ebean.model
transactional-packages: com.example.ebean.app

2.3. Exploração madeireira

Vamos também criarlogback.xml e definir os níveis de registro em alguns pacotes paraTRACE para que possamos ver as instruções que estão sendo executadas:

3. Configurando um servidor

Precisamos criar uma instânciaEbeanServer para salvar entidades ou executar consultas em um banco de dados. Existem duas maneiras pelas quais podemos criar uma instância do servidor - usando um arquivo de propriedades padrão ou programaticamente.

3.1. Usando um arquivo de propriedades padrão

O arquivo de propriedades padrão pode ser do tipoproperties ouyaml. Ebean irá procurar por configuração em arquivos com os nomesapplication.properties,ebean.properties ouapplication.yml.

Além de fornecer os detalhes da conexão com o banco de dados, também podemos instruir o Ebean a criar e executar instruções DDL.

Agora, vamos ver um exemplo de configuração: 

ebean.db.ddl.generate=true
ebean.db.ddl.run=true

datasource.db.username=sa
datasource.db.password=
datasource.db.databaseUrl=jdbc:h2:mem:customer
datasource.db.databaseDriver=org.h2.Driver

3.2. Usando ServerConfig

A seguir, vamos ver como podemos criar o mesmo servidor programaticamente usandoEbeanServerFactoryeServerConfig: 

ServerConfig cfg = new ServerConfig();

Properties properties = new Properties();
properties.put("ebean.db.ddl.generate", "true");
properties.put("ebean.db.ddl.run", "true");
properties.put("datasource.db.username", "sa");
properties.put("datasource.db.password", "");
properties.put("datasource.db.databaseUrl","jdbc:h2:mem:app2";
properties.put("datasource.db.databaseDriver", "org.h2.Driver");

cfg.loadFromProperties(properties);
EbeanServer server = EbeanServerFactory.create(cfg);

3.3. Instância padrão do servidor

A single EbeanServer instance maps to a single database. Dependendo de nossos requisitos, poderíamos criar mais de uma instânciaEbeanServer também.

Se apenas uma instância do servidor for criada, por padrão, ela será registrada como a instância do servidor padrão. Ele pode ser acessado em qualquer lugar no aplicativo usando um método estático na classeEbean: 

EbeanServer server = Ebean.getDefaultServer();

Caso haja vários bancos de dados, é possível registrar uma das instâncias do servidor como padrão: 

cfg.setDefaultServer(true);

4. Criando entidades

O Ebean fornece suporte total para anotações JPA, bem como recursos adicionais usando suas próprias anotações.

Vamos criar algumas entidades usando anotações JPA e Ebean. Primeiro, vamos criar umBaseModel que contém propriedades que são comuns entre as entidades: 

@MappedSuperclass
public abstract class BaseModel {

    @Id
    protected long id;

    @Version
    protected long version;

    @WhenCreated
    protected Instant createdOn;

    @WhenModified
    protected Instant modifiedOn;

    // getters and setters
}

Aqui, usamos a anotaçãoMappedSuperClass JPA para definir as anotaçõesBaseModel. E as duas anotações Ebeanio.ebean.annotation.WhenCreatedeio.ebean.annotation.WhenModified para fins de auditoria.

A seguir, criaremos duas entidadesCustomer eAddress que estendemBaseModel: 

@Entity
public class Customer extends BaseModel {

    public Customer(String name, Address address) {
        super();
        this.name = name;
        this.address = address;
    }

    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    Address address;

    // getters and setters
}
@Entity
public class Address extends BaseModel{

    public Address(String addressLine1, String addressLine2, String city) {
        super();
        this.addressLine1 = addressLine1;
        this.addressLine2 = addressLine2;
        this.city = city;
    }

    private String addressLine1;
    private String addressLine2;
    private String city;

    // getters and setters
}

EmCustomer, definimos um mapeamento um para um comAddresse adicionamos o tipo de cascata de conjunto aALL para que as entidades filhas também sejam atualizadas junto com as entidades pais.

5. Operações básicas de CRUD

Anteriormente, vimos como configurarEbeanServere criamos duas entidades. Agora,let’s carry out some basic CRUD operations neles.

Estaremos usando a instância do servidor padrão para persistir e acessar os dados. A classeEbean também fornece métodos estáticos para persistir e acessar dados que fornecem proxy da solicitação para a instância do servidor padrão: 

Address a1 = new Address("5, Wide Street", null, "New York");
Customer c1 = new Customer("John Wide", a1);

EbeanServer server = Ebean.getDefaultServer();
server.save(c1);

c1.setName("Jane Wide");
c1.setAddress(null);
server.save(c1);

Customer foundC1 = Ebean.find(Customer.class, c1.getId());

Ebean.delete(foundC1);

Primeiro, criamos um objetoCustomer e usamos a instância do servidor padrão para salvá-lo usandosave().

Em seguida, estamos atualizando os detalhes do cliente e salvando-os novamente usandosave().

Finalmente, estamos usando o método estáticofind() emEbean para buscar o cliente e excluí-lo usandodelete().

6. Consultas

Query APIs can also be used to create an object graph with filters and predicates. Podemos usarEbean ouEbeanServer para criar e executar consultas.

Vejamos uma consulta que encontra umCustomer por cidade e retorna um sobjetoCustomereAddress com apenas alguns campos preenchidos: 

Customer customer = Ebean.find(Customer.class)
            .select("name")
            .fetch("address", "city")
            .where()
            .eq("city", "San Jose")
            .findOne();

Aqui, comfind(), indicamos que queremos encontrar entidades do tipoCustomer. Em seguida, usamosselect() para especificar as propriedades a serem preenchidas no objetoCustomer.

Mais tarde, usamosfetch() para indicar que queremos buscar o objetoAddress pertencente aCustomere queremos buscar o campocity.

Por fim, adicionamos um predicado e restringimos o tamanho do resultado a 1.

7. Transações

Ebean executa cada instrução ou consulta em uma nova transação por padrão.

Embora isso possa não ser um problema em alguns casos. Há momentos em que podemos querer executar um conjunto de instruções em uma única transação.

Nesses casos, se anotarmos o método comio.ebean.annotations.Transactional, all, todas as instruções dentro do método serão executadas na mesma transação: 

@Transactional
public static void insertAndDeleteInsideTransaction() {
    Customer c1 = getCustomer();
    EbeanServer server = Ebean.getDefaultServer();
    server.save(c1);
    Customer foundC1 = server.find(Customer.class, c1.getId());
    server.delete(foundC1);
}

8. Construindo o Projeto

Por fim, podemos construir o projeto Maven usando o comando: 

compile io.ebean:ebean-maven-plugin:enhance

9. Conclusão

Para resumir, vimos os recursos básicos do Ebean que podem ser usados ​​para persistir e consultar entidades em um banco de dados relacional.

Finalmente, este código está disponível emGithub.

Related