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

Me está costando decidir si debería seguir con Hibernate para un nuevo proyecto o mojarme 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?

Si bien ciertamente veo la ventaja en la reducción de código mediante el uso de la @Queryanotación, ¿qué haces para las consultas dinámicas? ¿Qué pasa cuando quieres implementar un método save () que es bastante complejo?

La documentación dice hacer una interfaz personalizada e implementación que implemente su repositorio principal, pero ¿qué sucede si necesita acceder a algún método súper en el repositorio de Crud? El repositorio crud implementa el personalizado, no al revés. Parece un diseño extraño.

No estoy seguro de si este marco responderá a los desafíos de las aplicaciones complejas y grandes. Nunca he tenido muchos problemas con Hibernate, y estoy considerando seguir con el viejo y confiable en lugar de ir con Spring Data JPA.

¿Qué tengo que hacer? ¿Qué complicaciones y costos imprevistos enfrentaré si uso Spring Data JPA?

Entonces, spring-data hace un poco de magia extra que ayuda con consultas complejas. Al principio es extraño y lo omites por completo en los documentos, pero es realmente poderoso y útil.

Implica crear una costumbre Repository 'RepositoryImpl' y personalizado y decirle a Spring dónde encontrarlo. Aquí hay un ejemplo:

Clase de configuración: señale su configuración xml aún necesaria con una anotación que apunte a su paquete de repositorios (ahora busca *Implclases automáticamente):

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

jpa-repositories.xml: indica Springdónde encontrar tus repositorios. También indique Springque busque repositorios personalizados con el CustomImplnombre del 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 puede colocar métodos de consulta anotados y no anotados. Tenga en cuenta cómo esta interfaz de repositorio extiende el Customuno:

@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 repositorio que son más complejos y no se pueden manejar con una simple consulta o anotación:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl- donde realmente implementa esos métodos con un autoconectado 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) se muestran cuando lo hace:

myObjectRepository.

Ya verás:

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

Realmente funciona. Y obtienes una interfaz para realizar consultas.spring-dataRealmente está listo para una gran aplicación. Y cuantas más consultas pueda enviar a simples o anotaciones, mejor será.

Todo esto está documentado en el sitio Spring Data Jpa .

Buena suerte.

He usado Spring Data JPA en proyectos pequeños y grandes con demandas de consultas simples. La principal ventaja es que ni siquiera tiene que usar la @Queryanotación. No hay nada en Spring Data que le impida usarlo en proyectos grandes y el QueryDSLsoporte reciente 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 los Spring Data simples Repositoryjunto 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 JPA de Spring Data.

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