Hibernate实体类常用注解

最新推荐文章于 2024-04-09 13:15:49 发布

一年不洗澡-_-

最新推荐文章于 2024-04-09 13:15:49 发布

阅读量588

点赞数 1

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

本文链接：https://blog.csdn.net/qq_34131878/article/details/52787880

版权

Hibernate 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

作为一名刚刚成为程序猿的我来说，对Hibernate的所知有限，最近在网上看了一些关于Hibernate注解的文章，决定自己写一写自己看这些文章的总结以及自己最近使用的体会，如有不对的地方，希望各位大牛指教。
Hibernate常用注解：
1，@Entity
表示这是一个实体类
2 @Table
与@Entity一起用，常用的有name属性，是对应数据库中的表名
例如： @Entity
@Table (name=”STUDENT”)
3@Id
这个是必须要写的，它对应的是表中的主键，一般写在主键的get方法之上

@Id
public Long getId() {
    return id;
}

4@Column
描述了数据库表中该字段的详细定义，有name属性，作用是表示数据库表中该字段的名称,默认情形属性名称一致，当实体类中定义的属性名与数据库中的字段名不一致时，需要写清楚；
例如：
在数据库的dept表格中有字段 SUP_DEPT_ID意思是上级部门id而在实体类中定义的属性为dept_id ,这样在实体类中就要写清楚，
@Column(name=”SUP_DEPT_ID”)
public Long getDept_id() {
return dept_id;
}
5@Transient
这个注解表示该属性并非是数据库表中的字段，而是自己定义的一个非持久化的一个属性，如果一个属性不是数据库表中的字段，就必须加上这个注解，

下边这些是我在网上看到，觉得要比我自己写的好，就直接粘过来了，

6@OneToMany 一对多关系映射

这里我们定义了两个实体类，一个是ClassRoom，一个是Student，这两者是一对多的关联关系。

ClassRoom类：
@Entity
@Table(name=”t_classroom”)
public class ClassRoom
{
private int id;
private String className;
private Set students; public ClassRoom()
{
students = new HashSet();
}

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

}

7 一对一映射(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;
}

}

注意:在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。

8 Many-to-Many映射(多对多映射关系)

多对多这里通常有两种处理方式，一种是通过建立一张中间表，然后由任一一个多的一方来维护关联关系，另一种就是将多对多拆分成两个一对多的关联关系

1.通过中间表由任一一个多的一方来维护关联关系

Teacher类：
@Entity
@Table(name=”t_teacher”)
public class Teacher
{
private int id;
private String name;
private Set 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 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 ars;
public Admin()
{
ars = new HashSet();
}
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 getArs()
{
return ars;
}
public void setArs(Set ars)
{
this.ars = ars;
}
}
Role类：
@Entity
@Table(name=”t_role”)
public class Role
{
private int id;
private String name;
private Set ars;
public Role()
{
ars = new HashSet();
}
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 getArs()
{
return ars;
}
public void setArs(Set 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);

第一次写这个东西，虽然大部分都是复制的，不过自己确实通过写理解了不少东西，如有不对，多多指教哈！

一年不洗澡-_-

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录