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

最新推荐文章于 2024-03-28 20:14:41 发布
最新推荐文章于 2024-03-28 20:14:41 发布
阅读量2.5k 收藏 4
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/38752989
版权

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元/天 解锁文章
小飞鹤
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Hibernate 注解映射
11-03
Hibernate 基于注解方式实体类与数据库表映射，提高开发效率
hibernate annotation注解方式来处理映射关系
weixin_34293141的博客
10-17 127
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用h...
【转】[hibernate]注解的说明
Fighting with Winston Shao
08-11 322
/**  *  * @author liuguangyi  * @content  ejb3注解的API定义在javax.persistence.*包里面。  *  * 注释说明：  * @Entity —— 将一个类声明为一个实体bean(即一个持久化POJO类
Hibernate注解详解(超全面)，Java开发人员不得不收集的代码
最新发布
m0_60635245的博客
03-28 893
我个人认为，如果你想靠着背面试题来获得心仪的offer，用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难，想找到心仪的工作也是越来越难，高薪工作羡慕不来，却又对自己目前的薪资不太满意，工作几年甚至连一个应届生的薪资都比不上，终究是错付了，错付了自己没有去提升技术。这些面试题分享给大家的目的，其实是希望大家通过大厂面试题分析自己的技术栈，给自己梳理一个更加明确的学习方向，当你准备好去面试大厂，你心里有底，大概知道面试官会问多广，多深，避免面试的时候一问三不知。
hibernate注解映射属性
weixin_30871293的博客
01-27 406
https://blog.csdn.net/dada678/article/details/51786201 1、普通属性 @Entity：修饰的持久化类的所有属性都会被映射到底层数据库。 @Column:修饰属性 @Transient：修饰不想持久化保存的属性。 @Lob:修饰大数据属性。 当属性为byte[]、Byte[]时数据库对应Blob 当属性为char[]、ch...
Hibernate映射关系配置：XML方式和注解方式
03-27
3. **关联映射**：XML映射文件中可以定义一对多、一对一、多对多等各种关系，比如使用`<set>`, `<one-to-one>`, `<many-to-many>`等元素。 **注解方式** 1. **@Entity**：这个注解标记一个Java类为Hibernate实体，...
开源对象关系映射框架Hibernate知识培训
11-07
标题和描述都在强调"开源对象关系映射框架Hibernate知识培训"，这意味着主要内容将围绕Hibernate这一框架，探讨如何进行对象关系映射（ORM）以及相关的学习和应用。 **对象关系映射（ORM）** 对象关系映射（Object...
springmvc+spring+hibernate整合(注解)
05-20
1. 创建实体类，使用Hibernate注解定义属性和关联关系。 2. 创建DAO接口和实现类，使用@Autowired注入SessionFactory，编写基本的CRUD操作。 3. 创建Service接口和实现类，定义业务逻辑，使用@Autowired注入DAO层。 ...
hibernate3.2详细案例
08-11
2. **持久化类（Persistent Class）**：通过Hibernate注解或XML配置，使Java类具备持久化能力。 3. **Session**：Hibernate的核心接口，负责对象的创建、读取、更新和删除操作。 4. **SessionFactory**：用于创建...
Hibernate一对多关联映射(注解)
06-01
NULL 博文链接：https://profound-accumulation.iteye.com/blog/2243079
hibernate 多对多全注解（单向关联、双向关联）
09-13
hibernate关联映射注解多对多单向关联、
8.Hibernate注解及其详细使用（在实体类中配置映射文件）
相互学习 共同进步
04-29 957
Hibernate提供了注解来进行对象（关系映射），它可以代替大量的hbm.xml文件，使得Hibernate程序的文件数量大大精简。使用注解，可以直接将映射信息定义在持久化类中，而无须编写对应的*.hbm.xml文件。
Hibernate注解方式映射
zll_zll_zll_zll的博客
04-17 264
JPA：Java persistence APIJPA注解是JavaEE的标准和规范JPA是标准接口，Hibernate是实现，优先使用JPA注解。一：类级别注解1：@Entity映射实体类name属性对应数据库中的表（一般不写通过@Table写）注意：使用@Entity时必须制定实体类的主键属性。2：@Table映射实体类在数据库中的表name属性（name=“表名”）表明和实体类名相同时不用写...
Hibernate 映射关系（基于注解）
qq_26564827的博客
11-28 444
提示：表与表之间的映射关系通过外键或中间表建立联系： 单向外键映射关系：这里主要是指在两个映射表对象类（一对一关系）之间只有一方包含另一方的引用，比如映射对象类A与映射表对象B之间，如果只有A中有一个属性是对B的引用 private B b;那么就称为单向外键关系。 双向外键映射关系；这里指双方都包含一方的引用，但如果是没有中间表，那么就要指定主控方与被控方。 上面所说的单向外键关系与映射外键
Hibernate注解方式多种映射
功不唐捐，玉汝于成。
04-13 843
1、先介绍一对一的映射annotation（Man和Woman） Man.java package ray.one2one; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Ge
Hibernate注解实战：关系映射详解
"本资源提供了一个关于Hibernate注解编程的实例教程，涵盖了多种关系映射的注解应用，适用于学习和理解Hibernate如何通过注解进行对象关系映射。示例代码包括了IdCard和Person实体类的映射配置。" 在Java的持久化...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值