Hibernate关系间映射实例

testrelation.java

package hp.epm.hibernate.model;

import static org.junit.Assert.*;

import java.util.Date;

import javax.persistence.FetchType;

import one2many_doubledirection.Group;
import one2many_doubledirection.User;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestRelation {
    private static Configuration configuration=null;
    private static ServiceRegistry serviceRegistry=null;
    private static SessionFactory sf=null;

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        configuration=new Configuration().configure();
        serviceRegistry=new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
        sf=configuration.buildSessionFactory(serviceRegistry);
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        sf.close();
    }

    @Test
    public void testCreateTable() {
        //可以使用此种方式完成创建表的操作
        //注：该方法与hibernate.cfg.xml中<property name="hbm2ddl.auto">create</property>的作用一样，
        //   都可以创建表，使用时请选择一种方法即可。
        new SchemaExport(configuration).create(true, true);
    }

    @Test
    public void testSaveUser(){
        Group g=new Group();
        g.setName("groupName");

        User u=new User();
        u.setName("userName");

        u.setGroup(g);

        Session session=sf.openSession();
        session.beginTransaction();
        session.save(u);
        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void testSaveGroup(){
        User u1=new User();
        u1.setName("userName1");

        User u2=new User();
        u2.setName("userName2");

        Group g=new Group();
        g.setName("groupName");

        g.getUsers().add(u1);
        g.getUsers().add(u2);

        u1.setGroup(g);
        u2.setGroup(g);

        Session session=sf.openSession();
        session.beginTransaction();
        session.save(g);
        session.getTransaction().commit();
        session.close();
    }


    @Test
    public void testGetUser(){
        Session session=sf.openSession();
        session.beginTransaction();
        //获取User类型的对象，并根据fetch的取值判定是否同时取出group的数据，因为User是多的一端，默认是Eager，会去自动获取。
        User u=(User)session.get(User.class, 2);
        session.getTransaction().commit();
        session.close();
    }
    //请先将User类定义中的“,fetch=FetchType.LAZY”的注释去掉，完成本测试再修改回来
    @Test
    public void testGetUser2(){
        Session session=sf.openSession();
        session.beginTransaction();
        //获取User类型的对象，并根据fetch的取值判定是否同时取出group的数据，因为User是多的一端，默认是Eager，如果修改为Lazy此时不取。
        User u=(User)session.get(User.class, 2);
        //在session的生命周期中，当调用getGroup时，会去数据库读取group的信息
        System.out.println(u.getGroup().getName());
        session.getTransaction().commit();
        session.close();
    }

    //请先将User类定义中的“,fetch=FetchType.LAZY”的注释去掉，完成本测试再修改回来
    @Test
    public void testGetUser3(){
        Session session=sf.openSession();
        session.beginTransaction();
        //获取User类型的对象，并根据fetch的取值判定是否同时取出group的数据，因为是Lazy所以此时不取。
        User u=(User)session.get(User.class, 2);
        session.getTransaction().commit();
        session.close();
        //session被关闭后才调用getGroup，无法正常执行，因为缺少session的支持
        System.out.println(u.getGroup().getName());
    }

    //请注意Group中fetch属性的取值，以及User中fetch属性的取值
    //1.Group中取Eager，User中取Lazy（都不是默认取值，不建议这样设定）
    //2.Group（1的一端）中fetch属性取Lazy（默认值），User（多的一端）中fetch属性取Eager（默认值）
    @Test
    public void testLoadUser(){
        Session session=sf.openSession();
        session.beginTransaction();
        User u=(User)session.load(User.class, 2);
        System.out.println(u.getGroup().getName());
        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void testGetGroup(){
        Session session=sf.openSession();
        session.beginTransaction();
        //Group是1的一端，查询操作对应的Fetch为Lazy，如果在session生命周期中没有对g的引用，后面再使用g容易出现懒加载异常
        Group g=(Group)session.get(Group.class,2);
        session.getTransaction().commit();
        session.close();
        for(User u:g.getUsers()){
            System.out.println("userName:"+u.getName());
        }
    }

    //请先将Group类定义中的“,fetch=FetchType.EAGER”的注释去掉，完成本测试再修改回来
    @Test
    public void testGetGroup2(){
        Session session=sf.openSession();
        session.beginTransaction();
        //获取Group类型的对象，并根据fetch的取值判定是否同时取出user的数据，因为Group是一的一端，默认是Lazy，如果修改为Eager会去自动获取。
        Group g=(Group)session.get(Group.class, 2);
        session.getTransaction().commit();
        session.close();
        for(User u:g.getUsers()){
            System.out.println("userName:"+u.getName());
        }
    }

    @Test
    public void testUpdateUser(){
        Session session=sf.openSession();
        session.beginTransaction();
        //根据load方法的的特性延迟加载获取User类型的对象，即在session的生命周期中，用到的时候再去加载。
        User u=(User)session.load(User.class, 2);
        //修改User中的数据
        u.setName("NewUserName");
        //修改Group中的数据
        u.getGroup().setName("NewGroupName");
        //提交会发出2个update语句，分别修改User表和Update表
        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void testUpdateUser2(){
        Session session=sf.openSession();
        session.beginTransaction();
        User u=(User)session.get(User.class, 2);
        session.getTransaction().commit();
        session.close();
        //托管状态下可以修改对象的属性
        u.setName("newUserName");
        u.getGroup().setName("newGroupName");

        Session session2=sf.openSession();
        session2.beginTransaction();
        //将托管状态变为持久化状态，准备更新语句待提交事务时执行
        session2.update(u);
        session2.getTransaction().commit();
        session2.close();
    }

    @Test
    public void testDeleteUser(){
        Session session=sf.openSession();
        session.beginTransaction();
        User u=(User)session.load(User.class, 4);
        //是否删除与User关联的Group信息，若设为null则仅删除User，不去删除Group
        u.setGroup(null);
        session.delete(u);
        session.getTransaction().commit();
        session.close();
    }

    //不论Group类定义中的“,fetch=FetchType.EAGER”的注释是否去掉都会
    //将group和对应的user记录级联删除
    @Test
    public void testDeleteGroup1(){
        testSaveGroup();

        Session session=sf.openSession();
        session.beginTransaction();
        Group g=(Group)session.load(Group.class,5);
        session.delete(g);
        session.getTransaction().commit();
        session.close();
    }
    //将Group类中定义中的“,fetch=FetchType.EAGER”的注释去掉，
    //可以做到只删除group并将user表中对应的外键值设为null，但user的基本信息未级联删除
    //完成本测试后请再将注释信息修改回来
    @Test
    public void testDeleteGroup2(){
        testSaveGroup();

        Session session=sf.openSession();
        session.beginTransaction();
        Group g=(Group)session.get(Group.class,8);
        for(User u:g.getUsers()){
            u.setGroup(null);
            session.update(u);
        }
        session.getTransaction().commit();

        session.beginTransaction();
        g.setUsers(null);
        session.delete(g);
        session.getTransaction().commit();
        session.close();
    }


}

user.java

package one2many_doubledirection;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="test_user")
public class User {
    private int id;
    private String name;
    private Group group;
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @ManyToOne(cascade=CascadeType.ALL
            /*,fetch=FetchType.LAZY*/
            )
    @JoinColumn(name="groupKeyInfo")
    public Group getGroup() {
        return group;
    }
    public void setGroup(Group group) {
        this.group = group;
    }

}

group.java

package one2many_doubledirection;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="test_group")
public class Group {
    private int id;
    private String name;
    private Set<User> users=new HashSet<User>();

    @OneToMany(mappedBy="group",cascade=CascadeType.ALL
            ,fetch=FetchType.EAGER
            )
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }
    @Id
    @Column(name="group_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="group_name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}