在Hibernate Session期间，我正在加载一些对象，其中一些由于延迟加载而被加载为代理。一切都好，我不想关闭延迟装载。
但后来我需要通过RPC将一些对象（实际上是一个对象）发送到GWT客户端。碰巧这个具体对象是代理。所以我需要把它变成一个真实的对象。我在Hibernate中找不到类似“实现”的方法。
如何知道他们的类和ID，从代理到实际的一些对象？
目前，我看到的唯一解决办法就是从Hibernate的缓存中驱逐该对象并重新加载它，但由于很多原因它真的很糟糕。
答案 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 );