@Override @SuppressWarnings("unchecked") public Object structure(Object item) { final CacheEntry entry = (CacheEntry) item; final String[] names = persister.getPropertyNames(); final Map map = new HashMap( names.length + 3, 1f ); map.put( SUBCLASS_KEY, entry.getSubclass() ); map.put( VERSION_KEY, entry.getVersion() ); for ( int i=0; i<names.length; i++ ) { map.put( names[i], entry.getDisassembledState()[i] ); } return map; } }
EntityPersister persister = (EntityPersister) sessionFactory().getClassMetadata( MyReferenceData.class ); assertFalse( persister.isMutable() ); assertTrue( persister.buildCacheEntry( null, null, null, null ).isReferenceEntry() ); assertFalse( persister.hasProxy() );
subclassPersister = factory.getEntityPersister( entry.getSubclass() ); final Object optionalObject = event.getInstanceToLoad(); entity = optionalObject == null subclassPersister, LockMode.NONE, entry.getVersion(), session );
public Object structure(Object item) { CacheEntry entry = (CacheEntry) item; String[] names = persister.getPropertyNames(); Map map = new HashMap(names.length+2); map.put( "_subclass", entry.getSubclass() ); map.put( "_version", entry.getVersion() ); map.put( "_lazyPropertiesUnfetched", entry.areLazyPropertiesUnfetched() ); for ( int i=0; i<names.length; i++ ) { map.put( names[i], entry.getDisassembledState()[i] ); } return map; } }
EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() ); Object result = optionalObject == null ? session.instantiate( subclassPersister, id ) : optionalObject; subclassPersister, LockMode.NONE, entry.areLazyPropertiesUnfetched(), entry.getVersion(), session ); Object[] values = entry.assemble( result, id, subclassPersister, session.getInterceptor(), session ); // intializes result by side-effect TypeHelper.deepCopy( values, subclassPersister, false, entry.areLazyPropertiesUnfetched() ); subclassPersister.afterInitialize( result, entry.areLazyPropertiesUnfetched(), session ); persistenceContext.initializeNonLazyCollections();
private Object findVersion(Object entry) { if (entry instanceof CacheEntry) { // with UnstructuredCacheEntry return ((CacheEntry) entry).getVersion(); } else if (entry instanceof Map) { return ((Map) entry).get(StructuredCacheEntry.VERSION_KEY); } else { return null; } }
private String findSubclass(Object entry) { // we won't find subclass for structured collections if (entry instanceof CacheEntry) { return ((CacheEntry) this.value).getSubclass(); } else if (entry instanceof Map) { Object maybeSubclass = ((Map) entry).get(StructuredCacheEntry.SUBCLASS_KEY); return maybeSubclass instanceof String ? (String) maybeSubclass : null; } else { return null; } }
Serializable[] disassembledValues = cacheEntry.getDisassembledState(); final Object[] snapshot = entry.getLoadedState(); for ( int j = 0; j < lazyPropertyNames.length; j++ ) {
public Object initializeLazyProperty(String fieldName, Object entity, SessionImplementor session) throws HibernateException { final Serializable id = session.getContextEntityIdentifier( entity ); final EntityEntry entry = session.getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new HibernateException( "entity is not associated with the session: " + id ); } if ( LOG.isTraceEnabled() ) { LOG.tracev( "Initializing lazy properties of: {0}, field access: {1}", MessageHelper.infoString( this, id, getFactory() ), fieldName ); } if ( hasCache() ) { CacheKey cacheKey = session.generateCacheKey( id, getIdentifierType(), getEntityName() ); Object ce = getCacheAccessStrategy().get( cacheKey, session.getTimestamp() ); if (ce!=null) { CacheEntry cacheEntry = (CacheEntry) getCacheEntryStructure().destructure(ce, factory); if ( !cacheEntry.areLazyPropertiesUnfetched() ) { //note early exit here: return initializeLazyPropertiesFromCache( fieldName, entity, session, entry, cacheEntry ); } } } return initializeLazyPropertiesFromDatastore( fieldName, entity, session, id, entry ); }
public Object destructure(Object item, SessionFactoryImplementor factory) { Map map = (Map) item; boolean lazyPropertiesUnfetched = ( (Boolean) map.get("_lazyPropertiesUnfetched") ).booleanValue(); String subclass = (String) map.get("_subclass"); Object version = map.get("_version"); EntityPersister subclassPersister = factory.getEntityPersister(subclass); String[] names = subclassPersister.getPropertyNames(); Serializable[] state = new Serializable[names.length]; for ( int i=0; i<names.length; i++ ) { state[i] = (Serializable) map.get( names[i] ); } return new CacheEntry(state, subclass, lazyPropertiesUnfetched, version); }
public Object structure(Object item) { CacheEntry entry = (CacheEntry) item; String[] names = persister.getPropertyNames(); Map map = new HashMap(names.length+2); map.put( "_subclass", entry.getSubclass() ); map.put( "_version", entry.getVersion() ); map.put( "_lazyPropertiesUnfetched", entry.areLazyPropertiesUnfetched() ); for ( int i=0; i<names.length; i++ ) { map.put( names[i], entry.getDisassembledState()[i] ); } return map; } }
EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() ); Object result = optionalObject == null ? session.instantiate( subclassPersister, id ) : optionalObject; subclassPersister, LockMode.NONE, entry.areLazyPropertiesUnfetched(), entry.getVersion(), session ); Object[] values = entry.assemble( result, id, subclassPersister, session.getInterceptor(), session ); // intializes result by side-effect TypeHelper.deepCopy( values, subclassPersister, false, entry.areLazyPropertiesUnfetched() ); subclassPersister.afterInitialize( result, entry.areLazyPropertiesUnfetched(), session ); persistenceContext.initializeNonLazyCollections();
protected Object getVersion(Object value) { if (value instanceof CacheEntry) { return ((CacheEntry) value).getVersion(); } else if (value instanceof VersionedEntry) { return ((VersionedEntry) value).getVersion(); } return null; }
private Class<?> getSubclassName(Object cacheEntry, boolean useStructuredCache) { String subclassName = null; if (useStructuredCache) { @SuppressWarnings("unchecked") Map structuredCacheEntry = (Map) cacheEntry; subclassName = (String) structuredCacheEntry.get(STRUCTURED_CACHE_ENTRY_SUBCLASS_KEY); } else { subclassName = ((CacheEntry) cacheEntry).getSubclass(); } Class<?> clazz; try { clazz = Class.forName(subclassName); } catch (ClassNotFoundException e) { throw new IllegalArgumentException(subclassName + " class is not found.", e); } return clazz; }
private Object initializeLazyPropertiesFromCache( final String fieldName, final Object entity, final SessionImplementor session, final EntityEntry entry, final CacheEntry cacheEntry ) { LOG.trace( "Initializing lazy properties from second-level cache" ); Object result = null; Serializable[] disassembledValues = cacheEntry.getDisassembledState(); final Object[] snapshot = entry.getLoadedState(); for ( int j = 0; j < lazyPropertyNames.length; j++ ) { final Object propValue = lazyPropertyTypes[j].assemble( disassembledValues[ lazyPropertyNumbers[j] ], session, entity ); if ( initializeLazyProperty( fieldName, entity, session, snapshot, j, propValue ) ) { result = propValue; } } LOG.trace( "Done initializing lazy properties" ); return result; }
public Object initializeLazyProperty(String fieldName, Object entity, SessionImplementor session) throws HibernateException { final Serializable id = session.getContextEntityIdentifier( entity ); final EntityEntry entry = session.getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new HibernateException( "entity is not associated with the session: " + id ); } if ( LOG.isTraceEnabled() ) { LOG.tracev( "Initializing lazy properties of: {0}, field access: {1}", MessageHelper.infoString( this, id, getFactory() ), fieldName ); } if ( hasCache() ) { CacheKey cacheKey = session.generateCacheKey( id, getIdentifierType(), getEntityName() ); Object ce = getCacheAccessStrategy().get( cacheKey, session.getTimestamp() ); if (ce!=null) { CacheEntry cacheEntry = (CacheEntry) getCacheEntryStructure().destructure(ce, factory); if ( !cacheEntry.areLazyPropertiesUnfetched() ) { //note early exit here: return initializeLazyPropertiesFromCache( fieldName, entity, session, entry, cacheEntry ); } } } return initializeLazyPropertiesFromDatastore( fieldName, entity, session, id, entry ); }
public Object destructure(Object item, SessionFactoryImplementor factory) { Map map = (Map) item; boolean lazyPropertiesUnfetched = ( (Boolean) map.get("_lazyPropertiesUnfetched") ).booleanValue(); String subclass = (String) map.get("_subclass"); Object version = map.get("_version"); EntityPersister subclassPersister = factory.getEntityPersister(subclass); String[] names = subclassPersister.getPropertyNames(); Serializable[] state = new Serializable[names.length]; for ( int i=0; i<names.length; i++ ) { state[i] = (Serializable) map.get( names[i] ); } return new CacheEntry(state, subclass, lazyPropertiesUnfetched, version); }
private static void writeDisassembled(final ObjectDataOutput out, final CacheEntry object) throws IOException { Serializable[] disassembledState = object.getDisassembledState(); out.writeInt(disassembledState.length); for (Serializable state : disassembledState) { out.writeObject(state); } out.writeUTF(object.getSubclass()); out.writeBoolean(object.areLazyPropertiesUnfetched()); out.writeObject(object.getVersion()); }
@Override @SuppressWarnings("unchecked") public Object structure(Object item) { final CacheEntry entry = (CacheEntry) item; final String[] names = descriptor.getPropertyNames(); final Map map = new HashMap( names.length + 3, 1f ); map.put( SUBCLASS_KEY, entry.getSubclass() ); map.put( VERSION_KEY, entry.getVersion() ); for ( int i=0; i<names.length; i++ ) { map.put( names[i], entry.getDisassembledState()[i] ); } return map; } }
@Override public Object merge(final String mapName, final EntryView mergingEntry, final EntryView existingEntry) { final Object existingValue = existingEntry != null ? existingEntry.getValue() : null; final Object mergingValue = mergingEntry.getValue(); if (existingValue != null && existingValue instanceof CacheEntry && mergingValue != null && mergingValue instanceof CacheEntry) { final CacheEntry existingCacheEntry = (CacheEntry) existingValue; final CacheEntry mergingCacheEntry = (CacheEntry) mergingValue; final Object mergingVersionObject = mergingCacheEntry.getVersion(); final Object existingVersionObject = existingCacheEntry.getVersion(); if (mergingVersionObject != null && existingVersionObject != null && mergingVersionObject instanceof Comparable && existingVersionObject instanceof Comparable) { final Comparable mergingVersion = (Comparable) mergingVersionObject; final Comparable existingVersion = (Comparable) existingVersionObject; if (mergingVersion.compareTo(existingVersion) > 0) { return mergingValue; } else { return existingValue; } } } return mergingValue; }