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;@Embeddablepublic 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);    }}

@EmbeddedIdprivate 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@Tablepublic 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@Tablepublic 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注解就差不多！