数据库的事件（超详细）

数据库的事件

一、界说

在 Java 中，事件管理是确保一组利用要么全部乐成要么全部失败的一种机制。事件通常用于数据库利用，以确保数据的一致性和完整性。Java 提供了多种事件管理方式，包括编程式事件管理和声明式事件管理。
理解：MySQL：每一条语句都属于独立事件,默认主动管理提交的。
假如需要把多条语句当成一个整体，那么就需要把多条语句放在一个事件里面
二、事件的特性（ACID）

原子性（ Atomicity ）、一致性（ Consistency ）、隔离性（ Isolation ）和长期性（ Durability ）
原子性：事件是数据库的逻辑工作单元，事件中包含的各利用要么都完成，要么都不完成
一致性：事件实行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含乐成事件提交的结果时，就说数据库处于一致性状态。假如数据库系统 运行中发生故障，有些事件尚未完成就被迫中断，这些未完成事件对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不精确的状态，或者说是 不一致的状态。
**隔离性：**一个事件的实行不能别的事件干扰。即一个事件内部的利用及利用的数据对别的并发事件是隔离的，并发实行的各个事件之间不能相互干扰。
长期性：指一个事件一旦提交，它对数据库中的数据的改变就应该是永世性的。接下来的别的利用或故障不应该对实在行结果有任何影响。
三、编程式事件管理

在编程式事件管理中，开辟者显式地控制事件的开始、提交和回滚。这通常通过 JDBC（Java Database Connectivity）来实现。
开启事件：start transaction 提交事件：commit; 回滚事件：rollback

1. import java.sql.Connection;
2. import java.sql.DriverManager;
3. import java.sql.SQLException;
5. public class TransactionExample {
6.     public static void main(String[] args) {
7.         Connection conn = null;
8.         try {
9.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
10.             conn.setAutoCommit(false);  // 关闭自动提交
12.             // 执行 SQL 语句（需自己给数据库建表）
13.             conn.createStatement().executeUpdate("INSERT INTO bank (name, money) VALUES ('Alice', 1000)");
14.             conn.createStatement().executeUpdate("INSERT INTO bank (name, money) VALUES ('Bob', 1500)");
16.             conn.commit();  // 提交事务
17.         } catch (SQLException e) {
18.             if (conn != null) {
19.                 try {
20.                     conn.rollback();  // 回滚事务
21.                 } catch (SQLException ex) {
22.                     ex.printStackTrace();
23.                 }
24.             }
25.             e.printStackTrace();
26.         } finally {
27.             if (conn != null) {
28.                 try {
29.                     conn.close();
30.                 } catch (SQLException e) {
31.                     e.printStackTrace();
32.                 }
33.             }
34.         }
35.     }
36. }

复制代码

四、事件的隔离级别

可以通过 @Transactional 注解的 isolation 属性设置事件的隔离级别，如 READ_COMMITTED、REPEATABLE_READ 等。
1、事件里可能出现的征象：
脏读：一个线程中的事件读到了另外一个线程中未提交的数据。
**不可重复读：**一个线程中的事件读到了另外一个线程中已经提交的update的数据。
虚读：一个线程中的事件读到了另外一个线程中已经提交的insert的数据。
2、4种隔离级别：
   READ UNCOMMITTED（读未提交）： 脏读、不可重复读、虚读有可能发生。
  READ COMMITTED（读已提交）： 制止脏读的发生，不可重复读、虚读有可能发生。
  REPEATABLE READ（可重复读）： 制止脏读、不可重复读的发生，虚读有可能发生。
  SERIALIZABLE（串行化）： 制止脏读、不可重复读、虚读的发生。
  3、MySQL和ORACLE默认的隔离级别
MySQL：默认REPEATABLE READ
ORACLE：默认READ COMMITTED
4、SQL命令：查察当前的隔离级别
   ​ SELECT @@SESSION.transaction_isolation;
  ​ 设置当前的事件隔离级别
   ​ set transaction isolation level READ UNCOMMITTED
  图片理解：

五、通过JDBC利用事件

1、需求：
需求：模拟银行用户转账
需求一：实现取钱利用。
需求二：实现存钱利用。
需求三：实现转账利用，要考虑多对用户，每对用户之间两两存取钱。
需求三的思想：每对用户实现两两存取钱，则这一对就共享同一个connection，但与其他对之间的connection是不一样的，相当于多线程之间的局部变量是不一样的，也就需要用到共享局部变量的思想，ThreadLocal来办理需求。
2、代码实现：

1. package com.qf.jdbc01;
3. import com.utils.DBUtil;
5. import java.sql.Connection;
6. import java.sql.PreparedStatement;
7. import java.sql.SQLException;
9. public class Test02 {
10.     public static void main(String[] args) {
11.         //传参
12.         try {
13.             saveMoney(1,200);
14.         } catch (SQLException e) {
15.             throw new RuntimeException(e);
16.         }
17.         try {
18.             withdrawMoney(2,300);
19.         } catch (SQLException e) {
20.             throw new RuntimeException(e);
21.         }
22.     }
23.     //场景一：取钱
24.    public static void withdrawMoney(int id,float money) throws SQLException {
25.         Connection connection = null;
26.         PreparedStatement statement = null;
27.        try {
28.            connection = DBUtil.getConnection();
29.            System.out.println(connection);
30.            String sql = "update bank set money = money-? where id = ?";
31.            statement = connection.prepareStatement(sql);
32.            statement.setFloat(1,money);
33.            statement.setInt(2,id);
34.            statement.executeUpdate();
35.        } finally {
36.            DBUtil.close(connection,statement,null);
37.        }
38.    }
39.    //场景二、存钱
40.     public static void saveMoney(int id,float money) throws SQLException {
41.         Connection connection = null;
42.         PreparedStatement statement = null;
43.         try {
44.             connection = DBUtil.getConnection();
45.             System.out.println(connection);
46.             String sql = "update bank set money=money+? where id=?";
47.             statement = connection.prepareStatement(sql);
48.             statement.setFloat(1,money);
49.             statement.setInt(2,id);
50.             statement.executeUpdate();
52.         } finally {
53.             DBUtil.close(connection,statement,null);
54.         }
56.     }
57.     //场景三：转账
58. //        try {
59. //
60. //            DBUtil.startTransaction();
61. //
62. //            withdrawMoney(1,200);
63. //
64. //            //System.out.println(10/0);
65. //
66. //            saveMoney(2,200);
67. //
68. //            DBUtil.commit();
69. //
70. //        } catch (Exception e) {
71. //            try {
72. //                DBUtil.rollback();
73. //            } catch (SQLException ex) {
74. //                throw new RuntimeException(ex);
75. //            }
76. //  }
77. //   }
79. }

复制代码

DButil代码实现：

1. package com.utils;
3. import java.io.IOException;
4. import java.lang.reflect.Field;
5. import java.sql.*;
6. import java.util.ArrayList;
7. import java.util.List;
8. import java.util.Properties;
10. /**
11. * 数据库工具类
12. */
13. public class DBUtil {
15.     private static String url;
16.     private static String username;
17.     private static String password;
19.     private static final ThreadLocal<Object> local  ;//使用ThreadLocal处理线程安全的问题
21.     static{
22.         Properties properties = new Properties();
23.         try {
24.             properties.load(DBUtil.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
25.         } catch (IOException e) {
26.             throw new RuntimeException(e);
27.         }
28.         String driverName = properties.getProperty("driverName");
29.         url = properties.getProperty("url");
30.         username = properties.getProperty("username");
31.         password = properties.getProperty("password");
33.         try {
34.             Class.forName(driverName);
35.         } catch (ClassNotFoundException e) {
36.             throw new RuntimeException(e);
37.         }
38.         local = new ThreadLocal<>();
39.     }
41.     /**
42.      * 获取连接对象
43.      */
44.     public static Connection getConnection() throws SQLException {
45.         Connection connection = DriverManager.getConnection(url,username,password);
46.         if (connection == null){
47.             connection = DriverManager.getConnection(url,username,password);
48.             local.set(connection);//将Connection对象添加到local中
49.         }
50.         return connection;
51.     }
53.     /**
54.      * 关闭资源
55.      */
56.     public static void close(Connection connection, Statement statement, ResultSet resultSet){
57.         if(resultSet != null){
58.             try {
59.                 resultSet.close();
60.             } catch (SQLException e) {
61.                 throw new RuntimeException(e);
62.             }
63.         }
64.         if(statement != null){
65.             try {
66.                 statement.close();
67.             } catch (SQLException e) {
68.                 throw new RuntimeException(e);
69.             }
70.         }
71.         if(connection != null){
72.             try {
73.                 if (connection.getAutoCommit()){
74.                     connection.close();
75.                     if (connection == null) {
76.                         connection.close();
77.                         local.set(null);
78.                     }
79.                 }
80.             } catch (SQLException e) {
81.                 throw new RuntimeException(e);
82.             }
83.         }
84.     }
85.     /**
86.      * 开启事务
87.      */
88.     public static void startTransaction() throws SQLException {
89.         Connection connection = getConnection();
90.         connection.setAutoCommit(false);
91.     }
92.     /**
93.      * 提交事务
94.      */
95.     public static void commit() throws SQLException {
96.         Connection connection = (Connection) local.get();
97.         if(connection != null){
98.             connection.commit();
99.             local.set(null);
100.         }
101.     }
102.     /**
103.      * 事务回滚
104.      */
105.     public static void rollback() throws SQLException {
106.         Connection connection = (Connection) local.get();
107.         if (connection != null){
108.             connection.rollback();
109.             local.set(null);
110.         }
111.     }
113.     /**
114.      * 更新数据（添加、删除、修改）
115.      */
116.     public static int commonUpdate(String sql,Object... params) throws SQLException {
117.         Connection connection = null;
118.         PreparedStatement statement = null;
119.         try {
120.             connection = getConnection();
121.             statement = connection.prepareStatement(sql);
122.             paramHandler(statement,params);
123.             int num = statement.executeUpdate();
124.             return num;
125.         }finally {
126.             close(connection,statement,null);
127.         }
128.     }
130.     /**
131.      * 添加数据 - 主键回填(主键是int类型可以返回)
132.      */
133.     public static int commonInsert(String sql,Object... params) throws SQLException {
134.         Connection connection = null;
135.         PreparedStatement statement = null;
136.         ResultSet resultSet = null;
137.         try {
138.             connection = getConnection();
139.             statement = connection.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
140.             paramHandler(statement,params);
141.             statement.executeUpdate();
143.             resultSet = statement.getGeneratedKeys();
144.             int primaryKey = 0;
145.             if(resultSet.next()){
146.                 primaryKey = resultSet.getInt(1);
147.             }
148.             return primaryKey;
149.         }finally {
150.             close(connection,statement,resultSet);
151.         }
152.     }
154.     /**
155.      * 查询多个数据
156.      */
157.     public static <T> List<T> commonQueryList(Class<T> clazz,String sql, Object... params) throws SQLException, InstantiationException, IllegalAccessException {
159.         Connection connection = null;
160.         PreparedStatement statement = null;
161.         ResultSet resultSet = null;
163.         try {
164.             connection = getConnection();
165.             statement = connection.prepareStatement(sql);
166.             paramHandler(statement,params);
167.             resultSet = statement.executeQuery();
169.             //获取表数据对象
170.             ResultSetMetaData metaData = resultSet.getMetaData();
171.             //获取字段个数
172.             int count = metaData.getColumnCount();
174.             List<T> list = new ArrayList<>();
176.             while(resultSet.next()){
178.                 T t = clazz.newInstance();
180.                 //获取字段名及数据
181.                 for (int i = 1; i <= count; i++) {
182.                     String fieldName = metaData.getColumnName(i);
183.                     Object fieldVal = resultSet.getObject(fieldName);
184.                     setField(t,fieldName,fieldVal);
185.                 }
186.                 list.add(t);
187.             }
188.             return list;
189.         } finally {
190.             DBUtil.close(connection,statement,resultSet);
191.         }
192.     }
194.     /**
195.      * 查询单个数据
196.      */
197.     public static <T> T commonQueryObj(Class<T> clazz,String sql, Object... params) throws SQLException, InstantiationException, IllegalAccessException {
199.         Connection connection = null;
200.         PreparedStatement statement = null;
201.         ResultSet resultSet = null;
203.         try {
204.             connection = getConnection();
205.             statement = connection.prepareStatement(sql);
206.             paramHandler(statement,params);
207.             resultSet = statement.executeQuery();
209.             //获取表数据对象
210.             ResultSetMetaData metaData = resultSet.getMetaData();
211.             //获取字段个数
212.             int count = metaData.getColumnCount();
214.             if(resultSet.next()){
216.                 T t = clazz.newInstance();
218.                 //获取字段名及数据
219.                 for (int i = 1; i <= count; i++) {
220.                     String fieldName = metaData.getColumnName(i);
221.                     Object fieldVal = resultSet.getObject(fieldName);
222.                     setField(t,fieldName,fieldVal);
223.                 }
224.                 return t;
225.             }
226.         } finally {
227.             DBUtil.close(connection,statement,resultSet);
228.         }
229.         return null;
230.     }
232.     /**
233.      * 处理statement对象参数数据的处理器
234.      */
235.     private static void paramHandler(PreparedStatement statement,Object... params) throws SQLException {
236.         for (int i = 0; i < params.length; i++) {
237.             statement.setObject(i+1,params[i]);
238.         }
239.     }
241.     /**
242.      * 获取当前类及其父类的属性对象
243.      * @param clazz class对象
244.      * @param name 属性名
245.      * @return 属性对象
246.      */
247.     private static Field getField(Class<?> clazz,String name){
249.         for(Class<?> c = clazz;c != null;c = c.getSuperclass()){
250.             try {
251.                 Field field = c.getDeclaredField(name);
252.                 return field;
253.             } catch (NoSuchFieldException e) {
254.             } catch (SecurityException e) {
255.             }
256.         }
257.         return null;
258.     }
260.     /**
261.      * 设置对象中的属性
262.      * @param obj 对象
263.      * @param name 属性名
264.      * @param value 属性值
265.      */
266.     private static void setField(Object obj,String name,Object value){
268.         Field field = getField(obj.getClass(), name);
269.         if(field != null){
270.             field.setAccessible(true);
271.             try {
272.                 field.set(obj, value);
273.             } catch (IllegalArgumentException e) {
274.                 e.printStackTrace();
275.             } catch (IllegalAccessException e) {
276.                 e.printStackTrace();
277.             }
278.         }
279.     }
280. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。