在休眠期间
Session但后来我需要通过 RPC 将一些对象（实际上是一个对象）发送到 GWT 客户端。而这个具体对象恰好是一个代理。所以我需要把它变成一个真实的物体。我在 Hibernate 中找不到像“materialize”这样的方法。
如何将某些对象从代理对象转换为知道其类和 ID 的实数对象？
目前我看到的唯一解决方案是从 Hibernate 的缓存中逐出该对象并重新加载它，但由于多种原因，它确实很糟糕。
这是我正在使用的方法。
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;
}
从 Hibernate ORM 5.2.10 开始，你可以像这样做：
Object unproxiedEntity = Hibernate.unproxy(proxy);
休眠之前5.2.10。最简单的方法是使用 Hibernate 内部 PersistenceContext 实现提供的
unproxy方法：
Object unproxiedEntity = ((SessionImplementor) session)
.getPersistenceContext()
.unproxy(proxy);
尝试使用
Hibernate.getClass(obj)我编写了以下代码，该代码从代理中清除对象（如果它们尚未初始化）
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 服务的结果上使用此函数（通过方面），它会递归地清除代理中的所有结果对象（如果它们未初始化）。
我推荐的 JPA 2 方式：
Object unproxied = entityManager.unwrap(SessionImplementor.class).getPersistenceContext().unproxy(proxy);
从 Hiebrnate 5.2.10 开始，您可以使用 Hibernate.proxy 方法将代理转换为真实实体：
MyEntity myEntity = (MyEntity) Hibernate.unproxy( proxyMyEntity );
另一个解决方法是致电
Hibernate.initialize(extractedObject.getSubojbectToUnproxy());
就在会议结束之前。
使用 Spring Data JPA 和 Hibernate，我使用
JpaRepositoryVlad 对于取消代理这些结果有正确的想法；雅尼斯提供了更多细节。除了他们的答案之外，以下是您可能正在寻找的其余内容：
以下代码提供了一种取消代理代理实体的简单方法：
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希望这有帮助！
感谢您建议的解决方案！不幸的是，它们都不适合我的情况：使用本机查询通过 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();
}
希望这会对某人有所帮助！
我找到了使用标准 Java 和 JPA API 代理类的解决方案。使用 hibernate 进行测试，但不需要 hibernate 作为依赖项，并且应该与所有 JPA 提供程序一起使用。
只有一个要求 - 需要修改父类（Address）并添加一个简单的辅助方法。
总体思路：向父类添加返回自身的辅助方法。当在代理上调用方法时，它将把调用转发到真实实例并返回该真实实例。
实现有点复杂，因为 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;
}
对于那些需要“纯”JPA 解决方案的人：如果您不介意修改实体，您可以向其添加一个简单的方法：
class MyEntity {
//...
public MyEntity unproxy() {
return this;
}
}
这是有效的，因为一旦针对代理调用此方法，代理将调用实体上的“真实”方法（返回实体而不是代理）。