使用spring的JdbcTemplate操作批量插入数据

最新推荐文章于 2024-05-09 01:55:52 发布
最新推荐文章于 2024-05-09 01:55:52 发布
阅读量1.1w 收藏 7
点赞数
分类专栏： L01-Java基础 文章标签： 使用spring的JdbcTemplate操作批量插入数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangbeizhen18/article/details/85769396
版权

场景:从数据库中一张表批量查出数,每条记录封装到一个实例对象中,再将批量查出的数据插入到另一张数据库表
1.实现类与测试main方法

public class BatchOperationDao {
	
	private static String querySql = "SELECT CITY_NAME,LAND_AREA,POPULATION,GROSS,AREA_NUMBER,POSTAL_CODE,TELEPHONE_CODE,CAR_CODE,CITY_DESCRIBE FROM T_CITY WHERE  AREA_NUMBER= ? ";
	private static String insertBatchSql = "INSERT INTO T_CITY_INFO  (CITY_NAME,LAND_AREA,POPULATION,GROSS,AREA_NUMBER,POSTAL_CODE,TELEPHONE_CODE,CAR_CODE,CITY_DESCRIBE) VALUES (?,?,?,?,?,?,?,?,?) ";
	private static Logger logger = LoggerFactory.getLogger(BatchOperationDao.class);
	
	@SuppressWarnings("unchecked")
	public List<Object> queryForInsert() {
		List<Object> list = new ArrayList<Object>();
		Object[] Params = {"350200"};
		JdbcTemplate jdbc=	OperateJdbcUtils.getJdbcTemplate();
		list = jdbc.query(querySql, Params,new CityInfoMapper());
		return list;
	}
	
	private static final class CityInfoMapper implements RowMapper{

		@Override
		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			CityModel cityModel = new CityModel();
			cityModel.setCityName(rs.getString("CITY_NAME"));
			cityModel.setLandArea(rs.getDouble("LAND_AREA"));
			cityModel.setPopulation(rs.getLong("POPULATION"));
			cityModel.setGross(rs.getDouble("GROSS"));
			cityModel.setAreaNumber(rs.getString("AREA_NUMBER"));
			cityModel.setPostalCode(rs.getString("POSTAL_CODE"));
			cityModel.setTelephoneCode(rs.getString("TELEPHONE_CODE"));
			cityModel.setCarCode(rs.getString("CAR_CODE"));
			cityModel.setCityDescribe(rs.getString("CITY_DESCRIBE"));
			return cityModel;
		}
	}
	
	public int batchInsert(final List<Object> list) throws Exception {
		if (list.size() == 0) {
			return 0;
		}
		JdbcTemplate jdbc=	OperateJdbcUtils.getJdbcTemplate();
		String batchsql  =  getBatchInsertSql(insertBatchSql, list);
		int k= jdbc.update( batchsql , new PreparedStatementSetter(){
			@Override
			public void setValues(PreparedStatement ps) throws SQLException {
				 ObjectToPs(ps, list);
			}	
		});
		return k;
	}
	
	public void ObjectToPs(PreparedStatement ps, List<Object> list)
			throws SQLException {
		for (int i = 0; i < list.size(); ++i) {
			CityModel cityModel = (CityModel) list.get(i);
			ps.setString(9*i+1, cityModel.getCityName());
			ps.setDouble(9*i+2, cityModel.getLandArea() );
			ps.setLong(  9*i+3, cityModel.getPopulation() );
			ps.setDouble(9*i+4, cityModel.getGross() );
			ps.setString(9*i+5, cityModel.getAreaNumber() );
			ps.setString(9*i+6, cityModel.getPostalCode() );
			ps.setString(9*i+7, cityModel.getTelephoneCode() );
			ps.setString(9*i+8, cityModel.getCarCode() );
			ps.setString(9*i+9, cityModel.getCityDescribe() );
		}
		 
	}
	
	public static String getBatchInsertSql(String keyStr,List list) throws Exception{
		
		int index = keyStr.indexOf("VALUES");
		String loopStr = keyStr.substring(index+6);
		StringBuilder builder = new StringBuilder(keyStr.substring(0, index+6));
		for (int j = 0; j <list.size() ;++j) {
			builder.append(loopStr);
			if (j < list.size() -1) {
				builder.append(",");
			}
		}
		return builder.toString();
	}
	
	public static void main(String [] args) throws Exception{
		
		BatchOperationDao dao = new BatchOperationDao();
		logger.info("测试开始......");
		List<Object> list = dao.queryForInsert();
		dao.batchInsert(list);
		logger.info("测试结束......");
	}
}

2.实体类

public class CityModel implements Serializable {

	private static final long serialVersionUID = 4443714978780088961L;
	
	String cityName;
	double landArea;
	long population;	 
	double gross ;
	String areaNumber;
	String postalCode;
	String telephoneCode;
	String carCode;
	String cityDescribe;
	
	public String getCityName() {
		return cityName;
	}
	public void setCityName(String cityName) {
		this.cityName = cityName;
	}
	public double getLandArea() {
		return landArea;
	}
	public void setLandArea(double landArea) {
		this.landArea = landArea;
	}
	public long getPopulation() {
		return population;
	}
	public void setPopulation(long population) {
		this.population = population;
	}
	public double getGross() {
		return gross;
	}
	public void setGross(double gross) {
		this.gross = gross;
	}
	public String getAreaNumber() {
		return areaNumber;
	}
	public void setAreaNumber(String areaNumber) {
		this.areaNumber = areaNumber;
	}
	public String getPostalCode() {
		return postalCode;
	}
	public void setPostalCode(String postalCode) {
		this.postalCode = postalCode;
	}
	public String getTelephoneCode() {
		return telephoneCode;
	}
	public void setTelephoneCode(String telephoneCode) {
		this.telephoneCode = telephoneCode;
	}
	public String getCarCode() {
		return carCode;
	}
	public void setCarCode(String carCode) {
		this.carCode = carCode;
	}
	 
	
	public String getCityDescribe() {
		return cityDescribe;
	}
	public void setCityDescribe(String cityDescribe) {
		this.cityDescribe = cityDescribe;
	}
	@Override
	public String toString() {
		
		return "CityModel [cityName=" + cityName
				+",landArea=" + landArea
				+",population=" + population
				+",gross=" + gross
				+",areaNumber=" + areaNumber
				+",postalCode=" + postalCode
				+",telephoneCode=" + telephoneCode
				+",carCode=" + carCode
				+",cityDescribe=" + cityDescribe
				+"]";
	}
}

3.JdbcTemplate实例类

public class OperateJdbcUtils {
	
	/**数据库连接需要字符串*/
	public static final String username = "root";
	public static final String password = "123456";
	public static final String jdbcUrl = "jdbc:mysql://127.0.0.1:3306/zbzdb";
	public static final String driverName = "com.mysql.jdbc.Driver";
	public static JdbcTemplate jdbcTemplate = getJdbcTemplate();	
	/**获取一个JdbcTemplate实例对象*/
	public static JdbcTemplate getJdbcTemplate() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setPassword(password);
		dataSource.setUrl(jdbcUrl);
		dataSource.setUsername(username);
		dataSource.setDriverClassName(driverName);
		JdbcTemplate jdbcTemplate = new JdbcTemplate();
		jdbcTemplate.setDataSource(dataSource);
		return jdbcTemplate;
	}
}

4.数据库两张表

CREATE TABLE `t_city` (
  `CITY_NAME` VARCHAR(64) COLLATE utf8_bin NOT NULL COMMENT '城市名',
  `LAND_AREA` DOUBLE DEFAULT NULL COMMENT '城市面积',
  `POPULATION` BIGINT(16) DEFAULT NULL COMMENT '城市人口',
  `GROSS` DOUBLE DEFAULT NULL COMMENT '生产总值',
  `AREA_NUMBER` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '行政区划代码',
  `POSTAL_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '邮政编码',
  `TELEPHONE_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '电话区号',
  `CAR_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '车牌代码',
  `CITY_DESCRIBE` VARCHAR(512) COLLATE utf8_bin DEFAULT NULL COMMENT '城市描述'
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='城市信息表'


CREATE TABLE `t_city_info` (
  `CITY_NAME` VARCHAR(64) COLLATE utf8_bin NOT NULL COMMENT '城市名',
  `LAND_AREA` DOUBLE DEFAULT NULL COMMENT '城市面积',
  `POPULATION` BIGINT(16) DEFAULT NULL COMMENT '城市人口',
  `GROSS` DOUBLE DEFAULT NULL COMMENT '生产总值',
  `AREA_NUMBER` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '行政区划代码',
  `POSTAL_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '邮政编码',
  `TELEPHONE_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '电话区号',
  `CAR_CODE` VARCHAR(64) COLLATE utf8_bin DEFAULT NULL COMMENT '车牌代码',
  `CITY_DESCRIBE` VARCHAR(512) COLLATE utf8_bin DEFAULT NULL COMMENT '城市描述'
) ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='城市信息表'

以上,TKS.

zhangbeizhen18
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JdbcTemplate（操作数据库-添加功能）
LBJ8888888的博客
12-30 2976
JdbcTemplate（操作数据库-添加功能） 1.建立数据库表： 2.对应数据库创建实体类： User类对应数据库的t_user表的数据，每一个属性就是一条记录 3.编写service 和 dao （1）在 dao 进行数据库添加操作 （2）调用jdbcTemplate 对象里面 update 方法可以实现添加操作 update中有两个参数： 第一个参数：编写的sql语句 第二个参数：可变参数，设置sql 语句值 BookDaoImpl类代码如...
jdbcTemplate操作数据库（批量操作）
m0_63734254的博客
04-23 3285
1.批量操作：操作表里面多条记录 2.JdbcTemplate实现批量添加操作 batchUpdate(String sql, List<Object[]> batchArgs) 有两个参数： 第一个参数：sql语句 第二个参数：List集合，添加多条记录数据 3.JdbcTemplate实现批量修改操作 4.JdbcTemplate实现批量删除操作 1.对应数据库创建实体类 package com.atguigu.spring5.entity; public c.
Spring JdbcTemplate实现update或insert
hty68024352的专栏
06-04 734
三种使用Spring JdbcTemplate实现update或insert操作     第一种方式，重载PreparedStatementCreator jdbcTemplate.update(new PreparedStatementCreator(){     public PreparedStatement createPreparedStatement(Connection c...
JdbcTemplate批量插入
freekaiQaQ的博客
12-14 5991
jdbcTemplate批量插入数据，优化springJpa插入慢的情况
SpringBoot项目中对数据库的基本操作+批量插入数据的优化
最新发布
a289246的博客
05-09 1204
SpringBoot项目中对数据库的基本操作+批量插入数据的优化，主要包括增删改查基本操作以及批量插入的优化，如何成功插入百万条数据
使用Spring 内置的JdbcTemplate操作数据库
代码与酒
02-03 1123
Hibernate是一个很好的ORM框架，使用Hibernate可以很好的提高开发效率，而且操作起来也是非常简单，但是Hibernate也有一定的灵活性限制，此时就可以使用Spring内置的JDBC框架；JDBC框架是对纯JDBC的一个封装，简化了一些繁琐的操作，而且可以自己编写sql语句，灵活的处理业务。         Spring JDBC框架（spring-jdbc-x.x.x.
Spring JdbcDaoSupport 批量插入数据
05-28
总结起来，`Spring JdbcDaoSupport`是简化数据库操作的有效工具，特别适合批量插入数据。通过`JdbcTemplate`的`batchUpdate`方法和`BatchPreparedStatementSetter`，我们可以高效地处理大量数据，同时保持代码的整洁...
SpringJDBC批量处理数据代码示例
01-19
参数: List<Map> paramMaps = new ArrayList(); for(int i = 0; i < 100; i++ ){ Map paramMap = new HashMap(); paramMap.put(param1, param1);... paramMap.put(param2, param2);... paramMap.put(param5, param5
Spring框架实现Excel批量导入数据
04-13
以上就是使用Spring框架实现Excel批量导入数据的基本步骤。通过这种方式，可以极大地提高数据录入的效率，降低手动操作的工作量，尤其适用于需要频繁处理大量数据的业务场景。在实际项目中，可以根据具体需求进行...
使用Spring JDBCTemplate进行增删改查curd操作
01-13
JdbcTemplate还支持批量操作，比如批量插入： ```java public void batchInsert(List<User> users) { List[]> batchArgs = new ArrayList(); for (User user : users) { batchArgs.add(new Object[]{user....
使用JdbcTemplate的BatchPreparedStatementSetter批量插入数据
zhangbeizhen18的博客
04-10 2813
记录：397 场景：使用JdbcTemplate从一个数据库批量查出数据存放在List中，把查出的结果数据批量写入到另一个数据库。
JdbcTemplate简单实用讲解
cyh0503的博客
07-02 3098
一、建立demo所需的数据库 建立数据库：day18 create database day18; 建立数据表：t_user并创建三个字段，id、username、password。 create table t_user(id int primary_key auto_increment,username varchar(50),password varchar(32)); 插入几...
Spring——JdbcTemplate操作数据库
ouyangkq666的博客
12-15 1915
一、JdbcTemplate（概念和准备） 二、JdbcTemplate操作数据库（添加） 三、JdbcTemplate操作数据库（修改和删除） 四、JdbcTemplate操作数据库（查询返回某个值） 五、JdbcTemplate操作数据库（查询返回对象） 六、JdbcTemplate操作数据库（查询返回集合） 七、JdbcTemplate操作数据库（批量操作）
Java笔记-JdbcTemplate批量执行insert及update
IT1995的博客
08-17 1444
主要就是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[]>();
batch-insert-JdbcTemplate
qq_37276508的博客
05-07 536
* 表名* </p>/**** <p>* 表的主键*
jdbctemplate数据批量入库
qq_40711092的博客
01-09 613
相比于数据一条一条入库，批量入库效率更高，不过需要注意批量入库数据量大小需要控制好，1千到2千条数据入库较快，超过两千条数据入库较慢。
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 (?,?,?,?,?,?,?,?,?,?,?)";
jdbctemplate批量插入数据
06-28
### 回答1： JdbcTemplate是Spring框架中的一个核心类，用于简化JDBC操作。它提供了一些常用的方法，如查询、更新、批量操作等。在JdbcTemplate中，批量插入数据可以使用batchUpdate()方法实现。具体步骤如下： 1. 创建JdbcTemplate对象。 2. 定义SQL语句。 3. 定义数据集合，将需要插入的数据存入集合中。 4. 调用batchUpdate()方法，将数据集合作为参数传入。 5. 处理返回结果。 示例代码如下： ``` // 创建JdbcTemplate对象 JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); // 定义SQL语句 String sql = "INSERT INTO user(name, age) VALUES(?, ?)"; // 定义数据集合 List<Object[]> batchArgs = new ArrayList<>(); batchArgs.add(new Object[]{"张三", 20}); batchArgs.add(new Object[]{"李四", 22}); batchArgs.add(new Object[]{"王五", 25}); // 执行批量插入操作 int[] result = jdbcTemplate.batchUpdate(sql, batchArgs); // 处理返回结果 for (int i : result) { System.out.println("影响行数：" + i); } ``` 以上代码实现了批量插入3条数据的操作。其中，batchArgs集合中存放了需要插入的数据，每个元素是一个Object[]数组，表示一条数据的各个字段值。batchUpdate()方法返回一个int[]数组，表示每条SQL语句影响的行数。在处理返回结果时，可以根据需要进行相应的处理。 ### 回答2： 在实际开发中，我们常常需要批量插入大量的数据到数据库中。如果使用传统的JDBC插入方式，每个数据都需要进行一次数据库连接、执行插入操作、关闭连接，这样会大大降低程序的效率。而JdbcTemplate提供了批量插入数据的方法，可以一次性将多条数据插入到数据库中，极大地提高了程序的执行效率。 JdbcTemplate批量插入数据的方法主要有两种： 1. 批量插入数据并返回插入行数 ```java public int[] batchUpdate(String sql, BatchPreparedStatementSetter pss) ``` BatchPreparedStatementSetter是一个接口，需要我们实现其中的两个方法： ```java public interface BatchPreparedStatementSetter { void setValues(PreparedStatement ps, int i) throws SQLException; int getBatchSize(); } ``` setValues()方法用于设置PreparedStatement对象中的参数值，i参数表示当前执行的行数。getBatchSize()方法返回要执行的总行数。 示例代码如下： ```java String sql = "insert into user (name, age) values (?, ?)"; List<User> userList = new ArrayList<User>(); userList.add(new User("Tom", 25)); userList.add(new User("Jerry", 26)); userList.add(new User("Mike", 27)); int[] rows = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { ps.setString(1, userList.get(i).getName()); ps.setInt(2, userList.get(i).getAge()); } @Override public int getBatchSize() { return userList.size(); } }); ``` 2. 批量插入数据并返回自增主键的值 ```java public int[] batchUpdate(String sql, BatchPreparedStatementSetter pss, KeyHolder generatedKeyHolder) ``` KeyHolder是一个接口，用于获取插入的自增主键的值。我们可以使用GeneratedKeyHolder来实现该接口。示例代码如下： ```java String sql = "insert into user (name, age) values (?, ?)"; List<User> userList = new ArrayList<User>(); userList.add(new User("Tom", 25)); userList.add(new User("Jerry", 26)); userList.add(new User("Mike", 27)); KeyHolder keyHolder = new GeneratedKeyHolder(); int[] rows = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { ps.setString(1, userList.get(i).getName()); ps.setInt(2, userList.get(i).getAge()); } @Override public int getBatchSize() { return userList.size(); } }, keyHolder); List<Map<String, Object>> keyList = keyHolder.getKeyList(); for (int i = 0; i < keyList.size(); i++) { System.out.println("Row " + (i + 1) + " generated key：" + keyList.get(i).values()); } ``` 总的来说，JdbcTemplate提供的批量插入数据的方法可以大大提高程序的效率，让我们的开发更加高效。 ### 回答3： JdbcTemplate是Spring框架中的一个核心组件，它是一个简化JDBC操作的工具，提供了大量的方法来处理SQL语句和执行数据库操作。在JdbcTemplate中，使用批量插入操作可以提高数据插入的效率。下面我们将详细介绍如何使用JdbcTemplate批量插入数据。 1.创建JdbcTemplate对象 首先，我们需要在Spring配置文件中配置数据源，并创建一个JdbcTemplate对象。 ``` <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/test"></property> <property name="username" value="root"></property> <property name="password" value="123456"></property> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean> ``` 2.编写SQL语句 接下来，编写一个插入语句，并通过JdbcTemplate的batchUpdate()方法实现批量插入操作。 ``` String sql = "insert into user(name, age) values(?, ?)"; ``` 3.插入数据 通过参数化的方式设置插入语句中的参数，并将多个参数数组封装在一个List集合中，通过JdbcTemplate的batchUpdate()方法批量插入数据。 ``` List<Object[]> batchArgs = new ArrayList<Object[]>(); batchArgs.add( new Object[]{"张三", 20}); batchArgs.add( new Object[]{"李四", 22}); batchArgs.add( new Object[]{"王五", 25}); int[] result = jdbcTemplate.batchUpdate(sql, batchArgs); ``` 总的来说，使用JdbcTemplate批量插入数据可以大大提高数据插入的效率和性能，同时也降低了对数据库的负担。当然，在实际应用中，我们还需要注意事务的处理和异常的捕获等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值