hibernate annotation注解方式來處理映射關(guān)系

小花驢 2015-05-13

展開全文

在hibernate中，通常配置對象關(guān)系映射關(guān)系有兩種，一種是基于xml的方式，另一種是基于annotation的注解方式。使用annotation的方式可以更簡介，所以這里就簡單記錄下通過annotation來配置各種映射關(guān)系，在hibernate4以后已經(jīng)將annotation的jar包集成進來了，如果使用hibernate3的版本就需要引入annotation的jar包。

一、單對象操作

@Entity　　--->　　如果我們當(dāng)前這個bean要設(shè)置成實體對象，就需要加上Entity這個注解
@Table(name="t_user")　　---->　　設(shè)置數(shù)據(jù)庫的表名
public class User
{
    private int id;
    private String username;
    private String password;
    private Date born;
    private Date registerDate;

    @Column(name="register_date")　　--->　　Column中的name屬性對應(yīng)了數(shù)據(jù)庫的該字段名字，里面還有其他屬性，例如length，nullable等等
    public Date getRegisterDate()
    {
        return registerDate;
    }
    public void setRegisterDate(Date registerDate)
    {
        this.registerDate = registerDate;
    }

    @Id　　--->　　定義為數(shù)據(jù)庫的主鍵ID　　(建議不要在屬性上引入注解，因為屬性是private的，如果引入注解會破壞其封裝特性，所以建議在getter方法上加入注解)
    @GeneratedValue　　---->　　ID的生成策略為自動生成　　
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
 　　............
}

最后只需要在hibernate.cfg.xml文件里面將該實體類加進去即可：

<!-- 基于annotation的配置 -->
        <mapping class="com.xiaoluo.bean.User"/>
<!-- 基于hbm.xml配置文件 -->
        <mapping resource="com/xiaoluo/bean/User.hbm.xml"/>

這樣我們就可以寫測試類來進行我們的CRUD操作了。

二、一對多的映射(one-to-many)

這里我們定義了兩個實體類，一個是ClassRoom，一個是Student，這兩者是一對多的關(guān)聯(lián)關(guān)系。

ClassRoom類：

@Entity
@Table(name="t_classroom")
public class ClassRoom
{
    private int id;
    private String className;
    private Set<Student> students;
    
    public ClassRoom()
    {
        students = new HashSet<Student>();
    }
    
    public void addStudent(Student student)
    {
        students.add(student);
    }

    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }

    public String getClassName()
    {
        return className;
    }

    public void setClassName(String className)
    {
        this.className = className;
    }

    @OneToMany(mappedBy="room")　　--->　　OneToMany指定了一對多的關(guān)系，mappedBy="room"指定了由多的那一方來維護關(guān)聯(lián)關(guān)系，mappedBy指的是多的一方對1的這一方的依賴的屬性，(注意：如果沒有指定由誰來維護關(guān)聯(lián)關(guān)系，則系統(tǒng)會給我們創(chuàng)建一張中間表)
    @LazyCollection(LazyCollectionOption.EXTRA)　　--->　　LazyCollection屬性設(shè)置成EXTRA指定了當(dāng)如果查詢數(shù)據(jù)的個數(shù)時候，只會發(fā)出一條 count(*)的語句，提高性能
    public Set<Student> getStudents()
    {
        return students;
    }

    public void setStudents(Set<Student> students)
    {
        this.students = students;
    }
    
}

Student類：

@Entity
@Table(name="t_student")
public class Student
{
    private int id;
    private String name;
    private int age;
    private ClassRoom room;
    
    @ManyToOne(fetch=FetchType.LAZY)　　---> ManyToOne指定了多對一的關(guān)系，fetch=FetchType.LAZY屬性表示在多的那一方通過延遲加載的方式加載對象(默認(rèn)不是延遲加載)
    @JoinColumn(name="rid")　　--->　　通過 JoinColumn 的name屬性指定了外鍵的名稱 rid　(注意：如果我們不通過JoinColum來指定外鍵的名稱，系統(tǒng)會給我們聲明一個名稱)
    public ClassRoom getRoom()
    {
        return room;
    }
    public void setRoom(ClassRoom room)
    {
        this.room = room;
    }
    @Id
    @GeneratedValue
    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;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    
}

三、一對一映射(One-to-One)

一對一關(guān)系這里定義了一個Person對象以及一個IDCard對象

Person類：

@Entity
@Table(name="t_person")
public class Person
{
    private int id;
    private String name;
    private IDCard card;
    
    @OneToOne(mappedBy="person")　　--->　　指定了OneToOne的關(guān)聯(lián)關(guān)系，mappedBy同樣指定由對方來進行維護關(guān)聯(lián)關(guān)系
    public IDCard getCard()
    {
        return card;
    }
    public void setCard(IDCard card)
    {
        this.card = card;
    }
    @Id
    @GeneratedValue
    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;
    }
    
}

IDCard類：

@Entity
@Table(name="t_id_card")
public class IDCard
{
    private int id;
    private String no;
    private Person person;
    
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getNo()
    {
        return no;
    }
    public void setNo(String no)
    {
        this.no = no;
    }
    @OneToOne　　--->　　OnetoOne指定了一對一的關(guān)聯(lián)關(guān)系，一對一中隨便指定一方來維護映射關(guān)系，這里選擇IDCard來進行維護
    @JoinColumn(name="pid")　　--->　　指定外鍵的名字 pid
    public Person getPerson()
    {
        return person;
    }
    public void setPerson(Person person)
    {
        this.person = person;
    }
}

注意:在判斷到底是誰維護關(guān)聯(lián)關(guān)系時，可以通過查看外鍵，哪個實體類定義了外鍵，哪個類就負(fù)責(zé)維護關(guān)聯(lián)關(guān)系。

四、Many-to-Many映射(多對多映射關(guān)系)

多對多這里通常有兩種處理方式，一種是通過建立一張中間表，然后由任一一個多的一方來維護關(guān)聯(lián)關(guān)系，另一種就是將多對多拆分成兩個一對多的關(guān)聯(lián)關(guān)系

1.通過中間表由任一一個多的一方來維護關(guān)聯(lián)關(guān)系

Teacher類：

@Entity
@Table(name="t_teacher")
public class Teacher
{
    private int id;
    private String name;
    private Set<Course> courses;
    
    public Teacher()
    {
        courses = new HashSet<Course>();
    }
    public void addCourse(Course course)
    {
        courses.add(course);
    }
    
    @Id
    @GeneratedValue
    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;
    }
    @ManyToMany(mappedBy="teachers")　　--->　　表示由Course那一方來進行維護
    public Set<Course> getCourses()
    {
        return courses;
    }
    public void setCourses(Set<Course> courses)
    {
        this.courses = courses;
    }
    
}

Course類：

@Entity
@Table(name="t_course")
public class Course
{
    private int id;
    private String name;
    private Set<Teacher> teachers;
    
    public Course()
    {
        teachers = new HashSet<Teacher>();
    }
    public void addTeacher(Teacher teacher)
    {
        teachers.add(teacher);
    }
    @ManyToMany　　　--->　ManyToMany指定多對多的關(guān)聯(lián)關(guān)系
    @JoinTable(name="t_teacher_course", joinColumns={ @JoinColumn(name="cid")}, 
    inverseJoinColumns={ @JoinColumn(name = "tid") })　　--->　　因為多對多之間會通過一張中間表來維護兩表直接的關(guān)系，所以通過 JoinTable 這個注解來聲明，name就是指定了中間表的名字，JoinColumns是一個 @JoinColumn類型的數(shù)組，表示的是我這方在對方中的外鍵名稱，我方是Course，所以在對方外鍵的名稱就是 rid，inverseJoinColumns也是一個 @JoinColumn類型的數(shù)組，表示的是對方在我這放中的外鍵名稱，對方是Teacher，所以在我方外鍵的名稱就是 tid
    public Set<Teacher> getTeachers()
    {
        return teachers;
    }

    public void setTeachers(Set<Teacher> teachers)
    {
        this.teachers = teachers;
    }

    @Id
    @GeneratedValue
    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;
    }

}

2.將Many-to-Many拆分成兩個One-to-Many的映射(Admin、Role、AdminRole)

Admin類：

@Entity
@Table(name="t_admin")
public class Admin
{
    private int id;
    private String name;
    private Set<AdminRole> ars;
    public Admin()
    {
        ars = new HashSet<AdminRole>();
    }
    public void add(AdminRole ar)
    {
        ars.add(ar);
    }
    @Id
    @GeneratedValue
    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;
    }
    @OneToMany(mappedBy="admin")　　--->　　OneToMany關(guān)聯(lián)到了AdminRole這個類，由AdminRole這個類來維護多對一的關(guān)系，mappedBy="admin"
    @LazyCollection(LazyCollectionOption.EXTRA)　　
    public Set<AdminRole> getArs()
    {
        return ars;
    }
    public void setArs(Set<AdminRole> ars)
    {
        this.ars = ars;
    }
}

Role類：

@Entity
@Table(name="t_role")
public class Role
{
    private int id;
    private String name;
    private Set<AdminRole> ars;
    public Role()
    {
        ars = new HashSet<AdminRole>();
    }
    public void add(AdminRole ar)
    {
        ars.add(ar);
    }
    @Id
    @GeneratedValue
    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;
    }
    @OneToMany(mappedBy="role")　　--->　　OneToMany指定了由AdminRole這個類來維護多對一的關(guān)聯(lián)關(guān)系，mappedBy="role"
    @LazyCollection(LazyCollectionOption.EXTRA)
    public Set<AdminRole> getArs()
    {
        return ars;
    }
    public void setArs(Set<AdminRole> ars)
    {
        this.ars = ars;
    }
}

AdminRole類：

@Entity
@Table(name="t_admin_role")
public class AdminRole
{
    private int id;
    private String name;
    private Admin admin;
    private Role role;
    @Id
    @GeneratedValue
    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　　--->　　ManyToOne關(guān)聯(lián)到Admin
    @JoinColumn(name="aid")　　
    public Admin getAdmin()
    {
        return admin;
    }
    public void setAdmin(Admin admin)
    {
        this.admin = admin;
    }
    @ManyToOne　　--->　　
    @JoinColumn(name="rid")
    public Role getRole()
    {
        return role;
    }
    public void setRole(Role role)
    {
        this.role = role;
    }
}

小技巧:通過hibernate來進行插入操作的時候，不管是一對多、一對一還是多對多，都只需要記住一點，在哪個實體類聲明了外鍵，就由哪個類來維護關(guān)系，在保存數(shù)據(jù)時，總是先保存的是沒有維護關(guān)聯(lián)關(guān)系的那一方的數(shù)據(jù)，后保存維護了關(guān)聯(lián)關(guān)系的那一方的數(shù)據(jù)，如：

　　　　　　　Person p = new Person();
            p.setName("xiaoluo");
            session.save(p);
            
            IDCard card = new IDCard();
            card.setNo("1111111111");
            card.setPerson(p);
            session.save(card);