Alors, spring-data
faites 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 *Impl
automatiquement les classes maintenant):
@Configuration
@EnableJpaRepositories(basePackages = {"com.examples.repositories"})
@EnableTransactionManagement
public class MyConfiguration {
}
jpa-repositories.xml - indique Spring
où trouver vos dépôts. Dites également Spring
de rechercher des référentiels personnalisés avec le 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 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 Custom
celle:
@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-data
est 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.