TOC

API de inicialização do Hibernate 5

API de inicialização do Hibernate 5

*1. Visão geral *

Neste tutorial, exploraremos o novo mecanismo pelo qual podemos inicializar e iniciar um Hibernate SessionFactory. Vamos nos concentrar especialmente no novo processo de inicialização nativo, como foi redesenhado na versão 5.0.

Antes da versão 5.0, os aplicativos tinham que usar a classe Configuration para inicializar o SessionFactory. Essa abordagem agora está obsoleta, pois a documentação do Hibernate recomenda o uso da nova API baseada no ServiceRegistry.

Simplificando,* construir uma SessionFactory é tudo sobre ter uma implementação ServiceRegistry que contém os Services necessários ao Hibernate *durante a inicialização e o tempo de execução.

===* 2. Dependências do Maven *

Antes de começarmos a explorar o novo processo de inicialização, precisamos adicionar o arquivo hibernate-core jar ao caminho de classe do projeto. Em um projeto baseado em Maven, apenas precisamos declarar essa dependência no arquivo pom.xml:

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.4.0.Final</version>
</dependency>

Como o Hibernate é um provedor JPA, isso também incluirá a dependência da API JPA transitivamente.

Também precisamos do driver JDBC do banco de dados com o qual estamos trabalhando. Neste exemplo, usaremos um banco de dados H2 incorporado:

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.197</version>
</dependency>

Sinta-se à vontade para verificar as versões mais recentes de https://search.maven.org/search? Q = g: org.hibernate% 20AND% 20a: hibernate-core & core = gav [hibernate-core] _ e https://search. maven.org/search?q=g:com.h2database%20AND%20a:h2&core=gav[_H2 driver] no Maven Central .

===* 3. API de inicialização *

Bootstrapping refere-se ao processo de criação e inicialização de um SessionFactory.

*Para atingir esse objetivo, precisamos ter um _ServiceRegistry_ que contenha os _Services_ necessários ao Hibernate. Nesse registro, podemos criar um objeto _Metadata_ que representa o modelo de domínio do aplicativo e seu mapeamento para o banco de dados* .

Vamos explorar esses objetos principais em mais detalhes.

* 3.1 Serviço *

Antes de nos aprofundarmos no conceito ServiceRegistry, primeiro precisamos entender o que é um Service . No Hibernate 5.0, um Service é um tipo de funcionalidade representada pela interface com o mesmo nome:

org.hibernate.service.Service

Por padrão, o Hibernate fornece implementações para os Services mais comuns, e elas são suficientes na maioria dos casos. Caso contrário, podemos criar nossos próprios Services para modificar as funcionalidades originais do Hibernate ou adicionar novas.

Na próxima subseção, mostraremos como o Hibernate disponibiliza esses Services através de um contêiner leve chamado ServiceRegistry.

====* 3.2 ServiceRegistry *

A primeira etapa na criação de um SessionFactory é criar um ServiceRegistry. Isso permite manter vários Services que fornecem as funcionalidades necessárias ao Hibernate e se baseiam na funcionalidade https://www..com/java-spi [Java SPI].

Tecnicamente falando, podemos ver o ServiceRegistry como uma ferramenta leve de Injeção de Dependência, onde os beans são apenas do tipo Service.

Existem dois tipos de ServiceRegistry e eles são hierárquicos .* O primeiro é o BootstrapServiceRegistry, que não possui pai e mantém esses três serviços necessários *:

  • ClassLoaderService: _ permite ao Hibernate interagir com o _ClassLoader dos vários ambientes de tempo de execução

  • IntegratorService: _ controla a descoberta e o gerenciamento do serviço _Integrator, permitindo a integração de aplicativos de terceiros com o Hibernate

  • _StrategySelector: _ resolve implementações de vários contratos de estratégia

  • Para criar uma implementação BootstrapServiceRegistry, usamos a classe BootstrapServiceRegistryBuilder factory, * que permite personalizar esses três serviços de maneira segura:

BootstrapServiceRegistry bootstrapServiceRegistry = new BootstrapServiceRegistryBuilder()
  .applyClassLoader()
  .applyIntegrator()
  .applyStrategySelector()
  .build();

  • O segundo ServiceRegistry é o StandardServiceRegistry, que se baseia no BootstrapServiceRegistry anterior e mantém os três Services mencionados acima *. Além disso, contém vários outros Services necessários ao Hibernate, listados em StandardServiceInitiators.

Como no registro anterior, usamos o StandardServiceRegistryBuilder para criar uma instância do _StandardServiceRegistry: _

StandardServiceRegistryBuilder standardServiceRegistry =
  new StandardServiceRegistryBuilder();

Sob o capô, o StandardServiceRegistryBuilder cria e usa uma instância de BootstrapServiceRegistry. Também podemos usar um construtor sobrecarregado para passar uma instância já criada:

BootstrapServiceRegistry bootstrapServiceRegistry =
  new BootstrapServiceRegistryBuilder().build();
StandardServiceRegistryBuilder standardServiceRegistryBuilder =
  new StandardServiceRegistryBuilder(bootstrapServiceRegistry);

Usamos esse construtor para carregar uma configuração de um arquivo de recurso, como o padrão hibernate.cfg.xml e, finalmente, invocamos o método build () _ para obter uma instância do _StandardServiceRegistry.

StandardServiceRegistry standardServiceRegistry = standardServiceRegistryBuilder
  .configure()
  .build();

====* 3.3 Metadata *

Depois de configurar todos os Services necessários instanciando um ServiceRegistry do tipo BootstrapServiceRegistry ou StandardServiceRegistry, * agora precisamos fornecer a representação do modelo de domínio do aplicativo e seu mapeamento de banco de dados. *

A classe MetadataSources é responsável por isso:

MetadataSources metadataSources = new MetadataSources(standardServiceRegistry);
metadataSources.addAnnotatedClass();
metadataSources.addResource()

Em seguida, obtemos uma instância de Metadata, que usaremos na última etapa:

Metadata metadata = metadataSources.buildMetadata();

====* 3.4 SessionFactory *

A última etapa é criar o SessionFactory a partir do _Metadata criado anteriormente: _

SessionFactory sessionFactory = metadata.buildSessionFactory();

Agora podemos abrir uma Session e começar a persistir e ler entidades:

Session session = sessionFactory.openSession();
Movie movie = new Movie(100L);
session.persist(movie);
session.createQuery("FROM Movie").list();

===* 4. Conclusão*

Neste artigo, exploramos as etapas necessárias para criar uma SessionFactory. Embora o processo pareça complexo, podemos resumir em três etapas principais: primeiro criamos uma instância de StandardServiceRegistry, depois criamos um objeto Metadata e, finalmente, criamos o SessionFactory.

O código completo desses exemplos pode ser encontrado em over no Github.

Related