彻底解决SSH架构中的Hibernate懒加载问题

       在客户端使用AJAX框架，服务端采用Struts2+Spring+Hibernate的架构中，经常会遇到Hibernate懒加载的问题 ，异常为：

 

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role

      相信大家经常可以在网上看到相关的技术文章，大致是在web.xml中加上openSessionFilter，代码如下：

  
    hibernateFilter
    org.springframework.orm.hibernate4.support.OpenSessionInViewFilter
  

 

        如果你真的亲自去写代码了，你会发现这个方法根本不管用，原因在于Struts2的JSON插件使用反射技术，会调用关联对象的get方法获取对象的实例，从而触发Hibernate查询数据，导致本异常。

       本文的系统所采用的架构为Hibernate4、Spring4、Struts2，客户端使用Ext JS4作为WEB界面框架，Ext JS4和Struts2交互使用JSON格式的数据，故使用了struts_json插件，Struts2的配置则采用convention插件，即注解的配置方式，Hibernate4采用JPA注解方式配置对象关系映射 ，先看一下POJO的关系映射

     1、MenuPanel，一的一方：

package com.mcs.user.pojo;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.Columns;

import com.mcs.pojo.base.GenericObject;

@Entity
@Table(name = "MENUPANEL")
public class MenuPanel extends GenericObject {
	private String text;
	private List menus=new ArrayList();

	public MenuPanel() {
	}

	public MenuPanel(String text) {
		this.text = text;
	}
	public MenuPanel(long id,String text) {
		this.text = text;
		super.setId(id+"");
	}

	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}

	@OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY,mappedBy="menuPanel")
	public List getMenus() {
		return menus;
	}

	public void setMenus(List menus) {
		this.menus = menus;
	}

}

      2、menu多的一方：

package com.mcs.user.pojo;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import static org.hibernate.annotations.CascadeType.SAVE_UPDATE;
import org.hibernate.annotations.Cascade;

import com.mcs.pojo.base.GenericObject;


@Entity
@Table(name="MENU")
public class Menu extends GenericObject{
	private String text;
	private String url;
	private boolean leaf=true;//默认是叶子节点
	private MenuPanel menuPanel;
	private List children;
	private Menu menu;
	
	
	public Menu() {
	}

	public Menu(String text, String url) {
		super();
		this.text = text;
		this.url = url;
	}
	public Menu(long id,String text, String url,MenuPanel menuPanel) {
		super();
		super.setId(id+"");
		this.text = text;
		this.url = url;
		this.menuPanel=menuPanel;
	}
	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE}, targetEntity=MenuPanel.class)
	@JoinColumn(name="menuPanelId",referencedColumnName="id",insertable=true,updatable=true)
	public MenuPanel getMenuPanel() {
		return menuPanel;
	}

	public void setMenuPanel(MenuPanel menuPanel) {
		this.menuPanel = menuPanel;
	}

	@Column(length=1000)
	public boolean isLeaf() {
		return leaf;
	}

	public void setLeaf(boolean leaf) {
		this.leaf = leaf;
	}

	@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY,mappedBy="menu")
	public List getChildren() {
		return children;
	}

	public void setChildren(List children) {
		this.children = children;
	}

	@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE}, targetEntity=Menu.class)
	@JoinColumn(name="parentId",referencedColumnName="id",insertable=true,updatable=true)
	public Menu getMenu() {
		return menu;
	}

	public void setMenu(Menu menu) {
		this.menu = menu;
	}
	
	
}

       manuPanel和menu是一对多的关系，manuPanel是一的一方，menu是多的一方，采用懒加载的方式，Struts2使用JSON插件进行JSON数据转换，配置如下

@Action(value="queryMenu",results = { @Result(type = "json",params={"root","pageBean"})})
	public String queryMenu() {
		
		menuPanels=menuPanelService.queryMenuPanel();
		this.pageBean.setRows(menuPanels);
		this.pageBean.setTotal(menuPanels.size());//不使用分页
		return "success";
	}

        让Struts2支持Hibernate懒加载有三种方式，第一种：配置JSON插件需要排除的字段，第二种：使用DTO或者VO对象，可以解决懒加载的问题，并且可以有效减少不相关的调用，当然，在项目中使用DTO或VO对象，取决于项目架构的，我个人比较推崇使用DTO或者VO，但发现在项目组很难实行，第三种：修改JSON转换插件，可以彻底解决懒加的问题。咱们先介绍第一种：

@Action(value="queryMenu",results = { @Result(type = "json",params={"root","pageBean","excludeProperties","^.*menus$,^.*children$"})})
	public String queryMenu() {
		
		menuPanels=menuPanelService.queryMenuPanel();
		this.pageBean.setRows(menuPanels);
		this.pageBean.setTotal(menuPanels.size());//不使用分页
		return "success";
	}

 

        上面这个代码我们用的是正则表达式进行字段匹配，要排除多个字段，用逗号隔开。好了，现在不会报错了，数据也能加载了，但是如果我们有很多POJO类都使用懒加载，每次都要这么配置，简直就是一件痛苦的事，有没有一劳永逸的解决办法呢，答案是当然有，我们通过对JSON插件进行修改，让Struts2_JSON插件支持Hibernate懒加载，这样，就不用每次在Action中配置排除属性了，

      首先，在protected void bean(Object object)方法中的Object value = accessor.invoke(object);后面加入以下代码

					Object value = accessor.invoke(object);
					//如果是PersistentBag类型的实例，则是Hibernate的持久化对象
					if (value instanceof PersistentBag) {
						// 判断bag对象是否已经初始化，如果没有初始化，则是懒加载的方式
						PersistentBag bag=(PersistentBag) value;
						boolean b=Hibernate.isInitialized(bag);
						if(b==false)
						{
							continue;							
						}
					}
					if (baseAccessor.isAnnotationPresent(JSONFieldBridge.class)) {....

     然后将protected void value(Object object, Method method)方法中的LOG.debug("Cyclic reference detected on " + object);改为

					//将object改为取class类名，避免Hibernate懒加载错误
					LOG.debug("Cyclic reference detected on " + clazz.getName());

     完整代码如下：

/*
 * $Id: JSONWriter.java 1436290 2013-01-21 11:37:16Z lukaszlenart $
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.struts2.json;

import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.PropertyUtilsBean;
import org.apache.struts2.json.annotations.JSON;
import org.apache.struts2.json.annotations.JSONFieldBridge;
import org.apache.struts2.json.annotations.JSONParameter;
import org.apache.struts2.json.bridge.FieldBridge;
import org.apache.struts2.json.bridge.ParameterizedBridge;
import org.apache.velocity.texen.util.PropertiesUtil;
import org.hibernate.Hibernate;
import org.hibernate.collection.internal.PersistentBag;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.CharacterIterator;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.text.StringCharacterIterator;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Pattern;

/**
 * 

 * Serializes an object into JavaScript Object Notation (JSON). If cyclic
 * references are detected they will be nulled out.
 * 
 */
public class JSONWriter {

	private static final Logger LOG = LoggerFactory.getLogger(JSONWriter.class);

	/**
	 * By default, enums are serialised as name=value pairs
	 */
	public static final boolean ENUM_AS_BEAN_DEFAULT = false;

	private static char[] hex = "0123456789ABCDEF".toCharArray();

	private static final ConcurrentMap, BeanInfo> BEAN_INFO_CACHE_IGNORE_HIERARCHY = new ConcurrentHashMap, BeanInfo>();
	private static final ConcurrentMap, BeanInfo> BEAN_INFO_CACHE = new ConcurrentHashMap, BeanInfo>();

	private StringBuilder buf = new StringBuilder();
	private Stack