Java LazyInitializationException类代码示例

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Override
public final void initialize() throws HibernateException {
	if ( !initialized ) {
		if ( allowLoadOutsideTransaction ) {
			permissiveInitialization();
		}
		else if ( session == null ) {
			throw new LazyInitializationException( "could not initialize proxy - no Session" );
		}
		else if ( !session.isOpen() ) {
			throw new LazyInitializationException( "could not initialize proxy - the owning Session was closed" );
		}
		else if ( !session.isConnected() ) {
			throw new LazyInitializationException( "could not initialize proxy - the owning Session is disconnected" );
		}
		else {
			target = session.immediateLoad( entityName, id );
			initialized = true;
			checkTargetState();
		}
	}
	else {
		checkTargetState();
	}
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
public Department getDepartment() {
    Department dept = null;
    try {
        dept = this.getSubjectArea().getDepartment();
        if(dept.toString()==null) {
        }
    }
    catch (LazyInitializationException lie) {
        new _RootDAO().getSession().refresh(this);
        dept = this.getSubjectArea().getDepartment();
    }
    
	return (dept);
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Test(expected = LazyInitializationException.class)
public void selectFromWithoutJoinFetch() {
	log.info("... selectFromWithoutJoinFetch ...");

	EntityManager em = emf.createEntityManager();
	em.getTransaction().begin();

	Author a = em.createQuery("SELECT a FROM Author a WHERE id = 1", Author.class).getSingleResult();
	
	log.info("Commit transaction and close Session");
	em.getTransaction().commit();
	em.close();
	
	try {
		log.info(a.getFirstName()+" "+a.getLastName()+" wrote "+a.getBooks().size()+" books.");
	} catch (Exception e) {
		log.error(e);
		throw e;
	}
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
public final void initialize() throws HibernateException {
	if (!initialized) {
		if ( session==null ) {
			throw new LazyInitializationException("could not initialize proxy - no Session");
		}
		else if ( !session.isOpen() ) {
			throw new LazyInitializationException("could not initialize proxy - the owning Session was closed");
		}
		else if ( !session.isConnected() ) {
			throw new LazyInitializationException("could not initialize proxy - the owning Session is disconnected");
		}
		else {
			target = session.immediateLoad(entityName, id);
			initialized = true;
			checkTargetState();
		}
	}
	else {
		checkTargetState();
	}
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Override
public Component getTableCellRendererComponent(JTable table, Object value,
		boolean isSelected, boolean hasFocus, int row, int column) {
	JLabel lbText = (JLabel) super.getTableCellRendererComponent(table,
			null, isSelected, hasFocus, row, column);
	if (value == null || value instanceof String) {
		return lbText;
	}
	try {
		lbText.setText(value.toString());
	} catch (LazyInitializationException lie) {
		MainFrame mainFrame = (MainFrame) table
				.getClientProperty(ClientPropertyName.MAIN_FRAME.toString());
		BookModel model = mainFrame.getBookModel();
		Session session = model.beginTransaction();
		session.refresh((Chapter) value);
		lbText.setText(value.toString());
		model.commit();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return lbText;
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
private void refire() {
    EntityManager em = getEntityManager();
    try {
        for (AlertDefinition def : getAlertDefs(em)) {
            try {
                checkRefire(def);
            } catch (LazyInitializationException e) {
                // failed to lazily initialize a collection of role: org.rhq.core.domain.alert.AlertDefinition.alerts, could not initialize proxy - no Session
                log.debug("spurious exception?", e);
                def = em.find(AlertDefinition.class, def.getId());
                checkRefire(def);
            }
        }
    } finally {
        em.close();
    }
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
/**
 * Interception of access to the named field
 *
 * @param target The call target
 * @param fieldName The name of the field.
 * @param value The value.
 *
 * @return ?
 */
protected final Object intercept(Object target, String fieldName, Object value) {
	if ( initializing ) {
		return value;
	}

	if ( uninitializedFields != null && uninitializedFields.contains( fieldName ) ) {
		if ( session == null ) {
			throw new LazyInitializationException( "entity with lazy properties is not associated with a session" );
		}
		else if ( !session.isOpen() || !session.isConnected() ) {
			throw new LazyInitializationException( "session is not connected" );
		}

		final Object result;
		initializing = true;
		try {
			result = ( (LazyPropertyInitializer) session.getFactory().getEntityPersister( entityName ) )
					.initializeLazyProperty( fieldName, target, session );
		}
		finally {
			initializing = false;
		}
		// let's assume that there is only one lazy fetch group, for now!
		uninitializedFields = null;
		return result;
	}
	else {
		return value;
	}
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
private void throwLazyInitializationException(String message) {
	throw new LazyInitializationException(
			"failed to lazily initialize a collection" +
					(role == null ? "" : " of role: " + role) +
					", " + message
	);
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
/**
 * <strong>使用广度优先搜索收集</strong>当前实体及其所有子孙实体到集合，叶子实体排在最前面<br/>
 * 这样才能保证先删除子孙节点，后删除父节点，避免违反外键约束
 * @param currentEntity 存放当前实体及其所有子孙实体的集合
 * @param treeEntities 所有实体的集合
 * @return 当前实体及其所有子孙实体的集合，叶子实体排在集合最前面
 */
@SuppressWarnings("unchecked")
@Transactional
private LinkedList<SelfReference<T>> bfsTraverse(SelfReference<T> currentEntity, LinkedList<SelfReference<T>> treeEntities) {

    // 无法获取子孙类目时，在事务中重新获取当前节点
    try {
        currentEntity.getChildren().size();
    } catch (LazyInitializationException e) {
        ID id = (ID) ((BaseEntity)currentEntity).getId();
        currentEntity = (SelfReference<T>) findOne(id);
    }

    // 队列，用于广度优先遍历。每一时刻，队列所包含的节点是那些本身已经被访问，而它的邻居(这里即子节点)还有未被访问的节点
    Queue<SelfReference<T>> queue = new ArrayDeque<>();
    treeEntities.addFirst(currentEntity); // 对当前遍历到的元素执行的操作：加在头部，后续用于删除节点(避免违反外键约束)
    queue.add(currentEntity); // 加在尾部

    while (queue.size() != 0) { // 直到队列为空
        SelfReference<T> parent = queue.remove(); // 移除在队列头部的节点

        if(parent.getChildren().size() != 0) {
            parent.getChildren().forEach(child -> {
                treeEntities.addFirst((SelfReference<T>) child); // 对当前遍历到的元素执行的操作：加在头部
                queue.add((SelfReference<T>) child); // 加在尾部
            });
        }
    }

    return treeEntities;
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
public Set<Location> getRooms() {
	try {
		return super.getRooms();
	} catch (LazyInitializationException e) {
		(new AssignmentDAO()).getSession().merge(this);
		return super.getRooms();
	}
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Deprecated
  public String getHtmlHint(String preference) {
try {
	if (!Hibernate.isPropertyInitialized(this, "roomType") || !Hibernate.isInitialized(getRoomType())) {
		return LocationDAO.getInstance().get(getUniqueId()).getHtmlHintImpl(preference);
	} else {
		return getHtmlHintImpl(preference);
	}
} catch (LazyInitializationException e) {
	return LocationDAO.getInstance().get(getUniqueId()).getHtmlHintImpl(preference);
}
  }
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Test(expected = LazyInitializationException.class)
public void testFailLazyAccess() {
	User user = entityManager.find(User.class, 1L);
	assertNotNull(user);
	// Lazy init exception cars is mapped as lazy
	user.getCars().stream().forEach(System.out::println);
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Test(expected = LazyInitializationException.class)
public void testFailLazyAccessByExplicitJoinInJPAQL() {
	TypedQuery<User> loadUserQuery = entityManager.createQuery(
			"select usr from User usr left outer join usr.cars cars where cars.licensePlate = :licensePlate",
			User.class);
	loadUserQuery.setParameter("licensePlate", "HIBERNATE");
	User user = loadUserQuery.getSingleResult();
	user.getCars().stream().forEach(System.out::println);
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Test
public void testGetUserLazyProperties() {
    List<User> users = service.getAllUsers4LazyTest();
    assertNotNull(users);
    assertThat(users.size(), greaterThan(0));
    User user = users.get(0);
    assertThat(user, notNullValue());
    assertThat(user.getName(), notNullValue());

    try {
        user.getType().getValue();
    } catch (Exception e) {
        assertThat(e, instanceOf(LazyInitializationException.class));
    }
}
 

import org.hibernate.LazyInitializationException; //导入依赖的package包/类
@Test
public void testGetUserLazyProperties() {
    List<User> users = service.getAllUsers4LazyTest();
    assertNotNull(users);
    assertThat(users.size(), greaterThan(0));
    User user = users.get(0);
    assertThat(user, notNullValue());
    assertThat(user.getName(), notNullValue());
    
    try {
        user.getType().getValue();
    } catch (Exception e) {
        assertThat(e, instanceOf(LazyInitializationException.class));
    }
}