项目中js调用service和procedure的办法

Ajax.js

/**通用ajax服务的定义对象

 * services可以是单个服务对象，也可以是service服务数组
 * 具体服务的定义请参考appendServices成员函数
 */
function Service(services){
    this.services=[];
    this.shareParameters={};
    /**添加共享参数，在这里统一设置共享参数
     */
    this.addShareParameters=function(shareParameters){
        this.shareParameters=shareParameters;
        return this;
    };
    /**
     * 批量调用一般服务

     * 入参可以是一个调用服务的数组或者单个调用服务

     * 每个调用服务有下面的属性

     * serviceId 服务Id，不可为空

     * method 服务方法名，不可为空
     * parameters 服务参数，必须是object，object的属性名代表参数名，属性值代表参数值。

     * transform：结果集的转换规则（返回结果集合List<Map<String,Object>>时才会用到）：null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写 
     * shareResults 共享服务的返回结果，默认不共享false，如果后续服务需要使用到结果里面的参数，
     *   那么就需要明确指定。该参数可以是 boolean,array或者object，为true时表示全部共享；
     *   数组可以指定返回值中需要共享的值的名，这样返回值的键值对应关系共享；
     *   object可以额外指定共享名的别名，当要求返回值以新的字段名共享、

     *   或者一个以多个新别名共享时就需要用到这种类型，object的属性名表示结果集中需要共享的字段名，
     *   属性值表示新的字段名；

     *   参数共享处理列表结果集时，整个结果集的数据存放在别名为空串的特殊key上。如果本业务没有返回结果，那么参数共享无效。

     * useShare 使用共享参数标志，定义方式与shareResults一样，意义正好想对应。该参数指明如果从共享参数中获取要的值。

     * shareNotNull 校验共享参数是否为空，作为useShare的附属属性。

     *   有时希望如果获取到的共享参数是空的，那么不继续执行，那么可以在这里指定哪些一定不能为空。

     *   目前只允许三种取值，null,true和别名数组，null表示不校验，true表示全校验，别名数组表示只校验指定的值（别名是指useShare中新的别名，并非共享池里面的共享别名）。

     */
    this.appendServices=function(services){
        if(!services){
            return this;
        }
        //默认按批量形式添加服务，如果是单个，那么用数组包装

        var tmp_services=services;
        if(!$.isArray(tmp_services)){
            tmp_services = [tmp_services];
        }
        //每个service必须有serviceId，method
        for(index in tmp_services){
            //检查必录项
            if(!tmp_services[index].serviceId||!tmp_services[index].method){
                FWalert('服务定义的serviceId和method不可为空');
                return this;
            }
            //检查可选项
            if(tmp_services[index].parameters){
                if(typeof tmp_services[index].parameters !='object'
                    ||jQuery.isArray(tmp_services[index].parameters)){
                    FWalert('服务定义的参数必须是map！');
                    return;
                }
            }
            //如果指定了transform，那么值只能是规定的

            if(tmp_services[index].transform){
                if('FIRSTROW'!=tmp_services[index].transform.toUpperCase()
                        &&'BREAKDOWN'!=tmp_services[index].transform.toUpperCase()){
                    FWalert('transform属性不正确');
                    return this;
                }
            }
            //shareResults
            //转换shareResults，统一转换成map，或者boolean
            shareResults = tmp_services[index].shareResults;
            if(shareResults){
                if(typeof shareResults =='boolean'){
                    if(!shareResults){
                        shareResults =null;
                    }
                }else if(jQuery.isArray(shareResults)){
                    //转化为map
                    shareResults={};
                    $.each(tmp_services[index].shareResults,function(indexInArray, valueOfElement){
                        shareResults[valueOfElement]=valueOfElement;
                    });
                    tmp_services[index].shareResults =shareResults;
                }
            }
            //useShare
            useShare = tmp_services[index].useShare;
            if(useShare){
                if(typeof useShare =='boolean'){
                    if(!useShare){
                        tmp_services[index].useShare =null;
                    }
                }else if(jQuery.isArray(useShare)){
                    //转化为map
                    useShare={};
                    $.each(tmp_services[index].useShare,function(indexInArray, valueOfElement){
                        useShare[valueOfElement]=valueOfElement;
                    });
                    tmp_services[index].useShare =useShare;
                }
            }
            //shareNotNull，只允许true和字符串数组
            shareNotNull = tmp_services[index].shareNotNull;
            if(shareNotNull){
                if(typeof shareNotNull !=='boolean' && !jQuery.isArray(shareNotNull)){
                    FWalert('参数[shareNotNull]的取值必须是true或者字符串数组！');
                    return this;
                }else if(shareNotNull ===false){
                    tmp_services[index].shareNotNull = null;
                }
            }
        }
        this.services=this.services.concat(tmp_services);
        return this;
    };
    /**定义添加直接调用存储过程的服务

     * 可以批量添加存储过程。每个存储过程服务的有以下属性：
     * procName、parameters、shareResults、useShare，

     * 其中procName指明存储过程的名称，其他的请参考appendServices；parameters中的参数名不能是procName
     * 批量添加存储过程时，用数组存储各个存储过程作为参数传入即可。

     * ...
     */
    this.appendProc=function(procedures){
        if(!procedures){
            return this;
        }
        //默认按批量形式添加服务，如果是单个，那么用数组包装

        tmp_procedures=procedures;
        if(!$.isArray(tmp_procedures)){
            tmp_procedures = [tmp_procedures];
        }
        //遍历，一个一个的处理
        procedure_services =[];
        for (index in tmp_procedures){
            //必须有configId属性

            procedure = tmp_procedures[index];
            if(!procedure.procName){
                FWalert('存储过程服务必须指定procName属性');
                return this;
            }
            procedure = $.extend(true,{},procedure,
                    {serviceId:'directJdbcService',method:'savePointProcedure'
                        ,parameters:{'':procedure.procName}});
            //去掉存储过程名称
            delete procedure.procName;
            //添加到服务列表

            procedure_services.push(procedure);
        }
        return this.appendServices(procedure_services);
    };
    /**定义添加调用预定义查询语句的服务
     * 可以批量添加查询语句。每个查询服务的包括以下属性：
     * configId、transform、indices，parameters、shareResults、useShare。

     * configId是Mapper.xml中的配置ID(注意写上空间名)
     * parameters是传递给configId的参数

     * transform：结果集的转换规则：null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写

     * ，该参数要求传入字符串数组类型，元素值指明参数Map中的一个参数名。

     * 其它属性将作为查询语句的备用参数。其他的请参考appendServices；

     * 批量添加查询服务时，用数组存储各个查询服务作为参数传入即可。

     * ...
     */
    this.appendQuery=function(querys){
        if(!querys){
            return this;
        }
        //默认按批量形式添加服务，如果是单个，那么用数组包装

        tmp_querys=querys;
        if(!$.isArray(tmp_querys)){
            tmp_querys = [tmp_querys];
        }
        //遍历，一个一个的处理
        query_services = [];
        for (index in tmp_querys){
            //必须有configId属性

            var query = tmp_querys[index];
            if(!query.configId){
                FWalert('查询服务必须指定configId属性');
                return this;
            }
            //参数索引放入参数串中
            query = $.extend(true,{},query,
                    {serviceId:'commService',method:'query'
                        ,parameters:{'_commDo':query.configId}});
            
            //去掉存储过程名称，和参数索引
            delete query.configId;
            
            //添加到服务列表

            query_services.push(query);
        }
        return this.appendServices(query_services);
    };
    /**定义触发ajax的事件

     * message:本次ajax请求的名称，可选。

     * success:处理成功后触发的函数，原型是function(data)。

     * error:处理是否时触发的函数，原型是function(XMLHttpRequest, textStatus, errorThrown);
     * async：同步或是异步，同步为false、异步是true
     */
    this.sentAjax=function(message,success,error,async){
        if(this.services.length==0){
            FWalert('请至少添加一个服务');
            return;
        }
        var t_async = true;
        var t_message = message;
        var t_success = success;
        var t_error = error;
        if(jQuery.isFunction(message)){
            t_message = '正在请求服务，请稍候...';
            t_success =message;
            t_error = success;
        }else if (typeof message != 'string'){
            FWalert('入参错误，请检查程序！');
            return ;
        }
        if(async!=null&&typeof async=='boolean'){
            if(!async){
                t_async = false;
            }
        }
        var thisrequest={};
         $.ajax({
            url:contextPath+'/ajax.do'
            ,data:{parameters:JSON.stringify(this.services),shareArguments:JSON.stringify(this.shareParameters)}
            ,dataType :'json'
            ,cache:false
            ,async:t_async
            ,type:'post'
            ,error:function (request, textStatus, errorThrown) {
                if(!t_error){
                    FWalert('数据请求错误！');    
                }else{
                    t_error(request, textStatus, errorThrown);
                }
                }
            ,success:function (data, textStatus) {
                //校验业务处理是否正确执行
                if("1"!=data.FHZ){//出错了，弹出错误提醒
                    if ("loginTimeout" == data.FHZ) {
                        if(window.confirm(data.MSG||'')){
                            window.top.location.href=_selfUrl;
                        }
                    } else {
                        if(t_error){
                            t_error(data.MSG||'', 'serviceErr', data.MSG);
                        }else{
                            FWalert(data.MSG||'');
                        }
                    }
                }else if(!t_success){
                }else{
                    t_success(data.RTN);
                }
            }
            ,beforeSend:function( ){
                $.data(thisrequest,'msg',showMsg(t_message,-1));
                //createProgressBar();
            }
            ,complete:function( ){
                hideMsg($.data(thisrequest,'msg'));
            }
         });
    };
    //添加参数
    if(services){
        this.appendServices(services);
    }
}
/**
* 在页面的左上角显示错误消息

* @param msg 消息内容
* @param timeout 秒为单位,0或者负数表示不自动隐藏
* @author 吴英德

**/
var framework_message_layer;
var clearIntervalID;
function showMsg(msg,delay){

    var recurrectLocation=function(){
        if(framework_message_layer==null)
                {clearInterval(clearIntervalID);return;}
            var posX,posY;
        if (window.innerHeight) {
            posX = window.pageXOffset;
            posY = window.pageYOffset;
        }
        else if (document.documentElement && document.documentElement.scrollTop) {
            posX = document.documentElement.scrollLeft;
            posY = document.documentElement.scrollTop;
        }
        else if (document.body) {
            posX = document.body.scrollLeft;
            posY = document.body.scrollTop;
        }
        framework_message_layer.style.top=String(posY+10)+'px';
        framework_message_layer.style.right=String(posX+10)+'px';
    };
    if(framework_message_layer == null){
        framework_message_layer=document.createElement('div');
        framework_message_layer.className='err_message_blank_board';
        document.body.appendChild(framework_message_layer);
        clearIntervalID=window.setInterval(recurrectLocation,100);
        recurrectLocation();
    }
    var my_div = document.createElement('div');
    my_div.className='err_message';
    //Element.extend(my_div);
    my_div.innerHTML=msg;
    framework_message_layer.appendChild(my_div);
    recurrectLocation();
    if(delay>0){
        setTimeout(function(){
            jQuery(my_div).remove();
            if(jQuery(framework_message_layer).is(':empty')){
                jQuery(framework_message_layer).remove();
                window.clearInterval(clearIntervalID);
                framework_message_layer=null;
            }
        },delay*1000);
    }else{
        return my_div;
    }
}

/**隐藏右上角对应的消息
 * @param object 某消息对象，来自showMsg的返回值

 */
function hideMsg(object){
    jQuery(object).remove();
}

AjaxAction:

package cn.sinobest.framework.web;

import cn.sinobest.framework.comm.iface.IDTO;
import cn.sinobest.framework.comm.iface.IOperator;
import cn.sinobest.framework.service.CommService;
import cn.sinobest.framework.service.json.JSONUtilities;
import cn.sinobest.framework.service.tags.TreeService;
import cn.sinobest.framework.util.DTOUtil;
import cn.sinobest.framework.util.Util;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;

@Scope("prototype")
public class AjaxAction extends BaseActionSupport {
    private static Logger log = Logger.getLogger(AjaxAction.class);
    private static final long serialVersionUID = 1L;
    private InputStream inputStream;
    @Autowired
    TreeService treeService;
    @Autowired
    CommService commService;

    public InputStream getInputStream() {
        return this.inputStream;
    }

    public String execute() throws Exception {
        /**
         * getValue是从封装好的ajax中获取的，如项目中的身份证修改js中的sentAjax,实际上
         * 这个sentAjax是封装了的，具体的在ajax.js中的256行的data，这个data是一个json字符串，
         * 这个json字符串有两个属性，一个是parameters，一个是shareArguments，
         * 正好在这个execute()方法里通过request.getParameters可以获取到ajax中发过来的
         * 这两个参数
         */
        
        /**
         * 封装的$.sentAjax具体如下
         * $.ajax({
            url:contextPath+'/ajax.do'
            ,data:{parameters:JSON.stringify(this.services),shareArguments:JSON.stringify(this.shareParameters)}
            ,dataType :'json'
            ,cache:false
            ,async:t_async
            ,type:'post'
            ,error:function (request, textStatus, errorThrown) {
                if(!t_error){
                    FWalert('数据请求错误！');    
                }else{
                    t_error(request, textStatus, errorThrown);
                }
                }
            ,success:function (data, textStatus) {
                //校验业务处理是否正确执行
                if("1"!=data.FHZ){//出错了，弹出错误提醒
                    if ("loginTimeout" == data.FHZ) {
                        if(window.confirm(data.MSG||'')){
                            window.top.location.href=_selfUrl;
                        }
                    } else {
                        if(t_error){
                            t_error(data.MSG||'', 'serviceErr', data.MSG);
                        }else{
                            FWalert(data.MSG||'');
                        }
                    }
                }else if(!t_success){
                }else{
                    t_success(data.RTN);
                }
            }
            ,beforeSend:function( ){
                $.data(thisrequest,'msg',showMsg(t_message,-1));
                //createProgressBar();
            }
            ,complete:function( ){
                hideMsg($.data(thisrequest,'msg'));
            }
         });
         */
//        var proParams ={
//                PI_AAC002:aac002,
//                PI_AAC002_NEW:aac002n,
//                PI_AAE013:aae013,
//                PI_AAE011:aae011,
//                PI_BAE001:bae001
//                };
////        var mm = new WeiAjax('hha').hint();
////        alert(typeof mm);
//        
//                new Service().appendProc({
//                    procName:'pkg_weiyl.updateIDCard',
//                    parameters:proParams
//                }).sentAjax('正在进行数据处理',function(datass){
//                    if(datass[0]['PO_FHZ'] !='1'){
//                        alert(datass[0]['PO_FHZ']+"  "+ datass[0]['PO_MSG']);
//                    }else{
//                        closeWindow();
//                        getListData('glt_sfzxg',' 1=0 ');
//                        alert('身份证修改成功');
////                        setTimeout(alert('身份证修改成功'),1000);
//                    }
//                },function(data){
//                    docx();
//                    getListData('glt_sfzxg',' 1=0 ');
//                    closeWindow();
//                    alert("修改失败");},false);
        
        String inParameters = (String) getValue("parameters");
        String inShareParameters = (String) getValue("shareParameters");
        Map<String, Object> actionResult = new HashMap();
        try {
            Object[] inParams = (Object[]) JSONUtilities.parseJSON(inParameters);
            Map[] params = (Map[]) null;
            /**
             *  绝对不会为空，因为这是 比如miposdz_test.js中
             *   serviceCl.appendServices({
                    serviceId: 'miposdzService',
                    method: 'insertData',
                    parameters: {
                    CRXX: path
                }
                }).sentAjax('正在请求服务',function(){
                    ...;
                },function(){
                    ...;
                },false);
                中的入参，即 
                {
                    serviceId: 'miposdzService',
                    method: 'insertData',
                    parameters: {
                    CRXX: path
                }
                这个对象
             * 
             * 
             */
            if (inParams != null) {
                params = (Map[]) Util.toTypedArray(inParams, Map.class);
            }
            Map<String, Object> shareArguments = null;
            if (inShareParameters.length() > 0) {
                shareArguments = (Map) JSONUtilities.parseJSON(inShareParameters);
            } else {
                shareArguments = new HashMap();
            }
            /**
             * 所以 params不可能为空， 这里在dto里以 parameters 为键，  以 
             * {
                    serviceId: 'miposdzService',
                    method: 'insertData',
                    parameters: {
                    CRXX: path
                }
                为值
             * 
             */
            this.dto.setValue("parameters", params);
            /**
             *  shareParameters :可能为空
             */
            this.dto.setValue("shareParameters", shareArguments);
            Object rtn = this.commService.doAjaxService(this.dto);

            actionResult.put("RTN", rtn);
            actionResult.put("FHZ", "1");
        } catch (Exception e) {
            log.warn(null, e);
            actionResult.put("FHZ", e.getLocalizedMessage());
            actionResult.put("MSG", e.getLocalizedMessage());
            String url = this.request.getRequestURI();
            String operId = "";
            if (DTOUtil.getUserInfo() != null) {
                operId = DTOUtil.getUserInfo().getOperID();
            }
            this.commService.storeException(url, DTOUtil.getDTO(), operId, e);
        }
        StringBuffer rstString = new JSONUtilities(1).parseObject(actionResult);
        this.inputStream = new ByteArrayInputStream(rstString.toString().getBytes());
        return "success";
    }
}

CommService.java

 package cn.sinobest.framework.service;
 
 import cn.sinobest.framework.comm.dto.DTO;
 import cn.sinobest.framework.comm.exception.AppException;
 import cn.sinobest.framework.comm.iface.IDAO;
 import cn.sinobest.framework.comm.iface.IDTO;
 import cn.sinobest.framework.comm.iface.IOperator;
 import cn.sinobest.framework.comm.transcation.DataSourceCallBack;
 import cn.sinobest.framework.comm.transcation.IDataSourceCallBack;
 import cn.sinobest.framework.dao.CommDAO;
 import cn.sinobest.framework.dao.workflow.WfActionDef;
 import cn.sinobest.framework.dao.workflow.WfWorkItem;
 import cn.sinobest.framework.service.json.JSONUtilities;
 import cn.sinobest.framework.service.tags.WfService;
 import cn.sinobest.framework.service.workflow.IWorkflow.Attr;
 import cn.sinobest.framework.service.workflow.IWorkflow.ProcStartOrEnd;
 import cn.sinobest.framework.service.workflow.IWorkflow.RightMsg;
 import cn.sinobest.framework.service.workflow.IWorkflowService;
 import cn.sinobest.framework.util.ConfUtil;
 import cn.sinobest.framework.util.DateUtil.CurDate;
 import cn.sinobest.framework.util.Util;
 import java.lang.reflect.Array;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 @Service("commService")
 public class CommService
 {
   private static final Logger LOGGER = LoggerFactory.getLogger(CommService.class);
   public static final String COMM_DO = "_commDo";
   public static final String ACTION_AFTER = "_afterAction";
   public static final String ACTION_BEFORE = "_beforeAction";
   public static final String DS = "_ds";
   @Autowired
   private CommDAO commDAO;
   
   static enum Transform
   {
     FIRSTROW,  BREAKDOWN;
   }
   
   private static enum ExecType
   {
     MAPSQL,  PROCEDURE,  SERVICE;
   }
   
   private static enum MapSQLSuffix
   {
     I("_I"),  D("_D"),  U("_U"),  NONE("");
     
     private String suffix = "";
     
     private MapSQLSuffix(String suffix)
     {
       this.suffix = suffix;
     }
     
     public String getName()
     {
       return this.suffix;
     }
   }
   
   private class ExecMsg
   {
     private CommService.ExecType execType;
     private String execStr;
     private String objectName = "";
     private String methodName = "";
     
     private ExecMsg() {}
     
     public String getObjectName()
     {
       return this.objectName;
     }
     
     public void setObjectName(String objectName)
     {
       this.objectName = objectName;
     }
     
     public String getMethodName()
     {
       return this.methodName;
     }
     
     public void setMethodName(String methodName)
     {
       this.methodName = methodName;
     }
     
     public CommService.ExecType getExecType()
     {
       return this.execType;
     }
     
     public void setExecType(CommService.ExecType execType)
     {
       this.execType = execType;
     }
     
     public String getExecStr()
     {
       return this.execStr;
     }
     
     public void setExecStr(String execStr)
     {
       this.execStr = execStr;
     }
   }
   
   private int insert(String sqlId, Map<String, ?> paramsMap)
     throws Exception
   {
     return this.commDAO.insert(sqlId, paramsMap);
   }
   
   private int delete(String sqlId, Map<String, ?> paramsMap)
     throws Exception
   {
     return this.commDAO.delete(sqlId, paramsMap);
   }
   
   private int update(String sqlId, Map<String, ?> paramsMap)
     throws Exception
   {
     return this.commDAO.update(sqlId, paramsMap);
   }
   
   public List<Map<String, Object>> query(IDTO dto)
     throws Exception
   {
     String sqlId = (String)dto.getData().get("_commDo");
     return this.commDAO.select(sqlId, dto.getData());
   }
   
   private Map<String, Object> doOneService(ExecMsg executeMsg, IDTO dto)
     throws Throwable
   {
     String doActionCode = "";
     String actionMsg = "没有执行任何操作";
     Map<String, Object> paramsMap = dto.getData();
     Map<String, Object> rtnMap = new HashMap();
     String rtnURL = (String)paramsMap.get("_rtnURL");
     StringBuffer wfRtnURL = new StringBuffer(100);
     String wId = "";
     String pId = "";
     Object rtnObj = null;
     boolean startFlag = false;
     boolean nextFlag = false;
     boolean commitFlag = false;
     boolean isSubWf = ((Boolean)(paramsMap.get("_isSubWf") == null ? Boolean.valueOf(false) : paramsMap.get("_isSubWf"))).booleanValue();
     paramsMap.put("_isSubWf", Boolean.valueOf(isSubWf));
     Util.nvl(paramsMap);
     
     String wfDefineID = (String)paramsMap.get("_processDefId");
     String curActDefID = (String)paramsMap.get("_curActDefId");
     String workItemId = (String)paramsMap.get("wid");
     String wfState = ((String)Util.nvl(paramsMap.get("_wfState"))).toLowerCase();
     String pInsId = (String)paramsMap.get("pid");
     String keyData = (String)paramsMap.get("_keyData");
     String wfBZ = (String)paramsMap.get("_comment");
     String accepter = (String)paramsMap.get("_accepterId");
     String nextActDefID = (String)paramsMap.get("_nextActDefId");
     String isWfStart = ((String)(paramsMap.get("_isWfStart") != null ? paramsMap.get("_isWfStart") : "false")).toLowerCase();
     String jar = (String)paramsMap.get("_operId");
     LOGGER.info("/*******传入流程参数******************************/");
     LOGGER.info("_processDefId=" + wfDefineID);
     LOGGER.info("_curActDefId=" + curActDefID);
     LOGGER.info("_nextActDefId=" + nextActDefID);
     LOGGER.info("wid=" + workItemId);
     LOGGER.info("_wfState=" + wfState);
     LOGGER.info("_isWfStart=" + isWfStart);
     LOGGER.info("pid=" + pInsId);
     LOGGER.info("_accepterId=" + accepter);
     LOGGER.info("_keyData=" + keyData);
     LOGGER.info("_comment=" + wfBZ);
     LOGGER.info("/************end*********************************/");
     
     Map<String, String> respParams = new HashMap();
     
     IWorkflowService wfService = (IWorkflowService)Util.getBean("workflowService");
     if ("true".equals(isWfStart))
     {
       if ("wf".equals(wfState))
       {
         doActionCode = "001";
         actionMsg = "【001开始流程】";
         LOGGER.info(actionMsg);
         respParams = wfService.startWf(wfDefineID, paramsMap);
         pId = (String)respParams.get("pid");
         wId = (String)respParams.get("wid");
         if ((pId != null) && (pId.length() > 0)) {
           startFlag = true;
         }
         if (startFlag) {
           commitFlag = true;
         }
       }
       else if ("data".equals(wfState))
       {
         doActionCode = "002";
         actionMsg = "【002开始流程,保存数据】";
         LOGGER.info(actionMsg);
         
         respParams = wfService.startWf(wfDefineID, paramsMap);
         pId = (String)respParams.get("pid");
         wId = (String)respParams.get("wid");
         paramsMap.put("pid", pId);
         if ((pId != null) && (pId.length() > 0)) {
           startFlag = true;
         }
         rtnObj = doOperService(executeMsg, dto);
         if (startFlag) {
           commitFlag = true;
         }
       }
       else if ("all".equals(wfState))
       {
         doActionCode = "003";
         actionMsg = "【003开始流程,保存数据,提交下一环节】";
         LOGGER.info(actionMsg);
         
         respParams = wfService.startWf(wfDefineID, paramsMap);
         
         pId = (String)respParams.get("pid");
         wId = (String)respParams.get("wid");
         paramsMap.put("pid", pId);
         if ((pId != null) && (pId.length() > 0)) {
           startFlag = true;
         }
         rtnObj = doOperService(executeMsg, dto);
         
 
         nextFlag = wfService.submitWorkItem(pId, wId, paramsMap);
         if ((startFlag) && (nextFlag))
         {
           pId = (String)paramsMap.get("pid");
           wId = (String)paramsMap.get("wid");
           commitFlag = true;
         }
       }
     }
     else
     {
       pId = pInsId;
       wId = workItemId;
       if ("wf".equals(wfState))
       {
         if (("".equals(pId)) || ("".equals(wId))) {
           throw new AppException("业务流水号和环节号不能为空!");
         }
         doActionCode = "004";
         actionMsg = "【004提交到下一环节】";
         LOGGER.info(actionMsg);
         
         commitFlag = wfService.submitWorkItem(pId, wId, paramsMap);
         pId = (String)paramsMap.get("pid");
         wId = (String)paramsMap.get("wid");
       }
       else if ("all".equals(wfState))
       {
         if (("".equals(pId)) || ("".equals(wId))) {
           throw new AppException("业务流水号和环节号不能为空!");
         }
         doActionCode = "006";
         actionMsg = "【006保存数据,提交下一环节】";
         LOGGER.info(actionMsg);
         
         rtnObj = doOperService(executeMsg, dto);
         
 
 
 
 
         nextFlag = wfService.submitWorkItem(pId, wId, paramsMap);
         LOGGER.info("提交环节" + (nextFlag ? "成功" : "失败"));
         if (nextFlag)
         {
           pId = (String)paramsMap.get("pid");
           wId = (String)paramsMap.get("wid");
           commitFlag = true;
         }
       }
       else
       {
         doActionCode = "005";
         actionMsg = "【005保存数据】";
         if (!Util.isEmpty(workItemId))
         {
           WfWorkItem wfWorkItem = new WfWorkItem();
           wfWorkItem.setWORK_ITEM_ID(Long.valueOf(Long.parseLong(workItemId)));
           wfWorkItem.setMEMO((String)Util.nvl(wfBZ));
           wfService.updateWorkItem(wfWorkItem);
         }
         LOGGER.info(actionMsg);
         rtnObj = doOperService(executeMsg, dto);
         commitFlag = true;
       }
     }
     if (!commitFlag) {
       throw new AppException("系统错误，数据提交失败！");
     }
     boolean isGD = false;
     if ((!isSubWf) && (pId != null) && (pId.trim().length() > 0))
     {
       String isEnd = "";
       if (!"".equals(nextActDefID))
       {
         WfActionDef wfDef = wfService.getWfByActionDef(wfDefineID, WfService.getNextDefId(nextActDefID));
         if (wfDef == null)
         {
           isEnd = "no";
         }
         else
         {
           isEnd = wfDef.getSTART_OR_END();
           isGD = Boolean.parseBoolean((String)Util.nvl(Util.searchByKey(IWorkflow.Attr.GD.toString(), wfDef.getATTR())));
           String afterAction = (String)Util.nvl(Util.searchByKey("afterAction", wfDef.getATTR()));
           if (!Util.isEmpty(afterAction))
           {
             ExecMsg execMsg = getExecMsg(afterAction);
             rtnObj = doOperService(execMsg, dto);
             pId = (String)dto.getValue("pid");
             wId = (String)dto.getValue("wid");
           }
         }
       }
       String rightId = (String)Util.nvl(wfService.getRightIdByWfDefId(wfDefineID));
       if ((Util.isEmpty(rightId)) && (!Util.isEmpty(wId)))
       {
         Map<String, String> url = wfService.getActionForward(Long.valueOf(wId));
         rightId = (String)url.get(IWorkflow.RightMsg.ID.toString());
       }
       String menuId = (String)Util.nvl(wfService.getRightIdByPid(pId));
       if (("001".equals(doActionCode)) || 
         ("002".equals(doActionCode)) || 
         ("005".equals(doActionCode)))
       {
         Map<String, String> forward = wfService.getActionForward(curActDefID);
         String rightIdStr = (String)forward.get("RIGHTID");
         wfRtnURL.append((String)forward.get(IWorkflow.RightMsg.URL.toString())).append(IWorkflow.RightMsg.URL.toString().indexOf("?") >= 0 ? "&" : "?")
           .append("pid").append("=").append(pId)
           .append("&")
           .append("wid").append("=").append(wId)
           .append("&RightID=").append(rightIdStr)
           .append("&_menuID=").append(menuId)
           .append("&").append("funcID").append("=").append(Util.nvl(forward.get(IWorkflow.RightMsg.BUSSFUNCID.toString())));
       }
       else if (IWorkflow.ProcStartOrEnd.PSE_END.getState().equalsIgnoreCase(isEnd))
       {
         wfRtnURL.append("/jsp/framework/blank.jsp");
       }
       else if (jar.equals(accepter))
       {
         Map<String, String> forward = wfService.getActionForward(curActDefID);
         wfRtnURL.append("/Workflow.do?")
           .append("pid").append("=").append(pId)
           .append("&").append("wid").append("=").append(wId)
           .append("&RightID=").append(rightId)
           .append("&_menuID=").append(menuId)
           .append("&").append("funcID").append("=").append(Util.nvl(forward.get(IWorkflow.RightMsg.BUSSFUNCID.toString())));
       }
       else
       {
         wfRtnURL.append("/jsp/framework/blank.jsp");
       }
       if ((rtnURL.equals("")) || (rtnURL.equalsIgnoreCase("null"))) {
         rtnURL = wfRtnURL.toString();
       }
     }
     Map<String, Object> oMap = uniformResult(rtnObj);
     rtnMap.putAll(oMap);
     
     rtnMap.put("pid", pId);
     rtnMap.put("wid", wId);
     rtnMap.put("_rtnURL", rtnURL);
     rtnMap.put(IWorkflow.Attr.GD.toString(), Boolean.toString(isGD));
     return rtnMap;
   }
   
   private ExecMsg getExecMsg(String execStr)
     throws Exception
   {
     String[] exec = execStr.split("\.");
     String prefx = exec[0];
     ExecMsg execMsg = new ExecMsg(null);
     if (Util.isEmpty(prefx)) {
       throw new AppException("_commDo不合法!");
     }
     if (prefx.lastIndexOf("Service") > 0)
     {
       execMsg.setExecType(ExecType.SERVICE);
       execMsg.setObjectName(prefx);
       execMsg.setMethodName(exec[1]);
       return execMsg;
     }
     if (Util.isMatches(prefx, "^pkg_\w+\.\w+$"))
     {
       execMsg.setExecType(ExecType.PROCEDURE);
       execMsg.setExecStr(execStr);
       return execMsg;
     }
     execMsg.setExecType(ExecType.MAPSQL);
     execMsg.setExecStr(execStr);
     return execMsg;
   }
   
   private Map<String, ?> doExecute(IDTO dto, String execStr)
     throws Throwable
   {
     ExecMsg execMsg = getExecMsg(execStr);
     
     Map<String, Object> rtnMap = null;
     switch (execMsg.getExecType())
     {
     case SERVICE: 
       rtnMap = doOneService(execMsg, dto);
       break;
     case PROCEDURE: 
       rtnMap = doProcedure(execMsg.getExecStr(), dto.getData(), (String)dto.getValue("_ds"));
       break;
     default: 
       switch (getMapSQLSuffix(execMsg.getExecStr()))
       {
       case D: 
         insert(execStr, dto.getData()); break;
       case I: 
         update(execStr, dto.getData()); break;
       case NONE: 
         delete(execStr, dto.getData()); break;
       default: 
         throw new AppException("_commDo中" + execStr + "没有包含后缀_I、_U、_D");
       }
       break;
     }
     return rtnMap;
   }
   
   private MapSQLSuffix getMapSQLSuffix(String execStr)
   {
     String actType = execStr.substring(execStr.lastIndexOf("_"), execStr.lastIndexOf("_") + 2).toUpperCase();
     if (MapSQLSuffix.I.getName().equalsIgnoreCase(actType)) {
       return MapSQLSuffix.I;
     }
     if (MapSQLSuffix.D.getName().equalsIgnoreCase(actType)) {
       return MapSQLSuffix.D;
     }
     if (MapSQLSuffix.U.getName().equalsIgnoreCase(actType)) {
       return MapSQLSuffix.U;
     }
     return MapSQLSuffix.NONE;
   }
   
   public void doService(IDTO dto)
     throws Throwable
   {
     try
     {
       final String[] execStrs = ((String)dto.getData().get("_commDo")).split("\|");
       if (execStrs.length <= 0) {
         throw new AppException("参数_commDo为指定操作");
       }
       final IDTO dto2 = new DTO();
       dto2.setUserInfo(dto.getUserInfo());
       final Map<String, Object> argsMap = Util.mapClone(dto.getData());
       final Map<String, Object> rtnsMap = new HashMap();
       String ds = (String)dto.getValue("_ds");
       if (Util.isEmpty(ds)) {
         for (String exec : execStrs)
         {
           dto2.setData(Util.mapClone(argsMap));
           
 
           Map<String, ?> rtnMap = doExecute(dto2, exec);
           if (rtnMap != null)
           {
             rtnsMap.putAll(rtnMap);
             argsMap.putAll(rtnsMap);
           }
         }
       } else {
         DataSourceCallBack.execute(ds, new IDataSourceCallBack()
         {
           public String doAction()
             throws AppException
           {
             try
             {
               for (String exec : execStrs)
               {
                 dto2.setData(Util.mapClone(argsMap));
                 
 
                 Map<String, ?> rtnMap = CommService.this.doExecute(dto2, exec);
                 if (rtnMap != null)
                 {
                   rtnsMap.putAll(rtnMap);
                   argsMap.putAll(rtnsMap);
                 }
               }
             }
             catch (Throwable e)
             {
               throw new AppException(e.getLocalizedMessage(), e);
             }
             return "";
           }
         });
       }
       dto.setData(rtnsMap);
     }
     catch (Throwable t)
     {
       throw t;
     }
   }
   
   private Object doOperService(ExecMsg executeMsg, IDTO dto)
     throws Throwable
   {
     try
     {
       Object service = Util.getBean(executeMsg.getObjectName());
       Class<?> cls = service.getClass();
       LOGGER.debug("执行service:" + executeMsg.getObjectName() + "." + executeMsg.getMethodName());
       Method method = cls.getMethod(executeMsg.getMethodName(), new Class[] { IDTO.class });
       return method.invoke(service, new Object[] { dto });
     }
     catch (InvocationTargetException e)
     {
       throw e.getTargetException();
     }
   }
   
   public void submitWf(IDTO dto)
     throws AppException
   {
     try
     {
       IWorkflowService wfService = (IWorkflowService)Util.getBean("workflowService");
       if (wfService.submitWorkItem(dto))
       {
         String execStr = (String)dto.getValue("_commDo");
         if (Util.isEmpty(execStr)) {
           return;
         }
         ExecMsg execMsg = getExecMsg(execStr);
         if (execMsg.getExecType() == ExecType.SERVICE) {
           doOperService(execMsg, dto);
         } else {
           throw new AppException("未指定要执行业务处理的Serivce对象！");
         }
       }
     }
     catch (AppException e)
     {
       throw e;
     }
     catch (Throwable e)
     {
       throw new AppException("提交任务失败!", e);
     }
   }
   
   private Map<String, Object> doProcedure(String procedureName, Map<String, ?> values, String dataSource)
     throws Exception
   {
     JdbcCallService service = (JdbcCallService)Util.getBean("jdbcCallService");
     return service.doProcedure(procedureName, values, dataSource);
   }
   
   public List<Object> doAjaxService(IDTO dto)
     throws AppException
   {
     Map[] parameters = (Map[])dto.getValue("parameters");
     Map<String, Object> shareArguments = (Map)dto.getValue("shareParameters");
     if (LOGGER.isDebugEnabled())
     {
       LOGGER.debug("处理ajax业务，入参串是：" + new JSONUtilities().parseObject(parameters));
       LOGGER.debug(">>>共享参数是：" + shareArguments);
     }
     List<Object> resultList = new ArrayList();
     for (Map<String, Object> serviceMap : parameters)
     {
       String serviceId = (String)serviceMap.get("serviceId");
       String methodName = (String)serviceMap.get("method");
       Object useShare = serviceMap.get("useShare");
       Object shareNotNull = serviceMap.get("shareNotNull");
       String transform = (String)serviceMap.get("transform");
       Map dtoData = dto.getData();
       if ((serviceId.length() == 0) || (methodName.length() == 0)) {
         throw new AppException("EFW0001", null, new Object[] { "serviceId和method" });
       }
       Map<String, Object> serviceParameters = (Map)serviceMap.get("parameters");
       
       Map<String, Object> arguments = new HashMap();
       if ((shareArguments != null) && (useShare != null))
       {
         if (Boolean.TRUE.equals(useShare)) {
           arguments.putAll(shareArguments);
         } else {
           for (Map.Entry<String, Object> entry : ((Map)useShare).entrySet())
           {
             Object value = entry.getValue();
             if ((value instanceof Collection)) {
               for (String c_value : (Collection)value) {
                 arguments.put(c_value, shareArguments.get(entry.getKey()));
               }
             } else {
               arguments.put((String)value, shareArguments.get(entry.getKey()));
             }
           }
         }
         if (shareNotNull != null) {
           if (Boolean.TRUE.equals(shareNotNull))
           {
             for (Map.Entry<String, Object> entry : arguments.entrySet())
             {
               if (entry.getValue() == null) {
                 throw new AppException("EFW0001", null, new Object[] { entry.getKey() });
               }
               if (((entry.getValue() instanceof String)) && 
                 (((String)entry.getValue()).length() == 0)) {
                 throw new AppException("EFW0001", null, new Object[] { entry.getKey() });
               }
             }
           }
           else
           {
             int arrayLength = Array.getLength(shareNotNull);
             for (int i = 0; i < arrayLength; i++)
             {
               Object one = Array.get(shareNotNull, i);
               if (one != null)
               {
                 String str = one.toString();
                 Object value = arguments.get(str);
                 if (value == null) {
                   throw new AppException("EFW0001", null, new Object[] { str });
                 }
                 if (((value instanceof String)) && 
                   (((String)value).length() == 0)) {
                   throw new AppException("EFW0001", null, new Object[] { str });
                 }
               }
             }
           }
         }
       }
       if (serviceParameters != null) {
         arguments.putAll(serviceParameters);
       }
       dto.getData().clear();
       
       dto.getData().putAll(dtoData);
       
       dto.setData(arguments);
       
       Object service = Util.getBean(serviceId);
       Object cls = service.getClass();
       LOGGER.debug("执行" + serviceId + "." + methodName);
       
       Object rst = null;
       try
       {
         Method method = ((Class)cls).getMethod(methodName, new Class[] { IDTO.class });
         rst = method.invoke(service, new Object[] { dto });
       }
       catch (SecurityException e)
       {
         throw new AppException("无访问权限", e);
       }
       catch (InvocationTargetException e)
       {
         throw new AppException(e.getTargetException().getMessage(), e.getTargetException());
       }
       catch (NoSuchMethodException e)
       {
         throw new AppException(serviceId + "中未找到方法" + methodName, e);
       }
       catch (IllegalArgumentException e)
       {
         throw new AppException("非法参数", e);
       }
       catch (IllegalAccessException e)
       {
         throw new AppException("非法访问", e);
       }
       Method method;
       if ((rst != null) && ((rst instanceof List)) && (!((List)rst).isEmpty()) && (transform != null)) {
         switch (Transform.valueOf(transform.toUpperCase()))
         {
         case BREAKDOWN: 
           rst = ((List)rst).get(0);
           break;
         default: 
           rst = breakDown((List)rst);
         }
       }
       resultList.add(rst);
       if ((rst != null) && (serviceMap.get("shareResults") != null))
       {
         Object shareResult = serviceMap.get("shareResults");
         if (!Boolean.FALSE.equals(shareResult)) {
           if (Boolean.TRUE.equals(shareResult))
           {
             Object t = uniformResult(rst);
             if (t != null) {
               shareArguments.putAll(uniformResult(rst));
             }
           }
           else
           {
             Map<String, Object> resultMap = uniformResult(rst);
             for (Map.Entry<String, Object> entry : ((Map)shareResult).entrySet())
             {
               Object value = entry.getValue();
               if ((value instanceof Collection)) {
                 for (String c_value : (Collection)value) {
                   shareArguments.put(c_value, resultMap.get(entry.getKey()));
                 }
               } else {
                 shareArguments.put((String)value, resultMap.get(entry.getKey()));
               }
             }
           }
         }
       }
     }
     return resultList;
   }
   
   public Map<String, String> startWf(IDTO dto)
     throws AppException
   {
     String SERVER_OBJECT = "object";
     
 
 
     String SERVER_METHOD = "method";
     
 
     Map<String, Object> params = dto.getData();
     String processDefId = (String)params.get("_processDefId");
     String keyData = (String)params.get("_keyData");
     String OPERID = (String)params.get("_operId");
     if (Util.isEmpty(processDefId)) {
       throw new AppException("未指定流程定义ID,key=_processDefId");
     }
     if (Util.isEmpty(OPERID))
     {
       if (dto.getUserInfo() == null) {
         throw new AppException("未指定经办人,key=_operId");
       }
       dto.setValue("_operId", dto.getUserInfo().getLoginID());
     }
     if (Util.isEmpty(keyData)) {
       LOGGER.warn("未指定关键信息,key=_keyData");
     }
     try
     {
       String commDo = (String)params.get("_commDo");
       String wfstate = (String)params.get("_wfState");
       
       String serverObject = (String)params.get("object");
       String serverMethod = (String)params.get("method");
       if (Util.isEmpty(wfstate))
       {
         wfstate = "wf";
       }
       else
       {
         if (Util.isEmpty(commDo)) {
           commDo = serverObject + "." + serverMethod;
         }
         if (Util.isEmpty(commDo)) {
           LOGGER.warn("未指定_commDo");
         }
       }
       dto.setValue("_isWfStart", params.get("_isWfStart"));
       dto.setValue("_wfState", wfstate);
       dto.setValue("_isSubWf", Boolean.valueOf(true));
       dto.setValue("_commDo", commDo);
       CommService commService = (CommService)Util.getBean("commService");
       commService.doService(dto);
       Map<String, String> respMap = new HashMap();
       respMap.put("pid", (String)dto.getValue("pid"));
       respMap.put("wid", (String)dto.getValue("wid"));
       return respMap;
     }
     catch (Throwable e)
     {
       LOGGER.error("开启流程失败，详细：" + e.getMessage(), e);
       throw new AppException("开启流程失败，详细：" + e.getMessage(), e);
     }
   }
   
   private Map<String, Object> breakDown(List<Map<String, Object>> rst)
   {
     if ((rst == null) || (rst.isEmpty())) {
       return null;
     }
     Object row = rst.get(0);
     
     Map<String, Object> rest = new HashMap();
     for (String key : ((Map)row).keySet()) {
       rest.put(key, new ArrayList(rst.size()));
     }
     for (Map.Entry<String, Object> key : ((Map)row).entrySet()) {
       ((Collection)rest.get(key.getKey())).add(key.getValue());
     }
     return rest;
   }
   
   private Map<String, Object> uniformResult(Object rst)
   {
     if ((rst instanceof Map)) {
       return (Map)rst;
     }
     if ((rst instanceof List)) {
       return Collections.singletonMap("", rst);
     }
     return Collections.singletonMap("", rst);
   }
   
   public void storeException(String url, IDTO dto, String operId, Throwable e)
   {
     try
     {
       if ("1".equals(ConfUtil.getParam("STORE_EXCEPTION")))
       {
         LOGGER.debug("保存异常信息到FW_LOG4EXCEPTION表");
         IDAO dao = (IDAO)Util.getBean("commDAO");
         
         StringBuffer ex = new StringBuffer();
         if (e != null)
         {
           ex.append(e.getLocalizedMessage());
           StackTraceElement[] st = e.getStackTrace();
           for (StackTraceElement ste : st) {
             ex.append(ste.toString());
           }
         }
         String exStr = ex.toString();
         if (exStr.getBytes().length > 1333) {
           exStr = Util.subStringByte(exStr, 1333);
         }
         String paramStr = "";
         if (dao != null)
         {
           dto.getData().remove("struts.valueStack");
           dto.getData().remove("struts.actionMapping");
           dto.getData().remove("CharacterEncodingFilter.FILTERED");
           dto.getData().remove("__cleanup_recursion_counter");
           dto.getData().remove("org.springframework.web.context.request.RequestContextListener.REQUEST_ATTRIBUTES");
           dto.getData().remove("OPERATOR");
           JSONUtilities jsonUtil = new JSONUtilities();
           paramStr = jsonUtil.parseObject(dto.getData()).toString();
         }
         if (paramStr.getBytes().length > 1333) {
           paramStr = Util.subStringByte(paramStr, 1333);
         }
         Object err = new HashMap(5);
         ((Map)err).put("EXCEPTIONSTACK", exStr);
         ((Map)err).put("URL", (String)Util.nvl(url));
         ((Map)err).put("PARAMS", paramStr);
         ((Map)err).put("OPERID", (String)Util.nvl(operId));
         ((Map)err).put("EVENTTIME", DateUtil.CurDate.YYYYMMDDHHmmss.getDate());
         dao.insert("FW_CONFIG.FW_LOG4EXCEPTION_I", (Map)err);
       }
     }
     catch (Exception ex)
     {
       LOGGER.error(ex.getLocalizedMessage(), ex);
     }
   }
   
   public <T> T autoActoin(IDataSourceCallBack<T> action)
   {
     return action.doAction();
   }
 }