Como o JPA do Spring Data difere do Hibernate para grandes projetos?

Estou com dificuldades para decidir se devo continuar com o Hibernate para um novo projeto ou se me molhar com o JPA e a nova implementação do Spring Data.

A estrutura do Spring Data é destinada a projetos grandes ou pequenos com requisitos de consulta modestos?

Embora eu certamente veja a vantagem na redução de código usando a @Queryanotação, o que você faz para consultas dinâmicas? E quando você deseja implementar um método save () bastante complexo?

A documentação diz para criar uma interface e implementação personalizadas que seu repositório principal implementa, mas e se você precisar acessar algum super método no próprio repositório crud? O repositório crud implementa o personalizado - e não o contrário. Parece um design estranho.

Estou muito incerto se essa estrutura atenderá aos desafios de aplicativos complexos e grandes. Eu nunca tive muitos problemas com o Hibernate, e estou pensando em manter a boa e velha confiabilidade, em vez de ir com o Spring Data JPA.

O que devo fazer? Quais complicações e custos imprevistos vou encontrar se eu for com o Spring Data JPA?

Então, spring-datafaz alguma mágica extra que ajuda com consultas complexas. É estranho no começo e você pula totalmente nos documentos, mas é realmente poderoso e útil.

Envolve criar um personalizado Repositorye um personalizado `RepositoryImpl 'e dizer ao Spring onde encontrá-lo. Aqui está um exemplo:

Classe de configuração - aponte para sua configuração xml ainda necessária com a anotação apontando para o pacote de repositórios (ele procura *Implclasses automaticamente agora):

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

jpa-repositories.xml - diga Springonde encontrar seus repositórios. Diga também Springpara procurar repositórios personalizados com o CustomImplnome do arquivo:

<?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- é aqui que você pode colocar métodos de consulta anotados e não anotados. Observe como essa interface do repositório estende a seguinte 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 repositório que são mais complexos e não podem ser manipulados com uma consulta simples ou uma anotação:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl- onde você realmente implementa esses métodos com uma conexão automática 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);
    }
}

Surpreendentemente, tudo isso se junta e os métodos de ambas as interfaces (e a interface CRUD que você implementa) aparecem quando você faz:

myObjectRepository.

Você verá:

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

Realmente funciona. E você obtém uma interface para consulta. spring-dataestá realmente pronto para uma aplicação grande. E quanto mais consultas você puder inserir em anotações simples ou apenas o melhor para você.

Tudo isso está documentado no site Spring Data Jpa .

Boa sorte.

Eu usei o Spring Data JPA em projetos pequenos e grandes com demandas de consulta simples. A principal vantagem é não ter que usar a @Queryanotação. Não há nada no Spring Data que o impeça de usá-lo em grandes projetos, e o QueryDSLsuporte recente pode ajudá-lo. Este é um exemplo do uso do QueryDSL para direcionar o Hibernate.

Se você prevê consultas complexas e se sente à vontade usando objetos do Hibernate sem JPA, acho que uma combinação alternativa poderia ser ter os dados simples do Spring Repositoryao lado dos complexos baseados no Hibernate com os métodos específicos que você pode precisar. Pode ser menos complicado que distorcer uma implementação do Hibernate na estrutura JPA do Spring Data.

O Spring JPA fornecerá muita abstração ao escrever SQL e até alguns HQL usando a declaração do método de consulta. O Spring JPA brilha com sua geração de consulta, mas quando você deseja uma solução puramente hibernada, pode personalizar conforme necessário, pois o Spring JPA ainda é baseado no hibernação. Verifique os documentos http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html para obter mais informações.