Java
javaDidacticiel
Implémentation JDBC d'exemples de soumission et d'annulation de transactions
Implémentation JDBC d'exemples de soumission et d'annulation de transactions
1. Examen des méthodes couramment utilisées dans la classe Connection
1.1 L'instruction createStatement() lance une exception SQL ;
Créer une instance d'instruction (c'est-à-dire : Créer un objet d'exécution SQL)
1.2 PreparedStatement prepareStatement(String sql) throws SQLException;
Créer un objet PreparedStatement (c'est-à-dire : créer un objet d'exécution SQL précompilé)
1.3 void setAutoCommit(boolean autoCommit) throws SQLException;
Définir la validation automatique de la transaction (false signifie désactiver la validation automatique, true pour démarrer la validation automatique) >
Valider manuellement la transaction 1.5 void rollback() throws SQLException; Rollback manuel de la transaction 2 Nécessité d'utiliser le rollback de transaction Cas classique : Cas de virement bancaire Transfert Le transfert sortant et entrant constitue une seule transaction. Si le transfert réussit mais que le transfert échoue, la transaction doit être annulée. Sinon, le solde du cédant sera réduit mais le transfert échouera. Remarque : La soumission et l'annulation de la transaction sontappelées via la méthode
fournie par Connection ; essentiellement, la transactionrepose sur l'implémentation de la base de données ; >La méthode de connexion appelle essentiellement le mécanisme de transaction de la base de données. 2.1 Transfert d'activité sans contrôle des transactions
Inconvénients : Si le transfert réussit mais échoue, le solde du cédant sera réduit, mais le solde du cédant restera inchangé
Organigramme du projet
1 package cn.xiangxu.entity; 2 3 import java.sql.Connection; 4 import java.sql.PreparedStatement; 5 import java.util.Scanner; 6 7 import cn.xiangxu.tools.DBUtil; 8 9 public class Test {10 public static void main(String[] args) {11 Scanner scanner = new Scanner(System.in);12 System.out.println("请输入转出用户名：");13 String outName = scanner.nextLine();14 System.out.println("请输入需要转出的资金额度：");15 Double money = Double.parseDouble(scanner.nextLine());16 System.out.println("请输入转入用户名：");17 String inName = scanner.nextLine();18 System.out.println("转出账户为：" + outName + "转出金额为：" + money + "转入账户为：" + inName);19 20 21 Connection conn = null;22 try {23 conn = DBUtil.getConnection(); // 实例化连接对象24 25 // conn.setAutoCommit(false); // 关闭自动提交事务功能26 27 String sql = "UPDATE client "28 + "SET account = account - ? "
29 + "WHERE name = ? ";30 PreparedStatement ps = conn.prepareStatement(sql);31 ps.setDouble(1, money);32 ps.setString(2, outName);33 Integer rs = ps.executeUpdate();34 if(rs > 0) {35 System.out.println("转出成功");36 } else {37 System.out.println("转出失败");38 return; // 转出失败跳出函数，不再执行下面的语句；但是finally中的语句还是会执行的，因为就算天塌下来finally中的语句都会执行39 }40 41 System.out.println("======分割线=======");42 43 String sql_in = "UPDATE client "44 + "SET account = account + ? "
45 + "WHERE name = ? ";46 PreparedStatement ps_in = conn.prepareStatement(sql_in);47 ps_in.setDouble(1, money);48 ps_in.setString(2, inName);49 Integer judge_in = ps_in.executeUpdate();50 if(judge_in > 0) {51 System.out.println("转入成功");52 // conn.commit(); // 转出、转入都成功就提交事务53 } else {54 System.out.println("转入失败");55 // conn.rollback(); // 转出成功、转入失败就回滚事务56 }57 58 // conn.setAutoCommit(true); // 打开自动提交事务59 60 } catch (Exception e) {61 // TODO Auto-generated catch block62 e.printStackTrace();63 } finally {64 System.out.println("我是finally中的语句哟");65 try {66 DBUtil.closeConnection();67 } catch (Exception e) {68 // TODO Auto-generated catch block69 e.printStackTrace();70 }71 }72 }73 }1 CREATE TABLE client (2 id INT (10) PRIMARY KEY,3 name VARCHAR (10),4 pwd VARCHAR (10),5 account INT (20)6 );
1 package cn.xiangxu.tools; 2 3 import java.io.IOException; 4 import java.io.InputStream; 5 import java.sql.Connection; 6 import java.sql.SQLException; 7 import java.util.Properties; 8 9 import org.apache.commons.dbcp.BasicDataSource;10 11 public class DBUtil {12 /*13 * ThreadLocal用于线程跨方法共享数据使用14 * ThreadLocal内部有一个Map, key为需要共享数据的线程本身,value就是其需要共享的数据15 */16 private static ThreadLocal<Connection> tl; // 声明一个类似于仓库的东西17 private static BasicDataSource dataSource; // 声明一个数据库连接池对象18 19 // 静态代码块，在类加载的时候执行，而且只执行一次20 static {21 tl = new ThreadLocal<Connection>(); // 实例化仓库对象22 dataSource = new BasicDataSource(); // 实例数据库连接池对象23 24 Properties prop = new Properties(); // 创建一个Properties对象用（该对象可以用来加载配置文件中的属性列表）25 InputStream is = DBUtil.class.getClassLoader().getResourceAsStream("config/mysql.properties"); // 读取配置文件信息26 try {27 prop.load(is); // 加载配置文件中的属性列表28 29 String driverClassName = prop.getProperty("driverClassName"); // 获取属性信息30 String url = prop.getProperty("url");31 String username = prop.getProperty("username");32 String password = prop.getProperty("password");33 Integer maxActive = Integer.parseInt(prop.getProperty("maxActive"));34 Integer maxWait = Integer.parseInt(prop.getProperty("maxWait"));35 36 dataSource.setDriverClassName(driverClassName); // 初始化数据库连接池（即：配置数据库连接池的先关参数）37 dataSource.setUrl(url);38 dataSource.setUsername(username);39 dataSource.setPassword(password);40 dataSource.setMaxActive(maxActive);41 dataSource.setMaxWait(maxWait);42 43 is.close(); // 关闭输入流，释放资源44 } catch (IOException e) {45 // TODO Auto-generated catch block46 e.printStackTrace();47 }
48 49 }50 51 /**52 * 创建连接对象（注意：静态方法可以直接通过类名来调用）53 * @return 连接对象54 * @throws Exception55 */56 public static Connection getConnection() throws Exception {
57 try {58 Connection conn = dataSource.getConnection(); // 创建连接对象（利用数据库连接池进行创建）59 tl.set(conn); // 将连接对象放到仓库中60 return conn;
61 } catch (Exception e) {62 // TODO Auto-generated catch block63 e.printStackTrace();64 throw e;65 }66 }67 68 /**69 * 关闭连接对象（注意：静态方法可以通过类名直接调用）70 * @throws Exception71 */72 public static void closeConnection() throws Exception {73 Connection conn = tl.get(); // 从仓库中取出连接对象74 tl.remove(); // 清空仓库75 if(conn != null) { // 判断连接对象是否释放资源76 try {77 conn.close();78 } catch (Exception e) {79 // TODO Auto-generated catch block80 e.printStackTrace();81 throw e;82 }83 }84 }85 86 }1 # zhe shi zhu shi , yi ban bu yong zhong wen 2 # deng hao liang bian mei you kong ge, mo wei mei you fen hao3 # hou mian bu neng you kong ge4 driverClassName=com.mysql.jdbc.Driver5 url=jdbc:mysql://localhost:3306/test6 username=root7 password=1828388 maxActive=1009 maxWait=3000
1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 "> 2 <modelVersion>4.0.0</modelVersion> 3 <groupId>cn.xiangxu</groupId> 4 <artifactId>testJDBC</artifactId> 5 <version>0.0.1-SNAPSHOT</version> 6 <dependencies> 7 <dependency> 8 <groupId>mysql</groupId> 9 <artifactId>mysql-connector-java</artifactId>10 <version>5.1.37</version>11 </dependency>12 <dependency>13 <groupId>junit</groupId>14 <artifactId>junit</artifactId>15 <version>4.12</version>16 </dependency>17 <dependency>18 <groupId>commons-dbcp</groupId>19 <artifactId>commons-dbcp</artifactId>20 <version>1.4</version>21 </dependency>22 </dependencies>23 </project>
1 package cn.xiangxu.entity; 2 3 import java.sql.Connection; 4 import java.sql.PreparedStatement; 5 import java.sql.SQLException; 6 import java.util.Scanner; 7 8 import cn.xiangxu.tools.DBUtil; 9 10 public class Test {11 public static void main(String[] args) {12 Scanner scanner = new Scanner(System.in);13 System.out.println("请输入转出用户名：");14 String outName = scanner.nextLine();15 System.out.println("请输入需要转出的资金额度：");16 Double money = Double.parseDouble(scanner.nextLine());17 System.out.println("请输入转入用户名：");18 String inName = scanner.nextLine();19 System.out.println("转出账户为：" + outName + "转出金额为：" + money + "转入账户为：" + inName);20 21 22 Connection conn = null;23 try {24 conn = DBUtil.getConnection(); // 实例化连接对象25 26 conn.setAutoCommit(false); // 关闭自动提交事务功能27 28 String sql = "UPDATE client "29 + "SET account = account - ? "
30 + "WHERE name = ? ";31 PreparedStatement ps = conn.prepareStatement(sql);32 ps.setDouble(1, money);33 ps.setString(2, outName);34 Integer rs = ps.executeUpdate();35 if(rs > 0) {36 System.out.println("转出成功");37 } else {38 System.out.println("转出失败");39 return; // 转出失败跳出函数，不再执行下面的语句；但是finally中的语句还是会执行的，因为就算天塌下来finally中的语句都会执行40 }41 42 System.out.println("======分割线=======");43 44 String sql_in = "UPDATE client "45 + "SET account = account + ? "
46 + "WHERE name = ? ";47 PreparedStatement ps_in = conn.prepareStatement(sql_in);48 ps_in.setDouble(1, money);49 ps_in.setString(2, inName);50 Integer judge_in = ps_in.executeUpdate();51 if(judge_in > 0) {52 System.out.println("转入成功");53 conn.commit(); // 转出、转入都成功就提交事务54 } else {55 System.out.println("转入失败");56 conn.rollback(); // 转出成功、转入失败就回滚事务57 }58 59 conn.setAutoCommit(true); // 打开自动提交事务60 61 } catch (Exception e) {62 // TODO Auto-generated catch block63 try {64 conn.rollback(); // 捕获到异常后也需要进行事务回滚65 } catch (SQLException e1) {66 // TODO Auto-generated catch block67 e1.printStackTrace();68 }
69 e.printStackTrace();70 } finally {71 System.out.println("我是finally中的语句哟");72 try {73 DBUtil.closeConnection();74 } catch (Exception e) {75 // TODO Auto-generated catch block76 e.printStackTrace();77 }78 }79 }80 } 1 package cn.xiangxu.tools; 2 3 import java.io.IOException; 4 import java.io.InputStream; 5 import java.sql.Connection; 6 import java.sql.SQLException; 7 import java.util.Properties; 8 9 import org.apache.commons.dbcp.BasicDataSource; 10 11 public class DBUtil { 12 /* 13 * ThreadLocal用于线程跨方法共享数据使用 14 * ThreadLocal内部有一个Map, key为需要共享数据的线程本身,value就是其需要共享的数据 15 */ 16 private static ThreadLocal<Connection> tl; // 声明一个类似于仓库的东西 17 private static BasicDataSource dataSource; // 声明一个数据库连接池对象 18 19 // 静态代码块，在类加载的时候执行，而且只执行一次 20 static { 21 tl = new ThreadLocal<Connection>(); // 实例化仓库对象 22 dataSource = new BasicDataSource(); // 实例数据库连接池对象 23 24 Properties prop = new Properties(); // 创建一个Properties对象用（该对象可以用来加载配置文件中的属性列表） 25 InputStream is = DBUtil.class.getClassLoader().getResourceAsStream("config/mysql.properties"); // 读取配置文件信息 26 try { 27 prop.load(is); // 加载配置文件中的属性列表 28 29 String driverClassName = prop.getProperty("driverClassName"); // 获取属性信息 30 String url = prop.getProperty("url"); 31 String username = prop.getProperty("username"); 32 String password = prop.getProperty("password"); 33 Integer maxActive = Integer.parseInt(prop.getProperty("maxActive")); 34 Integer maxWait = Integer.parseInt(prop.getProperty("maxWait")); 35 36 dataSource.setDriverClassName(driverClassName); // 初始化数据库连接池（即：配置数据库连接池的先关参数） 37 dataSource.setUrl(url); 38 dataSource.setUsername(username); 39 dataSource.setPassword(password); 40 dataSource.setMaxActive(maxActive); 41 dataSource.setMaxWait(maxWait); 42 43 is.close(); // 关闭输入流，释放资源 44 } catch (IOException e) { 45 // TODO Auto-generated catch block 46 e.printStackTrace(); 47 }
48 49 } 50 51 /** 52 * 创建连接对象（注意：静态方法可以直接通过类名来调用） 53 * @return 连接对象 54 * @throws Exception 55 */ 56 public static Connection getConnection() throws Exception {
57 try { 58 Connection conn = dataSource.getConnection(); // 创建连接对象（利用数据库连接池进行创建） 59 tl.set(conn); // 将连接对象放到仓库中 60 return conn;
61 } catch (Exception e) { 62 // TODO Auto-generated catch block 63 e.printStackTrace(); 64 throw e; 65 } 66 } 67 68 /** 69 * 关闭连接对象（注意：静态方法可以通过类名直接调用） 70 * @throws Exception 71 */ 72 public static void closeConnection() throws Exception { 73 Connection conn = tl.get(); // 从仓库中取出连接对象 74 tl.remove(); // 清空仓库 75 if(conn != null) { // 判断连接对象是否释放资源 76 try { 77 conn.close(); 78 } catch (Exception e) { 79 // TODO Auto-generated catch block 80 e.printStackTrace(); 81 throw e; 82 } 83 } 84 } 85 86 /** 87 * 在执行SQL语句前关闭JDBC的自动提交事务功能 88 * @throws SQLException 89 */ 90 public static void tansBegin() throws SQLException { 91 try { 92 tl.get().setAutoCommit(false); // 从仓库中获取连接对象并调用setAutoCommit来关闭自动提交事务功能 93 } catch(SQLException e) { 94 e.printStackTrace(); 95 throw e; 96 } 97 } 98 99 /**100 * 手动回滚功能101 * @throws SQLException102 */103 public static void transBack() throws SQLException {104 tl.get().rollback(); // 从仓库中获取连接对象并调用rollback来实现事务回滚操作105 tl.get().setAutoCommit(true); // 回滚启动事务自动提交功能106 }107 108 /**109 * 手动提交功能110 * @throws SQLException111 */112 public static void transCommit() throws SQLException {113 tl.get().commit(); // 从仓库中获取连接对象并调用commit来实现事务提交操作114 tl.get().setAutoCommit(true); // 提交后启动事务自动提交功能115 }116 117 } 1 package cn.xiangxu.entity; 2 3 import java.sql.Connection; 4 import java.sql.PreparedStatement; 5 import java.sql.SQLException; 6 import java.util.Scanner; 7 8 import cn.xiangxu.tools.DBUtil; 9 10 public class Test {11 public static void main(String[] args) {12 Scanner scanner = new Scanner(System.in);13 System.out.println("请输入转出用户名：");14 String outName = scanner.nextLine();15 System.out.println("请输入需要转出的资金额度：");16 Double money = Double.parseDouble(scanner.nextLine());17 System.out.println("请输入转入用户名：");18 String inName = scanner.nextLine();19 System.out.println("转出账户为：" + outName + "转出金额为：" + money + "转入账户为：" + inName);20 21 22 Connection conn = null;23 try {24 conn = DBUtil.getConnection(); // 实例化连接对象25 26 DBUtil.tansBegin(); // 关闭自动提交事务功能27 28 String sql = "UPDATE client "29 + "SET account = account - ? "
30 + "WHERE name = ? ";31 PreparedStatement ps = conn.prepareStatement(sql);32 ps.setDouble(1, money);33 ps.setString(2, outName);34 Integer rs = ps.executeUpdate();35 if(rs > 0) {36 System.out.println("转出成功");37 } else {38 System.out.println("转出失败");39 return; // 转出失败跳出函数，不再执行下面的语句；但是finally中的语句还是会执行的，因为就算天塌下来finally中的语句都会执行40 }41 42 System.out.println("======分割线=======");43 44 String sql_in = "UPDATE client "45 + "SET account = account + ? "
46 + "WHERE name = ? ";47 PreparedStatement ps_in = conn.prepareStatement(sql_in);48 ps_in.setDouble(1, money);49 ps_in.setString(2, inName);50 Integer judge_in = ps_in.executeUpdate();51 if(judge_in > 0) {52 System.out.println("转入成功");53 DBUtil.transCommit(); // 转出、转入都成功就提交事务54 } else {55 System.out.println("转入失败");56 DBUtil.transBack(); // 转出成功、转入失败就回滚事务57 }58 59 } catch (Exception e) {60 // TODO Auto-generated catch block61 try {62 DBUtil.transBack();// 捕获到异常后也需要进行事务回滚63 } catch (SQLException e1) {64 // TODO Auto-generated catch block65 e1.printStackTrace();66 }
67 e.printStackTrace();68 } finally {69 System.out.println("我是finally中的语句哟");70 try {71 DBUtil.closeConnection();72 } catch (Exception e) {73 // TODO Auto-generated catch block74 e.printStackTrace();75 }76 }77 }78 }Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Outils d'IA chauds
Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes
AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.
Undress AI Tool
Images de déshabillage gratuites
Clothoff.io
Dissolvant de vêtements AI
Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !
Article chaud
Outils chauds
Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit
SublimeText3 version chinoise
Version chinoise, très simple à utiliser
Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP
Dreamweaver CS6
Outils de développement Web visuel
SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)
Après Java8 (291), TLS1.1 est désactivé et JDBC ne peut pas se connecter à SqlServer2008 via SSL. Comment résoudre le problème ?
May 16, 2023 pm 11:55 PM
Après Java8-291, TLS1.1 est désactivé, de sorte que JDBC ne peut pas se connecter à SqlServer2008 à l'aide de SSL. Que dois-je faire ? Voici la solution pour modifier le fichier java.security 1. Recherchez le fichier java.security de jre. c'est jre, allez dans {JAVA_HOME}/jre/ Dans lib/security, par exemple ????C:\ProgramFiles\Java\jre1.8.0_301\lib\security S'il s'agit de la version portable sans installation verte d'Eclipse. , recherchez java.security dans le dossier d'installation, tel que ????xxx\plugins \org
Délai d'attente du verrouillage dépassé ; essayez de redémarrer la transaction - Comment résoudre l'erreur MySQL : délai d'attente de la transaction
Oct 05, 2023 am 08:46 AM
Lockwaittimeoutexceeded;tryrestartingtransaction - Comment résoudre l'erreur MySQL : délai d'attente de transaction Lorsque vous utilisez la base de données MySQL, vous pouvez parfois rencontrer une erreur courante : Lockwaittimeoutexceeded;tryrestartingtransaction. Cette erreur indique que le délai d'attente de transaction a expiré. Cette erreur se produit généralement lorsque
Traitement des transactions MySQL : la différence entre la soumission automatique et la soumission manuelle
Mar 16, 2024 am 11:33 AM
Traitement des transactions MySQL : la différence entre la soumission automatique et la soumission manuelle Dans la base de données MySQL, une transaction est un ensemble d'instructions SQL soit toutes les exécutions réussissent, soit toutes les exécutions échouent, garantissant la cohérence et l'intégrité des données. Dans MySQL, les transactions peuvent être divisées en soumission automatique et soumission manuelle. La différence réside dans le moment de la soumission de la transaction et dans l'étendue du contrôle sur la transaction. Ce qui suit présentera en détail la différence entre la soumission automatique et la soumission manuelle, et donnera des exemples de code spécifiques à illustrer. 1. Soumettre automatiquement dans MySQL, s'il n'est pas affiché
Tutoriel PHP PDO : Un guide avancé des bases à la maîtrise
Feb 19, 2024 pm 06:30 PM
1. Introduction à PDO PDO est une bibliothèque d'extension de PHP, qui fournit une manière orientée objet d'exploiter la base de données. PDO prend en charge une variété de bases de données, notamment Mysql, postgresql, Oracle, SQLServer, etc. PDO permet aux développeurs d'utiliser une API unifiée pour exploiter différentes bases de données, ce qui permet aux développeurs de basculer facilement entre différentes bases de données. 2. PDO se connecte à la base de données Pour utiliser PDO pour vous connecter à la base de données, vous devez d'abord créer un objet PDO. Le constructeur de l'objet PDO reçoit trois paramètres : type de base de données, nom d'hôte, nom d'utilisateur de la base de données et mot de passe. Par exemple, le code suivant crée un objet qui se connecte à une base de données MySQL : $dsn="mysq
Comment implémenter l'insertion par lots JDBC en Java
May 18, 2023 am 10:02 AM
1. Expliquez que dans JDBC, la méthode executeBatch peut exécuter plusieurs instructions dml par lots et que l'efficacité est bien supérieure à l'exécution individuelle d'executeUpdate. Quel est le principe ? Comment implémenter l'exécution par lots dans MySQL et Oracle ? Cet article vous présentera le principe derrière cela. 2. Introduction à l'expérience Cette expérience sera réalisée en trois étapes : a. Enregistrer la durée d'exécution par lots de jdbc et d'exécution unique dans MySQL. b. Enregistrer la durée d'exécution par lots de jdbc et d'exécution unique dans Oracle ; Enregistrez l'exécution par lots et l'exécution unique d'oracleplsql. Les versions Java et de base de données associées qui prennent du temps d'exécution sont les suivantes : Java17, Mysql8, Oracle.
Erreurs Java : erreurs JDBC, comment les résoudre et les éviter
Jun 24, 2023 pm 02:40 PM
Avec l'application répandue de Java, des erreurs JDBC se produisent souvent lorsque les programmes Java se connectent aux bases de données. JDBC (JavaDatabaseConnectivity) est une interface de programmation en Java utilisée pour se connecter à une base de données. Par conséquent, une erreur JDBC est une erreur rencontrée lorsqu'un programme Java interagit avec une base de données. Voici quelques-unes des erreurs JDBC les plus courantes et comment les résoudre et les éviter. ClassNotFoundException C'est le JDBC le plus courant
Analyse des solutions aux problèmes de gestion des transactions rencontrés dans le développement de la technologie MongoDB
Oct 08, 2023 am 08:15 AM
Analyse des solutions aux problèmes de gestion des transactions rencontrés dans le développement de la technologie MongoDB À mesure que les applications modernes deviennent de plus en plus complexes et volumineuses, les exigences en matière de traitement des transactions pour les données deviennent également de plus en plus élevées. En tant que base de données NoSQL populaire, MongoDB offre d'excellentes performances et évolutivité dans la gestion des données. Cependant, MongoDB est relativement faible en termes de cohérence des données et de gestion des transactions, ce qui pose des défis aux développeurs. Dans cet article, nous explorerons les problèmes de gestion des transactions rencontrés dans le développement de MongoDB et proposerons quelques solutions.
Les principes et scénarios d'application des transactions MySQL
Mar 02, 2024 am 09:51 AM
Le principe et les scénarios d'application des transactions MySQL Dans le système de base de données, une transaction est un ensemble d'opérations SQL. Ces opérations sont soit toutes exécutées avec succès, soit toutes échouent et sont annulées. En tant que système de gestion de base de données relationnelle couramment utilisé, MySQL prend en charge les caractéristiques des transactions et peut garantir que les données de la base de données sont garanties en termes de cohérence, d'isolement, de durabilité et d'atomicité. Cet article commencera par les principes de base des transactions MySQL, présentera ses scénarios d'application et fournira des exemples de code spécifiques pour référence aux lecteurs. Le principe des transactions MySQL : Mon
