`

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

 
阅读更多

http://www.cnblogs.com/xiaoluo501395377/p/3374955.html

 

在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);

以上就是对hibernate annotation注解方式来配置映射关系的一些总结。

分享到：
| 代码片段，导出的文件头
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate Annotation jar

    现在我们公司在做web项目的时候，已经不用*.hbm.xml这种映射文件了，都是用Annotation（注解）方式来完成实体与表之间的映射关系，这样看起来比用xml文件来映射更具有可读性，自我感觉以后Hibernate Annotation的...

    hibernate _annotation 注解编程

    - **概述**：Hibernate 是一个流行的 Java 持久层框架，它提供了一种面向对象的方式来处理数据库操作。Hibernate 支持多种元数据定义方式，其中注解方式因其简洁易用而受到广泛欢迎。Hibernate 的注解支持主要通过 ...

    Hibernate Annotation库

    Hibernate Annotation库是Java开发中用于简化对象关系映射（ORM）的一个重要组件，它使得开发者能够在Java类上直接使用注解来定义数据库映射，从而避免了传统的XML配置文件。这三个特定的jar包是Hibernate ORM框架中...

    hibernate annotation 中文文档

    《Hibernate Annotation 中文文档》是Java开发者们的重要参考资料，它详细介绍了如何在Hibernate框架中使用注解进行对象关系映射（ORM）。Hibernate是一款强大的开源Java持久化框架，它简化了数据库与Java对象之间的...

    hibernate annotation hibernate3

    在Java开发领域，Hibernate作为一种强大的对象关系映射（ORM）框架，极大地简化了数据库操作。本篇将深入探讨Hibernate 3版本中的注解使用，帮助开发者理解如何利用注解进行数据持久化，提高开发效率。 一、...

    Hibernate Annotation 中文文档

    Hibernate Annotation是Hibernate框架的一个扩展，它允许开发者直接在Java类和属性上使用注解（Annotations），来定义实体类与数据库表之间的映射关系。相比于XML配置，注解提供了一种更加内聚和直接的方式，使得...

    Hibernate Annotation 笔记 总结 注解

    1. **注解替代XML映射**：在Hibernate 3.2及更高版本中，引入了Annotation支持，开发者可以直接在Java实体类上使用注解来定义持久化字段和关系，不再需要创建单独的`.hbm.xml`映射文件。 2. **依赖**：使用...

    最全的Hibernate Annotation API文档

    在Hibernate中，注解（Annotation）是一种声明式的方法，用于配置实体类、属性以及它们与数据库表之间的映射关系。本文将深入探讨“最全的Hibernate Annotation API文档”中的关键知识点。 一、实体类（Entity） 在...

    让Hibernate同时支持xml和注解两种映射方式

    要让Hibernate同时支持XML和注解映射，我们可以创建一个新的配置类，该类扩展`AnnotationSessionFactoryBean`，并在需要时调用其父类`LocalSessionFactoryBean`的方法来处理XML映射。这样，我们就可以拥有一个单一的...

    hibernate-Annotation.jar

    在Hibernate 3.x版本中，引入了Annotation注解，这是一种元数据的方式，可以替代XML配置文件来描述对象与数据库表之间的映射关系。 **Hibernate Annotation注解** 在Hibernate 3.x之前，对象到数据库的映射通常...

    Hibernate Annotation 学习笔记

    而Hibernate Annotation则是Hibernate提供的一种基于注解的实体映射方式，它极大地简化了传统XML配置文件的繁琐工作，使得开发过程更加简洁高效。本文将通过一个实际操作的实例，逐步介绍Hibernate Annotation的基础...

    Hibernate Annotation入门

    总之，Hibernate Annotation为Java开发者提供了一种直观且强大的方式来处理数据库操作，让ORM变得更加简单易用。随着对它的不断学习和实践，你将能够更好地应对复杂的业务场景，提高软件的稳定性和可维护性。

    hibernate annotation api chm文件

    在Hibernate 3.3版本中，引入了Annotation API，这是一种更加直观、简洁的方式来声明对象-关系映射（ORM）。本文将深入探讨Hibernate Annotation API的核心概念、使用方法及其优势。 1. **什么是Hibernate ...

    Hibernate distribution and annotation

    2. **映射机制**： Hibernate支持XML映射文件（hbm.xml）和注解映射两种方式，让对象与数据库表之间建立映射关系。 3. **Session和Transaction**： Session是Hibernate的主要工作单元，负责保存、更新和检索对象。...

    sping hibernate Annotation(注释配置) demo（例子）

    总结来说，这个 "Spring Hibernate Annotation demo" 展示了如何在 Spring 框架中使用注解配置来管理依赖，以及如何利用 Hibernate 的注解进行数据持久化。同时，它还涉及到了 Flex 前端与后端的交互。通过学习这个 ...

    hibernate-annotation

    在传统的Hibernate应用中，我们通常使用XML文件来描述对象和表之间的映射关系。然而，随着Java 5的发布，注解成为了一种更简洁、更直观的元数据表示方式。Hibernate注解就是利用这种方式，将对象的映射信息直接写在...

    hibernate annotations3.4.0 GA.rar

    现在已经不用*.hbm.xml这种映射文件了，都是用Annotation（注解）方式来完成实体与表之间的映射关系，这样看起来比用xml文件来映射更具有可读性，自我感觉以后Hibernate Annotation的映射方式将代替hibernate 的*....

    HibernateAnnotation

    ### HibernateAnnotation ...通过上述介绍，我们可以看到HibernateAnnotation技术不仅简化了配置过程，而且提供了一种更加灵活的方式来管理对象与数据库之间的映射关系。这对于提高开发效率和维护性都有着重要的意义。

    Hibernate中文文档+hibernate annotation +distribution

    其次，hibernate-annotations-3.4.0GA是Hibernate支持JPA（Java Persistence API）的重要组成部分，引入了注解方式来声明对象与数据库表之间的映射关系。例如，`@Entity`表示一个类作为数据库中的表，`@Table`定义...

Magicbox
Global site tag (gtag.js) - Google Analytics