`

Hibernate 实现批量添加数据

 
阅读更多

转：http://blog.csdn.net/tkd03072010/article/details/6905899

 

1.Hibernate_016_BatchAddData程序目录结构：

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

3.MedicineDao.java源代码：

[java] view plaincopyprint?
  1. package com.xqh.dao;
  3. import java.util.List;
  5. import org.hibernate.Session;
  7. import com.xqh.model.Medicine;
  8. import com.xqh.util.HibernateUtil;
  10. /**
  11. * 药品数据库操作类
  12. *
  13. */
  14. publicclass MedicineDao {
  15. /**
  16. * 批量保存药品
  17. *
  18. * @param ms
  19. * List集合
  20. */
  21. publicvoid 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. } 
package com.xqh.dao;

import java.util.List;

import org.hibernate.Session;

import com.xqh.model.Medicine;
import com.xqh.util.HibernateUtil;

/**
 * 药品数据库操作类
 * 
 */
public class MedicineDao {
	/**
	 * 批量保存药品
	 * 
	 * @param ms
	 *            List集合
	 */
	public void saveMedicines(List<Medicine> ms) {
		Session session = null;
		if (ms != null && ms.size() > 0) {
			try {
				session = HibernateUtil.getSession(); // 获取Session
				session.beginTransaction(); // 开启事物
				Medicine medicine = null; // 创建药品对象
				// 循环获取药品对象
				for (int i = 0; i < ms.size(); i++) {
					medicine = (Medicine) ms.get(i); // 获取药品
					session.save(medicine); // 保存药品对象
					// 批插入的对象立即写入数据库并释放内存
					if (i % 10 == 0) {
						session.flush();
						session.clear();
					}
				}
				session.getTransaction().commit(); // 提交事物
			} catch (Exception e) {
				e.printStackTrace(); // 打印错误信息
				session.getTransaction().rollback(); // 出错将回滚事物
			} finally {
				HibernateUtil.closeSession(session); // 关闭Session
			}
		}
	}
}


4.Medicine.java源代码：

 

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


5.Medicine.hbm.xml源代码：

 

[html] view plaincopyprint?
  1. <?xmlversion="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. <classname="com.xqh.model.Medicine"table="tb_medicine_batch">
  7. <idname="id">
  8. <generatorclass="native"/>
  9. </id>
  10. <propertyname="name"not-null="true"length="200"/>
  11. <propertyname="price"not-null="true"/>
  12. <propertyname="factoryAdd"length="200"/>
  13. </class>
  14. </hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.xqh.model.Medicine" table="tb_medicine_batch">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name" not-null="true" length="200" />
		<property name="price" not-null="true"/>
		<property name="factoryAdd" length="200"/>
	</class>
</hibernate-mapping>


6.SaveMedicine.java源代码：

 

[java] view plaincopyprint?
  1. package com.xqh.servlet;
  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  12. import com.xqh.dao.MedicineDao;
  13. import com.xqh.model.Medicine;
  15. publicclass SaveMedicine extends HttpServlet {
  16. privatestaticfinallong serialVersionUID = 3743334039515411666L;
  18. publicvoid 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. } 
package com.xqh.servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.xqh.dao.MedicineDao;
import com.xqh.model.Medicine;

public class SaveMedicine extends HttpServlet {
	private static final long serialVersionUID = 3743334039515411666L;
	
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// 药品名称
		String names[] = request.getParameterValues("name");
		// 价格
		String prices[] = request.getParameterValues("price");
		// 出厂地址
		String adds[] = request.getParameterValues("factoryAdd");
		// 有效性判断
		if(names != null && prices != null && adds != null){
			if(names.length == prices.length && names.length == adds.length){
				// 实例化一个List集合
				List<Medicine> ms = new ArrayList<Medicine>();
				Medicine m = null;	// 药品对象
				// 依次实例化药品对象并添加到集合中
				for (int i = 0; i < names.length; i++) {
					m = new Medicine();	// 实例化药品
					// 对属性赋值
					m.setName(names[i]);
					m.setPrice(Double.parseDouble(prices[i]));
					m.setFactoryAdd(adds[i]);
					ms.add(m);	// 添加到集合中
				}
				// 实例化MedicineDao对象
				MedicineDao dao = new MedicineDao();
				dao.saveMedicines(ms);	// 批量保存药品
				request.setAttribute("info", "药品信息保存成功！！！");
			}
		}
		// 转发到result.jsp页面
		request.getRequestDispatcher("result.jsp").forward(request, response);
	}
}


7.CharacterEncodingFilter.java源代码：

 

[java] view plaincopyprint?
  1. /*
  2. * To change this template, choose Tools | Templates
  3. * and open the template in the editor.
  4. */
  5. package com.xqh.util;
  7. import java.io.IOException;
  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;
  16. /**
  17. * 字符编码过滤器
  18. */
  19. publicclass CharacterEncodingFilter implements Filter{
  21. protected String encoding = null;
  22. protected FilterConfig filterConfig = null;
  24. publicvoid init(FilterConfig filterConfig) throws ServletException {
  25. this.filterConfig = filterConfig;
  26. this.encoding = filterConfig.getInitParameter("encoding");
  27. }
  29. publicvoid 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. }
  37. publicvoid destroy() {
  38. this.encoding = null;
  39. this.filterConfig = null;
  40. }
  41. } 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.xqh.util;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 字符编码过滤器
 */
public class CharacterEncodingFilter implements Filter{

    protected String encoding = null;
    protected FilterConfig filterConfig = null;

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
        this.encoding = filterConfig.getInitParameter("encoding");
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (encoding != null) {
            request.setCharacterEncoding(encoding);
            response.setContentType("text/html; charset="+encoding);
        }
        chain.doFilter(request, response);
    }

    public void destroy() {
        this.encoding = null;
        this.filterConfig = null;
    }
}


8.HibernateUtil.java源代码：

 

[java] view plaincopyprint?
  1. package com.xqh.util;
  3. import org.hibernate.HibernateException;
  4. import org.hibernate.Session;
  5. import org.hibernate.SessionFactory;
  6. import org.hibernate.cfg.Configuration;
  8. /**
  9. * Hibernate初始化类，用于获取Session、SessionFactory 及关闭Session
  10. */
  11. publicclass HibernateUtil {
  12. // SessionFactory对象
  13. privatestatic 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. publicstatic 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. publicstatic SessionFactory getSessionFactory() {
  39. return factory;
  40. }
  41. /**
  42. * 关闭Session
  43. * @param session对象
  44. */
  45. publicstaticvoid closeSession(Session session) {
  46. if (session != null) {
  47. if (session.isOpen()) {
  48. session.close(); // 关闭Session
  49. }
  50. }
  51. }
  52. } 
package com.xqh.util;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate初始化类，用于获取Session、SessionFactory 及关闭Session
 */
public class HibernateUtil {
	// SessionFactory对象
	private static SessionFactory factory = null;
	// 静态块
	static {
		try {
			// 加载Hibernate配置文件
			Configuration cfg = new Configuration().configure();
			// 实例化SessionFactory
			factory = cfg.buildSessionFactory();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 获取Session对象
	 * @return Session对象
	 */
	public static Session getSession() {
		//如果SessionFacroty不为空，则开启Session
		Session	session = (factory != null) ? factory.openSession() : null;
		return session;
	}
	/**
	 * 获取SessionFactory对象
	 * @return SessionFactory对象
	 */
	public static SessionFactory getSessionFactory() {
		return factory;
	}
	/**
	 * 关闭Session
	 * @param session对象
	 */
	public static void closeSession(Session session) {
		if (session != null) {
			if (session.isOpen()) {
				session.close(); // 关闭Session
			}
		}
	}
}


9.hibernate.cfg.xml源代码：

 

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


10.log4j.properties源代码：

 

[html] view plaincopyprint?
  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
  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
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###
  15. log4j.rootLogger=warn, stdout
  17. #log4j.logger.org.hibernate=info
  18. #log4j.logger.org.hibernate=debug
  20. ### log HQL query parser activity
  21. #log4j.logger.org.hibernate.hql.ast.AST=debug
  23. ### log just the SQL
  24. #log4j.logger.org.hibernate.SQL=debug
  26. ### log JDBC bind parameters ###
  27. #log4j.logger.org.hibernate.type=info
  28. #log4j.logger.org.hibernate.type=debug
  30. ### log schema export/update ###
  31. #log4j.logger.org.hibernate.tool.hbm2ddl=debug
  33. ### log HQL parse trees
  34. #log4j.logger.org.hibernate.hql=debug
  36. ### log cache activity ###
  37. #log4j.logger.org.hibernate.cache=debug
  39. ### log transaction activity
  40. #log4j.logger.org.hibernate.transaction=debug
  42. ### log JDBC resource acquisition
  43. #log4j.logger.org.hibernate.jdbc=debug
  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
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
#log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace


11.index.jsp源代码：

 

[html] view plaincopyprint?
  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. <styletype="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. <scripttype="text/javascript">
  18. function add(){
  19. var a = document.getElementById("a");
  20. var b = document.getElementById("b");
  21. b.innerHTML += a.innerHTML;
  22. }
  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>
  42. <bodyonload="add()">
  43. <formaction="SaveMedicine"method="post"
  44. onsubmit="return save(this);">
  45. <tablealign="center"border="0"cellpadding="3"cellspacing="1"
  46. width="600">
  47. <tr>
  48. <tdalign="center">
  49. <br>
  50. <h1>
  51. 批量添加药品信息
  52. </h1>
  53. </td>
  54. </tr>
  55. <tr>
  56. <td>
  57. <divid="b"></div>
  58. </td>
  59. </tr>
  60. <tr>
  61. <td>
  62. <inputtype="button"value="添加一行 "onclick="add()">
  63. <inputtype="button"value="减少一行"onclick="reduce()">
  64. <inputtype="submit"value="批量添加到数据库">
  65. </td>
  66. </tr>
  67. </table>
  68. </form>
  69. <divid="a"style="display: none">
  70. <tablealign="center"border="0">
  71. <tr>
  72. <td>
  73. 名称：
  74. </td>
  75. <td>
  76. <inputtype="text"name="name"size="13">
  77. </td>
  78. <td>
  79. 单价：
  80. </td>
  81. <td>
  82. <inputtype="text"name="price"size="13">
  83. </td>
  84. <td>
  85. 厂址：
  86. </td>
  87. <td>
  88. <inputtype="text"name="factoryAdd"size="30">
  89. </td>
  90. </tr>
  91. </table>
  92. </div>
  93. </body>
  94. </html>
<%@ page language="java" contentType="text/html" pageEncoding="GBK"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
	<head>
		<title>批量添加药品信息</title>
		<style type="text/css">
td {
	background: #EBEBEB;
	font-family: Verdana;
	font-size: 12px;
	background-color: #EBEBEB;
	color: black;
	line-height: 20px;
	height: 30px;
}
</style>
		<script type="text/javascript">
		function add(){
			var a = document.getElementById("a");
			var b = document.getElementById("b");
			b.innerHTML += a.innerHTML;
		}

		function reduce() {
			var a = document.getElementById("a");
			var b = document.getElementById("b");
			var stra = a.innerHTML;
			var strb = b.innerHTML;
			b.innerHTML = strb.substring(0, strb.length - stra.length);
		}
		function save(formName){
		    for(i=0;i<formName.length;i++){
				if(formName.elements[i].value==""){
					alert("请填写完整信息!");
				    return false;
				}
		    }
		}
	</script>
	</head>

	<body onload="add()">
		<form action="SaveMedicine" method="post"
			onsubmit="return save(this);">
			<table align="center" border="0" cellpadding="3" cellspacing="1"
				width="600">
				<tr>
					<td align="center">
						<br>
						<h1>
							批量添加药品信息
						</h1>
					</td>
				</tr>
				<tr>
					<td>
						<div id="b"></div>
					</td>
				</tr>
				<tr>
					<td>
						<input type="button" value="添加一行 " onclick="add()">
						<input type="button" value="减少一行" onclick="reduce()">
						<input type="submit" value="批量添加到数据库">
					</td>
				</tr>
			</table>
		</form>
		<div id="a" style="display: none">
			<table align="center" border="0">
				<tr>
					<td>
						名称：
					</td>
					<td>
						<input type="text" name="name" size="13">
					</td>
					<td>
						单价：
					</td>
					<td>
						<input type="text" name="price" size="13">
					</td>
					<td>
						厂址：
					</td>
					<td>
						<input type="text" name="factoryAdd" size="30">
					</td>
				</tr>
			</table>
		</div>
	</body>
</html>


12.result.jsp源代码：

 

[html] view plaincopyprint?
  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>
  11. <body>
  12. <divalign="center">
  13. <fontcolor="red"size="12px;"style="font-weight: bold;">
  14. ${info}
  15. </font>
  16. <br><br><br><br>
  17. <ahref="index.jsp">返回</a>
  18. </div>
  19. </body>
  20. </html>
<%@ page language="java" contentType="text/html" pageEncoding="GBK"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>结果信息</title>
    <!--
	<link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
  
  <body>
    <div align="center">
    	<font color="red" size="12px;" style="font-weight: bold;">
    		${info}
    	</font>
    	<br><br><br><br>
    	<a href="index.jsp">返回</a>
    </div>
  </body>
</html>


13.数据表tb_medicine_batch结构：

 

14.程序运行结果截图：

分享到：
| 任务列表
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate下数据批量处理解决方案

    在Java开发中，尤其是涉及到大数据量的处理时，人们往往会质疑ORM框架，如Hibernate，是否适合进行批量数据操作。然而，实际上，通过适当的技术手段，我们可以有效地解决Hibernate在批量处理时可能出现的性能问题。...

    Hibernate中大量数据的更新

    在这些场景中，如果使用传统的 INSERT 语句逐条插入数据，会导致性能下降和内存溢出问题。因此，使用批量更新机制可以大大提高性能和降低内存占用。 Hibernate 的批量更新机制 Hibernate 提供了两种批量更新机制：...

    Hibernate批量处理数据

    ### Hibernate批量处理数据 #### 一、概述 Hibernate作为一款流行的Java持久层框架，它能够以面向对象的方式处理数据库操作，极大地简化了开发过程。然而，在处理大量数据时，如果仍然采用逐条处理的方式，将会...

    hibernate批量删除

    ### Hibernate批量删除详解 #### 背景与概念 在Java开发中，处理大量数据时，经常需要执行批量操作，如批量更新或批量删除。这些操作对于提高应用程序性能至关重要，尤其是在涉及成千上万条记录的情况下。...

    2022年Hibernate下数据批量处理Java教程.docx

    在批量插入数据时，我们可以使用以下代码： ``` Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); for (int i=0; i; i++) { Customer customer = new Customer(...)...

    Java中Hibernate的批量插入

    然而，在处理大量数据的批量操作时，如批量插入、更新或删除，如果不采取适当的策略，可能会导致性能问题甚至出现内存溢出异常。针对这种情况，Hibernate提供了一些批量处理的解决方案。 批量插入是处理大量数据...

    struts2与hibernate的整合实现数据的crud

    1. **添加依赖**：在项目的构建文件（如Maven的pom.xml或Gradle的build.gradle）中，添加Struts2和Hibernate的库依赖。 2. **配置Struts2**：在struts.xml配置文件中，定义Action类及其对应的Result，以指定处理...

    Hibernate插入数据

    本篇将详细探讨“Hibernate插入数据”的相关知识点，结合学习心得，深入理解并掌握其核心原理与实践技巧。 首先，Hibernate通过对象关系映射（ORM）技术，将数据库表与Java类关联起来，使得数据库操作可以通过对象...

    浅析Hibernate下数据批量处理方法.doc

    标题"浅析Hibernate下数据批量处理方法"和描述中提到，早期的Hibernate在批量插入时可能存在效率问题，但最新版本已经进行了优化，例如通过设置`batch_size`参数来提高批量处理的性能。`batch_size`设置的是JDBC...

    Hibernate批量处理

    ### Hibernate批量处理详解 #### 一、批量处理概述 Hibernate作为一种强大的对象关系映射（ORM）框架，提供了多种批量处理的方式以提高数据处理效率。批量处理对于需要在短时间内处理大量数据的应用尤其重要，如...

    Java Hibernate3 添加和删除数据

    在实际应用中，为了提高性能和防止脏读，通常会使用批处理操作，比如批量添加或删除。此外，还可以利用Criteria或HQL（Hibernate Query Language）进行更复杂的查询操作。 总的来说，Java Hibernate3简化了数据库...

    Hibernate批量处理海量数据的方法

    以下是针对Hibernate批量处理海量数据的一些关键知识点和优化策略： 1. **理解Hibernate的工作原理**：Hibernate通过查询数据库获取数据，并将其转化为Java对象存储在内存中，这种做法在处理小量数据时非常便捷，但...

    Hibernate方法的实现

    本篇将深入探讨Hibernate方法的实现，包括其基本概念、配置、实体类、会话工厂以及各种操作数据库的方法。 1. **Hibernate基础** Hibernate是基于Java的持久层框架，通过XML配置文件或注解来定义对象与数据库表...

    往数据库插入数据，相同的不插入

    ### 往数据库插入数据，相同的不插入 ...综上所述，通过上述分析我们可以清晰地理解如何实现在插入数据时避免重复的功能。同时，也探讨了一些可能的改进方案，以期在实际项目中更好地应用这些技术。

    HQL批量插入、更新和删除

    在批量插入数据时，需要注意内存管理问题。如果一次性插入大量数据，可能会导致`OutOfMemoryError`异常。为了避免这种情况的发生，在进行批量插入操作时，可以采用以下策略： 1. **分批提交**：将大批量的数据分割...

    完整XML读取数据，省市区三级插入数据库的Hibernate的实现。

    6. **插入数据**：在`Session`实例上开启事务，通过`save()`或`saveOrUpdate()`方法逐个保存省市区实体。注意，由于层级关系，需要先保存省份，再保存城市（关联父省），最后保存区县（关联父市）。 7. **提交事务*...

    struts2+hibernate实现的网站

    这可能涉及使用Apache POI库解析Excel文件，读取数据，并通过Hibernate批量插入到数据库中。开发者需要处理Excel格式的不同版本，以及数据验证和异常处理。 视频播放功能意味着网站包含了多媒体内容的处理。这通常...

    struts2+hibernate(文件批量上传至数据库+Ajax分页显示)

    总之，这个项目展示了如何将Struts2和Hibernate结合使用，以实现文件批量上传到数据库以及Ajax分页显示的功能。通过学习这个项目，开发者可以深入理解Java Web开发中的MVC模式、ORM框架以及前端动态加载技术。

    hibernate(一对多，多对一映射)操作

    - 增加：在保存父实体时，可以同时保存其关联的子实体，Hibernate会自动处理子实体的插入操作。对于多对一关系，只需要在父实体中设置子实体的引用即可。 - 查询：可以通过HQL（Hibernate Query Language）或者 ...

Magicbox
Global site tag (gtag.js) - Google Analytics