hibernate--关联映射（多对一，一对一）

public class Group {
    private int id;    
    private String name;
    GET...SET
}

<hibernate-mapping>
    <class name="h.one.bean.Group" table="t_group">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

<hibernate-mapping>
    <class name="h.one.bean.User" table="t_user">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <!--<many-to-one> 关联映射 多对一的关系
            name:是维护的属性(User.group),这样表示在多的一端表里加入一个字段名称为group,
            但group与SQL中的关键字重复，所以需要重新命名字段(column="groupid").
        这样这个字段(groupid)会作为外键参照数据库中group表(t_group也叫一的一端)，也就是就在多的一
            端加入一个外键指向一的一端。
         -->
        <many-to-one name="group" column="groupid"/>
    </class>
</hibernate-mapping>

            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
    
            Group group = new Group();
            group.setName("wjt276");
            session.save(group); //存储Group对象。
            
            User user1 = new User();
            user1.setName("菜10");
            user1.setGroup(group);//设置用户所属的组
            
            User user2 = new User();
            user2.setName("容祖儿");
            user2.setGroup(group);//设置用户所属的组
            
            //开始存储
            session.save(user1);//存储用户
            session.save(user2);
                        
            tx.commit();//提交事务

            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            User user = (User)session.load(User.class, 3);
            System.out.println("user.name=" + user.getName());
            System.out.println("user.group.name=" + user.getGroup().getName());
            //提交事务
             tx.commit();

public class IdCard {
    private int id;    
    private String cardNo;
}

public class Person {
    private int id;    
    private String name;    
    private IdCard idCard;//持有IdCard对象的引用
}

<hibernate-mapping>
    <class name="h.one.bean.IdCard" table="t_idcard">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
    </class>
</hibernate-mapping>

<hibernate-mapping package="h.one.bean">
    <class name="Person" table="t_person">
        <id name="id" column="id">
            <!-- 因为主键不是自己生成的，而是作为一个外键(来源于其它值)，所以使用foreign生成策略 foreign:使用另外一个相关联的对象的标识符，通常和<one-to-one>联合起来使用。 
                再使用元素<param>的属性值指定相关联对象(这里Person相关联的对象为idCard,则标识符为idCard的id)为了能够在加载person数据同时加载IdCard数据，所以需要使用一个标签<one-to-one>来设置这个功能。 -->
            <generator class="foreign">
                <!-- 元素<param>属性name的值是固定为property -->
                <param name="property">idCard</param>
            </generator>
        </id>
        <property name="name" />
        <!-- <one-to-one>标签 表示如何加载它的引用对象(这里引用对象就指idCard这里的name值是idCard)，同时也说是一对一的关系。 
            默认方式是根据主键加载(把person中的主键取出再到IdCard中来取相关IdCard数据。) 我们也说过此主键也作为一个外键引用 了IdCard，所以需要加一个数据库限制(外键约束)constrained="true" -->
        <one-to-one name="idCard" constrained="true" />
    </class>
</hibernate-mapping>

    @Test
    public void testOneToOneSave() {
        session = HibernateUtil.getSession();
        tx = session.beginTransaction();

        IdCard idCard = new IdCard();
        idCard.setCardNo("88888888888888888888888");
        
        Person person = new Person();
        person.setName("菜10");
        person.setIdCard(idCard);
        
        //不会出现TransientObjectException异常
        //因为一对一主键关键映射中，默认了cascade属性。
        session.save(person);
        tx.commit();
    }

    @Test
    public void testLoad() {
        session = HibernateUtil.getSession();
        tx = session.beginTransaction();
        User user = (User) session.load(User.class,
                "4028718146f232890146f2328b660001");
        System.out.println("user.name=" + user.getName());
        System.out.println("user.group.name=" + user.getGroup().getName());
        // 提交事务
        tx.commit();
    }

public class IdCard {
    private int id;    
    private String cardNo;    
    private Person person; //持有Person对象的引用
}

public class Person {
    private int id;    
    private String name;    
    private IdCard idCard;//持有IdCard对象的引用
}

<hibernate-mapping>
    <class name="h.one.bean.IdCard" table="t_idcard">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="cardNo"/>
    <!—
one-to-one标签的含义：指示hibernate怎么加载它的关联对象(这里的关联对象为person)，默认根据主键加载
-->
        <one-to-one name="person"/>
    </class>
</hibernate-mapping>

       // 提交事务
        // 利用Hibernate将实体类对象保存到数据库中
        // 因为user主键生成策略采用的是uuid，所以调用完成save后，只是将user纳入session的管理
        // 不会发出insert语句，但是id已经生成，session中的existsInDatabase状态为false
        session.save(user);

        // 调用flush,hibernate会清理缓存，执行sql
        // 如果数据库的隔离级别设置为未提交读，那么我们可以看到flush过的数据，并且session中的exitsInDatabase为true
        session.flush();

        // 提交事务
        // 默认情况下commit操作会先执行flush清理缓存，所以不用显示调用flush
        // commit后数据是无法回滚的。
        tx.commit();

       // 利用Hibernate将实体类对象保存到数据库中
        // 因为user的主键生成策略为native(自动添加)，所以调用session.save()后，将执行insert语句，返回由数据库生成的id
       // 纳入了session的管理，修改了session中existsInDatabase状态为true。
        // 如果数据库的隔离级别设置为未提交读，那么我们可以看到save过的数据
        session.save(user);

        // 提交事务
        tx.commit();

        session = HibernateUtil.getSession();
        tx = session.beginTransaction();

        User1 user = new User1();
        user.setName("李四");
        user.setPassword("123");
        user.setCreateTime(new Date());
        user.setExpireTime(new Date());

        // 利用Hibernate将实体类对象保存到数据库中
        // 因为user主键生成策略采用的是uuid，所以调用完成save后，只是将user纳入session的管理
        // 不会发出insert语句，但是id已经生成，session中的existsInDatabase状态为false
        session.save(user);

        session.evict(user);// 从session缓存(EntityEntries属性)中逐出该对象
        // 无法成功提交，因为hibernate在清理缓存时，在session的临时集合(insertions)中取出user对象进行insert操作后需要更新entityEntries属性中的existsInDatabase为true,而我们采用evict已经将user从session中逐出了，所以找不到相关数据,无法更新，抛出异常。

        tx.commit();

       // 利用Hibernate将实体类对象保存到数据库中
        // 因为user主键生成策略采用的是uuid，所以调用完成save后，只是将user纳入session的管理
        // 不会发出insert语句，但是id已经生成，session中的existsInDatabase状态为false
        session.save(user);

        // flush后hibernate会清理缓存，会将user对象保存到数据库中，将session中的insertions中的user对象清除，并且会设置session中的existsInDatabase状态为false
        session.flush();

        session.evict(user);// 从session缓存(EntityEntries属性)中逐出该对象

        // 可以成功提交，因为hibernate在清理缓存时，在Session的insertions中集合中无法找到user对象所以不会发出insert语句，也不会更新session中existsInDatabase的状态。
        tx.commit();