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

时间:2010-02-07 09:31:43

标签: java hibernate jpa proxy lazy-loading

在Hibernate Session期间,我正在加载一些对象,其中一些由于延迟加载而被加载为代理。一切都好,我不想关闭延迟装载。

但后来我需要通过RPC将一些对象(实际上是一个对象)发送到GWT客户端。碰巧这个具体对象是代理。所以我需要把它变成一个真实的对象。我在Hibernate中找不到类似“实现”的方法。

如何知道他们的类和ID,从代理到实际的一些对象?

目前,我看到的唯一解决办法就是从Hibernate的缓存中驱逐该对象并重新加载它,但由于很多原因它真的很糟糕。

10 个答案:

答案 0 :(得分:220)

这是我正在使用的方法。

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

答案 1 :(得分:20)

正如我在this article中解释的那样,自从Hibernate ORM 5.2.10开始,你可以这样做:

Object unproxiedEntity = Hibernate.unproxy( proxy );

在Hibernate 5.2.10之前。最简单的方法是使用Hibernate内部PersistenceContext实现提供的unproxy方法:

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

答案 2 :(得分:13)

我编写了以下代码来清除代理中的对象(如果它们尚未初始化)

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服务的结果(通过方面),并且它从代理中递归清除所有结果对象(如果它们未初始化)。

答案 3 :(得分:12)

尝试使用Hibernate.getClass(obj)

答案 4 :(得分:8)

我推荐使用JPA 2的方式:

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

答案 5 :(得分:2)

使用Spring Data JPA和Hibernate,我使用JpaRepository的子接口来查找属于使用“join”策略映射的类型层次结构的对象。不幸的是,查询返回了基类型的代理,而不是预期的具体类型的实例。这使我无法将结果转换为正确的类型。和你一样,我来到这里寻找一种有效的方法来让我的行为不受影响。

弗拉德有正确的想法让这些结果失败; Yannis提供了更多细节。添加他们的答案,这是你可能正在寻找的其余部分:

以下代码提供了一种简单的方法来取消代理实体的代理:

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

}

您可以将未经代理的实体或代理实体传递给unproxy方法。如果他们已经没有代理,他们只会被退回。否则,它们将被取消并返回。

希望这有帮助!

答案 6 :(得分:1)

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

Onle one requirements - 修改父类(Address)和添加简单帮助方法所必需的。

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

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

在代码中:

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

class AddressWrapper {
    private Address wrappedAddress;
...
}

要将Address代理转换为实际子类,请使用以下命令:

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

答案 7 :(得分:1)

另一种解决方法是调用

Hibernate.initialize(extractedObject.getSubojbectToUnproxy());

在结束会议之前。

答案 8 :(得分:0)

感谢您提供的建议解决方案!不幸的是,它们都不适用于我的情况:使用本机查询通过JPA - Hibernate从Oracle数据库接收CLOB对象列表。

所有提议的方法都给了我一个ClassCastException或者只返回了java Proxy对象(它内部包含了所需的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();
}

希望这会对某人有所帮助!

答案 9 :(得分:0)

Hiebrnate 5.2.10开始,您可以使用Hibernate.proxy方法将代理转换为真实实体:

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