devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JDBC(二)大结果集分页,批处理，学习_java中什么是大结果集的定义

作者：IT小白 | 2024-04-14 13:29:43

赞

踩

java中什么是大结果集的定义

一、大结果集分列

减少内存的占用率，分批次去数据库查询记录  (分页查询)

           分页语句   不同数据库是不同的

                   MySQL:   LIMIT  M,N  

                             M：是开始记录的索引。从0开始

                             N:   每次查询多少条

             例如:

  

每次查10条：

查第一页的：SELECT * FROM customer LIMIT 0,10;

查第二页的：SELECT * FROM customer LIMIT 10,10; 

           实现分页步骤及代码

     

1.封装分页有关信息的类Page     

  1. public class Page {
  2.  
  3. 	private List records;// 显示的分页的记录信息
  4. 	private int pageSize = 10;// 每页显示的记录条数
  5. 	private int pageNum;// 当前页码
  6. 	private int totalPageNum;// 总页数
  7.  
  8. 	private int startIndex;// 每页开始的记录索引
  9. 	private int totalRecordsNum;// 总记录的条数
  10.  
  11. 	private int proviousPageNum;// 上一页页码
  12. 	private int nextPageNum;// 下一页页码
  13.  
  14. 	private int startPage;// 页码:开始
  15. 	private int endPage;// 页码：结束
  16.  
  17. 	// 查询记录的Servlet的url地址
  18. 	private String url;
  19.  
  20. 	public Page(int pageNum, int totalRecordsNum) {
  21. 		this.pageNum = pageNum;
  22. 		this.totalRecordsNum = totalRecordsNum;
  23. 		// 计算总页数 
  24. 		totalPageNum = totalRecordsNum % pageSize == 0 ? totalRecordsNum
  25. 				/ pageSize : totalRecordsNum / pageSize + 1;
  26. 		//计算每页开始记录的索引   当前页数-1*每页的记录条数  
  27. 		startIndex=(pageNum-1)*pageSize;
  28. 		
  29. 		//页码计算
  30. 		if(totalPageNum<=9){   //这里是实现页码条的计算 最多显示8条
  31. 			startPage=1;
  32. 			endPage=totalPageNum;
  33. 		}else{
  34. 			startPage=pageNum-4;
  35. 			endPage=pageNum+4;
  36. 		}
  37. 		   if(startPage<1){
  38. 			   startPage=1;
  39. 			   endPage=startPage+8;
  40. 		   }
  41. 		   if(endPage>totalPageNum){
  42. 			   endPage=totalPageNum;
  43. 			   startPage=totalPageNum-8;
  44. 		   }
  45. 	}
  46.  
  47. 	public List getRecords() {
  48. 		return records;
  49. 	}
  50.  
  51. 	public void setRecords(List records) {
  52. 		this.records = records;
  53. 	}
  54.  
  55. 	public int getPageSize() {
  56. 		return pageSize;
  57. 	}
  58.  
  59. 	public void setPageSize(int pageSize) {
  60. 		this.pageSize = pageSize;
  61. 	}
  62.  
  63. 	public int getPageNum() {
  64. 		return pageNum;
  65. 	}
  66.  
  67. 	public void setPageNum(int pageNum) {
  68. 		this.pageNum = pageNum;
  69. 	}
  70.  
  71. 	public int getTotalPageNum() {
  72. 		return totalPageNum;
  73. 	}
  74.  
  75. 	public void setTotalPageNum(int totalPageNum) {
  76. 		this.totalPageNum = totalPageNum;
  77. 	}
  78.  
  79. 	public int getStartIndex() {
  80. 		return startIndex;
  81. 	}
  82.  
  83. 	public void setStartIndex(int startIndex) {
  84. 		this.startIndex = startIndex;
  85. 	}
  86.  
  87. 	public int getTotalRecordsNum() {
  88. 		return totalRecordsNum;
  89. 	}
  90.  
  91. 	public void setTotalRecordsNum(int totalRecordsNum) {
  92. 		this.totalRecordsNum = totalRecordsNum;
  93. 	}
  94.  
  95. 	public int getProviousPageNum() {
  96. 		return pageNum-1>0?pageNum-1:1;  //上一页页码等于当前页码-1如果是第一页不变
  97. 	}
  98.  
  99. 	public void setProviousPageNum(int proviousPageNum) {
  100. 		this.proviousPageNum = proviousPageNum;
  101. 	}
  102.  
  103. 	public int getNextPageNum() {
  104. 		//下一页页码等于当前页码+1如果已经超过总页数那就是不变
  105. 		return pageNum+1>totalPageNum?totalPageNum:pageNum+1;
  106. 	}
  107.  
  108. 	public void setNextPageNum(int nextPageNum) {
  109. 		this.nextPageNum = nextPageNum;
  110. 	}
  111.  
  112. 	public int getStartPage() {
  113. 		return startPage;
  114. 	}
  115.  
  116. 	public void setStartPage(int startPage) {
  117. 		this.startPage = startPage;
  118. 	}
  119.  
  120. 	public int getEndPage() {
  121. 		return endPage;
  122. 	}
  123.  
  124. 	public void setEndPage(int endPage) {
  125. 		this.endPage = endPage;
  126. 	}
  127.  
  128. 	public String getUrl() {
  129. 		return url;
  130. 	}
  131.  
  132. 	public void setUrl(String url) {
  133. 		this.url = url;
  134. 	}
  135. }
2.DAO的2个方法 

  1. // 得到记录的总条数
  2. 	public int getTotalRecords() {
  3. 		Connection conn = null;
  4. 		PreparedStatement stmt = null;
  5. 		ResultSet rs = null;
  6.  
  7. 		try {
  8. 			conn = JdbcUtil.getConnection();
  9. 			stmt = conn.prepareStatement("select count(*) from customers");
  10. 			rs = stmt.executeQuery();
  11. 			if (rs.next()) {
  12. 				return rs.getInt(1);
  13. 			}
  14. 			return 0;
  15. 		} catch (Exception e) {
  16. 			throw new DaoException(e);
  17. 		} finally {
  18. 			JdbcUtil.release(rs, stmt, conn);
  19. 		}
  20. 	}
  21.  
  22. 	// 根据开始索引和页面记录条数查询查询分页数据
  23. 	public List<Customer> findPageRecords(int startIndex, int pageSize) {
  24. 		Connection conn = null;
  25. 		PreparedStatement stmt = null;
  26. 		ResultSet rs = null;
  27.  
  28. 		try {
  29. 			conn = JdbcUtil.getConnection();
  30. 			stmt = conn
  31. 					.prepareStatement("select id,name,gender,birthday,phone,email,hobby,type,description from customers limit ?,?");
  32. 			stmt.setInt(1, startIndex);
  33. 			stmt.setInt(2, pageSize);
  34. 			rs = stmt.executeQuery();
  35. 			// 查询到的数据保存到bean
  36. 			List<Customer> cs = new ArrayList<Customer>();
  37. 			while (rs.next()) {
  38. 				Customer c = new Customer();
  39. 				c.setId(rs.getString("id"));
  40. 				c.setName(rs.getString("name"));
  41. 				c.setGender(rs.getString("gender"));
  42. 				c.setBirthday(rs.getDate("birthday"));
  43. 				c.setPhone(rs.getString("phone"));
  44. 				c.setEmail(rs.getString("email"));
  45. 				c.setHobby(rs.getString("hobby"));
  46. 				c.setType(rs.getString("type"));
  47. 				c.setDescription(rs.getString("description"));
  48. 				cs.add(c);
  49. 			}
  50. 			return cs;
  51. 		} catch (Exception e) {
  52. 			throw new DaoException(e);
  53. 		} finally {
  54. 			JdbcUtil.release(rs, stmt, conn);
  55. 		}
  56. 	}
3.业务处理方法 
  1. 	// 根据客户端查看页码查询数据
  2. 	public Page findPageReocords(String num) {
  3. 		int pageNum = 1;
  4. 		if (num != null && !num.trim().equals("")) {
  5. 			pageNum = Integer.parseInt(num);
  6. 		}
  7. 		int totalRecordsNum = dao.getTotalRecords();//获取总记录条数
  8. 		Page page = new Page(pageNum, totalRecordsNum);
  9. 		// 把记录搞进去
  10. 		List<Customer> cs = dao.findPageRecords(page.getStartIndex(),
  11. 				page.getPageSize());
  12. 		page.setRecords(cs);
  13. 		return page;
  14. 	}

4.页面jsp实现

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <!-- 分页开始 -->
  3. 第${page.pageNum}页/共${page.totalPageNum}页;  
  4.  
  5. <a href="${pageContext.request.contextPath}${page.url}">首页</a>
  6.   
  7. <a
  8. 	href="${pageContext.request.contextPath}${page.url}&num=${page.proviousPageNum}">上一页</a>
  9.   
  10.  
  11. <!-- 这里实现上一页下一页效果 -->
  12. <a
  13. 	href="${pageContext.request.contextPath}${page.url}&num=${page.nextPageNum}">下一页</a>
  14. <a
  15. 	href="${pageContext.request.contextPath}${page.url}&num=${page.totalPageNum}">尾页</a>
  16.   
  17.  
  18.  
  19. <c:forEach begin="${page.startPage}" end="${page.endPage}" var="num">
  20. 	<!-- 这里实现页码条 -->
  21. 	<a href="${pageContext.request.contextPath}${page.url}&num=${num}">${num}</a>
  22. </c:forEach>
  23.  
  24. <select id="s1">
  25. 	<!-- 选项下拉页码-->
  26. 	<c:forEach begin="1" end="${page.totalPageNum}" var="num">
  27. 		<option value="${num}" ${page.pageNum==num? 'selected="selected"':''}>${num}</option>
  28.  
  29. 	</c:forEach>
  30. </select>
  31.  
  32. <!--输入指定页码跳转-->
  33.  
  34. <input type="text" size="3" id="input1" value="" />
  35. <input type="button" id="bt1" value="跳转" />
  36.  
  37. 	<script type="text/javascript">
  38.     		window.οnlοad=function(){
  39.     			document.getElementById("s1").οnchange=function(){
  40.     				window.location.href="${pageContext.request.contextPath}${page.url}&num="+this.value;
  41.     			}
  42.     			document.getElementById("bt1").οnclick=function(){
  43.     				var num = document.getElementById("input1");
  44.     				//验证
  45.     				if(!/^[1-9][0-9]*$/.test(num.value)){
  46.     					alert("请输入正确的页码");
  47.     					return;
  48.     				}
  49.     				if(num.value>${page.totalPageNum}){
  50.     					alert("页码不能超过总页数");
  51.     					return;
  52.     				}
  53.     				window.location.href="${pageContext.request.contextPath}${page.url}&num="+num.value;
  54.     			}
  55.     		}
  56.      	</script>
  57.  
  58. <!-- 分页结束 -->
效果

二、JDBC处理大数据大文本和大二进制数据的存取 

  大数据也称之为LOB(Large Objects)，LOB又分为：clob和blob

clob用于存储大文本。Text

blob用于存储二进制数据，例如图像、声音


  对MySQL而言只有blob，而没有clob，mysql存储大文本采用的是Text，Text和blob分别又分为：

TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT

TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB

  1. //大文本数据存储
  2. 	@Test
  3. 	public void testWriteClob(){
  4. 		/*
  5. 		 * 需要的数据库
  6. 		create table t1(
  7. 			id int primary key,
  8. 			content longtext
  9. 		);
  10. 		 */
  11. 		Connection conn=null;
  12. 		PreparedStatement stmt=null;
  13. 		ResultSet rs=null;
  14. 				try {
  15. 			conn=JdbcUtil.getConnection();
  16. 			stmt=conn.prepareStatement("insert into t1(id,content) values(?,?)");
  17. 			stmt.setInt(1, 1);
  18. 			File file=new File("src/dw.txt");
  19. 			Reader  reader=new FileReader(file);
  20. 			stmt.setCharacterStream(2, reader,(int)file.length());
  21. 			stmt.executeUpdate();
  22. 		} catch (Exception e) {
  23. 			e.printStackTrace();
  24. 		}finally{
  25. 			JdbcUtil.release(rs,stmt, conn);
  26. 		}
  27. 		
  28. 	}
  29. 	@Test //大文本数据读取
  30. 	public void testReadClob(){
  31. 		Connection conn=null;
  32. 		PreparedStatement stmt=null;
  33. 		ResultSet rs=null;
  34. 				try {
  35. 			conn=JdbcUtil.getConnection();
  36. 			stmt=conn.prepareStatement("select * from t1 where id=1");
  37. 			rs=stmt.executeQuery();
  38. 			if(rs.next()){
  39. 				//存储到D盘
  40. 				Writer w =new FileWriter("d:/dw.txt");
  41. 				Reader r =rs.getCharacterStream("content");//获取指定列的值
  42. 				char c[] =new char[1024];
  43. 				int len =-1;
  44. 				while((len=r.read(c))!=-1){
  45. 					w.write(c,0,len);
  46. 				}
  47. 				r.close();
  48. 				w.close();
  49. 			}
  50. 		} catch (Exception e) {
  51. 			e.printStackTrace();
  52. 		}finally{
  53. 			JdbcUtil.release(rs,stmt, conn);
  54. 		}
  55. 	}
  56. 		
  57. 	@Test <span style="color:#3333ff;">//二进制的存储</span>
  58. 		public void testWriteBlob(){
  59. 		/*
  60. 		create table t2(
  61. 			id int primary key,
  62. 			content longblob
  63. 		);
  64. 		 */
  65. 		Connection conn=null;
  66. 		PreparedStatement stmt=null;
  67. 		ResultSet rs=null;
  68. 				try {
  69. 			conn=JdbcUtil.getConnection();
  70. 			stmt=conn.prepareStatement("insert into t2(id,content)values(?,?)");
  71. 			stmt.setInt(1,1);
  72. 			InputStream in =new FileInputStream("src/125q.jpg");
  73. 			stmt.setBinaryStream(2, in,in.available());
  74. 			stmt.executeUpdate();
  75. 		} catch (Exception e) {
  76. 			e.printStackTrace();
  77. 		}finally{
  78. 			JdbcUtil.release(rs,stmt, conn);
  79. 		}
  80. 	}
  81. 	
  82. 	@Test //二进制的取出
  83. 	public void testReadBlob(){
  84. 		Connection conn=null;
  85. 		PreparedStatement stmt=null;
  86. 		ResultSet rs=null;
  87. 				try {
  88. 			conn=JdbcUtil.getConnection();
  89. 			stmt=conn.prepareStatement("select * from t2 where id=1");
  90. 			rs=stmt.executeQuery();
  91. 			if(rs.next()){
  92. 				//存储到当前目录
  93. 				InputStream in =rs.getBinaryStream("content");//读取content值
  94. 				
  95. 				OutputStream out =new FileOutputStream("d:/1.jpg");
  96. 				int len =-1;
  97. 				byte b[] =new byte[1024];
  98. 				while((len=in.read(b))!=-1){
  99. 					out.write(b,0,len);
  100. 				}
  101. 				in.close();
  102. 				out.close();
  103. 			}
  104. 		} catch (Exception e) {
  105. 			e.printStackTrace();
  106. 		}finally{
  107. 			JdbcUtil.release(rs,stmt, conn);
  108. 		}
  109. 	}

三、批处理

       JDBC提供了数据库batch处理的能力，在数据大批量操作（新增、删除等）的情况下可以大幅度提升系统的性能。

Statement：他的实现中。

有一个List集合，元素就是SQL语句

addBatch(sql);相当于    List.add(sql);

 

executeBatch();//  把List中的所有语句一次性的交给数据库处理

clearBatch();// 清空List中的元素

 

PreparedStatement：适合语句相同，但参数不同的批处理。

  1. 	@Test //插入两条删除1条 批处理
  2. 	public void testBatch1(){
  3. 		 /*create table t3(
  4. 				 	id int primary key,
  5. 				 	name varchar(100)
  6. 				 );*/
  7. 		Connection conn=null;
  8. 		Statement stmt=null;
  9. 		ResultSet rs=null;
  10. 		
  11. 		try {
  12. 			conn=JdbcUtil.getConnection();
  13. 			stmt=conn.createStatement();
  14. 					
  15. 			String sq1="insert into t3(id,name)values(1,'ww')";
  16. 			String sq2="insert into t3(id,name)values(2,'gg')";
  17. 			String sq3="delete from t3 where id =1";
  18. 	
  19. 			
  20. 			stmt.addBatch(sq1);//把三条语句添加到List缓存中
  21. 			stmt.addBatch(sq2);
  22. 			stmt.addBatch(sq3);
  23. 			
  24. 			stmt.executeBatch();//批量交给数据库处理
  25. 		} catch (Exception e) {
  26. 			e.printStackTrace();
  27. 		}finally{
  28. 			JdbcUtil.release(rs, stmt, conn);
  29. 		}
  30. 	}
  31. 	@Test //向表中插入5条记录 语句一样 参数值不一样
  32. 	public void testBatch2(){
  33. 		Connection conn=null;
  34. 		PreparedStatement stmt=null;    //使用preparedStatement
  35. 		ResultSet rs=null;
  36. 		
  37. 		try {
  38. 			conn=JdbcUtil.getConnection();
  39. 			stmt=conn.prepareStatement("insert into t3(id,name) values(?,?)");
  40. 			for(int i=0;i<10;i++){
  41. 				 stmt.setInt(1, i+1);
  42. 				 stmt.setString(2, "第"+i+"条");
  43. 				 stmt.addBatch();
  44. 			}
  45. 			stmt.executeBatch();
  46. 		} catch (Exception e) {
  47. 			e.printStackTrace();
  48. 		}finally{
  49. 			JdbcUtil.release(rs, stmt, conn);
  50. 		}
  51. 	}
  52. 	@Test //使用批处理处理1W条数据
  53. 	public void testBatch3(){
  54. 		Connection conn=null;
  55. 		PreparedStatement stmt=null;
  56. 		ResultSet rs=null;
  57. 		
  58. 		try {
  59. 			conn=JdbcUtil.getConnection();
  60. 			stmt=conn.prepareStatement("insert into t3(id,name) values(?,?)");
  61. 			for(int i=0;i<10000;i++){
  62. 				stmt.setInt(1, i+1);
  63. 				stmt.setString(2, "第"+i+"条");
  64. 				stmt.addBatch();
  65. 				
  66. 				if(i%1000==0){    //防止内存溢出
  67. 					stmt.executeBatch();
  68. 					stmt.clearBatch();//清除缓存
  69. 				}
  70. 			}
  71. 			stmt.executeBatch();
  72. 		} catch (Exception e) {
  73. 			e.printStackTrace();
  74. 		}finally{
  75. 			JdbcUtil.release(rs, stmt, conn);
  76. 		}
  77. 		
  78. 	}

四、存储过程 Stored Procedure

是在大型数据库系统中，一组为了完成特定功能的SQL 语句集，相当于自定义的方法

  1. <span style="color:#333333;">/*连接字符串      </span><span style="color:#ff0000;"> delimiter 是设置语句结束的符号   </span><span style="color:#333333;">
  2. </span><span style="color:#ff0000;">delimiter</span><span style="color:#333333;"> $$     
  4. CREATE PROCEDURE demoSp(IN inputParam VARCHAR(255), INOUT inOutParam varchar(255))
  5. BEGIN
  6.     SELECT CONCAT('连接字符串---', inputParam) into inOutParam;
  7. END $$
  9. delimiter ;
  10.  */
  11. //调用
  12. public class ProcedureDemo {
  13. 	@Test
  14. 	public void test(){
  15. 		Connection conn = null;
  16. 		CallableStatement stmt = null;
  17. 		ResultSet rs = null;
  18. 		try{
  19. 			conn = JdbcUtil.getConnection();
  20. 			stmt = conn.prepareCall("{call demoSp(?,?)}");//固定的
  21. 			//输入参数，设置值
  22. 			stmt.setString(1, "值");
  23. 			//输出参数要注册类型
  24. 			stmt.registerOutParameter(2, Types.VARCHAR);
  25. 			//执行存储过程
  26. 			stmt.execute();
  27. 			//获取输出参数的值
  28. 			String value = stmt.getString(2);
  29. 			System.out.println(value);
  30. 		}catch(Exception e){
  31. 			e.printStackTrace();
  32. 		}finally{
  33. 			JdbcUtil.release(rs, stmt, conn);
  34. 		}
  35. 	}</span>

五、事务

MySQL中事务是默认提交 一条语句就是一个事务

MySQL事务控制

start transaction:开启事务 后面的语言处于一个事务中

rollback:事务结束 不提交

commit:提交事务

JDBC控制事务方法

Start transaction =Connection.setAutoCommite(false)

rollback=Connection.rollback()

commit=Connection.commit()

六.事务的特性原理

1.原子性：原子性是指事务是一个不可分离；事务操作要么全部成功要么全部失败 例如转账给人 A成功转账给B B收到钱 是要么成功要么失败 不会发生A钱打出去了 B没有收到钱

2.一致性：事务必须使数据库从一个一致性状态到另一个一致性状态例如 A有100 B有100 合起来是200 A转账给B 50后 合计起来还是200 这就是一致性

3.隔离性：多个用户访问数据库时 数据库为每个用户开启一个线程不能被其他用户的事务操作数据干扰 多个用户间的并发事务要隔离 数据库在并发执行的事务间提供不同级别的隔离

4.持久性:是指事务成功结束后 它对数据库所做的跟新是永久保存的 即使发生系统崩溃 数据库重新启动 数据还可以恢复到事务成功结束时的状态


七、事务的隔离级别

如果不考虑事务隔离性可能会出现以下情况

1.脏读一个事务读到了另一个线程中未提交的数据

2.不可重复读:一个线程中的事务读到了另一个线程中Update的数据,前后读到的内容不一致

3.虚读 一个线程中的事务读到另一个线程中提交的insert或detele的数据,前后读到的记录条数不一致

事务的隔离级别：

READ UNCOMMITTED  脏读、不可重复读、虚读都有可能发生

READ COMMITTED 能避免脏读；不可重复读、虚读有可能发生（Oracle默认）

REPEATABLE READ 能避免脏读、不可重复读；虚读有可能发生（MySQL默认）

SERIALIZABLE 能避免脏读、不可重复读、虚读的发生

级别遇高 性能越低 数据越安全

MySQL：

查看当前数据库的隔离级别：

select @@tx_isolation;

更改隔离级别：（开启事务之前更改）

set transaction isolation level 四个级别之一

JDBC中设置隔离级别方法

Connection.setTransactionIsolation(int level);


八、丢失跟新

             是指一个线程的事务覆盖了另一个线程已经提交的数据 

  例如：   数据      id:1  name：A   age=13 

           第一个线程查询数据  第二个线程查询数据 

      name:A  改为B  name:A

age=13age=18 改为23

保存后结果应该是

 id:1  name:B  age:23   但是结果却是     id:1 name:A  age=23     第二个线程覆盖了第一个

            

解决：利用数据库的锁机制

共享锁：可以有多把。

 

独占锁：（排它锁）只能有一把。只要外面有共享锁，会等。update、insert、delete会自动加独占锁。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/422356
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号