聊聊hibernate的session-level repeatable reads

最新推荐文章于 2022-04-19 09:09:16 发布
最新推荐文章于 2022-04-19 09:09:16 发布
阅读量214 收藏
点赞数
文章标签： java 数据库
原文链接：https://juejin.im/post/5cc06842e51d456e2f77f130
版权

序

本文主要研究一下hibernate的session-level repeatable reads

实例

doInTransaction(session -> {
    Product product = new Product();
    product.setId(1L);
    product.setQuantity(7L);
    session.persist(product);
});
doInTransaction(session -> {
    final Product product = (Product) session.get(Product.class, 1L);
    try {
        executeSync(() -> doInTransaction(_session -> {
            Product otherThreadProduct = (Product) _session.get(Product.class, 1L);
            assertNotSame(product, otherThreadProduct);
            otherThreadProduct.setQuantity(6L);
        }));
        Product reloadedProduct = (Product) session.createQuery("from Product").uniqueResult();
        assertEquals(7L, reloadedProduct.getQuantity());
        assertEquals(6L, 
            ((Number) session
            .createSQLQuery("select quantity from product where id = :id")
            .setParameter("id", product.getId())
            .uniqueResult())
            .longValue()
        );
    } catch (Exception e) {
        fail(e.getMessage());
    }
});
复制代码
  • 这段代码展示了hibernate的session-level repeatable reads功能，这里reloadedProduct查询返回的是session中id为1的entity的缓存(但是也向db发出了sql语句，只是没有使用其返回的resultSet的值)，而project操作查询则直接根据jdbc查询返回的结果返回

实例代码来自How does Hibernate guarantee application-level repeatable reads

write-behind

write-behind cache

  • write-behind cache是cache策略的一种，其主要思路就是更新数据是首先更新cache，之后cache在批量持久化到存储中，比如批量更新到数据，这样做的好处是可以合并数据的多次操作减少IO

transactional write-behind cache

  • hibernate为了减少数据库连接加锁的时间，设计了transactional write-behind的策略，其persistence context充当transactional write-behind cache的角色，对entity的改动都先作用到内存，等到一定时机在flush到数据库；具体体现在Session类中

To reduce lock contention in the database, the physical database transaction needs to be as short as possible.

Long-running database transactions prevent your application from scaling to a highly-concurrent load. Do not hold a database transaction open during end-user-level work, but open it after the end-user-level work is finished. This concept is referred to as transactional write-behind.

The persistence context acts as a transactional write-behind cache, queuing any entity state change. Like any write-behind cache, changes are first applied in-memory and synchronized with the database during the flush time.

Session

hibernate的Session对jdbc的connection进行了包装，它主要是维护了level one cache，即"repeatable read" persistence context；具体体现在Loader的getRow方法中

Behind the scenes, the Hibernate Session wraps a JDBC java.sql.Connection and acts as a factory for org.hibernate.Transaction instances. It maintains a generally "repeatable read" persistence context (first level cache) of the application domain model.

The Hibernate Session acts as a transaction-scoped cache providing repeatable reads for lookup by identifier and queries that result in loading entities.

Loader.getRow

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/loader/Loader.java

	/**
	 * Resolve any IDs for currently loaded objects, duplications within the
	 * <tt>ResultSet</tt>, etc. Instantiate empty objects to be initialized from the
	 * <tt>ResultSet</tt>. Return an array of objects (a row of results) and an
	 * array of booleans (by side-effect) that determine whether the corresponding
	 * object should be initialized.
	 */
	private Object[] getRow(
			final ResultSet rs,
			final Loadable[] persisters,
			final EntityKey[] keys,
			final Object optionalObject,
			final EntityKey optionalObjectKey,
			final LockMode[] lockModes,
			final List hydratedObjects,
			final SharedSessionContractImplementor session) throws HibernateException, SQLException {
		final int cols = persisters.length;
		final EntityAliases[] descriptors = getEntityAliases();

		if ( LOG.isDebugEnabled() ) {
			LOG.debugf( "Result row: %s", StringHelper.toString( keys ) );
		}

		final Object[] rowResults = new Object[cols];

		for ( int i = 0; i < cols; i++ ) {

			Object object = null;
			EntityKey key = keys[i];

			if ( keys[i] == null ) {
				//do nothing
			}
			else {
				//If the object is already loaded, return the loaded one
				object = session.getEntityUsingInterceptor( key );
				if ( object != null ) {
					//its already loaded so don't need to hydrate it
					instanceAlreadyLoaded(
							rs,
							i,
							persisters[i],
							key,
							object,
							lockModes[i],
							session
					);
				}
				else {
					object = instanceNotYetLoaded(
							rs,
							i,
							persisters[i],
							descriptors[i].getRowIdAlias(),
							key,
							lockModes[i],
							optionalObjectKey,
							optionalObject,
							hydratedObjects,
							session
					);
				}
			}

			rowResults[i] = object;

		}

		return rowResults;
	}
复制代码
  • 在key不为null的情况下，该方法会设置object的值；这里首先通过session.getEntityUsingInterceptor方法根据key从session中寻找该entity，如果不为null，则执行instanceAlreadyLoaded，否则执行instanceNotYetLoaded去设置object

SessionImpl.getEntityUsingInterceptor

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/internal/SessionImpl.java

public final class SessionImpl
		extends AbstractSessionImpl
		implements EventSource, SessionImplementor, HibernateEntityManagerImplementor {

		//......

	@Override
	public Object getEntityUsingInterceptor(EntityKey key) throws HibernateException {
		checkOpenOrWaitingForAutoClose();
		// todo : should this get moved to PersistentContext?
		// logically, is PersistentContext the "thing" to which an interceptor gets attached?
		final Object result = persistenceContext.getEntity( key );
		if ( result == null ) {
			final Object newObject = getInterceptor().getEntity( key.getEntityName(), key.getIdentifier() );
			if ( newObject != null ) {
				lock( newObject, LockMode.NONE );
			}
			return newObject;
		}
		else {
			return result;
		}
	}

		//......
}
复制代码
  • getEntityUsingInterceptor方法首先从persistenceContext获取entity，如果获取不到再调用getInterceptor().getEntity获取；如果没有额外设置默认是EmptyInterceptor，其getEntity方法返回null

StatefulPersistenceContext

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/engine/internal/StatefulPersistenceContext.java

public class StatefulPersistenceContext implements PersistenceContext {
	//......

	// Loaded entity instances, by EntityKey
	private Map<EntityKey, Object> entitiesByKey;

	@Override
	public Object getEntity(EntityKey key) {
		return entitiesByKey.get( key );
	}

	@Override
	public void addEntity(EntityKey key, Object entity) {
		entitiesByKey.put( key, entity );
		if( batchFetchQueue != null ) {
			getBatchFetchQueue().removeBatchLoadableEntityKey(key);
		}
	}

	@Override
	public Object removeEntity(EntityKey key) {
		final Object entity = entitiesByKey.remove( key );
		final Iterator itr = entitiesByUniqueKey.values().iterator();
		while ( itr.hasNext() ) {
			if ( itr.next() == entity ) {
				itr.remove();
			}
		}
		// Clear all parent cache
		parentsByChild.clear();
		entitySnapshotsByKey.remove( key );
		nullifiableEntityKeys.remove( key );
		if( batchFetchQueue != null ) {
			getBatchFetchQueue().removeBatchLoadableEntityKey(key);
			getBatchFetchQueue().removeSubselect(key);
		}
		return entity;
	}

	@Override
	public void replaceDelayedEntityIdentityInsertKeys(EntityKey oldKey, Serializable generatedId) {
		final Object entity = entitiesByKey.remove( oldKey );
		final EntityEntry oldEntry = entityEntryContext.removeEntityEntry( entity );
		parentsByChild.clear();

		final EntityKey newKey = session.generateEntityKey( generatedId, oldEntry.getPersister() );
		addEntity( newKey, entity );
		addEntry(
				entity,
				oldEntry.getStatus(),
				oldEntry.getLoadedState(),
				oldEntry.getRowId(),
				generatedId,
				oldEntry.getVersion(),
				oldEntry.getLockMode(),
				oldEntry.isExistsInDatabase(),
				oldEntry.getPersister(),
				oldEntry.isBeingReplicated()
		);
	}

	//......
}
复制代码
  • StatefulPersistenceContext维护了一个entitiesByKey的map，getEntity方法直接根据EntityKey从该map取数据；它同时也提供了addEntity、removeEntity、replaceDelayedEntityIdentityInsertKeys等方法来修改map

instanceAlreadyLoaded

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/loader/Loader.java

public abstract class Loader {

	//......

	/**
	 * The entity instance is already in the session cache
	 */
	private void instanceAlreadyLoaded(
			final ResultSet rs,
			final int i,
			final Loadable persister,
			final EntityKey key,
			final Object object,
			final LockMode requestedLockMode,
			final SharedSessionContractImplementor session)
			throws HibernateException, SQLException {
		if ( !persister.isInstance( object ) ) {
			throw new WrongClassException(
					"loaded object was of wrong class " + object.getClass(),
					key.getIdentifier(),
					persister.getEntityName()
			);
		}

		if ( LockMode.NONE != requestedLockMode && upgradeLocks() ) { //no point doing this if NONE was requested
			final EntityEntry entry = session.getPersistenceContext().getEntry( object );
			if ( entry.getLockMode().lessThan( requestedLockMode ) ) {
				//we only check the version when _upgrading_ lock modes
				if ( persister.isVersioned() ) {
					checkVersion( i, persister, key.getIdentifier(), object, rs, session );
				}
				//we need to upgrade the lock mode to the mode requested
				entry.setLockMode( requestedLockMode );
			}
		}
	}

	//......
}
复制代码
  • instanceAlreadyLoaded方法主要是校验类型是否正确，同时根据lockMode信息判断是否要升级lock mode等

instanceNotYetLoaded

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/loader/Loader.java

public abstract class Loader {
	//......

	/**
	 * The entity instance is not in the session cache
	 */
	private Object instanceNotYetLoaded(
			final ResultSet rs,
			final int i,
			final Loadable persister,
			final String rowIdAlias,
			final EntityKey key,
			final LockMode lockMode,
			final EntityKey optionalObjectKey,
			final Object optionalObject,
			final List hydratedObjects,
			final SharedSessionContractImplementor session)
			throws HibernateException, SQLException {
		final String instanceClass = getInstanceClass(
				rs,
				i,
				persister,
				key.getIdentifier(),
				session
		);

		// see if the entity defines reference caching, and if so use the cached reference (if one).
		if ( session.getCacheMode().isGetEnabled() && persister.canUseReferenceCacheEntries() ) {
			final EntityDataAccess cache = persister.getCacheAccessStrategy();
			final Object ck = cache.generateCacheKey(
					key.getIdentifier(),
					persister,
					session.getFactory(),
					session.getTenantIdentifier()
					);
			final Object cachedEntry = CacheHelper.fromSharedCache( session, ck, cache );
			if ( cachedEntry != null ) {
				CacheEntry entry = (CacheEntry) persister.getCacheEntryStructure().destructure( cachedEntry, factory );
				return ( (ReferenceCacheEntryImpl) entry ).getReference();
			}
		}

		final Object object;
		if ( optionalObjectKey != null && key.equals( optionalObjectKey ) ) {
			//its the given optional object
			object = optionalObject;
		}
		else {
			// instantiate a new instance
			object = session.instantiate( instanceClass, key.getIdentifier() );
		}

		//need to hydrate it.

		// grab its state from the ResultSet and keep it in the Session
		// (but don't yet initialize the object itself)
		// note that we acquire LockMode.READ even if it was not requested
		LockMode acquiredLockMode = lockMode == LockMode.NONE ? LockMode.READ : lockMode;
		loadFromResultSet(
				rs,
				i,
				object,
				instanceClass,
				key,
				rowIdAlias,
				acquiredLockMode,
				persister,
				session
		);

		//materialize associations (and initialize the object) later
		hydratedObjects.add( object );

		return object;
	}

	/**
	 * Hydrate the state an object from the SQL <tt>ResultSet</tt>, into
	 * an array or "hydrated" values (do not resolve associations yet),
	 * and pass the hydrates state to the session.
	 */
	private void loadFromResultSet(
			final ResultSet rs,
			final int i,
			final Object object,
			final String instanceEntityName,
			final EntityKey key,
			final String rowIdAlias,
			final LockMode lockMode,
			final Loadable rootPersister,
			final SharedSessionContractImplementor session) throws SQLException, HibernateException {

		final Serializable id = key.getIdentifier();

		// Get the persister for the _subclass_
		final Loadable persister = (Loadable) getFactory().getEntityPersister( instanceEntityName );

		if ( LOG.isTraceEnabled() ) {
			LOG.tracef(
					"Initializing object from ResultSet: %s",
					MessageHelper.infoString(
							persister,
							id,
							getFactory()
					)
			);
		}

		boolean fetchAllPropertiesRequested = isEagerPropertyFetchEnabled( i );

		// add temp entry so that the next step is circular-reference
		// safe - only needed because some types don't take proper
		// advantage of two-phase-load (esp. components)
		TwoPhaseLoad.addUninitializedEntity(
				key,
				object,
				persister,
				lockMode,
				session
		);

		//This is not very nice (and quite slow):
		final String[][] cols = persister == rootPersister ?
				getEntityAliases()[i].getSuffixedPropertyAliases() :
				getEntityAliases()[i].getSuffixedPropertyAliases( persister );

		final Object[] values = persister.hydrate(
				rs,
				id,
				object,
				rootPersister,
				cols,
				fetchAllPropertiesRequested,
				session
		);

		final Object rowId = persister.hasRowId() ? rs.getObject( rowIdAlias ) : null;

		final AssociationType[] ownerAssociationTypes = getOwnerAssociationTypes();
		if ( ownerAssociationTypes != null && ownerAssociationTypes[i] != null ) {
			String ukName = ownerAssociationTypes[i].getRHSUniqueKeyPropertyName();
			if ( ukName != null ) {
				final int index = ( (UniqueKeyLoadable) persister ).getPropertyIndex( ukName );
				final Type type = persister.getPropertyTypes()[index];

				// polymorphism not really handled completely correctly,
				// perhaps...well, actually its ok, assuming that the
				// entity name used in the lookup is the same as the
				// the one used here, which it will be

				EntityUniqueKey euk = new EntityUniqueKey(
						rootPersister.getEntityName(), //polymorphism comment above
						ukName,
						type.semiResolve( values[index], session, object ),
						type,
						persister.getEntityMode(),
						session.getFactory()
				);
				session.getPersistenceContext().addEntity( euk, object );
			}
		}

		TwoPhaseLoad.postHydrate(
				persister,
				id,
				values,
				rowId,
				object,
				lockMode,
				session
		);

	}

	//......
}
复制代码
  • instanceNotYetLoaded方法主要hydrate object，它会调用loadFromResultSet方法从resultSet提取出对象，然后添加到hydratedObjects中再返回；loadFromResultSet方法主要是通过TwoPhaseLoad.addUninitializedEntity方法，调用了session.getPersistenceContext().addEntity，将该object添加到StatefulPersistenceContext中；之后使用persister.hydrate从resultSet提取values，最后通过TwoPhaseLoad.postHydrate方法来创建managedEntity并与object关联起来

initializeEntitiesAndCollections

hibernate-core-5.3.9.Final-sources.jar!/org/hibernate/loader/Loader.java

public abstract class Loader {
	//......

	private void initializeEntitiesAndCollections(
			final List hydratedObjects,
			final Object resultSetId,
			final SharedSessionContractImplementor session,
			final boolean readOnly,
			List<AfterLoadAction> afterLoadActions) throws HibernateException {

		final CollectionPersister[] collectionPersisters = getCollectionPersisters();
		if ( collectionPersisters != null ) {
			for ( CollectionPersister collectionPersister : collectionPersisters ) {
				if ( collectionPersister.isArray() ) {
					//for arrays, we should end the collection load before resolving
					//the entities, since the actual array instances are not instantiated
					//during loading
					//TODO: or we could do this polymorphically, and have two
					//      different operations implemented differently for arrays
					endCollectionLoad( resultSetId, session, collectionPersister );
				}
			}
		}

		//important: reuse the same event instances for performance!
		final PreLoadEvent pre;
		final PostLoadEvent post;
		if ( session.isEventSource() ) {
			pre = new PreLoadEvent( (EventSource) session );
			post = new PostLoadEvent( (EventSource) session );
		}
		else {
			pre = null;
			post = null;
		}

		if ( hydratedObjects != null ) {
			int hydratedObjectsSize = hydratedObjects.size();
			LOG.tracev( "Total objects hydrated: {0}", hydratedObjectsSize );
			for ( Object hydratedObject : hydratedObjects ) {
				TwoPhaseLoad.initializeEntity( hydratedObject, readOnly, session, pre );
			}
		}

		if ( collectionPersisters != null ) {
			for ( CollectionPersister collectionPersister : collectionPersisters ) {
				if ( !collectionPersister.isArray() ) {
					//for sets, we should end the collection load after resolving
					//the entities, since we might call hashCode() on the elements
					//TODO: or we could do this polymorphically, and have two
					//      different operations implemented differently for arrays
					endCollectionLoad( resultSetId, session, collectionPersister );
				}
			}
		}

		// Until this entire method is refactored w/ polymorphism, postLoad was
		// split off from initializeEntity.  It *must* occur after
		// endCollectionLoad to ensure the collection is in the
		// persistence context.
		if ( hydratedObjects != null ) {
			for ( Object hydratedObject : hydratedObjects ) {
				TwoPhaseLoad.postLoad( hydratedObject, session, post );
				if ( afterLoadActions != null ) {
					for ( AfterLoadAction afterLoadAction : afterLoadActions ) {
						final EntityEntry entityEntry = session.getPersistenceContext().getEntry( hydratedObject );
						if ( entityEntry == null ) {
							// big problem
							throw new HibernateException(
									"Could not locate EntityEntry immediately after two-phase load"
							);
						}
						afterLoadAction.afterLoad( session, hydratedObject, (Loadable) entityEntry.getPersister() );
					}
				}
			}
		}
	}

	//......
}
复制代码
  • initializeEntitiesAndCollections方法会调用TwoPhaseLoad.initializeEntity(该方法会调用persister.setPropertyValues( entity, hydratedState )来将hydratedState值填充到entity中)来初始化hydratedObject

小结

  • write-behind cache是cache策略的一种，其主要思路就是更新数据是首先更新cache，之后cache在批量持久化到存储中，比如批量更新到数据，这样做的好处是可以合并数据的多次操作减少IO
  • hibernate为了减少数据库连接加锁的时间，设计了transactional write-behind的策略，其persistence context充当transactional write-behind cache的角色，对entity的改动都先作用到内存，等到一定时机在flush到数据库；具体体现在Session类中
  • hibernate的Session对jdbc的connection进行了包装，它主要是维护了level one cache，即"repeatable read" persistence context；具体体现在Loader的getRow方法中
  • 在key不为null的情况下，该方法会设置object的值；这里首先通过session.getEntityUsingInterceptor方法根据key从session中寻找该entity，如果不为null，则执行instanceAlreadyLoaded，否则执行instanceNotYetLoaded去设置object
  • getEntityUsingInterceptor方法首先从persistenceContext获取entity，如果获取不到再调用getInterceptor().getEntity获取；如果没有额外设置默认是EmptyInterceptor，其getEntity方法返回null
  • StatefulPersistenceContext维护了一个entitiesByKey的map，getEntity方法直接根据EntityKey从该map取数据；它同时也提供了addEntity、removeEntity、replaceDelayedEntityIdentityInsertKeys等方法来修改map
  • instanceAlreadyLoaded方法主要是校验类型是否正确，同时根据lockMode信息判断是否要升级lock mode等；instanceNotYetLoaded方法主要hydrate object，它会调用loadFromResultSet方法从resultSet提取出对象，然后添加到hydratedObjects中再返回；loadFromResultSet方法主要是通过TwoPhaseLoad.addUninitializedEntity方法，调用了session.getPersistenceContext().addEntity，将该object添加到StatefulPersistenceContext中；之后使用persister.hydrate从resultSet提取values，最后通过TwoPhaseLoad.postHydrate方法来创建managedEntity并与object关联起来
  • initializeEntitiesAndCollections方法会调用TwoPhaseLoad.initializeEntity(该方法会调用persister.setPropertyValues( entity, hydratedState )来将hydratedState值填充到entity中)来初始化hydratedObject

doc

转载于:https://juejin.im/post/5cc06842e51d456e2f77f130

weixin_33728268
关注
hibernate二级缓存ehcache的put原理
Destiny宿命的博客
06-02 392
hibernate执行sql，将数据转化为映射实体类后会进行数据缓存，其中调用AbstractRowReader#performTwoPhaseLoad方法时，会循环数据集，调用TwoPhaseLoad.initializeEntity();该方法会调用ehcache的put方法进行数据缓存。 ehcache在put数据实例（数据实例已转化为Element实例对象)，该对象到磁盘时（此时内存缓存已满，按照ehcache.xml中设定的策略，超过部分存储在磁盘），会判断当前disk store spool i
JAVA注解学习-@Repeatable注解
madman
12-22 6250
@Repeatable注解是用来标注一个注解在同一个地方可重复使用的一个注解，比如说你定义了一个注解，如果你的注解没有标记@Repeatable这个JDK自带的注解，那么你这个注解在引用的地方就只能使用一次。 例： 这里@ImportResource(value = “”)注解里面没有设置添加@Repeatable属性，所有引入的多次的时候就会报错， 参考链接 java8注解@Repeata...
Hibernate Gossip: 簡介快取（Session Level）
04-21 507
Hibernate Gossip: 簡介快取（Session Level） 資料庫每一次的查詢都是一次不小的開銷，例如連結的開啟、執行查詢指令，當資料庫與應用伺服器不在同一個伺服器上時，還必須有遠程調用、Socket的建立等開銷，在Hibernate這樣的ORM框架中，還有資料的封裝等開銷必須考慮進去。快取（Cache）是資料庫在記憶體
Hibernate的其他的常用的查询方式和关系映射
Jack
10-20 270
Hibernate的其他的常用的查询方式 Hibernate除了原生的sql语句查询之外还有其余的两种查询方式，分别是Qurey查询和Criteria查询。 HQL查询： 查询所有 @Test public void findAll(){ //Query查询适用的是hql语句 String hql = "from News"; //得到一个Q...
hibernate 常见问题总结
lipingping951462的专栏
02-23 1681
Caused by: org.springframework.orm.hibernate4.HibernateOptimisticLockingFailureException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1; nested exception
hibernate5--2.数据持久化及事务
03-07
数据持久化是通过Hibernate的核心接口Session来实现的。Session提供了对数据库的 CRUD（创建、读取、更新、删除）操作，它是连接应用程序和数据库的桥梁。在Hibernate中，对象的状态有三种：瞬时态、持久态和脱管态...
java收银系统源码-Build-Repeatable-Infrastructure-using-Terraform-and-Ansible:
06-05
java收银系统源码在 AWS 上使用 Terraform 和 Ansible 构建可重复的基础设施 许多公司仍在为基本 IT 运营而苦苦挣扎。...他们花费太多时间灭火并手动构建、配置和维护基础设施，导致本可以帮助公司转型的大量资金损失。...
浅析MYSQL REPEATABLE-READ隔离级别
01-19
REPEATABLE-READ 即可重复读，set autocommit= 0或者START TRANSACTION状态下select表的内容不会改变。这种隔离级别可能导致读到的东西是已经修改过的。 比如: 回话一中读取一个字段一行a=1 在回话二里这个字段该行...
Hibernate --- hibernate.cfg.xml核心配置文件详解
热门推荐
__静禅__
01-07 1万+
一、Hibernate配置文件加载流程 (1) 通过Configuration config = new Configuration().configure();加载默认配置文件 (2)Configuration的configure()方法 注意：hibernate默认加载的文件hibernate.cfg.xml (3)调用StandardS
hibernate之2----hibernate缓存
xiaoyu902151的博客
12-09 634
hibernate缓存，包括一级缓存、二级缓存和查询缓存。     其中，一级缓存的生命周期随着session的生命周期。在session 接口实现类org.hibernate.internal.SessionImpl中，persistenceContext 属性中保存着一级缓存； private transient StatefulPersistenceContext persistenc
Hibernate3官方教程－第1章－第2部分
未来之路
01-08 4485
1.3.第2部分 － 关联映射 我们映射了一个持久化实体类到一张数据库表，让我们在这个基础上添加一些类关联关系，首先，我们为这个应用添加相关人员信息，并且储存他们参与的事件列表。 1.3.1.映射Person类 这个Person类很简单： package events; public class Person { private Long id; private int
Hibernate使用中注意的问题
维
09-20 124
懒加载异常 再使用懒加载的时候使用的是代理对象，所以后有可能再使用懒加载属性的时候session已经关了，这个错误再代理对象这种设计模式的时候要考虑到 具体我知道的有 Hibernate中的load方法得到的代理对象 Spring JPA中的getReference得到的代理对象 ...
jpa双向一对一关联外键映射
weixin_30677617的博客
07-11 336
项目结构： Wife package auth.model; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.per...
还在用log.isDebugEnabled()判断debug日志？你out了
qq_35785465的博客
04-19 2690
https://juejin.cn/post/7087847327578193957/
Hibernate遇到处理大数据的问题
hzygbicc的专栏
10-14 212
       今天同事搞个东西,插入8000条数据，到了3000条就卡死了。。应该是session没释放，以下整理出出现该问题的解决方案。       大批量的数据插入到数据库。数量级有万级、十万级、百万级、甚至千万级别的。如此数量级别的数据用Hibernate做插入操作，就可能会发生异常，常见的异常是OutOfMemoryError（内存溢出异常）。      Hibernate插入操作的...
Hibernate Session_flush与隔离级别深度解析
"本文深入探讨了Hibernate的Session_flush机制和数据库隔离级别的概念，通过代码实例解析了相关知识点，包括脏读、不可重复读、幻读等现象以及对应的隔离级别，如提交读、可重复读和序列化。" 在 Hibernate 框架中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值