batch-insert-JdbcTemplate

最新推荐文章于 2024-06-14 17:38:32 发布
最新推荐文章于 2024-06-14 17:38:32 发布
阅读量598 收藏 1
点赞数
分类专栏： java 文章标签： batch mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37276508/article/details/130549283
版权
本文介绍了如何使用Java的JdbcTemplate和自定义注解实现数据库的批量写入，包括更新和插入操作。通过注解处理表和字段信息，动态生成SQL语句，以提高效率和灵活性。示例代码展示了如何在SpringBoot项目中应用这些工具。
摘要由CSDN通过智能技术生成
前言

后台开发中，批量往数据库写数据是一个很常见的功能，下面就简单实现一下使用 JdbcTemplate 来 batch 写入。

实现介绍
添加依赖

在项目的 pom.xml 中配置 JdbcTemplate 及 mysql 相关的依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.46</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>
自定义 table 注解

新建一个自定义注解，作用于类上面，用于备注 table 信息

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.List;

/**
 * Description：需要进行入库操作的表实体注解
 *
 * @author fy
 * @version 1.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbTable {

    /***
     * <p>
     * 表名
     * </p>
     * @author fy
     *
     * @return java.lang.String
     */
    String tableName();

    /***
     * <p>
     * 表的主键
     * </p>
     * @author fy
     *
     * @return java.lang.String
     */
    String primaryKey() default "";

    /***
     * <p>
     * 不参与操作的黑名单字段属性
     * </p>
     * @author fy
     *
     * @return java.lang.String[]
     */
    String[] blackIgnoreFieldList() default {};
}
自定义 column 注解

新建一个自定义注解，作用于类属性上面，用于备注 column 信息

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Description：需要进行入库操作的表字段注解
 *
 * @author fy
 * @version 1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface DbColumn {

    /***
     * <p>
     * 该字段是否允许为空（NULL）
     * </p>
     * @author fy
     *
     * @return boolean
     */
    boolean nullable() default false;

    /***
     * <p>
     * 新增时忽略
     * </p>
     * @author fy
     *
     * @return boolean
     */
    boolean ignoredInsert() default false;

    /***
     * <p>
     * 更新时忽略
     * </p>
     * @author fy
     *
     * @return boolean
     */
    boolean ignoredUpdate() default false;

    /***
     * <p>
     * 字段为 NULL 时候的默认值，不能漏了''
     * </p>
     * @author fy
     *
     * @return java.lang.String
     */
    String defaultValue() default "";
}
逻辑处理工具类

利用自定义的两个注解搭配反射获取表及表字段相关信息，然后通过字符串拼装出 batch 操作的 sql，最后通过 jdbcTemplate.execute 来执行该 sql 进行批量操作。

该类需要加入 spring 管理。

import com.fy.util.NormalUtil;
import com.fy.util.db.ann.DbColumn;
import com.fy.util.db.ann.DbTable;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Description：db 操作工具类
 *
 * @author fy
 * @version 1.0
 */
@Component
public class DbUtil {

    @Value("${db-util.sql.log:false}")
    private boolean isSqlLog;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /***
     * <p>
     * 批量执行的批次默认大小
     * </p>
     */
    private static final int BATCH_SIZE_DEFAULT = 5000;

    private static final String EMPTY_COLUMN_DATA = "";

    /***
     * <p>
     * 批量更新（通过主键）
     * </p>
     * @author fy
     *
     * @param list 批量更新的数据
     */
    public void batchUpdateByPrimaryKey(List<?> list) {
        batchUpdateByPrimaryKey(list, BATCH_SIZE_DEFAULT);
    }

    /***
     * <p>
     * 批量更新（通过主键）
     * </p>
     * @author fy
     *
     * @param list 批量更新的数据
     * @param batchSize 批量批次的大小
     */
    public void batchUpdateByPrimaryKey(List<?> list, int batchSize) {
        ClassBean classBean = checkAndLoadClass(list);
        if (classBean == null) {
            return;
        }
        DbTable dbTable = classBean.getDbTable();
        String primaryKey = dbTable.primaryKey();
        if ("".equals(primaryKey.trim())) {
            // 配置没有指定主键
            return;
        }
        batchUpdate(list, Collections.singletonList(primaryKey), batchSize);
    }

    /***
     * <p>
     * 批量更新
     * </p>
     * @author fy
     *
     * @param list 批量更新的数据
     * @param whereColList 作为 where 条件的字段
     */
    public void batchUpdate(List<?> list, List<String> whereColList) {
        batchUpdate(list, whereColList, BATCH_SIZE_DEFAULT);
    }

    /***
     * <p>
     * 批量更新
     * </p>
     * @author fy
     *
     * @param list 批量更新的数据
     * @param whereColList 作为 where 条件的字段
     * @param batchSize 批量批次的大小
     */
    public void batchUpdate(List<?> list, List<String> whereColList, int batchSize) {
        ClassBean classBean = checkAndLoadClass(list);
        if (classBean == null) {
            return;
        }
        DbTable dbTable = classBean.getDbTable();
        String tableName = dbTable.tableName();
        Map<String, FieldBean> map = classBean.getFieldBeanMap();
        if (map == null || map.size() == 0) {
            return;
        }
        StringBuilder sb = new StringBuilder();
        int count = 0;
        for (Object o : list) {
            StringBuilder toUpdateSb = new StringBuilder();
            try {
                boolean hasToUpdate = isHasToUpdate(whereColList, map, o, toUpdateSb);
                if (hasToUpdate) {
                    sb.append(" UPDATE ").append(tableName).append(" SET ")
                            .append(toUpdateSb.toString());
                } else {
                    // 说明没有需要更新的字段
                    continue;
                }
                loadWhere(whereColList, map, sb, o);
                sb.append("; ");
            } catch (IllegalAccessException e) {
                // 获取值失败
                continue;
            }
            count ++;
            if (count == batchSize) {
                // 达到了批次数量，开始执行，并清理 sql
                executeSql(sb.toString());
                count = 0;
                sb.delete(0, sb.length());
            }
        }
        if (count > 0) {
            // 执行未执行的批次
            executeSql(sb.toString());
            sb.delete(0, sb.length());
        }
    }

    private boolean isHasToUpdate(List<String> whereColList,
                                  Map<String, FieldBean> map,
                                  Object data,
                                  StringBuilder toUpdateSb)
            throws IllegalAccessException {
        boolean hasToUpdate = false;
        for (Map.Entry<String, FieldBean> entry : map.entrySet()) {
            String name = entry.getKey();
            if (whereColList != null && whereColList.contains(name)) {
                // 这个字段在 where 条件中
                continue;
            }
            FieldBean fieldBean = entry.getValue();
            DbColumn dbColumn = fieldBean.getDbColumn();
            if (dbColumn != null && dbColumn.ignoredUpdate()) {
                // 该字段设置了忽略更新
                continue;
            }
            Object colData = fieldBean.getField().get(data);
            if (colData == null) {
                // 该字段值为空
                if (dbColumn != null && dbColumn.nullable()) {
                    // 设置了该字段允许为空
                    if (hasToUpdate) {
                        toUpdateSb.append(", ");
                    }
                    toUpdateSb.append(name).append(" = NULL ");
                    hasToUpdate = true;
                }
            }
            else {
                // 该字段值不为空
                if (hasToUpdate) {
                    toUpdateSb.append(", ");
                }
                toUpdateSb.append(name).append(" = ")
                        .append("'").append(getData(colData)).append("'");
                hasToUpdate = true;
            }
        }
        return hasToUpdate;
    }

    private void loadWhere(List<String> whereColList,
                           Map<String, FieldBean> map,
                           StringBuilder sqlSb,
                           Object data)
            throws IllegalAccessException {
        if (whereColList != null && whereColList.size() > 0) {
            StringBuilder whereSb = new StringBuilder();
            boolean hasWhere = false;
            for (String colName : whereColList) {
                FieldBean fieldBean = map.get(colName);
                if (fieldBean == null) {
                    // 不存在这个字段
                    continue;
                }
                if (hasWhere) {
                    whereSb.append(" AND ");
                }
                Object colData = fieldBean.getField().get(data);
                whereSb.append(colName).append(" = ")
                        .append("'").append(getData(colData)).append("'");
                hasWhere = true;
            }
            if (hasWhere) {
                sqlSb.append(" WHERE ").append(whereSb.toString());
            }
        }
    }

    /***
     * <p>
     * 批量新增（非空字段）
     * </p>
     * @author fy
     *
     * @param list 批量新增的数据
     */
    public void batchInsertSelective(List<?> list) {
        batchInsertSelective(list, BATCH_SIZE_DEFAULT);
    }

    /***
     * <p>
     * 批量新增（非空字段）
     * </p>
     * @author fy
     *
     * @param list 批量新增的数据
     * @param batchSize 批量的批次大小
     */
    public void batchInsertSelective(List<?> list, int batchSize) {
        ClassBean classBean = checkAndLoadClass(list);
        if (classBean == null) {
            return;
        }
        DbTable dbTable = classBean.getDbTable();
        String tableName = dbTable.tableName();
        Map<String, FieldBean> map = classBean.getFieldBeanMap();
        if (map == null || map.size() == 0) {
            return;
        }
        StringBuilder sb = new StringBuilder();
        int count = 0;
        for (Object o : list) {
            try {
                StringBuilder columnSb = new StringBuilder();
                StringBuilder dataSb = new StringBuilder();
                boolean hasToInsert = isHasToInsert(map, o, columnSb, dataSb);
                if (hasToInsert) {
                    sb.append(" INSERT INTO ").append(tableName).append(" (")
                            .append(columnSb.toString()).append(") VALUES (")
                            .append(dataSb.toString()).append("); ");
                } else {
                    // 没有需要插入的数据
                    continue;
                }
            } catch (IllegalAccessException ignored) {
                // 获取值发生异常
                continue;
            }
            count ++;
            if (count == batchSize) {
                // 达到了批次数量，开始执行，并清理 sql
                executeSql(sb.toString());
                count = 0;
                sb.delete(0, sb.length());
            }
        }
        if (count > 0) {
            // 执行未执行的批次
            executeSql(sb.toString());
            sb.delete(0, sb.length());
        }
    }

    private boolean isHasToInsert(Map<String, FieldBean> map,
                                  Object data,
                                  StringBuilder columnSb,
                                  StringBuilder dataSb)
            throws IllegalAccessException {
        boolean hasToInsert = false;
        for (Map.Entry<String, FieldBean> entry : map.entrySet()) {
            String columnName = entry.getKey();
            FieldBean fieldBean = entry.getValue();
            Object colData = fieldBean.getField().get(data);
            DbColumn dbColumn = fieldBean.getDbColumn();
            if (dbColumn != null && dbColumn.ignoredInsert()) {
                continue;
            }
            if (colData == null) {
                // 该字段值为空
                if (dbColumn != null && !EMPTY_COLUMN_DATA.equals(dbColumn.defaultValue())) {
                    // 该字段配置了默认值
                    if (hasToInsert) {
                        columnSb.append(",");
                        dataSb.append(",");
                    }
                    columnSb.append(columnName);
                    dataSb.append(dbColumn.defaultValue());
                    hasToInsert = true;
                } else {
                    if (dbColumn != null && dbColumn.nullable()) {
                        // 设置了该字段允许为空
                        if (hasToInsert) {
                            columnSb.append(",");
                            dataSb.append(",");
                        }
                        columnSb.append(columnName);
                        dataSb.append(" NULL ");
                        hasToInsert = true;
                    }
                }
            } else {
                // 字段值不为空
                if (hasToInsert) {
                    columnSb.append(",");
                    dataSb.append(",");
                }
                columnSb.append(columnName);
                dataSb.append("'").append(getData(colData)).append("'");
                hasToInsert = true;
            }
        }
        return hasToInsert;
    }

    /***
     * <p>
     * 批量新增（所有字段）
     * </p>
     * @author fy
     *
     * @param list 批量新增的数据
     */
    public void batchInsert(List<?> list) {
        batchInsert(list, BATCH_SIZE_DEFAULT);
    }

    /***
     * <p>
     * 批量新增（所有字段）
     * </p>
     * @author fy
     *
     * @param list 批量新增的数据
     * @param batchSize 批量的批次大小
     */
    public void batchInsert(List<?> list, int batchSize) {
        ClassBean classBean = checkAndLoadClass(list);
        if (classBean == null) {
            return;
        }
        DbTable dbTable = classBean.getDbTable();
        String tableName = dbTable.tableName();
        Map<String, FieldBean> map = classBean.getFieldBeanMap();
        if (map == null || map.size() == 0) {
            return;
        }
        StringBuilder sb = new StringBuilder();
        StringBuilder columnSb = new StringBuilder();
        // 先组装出字段字符串
        boolean isNotFirst = false;
        for (Map.Entry<String, FieldBean> entry : map.entrySet()) {
            FieldBean fieldBean = entry.getValue();
            DbColumn dbColumn = fieldBean.getDbColumn();
            if (dbColumn != null && dbColumn.ignoredInsert()) {
                continue;
            }
            if (isNotFirst) {
                columnSb.append(",");
            }
            columnSb.append(entry.getKey());
            isNotFirst = true;
        }
        int count = 0;
        StringBuilder dataSb = new StringBuilder();
        for (Object o : list) {
            if (sb.length() == 0) {
                sb.append(" INSERT INTO ").append(tableName).append(" (")
                        .append(columnSb.toString()).append(") VALUES ");
            }
            if (count > 0) {
                dataSb.append(",");
            }
            try {
                dataSb.append("(");
                boolean isNotFirstColumn = false;
                for (Map.Entry<String, FieldBean> entry : map.entrySet()) {
                    FieldBean fieldBean = entry.getValue();
                    DbColumn dbColumn = fieldBean.getDbColumn();
                    if (dbColumn != null && dbColumn.ignoredInsert()) {
                        continue;
                    }
                    Object data = fieldBean.getField().get(o);
                    if (isNotFirstColumn) {
                        dataSb.append(",");
                    }
                    if (data == null) {
                        // 该字段值为空
                        if (dbColumn != null && !EMPTY_COLUMN_DATA.equals(dbColumn.defaultValue())) {
                            // 该字段配置了默认值
                            dataSb.append(dbColumn.defaultValue());
                        } else {
                            dataSb.append(" NULL ");
                        }
                    } else {
                        // 字段值不为空
                        dataSb.append("'").append(getData(data)).append("'");
                    }
                    isNotFirstColumn = true;
                }
                dataSb.append(")");
            } catch (IllegalAccessException ignored) {
                // 获取值发生异常
                continue;
            }
            count ++;
            if (count == batchSize) {
                // 达到了批次数量，开始执行，并清理 sql
                sb.append(dataSb.toString()).append(";");
                executeSql(sb.toString());
                count = 0;
                dataSb.delete(0, dataSb.length());
                sb.delete(0, sb.length());
            }
        }
        if (count > 0) {
            // 执行未执行的批次
            sb.append(dataSb.toString()).append(";");
            executeSql(sb.toString());
            dataSb.delete(0, dataSb.length());
            sb.delete(0, sb.length());
        }
    }

    /***
     * <p>
     * 执行 sql
     * </p>
     * @author fy
     *
     * @param sql 待执行的 sql 语句
     */
    private void executeSql(String sql) {
        if (isSqlLog) {
            System.err.println(sql);
        }
        jdbcTemplate.execute(sql);
    }

    private Object getData(Object data) {
        if (data == null) {
            return null;
        }
        if (data instanceof Date) {
            data = NormalUtil.formatDate((Date) data, "yyyy-MM-dd HH:mm:ss");
        }
        return data;
    }

    /***
     * <p>
     * 基础检查类信息
     * </p>
     * @author fy
     *
     * @param list 数据列表
     * @return com.fy.util.db.DbUtil.ClassBean
     */
    private ClassBean checkAndLoadClass(List<?> list) {
        if (list == null || list.size() == 0) {
            // 数据为空
            return null;
        }
        Class<?> clazz = list.get(0).getClass();
        DbTable dbTable = clazz.getAnnotation(DbTable.class);
        if (dbTable == null) {
            // 必须有这个注解
            throw new RuntimeException(clazz.getName() + " 类缺失【DbTable】注解！");
        }
        return getTransClass(clazz);
    }

    private static final Map<String, ClassBean> CLASS_TRANS_MAP_CACHE = new ConcurrentHashMap<>();
    private static Set<String> BLACK_FIELD_IGNORED_SET =
            Collections.singleton("serialVersionUID");

    /***
     * <p>
     * 通过 class 类获取该类中相关信息
     * </p>
     * @author fy
     *
     * @param clazz 操作的 class 类
     * @return com.fy.util.db.DbUtil.ClassBean
     */
    private ClassBean getTransClass(Class<?> clazz) {
        String clazzName = clazz.getName();
        if (CLASS_TRANS_MAP_CACHE.containsKey(clazzName)) {
            return CLASS_TRANS_MAP_CACHE.get(clazzName);
        }
        ClassBean classBean = CLASS_TRANS_MAP_CACHE.computeIfAbsent(clazzName,
                k -> new ClassBean());
        Field[] fields = clazz.getDeclaredFields();
        Map<String, FieldBean> fieldBeanMap = new HashMap<>(fields.length);
        DbTable dbTable = clazz.getAnnotation(DbTable.class);
        if (dbTable == null) {
            throw new RuntimeException(clazz.getName() + " 类缺失【DbTable】注解！");
        }
        String[] blackIgnoreFieldList = dbTable.blackIgnoreFieldList();
        BLACK_FIELD_IGNORED_SET.addAll(Arrays.asList(blackIgnoreFieldList));
        for (Field field : fields) {
            if (BLACK_FIELD_IGNORED_SET.contains(field.getName())) {
                continue;
            }
            field.setAccessible(true);
            // key 是下划线格式
            fieldBeanMap.put(NormalUtil.transUpper2Under(field.getName()),
                    new FieldBean(field, field.getAnnotation(DbColumn.class)));
        }
        classBean.setClazz(clazz);
        classBean.setDbTable(dbTable);
        classBean.setFieldBeanMap(fieldBeanMap);
        return classBean;
    }

    /***
     * <p>
     * 储存 class 相关信息的 bean
     * </p>
     * @author fy
     *
     */
    @Getter
    @Setter
    private static class ClassBean {
        Class<?> clazz;
        DbTable dbTable;
        Map<String, FieldBean> fieldBeanMap;
    }

    /***
     * <p>
     * 储存字段相关信息的 bean
     * </p>
     * @author fy
     *
     */
    @Getter
    @Setter
    @NoArgsConstructor
    private static class FieldBean {
        Field field;
        DbColumn dbColumn;

        FieldBean(Field field, DbColumn dbColumn) {
            this.field = field;
            this.dbColumn = dbColumn;
        }
    }
}
方法概览

预览工具类中的几个 public 方法

// 批量更新（通过主键）
public void batchUpdateByPrimaryKey(List<?> list);
// 批量更新（通过主键）
public void batchUpdateByPrimaryKey(List<?> list, int batchSize);
// 批量更新
public void batchUpdate(List<?> list, List<String> whereColList);
// 批量更新
public void batchUpdate(List<?> list, List<String> whereColList, int batchSize);
// 批量新增（非空字段）
public void batchInsertSelective(List<?> list);
// 批量新增（非空字段）
public void batchInsertSelective(List<?> list, int batchSize);
// 批量新增（所有字段）
public void batchInsert(List<?> list);
// 批量新增（所有字段）
public void batchInsert(List<?> list, int batchSize);
使用

1、先在需批量操作的 bean 类上添加相关注解

import com.fy.util.db.ann.DbColumn;
import com.fy.util.db.ann.DbTable;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;

@Getter
@Setter
@DbTable(tableName = "tb_user", primaryKey = "id")
public class UserDto {
    /**
     * 主键
     */
    private String id;

    /**
     * 用户名
     */
    private String userName;

    /**
     * 密码
     */
    private String userPassword;

    /**
     * 密码盐
     */
    private String userSalt;

    /**
     * 手机号
     */
    private String phone;

    /**
     * 创建人
     */
    @DbColumn(defaultValue = "'test-user'")
    private String createUser;

    /**
     * 创建时间
     */
    @DbColumn(ignoredInsert = true)
    private Date createTime;

    /**
     * 更新人
     */
    @DbColumn(defaultValue = "'test-user'")
    private String updateUser;

    /**
     * 更新时间
     */
    @DbColumn(ignoredUpdate = true, ignoredInsert = true)
    private Date updateTime;
}

2、使用 spring 注入，然后调用即可

@Autowired
private DbUtil dbUtil;

public void testDbUtilBatchInsertUser(int count) {
    long t1 = System.currentTimeMillis();
    dbUtil.batchInsert(getUserList(count));
    System.out.println("【DbUtil】插入条数：【" + count + "】耗时：【"
            + (System.currentTimeMillis() - t1) + "】");
}
结语

到此，使用 JdbcTemplate 来 batch 写入数据的实现就介绍完了，后续继续其他方式的批量写入 …

如果您看到了这里，欢迎和我沟通交流！
             一个95后码农

个人博客：fy-blog

羊末离殇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring源码分析——JdbcTemplate执行批量insert操作
weixin_34280237的博客
10-16 1178
最近用到一个方法： @Override public int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException { if (logger.isDebugEnabled()) { logger.debug...
Spring笔记----JDBCTemplate
crystal_hhj的博客
09-16 542
一、JDBCTemplate概述 为了使 JDBC 更加易于使用,Spring 在 JDBCAPI 上定义了一个抽象层, 以此建立一个JDBC存取框架. 作为 SpringJDBC 框架的核心, JDBC 模板的设计目的是为不同类型的JDBC操作提供模板方法. 每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务.通过这种 方式,可以在尽可能保留灵活性的情况下,将数据库存取的工作量降到最低. JdbcTemplate主要提供以下五类方法： execute方法：可以用于执行任何SQL语句，一
JdbcTemplate批量插入
freekaiQaQ的博客
12-14 6295
jdbcTemplate批量插入数据，优化springJpa插入慢的情况
【经验篇】JdbcTemplate数据批量操作性能优化
最新发布
光阴迷客的知识库
06-14 1403
最近在项目中使用进行批量数据更新/删除时，小数据量场景下，性能较为优越。但是在进行大量数据（如10万条）的更新操作时，可能会遇到性能问题。
使用spring的JdbcTemplate操作批量插入数据
zhangbeizhen18的博客
01-04 1万+
场景:从数据库中一张表批量查出数,每条记录封装到一个实例对象中,再将批量查出的数据插入到另一张数据库表 1.实现类与测试main方法 public class BatchOperationDao { private static String querySql = "SELECT CITY_NAME,LAND_AREA,POPULATION,GROSS,AREA_NUMBER,POSTA...
JdbcTemplate 批量插入，HikariCP数据库连接池
CJ_L1995的博客
03-03 2048
例如，你可以从1000开始测试，逐步调整，观察性能变化，找到一个最适合你的应用场景的批量大小。过大的批量大小可能导致内存溢出或者长时间的事务锁定，而过小的批量大小则可能导致频繁的数据库交互，影响性能。假设你正在使用HikariCP作为数据库连接池，为了支持大量的并发插入操作，你需要合理配置数据库连接池的参数，比如。在调整这些参数时，建议进行适当的测试，以确保配置的修改能够带来预期的效果，并且不会对应用用性能产生不利影响。进行数据库操作时，批量插入是一种常见的需求，尤其是在需要高效地插入大量数据时。
quest-spring-jdbc-insert
03-12
jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { User user = users.get(i); ps.setString(1, ...
Spring-JdbcTemplate
03-18
- **性能优化**：合理使用批处理（batchUpdate）提高性能，避免过多的数据库交互。 通过以上介绍，我们可以看到 Spring-JdbcTemplate 是一个强大且易用的数据库访问工具，它通过封装 JDBC，简化了数据库操作，提升...
spring-jdbcTemplate实例工程
04-21
1. **JdbcTemplate对象**：这是Spring JdbcTemplate的核心，它包含了执行SQL语句的所有方法，如update()用于更新，query()用于查询，insert()用于插入等。 2. **参数绑定**：JdbcTemplate支持多种方式的参数绑定，...
Spring----JDBCTemplate
wowo
11-14 989
JDBCTemplate JDBCTemplate就是Spring对JDBC的在封装，方便对数据库进行操作。 在xml文件中 首先引入命名空间context，使用context:property-override标签引入外部properties文件，location指明位置 注入DruidDataSource的对象并完成属性注入，value内的内容可以直接注入，也能通过${ }【Spring表达式】进行获取配置文件中的内容 创建JDBCTemplate对象，将DruidDataSource对象注入
jdbctemplate数据批量入库
qq_40711092的博客
01-09 702
相比于数据一条一条入库，批量入库效率更高，不过需要注意批量入库数据量大小需要控制好，1千到2千条数据入库较快，超过两千条数据入库较慢。
jdbcTemplate批量插入处理数据
c601757850的博客
09-10 700
jdbcTemplate批量插入处理数据 public void batchCarFlowInsert(List<FlowCarReportDayBo> list) { String sql =" INSERT INTO flow_report_day (id, park_number, park_name, start_time, nature_sum_count, " + " temp_car_count, vip_car_count,
Batch Insert In Java – JDBC(含中文总结)
weixin_30446197的博客
05-10 92
//JDBC提供了数据库batch处理的能力，在数据大批量操作（新增、删除等）的情况下可以大幅度提升系统的性能。 Let’s see how we can perform batch insert in Java using JDBC APIs. Although you might already knew this, I will try to explain the bas...
Spring JdbcTemplate之批量插入
热门推荐
10000guo的博客
03-11 1万+
JdbcTemplate简介 　　Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 　　JdbcTemplate位于spring-jdbc-5.0.6.RELEASE.jar中。其全限定命名为org.springframework.jdbc.core.JdbcTemplate。要使用JdbcTe...
JdbcTemplate 批量插入
持续学习，持续更新
11-16 1万+
因为使用template插入速度过慢，上网查了资料，找到了一种插入速度很快的方法 String sql = "INSERT INTO `party_dealer_info_grp` ( `ID`, `PARTY_CODE6`, `PARTY_NAME`, `DEALER_ID`, `DEALER_NAME`, `TELE`, `FAX`, `EMAIL`, `MSN`, `ADDRESS`, `POSTAL_CODE` ) VALUES (?,?,?,?,?,?,?,?,?,?,?)";
Java笔记-JdbcTemplate批量执行insert及update
bai_Mou的博客
08-30 3117
主要就是batchUpdate函数 用法如下： insert： String cmdTmp = "INSERT INTO %s(CREATE_DATE, UPDATE_TIME, XXX_ID, XXXID, XXX_TYPE) VALUES(?, ?, ?, ?, ?)"; String cmd = String.format(cmdTmp, tableName); List<Object[]> batchArgs=new ArrayList<Object[]>()
【Spring Data Access】JdbcTemplate 批量插入
简简单单兔呦
09-28 8127
JdbcTemplate批量插入 JdbcTemplate支持批量命令的操作，我们先简单了解一下JdbcTemplate的API接口支持情况: 从上面的截图中我们可以了解当前有5个方法，注意这些方法都是JdbcTemplate实现JdbcOperations接口而来的方法 int[] batchUpdate(String sql, final BatchPreparedStatementSett...
Spring源码学习-JdbcTemplate batchUpdate批量操作
05-31
好的，关于Spring源码中的JdbcTemplate batchUpdate批量操作，可以简单地介绍一下其实现原理。 JdbcTemplate是Spring框架中用于简化JDBC操作的模板类，其中的batchUpdate方法可以用于批量执行SQL语句。batchUpdate方法的实现原理相对简单，主要包含以下几个步骤： 1. 将SQL语句和参数列表组成一个BatchPreparedStatementSetter对象； 2. 调用NamedParameterJdbcTemplate的batchUpdate方法； 3. NamedParameterJdbcTemplate会将BatchPreparedStatementSetter对象中的SQL语句和参数列表设置到PreparedStatement中，然后执行批量更新操作； 4. 执行完毕后返回更新记录数的数组。 需要注意的是，JdbcTemplate batchUpdate方法的批量操作是通过JDBC驱动实现的，因此其批量更新的效率取决于具体的数据库驱动程序。同时，JdbcTemplate也提供了其他的批量操作方式，例如batchInsert和batchDelete等方法，其实现原理与batchUpdate类似。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值