hibernate 关联关系映射配置

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量95 收藏
点赞数
文章标签： java 数据库
Hibernate关联关系映射配置

一、 一对一单向外键关联：

1.1目录结构


1.2 Annotation方式

1.2.1 类图


1.2.2数据库表结构


1.2.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_id
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

1.3 XML方式

1.3.1 类图


1.3.2 数据库表结构


1.3.3 实体类 

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
1.3.4 对象关系映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<many-to-one name="wife" column="wife_id" unique="true" not-null="true" />
		<!--many-to-one是站在当前类XML_Husband的角度来看，XML_Husband与wife是多对一-->
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
    </class>
</hibernate-mapping>
1.4 Hibernate配置文件 

<?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="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:silence</property>
		<property name="connection.username">cnuser</property>
		<property name="connection.password">cn830306</property>
		<property name="connection.pool_size">1</property>
		<property name="current_session_context_class">thread</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
		<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
		<!--<property name="hbm2ddl.auto">update</property>-->
		<mapping class="com.rongqq.hibernate3.annotation.entity.Husband" />
		<mapping class="com.rongqq.hibernate3.annotation.entity.Wife" />
		<mapping resource="com/rongqq/hibernate3/xml/entity/XML_Husband.hbm.xml" />
		<mapping resource="com/rongqq/hibernate3/xml/entity/XML_Wife.hbm.xml" />
	</session-factory>
</hibernate-configuration>

二、一对一双向外键关联

2.1 Annotation方式

2.1.1 类图


2.1.2 数据库结构图


2.1.3 实体类

@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_id
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	private Husband husband;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne(mappedBy="wife")
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
}

2.2 XML方式

2.2.1 类图

2.2.2 数据库结构图


2.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	private XML_Husband husband;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public XML_Husband getHusband() {
		return husband;
	}
	public void setHusband(XML_Husband husband) {
		this.husband = husband;
	}
}

2.2.4 对象关系映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
			<many-to-one name="wife" unique="true" not-null="true" >
				<column name="wife_id" precision="4"></column>
		</many-to-one>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
		<!-- 这里的wife是XML_Husband类中的属性名，表示这里的关联关系已经由Husband的对象
		映射文件的wife属性上定义过了 -->
		<one-to-one name="husband" property-ref="wife" />
    </class>
</hibernate-mapping>

三、一对一单向主键关联（不重要）

3.1 Annotation方式

3.1.1 类图


3.1.2 数据库表结构


3.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
注：只生成了表，但是没有外键约束，具体实现还需要查找


3.2 XML方式

3.2.1 类图

3.2.2 数据库表结构


3.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import com.rongqq.hibernate3.annotation.entity.Husband;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
3.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<!--  指明具体参考哪一个外键，因为一张表可能存在多个外键 -->
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<one-to-one name="wife" constrained="true"></one-to-one>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
    </class>
</hibernate-mapping>

四、一对一双向主键关联（不重要）

4.1 Annotation方式

4.1.1 类图

4.1.2 数据库表结构


4.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	private Husband husband;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
}
注：同样不产生关联关系，具体实现待查


4.2 XML方式

4.2.1 类图



4.2.2 数据库表结构



4.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	private XML_Husband husband;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public XML_Husband getHusband() {
		return husband;
	}
	public void setHusband(XML_Husband husband) {
		this.husband = husband;
	}
}

4.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<one-to-one name="wife" constrained="true"></one-to-one>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
		<one-to-one name="husband" property-ref="wife"></one-to-one>
    </class>
</hibernate-mapping>

五、组件映射

5.1 Annotation方式

5.1.1 类图


5.1.2 数据库表结构


5.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@Embedded
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
public class Wife {
	private String name;
	private BigDecimal age;
	@Column(name="wifeName")
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Column(precision=3)
	public BigDecimal getAge() {
		return age;
	}
	public void setAge(BigDecimal age) {
		this.age = age;
	}
}

5.2 XML方式

5.2.1 类图


5.2.2 数据库表结构


5.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private String name;
	private BigDecimal age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public BigDecimal getAge() {
		return age;
	}
	public void setAge(BigDecimal age) {
		this.age = age;
	}
}

5.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<component name="wife">
			<property name="name" column="WIFENAME" />
			<property name="age" column="AGE" precision="3" />
		</component>
    </class>
</hibernate-mapping>


六、多对一单向关联

6.1 Annotation方式

6.1.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

6.1.2 数据库表结构


6.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	private Person person;//House(多)-Person(一)，一个人可以有多个房子，而这些房子属于这一个人
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@ManyToOne
	//@JoinColumn(name=””)//可以指定外键名称
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

6.2 XML方式

6.2.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

6.2.2 数据库表结构


6.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	private XML_Person person;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	public XML_Person getPerson() {
		return person;
	}
	public void setPerson(XML_Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

6.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"></property>
		<many-to-one name="person">
			<column name="PERSON_ID" precision="21" scale="0" />
		</many-to-one>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
    </class>
</hibernate-mapping>
注：（表）设计原则，在多的一方加外键


七、一对多单向关联

7.1 Annotation方式

7.1.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）


7.1.2 数据库表结构

7.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	private Set<House> houses = new HashSet<House>();
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany
	@JoinColumn(name="HOUSE_ID")//不加会生成由一张中间表连接的共三张表
	public Set<House> getHouses() {
		return houses;
	}
	public void setHouses(Set<House> houses) {
		this.houses = houses;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
}

7.2 XML方式

7.2.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）


7.2.2 数据库表结构


7.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	private Set<XML_House> houses = new HashSet<XML_House>();
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_House> getHouses() {
		return houses;
	}
	public void setHouses(Set<XML_House> houses) {
		this.houses = houses;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
}
7.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="houses">
			<key><!-- 指定H_HOUSE_XML表中的外键字段名，也可以<key column="PERSON_ID" /> -->
				<column name="PERSON_ID" precision="21" />
			</key>
			<one-to-many class="XML_House"/>
		</set>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"></property>
    </class>
</hibernate-mapping>

八、一对多、多对一双向关联

8.1 Annotation方式

8.1.1 类图


8.1.2 数据库表结构


8.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	private Person person;
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@ManyToOne//如果需要指定外键字段使用@JoinColumn(name="PERSON_ID")
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	private Set<House> houses = new HashSet<House>();
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany(mappedBy="person")//参考了对方的属性名
	public Set<House> getHouses() {
		return houses;
	}
	public void setHouses(Set<House> houses) {
		this.houses = houses;
	}
}

8.2 XML方式

8.2.1 类图


8.2.2 数据库表结构

8.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	private XML_Person person;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	public XML_Person getPerson() {
		return person;
	}
	public void setPerson(XML_Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	private Set<XML_House> houses = new HashSet<XML_House>();
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_House> getHouses() {
		return houses;
	}
	public void setHouses(Set<XML_House> houses) {
		this.houses = houses;
	}
}

8.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="houses">
			<key>
<!—关联表中指向当前类对应表的外键字段名，也可以<key column="PERSON_ID" /> -->
				<column name="PERSON_ID" precision="21" />
			</key>
			<one-to-many class="XML_House"/>
		</set>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"/>
		<many-to-one name="person" column="PERSON_ID"/>
		<!-- 字段名与对应的XML_Person.hbm.xml中配置的set的key中column的值必须一致 -->
    </class>
</hibernate-mapping>

九、多对多单向关联

9.1 Annotation方式

9.1.1 类图


9.1.2 数据库表结构


9.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="T")//name是用来在HQL语句中应用的本类的名字
@Table(name="H_TEACHER_")//数据库中当前类对应的表名
@SequenceGenerator(name="Teacher_Gene", sequenceName="H_TEACHER_SEQ", allocationSize=1)
public class Teacher {
	private BigDecimal id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Teacher_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany
	@JoinTable(
			name="H_T_S",//指明中间表的名字
			joinColumns={@JoinColumn(name="TEACHER_ID", referencedColumnName="ID")},
//指明中间表参考当前类对应数据库表中的字段ID的外键名为TEACHER_ID
		inverseJoinColumns={@JoinColumn(name="STUDENT_ID",referencedColumnName="ID")}
//指明中间表参考另外一张表中的字段ID的外键名为STUDENT_ID
	)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="S")
@Table(name="H_STUDENT_")
@SequenceGenerator(name="Student_Gene", sequenceName="H_STUDENT_SEQ", allocationSize=1)
public class Student {
	private BigDecimal id;
	private String name;
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Student_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

9.2 XML方式

9.2.1 类图

9.2.2 数据库表结构


9.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Teacher {
	private BigDecimal id;
	private String name;
	private Set<XML_Student> students = new HashSet<XML_Student>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Student> getStudents() {
		return students;
	}
	public void setStudents(Set<XML_Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Student {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

9.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Teacher" table="H_TEACHER_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_TEACHER_XML_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="students" table="H_XML_T_S">
			<key column="TEACHER_ID"/>
<!--中间表中指向当前类对应表的外键字段名为TEACHER_ID -->
			<many-to-many class="XML_Student" column="SUTDNET_ID"/>
			<!-- 中间表中指向XML_Student类对应表的外键字段名为STUDENT_ID -->
		</set>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Student" table="H_STUDENT_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_STUDENT_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
    </class>
</hibernate-mapping>

十、多对多双向关联

10.1 Annotation方式

10.1.1 类图


10.1.2 数据库表结构


10.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="S")
@Table(name="H_STUDENT_")
@SequenceGenerator(name="Student_Gene", sequenceName="H_STUDENT_SEQ", allocationSize=1)
public class Student {
	private BigDecimal id;
	private String name;
	private Set<Teacher> teachers = new HashSet<Teacher>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Student_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany(mappedBy="students")
	public Set<Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<Teacher> teachers) {
		this.teachers = teachers;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="T")
@Table(name="H_TEACHER_")
@SequenceGenerator(name="Teacher_Gene", sequenceName="H_TEACHER_SEQ", allocationSize=1)
public class Teacher {
	private BigDecimal id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Teacher_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany
	@JoinTable(
			name="H_T_S",//指明中间表的名字
		joinColumns={@JoinColumn(name="TEACHER_ID", 
referencedColumnName="ID")},
//指明中间表参考当前类对应数据库表中的字段ID的外键名为TEACHER_ID
			inverseJoinColumns={@JoinColumn(name="STUDENT_ID", 
referencedColumnName="ID")}
//指明中间表参考另外一张表中的字段ID的外键名为STUDENT_ID
	)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

10.2 XML方式

10.2.1 类图

10.2.2 数据库表结构


10.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Teacher {
	private BigDecimal id;
	private String name;
	private Set<XML_Student> students = new HashSet<XML_Student>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Student> getStudents() {
		return students;
	}
	public void setStudents(Set<XML_Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Student {
	private BigDecimal id;
	private String name;
	private Set<XML_Teacher> teachers = new HashSet<XML_Teacher>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<XML_Teacher> teachers) {
		this.teachers = teachers;
	}
}

10.2.4 对象映射文件 

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Teacher" table="H_TEACHER_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_TEACHER_XML_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="students" table="H_XML_T_S">
			<key column="TEACHER_ID"/>
			<!-- 中间表中指向当前类对应表的外键字段名为TEACHER_ID -->
			<many-to-many class="XML_Student" column="STUDENT_ID"/>
			<!-- 中间表中指向XML_Student类对应表的外键字段名为STUDENT_ID -->
		</set>
    </class>
</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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Student" table="H_STUDENT_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_STUDENT_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="teachers" table="H_XML_T_S">
		<!-- 相关联的类的映射文件两侧定义的中间表名字必须一致 -->
			<key column="STUDENT_ID" />
<!-- 中间表中指向当前类对应表的外键字段名 -->
			<many-to-many class="XML_Teacher" column="TEACHER_ID" />
			<!-- 中间表中指向与当前类关联的另外一个类所对应表的外键字段名 -->
		</set>
    </class>
</hibernate-mapping>


参考链接：

http://wenku.baidu.com/link?url=mNEhY-Z75gbW63N71g8S2WI6cI96eG3DC2IuDswSVjA94Y3Tf74_ZJfQUuO_-FtTHDf6QgotdLj9vhGMa1Q0_U5U6ENJFxv-j84WE7XtRda

http://blog.csdn.net/zzjjiandan/article/details/20456495

http://jinnianshilongnian.iteye.com/blog/1522591















iteye_8785
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate关联关系映射
dream_heheda的博客
03-11 160
本文参考 谈一点我对hibernate关联关系映射的看法 Hibernate关联关系映射--级联功能 Hibernate作为持久层框架，初始实现最基本的ORM之外，最重要的就是关系关联映射。通过配置实体间的关联，如one-to-one、one-to-many等，可以实现级联保存，级联更新，级联查询，级联删除等级联操作。在建关联关系表的时候，可以通过设置@OneToOne,@@OneToMany,@@ManyToOne,@ManyToMany的cascade()属性值，来设置关系表之间的级联功能。举例
Hibernate的关联关系映射
小灰灰的博客
11-26 125
Hibernate的关联关系映射 首先应该考虑两个问题：类如何表示？数据库如何存储？ 一、树形结构关联 在pom.xml文件中引入相关依赖 <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.4.23.Final</
SSH：Hibernate框架（七种关联关系映射及配置详解）
热门推荐
流年少年
11-27 1万+
概念          基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。   分类                                关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。
Hibernate作业-实验五关联映射
lettyisme的博客
06-05 482
https://blog.csdn.net/yerenyuan_pku/article/details/70152173点击打开链接一、实验目的：  理解现实中的对象关联（1:1,1:N,M:N）在对象模型和关系模型中如何关联；  掌握关联映射配置文件的设置；  掌握关联对象的保存，查询等基本操作。 二、实验内容：1. 单向的多对一关联映射；2. 双向的一对一关联映射（基于主键或外键）；3. 单向...
hibernate映射关系
影子
10-18 295
hibernate的关联关系映射一共有7种： 1.单向多对一 2.单向一对多 3.单向一对一 4.单向多对多 5.双向多对一 6.双向一对一 7.双向多对多 一，单向多对一（many--to--one） 两个对象之间多对一的关系，比如员工（emp）和部门（dept），多个员工可以在一个部门，映射原理就是在多的一端添加一个外键指向一的一端的主键。 在多的一端的映射
Hibernate 关系映射 收集、总结整理
Cages的专栏
05-14 204
《Hibernate 关系映射》是我很早之前收集、总结整理的，在此也发上来 希望对大家有用。因为是很早之前写的，不当之处请指正。 一、概念： 关系：名词，事物之间相互作用、相互联系的状态。 关联：名词：表示对象（数据库表）之间的关系；动词：将对象（数据库表）之间通过某种方式联系起来。 映射：将一种形式转化为另一种形式，包括关系。 级联：动词，有关系的双方中操作一方，另一方也将采取一些...
Hibernate一对多的关联映射，详解（代码+图解）与应用 举个栗子，搞的清楚
2401_84409344的博客
04-18 935
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）如何准备面试？1、前期铺垫（技术沉积）程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。
Hibernate_关联关系映射配置详解
01-14
Hibernate_关联关系映射配置详解，希望能帮助广大java爱好者
Hibernate_关联关系映射配置
08-01
本教程将详细讲解Hibernate中的关联关系映射配置，帮助你理解和掌握如何在Hibernate中设置不同类型的关联。 一、一对一（One-to-One）关联 在现实世界中，两个实体之间可能存在一对一的关系，例如一个人只有一个...
hibernate关联关系映射
12-26
"hibernate关联关系映射"是Hibernate的核心概念之一，它定义了如何在Java对象和数据库表之间建立关系。以下是对这个主题的详细讲解： 一、一对一关系映射（One-to-One） 一对一关系是指一个实体对应另一个实体的...
hibernate的关系映射
05-29
Hibernate提供了一种基于XML或注解的方式来进行关系映射配置。 **二、Hibernate关系映射的类型** 1. **一对一（OneToOne）**: 表示一个实体对应另一个实体的唯一实例。这可以通过在两个类中都定义`@OneToOne`注解...
hibernate对象关系映射案例demo
03-04
在Java开发领域，对象关系映射（ORM）是一种将数据库中的数据与程序中的对象进行关联的技术，它极大地简化了数据操作。Hibernate作为一款流行的ORM框架，使得开发者无需关注底层SQL语句，就能方便地实现数据的增删改...
Hibernate多对多的关系映射，详解（代码+图解）与应用 举个栗子，搞的清楚
2401_83330354的博客
05-10 640
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Hibernate关联关系映射(双向篇)
JavaSheng的专栏
05-12 6339
Hibernate关联关系可分为单向关联和双向关联两大类。单向关联可以分为一对一、一对多、多对一和多对多4种关联方式，而多向关联可以分为一对一、一对多和多对多3种关联方式。Hibernate连接管理类HibernateUtil.Javapublic class HibernateUtil { private static SessionFactory sessionFactory; p
《精通Hibernate》学习(5)——映射一对多关联关系
OOM
01-04 1638
在域模型中，类和类之间最普通的关系就是关联关系。在UML语言中，关联是有方向的。以客户（Customer）和订单（Order）的关系为例，一个客户可以发出多个订单，而一个订单只能属于一个客户。 从Order到Customer的关联是多对一关联，这意味着每个Order对象都会引用一个Customer对象，因此在Order类中应该定义一个Customer类型的属性，来引用所关联的Customer对象
Hibernate5中利用关联关系操纵对象浅析——一对一关联关系
monkey_wei的博客
02-22 983
一对一关联关系 一对一关联关系在Hibernate5中的实现方式有两种：主键关联和外键关联。 1、主键关联 主键关联的重点：关联的两个表共享一个主键值，例如，一个单位在网上的一个系统中注册为会员，则会员有一个登陆账号，单位注册为会员的数据保存在表company中，每个会员的登陆账号保存在表login中；一个会员只有一个登陆账号，一个登陆账号只属于一个会员，两个表之间是一对一的对应关系。 两个表co...
Hibernate的关系映射以及检索
GoldWashing的博客
07-30 511
          Hibernate关联映射---数据对象三种关系 Hibernate框架基于orm设计思想,它将关系型数据库中的表与我们的java中的类进行关联映射,一个对象对应着数据库表中的一条记录,而表中的字段对应着类中的数据.数据库中表与表之间存在着三种关系,也就是系统设计中的三种实体关系，分别为1对1，一对多，多对一。 1.1一对一 原则有两种: 唯一外键对应:在任意一方添加...
Hibernate关联关系的映射
Howinfun的博客
01-08 412
1.1 Hibernate关联关系的映射: 1.1.1 实体之间的关系: 实体之间有三种关系: * 一对多: * 一个用户,生成多个订单,每一个订单只能属于一个用户. * 建表原则: * 在多的一方创建一个字段,作为外键,指向一的一方的主键. * 多对多: * 一个学生可以选择多门课程,一个课程可以被多个学生选择. * 建表原则: * 创建第三张
配置Java开发环境
最新发布
Broken_x的博客
07-10 1063
Java开发环境配置
信息系统软件设计：要懂Hibernate必须要懂的程序(2).ppt
07-07
映射配置与外键关联类似，但不需要额外的外键字段。 然后，多对一（Many-to-One）关联关系映射通常用来描述一对多的关系，如一个人可能有多个电话号码。在这种关系中，一个实体类（如Person）可以与多个其他实体类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值