批处理和事务

最新推荐文章于 2024-04-30 07:30:00 发布
最新推荐文章于 2024-04-30 07:30:00 发布
阅读量531 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44651031/article/details/98109550
版权

1.批处理：批量对数据库作增，删，改的操作。
批处理的优点：减少应用程序与数据库服务器交互次数，从而提高项目的运行性能。

2.批量执行多条sql语句，sql语句不相同,返回类型相同

eg:public static void main(String[] args) throws SQLException {
	//声明连接对象，执行对象
	Connection conn=null;
	Statement state=null;
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/studentmanager", "root", "123");
		//3.准备Sql语句
		String sql1="insert into t_student(sname,phone) values('cc','120')";
		String sql2="update t_student set sname='cs',phone='110' where sname='cc'";
		String sql3="delete from t_student where sname='cs'";
		//4.创建执行对象
		state=conn.createStatement();
		//5.用执行对象调用相应的方法将Sql语句加入批处理
		state.addBatch(sql1);
		state.addBatch(sql2);
		state.addBatch(sql3);
		//6.用执行对象调用相应方法将批处理的Sql语句传到数据库中执行，并等到结果
		int[] result=state.executeBatch();
		//7.处理结果
		for (int i : result) {
			System.out.println(i);
		}
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//8.关对象
		if (state!=null) {
			state.close();
		}
		if (conn!=null) {
			conn.close();
		}
	}
}

3.批量插入100条记录，sql语句相同，只是参数值不同

eg：public static void main(String[] args) throws SQLException {
	//声明连接对象，执行对象
	Connection conn=null;
	PreparedStatement state=null;
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/studentmanager", "root", "123");
		//3.准备Sql语句
		String sql1="insert into t_student(sname,phone) values(?,?)";
	
		//4.创建执行对象
		state=conn.prepareStatement(sql1);
		//5.用执行对象调用相应的方法向sql语句的占位符传参,将参数添加到批处理中
		for (int i = 1; i <=100; i++) {
			state.setString(1, "a"+i);
			state.setString(2, "11"+i);
			//将参数添加到批处理中
			state.addBatch();
		}
		//6.将批处理的数据传到数据库中去执行，并得到结果
		int[] result=state.executeBatch();
		//7.处理结果
		for (int i : result) {
			System.out.print(i+"\t");
		}
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//8.关对象
		if (state!=null) {
			state.close();
		}
		if (conn!=null) {
			conn.close();
		}
	}
}

4.批量插入10000条记录，Sql语句相同，需要分批次提交

eg:public static void main(String[] args) throws SQLException {
	//声明连接对象，执行对象
	Connection conn=null;
	PreparedStatement state=null;
	//声明一个二维数组存结果
	int[][] nums=new int[10][100];
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/studentmanager", "root", "123");
		//3.准备Sql语句
		String sql1="insert into t_student(sname,phone) values(?,?)";
	
		//4.创建执行对象
		state=conn.prepareStatement(sql1);
		//5.用执行对象调用相应的方法向sql语句的占位符传参,将参数添加到批处理中
		for (int i = 1; i <=1000; i++) {
			state.setString(1, "b"+i);
			state.setString(2, "11"+i);
			//将参数添加到批处理中
			state.addBatch();
			
			if (i%100==0) {
				//6.将批处理的数据传到数据库中去执行，并得到结果
				nums[i/100-1]=state.executeBatch();
				//清空批处理原来的数据
				state.clearBatch();
			}
		}
		
		//7.处理结果
		for (int[] is : nums) {
			for (int is2 : is) {
				System.out.print(is2+"\t");
			}
			System.out.println();
		}
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//8.关对象
		if (state!=null) {
			state.close();
		}
		if (conn!=null) {
			conn.close();
		}
	}
}

5.事务：由一条或多条SQL语句组成执行单元，这个执行单元要么同时执行成功，要么同时执行失败。
作用：保证数据安全。

6.事务常用语法：同一个事务要用同一个连接对象。
数据库 Java程序
开启事务 start transaction 连接对象.setAutoCommit(false)
提交事务 commit; 连接对象.commit();
回滚事务 rollback; 连接对象.rollback();
eg:#开启事务
START TRANSACTION;
update t_bank set money=money-200 where acount=‘张三’;
update t_bank set money=money+200 where acount=‘李四’;

#回滚事务
ROLLBACK;

#提交事务
commit;

eg:public static void main(String[] args) throws SQLException {
	//声明连接对象，执行对象
	Connection conn=null;
	Statement state=null;
	//创建jdbc工具类的对象
	BaseDAO bd=new BaseDAO();
	//准备转账的Sql语句
	String sql1="update t_bank set money=money-200 where acount='张三'";
	String sql2="update t_bank set money=money+200 where acount='李四'";
	try {
		//获得连接对象
		conn=bd.getConnection();
		//通过连接对象创建执行对象
		state=conn.createStatement();
		
		//开启事务 
		conn.setAutoCommit(false);
		
		//实现银行转账的业务
		int result1=state.executeUpdate(sql1);
		int num=8/0;
		int result2=state.executeUpdate(sql2);
		//处理结果
		if (result1>0&&result2>0) {
			//提交事务
			conn.commit();
			System.out.println("转账成功");
		}else {
			System.out.println("转账失败");
		}
	} catch (Exception e) {
		//回滚事务
		conn.rollback();
		e.printStackTrace();
	}finally {
		//关闭对象
		bd.closeObject2();
	}
}

7.事务的特性：ACID
7.1:原子性(Atomicity )：事务是数据库的逻辑工作单位，事务中包含的各操作要么都完成，要么 都不完成
7.2:一致性(Consistency)：事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性 状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状 态。如果数据库系统 运行中发生故障，有些事务尚未完成就被迫中断，这些 未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处 于一种不正确的状态，或者说是 不一致的状态。
7.3:隔离性( Isolation)：一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数 据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。
7.4:持久性(Durability)：指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。 接下来的其它操作或故障不应该对其执行结果有任何影响。

8.事务隔离的错误
8.1：脏读：一个线程中的事务读到了另外一个线程中未提交的数据。
8.2：不可重复读：一个线程中的事务读到了另外一个线程中已经提交的update的数据。
8.3：虚读：一个线程中的事务读到了另外一个线程中已经提交的insert的数据。

9.事务的级别：事务级别越高，安全性越高，效率越低。
9.1：READ UNCOMMITTED 脏读、不可重复读、虚读有可能发生。
9.2：READ COMMITTED 避免脏读的发生，不可重复读、虚读有可能发生。
9.3：REPEATABLE READ 避免脏读、不可重复读的发生，虚读有可能发生。
9.4：SERIALIZABLE 避免脏读、不可重复读、虚读的发生。
MySql：REPEATABLE READ Oracle：READ COMMITTED
在这里插入图片描述

10.设置事务的隔离：set [GLOBAL | SESSION] transaction isolation level 级别;
注意：设置完事务的隔离级别后，要重新连接数据库才能生效。
查看当前的隔离级别：select @@tx_isolation;

11.（扩展）存大数据：
11.1：存大文本：text,longtext

eg:public static void main(String[] args) {
	/**
	 * 声明连接对象，执行对象，结果集对象
	 */
	Connection conn=null;
	PreparedStatement state=null;
	ResultSet rs=null;
	
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool", "root", "123");
		//3.准备Sql语句
		String sql="insert into t_book(bookName,content) values(?,?)";
		//4.创建执行对象
		state=conn.prepareStatement(sql);
		//创建存的文件对象
		File f1=new File("aa/灵剑山.txt");
		//用执行 对象调用相应的方法来给占位符传参
		state.setString(1, f1.getName());
		state.setCharacterStream(2, new FileReader(f1), (int)f1.length());
		//5.用执行对象调用相应的方法将Sql语句传入数据库执行，并接收结果
		int result=state.executeUpdate();
		//6.处理结果
		if (result>0) {
			System.out.println("添加成功");
		}else {
			System.out.println("添加失败");
		}
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//7.关对象
		try {
			if (rs!=null) {
				rs.close();
			}
			if (state!=null) {
				state.close();
			}
			if (conn!=null) {
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


public static void main(String[] args) {
	/**
	 * 声明连接对象，执行对象，结果集对象
	 */
	Connection conn=null;
	PreparedStatement state=null;
	ResultSet rs=null;
	
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool", "root", "123");
		//3.准备Sql语句
		String sql="select bookName,content from t_book";
		//4.创建执行对象
		state=conn.prepareStatement(sql);
		//5.用执行对象调用相应的方法将Sql语句传入数据库执行，并接收结果
		rs=state.executeQuery();
		//6.处理结果
		while (rs.next()) {
			String bookName=rs.getString("bookName");
			Reader r=rs.getCharacterStream("content");
			//创建一个写入流，将从数据库读取大文本文件写入到当前项目下
			Writer w=new OutputStreamWriter(new FileOutputStream("bb/"+bookName), "utf-8");
			//边读边写入
			char[] c=new char[100];
			int len=r.read(c);
			while (len!=-1) {
				//读一次写入一次
				w.write(c, 0, len);
				//接着读取
				len=r.read(c);
			}
			r.close();
			w.close();
		}
		
		System.out.println("读取完毕");
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//7.关对象
		try {
			if (rs!=null) {
				rs.close();
			}
			if (state!=null) {
				state.close();
			}
			if (conn!=null) {
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

11.2：存二进制数据数据：blob,longblob

eg:public static void main(String[] args) {
	/**
	 * 声明连接对象，执行对象，结果集对象
	 */
	Connection conn=null;
	PreparedStatement state=null;
	ResultSet rs=null;
	
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool", "root", "123");
		//3.准备Sql语句
		String sql="insert into t_file(fileName,content) values(?,?)";
		//4.创建执行对象
		state=conn.prepareStatement(sql);
		//用执行对象调用相应的方法给占位符
		File f2=new File("aa/2.jpg");
		state.setString(1, f2.getName());
		state.setBinaryStream(2, new FileInputStream(f2), (int)f2.length());
		//5.用执行对象调用相应的方法将Sql语句传入数据库执行，并接收结果
		int result=state.executeUpdate();
		//6.处理结果
		if (result>0) {
			System.out.println("添加成功");
		}else {
			System.out.println("添加失败");
		}
		
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//7.关对象
		try {
			if (rs!=null) {
				rs.close();
			}
			if (state!=null) {
				state.close();
			}
			if (conn!=null) {
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
	
		
	public static void main(String[] args) {
	/**
	 * 声明连接对象，执行对象，结果集对象
	 */
	Connection conn=null;
	PreparedStatement state=null;
	ResultSet rs=null;
	
	try {
		//1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		//2.创建连接对象
		conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool", "root", "123");
		//3.准备Sql语句
		String sql="select fileName,content from t_file";
		//4.创建执行对象
		state=conn.prepareStatement(sql);
		//5.用执行对象调用相应的方法将Sql语句传入数据库执行，并接收结果
		rs=state.executeQuery();
		//6.处理结果
		while (rs.next()) {
			String fileName=rs.getString("fileName");
			InputStream is= rs.getBinaryStream("content");
			
			//创建写入流，将从数据库读取二进制文件写入到当前项目中
			OutputStream os=new FileOutputStream("bb/"+fileName);
			//边读取边写入
			byte[] b=new byte[1024];
			int len=is.read(b);
			while (len!=-1) {
				//读取一次就写入一次
				os.write(b, 0, len);
				//接着读取
				len=is.read(b);
			}
			is.close();
			os.close();
		}
		System.out.println("读取成功");
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		//7.关对象
		try {
			if (rs!=null) {
				rs.close();
			}
			if (state!=null) {
				state.close();
			}
			if (conn!=null) {
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
yiiyyy
关注
【Storm】批处理事务原理以及事务
晚风中的自由
08-10 676
1、批处理 对于容错机制，Storm通过一个系统级别的组件acker，结合xor校验机制判断一个tuple是否发送成功，进而spout可以重发该tuple，保证一个tuple在出错的情况下至少被重发一次。但是在需要精确统计tuple的数量如销售金额场景时，希望每个tuple”被且仅被处理一次” 。Storm 0.7.0引入了Transnational Topology, 它可以保证...
在批处理中使用事务
小坏蛋博客
07-27 408
为了方便认识什么叫做事务，在此举一个例子，最明显的例子银行的转账业务，大家再熟悉不过了，从汇款账户中减去指定金额，并将该金额添加至收款账户中，但是如果在转账的过程中发生程序错误或系统断电等意外情况，就可能导致汇款账户的余额已经减少而收款账户的余额没有增加。这时就需要应用事务对问题进行处理，本实例简单模拟银行转账系统进行账户余额的转账。 在数据库系统中，实际上每一条SQL语句都是一个事务。当这条语句...
事务+批处理
weixin_49428831的博客
09-16 445
事务 概念 数据库认为一个SQL指令就是一个事务 MySQL：每一条语句都属于一个独立的事务 金钱管理一般使用Decimal类型存储， Decimal类型的底层原理是一个字符串 Decimal处理数据是将字符串使用toCharArray转为字符串数组，然后将对应位置的数据一位一位的进行相加 原子性 一个事务中的SQL语句要么同时执行要么同时不执行 在处理银行转账的事务中，对转账的处理是两条SQL语句，如果将其看作两个独立的事务，则可能出现转账者的钱已经减了，但收账者的钱并没有收到，也就是第一条语句执行成功
事务和批处理
weixin_52086701的博客
08-17 185
事务 定义：由一条或多条sql语句组成，要么都成功，要么都失败。 事务分类： ①隐式事务：没有明显的开启或结束标记，比如insert,update,delete语句本身就是一条事务。 ②显式事务：具有明显的开启或结束标记，一般有多条sql语句组成。 mysql显式事务步骤： 1.取消隐式事务自动开启的功能 ：set autocommit=0; 2.开启事务 : start transaction; 3.编写事务需要的sql语句 4.结束事务:提交事务commit(
批处理、事务、批处理与事务结合
weixin_30292843的博客
08-30 444
批处理(batch)------------>好比快递员【不能一件一件的送快递】 - 批处理指的是一次操作中执行多条SQL语句- 批处理相比于一次一次执行效率会提高很多 - 批处理主要是分两步： 1.将要执行的SQL语句保存 2.执行SQL语句 - Statement和PreparedStatement都支持批处理操作，这里我们只需要掌...
JDBC批处理和事务
lalasonghhh的博客
08-23 548
JDBC批处理和事务 第一节 JDBC批处理 批量处理允许将相关的SQL语句分组到批处理中，并通过对数据库的一次调用提交它们。 当需要一次向数据库发送多个SQL语句时，可以减少连接数据库的开销，从而提高性能。 1.1 Statement批处理 以下是使用语句对象的批处理的典型步骤 1 注册驱动获取连接 2 使用*createStatement（）*方法创建Statement对象。 3 使用*se...
JDBC加强(批处理和事务)
最新发布
棉花糖老丫
04-30 506
所谓的事务，如果把多条sql语句看做一个事务，那么这个事务要么一起成功，要么一起失败！！
Storm在批处理和事务方面的机制分析
热门推荐
云计算、分布式架构、K8S、大数据、机器学习、搜索、推荐、广告
01-04 1万+
1、storm事务性topology的提出对于容错机制，Storm通过一个系统级别的组件acker，结合xor校验机制判断一个msg是否发送成功，进而spout可以重发该msg，保证一个msg在出错的情况下至少被重发一次。但是在一些事务性要求比较高的场景中，需要保障一次只有一次的语义，比如需要精确统计tuple的数量等等。Storm 0.7.0引入了Transactional Topology,
Spring框架——批处理（batch）和事务（Transaction）
weixin_30372371的博客
08-30 994
批处理(batch) 批处理(batch)------------>好比快递员【不能一件一件的送快递】 - 批处理指的是一次操作中执行多条SQL语句 - 批处理相比于一次一次执行效率会提高很多 - 批处理主要是分两步： 　　1.将要执行的SQL语句保存 　　2.执行SQL语句 - Statement和PreparedStatement都支持批处理操作，这里我们只需...
ibatis 完美例子 一对多 批处理 事务 和 spring struts2集成
09-10
本文将深入探讨如何利用Ibatis实现一对多关系、批处理、事务管理和与Spring及Struts2的集成。 首先，让我们来看一下“一对多”关系。在数据库设计中，一对多关系很常见，比如一个用户可以有多个订单。在Ibatis中，...
JDBC 事务和批处理 详解（通俗易懂）
Cyan_RA9的博客
06-10 2658
JDBC 第四节 事务和批处理详解！
数据批处理和事务控制
tanx的博客
03-11 207
数据批处理和事务控制
数据库事务和批处理
LBJ_2016_1984_12_30
11-29 303
事务： 事务使用来保证数据操作的完整性 一个业务由若干个一次性的操作组成，这些操作要么都成功，要么都失败 事务的四大特性ACID 原子性（Atomicity）：不可再分 一致性（consistency）：事务执行的前后，数据库是一致的 隔离性（Isolation）：两个事务的操作互不干扰 持久性（Durability）：事务提交后，结果被永久保存 JDBC默认是自动提交事务的，将每一条sql语句都当做一个独立的事务执行 关闭自动提交事务 conn.setAAutoCommit(f
mysql 批处理 事务 区别_批处理、事务、批处理与事务结合
weixin_42108948的博客
02-27 590
批处理(batch)------------>好比快递员【不能一件一件的送快递】- 批处理指的是一次操作中执行多条SQL语句- 批处理相比于一次一次执行效率会提高很多- 批处理主要是分两步：1.将要执行的SQL语句保存2.执行SQL语句- Statement和PreparedStatement都支持批处理操作，这里我们只需要掌握PreparedStatement的批处理方式：- 方法：voi...
批处理&事务
qq_36901488的博客
03-07 649
批处理 @Test public void test() { connection = JDBCUtils.getConnection(); try { // ps = connection.prepareStatement(&quot;insert into user (name,password,loves,email,img) value...
4.事务和批处理的区别：事务和批处理的区别？？？
ADbyCool的博客
07-09 956
跟汤老师学Java笔记：事务和批处理的区别 完成：第一遍 1.事务和批处理的区别? 事务： 事务底层是在数据库方存储SQL，没有提交事务的数据放在数据库的临时表空间。 最后一次提交是把临时表空间的数据提交到数据库服务器执行 消耗的是数据库服务器内存 批处理： 批处理底层是在客户端存储SQL 最后一次执行批处理是把客户端存储的数据发送到数据库服务器执行。 消耗的是客户端的内存。 ...
JDBC（6）事务处理&批量处理
weixin_34326179的博客
10-12 105
事务处理就是当执行多个SQL指令，因某个指令有误，则取消执行所有的命令 它的作用是保证各项的完整性和一致性 JDBC的数据操作时 commit()：提交事务 rollback():回退事务 绝位于java.sql.Connection接口类中 JDBC中的事务操作时默认提交的 可用setAutoCommit(false)来禁止自动提交 Java API中的JDBC...
事务，批处理，连接池概述
m0_55997161的博客
04-05 429
1.JDBC程序中当一个Connection对象创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚。 2.JDBC程序中为了让多个SQL语句作为一个整体执行，需要使用事务 3.调用Connection的setAutoCommit(false)可以取消自动提交事务 4.在所有的SQL语句都成功执行后，调用Connection.commit0:方法提交事务 5.在其中某个操作失败或出现异常时，调用Connection.rollback0:方法回滚事务 转
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值