Por lo tanto, spring-data
tiene algo de magia extra que ayuda con las consultas complejas. Es extraño al principio y se salta totalmente en los documentos, pero es realmente poderoso y útil.
Implica crear un Repository
personalizado y un `RepositoryImpl 'personalizado y decirle a Spring dónde encontrarlo. He aquí un ejemplo:
clase
Configuración - punto a su configuración XML todavía necesaria con la anotación que apuntan a su paquete de los repositorios (busca *Impl
clases ahora automáticamente):
@Configuration
@EnableJpaRepositories(basePackages = {"com.examples.repositories"})
@EnableTransactionManagement
public class MyConfiguration {
}
JPA-repositorios .xml: indique Spring
dónde encontrar sus repositorios. También informe a Spring
que busque repositorios personalizados con el nombre CustomImpl
archivo:
<?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
- aquí es donde usted puede poner anotado y métodos de consulta no anotadas.Nótese cómo se extiende esta interfaz repositorio de la Custom
uno:
@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
- métodos de depósito que son más complejos y no se pueden manejar con una consulta simple o una anotación:
public interface MyObjectRepositoryCustom {
List<MyObject> findByNameWithWeirdOrdering(String name);
}
MyObjectRepositoryCustomImpl
- donde realmente implemente esos métodos con un autoenlace 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);
}
}
Sorprendentemente, esto todo se junta y los métodos de ambas interfaces (y la interfaz CRUD, que implemento) todos muestran cuando haces:
myObjectRepository.
Verá:
myObjectRepository.save()
myObjectRepository.findAll()
myObjectRepository.findByName()
myObjectRepository.findByFirstNameOrMiddleName()
myObjectRepository.findByNameWithWeirdOrdering()
Se realmente funciona Y obtienes una interfaz para consultar. spring-data
realmente está listo para una gran aplicación. Y cuantas más consultas pueda ingresar en simples o anotaciones solo obtendrá mejores resultados.
Todo esto está documentado en Spring Data Jpa site.
Buena suerte.
Por lo que sé, hace poca diferencia. Ve con el que te sientas más cómodo. ¿Por qué el debate? – duffymo
Obviamente estoy más cómodo con Hibernate, pero si puedo hacer las mismas cosas y ser más productivo, prefiero adoptar los enfoques más nuevos. Sin embargo, si Hibernate es aún más poderoso y encontraré muchos menos problemas, eso es algo que me gustaría saber. – egervari
JPA es una generalización de ORM que utiliza Hibernate como una de muchas implementaciones. ¿Qué poderes atribuyes a uno sobre el otro? JPA es un estándar, pero veo poca diferencia entre los dos. En aras de una divulgación completa, diré que no me importa ninguno de los dos. Ambos generan SQL para ti. Prefiero escribirlo yo mismo. ORM no es para todos los problemas y para todos los usuarios. – duffymo