当前位置：首页 > 后端开发 > 正文

java中怎么实现大批量插入数据

Java中实现大批量插入数据，可以使用JDBC的 addBatch()和 executeBatch()方法。

Java中实现大批量插入数据是一项常见的任务，尤其是在处理大量数据时，为了提高性能和效率，通常需要采用一些优化策略和技术,以下是几种常见的方法及其详细实现步骤：

使用JDBC的批量插入

步骤：

  1. 获取数据库连接：使用DriverManager.getConnection()获取数据库连接。
  2. 关闭自动提交：通过connection.setAutoCommit(false)关闭自动提交模式。
  3. 准备SQL语句：使用PreparedStatement预编译SQL语句。
  4. 添加批处理：使用preparedStatement.addBatch()将多条插入语句添加到批处理中。
  5. 执行批处理：调用preparedStatement.executeBatch()执行批处理。
  6. 提交事务：通过connection.commit()提交事务。
  7. 处理异常：捕获并处理可能的SQLException,并在必要时回滚事务。

示例代码：

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) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "username";
        String password = "password";
        try (Connection connection = DriverManager.getConnection(url, user, password)) {
            connection.setAutoCommit(false);
            String sql = "INSERT INTO my_table (column1, column2) VALUES (?, ?)";
            try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                for (int i = 0; i < 1000; i++) {
                    preparedStatement.setString(1, "value1_" + i);
                    preparedStatement.setString(2, "value2_" + i);
                    preparedStatement.addBatch();
                    if (i % 100 == 0) { // 每100条执行一次批处理
                        preparedStatement.executeBatch();
                        connection.commit();
                    }
                }
                preparedStatement.executeBatch(); // 执行剩余的批处理
                connection.commit();
            } catch (SQLException e) {
                connection.rollback();
                e.printStackTrace();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

使用Hibernate的批量插入

步骤：

  1. 配置Hibernate：设置hibernate.jdbc.batch_size属性以启用批量插入。
  2. 开启事务：使用Session.beginTransaction()开启事务。
  3. 批量插入数据：通过Session.save()或Session.persist()方法插入数据，并定期调用Session.flush()和Session.clear()以清空缓存。
  4. 提交事务：调用transaction.commit()提交事务。

示例代码：

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateBatchInsertExample {
    public static void main(String[] args) {
        Session session = new Configuration().configure().buildSessionFactory().openSession();
        Transaction transaction = session.beginTransaction();
        try {
            for (int i = 0; i < 1000; i++) {
                MyEntity entity = new MyEntity("value1_" + i, "value2_" + i);
                session.save(entity);
                if (i % 100 == 0) { // 每100条执行一次批处理
                    session.flush();
                    session.clear();
                }
            }
            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

使用Spring JdbcTemplate的批量插入

步骤：

  1. 配置JdbcTemplate：在Spring配置文件中配置JdbcTemplate。
  2. 准备数据：将数据组织成List<Object[]>或List<Map<String, Object>>。
  3. 批量插入：使用JdbcTemplate.batchUpdate()方法执行批量插入。

示例代码：

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;
public class SpringBatchInsertExample {
    public static void main(String[] args) {
        DataSource dataSource = new DriverManagerDataSource("jdbc:mysql://localhost:3306/mydatabase", "username", "password");
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "INSERT INTO my_table (column1, column2) VALUES (?, ?)";
        List<Object[]> batchArgs = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            batchArgs.add(new Object[]{"value1_" + i, "value2_" + i});
        }
        jdbcTemplate.batchUpdate(sql, batchArgs);
    }
}

使用多线程并行插入

步骤：

  1. 分割数据：将大批量数据分割成多个小批次。
  2. 创建线程池：使用ExecutorService创建线程池。
  3. 并行插入：为每个小批次数据创建一个任务,并行执行插入操作。
  4. 等待完成：使用Future或CountDownLatch等待所有任务完成。

示例代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class MultiThreadBatchInsertExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "username";
        String password = "password";
        int batchSize = 100;
        int totalRecords = 1000;
        int threadCount = 10;
        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
        for (int i = 0; i < totalRecords; i += batchSize) {
            int start = i;
            int end = Math.min(i + batchSize, totalRecords);
            executorService.submit(() -> {
                try (Connection connection = DriverManager.getConnection(url, user, password)) {
                    connection.setAutoCommit(false);
                    String sql = "INSERT INTO my_table (column1, column2) VALUES (?, ?)";
                    try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
                        for (int j = start; j < end; j++) {
                            preparedStatement.setString(1, "value1_" + j);
                            preparedStatement.setString(2, "value2_" + j);
                            preparedStatement.addBatch();
                        }
                        preparedStatement.executeBatch();
                        connection.commit();
                    } catch (SQLException e) {
                        connection.rollback();
                        e.printStackTrace();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

使用存储过程进行批量插入

步骤：

  1. 编写存储过程：在数据库中编写一个存储过程,接受批量数据作为参数。
  2. 调用存储过程：在Java中使用CallableStatement调用存储过程。
  3. 传递数据：将批量数据传递给存储过程。
  4. 执行存储过程：调用CallableStatement.execute()执行存储过程。

示例代码：

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Arrays;
public class StoredProcedureBatchInsertExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "username";
        String password = "password";
        List<String[]> data = Arrays.asList(
                new String[]{"value1_1", "value2_1"},
                new String[]{"value1_2", "value2_2"},
                // 添加更多数据...
        );
        try (Connection connection = DriverManager.getConnection(url, user, password)) {
            String sql = "{CALL BatchInsertProcedure(?, ?)}";
            try (CallableStatement callableStatement = connection.prepareCall(sql)) {
                for (String[] record : data) {
                    callableStatement.setString(1, record[0]);
                    callableStatement.setString(2, record[1]);
                    callableStatement.addBatch();
                }
                callableStatement.executeBatch();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

FAQs

Q1: 为什么在大批量插入时需要关闭自动提交？
A1: 关闭自动提交可以显著提高性能，因为每次插入操作不需要立即提交事务，减少了磁盘I/O操作，通过手动控制事务，可以在一批插入完成后一次性提交,从而减少事务管理的开销。

Q2: 在使用多线程并行插入时，如何避免数据冲突和锁争用？
A2: 为了避免数据冲突和锁争用，可以将数据分割成多个独立的小批次,并为每个批次分配一个独立的线程进行处理。

va 批量插入 数据
0

相关文章