Co ja mam:
@Entity
public class MyEntity {
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
@JoinColumn(name = "myentiy_id")
private List<Address> addreses;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
@JoinColumn(name = "myentiy_id")
private List<Person> persons;
//....
}
public void handle() {
Session session = createNewSession();
MyEntity entity = (MyEntity) session.get(MyEntity.class, entityId);
proceed(session); // FLUSH, COMMIT, CLOSE session!
Utils.objectToJson(entity); //TROUBLES, because it can't convert to json lazy collections
}
Jaki problem:
Problem polega na tym, że nie mogę wyciągnąć leniwej kolekcji po zamknięciu sesji. Ale nie mogę też zamknąć sesji metodą kontynuacji .
Co za rozwiązanie (zgrubne rozwiązanie):
a) Przed zamknięciem sesji wymuś hibernację, aby wyciągnąć leniwe kolekcje
entity.getAddresses().size();
entity.getPersons().size();
....
b) Może bardziej wytwornym sposobem jest użycie @Fetch(FetchMode.SUBSELECT)
adnotacji
Pytanie:
Jaka jest najlepsza praktyka / powszechny sposób / bardziej elegancki sposób? Oznacza konwersję mojego obiektu do formatu JSON.
Możesz przechodzić przez Getters obiektu Hibernate w tej samej transakcji, aby upewnić się, że wszystkie leniwe obiekty potomne są pobierane chętnie za pomocą następującej ogólnej klasy pomocniczej:
package my.app.util; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.HashSet; import java.util.Set; import org.aspectj.org.eclipse.jdt.core.dom.Modifier; import org.hibernate.Hibernate; public class HibernateUtil { public static byte[] hibernateCollectionPackage = "org.hibernate.collection".getBytes(); public static void initializeObject( Object o, String insidePackageName ) { Set<Object> seenObjects = new HashSet<Object>(); initializeObject( o, seenObjects, insidePackageName.getBytes() ); seenObjects = null; } private static void initializeObject( Object o, Set<Object> seenObjects, byte[] insidePackageName ) { seenObjects.add( o ); Method[] methods = o.getClass().getMethods(); for ( Method method : methods ) { String methodName = method.getName(); // check Getters exclusively if ( methodName.length() < 3 || !"get".equals( methodName.substring( 0, 3 ) ) ) continue; // Getters without parameters if ( method.getParameterTypes().length > 0 ) continue; int modifiers = method.getModifiers(); // Getters that are public if ( !Modifier.isPublic( modifiers ) ) continue; // but not static if ( Modifier.isStatic( modifiers ) ) continue; try { // Check result of the Getter Object r = method.invoke( o ); if ( r == null ) continue; // prevent cycles if ( seenObjects.contains( r ) ) continue; // ignore simple types, arrays und anonymous classes if ( !isIgnoredType( r.getClass() ) && !r.getClass().isPrimitive() && !r.getClass().isArray() && !r.getClass().isAnonymousClass() ) { // ignore classes out of the given package and out of the hibernate collection // package if ( !isClassInPackage( r.getClass(), insidePackageName ) && !isClassInPackage( r.getClass(), hibernateCollectionPackage ) ) { continue; } // initialize child object Hibernate.initialize( r ); // traverse over the child object initializeObject( r, seenObjects, insidePackageName ); } } catch ( InvocationTargetException e ) { e.printStackTrace(); return; } catch ( IllegalArgumentException e ) { e.printStackTrace(); return; } catch ( IllegalAccessException e ) { e.printStackTrace(); return; } } } private static final Set<Class<?>> IGNORED_TYPES = getIgnoredTypes(); private static boolean isIgnoredType( Class<?> clazz ) { return IGNORED_TYPES.contains( clazz ); } private static Set<Class<?>> getIgnoredTypes() { Set<Class<?>> ret = new HashSet<Class<?>>(); ret.add( Boolean.class ); ret.add( Character.class ); ret.add( Byte.class ); ret.add( Short.class ); ret.add( Integer.class ); ret.add( Long.class ); ret.add( Float.class ); ret.add( Double.class ); ret.add( Void.class ); ret.add( String.class ); ret.add( Class.class ); ret.add( Package.class ); return ret; } private static Boolean isClassInPackage( Class<?> clazz, byte[] insidePackageName ) { Package p = clazz.getPackage(); if ( p == null ) return null; byte[] packageName = p.getName().getBytes(); int lenP = packageName.length; int lenI = insidePackageName.length; if ( lenP < lenI ) return false; for ( int i = 0; i < lenI; i++ ) { if ( packageName[i] != insidePackageName[i] ) return false; } return true; } }
źródło
if (object instanceof List) { for(Object item : (List<Object>) object) { initializeObject(item, seenObjects, insidePackageName); } return; } else if (object instanceof Set) { for(Object item : (Set<Object>) object) { initializeObject(item, seenObjects, insidePackageName); } return; }
Iterate list w przeciwnym razie ignorowane.Nie jest to najlepsze rozwiązanie, ale oto co mam:
1) Dodaj adnotację do metody pobierania, którą chcesz zainicjować, za pomocą tej adnotacji:
@Retention(RetentionPolicy.RUNTIME) public @interface Lazy { }
2) Użyj tej metody (można ją umieścić w klasie ogólnej lub zmienić T za pomocą klasy Object) na obiekcie po odczytaniu go z bazy danych:
public <T> void forceLoadLazyCollections(T entity) { Session session = getSession().openSession(); Transaction tx = null; try { tx = session.beginTransaction(); session.refresh(entity); if (entity == null) { throw new RuntimeException("Entity is null!"); } for (Method m : entityClass.getMethods()) { Lazy annotation = m.getAnnotation(Lazy.class); if (annotation != null) { m.setAccessible(true); logger.debug(" method.invoke(obj, arg1, arg2,...); {} field", m.getName()); try { Hibernate.initialize(m.invoke(entity)); } catch (Exception e) { logger.warn("initialization exception", e); } } } } finally { session.close(); } }
źródło
Umieść Utils.objectToJson (jednostkę); zadzwoń przed zamknięciem sesji.
Możesz też spróbować ustawić tryb pobierania i bawić się takim kodem
Session s = ... DetachedCriteria dc = DetachedCriteria.forClass(MyEntity.class).add(Expression.idEq(id)); dc.setFetchMode("innerTable", FetchMode.EAGER); Criteria c = dc.getExecutableCriteria(s); MyEntity a = (MyEntity)c.uniqueResult();
źródło
W Hibernate 4.1.6 wprowadzono nową funkcję, która rozwiązuje problemy związane z leniwymi skojarzeniami. Po włączeniu właściwości hibernate.enable_lazy_load_no_trans w hibernate.properties lub hibernate.cfg.xml nie będzie już wyjątku LazyInitializationException.
Aby uzyskać więcej, zobacz: https://stackoverflow.com/a/11913404/286588
źródło
Jeśli musisz pobrać wiele kolekcji, musisz:
Hibernate.initialize
dla pozostałych kolekcji.W twoim przypadku potrzebujesz pierwszego zapytania JPQL, takiego jak to:
MyEntity entity = session.createQuery("select e from MyEntity e join fetch e.addreses where e.id = :id", MyEntity.class) .setParameter("id", entityId) .getSingleResult(); Hibernate.initialize(entity.persons);
W ten sposób możesz osiągnąć swój cel za pomocą 2 zapytań SQL i uniknąć iloczynu kartezjańskiego.
źródło
Hibernate#initialize(entity.getSubSet())
jeśli zwróci getSubSetCollections.unmodifyableSet(this.subSet)
. Próbowałem i nie udało się. Kolekcja Underlaying to „PersistentSet”. Ta sama historia z dzwonieniem#size()
Prawdopodobnie nigdzie nie zbliża się to do najlepszej praktyki, ale zwykle dzwonię
SIZE
do kolekcji, aby załadować dzieci w tej samej transakcji, tak jak zasugerowałeś. Jest czysty, odporny na wszelkie zmiany w strukturze elementów podrzędnych i daje SQL przy niewielkim narzucie.źródło
Spróbuj użyć
Gson
biblioteki, aby przekonwertować obiekty na JsonPrzykład z serwletami:
List<Party> parties = bean.getPartiesByIncidentId(incidentId); String json = ""; try { json = new Gson().toJson(parties); } catch (Exception ex) { ex.printStackTrace(); } response.setContentType("application/json"); response.setCharacterEncoding("UTF-8"); response.getWriter().write(json);
źródło
jeśli używasz repozytorium jpa, set properties.put ("hibernate.enable_lazy_load_no_trans", true); do jpaPropertymap
źródło
Możesz użyć
@NamedEntityGraph
adnotacji do swojej encji, aby utworzyć ładowalne zapytanie, które ustawia kolekcje, które chcesz załadować do zapytania.Główną zaletą tego wyboru jest to, że hibernacja wykonuje jedno zapytanie w celu pobrania jednostki i jej kolekcji i tylko wtedy, gdy zdecydujesz się użyć tego wykresu, na przykład:
Konfiguracja jednostki
@Entity @NamedEntityGraph(name = "graph.myEntity.addresesAndPersons", attributeNodes = { @NamedAttributeNode(value = "addreses"), @NamedAttributeNode(value = "persons" })
Stosowanie
public MyEntity findNamedGraph(Object id, String namedGraph) { EntityGraph<MyEntity> graph = em.getEntityGraph(namedGraph); Map<String, Object> properties = new HashMap<>(); properties.put("javax.persistence.loadgraph", graph); return em.find(MyEntity.class, id, properties); }
źródło
Istnieje pewne nieporozumienie dotyczące leniwych kolekcji w JPA-Hibernate. Przede wszystkim wyjaśnijmy, dlaczego próba odczytania leniwej kolekcji generuje wyjątki, a nie po prostu zwraca NULL do konwersji lub dalszych przypadków użycia? .
Dzieje się tak, ponieważ pola Null w bazach danych, szczególnie w połączonych kolumnach, mają znaczenie, a nie po prostu nie prezentowany stan, jak języki programowania. kiedy próbujesz zinterpretować leniwą kolekcję na wartość Null, oznacza to (po stronie Datastore), że nie ma relacji między tymi encjami i to nieprawda. więc rzucanie wyjątków jest pewnego rodzaju najlepszą praktyką i musisz sobie z tym poradzić, a nie Hibernate.
Tak więc, jak wspomniano powyżej, polecam:
również, jak opisano w innych odpowiedziach, istnieje wiele podejść (chętne pobieranie, dołączanie itp.) lub bibliotek i metod robienia tego, ale musisz ustawić swój pogląd na to, co się dzieje, zanim zajmiesz się problemem i go rozwiązujesz.
źródło