Czym różni się JPA Spring Data od Hibernate w przypadku dużych projektów?

Trudno mi się zdecydować, czy powinienem pozostać przy Hibernate przy nowym projekcie, czy też zmoczyć stopy dzięki JPA i nowej implementacji Spring Data.

Czy framework Spring Data jest przeznaczony dla dużych projektów lub małych projektów ze skromnymi wymaganiami dotyczącymi zapytań?

Chociaż z pewnością dostrzegam zalety redukcji kodu przy użyciu @Queryadnotacji, co robisz w przypadku zapytań dynamicznych? A co jeśli chcesz zaimplementować dość złożoną metodę save ()?

Dokumentacja mówi o stworzeniu niestandardowego interfejsu i implementacji, które implementuje twoje główne repozytorium, ale co, jeśli potrzebujesz dostępu do super metod w samym repozytorium crud? Repozytorium crud implementuje własne - a nie na odwrót. Wydaje się, że to dziwny projekt.

Nie jestem pewien, czy te ramy sprostają wyzwaniom związanym ze złożonymi i dużymi aplikacjami. Nigdy nie napotkałem wielu problemów z Hibernacją i rozważam trzymanie się starego, dobrego, niezawodnego, zamiast iść z Spring Data JPA.

Co powinienem zrobić? Jakie nieprzewidziane komplikacje i koszty napotkam, jeśli zdecyduję się na Spring Data JPA?

Więc spring-datarobi trochę dodatkowej magii, która pomaga przy złożonych zapytaniach. Na początku jest to dziwne i całkowicie pomijasz to w dokumentach, ale jest naprawdę potężne i przydatne.

Polega na utworzeniu niestandardowego Repositoryi niestandardowego `RepositoryImpl 'oraz wskazaniu Springowi, gdzie go znaleźć. Oto przykład:

Klasa konfiguracji - wskaż wciąż potrzebną konfigurację xml z adnotacją wskazującą na pakiet repozytoriów (teraz szuka *Implklas automatycznie):

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

jpa-repositories.xml - powiedz, Springgdzie znaleźć swoje repozytoria. Powiedz również, Springaby poszukać niestandardowych repozytoriów o CustomImplnazwie pliku:

<?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- tutaj możesz umieścić metody zapytań z adnotacjami i bez adnotacji. Zwróć uwagę, jak ten interfejs repozytorium rozszerza ten 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 - metody repozytorium, które są bardziej złożone i nie można ich obsłużyć za pomocą prostego zapytania lub adnotacji:

public interface MyObjectRepositoryCustom {

    List<MyObject> findByNameWithWeirdOrdering(String name);
}

MyObjectRepositoryCustomImpl- gdzie faktycznie zaimplementujesz te metody z 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);
    }
}

O dziwo, wszystko to łączy się ze sobą, a metody z obu interfejsów (i interfejsu CRUD, który implementujesz), pojawiają się, gdy to zrobisz:

myObjectRepository.

Zobaczysz:

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

To naprawdę działa. Otrzymujesz jeden interfejs do wykonywania zapytań.spring-datanaprawdę jest gotowy na dużą aplikację. A im więcej zapytań umieścisz w prostych lub tylko adnotacjach, tym lepiej będziesz.

Wszystko to jest udokumentowane w witrynie Spring Data Jpa .

Powodzenia.

Używałem Spring Data JPA w małych i dużych projektach z prostymi zapytaniami. Główną zaletą jest to, że nie trzeba nawet używać @Queryadnotacji. W Spring Data nic nie stoi na przeszkodzie, abyś używał go w dużych projektach, a ostatnie QueryDSLwsparcie może ci pomóc. To jest przykład użycia QueryDSL do kierowania na Hibernate.

Jeśli przewidujesz złożone zapytania i czujesz się komfortowo używając obiektów Hibernate bez JPA, myślę, że alternatywną kombinacją może być posiadanie prostych Spring Data Repositoryobok złożonych opartych na Hibernacji z określonymi metodami, których możesz potrzebować. Może być mniej kłopotliwe niż przekręcenie implementacji Hibernate w strukturę JPA Spring Data.

Spring JPA zapewni Ci dużo abstrakcji od pisania SQL, a nawet niektórych HQL za pomocą deklaracji metody zapytania. Spring JPA wyróżnia się generowaniem zapytań, ale jeśli potrzebujesz rozwiązania czysto hibernacyjnego, możesz dostosować je w razie potrzeby, ponieważ wiosenny JPA nadal jest oparty na hibernacji. Więcej informacji znajdziesz w dokumentacji http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html .