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

最新推荐文章于 2018-04-17 17:50:41 发布
最新推荐文章于 2018-04-17 17:50:41 发布
阅读量2.6k 收藏 4
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/38752989
版权
本文详细介绍了Hibernate注解在处理关系映射中的应用，包括双向one-to-many映射关系的实现，以及多对一、一对多、多对多的案例分析。通过注解@OneToMany、@ManyToOne和@ManyToMany，配合mappedBy和cascade属性，实现了对象关系的持久化。文章还探讨了fetch和lazy属性在级联查询中的作用。
摘要由CSDN通过智能技术生成

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文件里面将该实体类加进去即可：

<!-- 基于annotation的配置 -->
        <mapping class="com.xiaoluo.bean.User"/>
<!-- 基于hbm.xml配置文件 -->
        <mapping resource="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<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指定了一对多的关系，mappedBy="room"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，(注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)
    @LazyCollection(LazyCollectionOption.EXTRA)　　--->　　LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 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指定了多对一的关系，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<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指定多对多的关联关系
    @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<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关联到了AdminRole这个类，由AdminRole这个类来维护多对一的关系，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这个类来维护多对一的关联关系，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关联到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，表示选择全部四项。 

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.yuqiaotech.nttelcom.model;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import javax.persistence.CascadeType;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.GeneratedValue;  
  9. import javax.persistence.GenerationType;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.OneToMany;  
  12. import javax.persistence.Table;  
  13.   
  14. /** 
  15.  * 青奥重点场所信息表。 
  16.  *  
  17.  */  
  18. @Entity(name="QING_AO_CENTER_INFO")  
  19. @Table(name="QING_AO_CENTER_INFO")  
  20. public class QingAoCenterInfo {  
  21.     private Long id;  
  22.     private String centerName;  //重点场所名称  
  23.     private Long alarmNum;      //告警数  
  24.     private String note;        //备注  
  25.     private String iconName;    //图标名称  
  26.     private String cityName;    //所在城市  
  27.     private String type;        //重点场所、活动保障  
  28.     private Date createTime;  
  29.     private List<QingAoPlaceInfo> qingAoPlaceInfo; //场所拥有的场馆  
  30.     @Id  
  31.     @GeneratedValue(strategy=GenerationType.AUTO)  
  32.     public Long getId() {  
  33.         return id;  
  34.     }  
  35.     public void setId(Long id) {  
  36.         this.id = id;  
  37.     }  
  38.     /** 
  39.      * @searchItem 
  40.      * displayType="text" 
  41.      *  
  42.      * 重点场所名称 
  43.      * @return 
  44.      */  
  45.     public String getCenterName() {  
  46.         return centerName;  
  47.     }  
  48.     public void setCenterName(String centerName) {  
  49.         this.centerName = centerName;  
  50.     }  
  51.     /** 
  52.      * 告警数 
  53.      * @return 
  54.      */  
  55.     public Long getAlarmNum() {  
  56.         return alarmNum;  
  57.     }  
  58.     public void setAlarmNum(Long alarmNum) {  
  59.         this.alarmNum = alarmNum;  
  60.     }  
  61.     /** 
  62.      * 备注 
  63.      * @return 
  64.      */  
  65.     public String getNote() {  
  66.         return note;  
  67.     }  
  68.     public void setNote(String note) {  
  69.         this.note = note;  
  70.     }  
  71.     /** 
  72.      * 图标名称 
  73.      * @return 
  74.      */  
  75.     public String getIconName() {  
  76.         return iconName;  
  77.     }  
  78.     public void setIconName(String iconName) {  
  79.         this.iconName = iconName;  
  80.     }  
  81.   
  82.     public String getCityName() {  
  83.         return cityName;  
  84.     }  
  85.   
  86.     public void setCityName(String cityName) {  
  87.         this.cityName = cityName;  
  88.     }  
  89.     public String getType() {  
  90.         return type;  
  91.     }  
  92.     public void setType(String type) {  
  93.         this.type = type;  
  94.     }  
  95.     public Date getCreateTime() {  
  96.         return createTime;  
  97.     }  
  98.     public void setCreateTime(Date createTime) {  
  99.         this.createTime = createTime;  
  100.     }  
  101.     @OneToMany(mappedBy="qingAoCenterInfo",cascade= CascadeType.ALL)  
  102.     public List<QingAoPlaceInfo> getQingAoPlaceInfo() {  
  103.         return qingAoPlaceInfo;  
  104.     }  
  105.     public void setQingAoPlaceInfo(List<QingAoPlaceInfo> qingAoPlaceInfo) {  
  106.         this.qingAoPlaceInfo = qingAoPlaceInfo;  
  107.     }  
  108. }  


many端：QingAoPlaceInfo，持有QingAoCenterInfo的引用

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

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

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

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


[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.yuqiaotech.nttelcom.model;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import javax.persistence.CascadeType;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.FetchType;  
最低0.47元/天 解锁文章
小飞鹤
关注
专栏目录
Hibernate 注解映射
11-03
Hibernate 基于注解方式实体类与数据库表映射，提高开发效率
Hibernate映射关系配置：XML方式和注解方式
03-27
3. **关联映射**：XML映射文件中可以定义一对多、一对一、多对多等各种关系，比如使用`<set>`, `<one-to-one>`, `<many-to-many>`等元素。 **注解方式** 1. **@Entity**：这个注解标记一个Java类为Hibernate实体，...
hibernate annotation注解方式来处理映射关系
weixin_34293141的博客
10-17 152
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用h...
Hibernate -- 注解（Annotation）关系映射
系统运维
02-07 110
来源于：http://www.cnblogs.com/tyler2000/archive/2011/01/20/1940354.html 1. Hibernate Annotation关系映射有下面几种类型： 1)一对一外键关联映射（单向） 2)一对一外键关联映射（双向） 3)一对一主键关联映射（不重要）在这不演示 在实际中很少用，使用注解@PrimaryKeyJoinColumn ...
hibernate注解配置关联关系
weixin_34194379的博客
08-27 124
1.在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。 JoinColumn(name="pid") 2. 在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据，如： 　 Person p = new Person(); ...
Hibernate注解与XML映射：哪种更适合你的项目？终极对比
在Java领域，对象关系映射（Object-Relational Mapping, ORM）是一种广泛应用的技术，它用于在关系数据库和对象之间建立映射关系，以简化数据库操作。Hibernate是一个强大的ORM框架，它允许开发者用Java对象代替SQL...
springmvc+spring+hibernate整合(注解)
05-20
1. 创建实体类，使用Hibernate注解定义属性和关联关系。 2. 创建DAO接口和实现类，使用@Autowired注入SessionFactory，编写基本的CRUD操作。 3. 创建Service接口和实现类，定义业务逻辑，使用@Autowired注入DAO层。 ...
Hibernate注解方式一对多自关联关系映射
Programmer.Wenlong 小龙在线
05-20 122
MySQL版数据库表结构 DROP TABLE IF EXISTS SYS_DICT_ITEM; CREATE TABLE SYS_DICT_ITEM( ITEM_CODE VARCHAR(100) NOT NULL, ITEM_VALUE VARCHAR(200), DICT_CODE VARCHAR(100) NOT NULL, PARENT_CODE VARCHAR(100), ...
Hibernate一对多关联映射(注解)
06-01
NULL 博文链接：https://profound-accumulation.iteye.com/blog/2243079
Hibernate的注解映射
youngboby的博客
09-28 348
[TOC] Hibernate的注解映射 1 基本映射 2 多对一单双向映射 3 一对多单双向映射 4 多对多双向映射 5 其他映射 基本映射 1 @Entity 定义在实体类处 Employee； 2 @Table（name=”employee”） 当实体类名与对应的数据库名不一致时定义； 3 @I
Hibernate注解方式映射
zll_zll_zll_zll的博客
04-17 305
JPA：Java persistence APIJPA注解是JavaEE的标准和规范JPA是标准接口，Hibernate是实现，优先使用JPA注解。一：类级别注解1：@Entity映射实体类name属性对应数据库中的表（一般不写通过@Table写）注意：使用@Entity时必须制定实体类的主键属性。2：@Table映射实体类在数据库中的表name属性（name=“表名”）表明和实体类名相同时不用写...
【转】[hibernate]注解的说明
Fighting with Winston Shao
08-11 340
/**  *  * @author liuguangyi  * @content  ejb3注解的API定义在javax.persistence.*包里面。  *  * 注释说明：  * @Entity —— 将一个类声明为一个实体bean(即一个持久化POJO类
hibernate表关联注解
wjboy49的专栏
08-02 355
好久就想玩一下hibernate注解了（因为不用hbm文件，维护起来也简单，灵活性较高，适应需求变化作出快速变动，还有一些好处就不一一例举啦），但是没有时间，今天搞了一下，碰个几个问题，我想这应该也就新手最容易碰的。问题有三：     第一、Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unkn...
Hibernate的七种映射关系之七种关联映射（一）
weixin_34239169的博客
04-27 142
　　 　　关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。　　 　　一、Hibernate多对一关联映射：就是在“多”的一端加外键，指向“一”的一端。 　　比如多个学生对应一个班级，多个用户对应一个级别等等，都是多对一关系。 　　 　　1、“多”端实体加入引用“一”端实体的变量及getter,setter方法。 　　比如说多个学生对应一个班级，在学生实体类加入：p...
Hibernate注解方式处理映射关系
逍遥飞鹤的专栏
10-20 986
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用h
Hibernate注解映射关系深入解析与实践
Hibernate注解处理映射关系是Hibernate框架中一个非常重要的部分，它允许开发者通过注解的方式来配置和管理实体类与数据库表之间的映射关系。 通过Hibernate注解，开发者可以在Java类的字段、方法以及类上使用注解...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值