java - ejemplo - ¿En qué se diferencia Spring Data JPA de Hibernate para proyectos grandes?

spring jpa maven

Question

Estoy teniendo dificultades para decidir si debo quedarme con Hibernate para un nuevo proyecto, o me mojo los pies con JPA y la nueva implementación de Spring Data.

¿El marco de Spring Data está destinado a proyectos grandes o pequeños con requisitos de consulta modestos?

Aunque ciertamente veo la ventaja en la reducción de código al usar la anotación @Query , ¿qué haces para las consultas dinámicas? ¿Qué pasa cuando quieres implementar un método save () que es bastante complejo?

La documentación dice que debe crearse una interfaz e implementación personalizadas que implemente su repositorio principal, pero ¿qué pasa si necesita acceder a cualquier supermétodo en el repositorio de crud en sí mismo? El repositorio crud implementa el personalizado, no al revés. Parece un diseño extraño.

No estoy seguro de si este marco satisfará los desafíos de las aplicaciones complejas y grandes. Nunca me he encontrado con muchos problemas con Hibernate, y estoy considerando seguir con la buena fiabilidad en lugar de recurrir a Spring Data JPA.

¿Que debería hacer? ¿Qué complicaciones y costos imprevistos encontraré si uso Spring Data JPA?

Answer 1

Entonces, spring-data hace algo de magia adicional que ayuda con 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. Aquí hay un ejemplo:

Clase de configuración: apunte a su configuración xml aún necesaria con una anotación apuntando a su paquete de repositorios (ahora busca *Impl clases *Impl automáticamente):

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

jpa-repositories.xml: dile a Spring dónde encontrar tus repositorios. CustomImpl también a Spring que busque repositorios personalizados con el nombre de archivo 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 : aquí es donde puede poner métodos de consulta anotados y no anotados. Observe cómo esta interfaz de repositorio extiende la Custom :

@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 pueden manejarse con una consulta simple o una anotación:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl - donde implementa realmente esos métodos con un EntityManager 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, todo esto se combina y los métodos de ambas interfaces (y la interfaz CRUD, que implementa) aparecen cuando lo hace:

myObjectRepository.

Ya verás:

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

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 el sitio Spring Data Jpa .

Buena suerte.

Answer 2

Spring JPA le proporcionará una gran cantidad de abstracción al escribir SQL e incluso algunos HQL utilizando la declaración del método de consulta. Spring JPA brilla con su generación de consultas, pero cuando quiere una solución puramente hibernada, puede personalizarla según sea necesario ya que el JPA de primavera todavía está basado en la hibernación. Consulte los documentos http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html para obtener más información.

Answer 3

Utilicé Spring Data JPA en proyectos pequeños y grandes con demandas simples de consulta. La principal ventaja es no tener que usar la anotación @Query . No hay nada en Spring Data que le impida usarlo en proyectos grandes y el soporte reciente de QueryDSL podría ayudarlo. Este es un ejemplo del uso de QueryDSL para apuntar a Hibernate.

Si prevé consultas complejas y se siente cómodo utilizando objetos de Hibernate sin JPA, creo que una combinación alternativa podría ser tener el Repository simple de Spring Data junto a los complejos basados ​​en Hibernate con los métodos específicos que pueda necesitar. Puede ser menos engorroso que torcer una implementación de Hibernate en la estructura de Spring Data JPA.