Cara mengonversi proksi Hibernate ke objek entitas nyata

Selama Hibernate Session, saya memuat beberapa objek dan beberapa di antaranya dimuat sebagai proxy karena pemuatan malas. Tidak apa-apa dan saya tidak ingin mematikan pemuatan malas.

Tetapi kemudian saya perlu mengirim beberapa objek (sebenarnya satu objek) ke klien GWT melalui RPC. Dan kebetulan objek konkret ini adalah proxy. Jadi saya perlu mengubahnya menjadi objek nyata. Saya tidak dapat menemukan metode seperti "terwujud" di Hibernate.

Bagaimana saya bisa mengubah beberapa objek dari proxy menjadi real dengan mengetahui kelas dan ID mereka?

Saat ini satu-satunya solusi yang saya lihat adalah mengusir objek dari cache Hibernate dan memuatnya kembali, tetapi itu benar-benar buruk karena banyak alasan.

Inilah metode yang saya gunakan.

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

Seperti yang saya jelaskan dalam artikel ini , sejak Hibernate ORM 5.2.10 , Anda dapat melakukannya seperti ini:

Object unproxiedEntity = Hibernate.unproxy(proxy);

Sebelum Hibernasi 5.2.10 . cara paling sederhana untuk melakukannya adalah dengan menggunakan metode unproxy yang ditawarkan oleh PersistenceContextimplementasi internal Hibernate :

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

Coba gunakan Hibernate.getClass(obj)

Saya telah menulis kode berikut yang membersihkan objek dari proxy (jika belum diinisialisasi)

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

}

Saya menggunakan fungsi ini atas hasil layanan RPC saya (melalui aspek) dan membersihkan secara rekursif semua objek hasil dari proxy (jika tidak diinisialisasi).

Cara saya merekomendasikan dengan JPA 2:

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

Dengan Spring Data JPA dan Hibernate, saya menggunakan subinterfaces JpaRepositoryuntuk mencari objek milik hierarki tipe yang dipetakan menggunakan strategi "join". Sayangnya, kueri mengembalikan proxy dari tipe dasar dan bukan contoh dari tipe beton yang diharapkan. Ini mencegah saya dari casting hasil ke tipe yang benar. Seperti Anda, saya datang ke sini mencari cara yang efektif untuk mendapatkan hak saya tidak diproksikan.

Vlad memiliki ide yang tepat untuk tidak menguji hasil ini; Yannis memberikan sedikit lebih banyak detail. Menambah jawaban mereka, inilah yang mungkin Anda cari:

Kode berikut memberikan cara mudah untuk membatalkan proksi entitas proksi Anda:

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

}

Anda dapat memberikan Entitas yang tidak diproksi atau entitas yang diproksi ke unproxy metode. Jika mereka sudah tidak terbukti, mereka hanya akan dikembalikan. Jika tidak, mereka akan diproteksi dan dikembalikan.

Semoga ini membantu!

Solusi lain adalah menelepon

Hibernate.initialize(extractedObject.getSubojbectToUnproxy());

Tepat sebelum menutup sesi.

Saya menemukan solusi untuk mendeproxy kelas menggunakan Java standar dan API JPA. Diuji dengan hibernate, tetapi tidak memerlukan hibernate sebagai dependensi dan harus bekerja dengan semua penyedia JPA.

Hanya satu persyaratan - perlu untuk memodifikasi kelas induk (Alamat) dan menambahkan metode pembantu sederhana.

Gagasan umum: tambahkan metode helper ke kelas induk yang mengembalikan sendiri. ketika metode dipanggil pada proxy, itu akan meneruskan panggilan ke instance nyata dan mengembalikan instance nyata ini.

Implementasi sedikit lebih kompleks, karena hibernate mengakui bahwa kelas proksi mengembalikan dirinya sendiri dan masih mengembalikan proksi alih-alih instance nyata. Solusinya adalah untuk membungkus instance yang dikembalikan ke dalam kelas wrapper sederhana, yang memiliki tipe kelas yang berbeda dari instance sebenarnya.

Dalam kode:

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

class AddressWrapper {
    private Address wrappedAddress;
...
}

Untuk memberikan alamat proxy ke subkelas nyata, gunakan yang berikut ini:

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

Mulai dari Hiebrnate 5.2.10 Anda dapat menggunakan metode Hibernate.proxy untuk mengonversi proxy ke entitas Anda yang sebenarnya:

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

Terima kasih atas solusi yang disarankan! Sayangnya, tidak ada satupun yang berfungsi untuk kasus saya: menerima daftar objek CLOB dari database Oracle melalui JPA - Hibernate, menggunakan kueri asli.

Semua pendekatan yang diusulkan memberi saya baik ClassCastException atau hanya mengembalikan objek java Proxy (yang jauh di dalamnya berisi Clob yang diinginkan).

Jadi solusi saya adalah sebagai berikut (berdasarkan beberapa pendekatan di atas):

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

Semoga ini bisa membantu seseorang!