nc 系统 发送 XML

package nc.impl.scp.com;


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


import nc.bs.framework.common.NCLocator;
import nc.bs.logging.Logger;
import nc.jdbc.framework.SQLParameter;
import nc.jdbc.framework.processor.BeanListProcessor;
import nc.pub.scp.com.IComConst;
import nc.pub.scp.com.IDataOperateConst;
import nc.pub.scp.com.IDataTypeConst;
import nc.pub.uapbd.FormulaTool;
import nc.vo.pub.BusinessException;
import nc.vo.pub.SuperVO;
import nc.vo.scp.basicdata.BasicDataOperate;
import nc.vo.scp.err.ErrVO;


/**
 * 下载服务实现类通用方法提供者
 * 
 * @author:Rain
 * @time:2015-3-28 下午11:14:50
 */
public abstract class DownLoadCommDeal extends CommDeal {


protected String OPERATE_SQL = "select * from scp_basicdata_operate where isnull(dr,0) = 0 and isnull(bsucceed,'N') = 'N' and data_type = ? order by operate_time asc";
protected nc.itf.scp.pub.IBasicDataOperate operateService = null;


public DownLoadCommDeal() throws BusinessException {
operateService = NCLocator.getInstance().lookup(
nc.itf.scp.pub.IBasicDataOperate.class);
}


private DataSend dataSendHandler = DataSend.getInstances();


protected abstract String getHeaderVOClass();


protected String getBodyVOClass() {
return null;
}


protected boolean bHaveBodyDom() {
return false; // 默认只处理表头List数据到XML
}


/**
* 将特殊符号转意成XML语言中字符
* 
* @param strString
* @return
*/
public static String turnSpecialString(String strString) {
if (null == strString || "".equals(strString))
return strString;


return strString.replaceAll("<", "&lt;").replaceAll(">", "&gt;")
.replaceAll("&", "&amp;").replaceAll("'", "&apos;")
.replaceAll("\"", "&quot;");
}


/*
* 初始化表头fields
*/
protected String[] initHeadFields() throws BusinessException {
String headerClass = getHeaderVOClass();
if (null == headerClass)
throw new BusinessException("但没有设置表头VO类型!");


SuperVO obj = null;
try {
obj = (SuperVO) Class.forName(headerClass).newInstance(); // 利用反射实例化对象
} catch (Exception e) {
throw new BusinessException("实例化类" + headerClass + "的对象时失败,具体原因:"
+ e.getMessage());
}
return obj.getAttributeNames();
}


/*
* 初始化表体fields
*/
protected String[] initBodyFields() throws BusinessException {
if (!bHaveBodyDom())
return null;
String bodyClass = getBodyVOClass();


if (null == bodyClass)
throw new BusinessException("需要加载表体VO,但没有设置表体VO类型!");


SuperVO obj = null;
try {
obj = (SuperVO) Class.forName(bodyClass).newInstance();
} catch (Exception e) {
throw new BusinessException("实例化类" + bodyClass + "的对象时失败,具体原因:"
+ e.getMessage());
}
return obj.getAttributeNames();
}


@Override
public String sendDatas(SuperVO[] arrayVO) throws BusinessException {
return sendDataArray(arrayVO);
}

/**
* 将查询结果格式化成xml
* 
* @param list
* @return
* @throws BusinessException
*/
protected String sendDataArray(SuperVO[] arrayVO) throws BusinessException {
if (null == arrayVO || 0 == arrayVO.length)
return null;


List<SuperVO> list = new ArrayList<SuperVO>();
list = Arrays.asList(arrayVO); // 数组转集合


return sendDataList(list);
}


protected String sendDataList(List<SuperVO> headVOList)
throws BusinessException {
return sendDataList(headVOList, IDataOperateConst.OPERATETYPE_ADD);
}


protected String sendDataList(List<SuperVO> headVOList, int operateType)
throws BusinessException {
String maxCountDataXML = null;
if (headVOList.size() > eveSendRecordsMaxCount) {
// 获取max条记录，做为一个list发送,剩余的递归调用本身
List<SuperVO> eve = headVOList.subList(0, eveSendRecordsMaxCount); // 截取本轮需要处理的list数据
maxCountDataXML = formartVOList2XML(eve, operateType);


sendData2SCP(maxCountDataXML); // 将maxCount数据发送


eve = headVOList.subList(eveSendRecordsMaxCount, headVOList.size()); // 余下的待处理list数据


return sendDataList(eve, operateType);// 剩余的递归调用本身


} else {
maxCountDataXML = formartVOList2XML(headVOList, operateType);// 继续处理
return sendData2SCP(maxCountDataXML); // 将小于maxCount的数据发送
}
}


/**
* 对特殊数据类型的处理 本类默认都是简单类型，都取toString,子类如果有需要重写此方法处理
* 
* @param field
*            字段
* @param obj
*            需要处理的数据
* @param bheader
*            是否表头
* @return
*/
protected String dealUserObj(String[] field, Object obj, boolean bheader)
throws BusinessException {
if (null == obj) {
return "";
}
return turnSpecialString(obj.toString());
}


/**
* 将查询结果格式化成xml
* 
* @param headVOList
* @return
* @throws BusinessException
*/
protected String formartVOList2XML(List<SuperVO> headVOList, int operateType)
throws BusinessException {


if (null == headVOList || headVOList.size() == 0)
return XML_HEADER + XML_FOOT;


StringBuffer xmlstr = new StringBuffer();
int tempInt = 0;
String tempObj = null;
String field = null;

String[] headerFields = initHeadFields();
if (null == headerFields || 0 == headerFields.length)
throw new BusinessException("表头VO attributeFields为空,请检查!");

String[] bodyFields = null; 
if (bHaveBodyDom()) {
bodyFields = initBodyFields();
if (null == bodyFields || 0 == bodyFields.length)
throw new BusinessException(
"表体VO attributeFields为空,请检查!");
}

for (SuperVO headVO : headVOList) {
xmlstr.append("<data>");
xmlstr.append("<header>");


tempObj = headVO.getPrimaryKey();
if (null != tempObj && tempObj.indexOf(IComConst.PREFIX) > 0) {
String[] pk_basic$pk = tempObj.split(IComConst.PREFIX);
xmlstr.append("<" + BasicDataOperate.PK_BASICDATA + ">"
+ pk_basic$pk[0] + "</" + BasicDataOperate.PK_BASICDATA
+ ">"); // 中间表数据主键,处理成功后返回便于处理
headVO.setPrimaryKey(pk_basic$pk[1]);
}


tempInt = headVO.getStatus();
if (0 != tempInt) {
xmlstr.append("<operatetype>" + tempInt + "</operatetype>"); // 数据操作类型(1增/-1删/2改)
} else {
xmlstr.append("<operatetype>" + operateType + "</operatetype>");
}




for (int j = 0; j < headerFields.length; j++) {
field = headerFields[j];


if (null == headVO.getAttributeValue(field)) {
if (!turnNullValue(field, true, headVO))
continue;
}


xmlstr.append("<" + field + ">");
String[] param = new String[] { field }; // String是值传递，而String数组是引用传递
xmlstr.append(dealUserObj(param,
headVO.getAttributeValue(field), true)); // 需要考虑特殊数据类型,如String[],CostVO[],List等的处理
field = param[0];
xmlstr.append("</" + field + ">");
//by 王千员  得到生产厂商
if(field.equals("pk_fac")){
xmlstr.append("<pk_fac_name>");
String fieldname=dealUserObj(param,headVO.getAttributeValue(field), true);
String facname=FormulaTool.exeGetColvalue2Fomular("bd_defdoc", "name", "pk_defdoc", fieldname,"dr","0");
xmlstr.append(facname);
xmlstr.append("</pk_fac_name>");
}


}
xmlstr.append("</header>");

// 在此加载bodyVO的信息到XML
if (bHaveBodyDom()) {
List<SuperVO> bodyVOList = getBodyVOList(headVO);
if (null != bodyVOList && bodyVOList.size() > 0) {
xmlstr.append("<bodys>");




for (SuperVO bodyVO : bodyVOList) {
xmlstr.append("<body>");
for (int j = 0; j < bodyFields.length; j++) {
field = bodyFields[j];


if (null == bodyVO.getAttributeValue(field)) {


if (!turnNullValue(field, false, bodyVO))
continue;
}


xmlstr.append("<" + field + ">");
String[] param = new String[] { field };
xmlstr.append(dealUserObj(param,
bodyVO.getAttributeValue(field), false));
field = param[0];
xmlstr.append("</" + field + ">");
}
xmlstr.append("</body>");
}
xmlstr.append("</bodys>");
}
}
xmlstr.append("</data>");
}


if (nc.pub.scp.com.IComConst.BDEBUG) {
Logger.error("scp_xml=" + XML_HEADER + xmlstr.toString() + XML_FOOT);
}


return XML_HEADER + xmlstr.toString() + XML_FOOT;
}


protected List<SuperVO> getBodyVOList(SuperVO headVO)
throws BusinessException {
return null;
}


// 发送数据
public String sendData2SCP(String xmldata) throws BusinessException {
int dataType = getSendDataType();
if (IDataTypeConst.DATA_TYPE_ROLLBACK_ORDER == dataType
|| IDataTypeConst.DATA_TYPE_ROLLBACK_STORAGE == dataType) {
return dataSendHandler.sendData(dataType, xmldata, true);
}
dataSendHandler.sendData(dataType, xmldata);
return null;
}


public String acceptDataDeal(int dataType, String supplierPk, String data)
throws BusinessException {
return myAcceptDataDeal(dataType, supplierPk, data);
}


public String myAcceptDataDeal(int dataType, String supplierPk, String data)
throws BusinessException {


String resu = null;


try {
checkQueryService(); // 检查查询服务对象
resu = selfAcceptDataDeal(supplierPk, data);
} catch (BusinessException ex) {
ErrVO errVO = getScpErrVO();
errVO.setVparam0("" + dataType);
errVO.setVparam1(supplierPk);
errVO.setVparam2(data);


// 记录异常
ScpErrSaveHelper.getInstance().insertScpErr(errVO);


if (bthorwsExp) { // 如果需要抛出异常
throw ex;
}
}
return resu;
}


/**
* 子类自己对请求数据的处理
* 
* @param supplierPk
* @param data
* @return
* @throws BusinessException
*/
protected abstract String selfAcceptDataDeal(String supplierPk, String data)
throws BusinessException;


@Override
public String getSendData() throws BusinessException {
List<SuperVO> list = getChangeData();
if (null == list || list.size() == 0)
return null;
sendDataList(list);
return null;
}


/**
* 需要从变更中间表 查询变更数据
* 
* @return
* @throws BusinessException
*/
@SuppressWarnings("unchecked")
protected List<SuperVO> getChangeData() throws BusinessException {
SQLParameter param = new SQLParameter();
param.addParam(getSendDataType());


List<BasicDataOperate> operateList = (List<BasicDataOperate>) getScpMidBaseDao()
.executeQuery(OPERATE_SQL, param,
new BeanListProcessor(BasicDataOperate.class));


if (null == operateList || operateList.size() == 0) {
return null;
}


setCurrentOrg(operateList.get(0));


checkQueryService(); // 检查查询服务对象
List<SuperVO> list = getChangeData(operateList);
return list;
}


/**
* 检查查询接口是否正常
* 
* @throws BusinessException
*/
public abstract void checkQueryService() throws BusinessException;


protected boolean turnNullValue(String sfield, boolean bheader,
SuperVO superVO) {
return false;
}


protected List<SuperVO> getChangeData(List<BasicDataOperate> operateList)
throws BusinessException {
List<SuperVO> list = new ArrayList<SuperVO>();
for (BasicDataOperate basicDataOperate : operateList) {
SuperVO superVO = getOneOperateData(basicDataOperate);
list.add(superVO);
}
return list;
}


protected SuperVO getOneOperateData(BasicDataOperate basicData)
throws BusinessException {
SuperVO vo = null;
if (IDataOperateConst.OPERATETYPE_DELETE == basicData.getOperate_type()) {
try {
vo = (SuperVO) Class.forName(getHeaderVOClass()).newInstance(); // 利用反射实例化对象
} catch (Exception e) {
throw new BusinessException("实例化headVO出错,具体原因:"
+ e.getMessage());
}
vo.setPrimaryKey(basicData.getPk_data());
} else {
vo = queryOperateDataByPK(basicData.getPk_org(),
basicData.getPk_data());
if (null == vo) {
throw new BusinessException("获取表头VO为空!");
}
}
vo.setStatus(basicData.getOperate_type());
vo.setPrimaryKey(basicData.getPk_basicdata() + IComConst.PREFIX
+ vo.getPrimaryKey());
return vo;
}


// 发送特定的数据
public String sendOneData(String pk_data) throws BusinessException {
if (nc.pub.scp.com.IComConst.BDEBUG) {
Logger.error("orderDeal:pk=" + pk_data);
}
BasicDataOperate basicData = (BasicDataOperate) getScpMidBaseDao()
.retrieveByPK(BasicDataOperate.class, pk_data);
if (null == basicData) {
throw new BusinessException("从中间表获取VO为空!");
}
SuperVO vo = getOneOperateData(basicData);


return sendDataArray(new SuperVO[] { vo });
}


protected abstract SuperVO queryOperateDataByPK(String pk_org,
String pk_data) throws BusinessException;

}

第二个类

package nc.impl.scp.com;


import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.itf.scp.pub.IDataDeal;
import nc.itf.scp.pub.IScpErr;
import nc.pub.scp.com.IComConst;
import nc.pub.scp.com.IParamConst;
import nc.pub.scp.tools.SysParamHelper;
import nc.vo.org.OrgVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.SuperVO;
import nc.vo.pub.lang.UFDate;
import nc.vo.pub.lang.UFDateTime;
import nc.vo.scp.err.ErrVO;


/**
 * 服务实现类通用方法提供者
 * 
 * @author:Rain
 * @time:2015-4-13 16:14:50
 */
public abstract class CommDeal implements IDataDeal,IScpErr {
protected static final String XML_HEADER = "<?xml version=\"1.0\" encoding=\"gb2312\"?><tableset><datas>";
protected static final String XML_FOOT = "</datas></tableset>";

private String pk_group;

protected boolean bthorwsExp = false; //是否往外抛异常

private String defDbName = "design";
private String scpMidDBName; // 数据源名称
protected int eveSendRecordsMaxCount;// 单次发送数据的最大记录数(暂未考虑子表记录数)

public CommDeal() throws BusinessException {
init();
}

//备份当前集团
protected void initInfo(){
pk_group = InvocationInfoProxy.getInstance().getProperty("pk_group");
}

//设置当前集团pk
protected void resetInfo(String pkGroup){
InvocationInfoProxy.getInstance().setProperty("pk_group", pkGroup);
}

//从备份中恢复当前集团
protected void backInfo(){
InvocationInfoProxy.getInstance().setProperty("pk_group", pk_group);
}


/**
* 初始化系统参数
* @throws BusinessException 
*/
protected void init() throws BusinessException {
// scpMidDBName = "design"; // 数据源设置有待优化，从参数取
// eveSendRecordsMaxCount = 100;
scpMidDBName = ConfigHelper.getParamValue("hrp");
//scpMidDBName = SysParamHelper.getSysParam(IComConst.PK_GROUP,IParamConst.SCP10);
String maxCount = SysParamHelper.getSysParam(IComConst.PK_GROUP,IParamConst.SCP11);
eveSendRecordsMaxCount = Integer.parseInt(maxCount);
}

/**
* 获取SCP中间库dao对象
* 
* @return
*/
private BaseDAO baseDao = null;


protected BaseDAO getScpMidBaseDao() {
if (null == baseDao){
baseDao = new BaseDAO(scpMidDBName);
defDbName = scpMidDBName;
ComDatasTemp.getInstances().setDataBaseName(scpMidDBName);
}else{
if(null != scpMidDBName &&!defDbName.equals(scpMidDBName)){  //如果参数变化了，需要重新实例化 dao
baseDao = new BaseDAO(scpMidDBName);
defDbName = scpMidDBName;
ComDatasTemp.getInstances().setDataBaseName(scpMidDBName);
}
}



return baseDao;
}


// 获取本类发生异常时的ErrVO
public ErrVO getScpErrVO() throws BusinessException{
ErrVO errVO = new ErrVO();
errVO.setItype(getSendDataType());
errVO.setPk_group(IComConst.PK_GROUP);

//业务单元
OrgVO orgVO = currentOrgVO;
if(null == orgVO){  //赋默认值
orgVO = getDefaultOrg();
}
errVO.setPk_org(orgVO.getPk_org());
errVO.setPk_org_v(orgVO.getPk_vid());

errVO.setIsendorrecv(nc.vo.scp.err.ErrConst.ISEND);
errVO.setDbilldate(new UFDate());
errVO.setVbilltype("SCPE");
//制单人
String maker = SysParamHelper.getSysParam(IComConst.PK_GROUP,IParamConst.SCP70);
errVO.setCreator(maker);
errVO.setCreationtime(new UFDateTime());
return errVO;
}

protected OrgVO getDefaultOrg() throws BusinessException{
OrgVO orgVO = new OrgVO();
String pk_org = SysParamHelper.getSysParam(IComConst.PK_GROUP,IParamConst.SCP20);
orgVO.setPk_org(pk_org);  //默认业务单元考虑从参数取
// orgVO.setPk_vid("0001M51000000001UVJC");
return orgVO;
}

protected OrgVO currentOrgVO = null;

//设置当前操作的业务单元
protected void setCurrentOrg(SuperVO headVO){
if(null == headVO)
return;
currentOrgVO = new OrgVO();
currentOrgVO.setPk_org((String)headVO.getAttributeValue("pk_org"));
currentOrgVO.setPk_vid((String)headVO.getAttributeValue("pk_org_v"));
}




}