1.建表
create table student
(sid varchar ( 32 ) not null primary key ,
sname varchar ( 16 ),
sage varchar ( 16 ),
)
create table course
(cid varchar ( 32 ) not null primary key ,
cname varchar ( 16 )
)
create table student_course_link
(sid varchar ( 32 ) not null ,
cid varchar ( 32 ) not null ,
primary key (sid,cid)
)
2.写VO
StudentVO
package com.test;
import java.util.Set;
public class Student
{
private String sid;
private String sname;
private String sage;
private Set course;
public Student()
{
}
//写上get setCourse vo
package com.test;
import java.util.Set;
public class Course
{
private String cid;
private String cname;
private Set student;
//写上get set
写配置文件
Student.hbm.xml
<!---->
<!---->
Course.hbm.xml
<!---->
<!---->
接着把下面的hibernate.properties文件拷到classes目录下。。这里用的是mysql
hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N'
## MySQL
hibernate.dialect net.sf.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class org.gjt.mm.mysql.Driver
hibernate.connection.url jdbc:mysql://localhost:3306/wjcms
hibernate.connection.username root
hibernate.connection.password wujun
hibernate.connection.pool_size 1
hibernate.proxool.pool_alias pool1
hibernate.show_sql true
hibernate.jdbc.batch_size 0
hibernate.max_fetch_depth 1
hibernate.cache.use_query_cache true 写测试类了..
package com.test;
xml 代码
- <?xml version="1.0"?>
- <!DOCTYPE hibernate-mapping
- PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
- "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
-
- <hibernate-mapping>
-
- <class name="com.test.Student" table="student" >
-
- <id name="sid" type="string" unsaved-value="null" >
- <column name="sid" sql-type="char(32)" not-null="true"/>
- <generator class="uuid.hex"/>
- </id>
-
- <property name="sname">
- <column name="sname" sql-type="varchar(16)" not-null="true"/>
- </property>
-
- <property name="sage">
- <column name="sage" sql-type="varchar(16)" not-null="true"/>
- </property>
-
- <set name="course" table="student_course_link" cascade="all" outer-join="false">
- <key column="sid"/>
- <many-to-many class="com.test.Course" column="cid"/>
- </set>
-
- </class>
-
- </hibernate-mapping>
<id name="sid" type="string" unsaved-value="null"></id>
xml 代码
- <?xml version="1.0"?>
- <!DOCTYPE hibernate-mapping
- PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
- "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
-
- <hibernate-mapping>
-
- <class name="com.test.Course" table="course" >
-
- <id name="cid" type="string" unsaved-value="null" >
- <column name="cid" sql-type="char(32)" not-null="true"/>
- <generator class="uuid.hex"/>
- </id>
-
- <property name="cname">
- <column name="cname" sql-type="varchar(16)" not-null="true"/>
- </property>
-
- <set name="student" table="student_course_link" lazy="false" cascade="all">
- <key column="cid"/>
- <many-to-many class="com.test.Student" column="sid"/>
- </set>
-
- </class>
-
- </hibernate-mapping>
<id name="cid" type="string" unsaved-value="null"></id>
<column name="cid" sql-type="char(32)" not-null="true"></column>
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.*;
import java.util.Set;
import java.util.HashSet;
import java.sql.*;
import java.util.List;
import java.util.Iterator;
public class TestManyToMany
{
SessionFactory sf;
Session session;
public TestManyToMany()
{
try
{
Configuration cfg = new Configuration();
sf = cfg.addClass(Student.class).addClass(Course.class).buildSessionFactory();
}
catch(HibernateException ex)
{
ex.printStackTrace();
}
}
public void doCreate()
{
try
{
session = sf.openSession();
Student student = new Student();
student.setSname("小王");
student.setSage("22");
Set courseSet = new HashSet();
Course course = null;
for(int i=0;i<2;i++)
{
course = new Course();
if(i==0)
course.setCname("c++");
else if(i==1)
course.setCname("java");
courseSet.add(course);
}
student.setCourse(courseSet);
session.save(student);
session.flush();
session.connection().commit();
}
catch(HibernateException ex)
{
ex.printStackTrace();
}
catch(SQLException ex1)
{
ex1.printStackTrace();
}
finally
{
try{
session.close();
}
catch(HibernateException ex2){
}
}
}
public void doQuery()
{
try{
session = sf.openSession();
Query q = session.createQuery("select s from Student as s");
List l = q.list();
Student s = null;
Course course = null;
for(int i=0;i {
s = (Student)l.get(i);
System.out.println("姓名: "+s.getSname());
System.out.println("年龄: "+s.getSage());
System.out.println("所选的课程:");
Iterator it = s.getCourse().iterator();
while(it.hasNext())
{
course = (Course)it.next();
System.out.println("课程名: "+course.getCname());
}
}
}
catch(HibernateException ex){
ex.printStackTrace();
}
finally{
try{
session.close();
}
catch(HibernateException ex2){
}
}
}
public static void main(String[] args)
{
TestManyToMany t = new TestManyToMany();
//t.doCreate();
t.doQuery();
}
}
好。。可以了。。
分享到:
相关推荐
以下是一个简单的例子,展示了一个班级(Class)与学生(Student)的one-to-many关系,以及学生对班级的many-to-one关系: ```java @Entity public class Class { @Id private Long id; @OneToMany(mappedBy =...
"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...
### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...
通过研究这个例子,你可以更深入地理解如何在实际开发中设置和使用Many-to-One关系。 总的来说,Hibernate的Many-to-One映射简化了数据库关系的处理,使得开发者可以专注于业务逻辑,而不是繁琐的SQL操作。通过这个...
本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...
在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...
在本文中,我们将深入探讨如何使用Hibernate来实现多对多(many-to-many)的映射关系。 首先,多对多映射关系通常涉及到两个实体类之间的关联,例如在学生选课的例子中,学生(Student)和课程(Course)之间存在多...
本文将深入探讨Hibernate中一对多(One-to-Many)关系的处理方式,特别是通过外键映射和inverse属性的应用场景。 #### 一对多关系概念 一对多关系在数据库设计中非常常见,它指的是一个实体可以与多个其他实体关联...
在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...
在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据模型,它表示一个实体可以与多个其他实体之间存在关联,反之亦然。这篇博客文章可能会深入探讨如何在Hibernate中处理这种多对多的关系,并可能涉及...
在Hibernate中,我们可以使用`<many-to-many>`标签来配置多对多映射。下面是一个简单的例子: ```xml <many-to-many column="USER_ID" foreign-key="FK_USER_ROLE" entity-name="com.example.Role" table="USER...
标题"Hibernate one to many(many to one) 配置"涉及到的是关系型数据库在Java中的持久化框架Hibernate中的两种关联映射关系:一对一(One-to-One)和多对一(Many-to-One)。在数据库设计中,这种关系很常见,例如...
<many-to-one name="address" column="addressId" unique="true"/> </hibernate-mapping> ``` --- ##### 2. 一对一主键单向关联 在一对一主键单向关联中,两个实体共享同一个主键。这种方式通常用于当两个实体...
在Java持久化框架Hibernate中,Many-to-Many(多对多)映射是一种常见的关联关系类型,用于表示两个实体类之间复杂的关系。在本场景中,我们探讨的是如何在Hibernate中配置Many-to-Many映射,并使用MySQL数据库来...
在这个“Hibernate学生-课程-成绩表的例子(many2many)”中,我们将探讨如何利用Hibernate处理多对多关联关系,以及相关源码和工具的使用。 多对多关联是数据库设计中常见的关系类型,它表示两个实体之间可以有多个...
- 双向`many-to-one`关联的例子,比如麻将桌上的玩家位置与玩家之间的关系。 #### 三、`one-to-one`关联管理 `one-to-one`关联主要用于表示两个实体之间的一对一关系。 - **定义**:`one-to-one`关联表示两个实体...
- **Mapping one-to-one and one-to-many associations:** - 映射一对一和一对多关联的方法。 - **自然ID(natural-id):** - 自然标识符的概念及其实现。 以上内容概述了从《hibernate doc 中文版》文档中提取...