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

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

转载于:https://www.cnblogs.com/loong-hon/p/4926080.html

hibernate注解方式来处理映射关系相关推荐

hibernate annotation注解方式来处理映射关系
2019独角兽企业重金招聘Python工程师标准>>> 在hibernate中,通常配置对象关系映射关系有两种,一种是基于xml的方式,另一种是基于annotation的注解方式,熟 ...
使用Hibernate注解Annotations进行对象映射的异常处理
通过Hibernate注解Annotations进行对象映射,想在Oracle数据库中自动创建表,代码如下: 实体类: import javax.persistence.Basic; import j ...
hibernate的3种继承映射关系总结——TPH,TPS,TPC
Java类中有继承关系,相应的在hibernate中,也有继承关系,子类反应到数据库中,就有多种实现形式了,子类和父类可以映射到同一张表中,子类也可以单独映射成一张表,但是用不同的标签实现,子类表和父 ...
Hibernate（六）一对一映射关系
One to One 映射关系(只有当映射自定义对象时,才会用,hibernate支持的java类型都可直接设成属性,了解第一和第二种的xml即可) 基于外键的单向一对一 (xml和annotatio ...
Hibernate注解方式实现1-1双向关联
2019独角兽企业重金招聘Python工程师标准>>> 以微博或博客为例,我们希望用户-用户信息设计为如下关系,即用户表用户口令登录等操作.用户信息表用户记录信息: 用户User代码 ...
Hibernate实体映射配置1（java@注解方式）
实体和数据库之间存在某种映射关系,hibernate根据这种映射关系完成数据的存取.在程序中这种映射关系由映射文件(*.hbm.xml)或者java注解(@)定义. 本文以java注解的形式总结映射关 ...
MyBatis 3（2）实体映射 CRUD 操作（XML/注解方式）
MyBatis 实体映射 Mybatis 配置数据映射主要有 2 种方式,通过 XML 配置文件进行,通过注解进行: Mybatis 对于实体映射是通过接口调用的方式,在底层上使用 Java 的动态代 ...
SpringBoot 注解方式快速整合Mybatis
点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试资料作者:yizhiwazi www.jianshu.com/p/82 ...
@column注解_SpringBoot 注解方式快速整合Mybatis
点击上方"Java研发军团",选择"置顶公众号" 关键时刻,第一时间送达! 阅读本文需要5分钟作者:yizhiwazi www.jianshu.com/p/8 ...

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

hibernate注解方式来处理映射关系相关推荐

最新文章

热门文章