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

Donc, spring-data fait de la magie supplémentaire qui aide avec des requêtes complexes. C'est étrange au début et vous l'ignorez totalement dans les docs mais c'est vraiment puissant et utile.

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

Classe de Configuration - pointez vers votre configuration xml toujours nécessaire avec une annotation pointant vers votre paquet de dépôts (il recherche automatiquement les classes *Impl maintenant):

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

JPA-dépôts.xml - dire Spring où trouver vos dépôts. Dites également à Spring de rechercher des référentiels personnalisés avec le nom de fichier CustomImpl:

<?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 des méthodes de requête annotées et non annotées. Notez comment cette interface de référentiel étend le Custom 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 - les méthodes de référentiel qui sont plus complexes et ne peuvent pas être gérées avec une simple requête ou 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 se réunit et les méthodes des deux interfaces (et de L'interface CRUD, que vous implémentez) apparaissent toutes quand vous le faites:

myObjectRepository.

, Vous verrez:

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

Ça marche vraiment. Et vous obtenez une interface pour interroger. spring-data est vraiment prêt pour une grande application. Et plus les requêtes que vous pouvez pousser dans simple ou annotation seulement le mieux vous vous trouvez.

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

Bonne chance.