XinYu_LZMES/.svn/pristine/a2/a2a99c2853791016a1e2b93563fc0e67f1f4d168.svn-base

package UIJ.UIJ03;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.sql.Connection;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

//import xin.glue.ui.common.DataSo;


import UIB.COM.XmlSqlParsersFactory;

import CoreFS.SA01.CoreIComponent;

/**
 * 发货实绩录入与发行装车明细
 * 
 * @author zsx
 * @date 2017-10-19
 */
public class UIJ030060 extends CoreIComponent {
	
	private static  Log	logger	=	LogFactory.getLog(UIJ030060.class);

	/**
	 * 根据钢卷号查找炉号或者式样号
	 * @param params
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectSMP 查询炉号或式样号sqlID
	 * @return 返回三期数据库中去重后的炉号或者式样号集合
	 */
	public Set<String> queryCHGOrSMP(ArrayList<String[]> params, Connection connLocal, String sqlIDxg3qSelectCHGOrSMP) {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		Set<String> set = new HashSet<String>();
		String[] param;
		try {
			pstm	=	connLocal.prepareStatement(XmlSqlParsersFactory.getSql(sqlIDxg3qSelectCHGOrSMP));
			for(int i = 0; i < params.size(); i++) {
				param = params.get(i);
				//param[10]为钢卷号
				pstm.setString(1, param[10]);						
				rs = pstm.executeQuery();
				while (rs.next()) {
					set.add(rs.getString(1));
				}
			}
			param = null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(pstm != null) {
				try {
					pstm.close();
					pstm = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return set;
	}
	
	/**
	 * 查找炉号
	 * @param params
	 * @param connLocal 三期数据库连接
	 * @return 返回三期数据库中去重后的炉号集合
	 */
	public Set<String> queryCHG(ArrayList<String[]> params, Connection connLocal) {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		Set<String> set = new HashSet<String>();
		String[] param;
		try {
			String sql = "select substr(slab_no, 1,10) chgNo from c_tbl02_coil_comm where old_sampl_no = ? and rownum = 1 ";
			pstm	=	connLocal.prepareStatement(sql);
			for(int i = 0; i < params.size(); i++) {
				param = params.get(i);
				//param[10]为钢卷号
				pstm.setString(1, param[10]);						
				rs = pstm.executeQuery();
				while (rs.next()) {
					set.add(rs.getString("chgNo"));
				}
			}
			param = null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(pstm != null) {
				try {
					pstm.close();
					pstm = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return set;
	}
	
	/**
	 * 检查优特数据库是否存在该炉号，如果存在则移除Set集合中的该炉号
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectCHG 查询炉号sqlID
	 * @param sqlIDyouteSelectCHG 判断炉号在优特数据库中是否存在sqlID
	 * @return  返回优特数据库中炉号不存在的、且在三期数据库中存在的炉号集合
	 */
	public Set<String> checkCHG(ArrayList<String[]> params, Connection conn, Connection connLocal) {
		//获取三期数据库中的炉号
		Set<String> set = queryCHG(params, connLocal);
		if(set == null) {
			return null;
		}
		if(set.size() == 0) {
			return set;
		}
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			Iterator<String> it = set.iterator();
			String sql = "select HEATNO from IF_RAW_MTR_COIL_CHEM where HEATNO = ? ";
			ps = conn.prepareStatement(sql);
			while (it.hasNext()) {
				ps.setString(1, it.next());	
				rs = ps.executeQuery();
				//如果该炉号在优特数据库中，则在集合中移除该炉号
				if(rs.next()) {
					it.remove();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(ps != null) {
				try {
					ps.close();
					ps = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return set;
	}
	
	/**
	 * 检查优特数据库是否存在该炉号或式样号，如果存在则移除Set集合中的该炉号或式样号
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectCHGOrSMP 查询炉号或样号sqlID
	 * @param sqlIDyouteSelectCHGOrSMP 判断炉号或式样号在优特数据库中是否存在sqlID
	 * @return  返回优特数据库中炉号不存在的、且在三期数据库中存在的炉号集合，
	 * 			或者返回优特数据库中式样号不存在的、且在三期数据库中存在的式样号集合
	 */
	public Set<String> checkCHGOrSMP(ArrayList<String[]> params, Connection conn, Connection connLocal, 
			String sqlIDxg3qSelectCHGOrSMP, String sqlIDyouteSelectCHGOrSMP) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		//获取三期数据库中的炉号或者式样号集合
		Set<String> set = queryCHGOrSMP(params, connLocal, sqlIDxg3qSelectCHGOrSMP);
		if(set == null) {
			return null;
		}
		if(set.size() == 0) {
			return set;
		}
		try {
			Iterator<String> it = set.iterator();
			ps = conn.prepareStatement(XmlSqlParsersFactory.getSql(sqlIDyouteSelectCHGOrSMP));
			while (it.hasNext()) {
				//it.next()为炉号或者式样号
				ps.setString(1, it.next());		
				rs = ps.executeQuery();
				//如果该炉号在优特数据库中，则在集合中移除该炉号
				if(rs.next()) {
					it.remove();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(ps != null) {
				try {
					ps.close();
					ps = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return set;
	}


	/**
	 * 获取优特数据库信息
	 * @param params
	 * @param connLocal 三期数据库连接
	 * @param sqlID xml中的id
	 * @return
	 */
	public ArrayList<Youte> getYoute(ArrayList<String[]> params, Connection connLocal, String sqlID) {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		ArrayList<Youte> list = new ArrayList<Youte>();
		String[] param;
		Youte youte = null;
		try {
			pstm = connLocal.prepareStatement(XmlSqlParsersFactory.getSql(sqlID));
			for (int i = 0; i < params.size(); i++) {
				param = params.get(i);
				//param[10]为钢卷号
				pstm.setString(1, param[10]);
				rs = pstm.executeQuery();
				while (rs.next()) {
					youte = new Youte();
					youte.setOld_sampl_no(rs.getString("OLD_SAMPL_NO"));
					youte.setCoil_source(rs.getString("COIL_SOURCE"));
					youte.setCoil_sort(rs.getString("COIL_SORT"));
					youte.setOrdcust_cd(rs.getString("ORDCUST_CD"));
					youte.setCust_nm(rs.getString("CUST_NM"));
					
					youte.setCharge(rs.getString("CHARGE"));
					youte.setSmp_no(rs.getString("SMP_NO"));
					youte.setPrd_code(rs.getString("PRD_CODE"));
					youte.setPrd_name(rs.getString("PRD_NAME"));
					youte.setStd_code(rs.getString("STD_CODE"));
					
					youte.setStd_name(rs.getString("STD_NAME"));
					youte.setSteel_code(rs.getString("STEEL_CODE"));
					youte.setSteel_name(rs.getString("STEEL_NAME"));
					youte.setCoil_thk(rs.getBigDecimal("COIL_THK"));
					youte.setCoil_wth(rs.getBigDecimal("COIL_WTH"));
					
					youte.setCoil_len(rs.getBigDecimal("COIL_LEN"));
					youte.setCoil_india(rs.getBigDecimal("COIL_INDIA"));
					youte.setCoil_outdia(rs.getBigDecimal("COIL_OUTDIA"));
					youte.setCoil_wgt(rs.getBigDecimal("COIL_WGT"));
					youte.setAct_wgt(rs.getBigDecimal("ACT_WGT"));
					
					youte.setMill_dtime(rs.getString("MILL_DTIME"));
					youte.setFlaw_code1(rs.getString("FLAW_CODE1"));
					youte.setFlaw_code1(rs.getString("FLAW_NAME1"));
					youte.setFlaw_code2(rs.getString("FLAW_CODE2"));
					youte.setFlaw_code2(rs.getString("FLAW_NAME2"));
					
					youte.setFlaw_code3(rs.getString("FLAW_CODE3"));
					youte.setFlaw_code3(rs.getString("FLAW_NAME3"));
					youte.setFlaw_code4(rs.getString("FLAW_CODE4"));
					youte.setFlaw_code4(rs.getString("FLAW_NAME4"));
					youte.setFlaw_code5(rs.getString("FLAW_CODE5"));
					
					youte.setFlaw_code5(rs.getString("FLAW_NAME5"));
					youte.setIngr_dec_grd(rs.getString("INGR_DEC_GRD"));
					youte.setIngr_dec_name(rs.getString("INGR_DEC_NAME"));
					youte.setExtshape_dec_grd(rs.getString("EXTSHAPE_DEC_GRD"));
					youte.setExtshape_dec_name(rs.getString("EXTSHAPE_DEC_NAME"));
					
					youte.setSize_dec_rst(rs.getString("SIZE_DEC_RST"));
					youte.setSize_dec_name(rs.getString("SIZE_DEC_NAME"));
					youte.setMatlqlty_dec_grd(rs.getString("MATLQLTY_DEC_GRD"));
					youte.setMatlqlty_dec_name(rs.getString("MATLQLTY_DEC_NAME"));
					youte.setWgt_dec_rst(rs.getString("WGT_DEC_RST"));
					
					youte.setWgt_dec_name(rs.getString("WGT_DEC_NAME"));
					youte.setTot_dec_grd(rs.getString("TOT_DEC_GRD"));
					youte.setTot_dec_name(rs.getString("TOT_DEC_NAME"));
					youte.setStatus(rs.getString("STATUS"));
					youte.setRemark(rs.getString("REMARK"));
					
					youte.setCreate_opr(rs.getString("CREATE_OPR"));
					youte.setOrderNo(rs.getString("ORD_NO"));
					youte.setProdOrderNo(rs.getString("ORD_SEQ"));
					
					youte.setOrd_nm(rs.getString("ORD_NM"));
					youte.setInstr_coil_thk(rs.getString("INSTR_COIL_THK"));
					youte.setInstr_coil_wth(rs.getString("INSTR_COIL_WTH"));
					youte.setDliv_tp(rs.getString("DLIV_TP"));
					youte.setTrans_car_no(rs.getString("TRANS_CAR_NO"));
					youte.setPackagel(rs.getString("PACKAGEL"));
					youte.setDestpcd(rs.getString("DESTPCD"));
					youte.setDDC_STL_GRD(rs.getString("DDC_STL_GRD"));
					youte.setORD_WGT(rs.getString("ORD_WGT"));
					
					list.add(youte);
				}
				youte = null;
			}
			param = null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(pstm != null) {
				try {
					pstm.close();
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return list;
	}
	
	/**
	 * 根据炉号获取三期成分实绩
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectCHG 查询炉号sqlID
	 * @param sqlIDyouteSelectCHG 判断炉号在优特数据库中是否存在sqlID
	 */
	public ArrayList<YouteCHEM> getCHEM(ArrayList<String[]> params, Connection conn, Connection connLocal,
			String sqlIDxg3qSelectCHG, String sqlIDyouteSelectCHG) {
		//获取炉号
		Set<String> set = checkCHGOrSMP(params, conn, connLocal, sqlIDxg3qSelectCHG, sqlIDyouteSelectCHG);
		if(set == null) {
			return null;
		}
		PreparedStatement pstm = null;
		ResultSet rs = null;
		//用来接收成分实绩
		ArrayList<YouteCHEM> listCHEM = new ArrayList<YouteCHEM>();
		YouteCHEM yChem = null;
		try {
			pstm = connLocal.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_xg3qCHEM.select"));
			for(String str : set) {
				pstm.setString(1, str);						
				rs = pstm.executeQuery();
				while(rs.next()) {
					yChem = new YouteCHEM();
					yChem.setCharge_no(rs.getString("CHARGE_NO"));
					yChem.setChem_cd(rs.getString("CHEM_CD"));
					yChem.setChem_val(rs.getBigDecimal("CHEM_VAL"));
					yChem.setCreate_opr(rs.getString("CREATE_OPR"));
					yChem.setReg_dtime(rs.getString("REG_DTIME"));
					yChem.setRemark(rs.getString("REMARK"));
					listCHEM.add(yChem);
				}
				yChem = null;
			}
			set = null;
		} catch (SQLException e) {
			e.printStackTrace();
			return null;
		}finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(pstm != null) {
				try {
					pstm.close();
					pstm = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return listCHEM;
	}
	
	/**
	 * 根据式样号获取三期成分实绩
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectCHGOrSMP 查询炉号或式样号sqlID
	 * @param sqlIDyouteSelectCHGOrSMP 判断炉号或式样号在优特数据库中是否存在sqlID
	 */
	public ArrayList<YouteQLTY> getQLTY(ArrayList<String[]> params, Connection conn, Connection connLocal, 
			String sqlIDxg3qSelectCHGOrSMP, String sqlIDyouteSelectCHGOrSMP) {
		//获取炉号或式样号
		Set<String> set = checkCHGOrSMP(params, conn, connLocal, sqlIDxg3qSelectCHGOrSMP, sqlIDyouteSelectCHGOrSMP);
		//用来接收成分实绩
		ArrayList<YouteQLTY> listQLTY = new ArrayList<YouteQLTY>();
		if(set == null) {
			return null;
		}
		if(set.size() == 0) {
			return listQLTY;
		}
		PreparedStatement pstm = null, pstm1 = null;
		ResultSet rs = null,rs1=null;
		YouteQLTY yQlty = null;
		try {
			pstm = connLocal.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_xg3qQLTY.select"));
			for(String str : set) {
				pstm.setString(1, str);						
				rs = pstm.executeQuery();
				while(rs.next()) {
					yQlty = new YouteQLTY();
					yQlty.setSmp_no(rs.getString("SMP_NO"));
					yQlty.setQlty_cd(rs.getString("QLTY_CD"));
					yQlty.setQlty_cd_cfnm(rs.getString("QLTY_CD_CFNM"));
					yQlty.setQlty_val_wk(rs.getString("QLTY_VAL_WK"));
					yQlty.setQlty_unit_wk(rs.getString("QLTY_UNIT_WK"));
					
					yQlty.setPfmc_unit_name(rs.getString("PFMC_UNIT_NAME"));
					yQlty.setQlty_type_wk(rs.getString("QLTY_TYPE_WK"));
					yQlty.setSm_cfnm(rs.getString("SM_CFNM"));
					yQlty.setReg_dtime(rs.getString("REG_DTIME"));
					yQlty.setRemark(rs.getString("REMARK"));
					
					yQlty.setCreate_opr(rs.getString("CREATE_OPR"));
					
					yQlty.setItem_code_d(rs.getString("Item_code_d"));
					yQlty.setItem_code_s(rs.getString("item_code_s"));
					yQlty.setItem_code_t(rs.getString("Item_code_t"));
					yQlty.setItem_name_d(rs.getString("Item_name_d"));
					yQlty.setItem_name_s(rs.getString("Item_name_s"));
					yQlty.setItem_name_t(rs.getString("Item_name_t"));
					
					yQlty.setPhy_code_l(rs.getString("Phy_code_l"));
					yQlty.setPhy_code_m(rs.getString("Phy_code_m"));
					yQlty.setPhy_code_s(rs.getString("Phy_code_s"));
					yQlty.setPhy_name_l(rs.getString("Phy_name_l"));
					yQlty.setPhy_name_m(rs.getString("Phy_name_m"));
					yQlty.setPhy_name_s(rs.getString("Phy_name_s"));
					yQlty.setXh(rs.getString("xh"));
					
					if("A3".equals(rs.getString("QLTY_TYPE_WK")))//针对需要三个值的拉力
					{
						pstm1 = connLocal.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_QLTYLL.select"));
						pstm1.setString(1, rs.getString("SMP_NO"));	
						pstm1.setString(2, rs.getString("QLTY_CD"));	
						rs1 = pstm1.executeQuery();
						while(rs1.next()) {
							if(rs1.getString("QLTY_SEQ").equals("A1"))
							{
								yQlty.setQlty_val_wk1(rs1.getString("QLTY_VAL_WK"));
							}
							else if(rs1.getString("QLTY_SEQ").equals("A2"))
							{
								yQlty.setQlty_val_wk2(rs1.getString("QLTY_VAL_WK"));
							}
							else 
							{
								yQlty.setQlty_val_wk(rs1.getString("QLTY_VAL_WK"));
								yQlty.setQlty_val_wk3(rs.getString("QLTY_VAL_WK"));
							}
						}
						
					}
					listQLTY.add(yQlty);
				}
				yQlty = null;
			}
			set = null;
		} catch (SQLException e) {
			e.printStackTrace();
			return null;
		} finally {
			if(rs != null) {
				try {
					rs.close();
					rs = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
			if(pstm != null) {
				try {
					pstm.close();
					pstm = null;
				} catch (SQLException e) {
					e.printStackTrace();
					return null;
				}
			}
		}
		return listQLTY;
	}
	
	/**
	 * 插入材质实绩
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectSMP 查询炉号或式样号sqlID
	 * @param sqlIDyouteSelectSMP 判断炉号或式样号在优特数据库中是否存在sqlID
	 * @param databaseName 数据库名称
	 * @return boolean true：表示插入材质实绩成功		
	 */
	public boolean insertQLTY(ArrayList<String[]> params, Connection conn, Connection connLocal, 
			String sqlIDxg3qSelectCHGOrSMP, String sqlIDyouteSelectCHGOrSMP, String databaseName) {
		//获取三期成分实绩
		ArrayList<YouteQLTY> listQLTY 
			= getQLTY(params, conn, connLocal, sqlIDxg3qSelectCHGOrSMP, sqlIDyouteSelectCHGOrSMP);
		if(listQLTY == null) {
			logger.error("从本地三期数据库获取优特材质实绩数据失败");
			return false;
		}
		if(listQLTY.size() == 0) {
			return true;
		}
		PreparedStatement ps = null;
//		PreparedStatement psLocal = null;
		int[] m = {};
		try {
			//获取prepareStatement
			ps = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youteQLTY.insert"));
//			psLocal = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youtejilu_caizhi.insert"));
			for(YouteQLTY yQlty : listQLTY) {
				/*
				ps.setString(1, yQlty.getSmp_no());
				ps.setString(2, yQlty.getQlty_cd());
				ps.setString(3, yQlty.getQlty_cd_cfnm());
				ps.setBigDecimal(4, yQlty.getQlty_val_wk());
				ps.setString(5, yQlty.getQlty_unit_wk());
				ps.setString(6, yQlty.getPfmc_unit_name());
				ps.setString(7, yQlty.getQlty_type_wk());
				ps.setString(8, yQlty.getSm_cfnm());
				ps.setString(9, yQlty.getReg_dtime());
				ps.setString(10, yQlty.getRemark());
				ps.setString(11, yQlty.getCreate_opr());
				
				*/
				//添加到批量操作里面
				ps.setString(1, yQlty.getSmp_no());
				ps.setString(2, yQlty.getXh());
				ps.setString(3, "1");
				ps.setString(4, yQlty.getQlty_val_wk());
				ps.setString(5, yQlty.getQlty_val_wk1());
				ps.setString(6, yQlty.getQlty_val_wk2());
				ps.setString(7, yQlty.getQlty_val_wk3());
				
				ps.setString(8, yQlty.getPhy_code_l());
				ps.setString(9, yQlty.getPhy_name_l());
				ps.setString(10, yQlty.getPhy_code_m());
				ps.setString(11, yQlty.getPhy_name_m());
				ps.setString(12, yQlty.getPhy_code_s());
				ps.setString(13,yQlty.getPhy_name_s());
				
				ps.setString(14, yQlty.getItem_code_d());
				ps.setString(15, yQlty.getItem_name_d());
				ps.setString(16, yQlty.getItem_code_t());
				ps.setString(17, yQlty.getItem_name_t());
				ps.setString(18, yQlty.getItem_code_s());
				ps.setString(19, yQlty.getItem_name_s());
				ps.setString(20, yQlty.getQlty_cd());
				ps.setString(21, yQlty.getQlty_cd_cfnm());
				
				ps.addBatch();

			}
			m = ps.executeBatch();
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("保存优特材质实绩时，数据库连接发生异常，数据保存失败");
			logger.error("保存优特材质实绩时发生异常原因：" + e);
			return false;
		}finally {
			if(ps != null) {
				try {
					ps.close();
					ps = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特材质实绩后关闭ps时发生异常：" + e);
					return false;
				}
			}
//			if(psLocal != null) {
//				try {
//					psLocal.close();
//					psLocal = null;
//				} catch (SQLException e) {
//					e.printStackTrace();
//					logger.error("保存优特材质实绩后关闭psLocal时发生异常：" + e);
//					return false;
//				}
//			}
		}
		return m.length == listQLTY.size();
	}
	
	/**
	 * 插入成分实绩
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 三期数据库连接
	 * @param sqlIDxg3qSelectCHG 查询炉号sqlID
	 * @param sqlIDyouteSelectCHG 判断炉号在优特数据库中是否存在sqlID
	 * @param databaseName 数据库名称
	 * @return boolean true：插入成分实绩成功
	 */
	public boolean insertCHEM(ArrayList<String[]> params, Connection conn, Connection connLocal, 
			String sqlIDxg3qSelectCHG, String sqlIDyouteSelectCHG, String databaseName) {
		PreparedStatement ps = null;
//		PreparedStatement psLocal = null;
		ArrayList<YouteCHEM> listCHEM = new ArrayList<YouteCHEM>();
		int[] m = {};
		try {
			//获取三期成分实绩
			listCHEM = getCHEM(params, conn, connLocal, sqlIDxg3qSelectCHG, sqlIDyouteSelectCHG);
			if(listCHEM == null) {
				logger.error("从本地三期数据库获取优特成分实绩数据失败");
				return false;
			}
			if(listCHEM.size() == 0) {
				return true;
			}
			//获取prepareStatement
			ps = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youteCHEM.insert"));
//			psLocal = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youtejilu_chengfen.insert"));
			for(YouteCHEM yChem : listCHEM) {
//				psLocal.setString(1, "if_raw_mtr_coil_chem");
//				psLocal.setString(2, yChem.getCharge_no());
//				psLocal.setString(3, yChem.getChem_cd());
//				psLocal.setString(4, databaseName);
				ps.setString(1, yChem.getCharge_no());
				ps.setString(2, yChem.getChem_cd());
				ps.setBigDecimal(3, yChem.getChem_val());
				ps.setString(4, yChem.getReg_dtime());
				ps.setString(5, yChem.getRemark());
				ps.setString(6, yChem.getCreate_opr());
				//添加到批量操作里面
				ps.addBatch();
//				psLocal.addBatch();
			}
//			psLocal.executeBatch();
			m = ps.executeBatch();
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("保存优特成分实绩时，数据库连接发生异常，数据保存失败");
			logger.error("保存优特成分实绩时发生异常原因：" + e);
			return false;
		}finally {
			if(ps != null) {
				try {
					ps.close();
					ps = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特成分实绩后关闭ps时发生异常：" + e);
					return false;
				}
			}
//			if(psLocal != null) {
//				try {
//					psLocal.close();
//					psLocal = null;
//				} catch (SQLException e) {
//					e.printStackTrace();
//					logger.error("保存优特成分实绩后关闭psLocal时发生异常：" + e);
//					return false;
//				}
//			}
		}
		return m.length == listCHEM.size();
	}
	
	/**
	 * 插入优特主数据
	 * @param params
	 * @param conn 优特数据库连接
	 * @param connLocal 本地三期数据库连接
	 * @param databaseName 数据库名称
	 * @return boolean true：表示插入优特主数据成功
	 */
	public boolean insertYoute(ArrayList<String[]> params, Connection conn, Connection connLocal, 
			String sqlIDSelect, String databaseName) {
		PreparedStatement ps = null;
		PreparedStatement psLocal = null;
		PreparedStatement psDele = null;
		PreparedStatement psupd = null;
		ArrayList<Youte> list = new ArrayList<Youte>();
		ArrayList<Youte> list2 = new ArrayList<Youte>();//存放删除数据，在每次写入前先对优特钢数据库进行删除
		String sqlIDChk = "UIJ030060_xg3qtbl.SELECT";
		int[] m = {};
		try {
			list = getYoute(params, connLocal, sqlIDSelect);
			list2 = getYoute(params, connLocal, sqlIDChk);
			if(list == null) {
				logger.error("从本地三期数据库获取优特主数据失败");
				return false;
			}
			if(list.size() == 0) {
				return true;
			}
			//获取prepareStatement
			ps = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youte.insert"));
			psLocal = connLocal.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youtejilu_zhu.insert"));
			if(list2.size()>0){
				//删除
			psDele = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youte.delete"));
			for(Youte youte2 : list2) {
				psDele.setString(1, youte2.getOld_sampl_no());
				psDele.addBatch();
			}
			//执行批量操作
			psDele.executeBatch();
			m = psDele.executeBatch();
			}
			
			
			for(Youte youte : list) {
				psLocal.setString(1, "if_raw_mtr_coil_m");
				psLocal.setString(2, youte.getOld_sampl_no());
				psLocal.setString(3, databaseName);
				ps.setString(1, youte.getOld_sampl_no());
				ps.setString(2, youte.getCoil_source());
				ps.setString(3, youte.getCoil_sort());
				ps.setString(4, youte.getOrdcust_cd());
				ps.setString(5, youte.getCust_nm());
				
				ps.setString(6, youte.getCharge());
				if(youte.getSmp_no() == null || "".equals(youte.getSmp_no())) {
					ps.setString(7, "无试样号");
				} else {
					ps.setString(7, youte.getSmp_no());
				}
				ps.setString(8, youte.getPrd_code());
				ps.setString(9, youte.getPrd_name());
				ps.setString(10, youte.getStd_code());
				
				ps.setString(11, youte.getStd_name());
				ps.setString(12, youte.getSteel_code());
				ps.setString(13, youte.getSteel_name());
				ps.setBigDecimal(14, youte.getCoil_thk());
				ps.setBigDecimal(15, youte.getCoil_wth());
				
				ps.setBigDecimal(16, youte.getCoil_len());
				ps.setBigDecimal(17, youte.getCoil_india());
				ps.setBigDecimal(18, youte.getCoil_outdia());
				ps.setBigDecimal(19, youte.getCoil_wgt());
				ps.setBigDecimal(20, youte.getAct_wgt());
				
				ps.setString(21, youte.getMill_dtime());
				ps.setString(22, youte.getFlaw_code1());
				ps.setString(23, youte.getFlaw_name1());
				ps.setString(24, youte.getFlaw_code2());
				ps.setString(25, youte.getFlaw_name2());
				
				ps.setString(26, youte.getFlaw_code3());
				ps.setString(27, youte.getFlaw_name3());
				ps.setString(28, youte.getFlaw_code4());
				ps.setString(29, youte.getFlaw_name4());
				ps.setString(30, youte.getFlaw_code5());
				
				ps.setString(31, youte.getFlaw_name5());
				ps.setString(32, youte.getIngr_dec_grd());
				ps.setString(33, youte.getIngr_dec_name());
				ps.setString(34, youte.getExtshape_dec_grd());
				ps.setString(35, youte.getExtshape_dec_name());
				
				ps.setString(36, youte.getSize_dec_rst());
				ps.setString(37, youte.getSize_dec_name());
				ps.setString(38, youte.getMatlqlty_dec_grd());
				ps.setString(39, youte.getMatlqlty_dec_name());
				ps.setString(40, youte.getWgt_dec_rst());
				
				ps.setString(41, youte.getWgt_dec_name());
				ps.setString(42, youte.getTot_dec_grd());
				ps.setString(43, youte.getTot_dec_name());
				ps.setString(44, youte.getStatus());
				ps.setString(45, youte.getRemark());
				
				ps.setString(46, youte.getCreate_opr());
				ps.setString(47, youte.getOrderNo());
				ps.setString(48, youte.getProdOrderNo());
				
				ps.setString(49, youte.getOrd_nm());
				ps.setString(50, youte.getInstr_coil_thk());
				ps.setString(51, youte.getInstr_coil_wth());
				ps.setString(52, youte.getDliv_tp());
				ps.setString(53, youte.getTrans_car_no());
				ps.setString(54, youte.getPackagel());
				ps.setString(55, youte.getDestpcd());
				ps.setString(56, youte.getDDC_STL_GRD());
				ps.setString(57, youte.getORD_WGT());
				//添加到批量操作里面
				ps.addBatch();
				psLocal.addBatch();
			}
			//执行批量操作
			psLocal.executeBatch();
			m = ps.executeBatch();
			if(list2.size()>0){
				//删除数据之后新数据标志变为’2‘
			psupd = conn.prepareStatement(XmlSqlParsersFactory.getSql("UIJ030060_youte.update"));
			for(Youte youte2 : list2) {
				psupd.setString(1, youte2.getOld_sampl_no());
				psupd.addBatch();
			}
			//执行批量操作
			psupd.executeBatch();
		    int[] a = psupd.executeBatch();
			}
			
			
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("保存优特主数据时，数据库连接发生异常，数据保存失败");
			logger.error("保存优特主数据时发生异常原因：" + e);
			return false;
		}finally {
			if(ps != null) {
				try {
					ps.close();
					ps = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特主数据后关闭ps时发生异常：" + e);
					return false;
				}
			}
			if(psLocal != null) {
				try {
					psLocal.close();
					psLocal = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特主数据后关闭psLocal时发生异常：" + e);
					return false;
				}
			}
			if(psDele != null) {
				try {
					psDele.close();
					psDele = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特主数据后关闭psDele时发生异常：" + e);
					return false;
				}
			}
			if(psupd != null) {
				try {
					psupd.close();
					psupd = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("保存优特主数据后关闭psDele时发生异常：" + e);
					return false;
				}
			}
		}
		return m.length == list.size();
	}
	
	/**
	 * 保存中间库信息
	 * @param params
	 */
	public void saveYouTeTblData(ArrayList<String[]> params) {
		if(params == null || params.size() == 0) {
			logger.error("没有需要保存到中间库的优特数据");
			return;
		}
		//优特数据库连接
		Connection conn = null;
		//本地三期数据库连接
		Connection connLocal = null;
		try {
			//获取连接
			//conn = this.getDao("YtDao").getConnection();
			conn = this.getDao("KgDao").getConnection();
			//conn = DataSo.getDataSource2().getConnection();
			connLocal = this.getDao("KgDao").getConnection();
			//设置事务属性 
			conn.setAutoCommit(false);
			//查询三期成品库sqlID
			String sqlIDSelect = "UIJ030060_xg3qtbl.SELECT";
			//插入优特主数据
			boolean isSuccess = insertYoute(params, conn, connLocal, sqlIDSelect, "中间库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据中间库时，优特主数据插入失败");
				return;
			}
			//查询成品库炉号sqlID
			String sqlIDxg3qSelectCHG = "UIJ030060_xg3qTblCHG.select";
			//判断炉号在优特数据库中是否存在sqlID
			String sqlIDyouteSelectCHG = "UIJ030060_youteCHG.select";
			//插入成分实绩
			isSuccess = insertCHEM(params, conn, connLocal, sqlIDxg3qSelectCHG, sqlIDyouteSelectCHG, "中间库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据中间库时，优特成分实绩数据插入失败");
				return;
			}
			//查询中间库式样号sqlID
			String sqlIDxg3qSelectSMP = "UIJ030060_xg3qTblSMP.select";
			//判断式样号在优特数据库中是否存在sqlID
			String sqlIDyouteSelectSMP = "UIJ030060_youteSMP.select";
			//插入材质
			isSuccess = insertQLTY(params, conn, connLocal, sqlIDxg3qSelectSMP, sqlIDyouteSelectSMP, "中间库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据到中间库时，优特材质数据插入失败");
				return;
			}
			conn.commit();
			logger.info("保存中间库优特信息成功");
		} catch (Exception e) {
			if (conn != null) {
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
					logger.error(e1);
				}
			}
			e.printStackTrace();
			logger.error("保存中间库信息时，发生异常，数据保存失败");
			logger.error("保存中间库信息时发生异常原因：" + e);
			return;
		}finally {
			if(conn != null) {
				try {
					conn.close();
					conn = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("关闭优特数据库连接失败");
				}
			}
			if(connLocal != null) {
				try {
					connLocal.close();
					connLocal = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("关闭本地三期数据库连接失败");
				}
			}
		}
		
	}
	
	/**
	 * 保存成品库信息
	 * @param params
	 */
	public void saveYouTeTbcData(ArrayList<String[]> params) {
		if(params == null || params.size() == 0) {
			logger.error("没有需要保存到成品库的优特数据");
			return;
		}
		//优特数据库连接
		Connection conn = null;
		//本地三期数据库连接
		Connection connLocal = null;
		try {
			//获取连接
			//conn = this.getDao("YtDao").getConnection();
			conn = this.getDao("KgDao").getConnection();
			connLocal = this.getDao("KgDao").getConnection();
			//设置事务属性 
			conn.setAutoCommit(false);
			//查询三期成品库sqlID
			String sqlIDSelect = "UIJ030060_xg3qtbc.SELECT";
			//插入优特主数据
			boolean isSuccess = insertYoute(params, conn, connLocal, sqlIDSelect, "成品库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据成品库时，优特主数据插入失败");
				return;
			}
			//查询成品库炉号sqlID
			String sqlIDxg3qSelectCHG = "UIJ030060_xg3qTbcCHG.select";
			//判断炉号在优特数据库中是否存在sqlID
			String sqlIDyouteSelectCHG = "UIJ030060_youteCHG.select";
			//插入成分实绩
			isSuccess = insertCHEM(params, conn, connLocal, sqlIDxg3qSelectCHG, sqlIDyouteSelectCHG, "成品库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据成品库时，优特成分实绩数据插入失败");
				return;
			}
			//查询成品库式样号sqlID
			String sqlIDxg3qSelectSMP = "UIJ030060_xg3qTbcSMP.select";
			//判断式样号在优特数据库中是否存在sqlID
			String sqlIDyouteSelectSMP = "UIJ030060_youteSMP.select";
			//插入材质
			isSuccess = insertQLTY(params, conn, connLocal, sqlIDxg3qSelectSMP, sqlIDyouteSelectSMP, "成品库");
			if (!isSuccess) {
				conn.rollback();
				logger.error("保存数据成品库时，优特材质数据插入失败");
				return;
			}
			conn.commit();
			logger.info("保存成品库信息成功");
		} catch (Exception e) {
			if (conn != null) {
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
					logger.error(e1);
				}
			}
			e.printStackTrace();
			logger.error("保存成品库信息时，数据库连接发生异常，数据保存失败");
			logger.error("保存成品库信息时发生异常原因：" + e);
			return;
		}finally {
			if(conn != null) {
				try {
					conn.close();
					conn = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("关闭优特数据库连接失败");
				}
			}
			if(connLocal != null) {
				try {
					connLocal.close();
					connLocal = null;
				} catch (SQLException e) {
					e.printStackTrace();
					logger.error("关闭本地三期数据库连接失败");
				}
			}
		}
		
	}
}