- 浏览: 117405 次
- 性别:
- 来自: 福建
文章分类
最新评论
-
wenbing2610:
其实用Struts实现图片上传比用Servlet实现容易多了。 ...
Struts2文件上传深入FileUploadInterceptor -
i_feng:
public class uploadImageAction ...
Struts2文件上传深入FileUploadInterceptor -
wenbing2610:
...
ognl.MethodFailedException
多对多其实是个很复杂的关系,hibernate在进行处理的时候借助中间表或者中间类。中间表是在映射文件的关联标签(比如集合标签<set>)中由table属性指定的由hibernate自动生成的表,它只有两个字段,分别由<key>和<many-to-many>标签的table属性指定,作为外键分别用来指向关联双方表的主键。中间类就是把我们的中间表抽象生成一个实体类,在映射的时候分别和两个关联类构成一对多的关系,即演变成两个一对多来处理。
以下用中间表的例子来说明单向多对多关系映射:运动员(player)与角色(role)就是典型的多对多关系。
首先创建player,role类分别对应的表格:sxt_hibernate_player,sxt_hibernate_role,和中间表sxt_hibernate_player_role(在MySQL环境中)代码如下:
create table sxt_hibernate_player(
id int(11) not null auto_increatement,
name varchar(16),
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
create table sxt_hibernate_role(
id int(11) not null auto_increatement,
name varchar(16),
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
create table sxt_hibernate_player_role(
player_id int(11),
role_id int(11)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
Player实体类:
public class Player {
private Integer id;
private String name;
private Set<Role> roles;
//...省去一系列的setter.getter方法
@Override
public String toString() {
return "Player:" + name;
}
}
Role实体类:
public class Role {
private Integer id;
private String name;
//...省去一系列的setter.getter方法
@Override
public String toString() {
return "Role:" + name;
}
}
映射文件:
Role.hbm.xml
<class name="com.sxt.hibernate.many2many.entity.Role" table="sxt_hibernate_role">
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
</class>
Player.hbm.xml
<class name="com.sxt.hibernate.many2many.entity.Player" table="sxt_hibernate_player">
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
<!--table="sxt_hibernate_user_role"含义,用来指定中间表 -->
<set name="roles" table="sxt_hibernate_player_role" cascade="save-update">
<!--<key column="user_id">含义,指定中间表中用来指向本表的外键 -->
<key column="player_id"></key>
<!-- column含义,用来指定中间表中用来指向另一端表的外键 -->
<many-to-many class="com.sxt.hibernate.many2many.entity.Role" column="role_id"></many-to-many>
</set>
</class>
测试类Test:
public class Test{
public static void main(String[] args) {
Session session = HibernateUtils.getSession();
Transaction t = session.beginTransaction();
try {
/**
* 测试插入数据
*/
Role role1=new Role();
role1.setName("后卫");
Role role2=new Role();
role2.setName("前锋");
Role role3=new Role();
role3.setName("中锋");
Player player1=new Player();
player1.setName("姚明");
Set<Role> roles1=new HashSet<Role>();
roles1.add(role3);
player1.setRoles(roles1);
Player player2=new Player();
player2.setName("詹姆斯");
Set<Role> roles2=new HashSet<Role>();
roles2.add(role1);
roles2.add(role2);
roles2.add(role3);
player2.setRoles(roles2);
//能正确保存.每保存player后,都要级联保存它的role,并且级联插入中间表记录.
session.save(player1);
session.save(player2);*/
/**
* 测试加载数据
*/
Player player=(Player)session.load(Player.class, 1);
System.out.println(player);
for(Iterator<Role> iterator=player.getRoles().iterator();iterator.hasNext();){
System.out.println(iterator.next());
}
t.commit();
} catch (HibernateException e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
}
以下用中间表的例子来说明单向多对多关系映射:运动员(player)与角色(role)就是典型的多对多关系。
首先创建player,role类分别对应的表格:sxt_hibernate_player,sxt_hibernate_role,和中间表sxt_hibernate_player_role(在MySQL环境中)代码如下:
create table sxt_hibernate_player(
id int(11) not null auto_increatement,
name varchar(16),
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
create table sxt_hibernate_role(
id int(11) not null auto_increatement,
name varchar(16),
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
create table sxt_hibernate_player_role(
player_id int(11),
role_id int(11)
)ENGINE=InnoDB DEFAULT CHARSET=gbk;
Player实体类:
public class Player {
private Integer id;
private String name;
private Set<Role> roles;
//...省去一系列的setter.getter方法
@Override
public String toString() {
return "Player:" + name;
}
}
Role实体类:
public class Role {
private Integer id;
private String name;
//...省去一系列的setter.getter方法
@Override
public String toString() {
return "Role:" + name;
}
}
映射文件:
Role.hbm.xml
<class name="com.sxt.hibernate.many2many.entity.Role" table="sxt_hibernate_role">
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
</class>
Player.hbm.xml
<class name="com.sxt.hibernate.many2many.entity.Player" table="sxt_hibernate_player">
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
<!--table="sxt_hibernate_user_role"含义,用来指定中间表 -->
<set name="roles" table="sxt_hibernate_player_role" cascade="save-update">
<!--<key column="user_id">含义,指定中间表中用来指向本表的外键 -->
<key column="player_id"></key>
<!-- column含义,用来指定中间表中用来指向另一端表的外键 -->
<many-to-many class="com.sxt.hibernate.many2many.entity.Role" column="role_id"></many-to-many>
</set>
</class>
测试类Test:
public class Test{
public static void main(String[] args) {
Session session = HibernateUtils.getSession();
Transaction t = session.beginTransaction();
try {
/**
* 测试插入数据
*/
Role role1=new Role();
role1.setName("后卫");
Role role2=new Role();
role2.setName("前锋");
Role role3=new Role();
role3.setName("中锋");
Player player1=new Player();
player1.setName("姚明");
Set<Role> roles1=new HashSet<Role>();
roles1.add(role3);
player1.setRoles(roles1);
Player player2=new Player();
player2.setName("詹姆斯");
Set<Role> roles2=new HashSet<Role>();
roles2.add(role1);
roles2.add(role2);
roles2.add(role3);
player2.setRoles(roles2);
//能正确保存.每保存player后,都要级联保存它的role,并且级联插入中间表记录.
session.save(player1);
session.save(player2);*/
/**
* 测试加载数据
*/
Player player=(Player)session.load(Player.class, 1);
System.out.println(player);
for(Iterator<Role> iterator=player.getRoles().iterator();iterator.hasNext();){
System.out.println(iterator.next());
}
t.commit();
} catch (HibernateException e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
}
发表评论
-
CSS样式表的overflow属性
2015-01-02 19:22 28一、滚动条样式overflow ... -
jrebel运用
2014-07-13 22:00 1186JRebel热部署 ... -
JPA执行原生SQL截断Char类型问题
2014-05-24 21:39 1185在JPA的API中执行原生 ... -
JPA基本数据类型映射
2014-05-24 21:06 3901/** ... -
spring定时器配置
2014-03-18 21:36 689创建测试类: ... -
The Struts dispatcher cannot be found
2013-11-03 18:48 647运行环境:struts2环境中访 ... -
JasperException
2013-09-15 20:41 1013JasperException异常: ... -
equal symbol expected
2013-09-15 20:08 1178equal symbol ... -
Hibernate主键生成器
2013-09-12 21:11 786... -
Criterion和Criteria
2013-09-08 16:00 1939Hibernate Criter ... -
getHibernateTemplate用法
2013-09-08 15:02 575HibernateTemplate提供的方法 ... -
JS中页面跳转
2013-09-08 14:01 648<html><head><t ... -
GridPanel详解
2013-03-10 10:45 10311、Ext.grid.GridPanel ... -
tomcat内存溢出
2013-03-04 20:26 721在使用Java程序从数据库中查询大量的数据或 ... -
History Object
2013-01-07 21:06 746history 对象是window 对象的另一个子 ... -
Write to programmer
2012-12-29 20:16 849很多的java初级程序员对自己没有一个明确的方 ... -
EL语言
2012-09-27 22:08 885EL的前世今生: ... -
JSTL标签的使用
2012-09-27 22:00 797JSP 标准标记库( Standard Tag Library ... -
使用IBATIS防止sql注入
2012-08-26 21:17 1591对于ibaits参数引用可以使用#和$两 ... -
IBATIS动态SQL标签用法
2012-08-26 21:04 12301、动态SQL片段通过SQL片 ...
相关推荐
在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者将数据库操作转换为面向对象的方式,从而提高开发效率。本主题聚焦于"hibernate单向多对多映射",特别是在XML配置文件中的实现。在这...
在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者将数据库操作与业务逻辑层解耦,提高开发效率。本练习主要关注的是Hibernate中的单向多对多关联映射,这是一种常见的关系数据库设计...
在Java的持久化框架Hibernate中,单向多对多映射是一种常见的关系映射方式,尤其在处理数据库中两个实体间复杂关联时显得尤为重要。在注解版的Hibernate中,我们不再需要传统的XML配置文件,而是直接在实体类上使用...
**标题详解:**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中,关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库...
在IT领域,尤其是在Java开发中,关系型数据库的映射是至关重要的,特别是在对象关系映射(ORM)框架如Hibernate的使用中。本篇将详细探讨"一对多单向和双向映射"这一主题,结合标签中的"源码"和"工具",我们将深入...
本教程主要探讨的是Hibernate中的一种重要关系映射类型:一对多单向关联。在关系型数据库中,一对多关联是最常见的关系类型,一个实体可以与多个其他实体相关联。在Hibernate中,这种关系可以通过配置XML映射文件或...
在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...
本教程主要聚焦于Hibernate中的一个关键概念——关系映射,特别是多对一单向关联的实现。这种关联类型常出现在数据库设计中,比如一个部门可以有多名员工,但一个员工只属于一个部门。 首先,我们要理解多对一关系...
在本教程中,我们将深入探讨Hibernate中的一个关键概念——关系映射,特别是多对多单向关联。在数据库设计中,多对多关系是两个实体之间最复杂的关系类型,允许一个实体实例与多个其他实体实例相关联,反之亦然。在...
Hibernate通过注解使得对象关系映射(ORM)更加简洁明了,避免了传统的XML配置文件。 首先,让我们理解一下“单向一对多”关联的基本概念。在数据库设计中,如果一个实体(比如部门)可以与多个其他实体(比如员工...
本项目“Hibernate学习:单向多对一关联 工程”专注于讲解Hibernate中的单向多对一关联映射,这是数据库设计中常见的关系类型,尤其在处理具有层次结构的数据时。 单向多对一关联指的是在一个实体类中有一个引用,...
在Java Persistence API (JPA) 中,实体映射关系是数据库关系模型与Java对象模型之间的桥梁,用于在ORM(对象关系映射)框架下管理数据。JPA 提供了多种映射关系,使得开发者能够方便地处理不同类型的关联。下面我们...
Hibernate是一个开源的对象关系映射(ORM)框架,它允许开发者用Java对象来操作数据库,通过将Java类与数据库表进行映射,简化了数据库操作。ORM的主要优势在于它可以减少数据库访问的复杂性,提高开发效率。 **二...
**标题详解:** "Hibernate教程06_关系映射之一对一单向主键关联" 在Hibernate框架中,关系映射是将数据库中的表关系映射到对象模型上的过程。本教程聚焦于一对一(One-to-One)单向主键关联,这是一种特定类型的...
3. **多对多关系映射** - 单向:通常会创建一个关联中间表,通过`@ManyToMany`注解和`@JoinTable`指定关联信息。 - 双向:双方实体都可以访问对方的集合,通过`@ManyToMany`注解并设置`mappedBy`来区分维护端。 ...