La méthode de configuration buildSessionFactory () est-elle déconseillée dans Hibernate

Lorsque j'ai mis à jour la version Hibernate de 3.6.8 à 4.0.0, j'ai reçu un avertissement concernant la méthode obsolète buildSessionFactory()dans cette ligne:

private static final SessionFactory sessionFactory =
         new Configuration().configure().buildSessionFactory();

Javadoc recommande d'utiliser une autre méthode

buildSessionFactory(ServiceRegistry serviceRegistry)

mais dans la documentation, j'ai trouvé une variante obsolète :(

Pouvez-vous m'aider avec ce petit malentendu?

Oui, il est obsolète. Remplacez votre SessionFactory par ce qui suit:

Dans Hibernate 4.0, 4.1, 4.2

private static SessionFactory sessionFactory;
private static ServiceRegistry serviceRegistry;

public static SessionFactory createSessionFactory() {
    Configuration configuration = new Configuration();
    configuration.configure();
    ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(
            configuration.getProperties()). buildServiceRegistry();
    sessionFactory = configuration.buildSessionFactory(serviceRegistry);
    return sessionFactory;
}

METTRE À JOUR:

Dans Hibernate 4.3, ServiceRegistryBuilder est obsolète . Utilisez plutôt ce qui suit.

serviceRegistry = new StandardServiceRegistryBuilder().applySettings(
            configuration.getProperties()).build();

Oui, c'est obsolète. http://docs.jboss.org/hibernate/core/4.0/javadocs/org/hibernate/cfg/Configuration.html#buildSessionFactory () vous dit spécifiquement d'utiliser l'autre méthode que vous avez trouvée à la place ( buildSessionFactory(ServiceRegistry serviceRegistry)) - alors utilisez-la.

La documentation est copiée de version en version, et n'a probablement pas encore été mise à jour (ils ne réécrivent pas le manuel avec chaque version) - alors faites confiance aux Javadocs.

Les détails de ce changement peuvent être consultés sur:

• Code source: https://github.com/hibernate/hibernate-core/commit/0b10334e403cf2b11ee60725cc5619eaafecc00b
• Billet: https://hibernate.onjira.com/browse/HHH-5991

Quelques références supplémentaires:

• http://relation.to/Bloggers/HibernateCore40IsFinal
• http://relation.to/19942.lace
• http://docs.jboss.org/hibernate/core/4.0/devguide/en-US/html/ch07.html#services-registry
• http://sourceforge.net/apps/mediawiki/hibernate/index.php?title=Category:Services

ou

public class Hbutil {

    private static SessionFactory sessionFactory;
    private static ServiceRegistry serviceRegistry;

    private static SessionFactory configureSessionFactory() throws HibernateException {
        Configuration configuration = new Configuration();
        configuration.configure();
        serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();        
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        return sessionFactory;
    }

    public static SessionFactory getSessionFactory() {
        return configureSessionFactory();

    }
}

Code vérifié pour fonctionner dans Hibernate 4.3.0. Notez que vous pouvez supprimer le paramètre de nom de fichier XML, ou bien y indiquer votre propre chemin. Ceci est similaire (mais les fautes de frappe ont été corrigées) à d'autres articles ici, mais celui-ci est correct.

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;    


Configuration configuration = new Configuration();
configuration.configure("/com/rtw/test/hiber/hibernate.cfg.xml");
ServiceRegistry  serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();        
    sessionFactory = configuration.buildSessionFactory(serviceRegistry);

C'est aussi simple que cela: les documents JBoss ne sont pas parfaitement bien entretenus à 100%. Allez avec ce que le JavaDoc dit : buildSessionFactory(ServiceRegistry serviceRegistry).

Une meilleure façon de créer un objet SessionFactory dans la dernière version hibernate 4.3.0 est la suivante:

Configuration configuration = new Configuration().configure();
StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().
applySettings(configuration.getProperties());
SessionFactory factory = configuration.buildSessionFactory(builder.build());

Il n'est pas rare de trouver des écarts entre les différentes versions de la documentation. La plupart des développeurs considèrent la documentation comme une corvée et ont tendance à la reporter.

En règle générale, si le javadoc dit une chose et que certains documents non javadoc le contredisent, il est probable que le javadoc soit plus précis. Les programmeurs sont plus susceptibles de maintenir le javadoc à jour avec les modifications apportées au code ... car la "source" du javadoc se trouve dans le même fichier que le code.

Dans le cas des @deprecatedbalises, il est pratiquement certain que le javadoc est plus précis. Les développeurs déconseillent les choses après un examen attentif ... et (de manière générale) ils ne les déprécient pas.

Si vous utilisez Hibernate 5.2 et supérieur, vous pouvez utiliser ceci:

  private static StandardServiceRegistry registry;
  private static SessionFactory sessionFactory;

  public static SessionFactory getSessionFactory() {
    if (sessionFactory == null) {
      try {
        // Creating a registry
        registry = new StandardServiceRegistryBuilder().configure("hibernate.cfg.xml").build();

        // Create the MetadataSources
        MetadataSources sources = new MetadataSources(registry);

        // Create the Metadata
        Metadata metadata = sources.getMetadataBuilder().build();

        // Create SessionFactory
        sessionFactory = metadata.getSessionFactoryBuilder().build();

      } catch (Exception e) {
        e.printStackTrace();
        if (registry != null) {
          StandardServiceRegistryBuilder.destroy(registry);
        }
      }
    }
    return sessionFactory;
  }

  //To shut down
 public static void shutdown() {
    if (registry != null) {
      StandardServiceRegistryBuilder.destroy(registry);
    }
  }

TL; DR

Oui, ça l'est. Il existe de meilleures façons d'amorcer Hibernate, comme les suivantes.

Bootstrap natif en veille prolongée

L' Configurationobjet hérité est moins puissant que l'utilisation du BootstrapServiceRegistryBuilder, introduit depuis Hibernate 4:

final BootstrapServiceRegistryBuilder bsrb = new BootstrapServiceRegistryBuilder()
    .enableAutoClose();

Integrator integrator = integrator();
if (integrator != null) {
    bsrb.applyIntegrator( integrator );
}

final BootstrapServiceRegistry bsr = bsrb.build();

final StandardServiceRegistry serviceRegistry = 
    new StandardServiceRegistryBuilder(bsr)
        .applySettings(properties())
        .build();

final MetadataSources metadataSources = new MetadataSources(serviceRegistry);

for (Class annotatedClass : entities()) {
    metadataSources.addAnnotatedClass(annotatedClass);
}

String[] packages = packages();
if (packages != null) {
    for (String annotatedPackage : packages) {
        metadataSources.addPackage(annotatedPackage);
    }
}

String[] resources = resources();
if (resources != null) {
    for (String resource : resources) {
        metadataSources.addResource(resource);
    }
}

final MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder()
    .enableNewIdentifierGeneratorSupport(true)
    .applyImplicitNamingStrategy(ImplicitNamingStrategyLegacyJpaImpl.INSTANCE);

final List<Type> additionalTypes = additionalTypes();
if (additionalTypes != null) {
    additionalTypes.stream().forEach(type -> {
        metadataBuilder.applyTypes((typeContributions, sr) -> {
            if(type instanceof BasicType) {
                typeContributions.contributeType((BasicType) type);
            } else if (type instanceof UserType ){
                typeContributions.contributeType((UserType) type);
            } else if (type instanceof CompositeUserType) {
                typeContributions.contributeType((CompositeUserType) type);
            }
        });
    });
}

additionalMetadata(metadataBuilder);

MetadataImplementor metadata = (MetadataImplementor) metadataBuilder.build();

final SessionFactoryBuilder sfb = metadata.getSessionFactoryBuilder();
Interceptor interceptor = interceptor();
if(interceptor != null) {
    sfb.applyInterceptor(interceptor);
}

SessionFactory sessionFactory = sfb.build();

Bootstrap JPA

Vous pouvez également démarrer Hibernate à l'aide de JPA:

PersistenceUnitInfo persistenceUnitInfo = persistenceUnitInfo(getClass().getSimpleName());
Map configuration = properties();

Interceptor interceptor = interceptor();
if (interceptor != null) {
    configuration.put(AvailableSettings.INTERCEPTOR, interceptor);
}

Integrator integrator = integrator();
if (integrator != null) {
    configuration.put(
        "hibernate.integrator_provider", 
        (IntegratorProvider) () -> Collections.singletonList(integrator));
}

EntityManagerFactoryBuilderImpl entityManagerFactoryBuilder = 
    new EntityManagerFactoryBuilderImpl(
        new PersistenceUnitInfoDescriptor(persistenceUnitInfo), 
        configuration
);
EntityManagerFactory entityManagerFactory = entityManagerFactoryBuilder.build();

De cette façon, vous construisez le EntityManagerFactoryau lieu d'un SessionFactory. Cependant, le SessionFactoryétend EntityManagerFactory, so the actual object that's built is aégalement SessionFactoryImpl`.

Conclusion

Ces deux méthodes d'amorçage affectent le comportement Hibernate. Lors de l'utilisation du bootstrap natif, Hibernate se comporte en mode hérité, antérieur à JPA.

Lors du démarrage à l'aide de JPA, Hibernate se comportera conformément à la spécification JPA.

Il existe plusieurs différences entre ces deux modes:

• Fonctionnement du mode de vidage automatique en ce qui concerne les requêtes SQL natives
• Comment le proxy d'entité est construit. Traditionnellement, Hibernate n'a pas touché la base de données lors de la construction d'un proxy, mais JPA nécessite de lancer un EntityNotFoundException, exigeant donc un contrôle de la base de données.
• si vous pouvez supprimer une entité non gérée

Pour plus de détails sur ces différences, consultez la JpaComplianceclasse.

public class HibernateSessionFactory {

private static final SessionFactory sessionFactory = buildSessionFactory1();

private static SessionFactory buildSessionFactory1() {
Configuration configuration = new Configuration().configure(); // configuration
                                                                // settings
                                                                // from
                                                                // hibernate.cfg.xml

StandardServiceRegistryBuilder serviceRegistryBuilder = new StandardServiceRegistryBuilder();


serviceRegistryBuilder.applySettings(configuration.getProperties());

ServiceRegistry serviceRegistry = serviceRegistryBuilder.build();

return configuration.buildSessionFactory(serviceRegistry);
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
 }

public static void shutdown() {
// Close caches and connection pools
getSessionFactory().close();
 }

public void sampleConnection () lève une exception {

     Configuration cfg = new Configuration().addResource("hibernate.cfg.xml").configure();
     StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
     SessionFactory sessionFactory = configuration.buildSessionFactory(ssrb.build());
     Session session = sessionFactory.openSession();
     logger.debug(" connection with the database created successfuly.");
}

J'ai édité la méthode créée par batbaatar ci-dessus pour qu'elle accepte l'objet Configuration en tant que paramètre:

    public static SessionFactory createSessionFactory(Configuration configuration) {
        serviceRegistry = new StandardServiceRegistryBuilder().applySettings(
                configuration.getProperties()).build();
        factory = configuration.buildSessionFactory(serviceRegistry);
        return factory;
    }

Dans la classe principale, j'ai fait:

    private static SessionFactory factory;
    private static Configuration configuration 
    ...      
    configuration = new Configuration();
    configuration.configure().addAnnotatedClass(Employee.class);
    // Other configurations, then           
    factory = createSessionFactory(configuration);

Dans Hibernate 4.2.2

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class Test {
    public static void main(String[] args) throws Exception
{
    Configuration configuration = new Configuration()
            .configure();

    ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(
            configuration.getProperties()).buildServiceRegistry();

    SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

    Session session = sessionFactory.openSession();

    Transaction transaction = session.beginTransaction();

    Users users = new Users();

    ... ...

    session.save(users);

    transaction.commit();

    session.close();

    sessionFactory.close();

    }
}

Tested on 4.2.7 release

package com.national.software.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

import com.national.software.dto.UserDetails;

public class HibernateTest {

    static SessionFactory sessionFactory;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        UserDetails user = new UserDetails();
        user.setUserId(1);
        user.setUserName("user1");

        Configuration config = new Configuration();
        config.configure();

        ServiceRegistry  serviceRegistry = (ServiceRegistry) new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        sessionFactory = config.buildSessionFactory(serviceRegistry);

        Session session = sessionFactory.openSession();
        session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();

    }

}

voici de nombreuses API déconseillées dans le framework core hibernate.

nous avons créé la fabrique de sessions comme ci-dessous:

SessionFactory sessionFactory = new Configuration (). Configure (). BuildSessionFactory ();

La méthode buildSessionFactory est obsolète de la version hibernate 4 et elle est remplacée par la nouvelle API. Si vous utilisez hibernate 4.3.0 et supérieur, votre code doit être:

1. Configuration configuration = nouvelle Configuration (). Configure ();

2. Générateur StandardServiceRegistryBuilder = nouveau StandardServiceRegistryBuilder (). ApplySettings (configuration.getProperties ());

3. SessionFactory factory = configuration.buildSessionFactory (builder.build ());

La classe ServiceRegistryBuilder est remplacée par StandardServiceRegistryBuilder à partir de 4.3.0. Il semble qu'il y aura beaucoup de changements dans la version 5.0. Il n'y a toujours pas beaucoup de clarté sur les API obsolètes et les alternatives appropriées à utiliser. Chaque version incrémentielle propose une API plus obsolète, ils sont en train de peaufiner le cadre principal de la version 5.0.

Dans hibernate 5.3.1, vous pouvez essayer ceci:

ServiceRegistry standardRegistry = 
                new StandardServiceRegistryBuilder().configure().build();

Metadata sources = new MetadataSources(standardRegistry).addAnnotatedClass(MyEntity.class).getMetadataBuilder().build();

SessionFactory sf = sources.buildSessionFactory();

Si quelqu'un ici après la mise à jour vers la 5.1 fonctionne ainsi

StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
                MetadataSources sources = new MetadataSources(registry);
                Metadata metadata = sources.getMetadataBuilder().build();
                sessionFactory = metadata.getSessionFactoryBuilder().build();

au lieu de ci-dessous en veille prolongée 4.3

 ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(
            configuration.getProperties()). buildServiceRegistry();
    sessionFactory = configuration.buildSessionFactory(serviceRegistry);

Importez simplement le package suivant,

import org.hibernate.cfg.Configuration;