oracle jdbc批量插入数据库 不存在增加 存在则更新

最新推荐文章于 2021-08-28 17:37:24 发布
最新推荐文章于 2021-08-28 17:37:24 发布
阅读量2.1k 收藏 5
点赞数 3
分类专栏： Oracle JAVA 文章标签： JDBC ORACLE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnzyyh/article/details/79627818
版权
JAVA 同时被 2 个专栏收录
36 篇文章 0 订阅
订阅专栏
Oracle
21 篇文章 0 订阅
订阅专栏

以下就是一个实例：

package cn.rojao.utils.batch;


import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.sql.DataSource;
import java.sql.*;
import java.util.List;

/**
 * 大数据导入工具类
 */
public class JDBCBatch {
    private static Logger logger = LoggerFactory.getLogger(JDBCBatch.class);

    private JDBCBatch() {
    }

    private volatile static DataSource dataSource;

    public static void init(DataSource dataSource0) {
        if (dataSource == null) {
            dataSource = dataSource0;
        }
    }

    public static int insertBatch(List<Object[]> list,String tablename,int sqlCount, String... sql) throws SQLException {

        AbstractBatch abstractBatch = null;
        try {
            if (sql != null && sql.length == 1)
                abstractBatch = new BatchNoGroup();
            else if (sql.length == 2)
                abstractBatch = new BatchGroup();
            else
                abstractBatch = new BatchGroup2();
            return abstractBatch.insertBatch(list,tablename,sqlCount, sql);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            try {
                abstractBatch.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    }

    public static void insertBatchIn(List<Object[]> list,String tablename,int sqlCount, String... sql) throws SQLException {
        AbstractBatch abstractBatch = new BatchNoGroupIn();
        try {
            abstractBatch.insertBatch(list,tablename,sqlCount, sql);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            try {
                abstractBatch.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    static abstract class AbstractBatch {
        Connection connection = null;

        /**
         * insert into table values(?,?,?)
         */
        PreparedStatement pStatement = null;

        /**
         * insert into group_table select id ,groupId from table where field = ?
         */
        PreparedStatement pStatement2 = null;

        /**
         * insert into table select id ,(select id from table where field = ? )
         * select id from table where field in ()
         */
        PreparedStatement pStatement3 = null;
        Statement statement = null;

        /**
         * @return
         * @throws SQLException
         */
        Connection getConnection() throws SQLException {
            return JDBCBatch.dataSource.getConnection();
        }

        /**
         * @throws SQLException
         */
        void close() throws SQLException {
            if (statement != null) {
                statement.close();
            }
            if (pStatement != null) {
                pStatement.close();
            }
            if (pStatement2 != null) {
                pStatement2.close();
            }
            if (pStatement3 != null) {
                pStatement3.close();
            }
            if (connection != null) {
                connection.setAutoCommit(Boolean.TRUE);
                connection.close();
            }
        }

        /**
         * 批量插入
         *
         * @param list 占位符 后一个占位符用于检索id
         * @param sql
         */
        abstract int insertBatch(List<Object[]> list,String tablename,int sqlCount,String... sql) throws SQLException;
    }

    static class BatchNoGroup extends AbstractBatch {
        /**
         * list -> object[] {?,?,?}对应占位符
         *
         * @param list 占位符
         * @param sql
         * @return
         * @throws SQLException
         */
        @Override
        int insertBatch(List<Object[]> list,String tablename,int sqlCount, String... sql) throws SQLException {
            int count = 0;
            String batchSql = sql[0];
            connection = getConnection();
            connection.setAutoCommit(Boolean.FALSE);
            pStatement = connection.prepareStatement(batchSql);
            long start = System.currentTimeMillis();
            for (int i = 0; i < list.size(); i++) {
                for (int j = 1, k = 0; k < list.get(0).length - 1; j++, k++) {//
                    Object obj = list.get(i)[k];
                    if (obj instanceof Integer) {
                        pStatement.setInt(j, (Integer) obj);
                    } else if (obj instanceof String) {
                        pStatement.setString(j, (String) obj);
                    } else if (obj instanceof Long) {
                        pStatement.setLong(j, (Long) obj);
                    } else if (obj == null) {
                        pStatement.setNull(j, java.sql.Types.INTEGER);
                    }
                }
                pStatement.addBatch();
                count++;
                if (i % sqlCount == 0 && i != 0) {
                    pStatement.executeBatch();
                    connection.commit();
                }
            }
            pStatement.executeBatch();
            connection.commit();  // 提交
            pStatement.clearBatch();
            if(batchSql.indexOf("DELETE")!=-1){
                logger.info("============================="+tablename+" 删除" + count + "条数据用了" + (System.currentTimeMillis() - start) / 1000 + "秒 =============================");
            }else{
                logger.info("============================="+tablename+" 插入" + count + "条数据用了" + (System.currentTimeMillis() - start) / 1000 + "秒 =============================");

            }
            return count;
        }
    }

    static class BatchGroup extends AbstractBatch {
        /**
         * object[] {?,?,?}对应占位符 最后一个占位符用于检索分组id
         *
         * @param list 占位符
         * @param sql
         * @return
         * @throws SQLException
         */
        @Override
        int insertBatch(List<Object[]> list,String tablename,int sqlCount ,String... sql) throws SQLException {
          //  Connection conn;
            int count = 0;
            String batchSql0 = sql[0];
            String batchSql1 = sql[1];
            connection = getConnection();
            connection.setAutoCommit(Boolean.FALSE);
            pStatement = connection.prepareStatement(batchSql0, PreparedStatement.RETURN_GENERATED_KEYS);
            pStatement2 = connection.prepareStatement(batchSql1, PreparedStatement.RETURN_GENERATED_KEYS);//分组sql
            long start = System.currentTimeMillis();
            int length;
            for (int i = 0; i < list.size(); i++) {
                for (int j = 1, k = 0; j < (length = list.get(0).length) + 1; j++, k++) {//替换占位符
                    Object obj = list.get(i)[k];
                    if (k < length - 1) {
                        if (obj instanceof Integer) {
                            pStatement.setInt(j, (Integer) obj);
                        } else if (obj instanceof String) {
                            pStatement.setString(j, (String) obj);
                        } else if (obj instanceof Long) {
                            pStatement.setLong(j, (Long) obj);
                        } else if (obj == null) {
                            pStatement.setNull(j, java.sql.Types.INTEGER);
                        }
                    } else {//替换分组占位符
                        Object o = list.get(i)[k];
                        String[] split = o.toString().split("\\|\\|");
                        for (int n = 1, m = 0; m < split.length; n++, m++) {
                            pStatement2.setString(n, split[m]);
                        }
                    }
                }
                pStatement.addBatch();
                pStatement2.addBatch();
                if (i % sqlCount == 0 && i != 0) {
                    pStatement.executeBatch();
                    ResultSet result = pStatement.getGeneratedKeys();
                    while (result.next()) {
                        count++;
                    }
                    connection.commit();
                    pStatement2.executeBatch();
                    ResultSet result2 = pStatement2.getGeneratedKeys();
                    while (result.next()) {
                        count++;
                    }
                    connection.commit();
                    System.out.println("insert rows :" + i + ".....");
                }
            }
            pStatement.executeBatch();
            ResultSet result = pStatement.getGeneratedKeys();
            while (result.next()) {
                count++;
            }
            connection.commit();  // 提交
            pStatement2.executeBatch();
            ResultSet result2 = pStatement2.getGeneratedKeys();
            while (result.next()) {
                count++;
            }
            connection.commit();
            logger.info("============================= 插入" + count + "条数据用了" + (System.currentTimeMillis() - start) / 1000 + "秒 =============================");
            return count;
        }
    }

    /**
     * 采用in的方法
     */
    static class BatchNoGroupIn extends AbstractBatch {

        @Override
        int insertBatch(List<Object[]> list,String tablename,int sqlCount, String... sql) throws SQLException {
           // Connection conn;
            String batchSql = sql[0];
            int count = 0;
            connection = getConnection();
            connection.setAutoCommit(Boolean.FALSE);
            statement = connection.createStatement();
            long start = System.currentTimeMillis();
            int length;
            boolean isLoad = Boolean.FALSE;
            for (int i = 0; i < list.size(); i++) {
                length = list.get(i).length;
                if (length > 0) {
                    for (int j = 0; j < length; j++) {
                        Object obj = list.get(i)[j];
                        if (j == 0) {
                            batchSql = batchSql.replaceFirst("\\?", "'" + obj.toString() + "'");
                            continue;
                        }
                        String splitStr = (String) obj;
                        if (StringUtils.isNotEmpty(splitStr)) {
                            isLoad = Boolean.TRUE;
                            String[] fea = splitStr.split("\\+");//feature : a+b
                            for (String s : fea) {
                                statement.addBatch(batchSql.replace("?", "'" + s + "'"));
                            }
                        }
                    }
                }
                if (i % sqlCount == 0 && i != 0) {
                    if (isLoad) {
                        int[] c = statement.executeBatch();
                        for (int k = 0; k < c.length; k++) {
                            if (c[k] == 1) {
                                count++;
                            }
                        }
                        connection.commit();
                        System.out.println("insert 10000 .....");
                    }
                }
            }
            if (isLoad) {
                int[] c = statement.executeBatch();
                for (int k = 0; k < c.length; k++) {
                    if (c[k] == 1) {
                        count++;
                    }
                }
                connection.commit();  // 提交
                logger.info("============================= 插入" + count + "条数据用了" + (System.currentTimeMillis() - start) / 1000 + "秒 =============================");
            }
            return count;
        }
    }

    private static class BatchGroup2 extends AbstractBatch {
        @Override
        int insertBatch(List<Object[]> list,String tablename,int sqlCount, String... sql) throws SQLException {
       //     Connection conn;
            int count = 0;
            int[] c;
            boolean s1 = false, s2 = false;
            String batchSql0 = sql[0];
            String batchSql1 = sql[1];
            String batchSql2 = sql[2];
            connection = getConnection();
            connection.setAutoCommit(Boolean.FALSE);
            pStatement = connection.prepareStatement(batchSql0);
            pStatement2 = connection.prepareStatement(batchSql1);// null
            if (StringUtils.isNotEmpty(batchSql2))
                pStatement3 = connection.prepareStatement(batchSql2);//分组sql
            long start = System.currentTimeMillis();
            int length;
            for (int i = 0; i < list.size(); i++) {
                for (int j = 1, k = 0; j < (length = list.get(0).length) + 1; j++, k++) {//替换占位符
                    Object obj = list.get(i)[k];
                    if (k < length - 1) {
                        if (StringUtils.isNotEmpty((String) list.get(i)[length - 2])) {
                            s1 = Boolean.TRUE;
                            if (obj instanceof Integer) {
                                pStatement.setInt(j, (Integer) obj);
                            } else if (obj instanceof String) {
                                pStatement.setString(j, (String) obj);
                            } else if (obj instanceof Long) {
                                pStatement.setLong(j, (Long) obj);
                            }
                        } else {
                            s2 = Boolean.TRUE;
                            if (obj instanceof Integer) {
                                pStatement2.setInt(j, (Integer) obj);
                            } else if (obj instanceof String) {
                                pStatement2.setString(j, (String) obj);
                            } else if (obj instanceof Long) {
                                pStatement2.setLong(j, (Long) obj);
                            }
                        }
                    } else {//group
                        if (StringUtils.isNotEmpty(batchSql2)) {
                            Object o = list.get(i)[k];
                            String[] split = o.toString().split("\\|\\|");
                            for (int n = 1, m = 0; m < split.length; n++, m++) {
                                pStatement3.setString(n, split[m]);
                            }
                        }
                    }
                }
                if (s1)
                    pStatement.addBatch();
                if (s2)
                    pStatement2.addBatch();
                if (StringUtils.isNotEmpty(batchSql2))
                    pStatement3.addBatch();
                if (i % sqlCount == 0 && i != 0) {
                    if (s1) {//去空
                        c = pStatement.executeBatch();
                        for (int k = 0; k < c.length; k++) {
                            if (c[k] == -2) {
                                count++;
                            }
                        }
                        connection.commit();
                    }
                    if (s2) {//去空
                        c = pStatement2.executeBatch();
                        for (int k = 0; k < c.length; k++) {
                            if (c[k] == -2) {
                                count++;
                            }
                        }
                        connection.commit();
                    }
                    if (StringUtils.isNotEmpty(batchSql2)) {
                        c = pStatement3.executeBatch();
                        for (int k = 0; k < c.length; k++) {
                            if (c[k] == -2) {
                                count++;
                            }
                        }
                    }
                    connection.commit();
                    System.out.println("insert rows :" + i + ".....");
                }
            }
            if (s1) {//去空
                c = pStatement.executeBatch();
                for (int k = 0; k < c.length; k++) {
                    if (c[k] == -2) {
                        count++;
                    }
                }
                connection.commit();  // 提交
            }
            if (s2) {//去空
                c = pStatement2.executeBatch();
                for (int k = 0; k < c.length; k++) {
                    if (c[k] == -2) {
                        count++;
                    }
                }
                connection.commit();  // 提交
            }
            if (StringUtils.isNotEmpty(batchSql2)) {
                c = pStatement3.executeBatch();
                for (int k = 0; k < c.length; k++) {
                    if (c[k] == -2) {
                        count++;
                    }
                }
                connection.commit();
            }
            logger.info("============================= 插入" + count + "条数据用了" + (System.currentTimeMillis() - start) / 1000 + "秒 =============================");
            return count;
        }
    }
}




/**
 * 同步信息
 * @param channelList
 * @throws Exception
 */
public boolean insertKk(List<String> channelList,boolean isQl,String fileRight,String fileError) throws Exception{
	String time = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
	List<Object[]> list = new ArrayList<Object[]>();
	List<Object[]> listDel = new ArrayList<Object[]>();
	List<String> listRight = new ArrayList<String>();
	List<String> listError = new ArrayList<String>();
	String channel[] = null;
	String errorString = null;
	Matcher matcher = null;
	for(String channelString:channelList){
		errorString =  channelString;
		channelString = channelString + "|555";//防止最后一个元素数组无法统计进去
		channel = channelString.split("\\|");
		if(channel.length!=22){
			if(StringUtils.isNotEmpty(channel[0])){
				log.debug("导入文件格式错误:"+errorString);
			}
			listError.add(errorString);
			continue;
		}
		
		if(StringUtils.isBlank(channel[0])){
			log.debug("编码不能为空:"+errorString);
			listError.add(errorString);
			continue;
		}else{
			matcher = reg3.matcher(channel[0]);
			if(!matcher.matches()){
				log.debug("编码不符合规范:"+errorString);
				listError.add(errorString);
				continue;
			}else{
				if(channel[0].length()>38){
					log.debug("编码不符合规范:"+errorString);
					listError.add(errorString);
					continue;
				}
			}
		}
		
		if(StringUtils.isBlank(channel[3])){
			log.debug("类型不能为空:"+errorString);
			listError.add(errorString);
			continue;
		}else{
			if(!"1".equals(channel[3])&&!"2".equals(channel[3])){
				log.debug("类型不符合规范:"+errorString);
				listError.add(errorString);
				continue;
			}
		}			
		
		if(StringUtils.isBlank(channel[3])){
			log.debug("软删除标志位不能为空:"+errorString);
			listError.add(errorString);
			continue;
		}
		
		if("0".equals(channel[15])){
            list.add(new Object[]{
            		channel[0],Integer.valueOf(channel[3]),channel[0],Integer.valueOf(channel[3]),"111"
            });
		}else if("1".equals(channel[15])){
			listDel.add(new Object[]{
            		channel[0],"111"
            });
		}else{
			log.debug("软删除标志位不符合规范:"+errorString);
			listError.add(errorString);
			continue;
		}
		listRight.add(errorString);
	}
  String  sql1 = "MERGE INTO BUS_CHANNEL a1 Using (SELECT ? CHANNEL_ID from dual) a2"
   +" ON (a1.CHANNEL_ID=a2.CHANNEL_ID )"
   +" WHEN MATCHED THEN"
   +" UPDATE SET a1.VIDEO_TYPE=?,a1.CREATE_TIME=to_date('"+time+"','yyyy-MM-dd hh24:mi:ss')"
   +" WHEN NOT MATCHED THEN"
   +" INSERT (CHANNEL_ID ,VIDEO_TYPE,CREATE_TIME,CREATE_BY,STATUS)"
   +" VALUES (?,?,to_date('"+time+"','yyyy-MM-dd hh24:mi:ss'),1,2)";
   String sql2 = "DELETE FROM BUS_CHANNEL WHERE CHANNEL_ID=?";
   JDBCBatch.init(dataSource);
   JDBCBatch.insertBatch(list,"BUS_CHANNEL", 5000, sql1);
   JDBCBatch.insertBatch(listDel,"BUS_CHANNEL", 5000, sql2);
   
   ListeningExecutorService pool = threadPools.getPool();
   submitWriteTask(pool,fileRight,fileError, listRight,listError);

   
   if(listError.size()>1000){
	   return false;
   }else{
	   return true;
   }
	
}

CNZYYH
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdbctemplete 存在就更新不存在就插入的优化操作
weixin_30408165的博客
12-11 1192
当我们用java，jdbc 或者 spring的jdbctemplate来操作数据时候，总有时候会碰到 存在就插入不存在就更新 这样的需求，我们一般都是用下面的方法解决 public void save(){ JdbcTemplate jdbc = getJdbc(); String updateStatement=""; String insertStatement=""; ...
Java - JDBC批量插入原理
xxxzzzqqq_的博客
03-13 518
本实验将通过以下三步进行a. 记录jdbc在mysql中批量执行和单条执行的耗时b. 记录jdbc在oracle中批量执行和单条执行的耗时c. 记录oracle plsql批量执行和单条执行的耗时相关java和数据库版本如下：Java17，Mysql8，Oracle11Gmysql的批量执行就是改写sql。oracle的批量执行就是用的forall。选择一个合适批量值。
oracle触发器学习笔记
大圣的博客
11-23 289
一、触发器概念与作用： 触发器概念：数据库触发器是一个与表相关联，存储的PL/SQL程序。 触发器作用：每当一个特定的数据操作语句( INSERT, UPDATE, DELETE)在指定的表上发出时，Oracle自动地执行触发器中的定义的语句序列 触发器功能：允许/限制对表的修改、自动生成派生列，比如自增字段、强制数据一致性、提供审计和日志记录、防止无效的事务处理、启用复杂的业务逻辑 注：
mysql insert ignore .. ON DUPLICATE KEY 与oracle MERGE INTO 可以相互替换 批量插入存在则替换，不存在则插入
CNZYYH的博客
03-05 909
ORALCEMERGE INTO BUS_TEST a1 Using (SELECT ? CODE from dual) a2      ON (a1.CODE=a2.CODE )      WHEN MATCHED THEN      UPDATE SET a1.CODE_NAME=?,a1.VIDEO_TYPE=?      WHEN NOT MATCHED THEN      INSERT ...
oracle mybatis实现批量添加数据时如果数据存在就更新，如果不存在就插入（merge into 的用法）
奋斗的日子最甜美，在科技的海洋里，永无止境。
06-16 5864
判断需要插入的数据是否存在，如果不存在就更新 <insert id="saveBatch" parameterType="java.util.List" > MERGE INTO 表名 T1 USING ( <foreach collection="list" item="item" index="index" separator="u...
2021-08-28 使用JDBC实现数据更新
qq_45981086的博客
08-28 1660
JDBC的四种接口: DriverManager : 依据数据厍的不同，管理JDBC驱动 Connection :负责连接数据库并担任传送数据的任务 Statement :由Connection产生、负责执行SQL语句 ResultSet:负责保存Statement执行后所产生的查询结果 一、DriverManager: java.sql.DriverManager接口用来装载驱动程序，并创建新的数据连接。 关键方法: setConnection():使用给定的url建立一个数据库连接，并返回一个Con
Oracle批量插入6种方法小结
BringMyself的博客
02-03 6045
斜体样式@[TOC]Oracle批量插入6种方法小结 Oracle批量插入6种方法小结 准备 ` create table T_DQS_DATA_CRITERION_PAGE ( ID VARCHAR2(32) not null constraint T_DQS_DATA_CRITERION_PAGE_PK primary key, DATA_CRITERION_PRIMARY_ID VARCHAR2(32) not null, IS_ASSOCIATE NUMBER, FILE_NAME VARCHAR2
oracle 开启事务_小白都能看懂的JDBC事务
weixin_39616003的博客
01-28 1286
问：什么是事务？事务一组sql语句(insert、update、delete)，全部成功，整体才算成功，一个失败，整体也算失败。简单总结：开启事务执行sql语句群出现异常 回滚事务(撤销)无异常 事务提交(生效)Mysql中的事务管理mysql 的事务默认自动打开，自动提交。 一条sql就是一个事务，所以不需要事务开启、事务回滚、事务提交。开启事务： start transaction;执行sql...
初识jdbc对oracle数据库事务处理(隔离级别)
shunan的专栏
11-08 2223
一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。我们通过提交commit()或是回退rollback()来结束事务的操作。    在JDBC中，事务操作默认是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作。操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回退。    其次，在JDBC中，可以通过调用setAutoCo
Oracle jdbc for 11g 最新版 驱动 ojdbc6.jar
10-18
　我遇到的，之前使用ojdbc14.jar（不记得哪个版本了）批量插入10万条，实际只插入了3万多条，其它的丢失了，换ojdbc6.jar后，一次commit批量插入100万条也OK了。 　尽量使用和数据库版本一致的驱动,有bug时，换高...
Oracle jdbc for 11g 最新版 驱动 ojdbc6dms.jar
11-02
　我遇到的，之前使用ojdbc14.jar（不记得哪个版本了）批量插入10万条，实际只插入了3万多条，其它的丢失了，换ojdbc6.jar后，一次commit批量插入100万条也OK了。 　尽量使用和数据库版本一致的驱动,有bug时，换高...
java快速插入千万级数据
05-25
java快速插入千万级数据，亲测91秒插入1700万数据！！！
尚硅谷_佟刚_JDBC.pptx
11-15
尚硅谷_佟刚_JDBC 视频教程>> ------------------------------------ 视频特点： 除了常规的 JDBC 技术外，更涵盖 <利用反射及 JDBC 元数据编写通用的查询方法>、<使用 DBUtils 工具类>、设计模式>、<编写通用的...
利用XSSFWorkbook 来生成.xlsx类型的Excel表格
CNZYYH的博客
02-27 7072
以下是一个demo： @RequestMapping("/downExample") public void downExample(HttpServletResponse response,HttpServletRequest request){ String advProJson = request.getParameter("advProJson"); Lis...
JAVA检测文件是否传输完成
CNZYYH的博客
03-27 6948
    /**     * 检测文件是否传输完成     * @param fileName     * @return     * @throws Exception     */    public static boolean checkFileWritingOn(String fileName) throws Exception{        long oldLen = 0;      ...
Runtime.getRuntime().exec执行阻塞问题解决
CNZYYH的博客
02-03 5809
有时候我们可能需要调用系统外部的某个程序，此时就可以用Runtime.getRuntime().exec()来调用，他会生成一个新的进程去运行调用的程序。 此方法返回一个java.lang.Process对象，该对象可以得到之前开启的进程的运行结果，还可以操作进程的输入输出流。 Process对象有以下几个方法： 　　1、destroy()　　　　　　杀死这个子进程 　　2
JAVA Json字符串转POJO对象 POJO对象转JSON字符串 List转JSON JSON转List
CNZYYH的博客
02-26 4656
以下是Json字符串转POJO对象  POJO对象转JSON字符串 List转JSON JSON转List的工具类，类中有例子可参照：package cn.rojao.utils;import java.util.List;import cn.rojao.entity.stat.RequestEntity;import cn.rojao.entity.stat.ResponseEntity;imp...
maven 去除依赖包的默认依赖，重新引入新的依赖包
CNZYYH的博客
04-17 4255
&lt;dependency&gt;       &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;       &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt;   &lt;exclusions&gt;                   ...
oracle mybatis 批量插入
最新发布
04-27
要实现Oracle MyBatis批量插入，可以使用以下步骤： 1. 在MyBatis的Mapper文件中编写SQL语句，例如： ``` <insert id="batchInsert" parameterType="java.util.List"> insert into my_table (col1, col2, col3) values <foreach collection="list" item="item" separator=","> (#{item.col1}, #{item.col2}, #{item.col3}) </foreach> </insert> ``` 其中，`parameterType`指定了传入的参数类型为`java.util.List`，`foreach`标签用于遍历集合中的元素，生成多个插入语句。 2. 在Java代码中调用Mapper接口中的方法，例如： ``` List<MyTable> list = new ArrayList<>(); // 添加多个MyTable对象到list中 mapper.batchInsert(list); ``` 其中，`list`为要插入的对象列表，`mapper`为MyBatis的Mapper接口实例。 3. 在MyBatis的配置文件中开启批量操作支持，例如： ``` <configuration> <settings> <setting name="jdbcTypeForNull" value="NULL" /> <setting name="cacheEnabled" value="true" /> <setting name="lazyLoadingEnabled" value="true" /> <setting name="multipleResultSetsEnabled" value="true" /> <setting name="useColumnLabel" value="true" /> <setting name="useGeneratedKeys" value="false" /> <setting name="autoMappingBehavior" value="PARTIAL" /> <setting name="defaultExecutorType" value="SIMPLE" /> <setting name="defaultStatementTimeout" value="25" /> <setting name="safeRowBoundsEnabled" value="false" /> <setting name="mapUnderscoreToCamelCase" value="false" /> <!-- 开启批量操作支持 --> <setting name="defaultExecutorType" value="BATCH" /> </settings> <mappers> <mapper resource="com/example/MyMapper.xml" /> </mappers> </configuration> ``` 其中，`defaultExecutorType`设置为`BATCH`即可开启批量操作支持。 注意，Oracle数据库的批量插入操作需要使用JDBC的`addBatch()`和`executeBatch()`方法，因此插入数据时需要使用`BatchExecutor`批量执行器。如果使用的是MyBatis的`SimpleExecutor`简单执行器，则无法实现批量插入。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值