So rufen Sie FetchType.LAZY-Zuordnungen mit JPA und Hibernate in einem Spring Controller ab

Ich habe eine Personenklasse:

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;

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

Mit einer Viele-zu-Viele-Beziehung ist das faul.

In meinem Controller habe ich

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

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

Und das PersonRepository ist genau dieser Code, der gemäß dieser Anleitung geschrieben wurde

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

In diesem Controller benötige ich jedoch tatsächlich die Lazy-Daten. Wie kann ich das Laden auslösen?

Der Versuch, darauf zuzugreifen, schlägt mit fehl

Fehler beim Initialisieren einer Rollensammlung: no.dusken.momus.model.Person.roles, Proxy konnte nicht initialisiert werden - keine Sitzung

oder andere Ausnahmen, je nachdem, was ich versuche.

Meine XML-Beschreibung , falls benötigt.

Vielen Dank.

Sie müssen die Lazy-Sammlung explizit aufrufen, um sie zu initialisieren (es ist üblich, zu .size()diesem Zweck aufzurufen ). Im Ruhezustand gibt es eine dedizierte Methode für this ( Hibernate.initialize()), aber JPA hat kein Äquivalent dazu. Natürlich müssen Sie sicherstellen, dass der Aufruf erfolgt, wenn die Sitzung noch verfügbar ist. Kommentieren Sie daher Ihre Controller-Methode mit @Transactional. Eine Alternative besteht darin, eine Zwischen-Service-Schicht zwischen dem Controller und dem Repository zu erstellen, die Methoden verfügbar machen kann, die verzögerte Sammlungen initialisieren.

Aktualisieren:

Bitte beachten Sie, dass die obige Lösung einfach ist, jedoch zu zwei unterschiedlichen Abfragen an die Datenbank führt (eine für den Benutzer, eine andere für seine Rollen). Wenn Sie eine bessere Leistung erzielen möchten, fügen Sie Ihrer Spring Data JPA-Repository-Schnittstelle die folgende Methode hinzu:

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);

}

Diese Methode verwendet die Fetch-Join- Klausel von JPQL, um die Rollenzuordnung in einem einzigen Roundtrip in die Datenbank eifrig zu laden, und verringert daher die Leistungseinbußen, die durch die beiden unterschiedlichen Abfragen in der obigen Lösung entstehen.

Obwohl dies ein alter Beitrag ist, sollten Sie @NamedEntityGraph (Javax Persistence) und @EntityGraph (Spring Data JPA) verwenden. Die Kombination funktioniert.

Beispiel

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

und dann das Feder-Repo wie unten

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

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

}

Sie haben einige Möglichkeiten

• Schreiben Sie eine Methode in das Repository, die eine initialisierte Entität zurückgibt, wie von RJ vorgeschlagen.

Mehr Arbeit, beste Leistung.

• Verwenden Sie OpenEntityManagerInViewFilter, um die Sitzung für die gesamte Anforderung offen zu halten.

Weniger Arbeit, normalerweise in Webumgebungen akzeptabel.

• Verwenden Sie eine Hilfsklasse, um Entitäten bei Bedarf zu initialisieren.

Weniger Arbeit, nützlich, wenn OEMIV nicht verfügbar ist, z. B. in einer Swing-Anwendung, aber auch bei Repository-Implementierungen, um eine Entität auf einmal zu initialisieren.

Für die letzte Option habe ich eine Utility-Klasse geschrieben, JpaUtils , um Entitäten bei einem Deph zu initialisieren.

Beispielsweise:

@Transactional
public class RepositoryHelper {

    @PersistenceContext
    private EntityManager em;

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

Es kann nur während einer Transaktion träge geladen werden. Sie können also auf die Sammlung in Ihrem Repository zugreifen, die eine Transaktion enthält - oder was ich normalerweise mache, ist ein get with associationoder den Fetch-Modus auf eifrig setzen.

Ich denke, Sie benötigen OpenSessionInViewFilter , um Ihre Sitzung während des Renderns der Ansicht offen zu halten (dies ist jedoch keine allzu gute Vorgehensweise).

Federdaten JpaRepository

Die Federdaten JpaRepositorydefinieren die folgenden zwei Methoden:

• getOne, der einen Entitäts-Proxy zurückgibt, der zum Festlegen einer @ManyToOneoder einer @OneToOneübergeordneten Zuordnung geeignet ist, wenn eine untergeordnete Entität beibehalten wird .
• findById, der die Entität POJO zurückgibt, nachdem die SELECT-Anweisung ausgeführt wurde, die die Entität aus der zugehörigen Tabelle lädt

In Ihrem Fall haben Sie jedoch weder angerufen getOnenoch findById:

Person person = personRepository.findOne(1L);

Ich gehe also davon aus, dass die findOneMethode eine Methode ist, die Sie in der definiert haben PersonRepository. Die findOneMethode ist in Ihrem Fall jedoch nicht sehr nützlich. Da Sie die Sammlung Personzusammen mit is rolesabrufen müssen, ist es besser, findOneWithRolesstattdessen eine Methode zu verwenden.

Benutzerdefinierte Spring Data-Methoden

Sie können eine PersonRepositoryCustomSchnittstelle wie folgt definieren:

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

}

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

Und definieren Sie die Implementierung folgendermaßen:

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();
    }
}

Das ist es!

Sie können dasselbe wie folgt tun:

@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;
}

Verwenden Sie einfach faqQuestions.getFaqAnswers (). Size () in Ihrem Controller, und Sie erhalten die Größe, wenn Sie die Liste träge initialisiert haben, ohne die Liste selbst abzurufen.