将Hibernate代理转换为真实体对象

Question

在Hibernate会话期间，我加载了一些对象，其中一些由于延迟加载而被加载为代理。没关系，我不想关闭延迟加载。

但后来我需要通过RPC发送一些对象（实际上是一个对象）到GWT客户端。碰巧这个具体的对象是一个代理。所以我需要把它变成真正的对象。我在Hibernate中找不到像“物化”这样的方法。

如何将代理中的一些对象转换为知道他们的类和ID的实数？

目前我看到的唯一解决方案是从Hibernate的缓存中逐出该对象并重新加载它，但由于很多原因它确实很糟糕。

Answer 1

这是我使用的一种方法。

public static <T> T initializeAndUnproxy(T entity) { 
    if (entity == null) { 
     throw new 
      NullPointerException("Entity passed for initialization is null"); 
    } 

    Hibernate.initialize(entity); 
    if (entity instanceof HibernateProxy) { 
     entity = (T) ((HibernateProxy) entity).getHibernateLazyInitializer() 
       .getImplementation(); 
    } 
    return entity; 
} 

Answer 2

尝试使用Hibernate.getClass(obj)

Answer 3

我找到了一个解决方案使用标准的Java和JPA API来deproxy类。使用hibernate进行测试，但不要求hibernate作为依赖项，并且应该与所有JPA提供程序一起使用。

Onle的一个要求 - 它需要修改父类（地址）并添加一个简单的辅助方法。

一般想法：将辅助方法添加到返回自身的父类。当调用代理的方法时，它会将调用转发给实例并返回此实例。

实现有点复杂，因为hibernate认识到代理类返回自身并且仍然返回代理而不是实际实例。解决方法是将返回的实例包装到一个简单的包装类中，该包装类与实际实例具有不同的类类型。

在代码：

class Address { 
    public AddressWrapper getWrappedSelf() { 
     return new AddressWrapper(this); 
    } 
... 
} 

class AddressWrapper { 
    private Address wrappedAddress; 
... 
} 

要投地址代理实子类，使用下列内容：

Address address = dao.getSomeAddress(...); 
Address deproxiedAddress = address.getWrappedSelf().getWrappedAddress(); 
if (deproxiedAddress instanceof WorkAddress) { 
WorkAddress workAddress = (WorkAddress)deproxiedAddress; 
} 

Answer 4

我已经写了下面这从代理清除对象（如果它们尚未初始化代码）

public class PersistenceUtils { 

    private static void cleanFromProxies(Object value, List<Object> handledObjects) { 
     if ((value != null) && (!isProxy(value)) && !containsTotallyEqual(handledObjects, value)) { 
      handledObjects.add(value); 
      if (value instanceof Iterable) { 
       for (Object item : (Iterable<?>) value) { 
        cleanFromProxies(item, handledObjects); 
       } 
      } else if (value.getClass().isArray()) { 
       for (Object item : (Object[]) value) { 
        cleanFromProxies(item, handledObjects); 
       } 
      } 
      BeanInfo beanInfo = null; 
      try { 
       beanInfo = Introspector.getBeanInfo(value.getClass()); 
      } catch (IntrospectionException e) { 
       // LOGGER.warn(e.getMessage(), e); 
      } 
      if (beanInfo != null) { 
       for (PropertyDescriptor property : beanInfo.getPropertyDescriptors()) { 
        try { 
         if ((property.getWriteMethod() != null) && (property.getReadMethod() != null)) { 
          Object fieldValue = property.getReadMethod().invoke(value); 
          if (isProxy(fieldValue)) { 
           fieldValue = unproxyObject(fieldValue); 
           property.getWriteMethod().invoke(value, fieldValue); 
          } 
          cleanFromProxies(fieldValue, handledObjects); 
         } 
        } catch (Exception e) { 
         // LOGGER.warn(e.getMessage(), e); 
        } 
       } 
      } 
     } 
    } 

    public static <T> T cleanFromProxies(T value) { 
     T result = unproxyObject(value); 
     cleanFromProxies(result, new ArrayList<Object>()); 
     return result; 
    } 

    private static boolean containsTotallyEqual(Collection<?> collection, Object value) { 
     if (CollectionUtils.isEmpty(collection)) { 
      return false; 
     } 
     for (Object object : collection) { 
      if (object == value) { 
       return true; 
      } 
     } 
     return false; 
    } 

    public static boolean isProxy(Object value) { 
     if (value == null) { 
      return false; 
     } 
     if ((value instanceof HibernateProxy) || (value instanceof PersistentCollection)) { 
      return true; 
     } 
     return false; 
    } 

    private static Object unproxyHibernateProxy(HibernateProxy hibernateProxy) { 
     Object result = hibernateProxy.writeReplace(); 
     if (!(result instanceof SerializableProxy)) { 
      return result; 
     } 
     return null; 
    } 

    @SuppressWarnings("unchecked") 
    private static <T> T unproxyObject(T object) { 
     if (isProxy(object)) { 
      if (object instanceof PersistentCollection) { 
       PersistentCollection persistentCollection = (PersistentCollection) object; 
       return (T) unproxyPersistentCollection(persistentCollection); 
      } else if (object instanceof HibernateProxy) { 
       HibernateProxy hibernateProxy = (HibernateProxy) object; 
       return (T) unproxyHibernateProxy(hibernateProxy); 
      } else { 
       return null; 
      } 
     } 
     return object; 
    } 

    private static Object unproxyPersistentCollection(PersistentCollection persistentCollection) { 
     if (persistentCollection instanceof PersistentSet) { 
      return unproxyPersistentSet((Map<?, ?>) persistentCollection.getStoredSnapshot()); 
     } 
     return persistentCollection.getStoredSnapshot(); 
    } 

    private static <T> Set<T> unproxyPersistentSet(Map<T, ?> persistenceSet) { 
     return new LinkedHashSet<T>(persistenceSet.keySet()); 
    } 

} 

我使用此函数而不是RPC服务的结果（通过方面），它使用c递归地从代理缓存所有结果对象（如果它们未被初始化）。

Answer 5

正如我在this article解释，因为Hibernate ORM 5.2.10，你能做到这likee：

Object unproxiedEntity = Hibernate.unproxy(proxy); 

之前休眠5.2.10。要做到这一点里边反最简单的方法是使用由Hibernate内部PersistenceContext实施提供了unproxy方法：

Object unproxiedEntity = ((SessionImplementor) session) 
         .getPersistenceContext() 
         .unproxy(proxy); 

Answer 6

我建议使用JPA 2的方式：

Object unproxied = entityManager.unwrap(SessionImplementor.class).getPersistenceContext().unproxy(proxy); 

Answer 7

的另一种解决方法是调用

Hibernate.initialize(extractedObject.getSubojbectToUnproxy()); 

就在会议结束前。

Answer 8

谢谢您的建议解决方案！不幸的是，它们中没有一个适用于我的情况：使用本机查询从JPA-Hibernate接收Oracle数据库中的CLOB对象列表。

所有提出的方法都给了我一个ClassCastException或刚刚返回的java代理对象（它深深地包含了所需的Clob）。

所以我的解决办法是下面的（基于以上几个方法）：

Query sqlQuery = manager.createNativeQuery(queryStr); 
List resultList = sqlQuery.getResultList(); 
for (Object resultProxy : resultList) { 
    String unproxiedClob = unproxyClob(resultProxy); 
    if (unproxiedClob != null) { 
     resultCollection.add(unproxiedClob); 
    } 
} 

private String unproxyClob(Object proxy) { 
    try { 
     BeanInfo beanInfo = Introspector.getBeanInfo(proxy.getClass()); 
     for (PropertyDescriptor property : beanInfo.getPropertyDescriptors()) { 
      Method readMethod = property.getReadMethod(); 
      if (readMethod.getName().contains("getWrappedClob")) { 
       Object result = readMethod.invoke(proxy); 
       return clobToString((Clob) result); 
      } 
     } 
    } 
    catch (InvocationTargetException | IntrospectionException | IllegalAccessException | SQLException | IOException e) { 
     LOG.error("Unable to unproxy CLOB value.", e); 
    } 
    return null; 
} 

private String clobToString(Clob data) throws SQLException, IOException { 
    StringBuilder sb = new StringBuilder(); 
    Reader reader = data.getCharacterStream(); 
    BufferedReader br = new BufferedReader(reader); 

    String line; 
    while(null != (line = br.readLine())) { 
     sb.append(line); 
    } 
    br.close(); 

    return sb.toString(); 
} 

希望这会帮助别人！

Answer 9

使用Spring Data JPA和Hibernate，我使用JpaRepository的子接口来查找属于使用“join”策略映射的类型层次结构的对象。不幸的是，查询返回的是基类型的代理，而不是预期的具体类型的实例。这阻止了我将结果转换为正确的类型。和你一样，我来到这里寻找一种有效的方式来让我的物品变得没有问题。

弗拉德有正确的想法来取消这些结果; Yannis提供了更多细节。添加到自己的答案，这里的其他人呢，你可能会寻找：

下面的代码提供了一个简单的方法来unproxy您的代理机构：

import org.hibernate.engine.spi.PersistenceContext; 
import org.hibernate.engine.spi.SessionImplementor; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.data.jpa.repository.JpaContext; 
import org.springframework.stereotype.Component; 

@Component 
public final class JpaHibernateUtil { 

    private static JpaContext jpaContext; 

    @Autowired 
    JpaHibernateUtil(JpaContext jpaContext) { 
     JpaHibernateUtil.jpaContext = jpaContext; 
    } 

    public static <Type> Type unproxy(Type proxied, Class<Type> type) { 
     PersistenceContext persistenceContext = 
      jpaContext 
      .getEntityManagerByManagedType(type) 
      .unwrap(SessionImplementor.class) 
      .getPersistenceContext(); 
     Type unproxied = (Type) persistenceContext.unproxyAndReassociate(proxied); 
     return unproxied; 
    } 

} 

您可以通过其中非代理的entites或代理实体方法unproxy。如果他们已经没有任何问题，他们只会被退回。否则，他们会得不到答复并返回。

希望这会有所帮助！

Answer 10

从Hiebrnate 5.2.10开始，你可以使用Hibernate.proxy方法把代理转换到你的真正的实体：

MyEntity myEntity = (MyEntity) Hibernate.unproxy(proxyMyEntity);