En quoi Spring Data JPA diffère-t-il d'Hibernate pour les grands projets?

J'ai du mal à décider si je devrais rester avec Hibernate pour un nouveau projet, ou me mouiller les pieds avec JPA et la nouvelle implémentation de Spring Data.

Le framework Spring Data est-il destiné aux grands projets ou aux petits projets avec des exigences de requête modestes?

Bien que je vois certainement l'avantage de la réduction du code en utilisant l' @Queryannotation, que faites-vous pour les requêtes dynamiques? Qu'en est-il lorsque vous souhaitez implémenter une méthode save () assez complexe?

La documentation dit de créer une interface personnalisée et une implémentation que votre référentiel principal implémente, mais que faire si vous avez besoin d'accéder à des super méthodes sur le référentiel crud lui-même? Le référentiel crud implémente le référentiel personnalisé - et non l'inverse. Cela semble être un design étrange.

Je ne sais pas si ce cadre répondra aux défis des applications complexes et volumineuses. Je n'ai jamais rencontré beaucoup de problèmes avec Hibernate, et j'envisage de m'en tenir au bon vieux fiable plutôt que d'utiliser Spring Data JPA.

Que devrais-je faire? Quelles complications et quels coûts imprévus vais-je rencontrer si j'utilise Spring Data JPA?

Alors, spring-datafaites un peu de magie supplémentaire qui aide avec les requêtes complexes. C'est étrange au début et vous l'ignorez totalement dans la documentation mais c'est vraiment puissant et utile.

Cela implique de créer un Repository`RepositoryImpl ' personnalisé et personnalisé et d'indiquer à Spring où le trouver. Voici un exemple:

Classe de configuration - pointez sur votre configuration xml encore nécessaire avec une annotation pointant vers votre package de référentiels (il recherche *Implautomatiquement les classes maintenant):

@Configuration
@EnableJpaRepositories(basePackages = {"com.examples.repositories"})
@EnableTransactionManagement
public class MyConfiguration {
}

jpa-repositories.xml - indique Springoù trouver vos dépôts. Dites également Springde rechercher des référentiels personnalisés avec le CustomImplnom de fichier:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

<jpa:repositories base-package="com.example.repositories" repository-impl-postfix="CustomImpl" />

</beans>

MyObjectRepository- c'est ici que vous pouvez placer des méthodes de requête annotées et non annotées. Notez comment cette interface de référentiel étend Customcelle:

@Transactional
public interface MyObjectRepository extends JpaRepository<MyObject, Integer>, MyObjectRepositoryCustom {

    List<MyObject> findByName(String name);

    @Query("select * from my_object where name = ?0 or middle_name = ?0")
    List<MyObject> findByFirstNameOrMiddleName(String name);
}

MyObjectRepositoryCustom - des méthodes de référentiel plus complexes et ne pouvant être manipulées avec une simple requête ou une annotation:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl- où vous implémentez réellement ces méthodes avec un autowired EntityManager:

public class MyObjectRepositoryCustomImpl implements MyObjectRepositoryCustom {

    @Autowired
    private EntityManager entityManager;

    public final List<MyObject> findByNameWithWeirdOrdering(String name) {
        Query query = query(where("name").is(name));
        query.sort().on("whatever", Order.ASC);
        return entityManager.find(query, MyObject.class);
    }
}

Étonnamment, tout cela est réuni et les méthodes des deux interfaces (et de l'interface CRUD, que vous implémentez) apparaissent toutes lorsque vous le faites:

myObjectRepository.

Tu verras:

myObjectRepository.save()
myObjectRepository.findAll()
myObjectRepository.findByName()
myObjectRepository.findByFirstNameOrMiddleName()
myObjectRepository.findByNameWithWeirdOrdering()

Cela fonctionne vraiment. Et vous obtenez une interface pour les requêtes. spring-dataest vraiment prêt pour une grande application. Et plus vous pouvez intégrer de requêtes simples ou d'annotations, mieux vous vous portez.

Tout cela est documenté sur le site Spring Data Jpa .

Bonne chance.

J'ai utilisé Spring Data JPA dans des projets petits et grands avec des requêtes simples. Le principal avantage est de ne même pas avoir à utiliser l' @Queryannotation. Il n'y a rien dans Spring Data qui vous empêche de l'utiliser dans de grands projets et le QueryDSLsupport récent pourrait vous aider. Voici un exemple d'utilisation de QueryDSL pour cibler Hibernate.

Si vous prévoyez des requêtes complexes et que vous vous sentez à l'aise d'utiliser des objets Hibernate sans JPA, je pense qu'une combinaison alternative pourrait être d'avoir les simples Spring Data à Repositorycôté de celles basées sur Hibernate complexes avec les méthodes spécifiques dont vous pourriez avoir besoin. Cela peut être moins fastidieux que de transformer une implémentation Hibernate en une structure Spring Data JPA.

Spring JPA vous fournira beaucoup d'abstraction de l'écriture de SQL et même de HQL en utilisant la déclaration de méthode de requête. Spring JPA brille avec sa génération de requêtes, mais lorsque vous souhaitez une solution purement de mise en veille prolongée, vous pouvez la personnaliser selon vos besoins, car Spring JPA est toujours basé sur la mise en veille prolongée. Consultez la documentation http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html pour plus d'informations.