Hibernate 实现批量添加数据

最新推荐文章于 2022-02-21 22:02:36 发布
最新推荐文章于 2022-02-21 22:02:36 发布
阅读量405 收藏
点赞数
分类专栏： 碎片 文章标签： hibernate

1.Hibernate_016_BatchAddData程序目录结构：

2.lib目录下所引入的jar包：

3.MedicineDao.java源代码：

[java]  view plain copy
  1. package com.xqh.dao;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.hibernate.Session;  
  6.   
  7. import com.xqh.model.Medicine;  
  8. import com.xqh.util.HibernateUtil;  
  9.   
  10. /** 
  11.  * 药品数据库操作类 
  12.  *  
  13.  */  
  14. public class MedicineDao {  
  15.     /** 
  16.      * 批量保存药品 
  17.      *  
  18.      * @param ms 
  19.      *            List集合 
  20.      */  
  21.     public void saveMedicines(List<Medicine> ms) {  
  22.         Session session = null;  
  23.         if (ms != null && ms.size() > 0) {  
  24.             try {  
  25.                 session = HibernateUtil.getSession(); // 获取Session  
  26.                 session.beginTransaction(); // 开启事物  
  27.                 Medicine medicine = null; // 创建药品对象  
  28.                 // 循环获取药品对象  
  29.                 for (int i = 0; i < ms.size(); i++) {  
  30.                     medicine = (Medicine) ms.get(i); // 获取药品  
  31.                     session.save(medicine); // 保存药品对象  
  32.                     // 批插入的对象立即写入数据库并释放内存  
  33.                     if (i % 10 == 0) {  
  34.                         session.flush();  
  35.                         session.clear();  
  36.                     }  
  37.                 }  
  38.                 session.getTransaction().commit(); // 提交事物  
  39.             } catch (Exception e) {  
  40.                 e.printStackTrace(); // 打印错误信息  
  41.                 session.getTransaction().rollback(); // 出错将回滚事物  
  42.             } finally {  
  43.                 HibernateUtil.closeSession(session); // 关闭Session  
  44.             }  
  45.         }  
  46.     }  
  47. }  

4.Medicine.java源代码：

[java]  view plain copy
  1. package com.xqh.model;  
  2. /** 
  3.  * 药品持久化类 
  4.  */  
  5. public class Medicine {  
  6.     private Integer id;             //id号  
  7.     private String name;            //药品名称  
  8.     private double price;           //价格  
  9.     private String factoryAdd;      //出厂地址  
  10.     public Integer getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(Integer id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public double getPrice() {  
  23.         return price;  
  24.     }  
  25.     public void setPrice(double price) {  
  26.         this.price = price;  
  27.     }  
  28.     public String getFactoryAdd() {  
  29.         return factoryAdd;  
  30.     }  
  31.     public void setFactoryAdd(String factoryAdd) {  
  32.         this.factoryAdd = factoryAdd;  
  33.     }  
  34. }  

5.Medicine.hbm.xml源代码：

[html]  view plain copy
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.xqh.model.Medicine" table="tb_medicine_batch">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name" not-null="true" length="200" />  
  11.         <property name="price" not-null="true"/>  
  12.         <property name="factoryAdd" length="200"/>  
  13.     </class>  
  14. </hibernate-mapping>  

6.SaveMedicine.java源代码：

[java]  view plain copy
  1. package com.xqh.servlet;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. import javax.servlet.ServletException;  
  8. import javax.servlet.http.HttpServlet;  
  9. import javax.servlet.http.HttpServletRequest;  
  10. import javax.servlet.http.HttpServletResponse;  
  11.   
  12. import com.xqh.dao.MedicineDao;  
  13. import com.xqh.model.Medicine;  
  14.   
  15. public class SaveMedicine extends HttpServlet {  
  16.     private static final long serialVersionUID = 3743334039515411666L;  
  17.       
  18.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
  19.             throws ServletException, IOException {  
  20.         // 药品名称  
  21.         String names[] = request.getParameterValues("name");  
  22.         // 价格  
  23.         String prices[] = request.getParameterValues("price");  
  24.         // 出厂地址  
  25.         String adds[] = request.getParameterValues("factoryAdd");  
  26.         // 有效性判断  
  27.         if(names != null && prices != null && adds != null){  
  28.             if(names.length == prices.length && names.length == adds.length){  
  29.                 // 实例化一个List集合  
  30.                 List<Medicine> ms = new ArrayList<Medicine>();  
  31.                 Medicine m = null;  // 药品对象  
  32.                 // 依次实例化药品对象并添加到集合中  
  33.                 for (int i = 0; i < names.length; i++) {  
  34.                     m = new Medicine(); // 实例化药品  
  35.                     // 对属性赋值  
  36.                     m.setName(names[i]);  
  37.                     m.setPrice(Double.parseDouble(prices[i]));  
  38.                     m.setFactoryAdd(adds[i]);  
  39.                     ms.add(m);  // 添加到集合中  
  40.                 }  
  41.                 // 实例化MedicineDao对象  
  42.                 MedicineDao dao = new MedicineDao();  
  43.                 dao.saveMedicines(ms);  // 批量保存药品  
  44.                 request.setAttribute("info", "药品信息保存成功！！！");  
  45.             }  
  46.         }  
  47.         // 转发到result.jsp页面  
  48.         request.getRequestDispatcher("result.jsp").forward(request, response);  
  49.     }  
  50. }  

7.CharacterEncodingFilter.java源代码：

[java]  view plain copy
  1. /* 
  2.  * To change this template, choose Tools | Templates 
  3.  * and open the template in the editor. 
  4.  */  
  5. package com.xqh.util;  
  6.   
  7. import java.io.IOException;  
  8.   
  9. import javax.servlet.Filter;  
  10. import javax.servlet.FilterChain;  
  11. import javax.servlet.FilterConfig;  
  12. import javax.servlet.ServletException;  
  13. import javax.servlet.ServletRequest;  
  14. import javax.servlet.ServletResponse;  
  15.   
  16. /** 
  17.  * 字符编码过滤器 
  18.  */  
  19. public class CharacterEncodingFilter implements Filter{  
  20.   
  21.     protected String encoding = null;  
  22.     protected FilterConfig filterConfig = null;  
  23.   
  24.     public void init(FilterConfig filterConfig) throws ServletException {  
  25.         this.filterConfig = filterConfig;  
  26.         this.encoding = filterConfig.getInitParameter("encoding");  
  27.     }  
  28.   
  29.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
  30.         if (encoding != null) {  
  31.             request.setCharacterEncoding(encoding);  
  32.             response.setContentType("text/html; charset="+encoding);  
  33.         }  
  34.         chain.doFilter(request, response);  
  35.     }  
  36.   
  37.     public void destroy() {  
  38.         this.encoding = null;  
  39.         this.filterConfig = null;  
  40.     }  
  41. }  

8.HibernateUtil.java源代码：

[java]  view plain copy
  1. package com.xqh.util;  
  2.   
  3. import org.hibernate.HibernateException;  
  4. import org.hibernate.Session;  
  5. import org.hibernate.SessionFactory;  
  6. import org.hibernate.cfg.Configuration;  
  7.   
  8. /** 
  9.  * Hibernate初始化类，用于获取Session、SessionFactory 及关闭Session 
  10.  */  
  11. public class HibernateUtil {  
  12.     // SessionFactory对象  
  13.     private static SessionFactory factory = null;  
  14.     // 静态块  
  15.     static {  
  16.         try {  
  17.             // 加载Hibernate配置文件  
  18.             Configuration cfg = new Configuration().configure();  
  19.             // 实例化SessionFactory  
  20.             factory = cfg.buildSessionFactory();  
  21.         } catch (HibernateException e) {  
  22.             e.printStackTrace();  
  23.         }  
  24.     }  
  25.     /** 
  26.      * 获取Session对象 
  27.      * @return Session对象 
  28.      */  
  29.     public static Session getSession() {  
  30.         //如果SessionFacroty不为空，则开启Session  
  31.         Session session = (factory != null) ? factory.openSession() : null;  
  32.         return session;  
  33.     }  
  34.     /** 
  35.      * 获取SessionFactory对象 
  36.      * @return SessionFactory对象 
  37.      */  
  38.     public static SessionFactory getSessionFactory() {  
  39.         return factory;  
  40.     }  
  41.     /** 
  42.      * 关闭Session 
  43.      * @param session对象 
  44.      */  
  45.     public static void closeSession(Session session) {  
  46.         if (session != null) {  
  47.             if (session.isOpen()) {  
  48.                 session.close(); // 关闭Session  
  49.             }  
  50.         }  
  51.     }  
  52. }  

9.hibernate.cfg.xml源代码：

[html]  view plain copy
  1. <?xml version='1.0' encoding='UTF-8'?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  5. <hibernate-configuration>  
  6.     <session-factory>  
  7.         <!-- 方言 -->  
  8.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
  9.         <!-- 数据库连接 -->  
  10.         <property name="connection.url">jdbc:mysql://localhost:3306/learn</property>  
  11.         <!-- 数据库连接用户名 -->  
  12.         <property name="connection.username">root</property>  
  13.         <!-- 数据库连接密码 -->  
  14.         <property name="connection.password">1120</property>  
  15.         <!-- 数据库驱动 -->  
  16.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
  17.         <!-- 打印SQL语句 -->  
  18.         <property name="show_sql">true</property>  
  19.         <!-- 自动建表 -->  
  20.         <property name="hibernate.hbm2ddl.auto">update</property>  
  21.         <!-- 映射文件 -->  
  22.         <mapping resource="com/xqh/model/Medicine.hbm.xml"/>  
  23.     </session-factory>  
  24. </hibernate-configuration>  

10.log4j.properties源代码：

[html]  view plain copy
  1. ### direct log messages to stdout ###  
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  3. log4j.appender.stdout.Target=System.out  
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
  6.   
  7. ### direct messages to file hibernate.log ###  
  8. #log4j.appender.file=org.apache.log4j.FileAppender  
  9. #log4j.appender.file.File=hibernate.log  
  10. #log4j.appender.file.layout=org.apache.log4j.PatternLayout  
  11. #log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
  12.   
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###  
  14.   
  15. log4j.rootLogger=warn, stdout  
  16.   
  17. #log4j.logger.org.hibernate=info  
  18. #log4j.logger.org.hibernate=debug  
  19.   
  20. ### log HQL query parser activity  
  21. #log4j.logger.org.hibernate.hql.ast.AST=debug  
  22.   
  23. ### log just the SQL  
  24. #log4j.logger.org.hibernate.SQL=debug  
  25.   
  26. ### log JDBC bind parameters ###  
  27. #log4j.logger.org.hibernate.type=info  
  28. #log4j.logger.org.hibernate.type=debug  
  29.   
  30. ### log schema export/update ###  
  31. #log4j.logger.org.hibernate.tool.hbm2ddl=debug  
  32.   
  33. ### log HQL parse trees  
  34. #log4j.logger.org.hibernate.hql=debug  
  35.   
  36. ### log cache activity ###  
  37. #log4j.logger.org.hibernate.cache=debug  
  38.   
  39. ### log transaction activity  
  40. #log4j.logger.org.hibernate.transaction=debug  
  41.   
  42. ### log JDBC resource acquisition  
  43. #log4j.logger.org.hibernate.jdbc=debug  
  44.   
  45. ### enable the following line if you want to track down connection ###  
  46. ### leakages when using DriverManagerConnectionProvider ###  
  47. #log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace  

11.index.jsp源代码：

[html]  view plain copy
  1. <%@ page language="java" contentType="text/html" pageEncoding="GBK"%>  
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  3. <html>  
  4.     <head>  
  5.         <title>批量添加药品信息</title>  
  6.         <style type="text/css">  
  7. td {  
  8.     background: #EBEBEB;  
  9.     font-family: Verdana;  
  10.     font-size: 12px;  
  11.     background-color: #EBEBEB;  
  12.     color: black;  
  13.     line-height: 20px;  
  14.     height: 30px;  
  15. }  
  16. </style>  
  17.         <script type="text/javascript">  
  18.         function add(){  
  19.             var a = document.getElementById("a");  
  20.             var b = document.getElementById("b");  
  21.             b.innerHTML += a.innerHTML;  
  22.         }  
  23.   
  24.         function reduce() {  
  25.             var a = document.getElementById("a");  
  26.             var b = document.getElementById("b");  
  27.             var stra = a.innerHTML;  
  28.             var strb = b.innerHTML;  
  29.             b.innerHTML = strb.substring(0, strb.length - stra.length);  
  30.         }  
  31.         function save(formName){  
  32.             for(i=0;i<formName.length;i++){  
  33.                 if(formName.elements[i].value==""){  
  34.                     alert("请填写完整信息!");  
  35.                     return false;  
  36.                 }  
  37.             }  
  38.         }  
  39.     </script>  
  40.     </head>  
  41.   
  42.     <body onload="add()">  
  43.         <form action="SaveMedicine" method="post"  
  44.             onsubmit="return save(this);">  
  45.             <table align="center" border="0" cellpadding="3" cellspacing="1"  
  46.                 width="600">  
  47.                 <tr>  
  48.                     <td align="center">  
  49.                         <br>  
  50.                         <h1>  
  51.                             批量添加药品信息  
  52.                         </h1>  
  53.                     </td>  
  54.                 </tr>  
  55.                 <tr>  
  56.                     <td>  
  57.                         <div id="b"></div>  
  58.                     </td>  
  59.                 </tr>  
  60.                 <tr>  
  61.                     <td>  
  62.                         <input type="button" value="添加一行 " onclick="add()">  
  63.                         <input type="button" value="减少一行" onclick="reduce()">  
  64.                         <input type="submit" value="批量添加到数据库">  
  65.                     </td>  
  66.                 </tr>  
  67.             </table>  
  68.         </form>  
  69.         <div id="a" style="display: none">  
  70.             <table align="center" border="0">  
  71.                 <tr>  
  72.                     <td>  
  73.                         名称：  
  74.                     </td>  
  75.                     <td>  
  76.                         <input type="text" name="name" size="13">  
  77.                     </td>  
  78.                     <td>  
  79.                         单价：  
  80.                     </td>  
  81.                     <td>  
  82.                         <input type="text" name="price" size="13">  
  83.                     </td>  
  84.                     <td>  
  85.                         厂址：  
  86.                     </td>  
  87.                     <td>  
  88.                         <input type="text" name="factoryAdd" size="30">  
  89.                     </td>  
  90.                 </tr>  
  91.             </table>  
  92.         </div>  
  93.     </body>  
  94. </html>  

12.result.jsp源代码：

[html]  view plain copy
  1. <%@ page language="java" contentType="text/html" pageEncoding="GBK"%>  
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  3. <html>  
  4.   <head>  
  5.     <title>结果信息</title>  
  6.     <!-- 
  7.     <link rel="stylesheet" type="text/css" href="styles.css"> 
  8.     -->  
  9.   </head>  
  10.     
  11.   <body>  
  12.     <div align="center">  
  13.         <font color="red" size="12px;" style="font-weight: bold;">  
  14.             ${info}  
  15.         </font>  
  16.         <br><br><br><br>  
  17.         <a href="index.jsp">返回</a>  
  18.     </div>  
  19.   </body>  
  20. </html>  

13.数据表tb_medicine_batch结构：


14.程序运行结果截图：



siyunx
关注
专栏目录
java hibernate 插入数据_Hibernate实现批量添加数据的方法
weixin_36353849的博客
02-13 2170
本文实例讲述了Hibernate实现批量添加数据的方法。分享给大家供大家参考，具体如下：1.Hibernate_016_BatchAddData程序目录结构：2.lib目录下所引入的jar包：3.MedicineDao.java源代码：package com.xqh.dao;import java.util.List;import org.hibernate.Session;imp...
Hibernate的批量插入实战
实践求真知
09-20 375
一配置 <?xml version="1.0" encoding="GBK"?> <!-- 指定Hibernate配置文件的DTD信息 --> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://...
Hibernate的批量插入（&&JDBC）
热门推荐
浅浅请留步
06-25 1万+
一、批量插入(两种方式) 1，通过Hibernate缓存 如果这样写代码进行批量插入(初始设想)： package com.anlw.util; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.b
Java中Hibernate的批量插入
12-22
Hibernate完全以面向对象的方式来操作数据库，当程序里以面向对象的方式操作持久化对象时，将被自动转换为对数据库的操作。例如我们调用Session的delete()方法，来删除持久化对象，Hibernate将负责删除对应的数据记录；当我们执行持久化对象的setter方法时，Hibernate将自动转换为底层的update语句，修改数据库的对应记录。 　　问题是：如果我们需要同时更新100000条记录，是不是要逐一加载100000条记录，然后依次调用setter方法——这样不仅烦琐，数据访问的性能也十分糟糕。为了面对这种批量处理的场景，Hibernate提供了批量处理的解决方案。下面分别
Hibernate批量处理海量数据的方法
09-02
以下是针对Hibernate批量处理海量数据的一些关键知识点和优化策略： 1. **理解Hibernate的工作原理**：Hibernate通过查询数据库获取数据，并将其转化为Java对象存储在内存中，这种做法在处理小量数据时非常便捷，但...
Hibernate的批量处理-批量插入
fulerbakesi
07-12 242
Hibernate完全以面向对象的方式来操作数据库，当程序里以面向对象的方式操作持久化对象时，将被自动转换为对数据库的操作。例如我们调用Session的delete()方法，来删除持久化对象，Hibernate将负责删除对应的数据记录；当我们执行持久化对象的setter方法时，Hibernate将自动转换为底层的update语句，修改数据库的对应记录。 问题是：如果我们需要同时更新100000条...
Hibernate的批量处理-批量更新
weixin_34290096的博客
06-28 509
上面介绍的方法同样适用于批量更新数据，如果需要返回多行数据，应该使用scroll()方法，从而可以充分利用服务器端游标所带来的性能优势。下面是进行批量更新的代码片段。 程序清单：codes\06\6.3\batchUpdate\src\lee\UserManager.java private void updateUsers()throws Exception  {      //打开Sess...
Hibernate-批量新增
niuzai1111的博客
02-13 193
 public void batchProcessCards(final List&lt;Card&gt; listOfCard) {  getHibernateTemplate().execute(new HibernateCallback(){  public Object doInHibernate(Session session) throws HibernateException, SQ...
Hibernate+JDBC实现批量插入、更新及删除的方法详解
08-28
主要介绍了Hibernate+JDBC实现批量插入、更新及删除的方法,结合实例形式较为详细的分析了Hibernate与JDBC针对数据库的批量操作相关实现技巧,需要的朋友可以参考下
Hibernate 批量插入数据方法
qinganjing的博客
08-23 1753
hibernate 批量插入数据
Hibernate的批量处理
weixin_30471561的博客
07-19 426
Hibernate的批量处理 Hibernate完全以面向对象的方式来操作数据库，当程序里以面向对象的方式操作持久化对象时，将被自动转换为对数据库的操作。例如调用Session的delete()方法来删除持久化对象，Hibernate将负责删除对应的数据记录；当执行持久化对象的set方法时，Hibernate将自动转换为对应的update方法，修改数据库的对应记录。 问题是如果需要同时更新100 ...
Hibernate批量插入数据
挨T榕
02-25 345
    使用Hibernate将大量的记录（如100000条）插入到数据库时，很自然的的一种做法可能是：   Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); for ( int i=0; i&lt;100000; i++ ) { ...
Springboot+jpa+druid+hibernate实现批量新增
风间净琉璃的博客
02-21 2633
Springboot+jpa+druid+hibernate实现批量新增，并验证批量功能
hibernate 批量插入
u010676959的专栏
02-28 835
一般如果要插入100万条数据，则会写如下代码： [java] view plaincopy package org.xiazdong.test;    import junit.framework.TestCase;    import org.hibernate.Session;  import org.hibernate.SessionFactory;  import 
hibernate 批量增加/更改
qq_33291307的博客
03-27 506
hibernate 批量增加/更改
在Hibernate应用中如何处理批量更新和批量删除？
zhaopengfei8023的专栏
08-21 877
<br />在Hibernate应用中如何处理批量更新和批量删除？<br />选自<<精通Hibernate：Java对象持久化技术详解>> 作者：孙卫琴 来源:www.javathinker.org<br />如果转载，请标明出处，谢谢<br />9.4 批量处理数据<br /> <br />通常，在一个Session对象的缓存中只存放数量有限的持久化对象，等到Session对象处理事务完毕，还要关闭Session对象，从而及时释放Session的缓存占用的内存。<br />批量处理数据是指在一个事务中处
Hibernate批量添加数据详解及示例
本文详细介绍了如何在Hibernate框架中实现批量添加数据的方法，重点围绕以下几个关键点...通过阅读这篇文章，开发人员可以学习到如何在实际项目中合理运用Hibernate批量添加数据的方法，以提升代码的可读性和性能表现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值