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

Question

Je vais avoir un moment difficile de décider si je devais m'en tenir avec mise en veille prolongée pour un nouveau projet, ou d'obtenir mon pieds humides avec JPA et la nouvelle source de Données de mise en œuvre.

C'est le Printemps des Données-cadre destiné à de grands projets ou de petits projets avec de modestes requête exigences?

Alors que je vois bien l'avantage dans le code de réduction à l'aide de la @Query d'annotation, que faites-vous pour les requêtes dynamiques? Quel sujet lorsque vous souhaitez mettre en œuvre une méthode save() c'est assez complexe?

La documentation dit de faire une interface Personnalisée et la mise en œuvre de votre dépôt principal met en œuvre, mais si vous avez besoin d'accéder à n'importe quel super méthodes crud référentiel lui-même? Le crud référentiel met en œuvre la coutume d'un non l'inverse. Il semble comme une étrange conception.

Je suis très incertain de savoir si ce cadre permettra de relever les défis complexes et de grandes applications. Je n'ai jamais couru dans de nombreux problèmes de mise en veille prolongée, et j'ai l'intention de coller avec la bonne vieille fiable plutôt que d'aller avec Spring Data JPA.

Que dois-je faire? Ce que d'éventuelles complications et les coûts vais-je rencontrer si je vais avec Spring Data JPA?

Answer 1

Donc, spring-data fait un peu de magie en plus qui aide avec des requêtes complexes. C'est étrange au premier abord et vous totalement l'ignorer dans les docs, mais il est vraiment puissant et utile.

Elle implique la création d'une coutume Repository et personnalisé `RepositoryImpl " et disant Printemps où le trouver. Voici un exemple:

La Configuration de la classe point à votre besoin de configuration xml avec l'annotation pointant vers votre référentiels de paquet (il regarde *Impl classes automatiquement maintenant):

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

jpa-repositories.xml - dites - Spring où trouver vos dépôts. Aussi dites - Spring chercher personnalisé des référentiels avec l' CustomImpl nom 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 là que vous pouvez mettre commentés et annotés méthodes de requête. Notez comment ce référentiel interface étend l' Custom d'un:

@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 - référentiel des méthodes qui sont plus complexes et ne peuvent pas être traitées avec une simple requête ou une annotation:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl - où vous avez réellement mettre en œuvre ces méthodes avec une autocâblés 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, ce tout vient ensemble et les méthodes des deux interfaces (et l'interface CRUD vous mettre en œuvre) tous affichent lorsque vous effectuez:

myObjectRepository.

Vous verrez:

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

Il fonctionne vraiment. Et vous obtenez une interface d'interrogation. spring-data est vraiment prêt pour une grande application. Et le plus de requêtes que vous pouvez pousser en simple ou annotation uniquement le mieux vous vous trouvez.

Tout cela est documenté à l' Spring Data Jpa site.

Bonne chance.

Answer 2

J'ai utilisé Spring Data JPA dans de petits et de grands projets avec une requête simple demande. Le principal avantage est de ne même pas avoir à utiliser l' @Query d'annotation. Il n'y a rien dans le Printemps de Données qui vous empêche de l'utiliser dans les grands projets et les récentes QueryDSLde soutien peut vous aider. Ceci est un exemple de l'utilisation de QueryDSL pour cible de mise en veille prolongée.

Si vous prévoyez des requêtes complexes et vous vous sentez à l'aise d'utiliser Hibernate objets sans JPA je pense que d'une combinaison alternative pourrait être d'avoir le Printemps simple de Données Repositorys complexe Hibernate base avec les méthodes spécifiques que vous pourriez avoir besoin. Il pourrait être moins lourde que la torsion Hibernate mise en œuvre dans Spring Data JPA structure.

Answer 3

J'ai passé un certain temps à évaluer le projet de données de printemps et recommanderais cette solution par rapport au projet de données de printemps

Actuellement, je travaille sur un projet à grande échelle mais je pense que cela fonctionnera également pour de petits projets.