/**
    * Copyright (c) Glodon Co. Ltd.
    */
   package gboat2.base.core.web;
   
   import gboat2.base.bridge.GboatAppContext;
   import gboat2.base.bridge.debug.DefaultDebugHook;
   import gboat2.base.bridge.exception.DefaultBusinessNestedException;
   import gboat2.base.core.Activator;
  import gboat2.base.core.GBoatClassLoader;
  import gboat2.base.core.GBoatConsistant;
  import gboat2.base.core.annotation.Business;
  import gboat2.base.core.annotation.Domain;
  import gboat2.base.core.annotation.ListDomain;
  import gboat2.base.core.annotation.NoQuery;
  import gboat2.base.core.dao.Page;
  import gboat2.base.core.dao.QuerySupport;
  import gboat2.base.core.exception.NoPrivilegeException;
  import gboat2.base.core.service.IBaseService;
  import gboat2.base.core.service.ModuleService;
  import gboat2.base.core.util.ActionUtil;
  import gboat2.base.core.util.SpringContextUtil;
  import gboat2.base.core.validate.IDataPrivilegeCheckService;
  import gboat2.base.core.validate.IOperaPrivilegeCheckService;
  import gboat2.base.core.validate.PrivilegeCheckServiceFactory;
  
  import java.io.IOException;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.annotation.Resource;
  import javax.persistence.Entity;
  import javax.persistence.Id;
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.collections.MapUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.text.WordUtils;
  import org.apache.struts2.StrutsConstants;
  import org.apache.struts2.convention.annotation.Result;
  import org.apache.struts2.convention.annotation.Results;
  import org.apache.struts2.osgi.OsgiHost;
  import org.apache.struts2.osgi.StrutsOsgiListener;
  import org.apache.struts2.osgi.interceptor.ServiceAware;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.FrameworkUtil;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.util.ReflectionUtils;
  
  import com.opensymphony.xwork2.ActionContext;
  import com.opensymphony.xwork2.ActionSupport;
  import com.opensymphony.xwork2.inject.Container;
  import com.opensymphony.xwork2.inject.Inject;
  
  /**
   * @author lysming
   * 2011-12-6
   */
  @SuppressWarnings("unchecked")
  public abstract class BaseActionSupport extends ActionSupport implements IBaseActionSupport, ServiceAware {
  
  	protected static final long serialVersionUID = 1L;
  	
  	private static Logger logger = LoggerFactory.getLogger(BaseActionSupport.class);
  
  	public static final String CURRENT_BUNDLE_RES_LOCATION = "_curr_bundle_res_location_";
  	public static final String MIN_SUFFIX = "minSuffix";
  
  	public HttpServletRequest request;
  
  	public HttpServletResponse response;
  
  	// struts-osgi中注入的始终是system-bundle
  	protected BundleContext context;
  	
  	protected Container container;
  	
  	/** 是否开启了 Struts 调试模式 */
  	protected boolean devMode;
  	
  	protected boolean flatResultLayout;
  	
  	protected String nameSeparator;
  
  	protected OsgiHost osgiHost;
 
 	protected Page<?> page;
 
     protected String SID; 
     
     protected Object model;
 
     /** 排序字段 */
     protected String sortField;
     
     /** 排序方向（ASC 或 DESC） */
     protected String sortDirection;
 
     /** 需要跳转到的目标页面 */
     protected String go;
 
     /** 当前执行的 Action 所在的 Bundle */
     private Bundle actionBundle;
 
     /**前端每次请求创建Module的id，用于前端取得module对象*/
     private String _MdId;
     
     private Map<String, Object> listParameterMap = null;
 
     //权限校验参数
     private Map<Object,Object> priCheckParams = new HashMap<Object,Object>();
 
 	private IBaseService baseServiceInBase;
 
 	@Inject
 	public void setContainer(Container container) {
 		this.container = container;
 	}
 
     @Inject(StrutsConstants.STRUTS_DEVMODE)
     public void setDevMode(String mode) {
         this.devMode = "true".equals(mode);
     }
     
     @Inject("struts.convention.result.flatLayout")
     public void setFlatResultLayout(String flatResultLayout) {
         this.flatResultLayout = "true".equals(flatResultLayout);
     }
     
     @Inject("struts.convention.action.name.separator")
     public void setNameSeparator(String nameSeparator) {
         this.nameSeparator = nameSeparator;
     }
 
 	/* (non-Javadoc)
 	 * @see gboat2.base.bridge.action.IBaseAction#delete()
 	 */
 	public String delete() {
 		deleteModel();
 
 		// 如果指定了"delete-success"则转向到"delete-success"配置的页面
 		if (this.getClass().isAnnotationPresent(Results.class)) {
 			Results rses = this.getClass().getAnnotation(Results.class);
 			for (Result rs : rses.value()) {
 				if (rs.name().equals("delete-success")) {
 					return rs.name();
 				}
 			}
 		}
 
 		// 未指定save-success，则转向到列表页面
 		try {
 			response.sendRedirect(getDefaultListUri());
 			return null;
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 		return "redirect:" + getDefaultListUri();
 	}
 
 	/**
 	 * desktop的Ajax删除处理
 	 * @return null
 	 */
 	public String ajaxDelete() {
 		try {
 			deleteModel();
 			GboatAppContext.output(JsonResult.SUCCESS);
 		} catch (Exception e) {
 		    GboatAppContext.output(JsonResult.createFailure(e.getMessage()));
 			logger.error(e.toString(), e);
 		}
 		return null;
 	}
 
 	protected final void deleteModel() {
 		if (null == SID || SID.equals("")) {
 			throw new RuntimeException("no id is setted to delete.");
 		} else {
 			prepareModel();
 			Object model = getModel();
 			if (model != null) {
 				//判断是否存在deleteXxxxx方法
 				Class<?> domainClass = getDomainClassAnnotationed();
 				IBaseService service = getServiceAnnotationed();
 				Class<?> serviceClass = service.getClass();
 				String methodName = "delete" + domainClass.getName().substring(domainClass.getName().lastIndexOf(".") + 1);
 				try {
 					Method method = serviceClass.getMethod(methodName, domainClass);
 					method.invoke(service, model);
 					logger.debug("called " + methodName + " ......");
 				} catch (IllegalArgumentException e) {
 					throw new RuntimeException(model.getClass().getName() + " is invalid for method '" + methodName + "' in business class");
 				} catch (IllegalAccessException e) {
 					throw new RuntimeException("faild to call method '" + methodName + "' in business class");
 				} catch (InvocationTargetException e) {
 					throw new RuntimeException("faild to call method '" + methodName + "' in business class");
 				} catch (Exception e) {
 					service.delete(model);//如果不存在deleteXxxxx方法,则用默认方法删除
 				}
 				postDelete();
 			}
 		}
 	}
 
 	protected void postDelete() {
 
 	}
 
 	public void prepareModel() {
 		Class<?> domainClass = getDomainClassAnnotationed();
 		if (domainClass != null) {
 			if (SID == null || SID.equals("")) {
 				if (model == null) {
 					try {
 						model = domainClass.newInstance();
 					} catch (Exception e) {
 						e.printStackTrace();
 						throw new RuntimeException(e);
 					}
 				}
 			} else {
 				model = getServiceAnnotationed().get(domainClass, SID);
 			}
 		} else {
 			logger.warn("No @Domain is configured at " + this.getClass().getName());
 		}
 	}
 
 	/**
 	 * 获取列表使用的注解ListDomain类
 	 * 如果使用了@ListDomain(方法级或类级)，则使用该注解申明的ListDomain；
 	 * 如果没有则使用@Domain申明的Domain
 	 * @return 返回当前action的po class或者vo class
 	 */
 	public final Class<?> getDomainClassAnnotationedForList() {
 		Class<?> clazz = this.getClass();
 		//判断方法是否使用了@ListDomain注解
 		String invokeMethod = "";
 		invokeMethod = ActionContext.getContext().getActionInvocation().getProxy().getMethod();
 		Method method = ReflectionUtils.findMethod(this.getClass(), invokeMethod);
 		if (method != null) {
 			if (method.isAnnotationPresent(ListDomain.class)) {
 				ListDomain domainAn = (ListDomain) method.getAnnotation(ListDomain.class);
 				return domainAn.value();
 			}
 		}
 		//检查initXxxx是否使用了@ListDomain注解
 		Method initMethod = ReflectionUtils.findMethod(this.getClass(), getInitMethodName(invokeMethod), new Class[] { Map.class });
 		if (initMethod != null && initMethod.isAnnotationPresent(ListDomain.class)) {
 			ListDomain domainAn = (ListDomain) initMethod.getAnnotation(ListDomain.class);
 			return domainAn.value();
 		}
 		if (clazz.isAnnotationPresent(ListDomain.class)) {
 			ListDomain domainAn = (ListDomain) clazz.getAnnotation(ListDomain.class);
 			return domainAn.value();
 		} else {
 			Class<?> domain = getDomainClassAnnotationed();
 			if (domain != null) {
 				return domain;
 			} else {
 				throw new RuntimeException("No @ListDomain or @Domain can be found for " + invokeMethod);
 			}
 		}
 	}
 
 	private String getInitMethodName(String invokeMethod) {
 		char firstChar = Character.toTitleCase(invokeMethod.charAt(0));
 		String finalMethodName = "init" + firstChar + invokeMethod.substring(1);
 		return finalMethodName;
 	}
 
 	/**
 	 * 获取注解配置的domain类
 	 * 优先级顺序：
 	 * 		1、方法是否配置@Domain注解；
 	 * 		2、类是否配置@Domain注解；
 	 * 		3、是否传递参数DomainClass
 	 * 		4、从配置的struts.gboat.domain.basePackage路径中找符合命名规范的PO类
 	 * 
 	 * @return 返回当前action的po class
 	 */
 	public final Class<?> getDomainClassAnnotationed() {
 		Class<?> domain = null;
 		Class<?> clazz = this.getClass();
 
 		//判断方法是否使用了@Domain注解
 		try {
 			String invokeMethod = ActionContext.getContext().getActionInvocation().getProxy().getMethod();
 			Method method = clazz.getMethod(invokeMethod, new Class[] {});
 			if (method.isAnnotationPresent(Domain.class)) {
 				Domain domainAn = (Domain) method.getAnnotation(Domain.class);
 				return domainAn.value();
 			}
 		} catch (Exception ignore) {
 			//ignore the exception
 		}
 
 		//判断类是否使用了@Domain注解
 		if (clazz.isAnnotationPresent(Domain.class)) {
 			Domain domainAn = (Domain) clazz.getAnnotation(Domain.class);
 			return domainAn.value();
 		}
 
 		//判断是否传递了DomainClass参数
 		String domainClass = request.getParameter("DomainClass");
 		if (null != domainClass && !domainClass.equals("")) {
 			if (domainClass.indexOf(".") == -1) {
 				// 从配置的domain路径中寻找匹配的PO类，参见struts.xml中的“struts.gboat.domain.basePackage”参数
 				String domainBasePack = container.getInstance(String.class, GBoatConsistant.GBOAT_ACTION_DOMAIN_PACKAGE);
 				String[] packs = domainBasePack.split(";|,");
 				for (int i = 0; i < packs.length; i++) {
 					try {
 						domainClass = packs[i] + "." + domainClass;
 						return Class.forName(domainClass);
 					} catch (ClassNotFoundException e) {
 						logger.info(e.getMessage(), e.getCause());
 					}
 				}
 			}
 
 			if (domain == null) {
 				throw new RuntimeException("Invalid domain class passed by parameter[\"DomainClass\"] : " + domainClass);
 			}
 		}
 
 		// 从配置的domain路径中寻找匹配的PO类，参见struts.xml中的“struts.gboat.domain.basePackage”参数
 		String domainBasePack = container.getInstance(String.class, GBoatConsistant.GBOAT_ACTION_DOMAIN_PACKAGE);
 		if (!StringUtils.isEmpty(domainBasePack)) {
 			String className = "";
 			// 根据Action名称自动匹配Domain类名
 			className = this.getClass().getName();
 			if (className.indexOf(".") != -1) {
 				className = className.substring(className.lastIndexOf(".") + 1);
 			}
 			if (className.endsWith("Action")) {
 				className = className.substring(0, className.length() - 6);
 			}
 			String[] packs = domainBasePack.split(";|,");
 			for (int i = 0; i < packs.length; i++) {
 				try {
 					domainClass = packs[i] + "." + className;
 					return Class.forName(domainClass);
 				} catch (ClassNotFoundException e) {
 					logger.info(e.getMessage(), e.getCause());
 				}
 			}
 			if (domain == null) {
 				throw new RuntimeException("No class[" + className + "] existed in package[" + domainBasePack
 						+ "],failed to auto find domain class.\n@Domain should be setted for " + this.getClass()
 						+ " or passed by parameter \"DomainClass\"");
 			}
 		}
 		return null;
 	}
 
 	private void prepareModelInBase(String methodName) throws Exception {
 		// 判断是否由BaseAction的方法触发，如果由override的方法触发将不执行Model准备的方法
 		Class<?> clazz = this.getClass();
 		try {
 			Method editMethod = clazz.getMethod(methodName, new Class<?>[] {});
 			if (editMethod.getDeclaringClass() == BaseActionSupport.class) {
 				prepareModel();
 			}
 		} catch (NoSuchMethodException exception) {
 			logger.info(exception.getMessage(), exception.getCause());
 		}
 	}
 
 	/**
 	 * 根据@Business定义的服务类查找对应的spring bean
 	 *  
 	 * @return 返回IBaseService
 	 */
 	final public IBaseService getServiceAnnotationed() {
 		if (baseServiceInBase == null) {
 			Class<?> clazz = this.getClass();
 			if (!clazz.isAnnotationPresent(Business.class)) {
 				// 未配置service类，采用默认的service类
 				baseServiceInBase = (IBaseService) context.getService(context.getServiceReference(IBaseService.class.getName()));
 				if (baseServiceInBase == null) {
 					throw new RuntimeException("@Business havn't setted for " + this.getClass()
 							+ ". Bean[id='defaultBaseService'] not found in Spring context.");
 				}
 			} else {
 				Business businessAn = (Business) clazz.getAnnotation(Business.class);
 				// 从spring context中获取配置的service bean
 				List<?> annotationSerivces = SpringContextUtil.getInstance().getBeansOfType(businessAn.value(), getActionBundle());
 				if (annotationSerivces.size() == 0) {
 					throw new RuntimeException("the Business Bean named " + businessAn.value().getName() + " can not be found.");
 				} else if (annotationSerivces.size() > 1) {
 					throw new RuntimeException("the Business Bean named " + businessAn.value().getName() + " is not unique.");
 				}
 				baseServiceInBase = (IBaseService) annotationSerivces.get(0);
 			}
 		}
 
 		return baseServiceInBase;
 	}
 
 	final public void prepareEdit() throws Exception {
 		prepareModelInBase("edit");
 	}
 
 	protected void initEdit() {
 
 	}
 
 	/**
 	 * 注册除包含在实体对象即po，vo中枚举类型
 	 * 使用场景：如果页面中用到的枚举 但此枚举没有出现在po、vo中，则需要覆盖此方法，把当前枚举注册参数enumClass中
 	 * @param enumClass
 	 */
 	public void registerEnumClassNotInEntry(List<Class<? extends Enum<?>>> enumClass) {
 
 	}
 
 	/* (non-Javadoc)
 	 * @see gboat2.base.bridge.action.IBaseAction#edit()
 	 */
 	public String edit() {
 		initEdit();
 		return "edit";
 	}
 
 	final public void prepareView() throws Exception {
 		prepareModelInBase("view");
 	}
 
 	protected void initView() {
 
 	}
 
 	public String view() {
 		initView();
 		return "view";
 	}
 
 	final public void prepareList() {
 		
 	}
 
 	/* 
 	 * 列表查询页面处理方法，需要在子类中使用@ListDomain或@Domain来定义Domain类支持该实现
 	 * @see gboat2.base.bridge.action.IBaseAction#list()
 	 */
 	public String list() {
 		Map<String,Object> queryMap = getListParameterMap();
 		initList(queryMap);
 		
 		if(StringUtils.isNotBlank(sortField)) {
 		    if(!"asc".equalsIgnoreCase(sortDirection) && !"desc".equalsIgnoreCase(sortDirection)) {
 		        sortDirection = "asc";
 		    }
 		    String orderBy = sortField + " " + sortDirection;
 		    String orderBy_old = (String) queryMap.get(QuerySupport.PARAM_ORDERBY);
 		    if(StringUtils.isNotBlank(orderBy_old)) {
 		        Matcher matcher = Pattern.compile("\\b" + sortField.trim() + "\\b(\\s*$|\\s+(asc|desc))?", Pattern.CASE_INSENSITIVE).matcher(orderBy_old);
 		        if(matcher.find()) { // 通过点击表头排序的字段和原先预设的排序字段有重名的情况
 		            orderBy = orderBy + "," + matcher.replaceFirst("");
 		        } else {
 		            orderBy = orderBy + "," + orderBy_old;
 		        }
 		    }
 		    queryMap.put(QuerySupport.PARAM_ORDERBY, orderBy.replaceFirst(",\\s*$", ""));
 		}
 		
 		executeListQuery(queryMap);
 		postList(page);
 		
 		return "list";
 	}
 	
 	public void ajaxListData(){
 		
 	}
 
 	protected void executeListQuery(Map<String,Object> queryMap) {
 		if (!getDomainClassAnnotationedForList().getName().equals(NoQuery.class.getName())) {
 			page = getServiceAnnotationed().getAsPage(queryMap);
 			// 默认记住页面的路径
 			page.getPageBean().setCurrentPageUrl(request.getRequestURI());
 		}
 	}
 
 	protected final Map<String, Object> getListParameterMap() {
 		if (listParameterMap == null) {
 			final Map<String,Object> params = request.getParameterMap();
 			listParameterMap = new HashMap<String, Object>(params);
 			listParameterMap.put(QuerySupport.PARAM_TABLENAME, getDomainClassAnnotationedForList().getName());
 			listParameterMap.put(QuerySupport.PARAM_SOURCE_MAP, params);
 		}
 		return listParameterMap;
 	}
 
 	protected void initList(Map<String, Object> params) {
 
 	}
 
 	protected void postList(Page<?> pageinfo) {
 
 	}
 
 	/* (non-Javadoc)
 	 * @see gboat2.base.bridge.action.IBaseAction#save()
 	 */
 	public String save() {
 		saveModel();
 		
  		// 如果指定了"save-success"则转向到"save-success"配置的页面
 		if (this.getClass().isAnnotationPresent(Results.class)) {
 			Results rses = this.getClass().getAnnotation(Results.class);
 			for (Result rs : rses.value()) {
 				if (rs.name().equals("save-success")) {
 					return rs.name();
 				}
 			}
 		}
 
 		// 未指定save-success，则转向到默认列表页面
 		try {
 			response.sendRedirect(getDefaultListUri());
 			return null;
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 		return  "redirect:" + getDefaultListUri();
 	}
 
 	/**
 	 * desktop的Ajax保存处理
 	 * @return null
 	 */
 	public String ajaxSave() {
 	
 		try {
 			saveModel();
 			Object model = getModel();
 			GboatAppContext.output(JsonResult.createSuccess(new Object[]{ajaxSaveReturn(model)}));
 		} catch (Exception e) {
 			logger.error(e.toString(), e);
 			GboatAppContext.output(JsonResult.createFailure(e.getMessage()));
 		}
 		return null;
 	}
 
 	public Object ajaxSaveReturn(Object model) {
 		return  Collections.singletonMap("SID", getUuid(model));
 	}
 
 	private String getUuid(Object model) {
 		String uuid = null;
 		Method[] methods = model.getClass().getMethods();
 		for (Method method : methods) {
 			if (method.isAnnotationPresent(Id.class)) {
 				try {
 					uuid = (String) method.invoke(model, new Object[] {});
 				} catch (IllegalArgumentException e) {
 					e.printStackTrace();
 				} catch (IllegalAccessException e) {
 					e.printStackTrace();
 				} catch (InvocationTargetException e) {
 					e.printStackTrace();
 				}
 				break;
 			}
 		}
 		return uuid;
 	}
 
 	protected final void saveModel() {
 		initSave();
 
 		IBaseService service = getServiceAnnotationed();
 		Class<?> serviceClass = service.getClass();
 		Class<?> domainClass = getDomainClassAnnotationed();
 
 		Method overrideMethod = ReflectionUtils.findMethod(this.getClass(), "saveModel", new Class[] { domainClass });
 		if (overrideMethod != null) {
 			ReflectionUtils.invokeMethod(overrideMethod, this, new Object[] { model });
 			logger.debug("called saveModel(" + domainClass.getSimpleName() + ")......");
 		} else {
 			// 判断主键值是否为空
 			boolean isPrimaryKeyNull = true;
 			if (domainClass.isAnnotationPresent(Entity.class)) {
 				Method[] methods = domainClass.getMethods();
 				for (Method m : methods) {
 					if (m.getName().startsWith("get") && m.isAnnotationPresent(Id.class)) {
 						try {
 							Object priKey = m.invoke(model, new Object[] {});
 							if (priKey != null) {
 								if (priKey instanceof String) {
 									isPrimaryKeyNull = ((String) priKey).equals("") ? true : false;
 								} else if (priKey instanceof Integer) {
 									isPrimaryKeyNull = ((Integer) priKey).intValue() == 0 ? true : false;
 								} else {
 									isPrimaryKeyNull = false;
 								}
 								break;
 							}
 						} catch (Exception e) {
 							e.printStackTrace();
 							throw new RuntimeException(e);
 						}
 					}
 				}
 			} else {
 				throw new RuntimeException("Now only support Hibernate configured by annotation. No @Entity at " + domainClass.getName());
 			}
 
 			if (isPrimaryKeyNull) {
 				//判断是否存在saveXxxxx方法
 				String methodName = "save" + domainClass.getName().substring(domainClass.getName().lastIndexOf(".") + 1);
 				Method method = ReflectionUtils.findMethod(serviceClass, methodName, new Class[] { domainClass });
 				if (method != null) {
 					ReflectionUtils.invokeMethod(method, service, new Object[] { model });
 					logger.debug("called " + methodName + " ......");
 				} else {
 					service.save(model);
 				}
 			} else {
 				//判断是否存在updateXxxxx方法
 				String methodName = "update" + domainClass.getName().substring(domainClass.getName().lastIndexOf(".") + 1);
 				Method method = ReflectionUtils.findMethod(serviceClass, methodName, new Class[] { domainClass });
 				if (method != null) {
 					ReflectionUtils.invokeMethod(method, service, new Object[] { model });
 					logger.debug("called " + methodName + " ......");
 				} else {
 					service.update(model);
 				}
 			}
 		}
 
 		postSave();
 	}
 
 	protected void initSave() {
 
 	}
 
 	protected void postSave() {
 
 	}
 
 	/* (non-Javadoc)
 	 * @see com.opensymphony.xwork2.Preparable#prepare()
 	 */
 	@Override
 	public final void prepare() throws Exception {
 	    Class<?> clazz = this.getClass();
 	    String invokeMethodName = ActionContext.getContext().getActionInvocation().getProxy().getMethod();
 		logger.debug("prepare {}: {}......", clazz.getName(), invokeMethodName);
 
         Map<String, Object> param = request.getParameterMap();
         boolean getForMetadata = param.containsKey("metadata") && StringUtils.isEmpty(request.getParameter("metadata"));
         // 获取 metadata 不进行权限判断（此处是为了兼容老版本的代码）
         if (!getForMetadata) {
             if (!priorityCheck()) {
                 throw new NoPrivilegeException("你没有操作权限！");
             }
             //根据SID是否存在来判断是否对数据有操作权限
             if (!StringUtils.isEmpty(SID) && !priorityDataCheck()) {
                 throw new NoPrivilegeException("你没有当前数据的操作权限！");
             }
         }
 
         // 为 Action 注入 Spring Bean
         while (clazz != BaseActionSupport.class) {
             setAutowiredBeans(clazz.getDeclaredFields(), clazz);
             clazz = clazz.getSuperclass();
         }
         
         // 往 ActionContext 中存入一些调试信息
         putDebugInfoIfDevMode();
         
         boolean getForData = param.containsKey("data") && StringUtils.isEmpty(request.getParameter("data"));
         boolean getForComponent = param.containsKey("component") && StringUtils.isEmpty(request.getParameter("component"));
         // 不是获取元数据（metadata、data、component）时，执行 initXxx() 方法
         if (!(getForMetadata || getForData || getForComponent)) {
             invokeInitMethod(invokeMethodName);
         }
 	}
 
 	//操作权限检查
 	private boolean priorityCheck() {
 		List<IOperaPrivilegeCheckService> priCheckServiceList = PrivilegeCheckServiceFactory.getPrivilegeSerivce();
 		if (null != priCheckServiceList && priCheckServiceList.size() == 0) {
 		    GboatAppContext.output(JsonResult.createFailure("对不起，当前系统权限验证尚未准备就绪，请稍后再试"));
 		}
 		Method method;
 		try {
 			//获取要执行的Action的方法
 			String invokeMethod = ActionContext.getContext().getActionInvocation().getProxy().getMethod();
 			String privilegeMethod = invokeMethod;
 			//ajaxDelete与delete的权限相等
 			if (privilegeMethod.startsWith("ajax")) {
 				privilegeMethod = String.valueOf(Character.toLowerCase(privilegeMethod.charAt(4))) + privilegeMethod.substring(5);
 			}
 			method = this.getClass().getMethod(invokeMethod);
 			//只有被Operation或者Operations注解注释的方法才需要权限校验
 			if (ModuleService.isMethodOperationAnnotationed(this.getClass(), method, privilegeMethod)) {
 				if (null != priCheckServiceList && priCheckServiceList.size() > 0) {
 					for (IOperaPrivilegeCheckService pcs : priCheckServiceList) {
 						//为防止数据被覆盖，设置为传入的参数为不可修改
 						priCheckParams.put("ACTION_NAME", this.getClass().getName());
 						priCheckParams.put("METHOD_NAME", privilegeMethod);
 						priCheckParams.put("REQUEST", request);
 						priCheckParams.put("USER_SESSION", request.getSession().getAttribute("COM.GLODON.SSO.SESSION.KEY"));
 						//priCheckParams.put("MODEL", getModel());
 						boolean checkResult = pcs.privilegeCheckServiceByMethodName(Collections.unmodifiableMap(priCheckParams), GBoatClassLoader
 								.getInstance().getBundle(this.getClass().getPackage().getName()));
 						logger.debug("check " + this.getClass().getName() + "." + invokeMethod + " in prepare : " + checkResult);
 						//有一个校验不通过，都算没有权限
 						if (!checkResult) {
 							return false;
 						}
 					}
 				}
 			}
 
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (NoSuchMethodException e) {
 			e.printStackTrace();
 		}
 		return true;
 	}
 
 	//数据权限校验
 	private boolean priorityDataCheck() {
 		List<IDataPrivilegeCheckService> dataPriCheckServiceList = PrivilegeCheckServiceFactory.getDataPrivelegeService();
 		Method method;
 		try {
 			//获取要执行的Action的方法
 			String invokeMethod = ActionContext.getContext().getActionInvocation().getProxy().getMethod();
 			String privilegeMethod = invokeMethod;
 			if (privilegeMethod.startsWith("ajax")) {
 				privilegeMethod = String.valueOf(Character.toLowerCase(privilegeMethod.charAt(4))) + privilegeMethod.substring(5);
 			}
 			method = this.getClass().getMethod(invokeMethod);
 			//只有被Operation或者Operations注解注释的方法才需要权限校验
 			if (ModuleService.isMethodOperationAnnotationed(this.getClass(), method, privilegeMethod)) {
 				if (null != dataPriCheckServiceList && dataPriCheckServiceList.size() > 0) {
 					for (IDataPrivilegeCheckService pcs : dataPriCheckServiceList) {
 						//为防止数据被覆盖，设置为传入的参数为不可修改
 						priCheckParams.put("ACTION_NAME", this.getClass().getName());
 						priCheckParams.put("METHOD_NAME", invokeMethod);
 						priCheckParams.put("REQUEST", request);
 						priCheckParams.put("USER_SESSION", request.getSession().getAttribute("COM.GLODON.SSO.SESSION.KEY"));
 						priCheckParams.put("MODEL", getModel());
 						boolean checkResult = pcs.privilegeCheckServiceByMethodName(Collections.unmodifiableMap(priCheckParams), GBoatClassLoader
 								.getInstance().getBundle(this.getClass().getPackage().getName()));
 						;
 						//有一个校验不通过，都算没有权限
 						if (!checkResult) {
 							return false;
 						}
 					}
 				}
 			}
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (NoSuchMethodException e) {
 			e.printStackTrace();
 		}
 		return true;
 	}
 	
 	private Bundle getBundle(String bundleName) {
 		Bundle[] bs = context.getBundles();
 		for (Bundle b : bs) {
 			if (b.getSymbolicName().equals(bundleName)) {
 				return b;
 			}
 		}
 		return null;
 	}
 	
 	/**
 	 * 对action扩展，Business的注入处理，
 	 */
 	protected void setAutowiredBeans(Field[] fields, Class<?> clazz) throws Exception {
 		Bundle bundle =  FrameworkUtil.getBundle(clazz);
 		Map<String, String> pomMap = Activator.pomCache.get(bundle.getSymbolicName());
 		boolean project = MapUtils.getBoolean(pomMap, Activator.HEADER_PROJECT_ENABLED, false);
 		String bundles =  MapUtils.getString(pomMap, Activator.HEADER_EXTENDER_BUNDLES, "");
 		
 		for (Field field : fields) {
             if (!field.isAccessible()) {
                 field.setAccessible(true);
             }
 
 		    if((project && field.get(this) != null) || (!project && field.getType().getName().lastIndexOf("Business") == -1 && field.get(this) != null)) // 如果字段已经有值了， 则不再进行注入，直接跳过
 		        continue;
 		 
 		    // project为true是项目bundle
 			String[] b = bundles.split(",");
 			if (project) {
 				if (!setValue(field, bundle)) {
 					for (int i = 0; StringUtils.isNotEmpty(bundles) && i < b.length; i++) {
 						Bundle bundleExt = getBundle(b[0]);
 						if (setValue(field, bundleExt)) 
 							break;
 					}
  				}
 			}else {
 				boolean flag = false;
 				for (int i = 0; StringUtils.isNotEmpty(bundles) && i < b.length; i++) {
 					Bundle bundleExt = getBundle(b[0]);
 					if (setValue(field, bundleExt)) {
 						flag = true;
 						break;
 					}
 				}
 				if (!flag) {
 					setValue(field, bundle);
 				}
 			}
 		}
 	}
 	
 	protected boolean setValue(Field field, Bundle bundle) throws Exception {
 		if (bundle == null) return false;
 		 Resource resource = field.getAnnotation(Resource.class);
 		 Object value = null;
 		 
 		 try {
 			if(resource != null) { // @Resource
 		        String name = resource.name();
 		        Class<?> requiredType = resource.type();
 		        SpringContextUtil spring = SpringContextUtil.getInstance();
 		        if(StringUtils.isNotBlank(name) && !Object.class.equals(requiredType)) {
 		            // 同时按 bean 的 id 和需要的类型匹配
 		            value = spring.getBeanOfId(name, bundle, requiredType);
 		        } else if (StringUtils.isNotBlank(name)) {
 		            // 按 bean 的 id 匹配
 		            value = spring.getBeanOfId(name, bundle);
 		        } else if (!Object.class.equals(requiredType)) {
 		            // 按需要的类型匹配
 		            value = spring.getBeanOfType(requiredType, bundle);
 		        } else {
 		            // 按字段的类型匹配
 		            value = spring.getBeanOfType(field.getType(), bundle);
 		        }
 		    } else {
 		        Autowired autowired = field.getAnnotation(Autowired.class);
 		        if(autowired != null) { // @Autowired
 		            value = SpringContextUtil.getInstance().getBeanOfType(field.getType(), bundle);
 		            /*
 		         if (value == null && autowired.required())
 		             throw new RuntimeException(this.getClass().getName() + " 的字段 [" + field.getType().getName() + " " + field.getName() + "] 使用了 @Autowired 注解， 并且 required=true， 但没有找到匹配类型的 bean");
 		         */
 		        }
 		    }
 		} catch (Exception e) {
 			logger.debug("{} bundle autowired not found object", bundle.getSymbolicName());
 			return false;
 		}
 		    
 	    if(value != null) {
          logger.debug("set autowired for {} {} : {}", field.getType().getName(), field.getName(), value);
 	        field.set(this, value);
 	        return true;
 	    }
 	    return false;
 	}
 
 	protected void setAutowiredBeans(Field[] fields, Bundle bundle) throws Exception {
 		for (Field field : fields) {
             if (!field.isAccessible()) {
                 field.setAccessible(true);
             }
 		    if(field.get(this) != null) // 如果字段已经有值了， 则不再进行注入，直接跳过
 		        continue;
 		    
 		    Object value = null;
 		    Resource resource = field.getAnnotation(Resource.class);
 		    if(resource != null) { // @Resource
 		        String name = resource.name();
 		        Class<?> requiredType = resource.type();
 		        SpringContextUtil spring = SpringContextUtil.getInstance();
 		        if(StringUtils.isNotBlank(name) && !Object.class.equals(requiredType)) {
 		            // 同时按 bean 的 id 和需要的类型匹配
 		            value = spring.getBeanOfId(name, bundle, requiredType);
 		        } else if (StringUtils.isNotBlank(name)) {
 		            // 按 bean 的 id 匹配
 		            value = spring.getBeanOfId(name, bundle);
 		        } else if (!Object.class.equals(requiredType)) {
 		            // 按需要的类型匹配
 		            value = spring.getBeanOfType(requiredType, bundle);
 		        } else {
 		            // 按字段的类型匹配
 		            value = spring.getBeanOfType(field.getType(), bundle);
 		        }
 		    } else {
 		        Autowired autowired = field.getAnnotation(Autowired.class);
 		        if(autowired != null) { // @Autowired
 		            value = SpringContextUtil.getInstance().getBeanOfType(field.getType(), bundle);
 		            /*
                     if (value == null && autowired.required())
                         throw new RuntimeException(this.getClass().getName() + " 的字段 [" + field.getType().getName() + " " + field.getName() + "] 使用了 @Autowired 注解， 并且 required=true， 但没有找到匹配类型的 bean");
                     */
 		        }
 		    }
 		    
 		    if(value != null) {
                 logger.debug("set autowired for {} {} : {}", field.getType().getName(), field.getName(), value);
 		        field.set(this, value);
 		    }
 		}
 	}
 
 	/**
 	 * @return 当前执行的 Action 所在的 Bundle
 	 */
 	protected Bundle getActionBundle() {
 	    if(actionBundle == null) {
 	        actionBundle = FrameworkUtil.getBundle(this.getClass());
 	    }
 		return actionBundle;
 	}
 
 	/**
 	 * 请求 Action 时， 在调用真正被请求的方法之前， 先调用该方法的初始化方法（如果存在的话）， xxx() 方法对应的初始化方法为 initXxx()。
 	 * <p>
 	 * <i>注意： 如果子类重写了本类的 edit(), view(), list(), save() 方法，则在请求这四个方法时，对应的 initXxx() 方法不会被执行。</i>
 	 * </p>
 	 * @param invokeMethodName 真正要请求的方法的名称
 	 */
 	@SuppressWarnings("rawtypes")
     protected void invokeInitMethod(String invokeMethodName){
         String[] ignores = new String[] { "edit", "view", "list", "save" };
         for (String ignore : ignores) {
             if (ignore.equals(invokeMethodName)) // 需要忽略的方法直接返回
                 return;
         }
         
         String initMethodName = ActionUtil.getInitMethodName(invokeMethodName);
         Method initMethod = null;
         Object[] initMethodArgs = null;
         if(ActionUtil.isListPage(invokeMethodName, this)) { // 如果是列表查询的方法，则 initXxx() 方法会有一个 Map 参数
             initMethod = ReflectionUtils.findMethod(this.getClass(), initMethodName, Map.class);
             if(initMethod != null) {
                 initMethodArgs = new Object[] { new LinkedHashMap(request.getParameterMap())  };  
             }
         } else { // 非列表查询的方法的 initXxx() 方法没有参数
             initMethod = ReflectionUtils.findMethod(this.getClass(), initMethodName);
             if(initMethod != null) {
                 initMethodArgs = new Object[0];
             }
         }
         
         // 不存在 initXxx() 方法 或 initXxx() 方法为私有（private）时直接返回
         if (initMethod == null || Modifier.isPrivate(initMethod.getModifiers()))
             return;
         
         if(!initMethod.isAccessible()) {
             initMethod.setAccessible(true);
         }
         // 调用 initXxx()
         ReflectionUtils.invokeMethod(initMethod, this, initMethodArgs);
     }
 	
 	/** 
 	  * 默认转到列表页
 	  * @see com.opensymphony.xwork2.ActionSupport#execute() 
 	  * @return 返回forward
 	  */
     @Override
 	public String execute() throws DefaultBusinessNestedException {
 		return list();
 	}
     
     /**
      * 转发到指定的 JSP 页面， 通过名称为 go 的参数指定需要跳转的路径，在跳转之前会执行 initXxx() 方法（如果 initXxx() 方法存在的话）
      * @return
      */
     public String forward() {
         go = StringUtils.trimToEmpty(go).replace('\\', '/');
         if(go.length() == 0)
             return null;
         
         // 老版本的平台，有的 Action 中只定义了 initXxx()，而没有定义 xxx() 方法，在跳转到对应的页面之前先执行对应的 initXxx() 方法
         int index = go.lastIndexOf('/');
         String resultCode = (index < 0 ? go : go.substring(index+1));
         if(flatResultLayout) {
             String simpleName = StringUtils.removeEnd(this.getClass().getSimpleName(), "Action");
             // UserGroupAction --> user-group-
             String prefix = (simpleName.charAt(0) + simpleName.substring(1).replaceAll("[A-Z]", nameSeparator + "$0")).toLowerCase() + nameSeparator;
             if(resultCode.startsWith(prefix)) {
                 resultCode = resultCode.substring(prefix.length());
             }
         }
         
         Matcher matcher = Pattern.compile(nameSeparator.replaceAll("[$()*+.\\[?\\^{|]", "\\\\$0")).matcher(resultCode);
         String methodName = null;
         int start = 0;
         while(matcher.find()) {
             if(methodName == null) {
                 methodName = Character.toLowerCase(resultCode.charAt(0)) + resultCode.substring(1, matcher.start());
             } else {
                 methodName += WordUtils.capitalize(resultCode.substring(start, matcher.start()));
             }
             start = matcher.end();
         }
         methodName += WordUtils.capitalize(resultCode.substring(start));
         invokeInitMethod(methodName);
         
         return go;
     }
 
 	/** 
 	  * 根据 metadataType 类型选择相应的处理类
 	  */
     @Override
 	public Object getMetadata(String metadataType, String invokeMethod) {
 		MetadataSupportStrategy metadataSupportStrategy;
 		if (metadataType.equals("metadata")) {
 			metadataSupportStrategy = ObtainMetadata.getInstance();
 		} else if (metadataType.equals("data")) {
 			metadataSupportStrategy = ObtainData.getInstance();
 		} else {
 			metadataSupportStrategy = ObtainOthers.getInstance();
 		}
 		return metadataSupportStrategy.getMetadata(metadataType, invokeMethod, this);
 	}
 
 	/**
 	 * 根据数据检查list中操作是否可见,如果有此方面的需求 请覆盖此方法，todo 方法应该定义为抽象
 	 * @param data 当前行中数据
 	 * @param operationCode 操作code
 	 * @return 是否展示操作，展示 返回 true ，否则 返回false
 	 */
 	public boolean operationCheck(Object data, String operationCode) {
 		return true;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.apache.struts2.osgi.interceptor.BundleContextAware#setBundleContext(org.osgi.framework.BundleContext)
 	 */
     @Override
 	public void setBundleContext(BundleContext context) {
 		this.context = context;
 	}
 
     @Override
 	public void setServletResponse(HttpServletResponse response) {
 		this.response = response;
 	}
 
 	@Override
 	public void setServletRequest(HttpServletRequest request) {
 		this.request = request;
 	}
 
     @Override
 	public void setServletContext(ServletContext servletContext) {
 		osgiHost = (OsgiHost) servletContext.getAttribute(StrutsOsgiListener.OSGI_HOST);
 	}
 
 	/**
 	 * 获取视图的扩展路径，返回不为空时视图文件名称为“example-edit-extend.md”
 	 * @return
 	 */
 	protected String getExtendForView() {
 		return "";
 	}
 
 	/**
 	 * 获取Model对象
 	 * @return 返回当前model
 	 */
 	public Object getModel() {
 		if (model == null) {
 			try {
 				prepareModel();
 			} catch (Exception e) {
 				logger.error(e.getMessage(), e.getCause());
 			}
 		}
 		return model;
 	}
 
 	public void setModel(Object model) {
 		this.model = model;
 	}
 
 	/**
 	 * 不符合方法命名规范，暂时这样
 	 * 用于绑定的简写，使用"_M"等同于"model"
 	 * @return 返回当前model
 	 */
 	public Object get_M() {
 		return getModel();
 	}
 
 	public void set_M(Object _M) {
 		this.model = _M;
 	}
 
 	/**
 	 * 拼装默认的列表页面URI
 	 * 
 	 * @return 列表页面URI
 	 */
 	public String getDefaultListUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!list.do");
 
 		return forwardUrl.toString();
 	}
 
 	/**
 	 * 获得默认的保存页面URI
 	 * @return 保存页面URI
 	 */
 	public String getDefaultSaveUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!save.do");
 		return forwardUrl.toString();
 	}
 
 	public String getDefaultAjaxSaveUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!ajaxSave.do");
 
 		return forwardUrl.toString();
 	}
 
 	/**
 	 * 获得默认的编辑页面URI
 	 * @return 编辑页面URI
 	 */
 	public String getDefaultEditUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!edit.do");
 
 		return forwardUrl.toString();
 	}
 
 	/**
 	 * 获得默认的查看页面URI
 	 * @return 查看页面URI
 	 */
 	public String getDefaultViewUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!view.do");
 
 		return forwardUrl.toString();
 	}
 
 	/**
 	 * 获得默认的删除请求URI
 	 * @return 删除请求URI
 	 */
 	public String getDefaultDeleteUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!delete.do");
 
 		return forwardUrl.toString();
 	}
 
 	public String getDefaultAjaxDeleteUri() {
 		StringBuffer forwardUrl = getUriPrefix();
 		forwardUrl.append("!ajaxDelete.do");
 
 		return forwardUrl.toString();
 	}
 
 	/**
 	 * 获取uri路径的前缀，如ExampleAction的前缀为example，参照convention的约定规则
 	 * @return
 	 */
 	public StringBuffer getUriPrefix() {
 		StringBuffer forwardUrl = new StringBuffer();
 		Class<?> clazz = this.getClass();
 		String className = clazz.getName().replace(clazz.getPackage().getName() + ".", "");
 		className = className.replaceAll("Action$", "");
 		Pattern pattern = Pattern.compile("[A-Z][a-z]*");
 		Matcher ma = pattern.matcher(className);
 		String matched;
 		while (ma.find()) {
 			matched = ma.group();
 			if (forwardUrl.length() > 0) {
 				forwardUrl.append("-");
 			}
 			forwardUrl.append(matched.substring(0, 1).toLowerCase() + matched.substring(1));
 		}
 		return forwardUrl;
 	}
 
 	/**
 	 * 功能：根据接口获取外部bundle中的服务实现
 	 * @param interfaceName
 	 * @deprecated
 	 * @return
 	 */
 	public Object getBean(String interfaceName) {
 		BundleContext bundleContext = context;
 		Object service = bundleContext.getService(bundleContext.getServiceReference(interfaceName));
 		return service;
 	}
 
 	/**
 	 * 功能：根据接口获取外部bundle中的服务实现
 	 * @param interfaceName
 	 * @author zhangxj-a
 	 * @return
 	 */
 	public <T> T getBean(Class<T> interfaceClass) {
 		BundleContext bundleContext = context;
 		T service = (T) bundleContext.getService(bundleContext.getServiceReference(interfaceClass.getName()));
 		return service;
 	}
 
 	public String getSID() {
 		return SID;
 	}
 
 	public void setSID(String sID) {
 		SID = sID;
 	}
 
 	public Page<?> getPage() {
 		return this.page;
 	}
 
 	public Map<Object,Object> getPriCheckParams() {
 		return priCheckParams;
 	}
 
 	public void setPriCheckParams(Map<Object,Object> priCheckParams) {
 		this.priCheckParams = priCheckParams;
 	}
 
 	/**
 	 * 往 ActionContext 实例中存放一些调试信息
 	 */
 	protected void putDebugInfoIfDevMode() {
 	    ActionContext actionContext = ActionContext.getContext();
         actionContext.put(MIN_SUFFIX, (devMode ? "" : ".min"));
         
 	    DefaultDebugHook debugHook = DefaultDebugHook.getInstance(); 
 		String bundleName = getActionBundle().getSymbolicName();
 		if (debugHook.isBundleDebugEnabled(bundleName)) {
 		    actionContext.put(CURRENT_BUNDLE_RES_LOCATION, debugHook.getSourceFilePath(bundleName, "/"));
 		}
 	}
 
 	public final String get_MdId() {
 		return _MdId;
 	}
 
 	public final void set_MdId(String mdId) {
 		_MdId = mdId;
 	}
 
 	public String getSortField() {
         return sortField;
     }
 
     public void setSortField(String sortField) {
         this.sortField = sortField;
     }
 
     public String getSortDirection() {
         return sortDirection;
     }
 
     public void setSortDirection(String sortDirection) {
         this.sortDirection = sortDirection;
     }
 
     public void setGo(String go) {
         this.go = go;
     }
 
     @Override
 	public void setServices(List services) {
 		// TODO Auto-generated method stub
 	}
 }