ssi集成,在批量增加数据的时候一定要自己控制事务的开启,否则你批量增加就没有效果,但就是在批量增加结束,立即执行另外一条sql语句时就会报错!后来度娘无果,谷歌也不给力,发现自己在结束操作的时候没有结束事务导致这个异常!
int result=0;
		sqlMapClient.startTransaction();
		sqlMapClient.startBatch();
		for(int i=0;i<reportDayItemsList.size();i++){
			ReportDayItemsVO reportDayItems=reportDayItemsList.get(i);
			sqlMapClient.insert("day.insertDayReportItem",reportDayItems);
		}
		result=sqlMapClient.executeBatch();
		sqlMapClient.commitTransaction();
		sqlMapClient.endTransaction();
		return result;

<insert id="insertBatch" parameterType="java.util.List">  

    insert into A10WEB (

        ABZ001, ABZ080, AAC102, ABB391, AAB001

        )

        select

        t.abz001,t.abz080,t.aac102,t.abb391,t.aab001

        from (

        <foreach collection="list" item="item" index="index"

            separator="union all">

            (select

            #{item.abz001} abz001,

            #{item.abz080} abz080,

            #{item.aac102} aac102,

            #{item.abb391} abb391,

            #{item.aab001} aab001

            from

            dual)

        </foreach>

        )t

</insert>

最近做项目遇到一个挺纠结的问题，由于业务的关系，DB的数据表无法确定，在使用过程中字段可能会增加，这样在insert时给我造成了很大的困扰。
先来看一下最终我是怎么实现的：
INSERT INTO tg_fcst_lines(${lineColumn})
select result.*,sq_fcst_lines.nextval from(
]]>
(select
#{_value}
from dual)
由于数据表不确定，所以我无法确定我要insert的字段，由于是批量insert，确定value值也挺费劲。
我传给mybatis的参数是一个map:
Map insertMap = new HashMap();
insertMap.put("lineColumn",lineColumn);
insertMap.put("lineList", lineList);
lineColumn是一个字符串，lineList是一个list:
List lineList = new ArrayList();
lineList里存放的是map，map的键对应数据表的字段，值是你要insert的值，这样就可以通过foreach取出list的值作为insert语句的value，但由于map是无序的，存放的顺序和
遍历时取值的顺序不一定一致，所以为了确保insert字段和值可以一一对应，可以通过遍历一次map来取出key拼接一个字符串作为insert的字段
String lineColumn = "";  //拼接的SQL,作为insert语句的一部分
[java] view plaincopy
Map lineMap = lineList.get(0);
for (String key : lineMap.keySet()) {
lineColumn +=key+",";
}
lineColumn +="LINE_ID";
这里的line)id是一个自增的字段，在语句中直接写序列会报错，所以先遍历list将取出的值作为result,在取出result的所有值，连同序列一起作为insert的值。
在取值的时候使用两个foreace嵌套来实现，外层的foreach遍历list,里层的foreach遍历map。
以上内容是本文给大家介绍的oracle+mybatis 使用动态Sql当插入字段不确定的情况下实现批量insert的全部叙述，希望大家喜欢。
原文：http://www.jb51.net/article/74203.htm

其中涉及的数据库的连接与关闭，Statement的关闭，ResultSet的关闭，请参考文章http://blog.csdn.net/mrw456/article/details/49718235
本例使用Mysql数据库，以宿舍室表为例
宿舍室表sql：

CREATE TABLE dorm(dormnum INT NOT NULL PRIMARY KEY,dormtext TEXT NOT NULL); 


Dorm.java

public class Dorm {
	private int dormnum;
	private String dormtext;
	public Dorm() {
		super();
	}
	public Dorm(int dormnum, String dormtext) {
		super();
		this.dormnum = dormnum;
 		this.dormtext = dormtext;
	}
 	public int getDormnum() {
		return dormnum;
 	}
  	public void setDormnum(int dormnum) {
 		this.dormnum = dormnum;
	}
 	public String getDormtext() {
		return dormtext;
	 }
 	public void setDormtext(String dormtext) {
		this.dormtext = dormtext;
	}
	
}

1、增加数据

public boolean dormadd(Dorm dorm) {
		Connection connection=MysqlOperation.getConnection();
		String addSQL="insert into dorm(dormnum,"+
		"dormtext) values(?,?)";
		PreparedStatement pstmt=null;
		try {
			connection.setAutoCommit(false); //设置自动提交为false,如果出现异常进行回滚
			pstmt=connection.prepareStatement(addSQL);
			pstmt.setInt(1,dorm.getDormnum());
			pstmt.setString(2,dorm.getDormtext());
			pstmt.execute();
			connection.commit();
		} catch (Exception e) {
			try {
				connection.rollback();//事务进行回滚，回到最初的状态
			} catch (SQLException e1) {
				System.out.println("事务提交异常");
			}
			e.printStackTrace();
			return false;
		}finally{
			MysqlOperation.close(pstmt);
			MysqlOperation.close(connection);
		}
		return true;
	}
2、删除数据
	public boolean dormdelete(String dormnum) {
		Connection connection=MysqlOperation.getConnection();
		String sql="delete from dorm where dormnum=?";
		PreparedStatement pstmt=null;
		try {
			connection.setAutoCommit(false);
			pstmt=connection.prepareStatement(sql);
			pstmt.setString(1,dormnum);
			pstmt.execute();
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				connection.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			return false;
		}finally{
			MysqlOperation.close(pstmt);
			MysqlOperation.close(connection);
		}
		return true;
	}
3、修改数据


	public boolean dormupdate(Dorm dori) {
		Connection connection=MysqlOperation.getConnection();
		String sql="update dorm set dormtext=? where dormnum=?";
		PreparedStatement pstmt=null;
		try {
			connection.setAutoCommit(false);
			pstmt=connection.prepareStatement(sql);
			pstmt.setString(1,dori.getDormtext());
			pstmt.setInt(2,dori.getDormnum());
			pstmt.execute();
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				connection.rollback();
			} catch (SQLException e1) {
				System.out.println("事务异常");
			}
			return false;
		}finally{
			MysqlOperation.close(pstmt);
			MysqlOperation.close(connection);
		}
		return true;
	}
4、查询数据


public List<Dorm> buildselect(String str) {
		Connection connection=MysqlOperation.getConnection();
		String findSQL="select * from dorm where dormnum=?";
		PreparedStatement pstmt=null;
		ResultSet rs=null;
		List<Dorm> dorms=new ArrayList<Dorm>();
		try {
			pstmt=connection.prepareStatement(findSQL);
			pstmt.setString(1,str);
			rs=pstmt.executeQuery();
			while(rs.next())
			{
				Dorm dorm=new Dorm();
				dorm.setDormnum(rs.getInt(1));
				dorm.setDormtext(rs.getString(2));
				dorms.add(dorm);
			}
		} catch (SQLException e) {
			e.printStackTrace();
			return null;
		}finally
		{
			MysqlOperation.close(rs);
			MysqlOperation.close(pstmt);
			MysqlOperation.close(connection);
		}
		
		return dorms;
	}
5、批量添加


public boolean dormpadd(ArrayList<Dorm> dorms) {
		Connection connection=MysqlOperation.getConnection();
		String addSQL="insert into dorm(dormnum,"+
		"dormtext) values(?,?)";
		PreparedStatement pstmt=null;
		try {
			connection.setAutoCommit(false);
			pstmt=connection.prepareStatement(addSQL);
			for(Dorm dorm:dorms){
				pstmt.setInt(1,dorm.getDormnum());
				pstmt.setString(2,dorm.getDormtext());
				pstmt.addBatch(); //添加预定义参数
			}
			pstmt.executeBatch();//批量执行预定义SQL
			connection.commit();
		} catch (Exception e) {
			try {
				connection.rollback();
			} catch (SQLException e1) {
				System.out.println("事务提交异常");
			}
			e.printStackTrace();
			return false;
		}finally{
			MysqlOperation.close(pstmt);
			MysqlOperation.close(connection);
		}
		return true;
	}