实体类中需要配置的spring注解 实体类常用注解

作为一名刚刚成为程序猿的我来说，对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; 
 }

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

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