31 数据库事务与批量操作

31 数据库事务与批量操作

在本节中,我们将深入探讨 Java 中的数据库事务处理以及批量操作的实现。我们将使用 JDBC 来连接和操作数据库。首先,我们将了解什么是数据库事务,然后学习如何在 Java 中实现事务控制,以及如何进行批量操作。

一、数据库事务概述

1.1 什么是事务

一个 事务 是一组操作的集合,这些操作要么全部成功,要么全部失败。数据库事务的特点包括:

  • 原子性(Atomicity):事务中的所有操作要么全部执行,要么全部不执行。
  • 一致性(Consistency):事务保证数据从一种一致性状态转到另一种一致性状态。
  • 隔离性(Isolation):多个事务并发执行时,互不干扰。
  • 持久性(Durability):一旦事务提交,对数据库的修改是永久的。

1.2 事务的必要性

在进行多个数据库操作时,如果其中一个操作失败,可能导致数据不一致。通过使用事务,可以确保数据的完整性和一致性。

二、Java 中的事务处理

使用 JDBC 处理事务非常简单。以下是基本步骤:

  1. 关闭 autoCommit
  2. 执行多条 SQL 语句。
  3. 提交或回滚。

2.1 示例代码

下面是一个简单的事务处理示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TransactionExample {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;

try {
// 1. 获取数据库连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");

// 2. 关闭 autoCommit
conn.setAutoCommit(false);

// 3. 执行 SQL 操作
String sql1 = "INSERT INTO accounts (name, balance) VALUES (?, ?)";
pstmt1 = conn.prepareStatement(sql1);
pstmt1.setString(1, "Alice");
pstmt1.setDouble(2, 1000.0);
pstmt1.executeUpdate();

String sql2 = "INSERT INTO accounts (name, balance) VALUES (?, ?)";
pstmt2 = conn.prepareStatement(sql2);
pstmt2.setString(1, "Bob");
pstmt2.setDouble(2, 2000.0);
pstmt2.executeUpdate();

// 4. 提交事务
conn.commit();
System.out.println("Transaction committed.");

} catch (SQLException e) {
// 5. 回滚事务
if (conn != null) {
try {
System.out.println("Transaction is being rolled back.");
conn.rollback();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
e.printStackTrace();
} finally {
// 6. 释放资源
try {
if (pstmt1 != null) pstmt1.close();
if (pstmt2 != null) pstmt2.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}

2.2 关键步骤解释

  • conn.setAutoCommit(false);:关闭自动提交模式,开始事务。
  • ctx.commit();:在所有 SQL 操作成功后提交事务。
  • conn.rollback();:如果发生异常,回滚所有操作。

三、批量操作

3.1 什么是批量操作

批量操作 是指在一次数据库操作中,批量执行多条 SQL 语句。这样可以显著提高效率,尤其在需要插入、更新大量数据时。

3.2 使用批量操作的步骤

  1. 创建 PreparedStatement
  2. 使用 addBatch() 方法添加多个操作。
  3. 使用 executeBatch() 方法执行所有操作。

3.3 示例代码

以下示例展示了如何使用批量操作插入多条数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class BatchInsertExample {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt = null;

try {
// 1. 获取数据库连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");

// 2. 关闭 autoCommit
conn.setAutoCommit(false);

// 3. 创建 PreparedStatement
String sql = "INSERT INTO accounts (name, balance) VALUES (?, ?)";
pstmt = conn.prepareStatement(sql);

// 4. 添加批量操作
pstmt.setString(1, "Alice");
pstmt.setDouble(2, 1000.0);
pstmt.addBatch();

pstmt.setString(1, "Bob");
pstmt.setDouble(2, 2000.0);
pstmt.addBatch();

pstmt.setString(1, "Charlie");
pstmt.setDouble(2, 3000.0);
pstmt.addBatch();

// 5. 执行批量操作
pstmt.executeBatch();
conn.commit();
System.out.println("Batch insert completed.");

} catch (SQLException e) {
if (conn != null) {
try {
conn.rollback();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
e.printStackTrace();
} finally {
// 6. 释放资源
try {
if (pstmt != null) pstmt.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}

3.4 批量操作注意事项

  • 使用批量操作时,应注意每个语句的参数设置。
  • 批量操作可能会导致一次性插入大量数据,需确保数据库性能能够支持。

四、总结

在本节中,我们学习了 Java 中的数据库事务处理和批量操作。合理地使用事务能够保证数据的一致性、完整性,而批量操作则提高了数据库操作的性能。通过上述代码示例,相信你能在实际开发中合理运用这两种技术。

31 Java 常用基本库入门指南

31 Java 常用基本库入门指南

在Java中,基本库提供了许多重要的工具和功能,帮助开发者更高效地编写代码。本节将详细介绍一些常用的基本库和它们的重要组成部分。

1. java.lang

java.lang 包是Java的核心库之一,默认被导入到每个Java程序中。它包含了许多基础类。

1.1. String

String 类用于表示字符串。字符串是不可变的,即一旦被创建就不能更改。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class StringExample {
public static void main(String[] args) {
String greeting = "Hello, World!";

// 获取字符串长度
int length = greeting.length();
System.out.println("String Length: " + length);

// 字符串连接
String name = "Java";
String message = greeting + " Welcome to " + name + " programming.";
System.out.println(message);

// 字符串比较
boolean isEqual = greeting.equals("Hello, World!");
System.out.println("Strings are equal: " + isEqual);
}
}

1.2. Math

Math 类提供了基本的数学运算方法和常量。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MathExample {
public static void main(String[] args) {
double radius = 5.0;

// 计算圆面积
double area = Math.PI * Math.pow(radius, 2);
System.out.println("Area of the circle: " + area);

// 取绝对值
int absoluteValue = Math.abs(-10);
System.out.println("Absolute Value: " + absoluteValue);

// 随机数生成
double randomValue = Math.random();
System.out.println("Random Value: " + randomValue);
}
}

2. java.util

java.util 包提供了多种数据结构、工具类和其他功能。

2.1. 集合框架 (Collection Framework)

Java的集合框架包括了许多常用的数据结构,如 ListSetMap

2.1.1. ArrayList

ArrayList 是一个可动态调整大小的数组实现。

示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.ArrayList;

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

// 遍历 ArrayList
for (String fruit : fruits) {
System.out.println(fruit);
}

// 获取元素
String firstFruit = fruits.get(0);
System.out.println("First fruit: " + firstFruit);
}
}

2.1.2. HashMap

HashMap 是一种基于哈希表的键值对存储结构。

示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.HashMap;

public class HashMapExample {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("Alice", 30);
map.put("Bob", 25);

// 获取值
int ageOfAlice = map.get("Alice");
System.out.println("Age of Alice: " + ageOfAlice);

// 遍历 HashMap
for (String key : map.keySet()) {
System.out.println(key + ": " + map.get(key));
}
}
}

2.2. 日期和时间 (java.time 包)

自Java 8起,java.time 包提供了一组强大的工具类用于处理日期和时间。

示例代码(使用 LocalDateLocalDateTime):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
public static void main(String[] args) {
// 获取当前日期
LocalDate today = LocalDate.now();
System.out.println("Today's date: " + today);

// 获取当前日期时间
LocalDateTime now = LocalDateTime.now();
System.out.println("Current date and time: " + now);

// 格式化日期时间
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
String formattedDate = now.format(formatter);
System.out.println("Formatted date and time: " + formattedDate);
}
}

3. 输入输出 (java.iojava.nio)

Java提供了丰富的输入输出操作类,用于处理文件、网络等。

3.1. 文件操作 (java.io)

使用 File 类进行文件操作,例如读写文件。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileExample {
public static void main(String[] args) {
File file = new File("example.txt");

try {
// 创建文件
if (file.createNewFile()) {
System.out.println("File created: " + file.getName());
} else {
System.out.println("File already exists.");
}

// 写入文件
FileWriter writer = new FileWriter(file);
writer.write("Hello, World!");
writer.close();
System.out.println("Successfully wrote to the file.");
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
}

结论

本节介绍了Java的一些常用基本库,包括java.langjava.util以及输入输出库。这些库为Java开发提供了基础和支持,使得编写程序变得更加高效和便捷。希望这些示例和讲解能帮助你更好地理解和使用Java的基本库。

32 ORM框架的基础与应用

32 ORM框架的基础与应用

什么是ORM框架

ORM(Object-Relational Mapping)框架是一种用于将对象与数据库之间的关系进行映射的工具。通过ORM,开发者可以使用面向对象的方式来操作数据库,而无需直接编写SQL语句。ORM框架能够自动处理数据的持久化,提供更高效的开发体验。

ORM的基本概念

1. 映射(Mapping)

ORM框架通过映射将数据库中的表转化为对象。每一行数据对应一个对象,每个数据字段对应对象的属性。这种映射关系使得我们可以用对象的方法来操作数据库。

2. 实体类(Entity Class)

实体类是ORM框架中定义的与数据库表相对应的 Java 类。每个实体类的属性对应数据库表中的字段。

1
2
3
4
5
6
7
8
// 示例:User实体类
public class User {
private Long id; // 对应数据库表中的id字段
private String name; // 对应数据库表中的name字段
private String email; // 对应数据库表中的email字段

// 省略构造函数、getter和setter方法
}

3. 会话(Session)

会话是ORM框架中的一个核心概念,负责与数据库进行交互。通过会话,我们可以执行CRUD(创建、读取、更新、删除)操作。

常见的Java ORM框架

  • Hibernate:最流行的ORM框架之一,提供了广泛的特性和良好的支持。
  • MyBatis:半ORM框架,支持定制SQL,但需要手动编写SQL语句。
  • JPA(Java Persistence API):Java EE标准接口,常与Hibernate一起使用。

Hibernate的基础应用

1. Maven依赖

在使用Hibernate之前,我们需要在项目中添加Hibernate的依赖。在pom.xml中添加以下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.32.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.32.Final</version>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>

2. Hibernate配置

在项目根目录下创建hibernate.cfg.xml配置文件,配置数据库连接信息:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hbm-3.0.dtd">

<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/testdb</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">password</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<mapping class="com.example.User"/>
</session-factory>
</hibernate-configuration>

3. 创建SessionFactory

在Java代码中,创建一个SessionFactory实例,供后续的会话使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
private static SessionFactory sessionFactory;

static {
// 创建SessionFactory
sessionFactory = new Configuration().configure().buildSessionFactory();
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}

public static void shutdown() {
getSessionFactory().close();
}
}

4. CRUD操作示例

以下代码展示了如何使用Hibernate进行基本的CRUD操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import org.hibernate.Session;
import org.hibernate.Transaction;

public class UserDao {

public void saveUser(User user) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
transaction = session.beginTransaction();
session.save(user); // 保存用户对象
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback(); // 回滚事务
}
e.printStackTrace();
}
}

public User getUser(Long userId) {
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
return session.get(User.class, userId); // 获取用户对象
}
}

public void updateUser(User user) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
transaction = session.beginTransaction();
session.update(user); // 更新用户对象
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback(); // 回滚事务
}
e.printStackTrace();
}
}

public void deleteUser(Long userId) {
Transaction transaction = null;
try (Session session = HibernateUtil.getSessionFactory().openSession()) {
transaction = session.beginTransaction();
User user = session.get(User.class, userId);
if (user != null) {
session.delete(user); // 删除用户对象
}
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback(); // 回滚事务
}
e.printStackTrace();
}
}
}

5. 使用示例

在主程序中使用UserDao进行CRUD操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Main {
public static void main(String[] args) {
UserDao userDao = new UserDao();

// 创建用户
User user = new User();
user.setName("John Doe");
user.setEmail("john@example.com");
userDao.saveUser(user);

// 获取用户
User retrievedUser = userDao.getUser(user.getId());
System.out.println("Retrieved User: " + retrievedUser.getName());

// 更新用户
retrievedUser.setEmail("john.doe@example.com");
userDao.updateUser(retrievedUser);

// 删除用户
userDao.deleteUser(retrievedUser.getId());

HibernateUtil.shutdown(); // 关闭SessionFactory
}
}

总结

在本节中,我们学习了ORM框架的基础知识