hibernate（三）

今天我们将来学习hibernate的注解。

之前的hibernate的学习，都是基于xml的配置，hibernate的注解，为了简化繁琐的orm映射文件（*.hbm）配置。

JPA与Hibernate

JPA：Java Persistence API java持久化api

JPA注解是JAVAEE的规范和标准

JPA和bibernate关系：JPA是接口，hibernate是实现，简单的说hibernate的功能更强大。

Hibernate是通过hibernate-annotation、hibernate-entitymanager和hibernate-core三个组件来实现。

在实际开发，优先使用JPA，便于移植。

hibernate类级别注解

@Entity

@Entity :映射实体类
@Entity（name=”tableName”）
name:可选，对应数据库中的一个表，如果表名与实体类名相同，则可以省略。

注意：使用@Entitiy时必须指定实体类的主键属性。

package com.example.hibernateannotation.entity;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
//这里使用是标准的JPA注解
public class Student {
   private int sid;
   private String name;
   private String sex;
   private String address;
   private Date birhtday;
   private String major;
@Id  加在属性上也可以
public int getSid() {
    return sid;
}
public void setSid(int sid) {
    this.sid = sid;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
public String getAddress() {
    return address;
}
public void setAddress(String address) {
    this.address = address;
}
public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}
public Student(int sid, String name, String sex, String address, Date birhtday,
        String major) {
    super();
    this.sid = sid;
    this.name = name;
    this.sex = sex;
    this.address = address;
    this.birhtday = birhtday;
    this.major = major;
} 
}

@Table

@Table(name=”“,catalog=”“,schema=”“)

@Table与@Entity配合使用，只能标注在实体class定义处，表示实体对应数据库表的信息。这样就不需要手动编写hbm.xml文件，在配置文件中只要添加如下信息：

<mapping class="com.example.hibernateannotation.entity.Student"></mapping>
<mapping class="com.example.hibernateannotation.entity.Address"></mapping>

• name：可选，映射表的名称，默认表名和实体名称一致，只有在不一致的情况下才需要指定表名。
• catalog：可选，表示catalog名称
• schema：可选，表示schema名称
  

@Embeddable

package com.example.hibernateannotation.entity;

import javax.persistence.Embeddable;

@Embeddable
//表示嵌入一个类，这个类的对象在另一个实体类中充当属性。
public class Address {
   private int postnumber;
   private String detailaddress;
public int getPostnumber() {
    return postnumber;
}
public void setPostnumber(int postnumber) {
    this.postnumber = postnumber;
}
public String getDetailaddress() {
    return detailaddress;
}
public Address() {
    super();
    // TODO Auto-generated constructor stub
}
public void setDetailaddress(String detailaddress) {
    this.detailaddress = detailaddress;
}
public Address(int postnumber, String detailaddress) {
    super();
    this.postnumber = postnumber;
    this.detailaddress = detailaddress;
}

}

hibernate属性级别注解

属性注解添加方式

1. 写在属性字段上面
2. 写在属性的get访问器的上面

@Id

@Id：必须，主键的表的定义了映射到数据库，一个实体类可以有一个或者多个属性被映射为主键。

如果有多个属性定义为主键属性，该实体类必须要实现serializable接口。这里需要注意就是如果联合主键有个字段是字符串类型，因为默认长度是255，必须规定该字段不能长度多长。

//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
   private int sid;
    @Id
    @Column(length=8)
   private String name;

@GeneratedValue

在第1点中，主键生成策略，由程序自动控制。

在第2点中主键生成策略，需要根据字段的唯一性来。identity由底层数据库生成标识符。identity是由数据库自己生成的，但这个主键必须设置为自增长，使用identity的前提条件是底层数据库支持自动增长字段类型，上述4种策略取值是基于JPA。

#

下面介绍字符串注解是手动赋值的

@GeneratedValue(generator="sid")//引用主键生成器
@GenericGenerator(name="sid",strategy="assigned")//指定主键生成器的名字，指定主键生成策略
private String sid;

出现这个错，很明显它要求这种主键生成策略，手动赋值，必须在save之前。

这种方法不同于上面的四种，他不是标准的JPA注解。

@Column

@Column 可将属性映射到列，使用该注解来覆盖默认值，@Column描述数据库表中该字段的详细定义，这对于根据JPA注解生成数据库表结构的工具非常有用。

@Embedded （属性级别注解）

这个注解是用来注解属性，表示该属性的类是嵌入类，但是需要注意的是@Embeddable注解，否则会有异常报错。

@EmbeddedId

@EmbeddedId使用嵌入式主键类实现符合主键

注意:嵌入式主键类必须实现Serializable接口、必须要有默认的public无参数构造方法、必须覆盖Object下的equals和hashCode方法。 实现代码如下:

package com.example.hibernateannotation.entity;

import java.io.Serializable;

import javax.persistence.Embeddable;
@Embeddable
public class StudentPk implements Serializable {
    private String id;
    private int identitynumber;
    public StudentPk(String id, int identitynumber) {
        super();
        this.id = id;
        this.identitynumber = identitynumber;
    }
    public StudentPk() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getIdentitynumber() {
        return identitynumber;
    }
    public void setIdentitynumber(int identitynumber) {
        this.identitynumber = identitynumber;
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return super.hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return super.equals(obj);
    }


}

@EmbeddedId
private StudentPk pk;

Address adress =new Address(1111, "太平洋");
StudentPk pk = new StudentPk("sdsada", 888888888);
Student s = new Student(pk,"刘星","男", new Date(), "修电脑", adress);

需要注意的地方，就是这种复合主键没有定义主键生成策略，而是通过主键类构造函数提供值，也就是手动赋值。

@Transient

可选，表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性，如果一个属性并非数据库表的字段映射，就务必将其表示为@Transient，否则ORM框架默认其注解为@Basic

关联外键注解

一对一单向外键关联

• 先构建从表，同样要注解为实体类，映射到数据库表

package com.example.hibernateannotation.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="IcCard",schema="hibernatetest")
public class IcCard {
    @Id
    @GeneratedValue(generator="pid")
    @GenericGenerator(name="pid",strategy="assigned")//字符串主键是手动生成，字符串主键长度不能默认长度，因为默认是255，不能过长，所以需要指定。
    @Column(length=18)
    private String pid;
    private String name;
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public IcCard(String pid, String name) {
        super();
        this.pid = pid;
        this.name = name;
    }
    public IcCard() {
        super();
        // TODO Auto-generated constructor stub
    }


}

• 构建主表

package com.example.hibernateannotation.entity;

import java.io.Serializable;
import java.util.Date;

import javax.naming.Name;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student",schema="hibernatetest")
//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)//主键自增
    private int sid;
    @OneToOne(cascade=CascadeType.ALL)//级联关系
    @JoinColumn(name="pid",unique=true)//表示外键关联的字段名称
   private IcCard card;//在主表中定义从表的对象
   private String sex;
   private Date birhtday;
   private String major;
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}



public IcCard getCard() {
    return card;
}
public void setCard(IcCard card) {
    this.card = card;
}

public Student(IcCard card, String sex, Date birhtday, String major) {
    super();
    this.card = card;
    this.sex = sex;
    this.birhtday = birhtday;
    this.major = major;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}




}

 IcCard card = new IcCard("1000011", "laoqang");
          Student s = new Student(card,"男", new Date(), "修电脑");
          session.save(card);
          session.save(s);//两个对象需要分别保存，一定要先保存从表，在保存主表对象

一对一双向外键关系

双向关联，必须设置mappedBy属性。因为双向关联只能交给一方去控制，不可能在双方都设置外键保存关联关系，否则双方都无法保存。

• 在上述的代码，在从表中添加如下代码

package com.example.hibernateannotation.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="IcCard",schema="hibernatetest")
public class IcCard {
    @Id
    @GeneratedValue(generator="pid")
    @GenericGenerator(name="pid",strategy="assigned")
    @Column(length=18)
    private String pid;
    private String name;
    @OneToOne(mappedBy="card")//将外键控制权交给主控方，因为在主控方定义被控方的属性设置，所以在这只要指定从表在主表中的属性即可。
    private Student stu;//定义主表的对象
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public IcCard(String pid, String name) {
        super();
        this.pid = pid;
        this.name = name;
    }
    public IcCard() {
        super();
        // TODO Auto-generated constructor stub
    }


}

多对一的单向外键关联

• 构建从表

package com.example.hibernateannotation.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="Classroom")
public class Classrom {
    @Id
    @GeneratedValue(generator="cid")
    @GenericGenerator(name="cid",strategy="assigned")
    private String cid;
    private String cname;
    public String getCid() {
        return cid;
    }
    public void setCid(String cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public Classrom(String cid, String cname) {
        super();
        this.cid = cid;
        this.cname = cname;
    }


}

• 构建主表

package com.example.hibernateannotation.entity;

import java.io.Serializable;
import java.util.Date;

import javax.naming.Name;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
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.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student",schema="hibernatetest")
//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int sid;
    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="pid",unique=true)
   private IcCard card;
   private String sex;
   @ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
   @JoinColumn(name="cid",referencedColumnName="CID")//指定外键的列，后面指定到数据库映射的字段，默认就是前面name中的字段，也可以自己指定
   private Classrom classroom;//定义从表属性对象，并且提供set、get、构造函数
   private Date birhtday;
   private String major;
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}



public IcCard getCard() {
    return card;
}
public void setCard(IcCard card) {
    this.card = card;
}

public Student(IcCard card, String sex, Date birhtday, String major) {
    super();
    this.card = card;
    this.sex = sex;
    this.birhtday = birhtday;
    this.major = major;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}
public Classrom getClassroom() {
    return classroom;
}
public void setClassroom(Classrom classroom) {
    this.classroom = classroom;
}
public Student(IcCard card, String sex, Classrom classroom, Date birhtday,
        String major) {
    super();
    this.card = card;
    this.sex = sex;
    this.classroom = classroom;
    this.birhtday = birhtday;
    this.major = major;
}
}

• 测试

 IcCard card = new IcCard("1000011", "laoqang");
          Classrom c = new Classrom("网络1", "laisd");
          Student s = new Student(card, "男", c, new Date(), "修电脑");
          session.save(c);
          session.save(card);
          session.save(s);

需要注意的还是要先保存从表，在保存主表。

一对多单向外键关联

• 一方的代码如下

package com.example.hibernateannotation.entity;

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

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

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="Classroom")
public class Classrom {
    @Id
    @GeneratedValue(generator="cid")
    @GenericGenerator(name="cid",strategy="assigned")
    private String cid;
    private String cname;
    @OneToMany(cascade={CascadeType.ALL},fetch=FetchType.LAZY)//fetch是抓取策略，在这里说明一下，在多对一时，多方用eager，一方用lazy。
    @JoinColumn(name="cid")//外键字段
    private Set<Student> stu = new HashSet<Student>();//在一方提供多方的集合
    public String getCid() {
        return cid;
    }
    public void setCid(String cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public Classrom(String cid, String cname) {
        super();
        this.cid = cid;
        this.cname = cname;
    }
    public Set<Student> getStu() {
        return stu;
    }
    public void setStu(Set<Student> stu) {
        this.stu = stu;
    }
}

• 测试添加如下

  Student s = new Student("男",new Date() , "软件");
          Student s1 = new Student("男",new Date() , "软件");
          Student s2 = new Student("男",new Date() , "网络");
          Student s3 = new Student("男",new Date() , "网络");
          Set<Student> students = new HashSet<Student>();
          students.add(s);
          students.add(s1);
          Classrom c = new Classrom("10001","软件工程");
          c.setStu(students);
          Set<Student> students1 = new HashSet<Student>();
          students1.add(s2);
          students1.add(s3);
          Classrom c1 = new Classrom("10002","网络技术");
          c1.setStu(students1);
          session.save(c);
          session.save(c1);

一对多双向外键关联

一方代码如下

package com.example.hibernateannotation.entity;

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

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

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="Classroom")
public class Classrom {
    @Id
    @GeneratedValue(generator="cid")
    @GenericGenerator(name="cid",strategy="assigned")
    private String cid;
    private String cname;
    @OneToMany(cascade={CascadeType.ALL},fetch=FetchType.LAZY)
    @JoinColumn(name="cid")
    private Set<Student> stu = new HashSet<Student>();
    public String getCid() {
        return cid;
    }
    public void setCid(String cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    public Classrom(String cid, String cname) {
        super();
        this.cid = cid;
        this.cname = cname;
    }
    public Set<Student> getStu() {
        return stu;
    }
    public void setStu(Set<Student> stu) {
        this.stu = stu;
    }
}

• 多方代码如下

package com.example.hibernateannotation.entity;

import java.io.Serializable;
import java.util.Date;

import javax.naming.Name;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
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.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student",schema="hibernatetest")
//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int sid;
   private String sex;
   @ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
   @JoinColumn(name="cid")
   private Classrom classroom;
   private Date birhtday;
   private String major;
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}




public Student() {
    super();
    // TODO Auto-generated constructor stub
}
public Classrom getClassroom() {
    return classroom;
}
public void setClassroom(Classrom classroom) {
    this.classroom = classroom;
}

public Student(String sex, Classrom classroom, Date birhtday, String major) {
    super();
    this.sex = sex;
    this.classroom = classroom;
    this.birhtday = birhtday;
    this.major = major;
}
public Student(String sex, Date birhtday, String major) {
    super();
    this.sex = sex;
    this.birhtday = birhtday;
    this.major = major;
}

}

测试用例如上面一个测试即可。

多对多单向外键关联

• 从表实体类

package com.example.hibernateannotation.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table
public class Teacher {
    @Id
    @GeneratedValue(generator="tid")
    @GenericGenerator(name="tid",strategy="assigned")
     private String tid;
     private String tname;
    public String getTid() {
        return tid;
    }
    public void setTid(String tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    public Teacher(String tid, String tname) {
        super();
        this.tid = tid;
        this.tname = tname;
    }   
}

• 主表实体类

package com.example.hibernateannotation.entity;

import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import javax.naming.Name;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
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.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student",schema="hibernatetest")
//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int sid;
   private String sex;
   private Date birhtday;
   private String major;
   @ManyToMany
   @JoinTable(name="teacher_student",joinColumns={@JoinColumn(name="sid")}
   ,inverseJoinColumns={@JoinColumn(name="tid")})
   // 通过生成一个中间表来维护两个表之间的关系，joinColumns是主操作表的中间表列，而inverseJoinColumns是副操作表的中间表列。
   private Set<Teacher> teacher = new HashSet<Teacher>();


public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String sex, Date birhtday, String major) {
    super();
    this.sex = sex;
    this.birhtday = birhtday;
    this.major = major;
}
public Set<Teacher> getTeacher() {
    return teacher;
}
public void setTeacher(Set<Teacher> teacher) {
    this.teacher = teacher;
}   
}

• 测试添加代码

 Student s = new Student("男",new Date() , "软件");
          Student s1 = new Student("男",new Date() , "软件");
          Student s2 = new Student("男",new Date() , "网络");
          Student s3 = new Student("男",new Date() , "网络");
         Teacher t1  = new Teacher("1111","laoqiang");
         Teacher t2 = new Teacher("22222","laoqiang");
         Teacher t3  = new Teacher("3333","laoqiang");
         Teacher t4  = new Teacher("4444","laoqiang");
         Teacher t5  = new Teacher("5555","laoqiang");
         Teacher t6  = new Teacher("6666","laoqiang");
          Set<Teacher> tacherone = new HashSet<Teacher>();
          tacherone.add(t6);
          tacherone.add(t5);
          tacherone.add(t4);
          tacherone.add(t3);
          tacherone.add(t2);

          Set<Teacher> tachertwo = new HashSet<Teacher>();
          tacherone.add(t3);
          tacherone.add(t5);
          tacherone.add(t4);
          tacherone.add(t2);
          tacherone.add(t1);
          s.setTeacher(tacherone);
          s1.setTeacher(tachertwo);
          s2.setTeacher(tachertwo);
          s3.setTeacher(tacherone);
          session.save(t1);
         session.save(t2);
         session.save(t3);
         session.save(t4);
         session.save(t5);
         session.save(t6);
         session.save(s);
         session.save(s1);
         session.save(s2);
         session.save(s3);//一定要注意到最后学生和老师度要保存

多对多双向外键关联

• 主表实体的代码

package com.example.hibernateannotation.entity;

import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import javax.naming.Name;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
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.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Transient;

import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student",schema="hibernatetest")
//这里使用是标准的JPA注解
public class Student implements Serializable{
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int sid;
   private String sex;
   private Date birhtday;
   private String major;
   @ManyToMany
   @JoinTable(name="teacher_student",joinColumns={@JoinColumn(name="sid")}
   ,inverseJoinColumns={@JoinColumn(name="tid")})
   // 通过生成一个中间表来维护两个表之间的关系，joinColumns是主操作表的中间表列，而inverseJoinColumns是副操作表的中间表列。
   private Set<Teacher> teacher = new HashSet<Teacher>();


public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}

public Date getBirhtday() {
    return birhtday;
}
public void setBirhtday(Date birhtday) {
    this.birhtday = birhtday;
}
public String getMajor() {
    return major;
}
public void setMajor(String major) {
    this.major = major;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String sex, Date birhtday, String major) {
    super();
    this.sex = sex;
    this.birhtday = birhtday;
    this.major = major;
}
public Set<Teacher> getTeacher() {
    return teacher;
}
public void setTeacher(Set<Teacher> teacher) {
    this.teacher = teacher;
} 
}

• 从表实体代码如下

package com.example.hibernateannotation.entity;

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

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table
public class Teacher {
    @Id
    @GeneratedValue(generator="tid")
    @GenericGenerator(name="tid",strategy="assigned")
     private String tid;
     private String tname;
     @ManyToMany(mappedBy="teacher")//将主控权交给学生，这里的值是教师对象的属性名
     private Set<Student> stu = new HashSet<Student>();
    public String getTid() {
        return tid;
    }
    public void setTid(String tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    public Teacher(String tid, String tname) {
        super();
        this.tid = tid;
        this.tname = tname;
    } 
}

今天到此，hibernate注解就差不多！