Jak pobrać skojarzenia FetchType.LAZY z JPA i Hibernate w kontrolerze Spring

Mam klasę Person:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    @ManyToMany(fetch = FetchType.LAZY)
    private List<Role> roles;
    // etc
}

Z leniwą relacją wiele do wielu.

W moim kontrolerze mam

@Controller
@RequestMapping("/person")
public class PersonController {
    @Autowired
    PersonRepository personRepository;

    @RequestMapping("/get")
    public @ResponseBody Person getPerson() {
        Person person = personRepository.findOne(1L);
        return person;
    }
}

A PersonRepository to tylko ten kod, napisany zgodnie z tym przewodnikiem

public interface PersonRepository extends JpaRepository<Person, Long> {
}

Jednak w tym kontrolerze faktycznie potrzebuję leniwych danych. Jak mogę uruchomić jego ładowanie?

Próba uzyskania do niego dostępu zakończy się niepowodzeniem

nie udało się leniwie zainicjować kolekcji ról: no.dusken.momus.model.Person.roles, nie można zainicjować serwera proxy - brak sesji

lub inne wyjątki w zależności od tego, co próbuję.

Mój opis XML , w razie potrzeby.

Dzięki.

Będziesz musiał wykonać jawne wywołanie leniwej kolekcji, aby ją zainicjować (powszechną praktyką jest wywoływanie .size()w tym celu). W Hibernate istnieje metoda this ( Hibernate.initialize()), ale JPA nie ma jej odpowiednika. Oczywiście będziesz musiał upewnić się, że wywołanie zostało wykonane, gdy sesja jest nadal dostępna, więc dodaj adnotację do metody kontrolera z @Transactional. Alternatywą jest utworzenie pośredniej warstwy usług między kontrolerem a repozytorium, która mogłaby ujawnić metody inicjujące leniwe kolekcje.

Aktualizacja:

Należy pamiętać, że powyższe rozwiązanie jest łatwe, ale skutkuje dwoma różnymi zapytaniami do bazy danych (jedno dla użytkownika, drugie dla jego ról). Jeśli chcesz osiągnąć lepszą wydajność, dodaj następującą metodę do interfejsu repozytorium Spring Data JPA:

public interface PersonRepository extends JpaRepository<Person, Long> {

    @Query("SELECT p FROM Person p JOIN FETCH p.roles WHERE p.id = (:id)")
    public Person findByIdAndFetchRolesEagerly(@Param("id") Long id);

}

Ta metoda wykorzysta klauzulę fetch join w JPQL, aby z niecierpliwością załadować skojarzenie ról w jednej rundzie do bazy danych, a zatem zmniejszy spadek wydajności poniesiony przez dwa różne zapytania w powyższym rozwiązaniu.

Chociaż jest to stary post, rozważ użycie @NamedEntityGraph (Persistence Javax) i @EntityGraph (Spring Data JPA). Połączenie działa.

Przykład

@Entity
@Table(name = "Employee", schema = "dbo", catalog = "ARCHO")
@NamedEntityGraph(name = "employeeAuthorities",
            attributeNodes = @NamedAttributeNode("employeeGroups"))
public class EmployeeEntity implements Serializable, UserDetails {
// your props
}

a następnie repozytorium wiosenne, jak poniżej

@RepositoryRestResource(collectionResourceRel = "Employee", path = "Employee")
public interface IEmployeeRepository extends PagingAndSortingRepository<EmployeeEntity, String>           {

    @EntityGraph(value = "employeeAuthorities", type = EntityGraphType.LOAD)
    EmployeeEntity getByUsername(String userName);

}

Masz kilka opcji

• Napisz metodę w repozytorium, która zwraca zainicjowaną jednostkę zgodnie z sugestią RJ.

Więcej pracy, najlepsza wydajność.

• Użyj OpenEntityManagerInViewFilter, aby sesja była otwarta dla całego żądania.

Mniej pracy, zwykle akceptowalne w środowiskach internetowych.

• Użyj klasy pomocniczej, aby zainicjować jednostki, gdy jest to wymagane.

Mniej pracy, przydatne, gdy OEMIV nie jest dostępny, na przykład w aplikacji Swing, ale może być również przydatny w implementacjach repozytorium, aby zainicjować dowolną jednostkę za jednym razem.

W przypadku ostatniej opcji napisałem klasę narzędziową JpaUtils do inicjowania jednostek w pewnym deph.

Na przykład:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

    public void intialize(Object entity, int depth) {
        JpaUtils.initialize(em, entity, depth);
    }
}

może być ładowany leniwie tylko podczas transakcji. Możesz więc uzyskać dostęp do kolekcji w swoim repozytorium, w którym znajduje się transakcja - lub to , co zwykle robię, to get with associationlub ustawiam fetchmode na Eager.

Myślę, że potrzebujesz OpenSessionInViewFilter, aby sesja była otwarta podczas renderowania widoku (ale nie jest to zbyt dobra praktyka).

Dane wiosenne JpaRepository

Spring Data JpaRepositorydefiniuje następujące dwie metody:

• getOne, która zwraca serwer proxy jednostki, który jest odpowiedni do ustawienia powiązania @ManyToOnelub @OneToOnenadrzędnego podczas utrwalania jednostki podrzędnej .
• findById, która zwraca jednostkę POJO po uruchomieniu instrukcji SELECT, która ładuje jednostkę z powiązanej tabeli

Jednak w Twoim przypadku nie zadzwoniłeś ani getOneteż findById:

Person person = personRepository.findOne(1L);

Więc zakładam, że findOnemetoda jest metodą zdefiniowaną w PersonRepository. Jednak findOnemetoda nie jest zbyt przydatna w twoim przypadku. Ponieważ musisz pobrać kolekcję Personwraz z is roles, lepiej findOneWithRoleszamiast tego użyć metody.

Niestandardowe metody Spring Data

Możesz zdefiniować PersonRepositoryCustominterfejs w następujący sposób:

public interface PersonRepository
    extends JpaRepository<Person, Long>, PersonRepositoryCustom { 

}

public interface PersonRepositoryCustom {
    Person findOneWithRoles(Long id);
}

I zdefiniuj jego implementację w ten sposób:

public class PersonRepositoryImpl implements PersonRepositoryCustom {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public Person findOneWithRoles(Long id)() {
        return entityManager.createQuery("""
            select p 
            from Person p
            left join fetch p.roles
            where p.id = :id 
            """, Person.class)
        .setParameter("id", id)
        .getSingleResult();
    }
}

Otóż ​​to!

Możesz zrobić to samo w ten sposób:

@Override
public FaqQuestions getFaqQuestionById(Long questionId) {
    session = sessionFactory.openSession();
    tx = session.beginTransaction();
    FaqQuestions faqQuestions = null;
    try {
        faqQuestions = (FaqQuestions) session.get(FaqQuestions.class,
                questionId);
        Hibernate.initialize(faqQuestions.getFaqAnswers());

        tx.commit();
        faqQuestions.getFaqAnswers().size();
    } finally {
        session.close();
    }
    return faqQuestions;
}

Po prostu użyj faqQuestions.getFaqAnswers (). Size () nin swojego kontrolera, a otrzymasz rozmiar, jeśli leniwie zainicjujesz listę, bez pobierania samej listy.