一对多保存，一是入库单storage，多是物品列表goods，store中保存的是一个goods数组，storagestore中放的是所有goods的信息和storage信息提交到后台
1）、从列表中取出数据往store中添加数据
var gridWin = new Ext.grid.GridPanel( {
frame : true,
stripeRows : true,
region : "center",
store : storeGoods,
listeners:{"rowdblclick":function(grid,index,e){
var record = gridWin.store.getAt(index);
var mygoods=new TopicRecord({
'goodsname':record.get('goodsname'),
'goodsunit':record.get('goodsunit'),
'goodsstyle':record.get('goodsstyle')
});
addWin.hide();
store.insert(0, mygoods); //双击grid中的数据就可以往store中添加多条物品信息
}
},
enableColumnMove : false,
colModel : cmWin,
viewConfig : {forceFit : true},
sm : smWin,
bbar : new Ext.PagingToolbar({
pageSize : 15,
store : storeGoods,
displayInfo : true,
displayMsg : '显示第 {0} 条到 {1} 条记录，一共 {2} 条',
emptyMsg : "没有记录"
})
});
2）、将store中的goods数组和入库单的数据放入到storagestore中，然后提交
var query = new Ext.Button( {
text : ' 保 存 ',
handler : function() {
//取出form中的storage数据然后插入到storagestore中
var mystorage=new TopicRecord({
'menucode':Ext.getCmp('menucode').getValue(),
'makedate':Ext.getCmp('makedate').getValue(),
'moneysum':Ext.getCmp('moneysum').getValue(),
'storename':Ext.getCmp('storename').getValue(),
'storekeep':Ext.getCmp('storekeep').getValue(),
'supplyfactory':Ext.getCmp('supplyfactory').getValue(),
'handleperson':Ext.getCmp('handleperson').getValue(),
'storagedate':Ext.getCmp('storagedate').getValue()
});
storeUpdate.insert(0, mystorage);
//取出grid列表中的所有goods信息，放入storage数组中
var view = grid.getView();
for (var i = 0; i < view.getRows().length; ++i) {
var record = grid.store.getAt(i);
var mygoodsdetail=new TopicRecord({
'goodsname':record.get('goodsname'),
'goodsunit':record.get('goodsunit'),
'goodsstyle':record.get('goodsstyle'),
'goodsnumber':record.get('goodsnumber'),
'unitprice':record.get('unitprice'),
'amount':record.get('amount'),
'productdate':record.get('productdate'),
'brand':record.get('brand')
});
storeUpdate.insert(0, mygoodsdetail);
}
var modified = storeUpdate.modified;
updateData(modified);
}
});
提交storage数组的数据，提交的是一个数组
function updateData(modified) {
var json = [];
Ext.each(modified, function(item) {
json.push(item.data);
});
if (json.length > 0) {
Ext.Ajax.request({
url: "../../ast/consumables/saveStorage.action",//调用一对多的保存action，提交到后台
params: { goods: Ext.util.JSON.encode(json) },//将数组转变为Jason对象数组，数组名为goods
method: "POST",
success: function(response) {
Ext.Msg.alert("信息", "数据更新成功！", function() { store.reload(); });
},
failure: function(response) {
Ext.Msg.alert("警告", "数据更新失败，请稍后再试！");
}
});
}
else {
Ext.Msg.alert("警告", "没有任何需要更新的数据！");
}
}
3）后台解析传入的Jason数组，然后给对象设置相应的一对多关系再保存
private ConStorageService conStorageService;
private ConStorage conStorage;
private Set<ConGoods> conGoodsall = new HashSet<ConGoods>();
public String saveStorage(){
try {
//后台读取前台传来的goods数组
String goods = request.getParameter("goods");
JSONArray js=JSONArray.fromObject(goods);
JSONObject jo=null;
//生成一个storage的入库单对象，然后往storage对象中设置值
ConStorage conStorage = new ConStorage();
for(int i=0;i<js.size();i++){
jo=(JSONObject)js.get(i);//依次读取Jason数组中的每一条数据
if(i==0){ //因为第一条插入的是storage的数据
conStorage.setMenucode(jo.getString("menucode"));
conStorage.setMakedate(jo.getString("makedate"));
conStorage.setMoneysum(jo.getString("moneysum"));
conStorage.setStorekeep(jo.getString("storekeep"));
conStorage.setStorename(jo.getString("storename"));
conStorage.setSupplyfactory(jo.getString("supplyfactory"));
conStorage.setHandleperson(jo.getString("handleperson"));
conStorage.setStoragedate(jo.getString("storagedate"));
}else{
ConGoods conGoods = new ConGoods();//生成一个新的goods对象然后给其赋值
conGoods.setGoodsname(jo.getString("goodsname"));
conGoods.setUnit(jo.getString("goodsunit"));
conGoods.setGoodsstyle(jo.getString("goodsstyle"));
conGoods.setGoodsnumber(jo.getString("goodsnumber"));
conGoods.setUnitprice(jo.getString("unitprice"));
conGoods.setAmount(jo.getString("amount"));
conGoods.setProductdate(jo.getString("productdate"));
conGoods.setBrand(jo.getString("brand"));
conGoods.setConStorage(conStorage);//设置goods对象与主单storage的一对多关系
conGoodsall.add(conGoods);//把goods对象加入ConGoods的set数组中
}
}
conStorage.setConGoods(conGoodsall);//往主单中设置多的goods对象的set数组
conStorageService.save(conStorage);//保存主单信息，同时保存了goods信息及一对多的关系
return SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return INPUT;
}
}
4）、一对多关系的hibernate配置：一的一方storage，多的一方goods
storage.hbm.xml
<hibernate-mapping package="com.kingee.ast.consumables.pojo">
<class
name="ConStorage"
table="ast_consumables_storage"
dynamic-update="true"
>
<meta attribute="sync-DAO">true</meta>
<id
name="Id"
type="string"
column="id"
>
<generator class="uuid.hex"/>
</id>
<property
name="storagedate"
column="storagedate"
type="string"
length="100"
/>
//上面一段就跟一般的hibernate配置一样把storage的所有属性写好
<set name="conGoods" cascade="save-update" inverse="true" lazy="true">
<key column="inid" />
<one-to-many class="com.kingee.ast.consumables.pojo.ConGoods"/>
</set>
</class>
//设置一对多的关系，以为storage对象中没有inid的属性所以用<set></set>然后设置<one-to-many >的关系
goods.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="com.kingee.ast.consumables.pojo">
<class
name="ConGoods"
table="ast_consumables_goods"
dynamic-update="true"
>
<meta attribute="sync-DAO">true</meta>
<id
name="Id"
type="string"
column="id"
>
<generator class="uuid.hex"/>
//<generator class="uuid.hex"/>的作用就是自动生成ID序列使生成的id不重复
</id>
<property
name="goodsstyle"
column="goodsstyle"
type="string"
length="100"
/>
//inid是一对多关系的外键属性对应storage中的id，因为在查询goods时要用到inid属性所以重写一个insert和update都为FALSE的property
<property
name="inid"
column="inid"
type="string"
length="100"
insert="false"
update="false">
</property>
//配置一对多的关系，inid对应一中的id，因为inid是goods中的属性，所以没有<set>直接用 <many-to-one >
<many-to-one name="conStorage"
column="inid"
class="com.kingee.ast.consumables.pojo.ConStorage"
lazy="false"
cascade="save-update"
not-null="false"
></many-to-one>
</class>
</hibernate-mapping>
5）、实体类的实现代码storage.java和goods.java
storage.java
public class ConStorage extends MunalBean{
private String menucode;
private String makedate;
private String moneysum;
private String storename;
private String storekeep;
private String supplyfactory;
private String handleperson;
private String storagedate;
private Set<ConGoods> conGoods ;//设置一对多的映射关系，在一中要设置一个多的数组
}
goods.java
public class ConGoods extends MunalBean{
private String inid;
private String outid;
private String originplace;
private String remarks;
private String goodsstyle;
private String goodscompanyid;
private ConStorage conStorage;//设置一对多的关系，多中ConGoods.setConStorage();
}
迭代器的使用
String goods = request.getParameter("goods");
JSONArray js=JSONArray.fromObject(goods);
Iterator it=js.iterator();
it.hasNext//用来判断是否还有对象数据，返回Boolean
it.next()//用来取到下一个对象数据
jo=(JSONObject)it.next();
先记录一下....
public String saveStorage(){
try {
ConStorage conStorage = new ConStorage();
String goods = request.getParameter("goods");
JSONArray js=JSONArray.fromObject(goods);
JSONObject jo=null;
Iterator it=js.iterator();
while(it.hasNext()){
ConGoods conGoods = new ConGoods();
jo=(JSONObject)it.next();
String goodId=jo.getString("goodsname");
String goodIddd=jo.getString("goodsname");
System.out.println(goodIddd);
conStorage.setStorekeep(goodIddd);
System.out.println(goodId);
conGoods.setGoodsname(goodId);
conGoods.setConStorage(conStorage);
conGoodsall.add(conGoods);
}
System.out.println(conGoodsall.size());
conStorage.setConGoods(conGoodsall);
conStorageService.save(conStorage);
return SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return INPUT;
}
}
分享到：
相关推荐
本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先，一对多关系在数据库中很常见，...
本篇主要讨论的是Hibernate中的一对多关系映射，以及如何在实际操作中进行配置和使用。 一对多关系指的是一个实体可以与多个其他实体相关联。例如，在用户系统中，一个用户可以有多个订单，这就是典型的一对多关系...
以上就是关于Hibernate中实现多对一单向关联关系的基本知识，包括如何在实体类中定义关联、如何进行数据库操作以及如何查询关联对象。这个源代码示例应该提供了更具体的实现细节，你可以通过查看和运行它来深入理解...
以上就是使用Hibernate实现一对多关系映射的基本步骤。通过这种方式，我们可以在Java对象模型和数据库表之间轻松地转换，大大简化了数据操作。需要注意的是，处理一对多关系时要合理配置级联操作和缓存策略，以避免...
本篇文章将详细讲解"hibernate一对多与多对一"的关系映射概念，以及如何在实际开发中进行配置和使用。 首先，我们来看一下“一对多”关系。在现实世界中，这种关系可以对应到例如一个班级有多个学生，或者一个人...
描述中的链接指向了一篇由“fangguanhong”在iteye博客上发表的文章，虽然具体内容没有提供，但我们可以根据标题推测该文章可能详细讲解了一个具体的Hibernate一对多关系的实现步骤和示例代码。 在Java的Hibernate...
本文将详细解析"hibernate一对多映射"的概念、配置及其实现过程，以帮助理解并掌握这一核心特性。 首先，我们要明白在关系型数据库中，"一对多"关系意味着一个实体（比如一个部门）可以有多个相关实体（如部门下的...
在保存或更新实体时，Hibernate会自动处理一对多关联的插入或更新。 通过这种方式，我们就可以在Hibernate中设置一对多非主键关联，使得在操作部门和员工数据时，能够方便地维护它们之间的关系。这种方法允许我们在...
在Hibernate中，一对多关系可以通过在实体类中定义集合属性（如List、Set等）来实现，同时配合使用`@OneToMany`注解。例如，一个学生可以有多个课程，那么"学生"就是"一"端，"课程"就是"多"端。配置时，需要指定`...
“Hibernate 一对多，多对一，一对多双向关联”是指在Java持久化框架Hibernate中，实体间常见的三种关联关系。在数据库设计中，这种关联关系是常见的，例如一个用户可以有多个订单（一对多），一个订单对应一个用户...
Hibernate一对多关联配置 #### XML配置方式： 在Hibernate的映射文件中，我们通常会在一方（拥有端）的实体类映射文件中添加`<set>`或`<list>`标签来表示一对多关系。以下是一个简单的例子： ```xml <!-- "一"端...
压缩包中的"**Hibernater**"文件可能包含了实现这些操作的Java源代码和数据库脚本，读者可以参考其中的实现细节，进一步理解Hibernate的一对多和多对一映射以及如何在实际项目中运用。通过实践，开发者可以更好地...
在本主题中，我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**： 在现实世界中，一个老师可以教多个学生，或者一个班级可以包含多个学生，这就是典型的一对多...
在Java的持久化框架Hibernate中，"一对多"（One-to-Many）关系是一种常见的实体关联类型，它代表了一个实体可以与多个其他实体相关联。本篇将详细讲解如何使用Hibernate处理这种关系，并涵盖增、删、改、查（CRUD）...
在这个“Struts+Hibernate一对多的管理系统”项目中，我们将深入理解这两个框架如何协同工作，构建出一个具备一对多关系的数据管理应用。在Java Web开发中，一对多关系非常常见，比如在一个用户可以拥有多个订单的...
通过这个项目，学习者可以深入理解Hibernate双向一对多关系的配置、使用及其实现细节，从而提升数据库操作和对象持久化的技能。实践中遇到的问题和解决方法也会帮助巩固理论知识，提升实际开发能力。
本教程将详细讲解如何在Hibernate中实现"一对多"关联，并通过实际例子加深理解。 首先，让我们了解什么是"一对多"关系。在数据库设计中，"一对多"关系意味着一个实体可以与多个其他实体相关联。例如，一个学生可以...
一、Hibernate一对多关系 在现实世界中，一对多关系很常见，例如一个班级可以有多名学生。在数据库中，这对应于一个表（如班级表）有一条记录可以关联多条记录（如学生表）。在Hibernate中，我们通过配置XML文件来...
一、Hibernate一对多关系概述 在数据库设计中，一对多关系意味着一个表（父表）中的记录可以与另一个表（子表）中的多个记录相对应。例如，一个学生可以有多个课程，而一门课程可以被多个学生选修。在Hibernate中，...
- **概念解析**：一对多（One-to-Many）关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**：创建具有一个实体与多个实体关联的域模型。 - **关系模型构建**：在数据库层面构建一对多的关系模型。 - **...