hibernate多对一单向关联的两种映射方法

多对一关系实现两种方法：
1，在多的一段添加1的主键作为外键。
2，多的一段不添加任何外键，重新建一个表来实现多对一的关联。

下面是实例：
1，Person类：

package com.supan.bean;
public class Person {
	//因为由人访问其地址，所有人必须有一个地址的引用
	private Integer id;
	private String name;
	private int age;
	private Address address;
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
}  

2，Address类：

package com.supan.bean;
public class Address {
	//程序无须从address访问Person属性，所以Address无须增加Person属性
	private Integer addressId;
	private String  addressDetail;
	public Address() {
	}
	public Address(String addressDetail){
		this.addressDetail = addressDetail;
	}
	public Integer getAddressId() {
		return addressId;
	}
	public void setAddressId(Integer addressId) {
		this.addressId = addressId;
	}
	public String getAddressDetail() {
		return addressDetail;
	}
	public void setAddressDetail(String addressDetail) {
		this.addressDetail = addressDetail;
	}
}

3，Person映射文件

    <class name="Person" dynamic-update="true" table="myperson" dynamic-insert="true">
        <id  name="id"
             column="id" 
             type="integer">
            <generator class="native"/>
        </id>
        <property 
                name="name" 
                type="string" 
                column="name" 
                access="property"
                length="40"/>
        <property 
                name="age" 
                type="integer" 
                column="age" 
                access="property"/>
        <!-- 
                                 第一种方法：实现外键的方法来映射
             cascase可以让person在保存自己前自动保存address持久对象，如果没有
                                   这个属性，在保存person会手动的保存address
        <many-to-one name="address"
                     class="Address"
                     column="address_id">
        </many-to-one>
        -->
        
        <!--
	                     第二种方法：使用重建关联表的方法来实现 
	                     多对一的另一种实现方式：使用连接表，即不再多的一段添加一的外键，而是
	                     重新创建一个新表，这个表中存放连个字段一个是多的一段的主键，一个是1的
	                     一段的主键。
         -->
        <join table="person_address">
            <!-- 映射链接表中参照本表主键的外键列 -->
            <key column="person_id"></key>
            <many-to-one name="address" cascade="all" class="Address" column="address_id">
            </many-to-one>
        </join>
    </class>

4，address的映射文件：
    <class name="Address" dynamic-update="true" dynamic-insert="true">
        <id  name="addressId"
             column="address_id" 
             type="integer">
            <generator class="native"/>
        </id>
        <property 
                name="addressDetail" 
                type="string" 
                column="addressDetail" 
                access="property"
                length="240"/>
    </class>

5，测试程序（不管使用哪种方式，程序的访问方式不会改变）

    //Person 和 Address 是多对一的单向关联
    public void testPersonSave(){
    	Configuration cfg = new Configuration().configure();
    	SessionFactory sessionFactory = cfg.buildSessionFactory();
    	Session session = sessionFactory.openSession();
    	Transaction ts = session.beginTransaction();
    	System.out.println("111111111111111");
    	Person p = new Person();
    	p.setName("陈超阳");
    	p.setAge(26);
    	Address a = new Address("河南省汝州市");
        p.setAddress(a);
        session.persist(a);//如果配置文件中没有指定cascade为all的话，这里需要先保存address才能保存person；
        session.save(p);   //在Person映射文件中设置了cascade为all，表示保存person前会自动保存address的
        Address a2 = new Address("广东省深圳市");
        session.persist(a2);
        p.setAddress(a2);
        ts.commit();
        session.close();
        sessionFactory.close();
    }