java自学之路-----jdbc_分页查询，大数据，批处理，存储过程

//该对象封装了分页查询的配置信息，用于dao层
public class QueryInfo {
	private int startindex;//查询的每页在数据库的起始位置，该值可以根据其他参数计算出，不需要set属性
	private int pagesize = 5;//查询的每页记录数，赋一个初始值
	private int querypage = 1;//查询第几页，赋一个初始值
	//提供get，set方法，便于设置，获取属性值
	public int getStartindex() {
	this.startindex = (this.querypage-1) + 1;
	return startindex;
	}
	public int getPagesize() {
	return pagesize;
	}
	public void setPagesize(int pagesize) {
	this.pagesize = pagesize;
	}
	public int getQuerypage() {
	return querypage;
	}
	public void setQuerypage(int querypage) {
	this.querypage = querypage;
	}
}

//该类封装了分页查询的结果信息，作为中间值，用于给QueryBean提供信息
public class QueryResult {
	private List list;//封装了查询后某页的所有记录
	private int totalrecord;//总记录数，用于给用户提供交互信息
//	提供属性的get，set方法，
	public List getList() {
	return list;
	}
	public void setList(List list) {
	this.list = list;
	}
	public int getTotalrecord() {
	return totalrecord;
	}
	public void setTotalrecord(int totalrecord) {
	this.totalrecord = totalrecord;
	}
}

//该类封装了分页查询的所有信息，用于与用户交互，用于jsp页面，web层
public class QueryBean {
	private List list;//封装查询的所有记录信息
	private int totalrecord;//告诉用户总共有多少记录，可以从QueryResult对象获取
	private int pagesize;//告诉用户每页有多少记录，从QueryInfo对象获取
	private int totalpage;//告诉用户一共有多少页，可以通过totalrecord和pagesize计算
	private int currentpage;//告诉用户当前查看的是第几页，从QueryInfo对象获取
	private int previouspage;//上一页是第几页，通过当前页计算出
	private int nextpage;//下一页是第几页，通过当前页计算出
	private int[] pagebar;//记录页码条，通过currentpage和pagesize计算出的一个数组
//	提供所有属性的get，set方法
	public int getTotalrecord() {
	return totalrecord;
	}
	public void setTotalrecord(int totalrecord) {
	this.totalrecord = totalrecord;
	}
	public int getPagesize() {
	return pagesize;
	}
	public void setPagesize(int pagesize) {
	this.pagesize = pagesize;
	}
	public int getTotalpage() {
//	计算总页数,21条，每页5条，有5页。20条，每页5条，有4页。
	if(this.totalrecord%this.pagesize == 0){
	this.totalpage = this.totalrecord / this.pagesize;
	}else{
	this.totalpage = this.totalrecord / this.pagesize + 1;
	}
	return totalpage;
	}
	public int getCurrentpage() {
	return currentpage;
	}
	public void setCurrentpage(int currentpage) {
	this.currentpage = currentpage;
	}
	public int getPreviouspage() {
	this.previouspage = this.currentpage - 1;
//	如果当前页小于等于0，就指向第一页
	if(this.previouspage<=0){
	this.previouspage = 1;
	}
	return previouspage;
	}
	public int getNextpage() {
	this.previouspage = this.currentpage - 1;
//	如果当前页小于等于0，就指向最后一页
	if(this.nextpage<=0){
	this.nextpage = 1;
	}
	return nextpage;
	}
	public int[] getPagebar() {
	int startindex;
	int endindex;
//	如果总页数小于10
	if(this.pagesize <= 10){
	startindex = 1;
	endindex = this.pagesize;
	}else{
	startindex = this.currentpage - 4;
	endindex = this.currentpage + 5;
//	如果startindex小于1，就从0开始，如果endindex大于总页数，就用总页数作为结束
	if(startindex < 1){
	startindex = 1;
	endindex = 10;
	}
	if(endindex > this.pagesize){
	startindex = this.pagesize - 9;
	endindex = this.pagesize;
	}
	}
//	更具两个索引值定义数组pagebar
	this.pagebar = new int[endindex-startindex+1];
//	为数组赋值
	for (int i = 0; i < pagebar.length; i++) {
	this.pagebar[i] = startindex++;
	}	
	return pagebar;
	}
}

//	在dao层提供一个分页查询的方法，将索引的初始位置和每页记录数传入
	public QueryResult pageQuery(int startIndex, int pageSize){
	Connection conn = null;
	PreparedStatement st = null;
	ResultSet rs = null;
	try {
//	获取数据库连接
	conn = JdbcUtils.getConnection();
//	提供分页查询的sql语句
	String sql = "select * from customer limit ?,?";
//	预编译sql语句，获得preparedstatement对象
	st = conn.prepareStatement(sql);
//	为占位符'?' 赋值
	st.setInt(1, startIndex);
	st.setInt(2, pageSize);
//	执行sql语句，获得结果集
	rs = st.executeQuery();
//	将结果封装到QueryResult对象中
	//在service层，将该对象封装到QueryBean中，传给jsp用于显示
	...
	} catch (Exception e) {
	}finally{
	JdbcUtils.release(conn, st, rs);
	}
	}

//	定义sql语句
	String sql = "insert into testclob(id,resum) values(?,?)";
//	预编译sql
	PreparedStatement st = conn.prepareStatement(sql);
//	赋值占位符
	st.setString(1, "1");
//	不建议用类装载器读取文件，因为文本内容可能太大，不适合读取至内存中
	File file = new File("src/1.txt");
	Reader reader = new FileReader(file);
	st.setCharacterStream(2, reader, file.length());//reader:一个读取文本的流 length:文本的大小
//	 这是long型的，使用1.6一下的jdk必须将其转成int

//	定义sql语句
	String sql = "select * from testclob where id= '1'";
//	预编译sql
	PreparedStatement st = conn.prepareStatement(sql);
//	无占位符直接执行sql
	ResultSet rs = st.executeQuery();
//	通过结果集获取大数据文件
	while(rs.next()){
	String id = rs.getString(1);
//	将数据库的文本数据放在一个流中，供用户使用
	Reader reader = rs.getCharacterStream(2);
//	读取数据
	Writer writer = new FileWriter("src/2.txt");
	...
	}

//	定义sql语句
	String sql = "insert into testblob(id,image) values(?,?)";
//	预编译sql
	PreparedStatement st = conn.prepareStatement(sql);
//	赋值占位符
	st.setString(1, "1");
//	不建议用类装载器读取文件，因为文本内容可能太大，不适合读取至内存中
	File file = new File("src/1.jpg");
	InputStream inputStream = new FileInputStream(file); 
	st.setBinaryStream(2, inputStream, file.length());//inputStream:一个读取文本的流 length:文本的大小
//	 这是long型的，使用1.6一下的jdk必须将其转成int

//	定义sql语句
	String sql = "select * from testblob where id= '1'";
//	预编译sql
	PreparedStatement st = conn.prepareStatement(sql);
//	无占位符直接执行sql
	ResultSet rs = st.executeQuery();
//	通过结果集获取大数据文件
	while(rs.next()){
	String id = rs.getString(1);
//	将数据库的文本数据放在一个流中，供用户使用
	InputStream in = rs.getBinaryStream(2);
//	存储数据
	OutputStream out = new FileOutputStream("c:\\2.jpg");
	...

//	定义sql语句
	String sql1 = "insert into testBatch(id,name) values('1', 'aaa')";
	String sql2 = "update testBatch set name = 'bbb' where id = '1'";
//	获取Statement对象
	Statement st = conn.createStatement();
//	将sql语句存到对象中，实际是将sql语句存放在内部的list对象中
	st.addBatch(sql1);
	st.addBatch(sql2);
//	执行sql
	int result[] = st.executeBatch();//该数组一次存放着每一条sql语句影响数据库数据的行数
//	清除
	st.clearBatch();

//	定义sql语句
	String sql = "insert into testBatch(id,name) values(?,?)";
//	获取PreparedStatement对象
	PreparedStatement st = conn.prepareStatement(sql);
////	替换占位符，第一个sql，存到list中
//	st.setString(1, "1");
//	st.setString(2, "aaa");
//	st.addBatch();
////	替换占位符，第二个sql，存到list中
//	st.setString(1, "2");
//	st.setString(2, "bbb");
//	st.addBatch();
	//例：
	for(int i=0; i<10; i++){
	st.setString(1, ""+i);
	st.setString(2, "aa"+i);
	st.addBatch();
	}
//	执行
	st.executeBatch();
//	清除
	st.clearBatch();

	//如果批处理的语句过多，可能造成内存溢出：使用下列处理方法
	for(int i=0; i<100000; i++){
	st.setString(1, ""+i);
	st.setString(2, "aa"+i);
	st.addBatch();
//	每次处理1000条sql语句
	if(i%1000==0){
	st.executeBatch();
	st.clearBatch();
	}
	}
//	以防sql语句未执行
	st.executeBatch();
//	清除
	st.clearBatch();

//	获取连接，通过数据库的方法，先得到一个数据，处理后再