Hibernate注解版关联关系映射全解析+案例

HIbernate注解说明

 1、@Entity(name="EntityName")
 必须,name为可选,对应数据库中一的个表，此处的EntryName要注意，在代码中使用hql进行查询时，需要from Xxx，那么Xxx就是对应的此处的EntryName，所以要注意EntryName的命名，否则会出现映射问题。



 2、@Table(name="",catalog="",schema="")
 可选,通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息

 name：可选,表示表的名称。默认地,表名和实体名称一致，只有在不一致的情况下才需要指定表名
 catalog：可选，表示Catalog名称。默认为Catalog("")
 schema：可选，表示Schema名称。默认为Schema("")


 3、@id
 必须

 @id定义了映射到数据库表的主键的属性，一个实体只能有一个属性被映射为主键。置于getXxxx()前



 4、@GeneratedValue(strategy=GenerationType,generator="")
 可选

 strategy：表示主键生成策略，有AUTO、INDENTITY、SEQUENCE和 TABLE 4种，分别表示让ORM框架自动选择、根据数据库的Identity字段生成、根据数据库表的Sequence字段生成、以及根据一个额外的表生成主键。默认为AUTO

 generator：表示主键生成器的名称，这个属性通常和ORM框架相关。例如，Hibernate可以指定uuid等主键生成方式

 示例:

     @Id

     @GeneratedValues(strategy=StrategyType.SEQUENCE)

     public int getPk() {

        return pk;

     }



 5、@Basic(fetch=FetchType,optional=true)
 可选

 @Basic表示一个简单的属性到数据库表的字段的映射，对于没有任何标注的getXxxx()方法。默认即为@Basic

 fetch：表示该属性的读取策略，有EAGER和LAZY两种，分别表示主支抓取和延迟加载。默认为EAGER
 optional：表示该属性是否允许为null，默认为true
 示例:

     @Basic(optional=false)

     public String getAddress() {

        return address;

     }



 6、@Column
 可选

 @Column描述了数据库表中该字段的详细定义，这对于根据JPA注解生成数据库表结构的工具非常有作用
 name：表示数据库表中该字段的名称。默认情形属性名称一致
 nullable：表示该字段是否允许为null。默认为true
 unique：表示该字段是否是唯一标识。默认为false
 length：表示该字段的大小，仅对String类型的字段有效
 insertable：表示在ORM框架执行插入操作时，该字段是否应出现INSETRT语句中。默认为true
 updateable：表示在ORM框架执行更新操作时，该字段是否应该出现在UPDATE语句中，默认为true。对于一经创建就不可以更改的字段，该属性非常有用，如对于birthday字段
 columnDefinition：表示该字段在数据库中的实际类型。通常ORM框架可以根据属性类型自动判断数据库中字段的类型，但是对于Date类型仍无法确定数据库中字段类型究竟是DATE、TIME还是TIMESTAMP。此外，String的默认映射类型为VARCHAR，如果要将String类型映射到特定数据库的BLOB或TEXT字段类型，该属性非常有用
  示例:

    @Column(name="BIRTH",nullable="false",columnDefinition="DATE")

     public String getBithday() {

        return birthday;

     }



 7、@Transient
 可选

 @Transient表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性

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

 示例:

     //根据birth计算出age属性

     @Transient

     public int getAge() {

        return getYear(new Date()) -getYear(birth);

     }



 8、@ManyToOne(fetch=FetchType,cascade=CascadeType)
 可选

 @ManyToOne表示一个多对一的映射，该注解标注的属性通常是数据库表的外键

  optional：是否允许该字段为null，该属性应该根据数据库表的外键约束来确定，默认为true
 fetch：表示抓取策略，默认为FetchType.EAGER
 cascade：表示默认的级联操作策略，可以指定为ALL、PERSIST、MERGE、REFRESH和REMOVE中的若干组合，默认为无级联操作
 targetEntity：表示该属性关联的实体类型，该属性通常不必指定，ORM框架根据属性类型自动判断targetEntity


 示例:

     //订单Order和用户User是一个ManyToOne的关系

     //在Order类中定义

     @ManyToOne()

     @JoinColumn(name="USER")

     public User getUser() {

        return user;

     }



 9、@JoinColumn
 可选

 @JoinColumn和@Column类似，介量描述的不是一个简单字段，而是一个关联字段，例如，描述一个@ManyToOne的字段.



 name：该字段的名称，由于@JoinColumn描述的是一个关联字段，如ManyToOne，则默认的名称由其关联的实体决定.


 例如，实体Order有一个user属性来关联实体User，则Order的user属性为一个外键

 其默认的名称为实体User的名称+下划线+实体User的主键名称

 示例:

     见@ManyToOne



 10、@OneToMany(fetch=FetchType,cascade=CascadeType)
 可选

 @OneToMany描述一个一对多的关联，该属性应该为集体类型，在数据库中并没有实际字段



 fetch：表示抓取策略，默认为FetchType.LAZY，因为关联的多个对象通常不必从数据库预先读取到内存
 cascade：表示级联操作策略，对于OneToMany类型的关联非常重要，通常该实体更新或删除时，其关联的实体也应当被更新或删除


 例如：实体User和Order是OneToMany的关系，则实体User被删除时，其关联的实体Order也应该被全部删除

 示例:

     @OneTyMany(cascade=ALL)

     public List getOrders() {

        return orders;

     }



 11、@OneToOne(fetch=FetchType,cascade=CascadeType)
 可选

 @OneToOne描述一个一对一的关联

 fetch：表示抓取策略,默认为FetchType.LAZY

 cascade：表示级联操作策略

 示例:

     @OneToOne(fetch=FetchType.LAZY)

     public Blog getBlog() {

        return blog;

     }



 12、@ManyToMany
 可选

 @ManyToMany描述一个多对多的关联，多对多关联上是两个一对多关联，但是在ManyToMany描述中，中间表是由ORM框架自动处理

 targetEntity：表示多对多关联的另一个实体类的全名，例如:package.Book.class

 mappedBy：表示多对多关联的另一个实体类的对应集合属性名称



 13、@MappedSuperclass
 可选

 @MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解

 示例:

     @MappedSuperclass

     public class Employee() {

        ....

     }



     @Entity

     public class Engineer extends Employee {

        .....

     }

     @Entity

     public class Manager extends Employee {

        .....

     }



 14、@Embedded
 可选

 @Embedded将几个字段组合成一个类，并作为整个Entity的一个属性

 例如User包括id、name、city、street、zip属性

 我们希望city、street、zip属性映射为Address对象。这样，User对象将具有id、name和address这三个属性.


 Address对象必须定义为@Embededable

 示例:

     @Embeddable

     public class Address {city,street,zip}

     @Entity

     public class User {

        @Embedded

        public Address getAddress() {

           ..........

        }

     }

1、Hibernate注解关系处理关系映射

 在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用hibernate3的版本就需要引入annotation的jar包。

 一、单对象操作


 @Entity　　--->　　如果我们当前这个bean要设置成实体对象，就需要加上Entity这个注解
 @Table(name="t_user")　　---->　　设置数据库的表名
 public class User
 {
     private int id;
     private String username;
     private String password;
     private Date born;
     private Date registerDate;

     @Column(name="register_date")　　--->　　Column中的name属性对应了数据库的该字段名字，里面还有其他属性，例如length，nullable等等
     public Date getRegisterDate()
     {
         return registerDate;
     }
     public void setRegisterDate(Date registerDate)
     {
         this.registerDate = registerDate;
     }

     @Id　　--->　　定义为数据库的主键ID　　(建议不要在属性上引入注解，因为属性是private的，如果引入注解会破坏其封装特性，所以建议在getter方法上加入注解)
     @GeneratedValue　　---->　　ID的生成策略为自动生成
     public int getId()
     {
         return id;
     }
     public void setId(int id)
     {
         this.id = id;
     }
  　　............
 }

 最后只需要在hibernate.cfg.xml文件里面将该实体类加进去即可：


         class="com.xiaoluo.bean.User"/>

         "com/xiaoluo/bean/User.hbm.xml"/>
 这样我们就可以写测试类来进行我们的CRUD操作了。

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

 这里我们定义了两个实体类，一个是ClassRoom，一个是Student，这两者是一对多的关联关系。

 ClassRoom类：


 @Entity
 @Table(name="t_classroom")
 public class ClassRoom
 {
     private int id;
     private String className;
     private Set students;

     public ClassRoom()
     {
         students = new HashSet();
     }

     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指定了一对多的关系，mappedBy="room"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，(注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)
     @LazyCollection(LazyCollectionOption.EXTRA)　　--->　　LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 count(*)的语句，提高性能
     public Set getStudents()
     {
         return students;
     }

     public void setStudents(Set 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指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
     @JoinColumn(name="rid")　　--->　　通过 JoinColumn 的name属性指定了外键的名称 rid　(注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)
     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)

 一对一关系这里定义了一个Person对象以及一个IDCard对象

 Person类：


 @Entity
 @Table(name="t_person")
 public class Person
 {
     private int id;
     private String name;
     private IDCard card;

     @OneToOne(mappedBy="person")　　--->　　指定了OneToOne的关联关系，mappedBy同样指定由对方来进行维护关联关系
     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指定了一对一的关联关系，一对一中随便指定一方来维护映射关系，这里选择IDCard来进行维护
     @JoinColumn(name="pid")　　--->　　指定外键的名字 pid
     public Person getPerson()
     {
         return person;
     }
     public void setPerson(Person person)
     {
         this.person = person;
     }
 }

 注意:在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。

 四、Many-to-Many映射(多对多映射关系)

 多对多这里通常有两种处理方式，一种是通过建立一张中间表，然后由任一一个多的一方来维护关联关系，另一种就是将多对多拆分成两个一对多的关联关系

 1.通过中间表由任一一个多的一方来维护关联关系

 Teacher类：


 @Entity
 @Table(name="t_teacher")
 public class Teacher
 {
     private int id;
     private String name;
     private Set courses;

     public Teacher()
     {
         courses = new HashSet();
     }
     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 getCourses()
     {
         return courses;
     }
     public void setCourses(Set courses)
     {
         this.courses = courses;
     }

 }

 Course类：


 @Entity
 @Table(name="t_course")
 public class Course
 {
     private int id;
     private String name;
     private Set teachers;

     public Course()
     {
         teachers = new HashSet();
     }
     public void addTeacher(Teacher teacher)
     {
         teachers.add(teacher);
     }
     @ManyToMany　　　--->　ManyToMany指定多对多的关联关系
     @JoinTable(name="t_teacher_course", joinColumns={ @JoinColumn(name="cid")},
     inverseJoinColumns={ @JoinColumn(name = "tid") })　　--->　　因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过 JoinTable 这个注解来声明，name就是指定了中间表的名字，JoinColumns是一个 @JoinColumn类型的数组，表示的是我这方在对方中的外键名称，我方是Course，所以在对方外键的名称就是 rid，inverseJoinColumns也是一个 @JoinColumn类型的数组，表示的是对方在我这放中的外键名称，对方是Teacher，所以在我方外键的名称就是 tid
     public Set getTeachers()
     {
         return teachers;
     }

     public void setTeachers(Set 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 ars;
     public Admin()
     {
         ars = new HashSet();
     }
     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关联到了AdminRole这个类，由AdminRole这个类来维护多对一的关系，mappedBy="admin"
     @LazyCollection(LazyCollectionOption.EXTRA)
     public Set getArs()
     {
         return ars;
     }
     public void setArs(Set ars)
     {
         this.ars = ars;
     }
 }

 Role类：


 @Entity
 @Table(name="t_role")
 public class Role
 {
     private int id;
     private String name;
     private Set ars;
     public Role()
     {
         ars = new HashSet();
     }
     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这个类来维护多对一的关联关系，mappedBy="role"
     @LazyCollection(LazyCollectionOption.EXTRA)
     public Set getArs()
     {
         return ars;
     }
     public void setArs(Set 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关联到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来进行插入操作的时候，不管是一对多、一对一还是多对多，都只需要记住一点，在哪个实体类声明了外键，就由哪个类来维护关系，在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据，如：


 　　　　　　　Person p = new Person();
             p.setName("xiaoluo");
             session.save(p);

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

2、Hibernate基于注解的双向one-to-many映射关系的实现

项目中用到了一对多的实体类关系映射，之前接触的都是基于配置文件的映射实现，但是公司的大部分都是基于注解的，因此自己参考之前的代码捣鼓了基于注解的一对多的映射关系实现。

背景：

一的一端：QingAoCenterInfo：青奥场所信息，

多的一端：QingAoPlaceInfo：青奥场馆信息，

其中一个青奥场所下可以包含多个青奥场馆

one端：QingAoCenterInfo，持有QingAoPlaceInfo的List引用，

通过注解@OneToMany(mappedBy="qingAoCenterInfo",cascade= CascadeType.ALL)

mappedBy：定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义， 否则可能引起数据一致性的问题。要由One的一方指向Many的一方，并且，这个属性应该等于Many的一方中含有One类的属性的属性名，否则会出错啦

cascade：CascadeType[]类型。该属性定义类和类之间的级联关系。

定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。

举个例子：Order 和OrderItem有级联关系，那么删除QingAoCenterInfo时将同时删除它所对应的QingAoPlaceInfo对象。而如果QingAoPlaceInfo还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。

cascade的值只能从CascadeType.PERSIST（级联新建）、CascadeType.REMOVE（级联删除）、CascadeType.REFRESH（级联刷新）、CascadeType.MERGE（级联更新）中选择一个或多个。还有一个选择是使用CascadeType.ALL，表示选择全部四项。 

 package com.yuqiaotech.nttelcom.model;

 import java.util.Date;
 import java.util.List;

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

 /**
  * 青奥重点场所信息表。
  *
  */
 @Entity(name="QING_AO_CENTER_INFO")
 @Table(name="QING_AO_CENTER_INFO")
 public class QingAoCenterInfo {
     private Long id;
     private String centerName;  //重点场所名称
     private Long alarmNum;      //告警数
     private String note;        //备注
     private String iconName;    //图标名称
     private String cityName;    //所在城市
     private String type;        //重点场所、活动保障
     private Date createTime;
     private List qingAoPlaceInfo; //场所拥有的场馆
     @Id
     @GeneratedValue(strategy=GenerationType.AUTO)
     public Long getId() {
         return id;
     }
     public void setId(Long id) {
         this.id = id;
     }
     /**
      * @searchItem
      * displayType="text"
      *
      * 重点场所名称
      * @return
      */
     public String getCenterName() {
         return centerName;
     }
     public void setCenterName(String centerName) {
         this.centerName = centerName;
     }
     /**
      * 告警数
      * @return
      */
     public Long getAlarmNum() {
         return alarmNum;
     }
     public void setAlarmNum(Long alarmNum) {
         this.alarmNum = alarmNum;
     }
     /**
      * 备注
      * @return
      */
     public String getNote() {
         return note;
     }
     public void setNote(String note) {
         this.note = note;
     }
     /**
      * 图标名称
      * @return
      */
     public String getIconName() {
         return iconName;
     }
     public void setIconName(String iconName) {
         this.iconName = iconName;
     }

     public String getCityName() {
         return cityName;
     }

     public void setCityName(String cityName) {
         this.cityName = cityName;
     }
     public String getType() {
         return type;
     }
     public void setType(String type) {
         this.type = type;
     }
     public Date getCreateTime() {
         return createTime;
     }
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
     @OneToMany(mappedBy="qingAoCenterInfo",cascade= CascadeType.ALL)
     public List getQingAoPlaceInfo() {
         return qingAoPlaceInfo;
     }
     public void setQingAoPlaceInfo(List qingAoPlaceInfo) {
         this.qingAoPlaceInfo = qingAoPlaceInfo;
     }
 }

many端：QingAoPlaceInfo，持有QingAoCenterInfo的引用

通过@ManyToOne(fetch=FetchType.LAZY )    @JoinColumn(name="f_center_id")设置关联关系

 @ManyToOne指明QingAoPlaceInfo和QingAoCenterInfo之间为多对一关系，多个QingAoPlaceInfo实例关联的都是同一个QingAoCenterInfo对象

    fetch和lazy是用来定义级联查询的方式：

    fetch:官方文档里对fetch有如下描述，Hibernate3 定义了如下几种抓取策略：

• 连接抓取（Join fetching）：Hibernate 通过在 SELECT 语句使用 OUTER JOIN（外连接）来获得对象的关联实例或者关联集合。

• 查询抓取（Select fetching）：另外发送一条 SELECT 语句抓取当前对象的关联实体或集合。除非你显式的指定 lazy="false" 禁止 延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 select 语句。

• 子查询抓取（Subselect fetching）：另外发送一条 SELECT 语句抓取在前面查询到（或者抓取到）的所有实体对象的关联集合。除非你显式的指定 lazy="false" 禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 select 语句。

• 批量抓取（Batch fetching）：对查询抓取的优化方案，通过指定一个主键或外键列表，Hibernate 使用单条 SELECT 语句获取一批对象实例或集合。

 package com.yuqiaotech.nttelcom.model;

 import java.util.Date;
 import java.util.List;

 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.OneToMany;
 import javax.persistence.Table;

 /**
  * 场馆信息。
  *
  */
 @Entity(name="QING_AO_PLACE_INFO")
 @Table(name="QING_AO_PLACE_INFO")
 public class QingAoPlaceInfo {
     private Long id;
     private QingAoCenterInfo qingAoCenterInfo;// 重点场所id
     private String placeName;// 场馆名称
     private String note;// 备注
     private String openStat;// 开通状态
     private Long displayOrder;
     private String cityName;
     private Date createTime;
     private List qingAoPlaceCdmaSector;//拥有的cdma
     private List qingAoPlaceLteSector;//拥有的Lte
     private List qingAoAp;                          //拥有的Ap


     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     public Long getId() {
         return id;
     }

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

     @ManyToOne(fetch=FetchType.LAZY )
     @JoinColumn(name="f_center_id")
     public QingAoCenterInfo getQingAoCenterInfo() {
         return qingAoCenterInfo;
     }

     public void setQingAoCenterInfo(QingAoCenterInfo qingAoCenterInfo) {
         this.qingAoCenterInfo = qingAoCenterInfo;
     }
     /**
      * @searchItem
      * displayType="text"
      * 场所名称
      * @return
      */
     public String getPlaceName() {
         return placeName;
     }
     public void setPlaceName(String placeName) {
         this.placeName = placeName;
     }

     public String getNote() {
         return note;
     }

     public void setNote(String note) {
         this.note = note;
     }

     public String getOpenStat() {
         return openStat;
     }

     public void setOpenStat(String openStat) {
         this.openStat = openStat;
     }

     public Long getDisplayOrder() {
         return displayOrder;
     }

     public void setDisplayOrder(Long displayOrder) {
         this.displayOrder = displayOrder;
     }

     public String getCityName() {
         return cityName;
     }

     public void setCityName(String cityName) {
         this.cityName = cityName;
     }
     public Date getCreateTime() {
         return createTime;
     }
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
     @OneToMany(mappedBy="qingAoPlaceInfo",cascade= CascadeType.ALL)
     public List getQingAoPlaceCdmaSector() {
         return qingAoPlaceCdmaSector;
     }

     public void setQingAoPlaceCdmaSector(
             List qingAoPlaceCdmaSector) {
         this.qingAoPlaceCdmaSector = qingAoPlaceCdmaSector;
     }
     @OneToMany(mappedBy="qingAoPlaceInfo",cascade= CascadeType.ALL)
     public List getQingAoPlaceLteSector() {
         return qingAoPlaceLteSector;
     }

     public void setQingAoPlaceLteSector(
             List qingAoPlaceLteSector) {
         this.qingAoPlaceLteSector = qingAoPlaceLteSector;
     }
     @OneToMany(mappedBy="qingAoPlaceInfo",cascade= CascadeType.ALL)
     public List getQingAoAp() {
         return qingAoAp;
     }

     public void setQingAoAp(List qingAoAp) {
         this.qingAoAp = qingAoAp;
     }
 }

3、Hibernate4 注解版关系案例

一对多和多对一

公司用的maven 所以我也是建的maven工程，导入hibernate4的jar包

    <dependency>
 <groupId>org.hibernategroupId>
 <artifactId>hibernate-coreartifactId>
 <version>4.1.6.Finalversion>
    dependency>

但是oracle的驱动包，好像要自己手动加。不知道有没有用maven直接从网上加的方法。

hibernate.cfg.xml  文件

     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
 <session-factory>


     <property name="dialect">
         org.hibernate.dialect.Oracle10gDialect
     property>
     <property name="connection.url">jdbc:oracle:thin:@192.168.15.102:1521:ora11gproperty>
     <property name="connection.driver_class">oracle.jdbc.driver.OracleDriverproperty>
     <property name="connection.username">iris_ecnu_devproperty>
     <property name="connection.password">iris_ecnu_devproperty>


     <property name="show_sql">trueproperty>
     <property name="hbm2ddl.auto">updateproperty>
     <property name="format_sql">trueproperty>


     <mapping class="cn.lzg.Order" />
     <mapping class="cn.lzg.Person" />
 session-factory>
 hibernate-configuration>

Order.java 文件 

 package cn.lzg;

 import java.util.Date;

 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.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.persistence.SequenceGenerator;
 import javax.persistence.Table;

 @Entity
 @Table(name = "order_lzg")
 public class Order {

     @Id
     @SequenceGenerator(name = "order_lzg", sequenceName = "o_seq", allocationSize = 1)
     @GeneratedValue(generator = "order_lzg", strategy = GenerationType.SEQUENCE)
     private Long order_id;

     @Column(name = "submit_time")
     private Date submit_time;

     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "p_id")
     // order_lzg表 里面 放person_lzg ID的列
     private Person person_lzg;

     public Order() {
     }

     public Long getOrder_id() {
         return order_id;
     }

     public void setOrder_id(Long order_id) {
         this.order_id = order_id;
     }

     public Date getSubmit_time() {
         return submit_time;
     }

     public void setSubmit_time(Date submit_time) {
         this.submit_time = submit_time;
     }

     public Person getPerson_lzg() {
         return person_lzg;
     }

     public void setPerson_lzg(Person person_lzg) {
         this.person_lzg = person_lzg;
     }

 }

Person.java 文件

 package cn.lzg;

 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.SequenceGenerator;
 import javax.persistence.Table;

 @Entity
 @Table(name = "person_lzg")
 public class Person {

     @Id
     @SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)
     @GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)
     private Long p_id;

     @Column(name = "name")
     private String name;

     @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "person_lzg")
     // mappedBy的值，是Order对象里面存Person对象的属性的值
     private Set orderSet = new HashSet();

     public Long getp_id() {
         return p_id;
     }

     public void setp_id(Long p_id) {
         this.p_id = p_id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Set getOrderSet() {
         return orderSet;
     }

     public void setOrderSet(Set orderSet) {
         this.orderSet = orderSet;
     }

 }

多对多

其实它的和 一对多 差不多，但是按照网上写法出现了一个问题，使得 双向的关系变成了单向的。

Person类

 package cn.lzg;

 import java.util.ArrayList;
 import java.util.List;

 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.JoinColumn;
 import javax.persistence.JoinTable;
 import javax.persistence.ManyToMany;
 import javax.persistence.SequenceGenerator;
 import javax.persistence.Table;

 @Entity
 @Table(name = "person_lzg")
 public class Person {

     @Id
     @SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)
     @GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)
     private Long p_id;

     @Column(name = "name")
     private String name;

     @ManyToMany(targetEntity = cn.lzg.Book.class, fetch = FetchType.LAZY)
     @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "p_id") }, inverseJoinColumns = { @JoinColumn(name = "b_id") })
     // name中间表的名字,第一个自己的主键，第二个关联的主键
     private List books = new ArrayList();

     public Long getP_id() {
         return p_id;
     }

     public void setP_id(Long p_id) {
         this.p_id = p_id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public List getBooks() {
         return books;
     }

     public void setBooks(List books) {
         this.books = books;
     }

 }

Book类

 package cn.lzg;

 import java.util.ArrayList;
 import java.util.List;

 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.JoinColumn;
 import javax.persistence.JoinTable;
 import javax.persistence.ManyToMany;
 import javax.persistence.SequenceGenerator;
 import javax.persistence.Table;

 @Entity
 @Table(name = "book_lzg")
 public class Book {
     @Id
     @SequenceGenerator(name = "book_lzg", sequenceName = "b_seq", allocationSize = 1)
     @GeneratedValue(generator = "book_lzg", strategy = GenerationType.SEQUENCE)
     private Long b_id;

     @Column(name = "name")
     private String name;

     @ManyToMany(targetEntity = cn.lzg.Person.class, fetch = FetchType.LAZY)
     "color:#FF0000;">// 如果在上面使用mappedBy后,就成单向的了.也就是mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人.
     // 这个问题搞了好久才发现，开始一直是单向的.
     @JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "b_id") }, inverseJoinColumns = { @JoinColumn(name = "p_id") })
     private List persons = new ArrayList();

     public Long getB_id() {
         return b_id;
     }

     public void setB_id(Long b_id) {
         this.b_id = b_id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public List getPersons() {
         return persons;
     }

     public void setPersons(List persons) {
         this.persons = persons;
     }

 }

注意

 "color:#FF0000;">如果在上面ManyToMany注解中使用mappedBy,就成单向的了.因为mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人

 "color:#330033;">测试类
 "code" class="java">package cn.lzg;

 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.hibernate.service.ServiceRegistry;
 import org.hibernate.service.ServiceRegistryBuilder;
 import org.junit.Test;

 public class TestHibernate {
     private static Configuration configuration = null;
     private static SessionFactory sessionFactory = null;
     private static ServiceRegistry serviceRegistry = null;
     private static Session session = null;

     static {
         /**
          * hibernate 4 貌失要这样获得sessionFactory 以前的configuration.buildSessionFactory();方法 过时了
          */
         configuration = new Configuration().configure();

         serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                 .buildServiceRegistry();

         sessionFactory = configuration.buildSessionFactory(serviceRegistry);
         session = sessionFactory.openSession();
     }



     @Test
     // 测试manytomany
     public void testM2M() {
         Person p1 = new Person();
         p1.setName("张三");
         Person p2 = new Person();
         p2.setName("李四");
         Person p3 = new Person();
         p3.setName("王五");
         List persons = new ArrayList();
         persons.add(p1);
         persons.add(p2);
         persons.add(p3);

         Book b1 = new Book();
         b1.setName("书本1");
         Book b2 = new Book();
         b2.setName("书本2");
         Book b3 = new Book();
         b3.setName("书本3");
         List books = new ArrayList();
         books.add(b1);
         books.add(b2);
         books.add(b3);

         p1.setBooks(books);
         b3.setPersons(persons);

         Transaction tx = session.beginTransaction();
         session.save(p1);
         session.save(p2);
         session.save(p3);
         session.save(b1);
         session.save(b2);
         session.save(b3);
         tx.commit();
         session.close();
     }
 }

结果生成了中间表

 lzgp_lzgb 里面的关系p1 有三本书， p1,p2,p3都有b3

HIbernate注解多对多关系要点总结

最近在公司做一个小项目，框架的持久层我选用的是Hibernate annotation，用户和他收藏的网站的关系是多对多的关系，一个用户可以收藏多个他喜爱的网站；反过来，一个网站也可以被多个用户收藏。
因此在设计类的时候，我设计了一个Sysuser（用户）类和一个Website（网站）类。

在配置注解的时候，由于在用户和网站之前，用户是主控方，网站是被控方。所以我在Sysuser类的getWebsite()方法上加了下面一段内容进行注解。

 @ManyToMany(fetch=FetchType.EAGER,cascade={CascadeType.PERSIST,CascadeType.MERGE})
     @JoinTable(name="user_web",joinColumns=@JoinColumn(name="userid"),
             inverseJoinColumns=@JoinColumn(name="webid"))
     public Set getWebsite() {
         return website;
     }
     public void setWebsite(Set website) {
         this.website = website;
     }

其中@ManyToMany就不用说了，指明用户和网站之前是多对多的关系。这里需要说的是，在主控方的get那个set集合的方法上面需要再加上@JoinTable进行注解，其中name="user_web"就是指在数据库中体现多对多关系的中间表是user_web，指定之后在首次运行项目的时候会在数据库中自动生成这个中间表，而且这个中间表不需要写个类去对应，可以通过这两个有多对多关系的类去维护第三章表的数据。joinColumns=@JoinColumn(name="userid")这句话的意思是是定义中间表与Sysuser这个类外键关系，中间表是通过userid这一列产生外键关联的，而inverseJoinColumns是中间表参考另一张的表的主键生成的列。

在Website类的getSysuser()方法上加了下面一段内容进行注解

 @ManyToMany(cascade={CascadeType.MERGE,CascadeType.PERSIST},mappedBy="website")
     public Set getSysuser() {
         return sysuser;
     }
     public void setSysuser(Set sysuser) {
         this.sysuser = sysuser;
     }

其中的@ManyToMany也不用说了，指明网站与用户之间是多对多的关系。需要说明的是在被控方，需要加上mappedBy，例如这里的mappedBy="website"是产生关系的属性。

总结一下需要注意的几点：

1、只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；

2、mappedBy标签一定是定义在the owned side(被控方，或者叫被拥有方)，他指向the owning side(主控方，或者叫做拥有方)；

3、mappedBy跟JoinColumn/JoinTable总是处于互斥的一方，可以理解为正是由于拥有方的关联被拥有方的字段存在，拥有方才拥有了被拥有方。mappedBy这方定义的JoinColumn/JoinTable总是失效的，不会建立对应的字段或者表。

Hibernate Annotation关系映射的几种类型映射用法及使用方法

 Hibernate Annotation关系映射的几种类型映射用法及使用方法（说明：以前实例的实体是user和role，主键分别是userid和roleid）

 1）一对一外键关联映射（单向）
 @OneToOne(cascade=CascadeType.ALL)  //一对一外键关联，使用@OneToOne，并设置了级联操作
 @JoinColumn(name="userid",unique=true)   //@JoinColum设置了外键的名称为userid（数据库字段名），如果不设置，则默认为另一类的属性名+ _id。外键的值是唯一的(unique)，不可重复，与另一类的主键一直

 2）一对一外键关联映射（双向）
 @OneToOne(mappedBy=" role",cascade=CascadeType.ALL)  //一对一双向关联关系，使用@OneToOne。注意：需要加上mappedBy="role"，如果不加上的话， role 也会生成一个外键（user_id），mappedby="role"需要指向与他关联对象的一个属性，说明双向关联关系中，有且仅有一端是作为主体(owner)端存在的，主体端负责维护联接列，对于不需要维护这种关系的从表则通过mappedBy属性进行声明，mappedBy的值指向主体的关联属性
 //规律：只有是双向关联关系，都加上mappedby，cascade=CascadeType.ALL级联

  3)一对一主键关联映射（不重要）
 在实际中很少用，使用注解@PrimaryKeyJoinColumn，意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML映射可以生成。Annotation注解一对一主键关联映，有些bug。不过没空去研究它。因为在实际开发中一对一很少用。在实际开发中我机会没有用过，主键关联就更少了

 4）多对一关联映射
 多端配置
 @ManyToOne(targetEntity=role.class)  //多对一注解@ManyToOne；targetEntity指定了关联对象
 @JoinColumn(name="userid")  //@JoinColumn(name="userid")指定生产的外键的字段名，默认是org_id

 5)一对多关联映射（单向）
 @OneToMany   //一对多注解@OneToMany（单向）,如果只写@OneToMany的话，hibernate会建一张中间表来维护他们之间的关系
 @JoinColumn(name="roleid")    //加上@JoinColumn(name="roleid")，则不会建中间表，他会在多的一端加上外键roleid，来维护他们之间的关系

 6)一对多关联映射（双向）
 一端配置
 @OneToMany(mappedBy="role")  //一对多双向，在一的一端中设置mappedBy,说明多的一端为主导
 @JoinColumn(name="roleid")  //如果指定了外键字段名称，则多的一端也需要指定相同的字段名称

 多端配置
 @ManyToOne  //一对多双向
 @JoinColumn(name=" roleid ") //需要指定外键与一的一端给的外键名称一致，@JoinColumn(name=" roleid "),也可以不指定，如果在多的一端不指定，则一的一端也不能指定,否则为生成两个外键

 7)多对多关联映射（单向）
 @ManyToMany  //多对多映射：注解@ManyToMany（单向），默认情况下，hibernate会自动的创建一张中间表来维护多对多关系

  默认中间表的名称 ：user_role中间表，字段的名称user_id role_id,如果想更换表名和字段名称，注解如下：
 @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})

 8)多对多关联映射（双向）
 user端
 @ManyToMany  //多对多映射：注解@ManyToMany（单向）;默认情况下，hibernate会自动的创建一张中间表，来维护多对多关系;默认中间表的名称 ：user_role中间表，字段的名称user_id role_id
 如果想更换表名和字段名称，注解如下：
 @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})  //@JoinTable(name="t_u_r"),指定中间表的表名；joinColumns={@JoinColumn(name="u_id")},指定当前对象的外键；inverseJoinColumns={@JoinColumn(name="r_id")},指定关联对象的外键

 role端
 @ManyToMany(mappedBy="role")   //多对多,双向关联映射

Hibernate Annotation笔记

在过去几年里，Hibernate不断发展，几乎成为Java数据库持久性的事实标准。它非常强大、灵活，而且具备了优异的性能。在本文中，我们将了解如何使用Java 5 注释来简化Hibernate代码，并使持久层的编码过程变得更为轻松。
　　传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。
    在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的Java 类中，并提供一种强大及灵活的方法来声明持久性映射。

即利用hibernate注解后，可不用定义持久化类对应的*.hbm.xml文件，直接以注解方式写入在持久化类中来实现。

Hibernate annotation使用了ejb JPA的注解,所以，下面安装配置hibernate annotation环境时，需要导入ejb的包。许多网上的资料都是jpa hibernate annotation方面的资料。

(2)
安装 Hibernate Annotation
第一步，
环境与jar包：
　　要使用 Hibernate Annotation，您至少需要具备 Hibernate 3.2和Java 5。可以从 Hibernate 站点下载 Hibernate 3.2 和 Hibernate Annotation库。除了标准的 Hibernate JAR 和依赖项之外，您还需要 Hibernate Annotations .jar 文件（hibernate-annotations.jar）、Java 持久性 API （lib/ejb3-persistence.jar）。

添加hibernate3.2.jar,hibernate-annotations-3.3.0.jar，hibernate-commons-annotations.jar和ejb3-persistence.jar 。这样就可以使用hibernate的annotation了。

如果您正在使用 Maven，只需要向 POM 文件添加相应的依赖项即可，如下所示：
    ...
   
      org.hibernate
      hibernate
      3.2.1.ga
   
   
      org.hibernate
      hibernate-annotations
      3.2.0.ga
   
   
      javax.persistence
      persistence-api
      1.0
   

第二步，
获取 Hibernate 会话工厂。尽管无需惊天的修改，但这一工作与使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 类来建立会话工厂：
sessionFactory = new AnnotationConfiguration().buildSessionFactory(); 
第三步，
尽管通常使用 元素来声明持久性类，您还是需要在 Hibernate 配置文件（通常是 hibernate.cfg.xml）中声明持久性类：
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    " http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
       
         
           
           
         
       
　　近期的许多 Java 项目都使用了轻量级的应用框架，例如 Spring。如果您正在使用 Spring 框架，可以使用

AnnotationSessionFactoryBean 类轻松建立一个基于注释的 Hibernate 会话工厂，如下所示：

         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  
    
  
  
    
       org.hibernate.dialect.DerbyDialect
       create
       ...
    
  
  
    
       com.onjava.modelplanes.domain.PlaneType
       com.onjava.modelplanes.domain.ModelPlane
       ...
    
  

(3)
hibernate Annotation标签的使用:

[1]
1.带注释的持久性类也是普通 POJO,它们只是具备了持久性注释的普通 POJO 。

2.事实上，您既可以保持字段的持久性（注释写在成员变量之上），也可以保持属性（注释写在getter方法之上）的持久性。