hibernate annotation注解方式来处理映射关系

最新推荐文章于 2025-07-28 23:27:29 发布

aionbo

最新推荐文章于 2025-07-28 23:27:29 发布

阅读量321

点赞数

CC 4.0 BY-SA版权

分类专栏： Hibernate 文章标签： hibernate

本文链接：https://blog.youkuaiyun.com/aionbo/article/details/78393101

Hibernate 专栏收录该内容

1 篇文章

订阅专栏

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

一、单对象操作

    @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对象以及一个Course对象
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，所以在对方外键的名称就是 cid，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)//LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时，
                                              //只会发出一条 count(*)的语句，提高性能　　
    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)//LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时，
                                              //只会发出一条 count(*)的语句，提高性能　
    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　//ManyToOne关联到Role 
    @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);

inverse与cascade属性使用总结：
使用”inverse”这个属性时，要考虑清楚关系，不然你的系统就会有大的性能问题，关系一般由”多方”维护，当遇到”多对多”时怎么办，其实多对多久是两个”一对多”，随意设置一方”inverse”为”true”就可以了，不要两方都设置或都不设置。而使用”cascade”属性时，主对象(一方)一般设置为”all”，而多方不建议设置包含delete操作的选项，建议设置多方为”save-update”，这是因为你删除一方，多方已经没有存在的意义了，而删除多方不能代表一方没意义了（例如，消费者和订单）。最后，“cascade”操作的是两张表的记录或两端的对象，而”inverse”操作的是两张表的关系或两个对象的关系。

Hibernate注解关系映射:（注意:在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。）
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”) //如果指定了外键字段名称，则多的一端也需要指定相同的字段名称
@LazyCollection(LazyCollectionOption.EXTRA)　　—>　　LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 count(*)的语句，提高性能

多端配置
@ManyToOne(fetch=FetchType.LAZY)　　—> ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载) //一对多双向
@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”) //多对多,双向关联映射