SSH——hibernate 利用注解实现实体关联映射详解

来源:互联网 发布:java写爬虫很复杂吗 编辑:程序博客网 时间:2024/06/06 18:40

原文:http://blog.csdn.net/daybreak1209/article/details/49447879

一、JPA:

JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中实现数据持久化。同时,它还是JCP 组织发布的 Java EE 标准之一,因此任何声称符合 JPA 标准的框架都遵循同样的架构hibernate 从3.2开始,就开始兼容JPA也就是说,除了通过配置xml实现实体关系映射,创建数据库表结构,还有一种更简易的办法,那就是使用注解。

二、搭建hibernate annotation 环境:

     搭建利用注解进行实体映射的环境,就是在普通hibernate应用中,多引入有关annotation的jar包即可。所以首先还是引入jar,然后配置hibernate.cfg,xml文件,将使用注解的实体路径通过<mapping class=””>配至到xml文件中。具体jar包如下:

       * HIBERNATE_HOME/lib/*.jar       --hibernate home lib下所有jar包

       * HIBERNATE_HOME/hibernate3.jar  --hibernate核心jar

       * 加入数据库驱动(MySQL驱动)

       * hibernate-annotations.jar      --3个hibernate annotation支持包

       * ejb3-persistence.jar

       * hibernate-commons-annotations.jar

三、实体关联关系通过注解的实现:

1、1:n  hibernate JPA一对多关联映射

[java] view plain copy
  1. @Entity  //该实体利用注解进行映射  
  2. @Table(name="t_student")  //指定实体对应的数据库名称  
  3. public class Student {  
  4.     private int id;   
  5.     private Classes classes;  
  6.       
  7.     @Id  //get方法指定主键      
  8.     @GeneratedValue   //相当于@GeneratedValue(strategy=GenerationType.AUTO)id生成策略相当于hibernate中的native    
  9.     public int getId() {  
  10.         return id;  
  11.     }  
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.     @ManyToOne           //多的一端加入关联关键 ,  
  16.     @JoinColumn(name="classesid")  
  17.     public Classes getClasses() {  
  18.         return classes;  
  19.     }  
  20.     public void setClasses(Classes classes) {  
  21.         this.classes = classes;  
  22.     }  
  23. }  
[java] view plain copy
  1. //1端:  
  2. @Entity  
  3. @Table(name="t_classes")  
  4. public class Classes {  
  5.       
  6.     private int id;   
  7.     private Set students;  
  8.   
  9.     @Id @GeneratedValue  
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.   
  14.     public void setId(int id) {  
  15.         this.id = id;  
  16.     }  
  17.     //mappedBy在哪一端,哪一端就不维护关系,它成为了关系的被管理端  
  18.     //向当于hibernate中的inverse=true  
  19.     //如果采用了泛型,可以不用采用targetEntity属性  
  20.     @OneToMany(mappedBy="classes",targetEntity=Student.class)  
  21.     @JoinColumn(name="classesid") //关联外键的名称==students 端外键名方可进行关联  
  22.     public Set getStudents() {  
  23.         return students;  
  24.     }  
  25.   
  26.     public void setStudents(Set students) {  
  27.         this.students = students;  
  28.     }  

2、n:1  hibernate JPA多对一关联映射


[java] view plain copy
  1. @Entity  
  2. @Table(name="t_user")  
  3. public class User {  
  4.   
  5.     private int id;  
  6.     private Group group;  
  7.       
  8.     @Id  
  9.     @GeneratedValue  
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.   
  14.     public void setId(int id) {  
  15.         this.id = id;  
  16.     }  
  17.     @ManyToOne   //多的一端采用manytoOne ,<span style="font-family:微软雅黑;">JPA会采用关联对象+"_" + "id"方式作为字段加入表中,故会在t_student表加入group_id负责关联</span>  
  18.     public Group getGroup() {  
  19.         return group;  
  20.     }  
  21.   
  22.     public void setGroup(Group group) {  
  23.         this.group = group;  
  24.     }  
  25. }  
  26.   
  27. @Entity  
  28. @Table(name="t_group")  
  29. public class Group {  
  30.     private int id;  
  31.   
  32.     @Id  
  33.     @GeneratedValue  
  34.     public int getId() {  
  35.         return id;  
  36.     }  
  37.     public void setId(int id) {  
  38.         this.id = id;  
  39.     }  
  40. }  

3、n:n hibernate jpa 多对多关联映射

[java] view plain copy
  1. @Entity  
  2. @Table(name="t_user")  
  3. public class User {   
  4.     private int id;   
  5.     private Set<Role> roles;  
  6.       
  7.     @Id @GeneratedValue  
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.     public void setId(int id) {  
  12.         this.id = id;  
  13.     }  
  14.     //因为集合使用泛型所以不再使用targetEntity来指定类型  
  15.     @ManyToMany   
  16.     @JoinTable( //采用@JoinTable指定第三方表的名称  
  17.             name="t_user_role",  
  18.             joinColumns={@JoinColumn(name="user_id")},  
  19.             inverseJoinColumns={@JoinColumn(name="role_id")}  
  20.     )  
  21.     public Set<Role> getRoles() {  
  22.         return roles;  
  23.     }  
  24.     public void setRoles(Set<Role> roles) {  
  25.         this.roles = roles;  
  26.     }  
  27. }  
  28.   
  29. @Entity  
  30. @Table(name="t_role")  
  31. public class Role {  
  32.     private int id;       
  33.     private Set<User> users;  
  34.       
  35.     @Id @GeneratedValue  
  36.     public int getId() {  
  37.         return id;  
  38.     }  
  39.     public void setId(int id) {  
  40.         this.id = id;  
  41.     }  
  42.       
  43.     @ManyToMany(mappedBy="roles")  //mappedBy通过对方(User对象)来管理关联关系  
  44.     public Set<User> getUsers() {  
  45.         return users;  
  46.     }  
  47.     public void setUsers(Set<User> users) {  
  48.         this.users = users;  
  49.     }  
  50. }  
4、继承——三个创建表机制--三种注解方法

 1、单表继承——子类生成两张表,利用鉴别字段 鉴别子类

[java] view plain copy
  1. @Entity  
  2. @Table(name="t_animal")  
  3. @Inheritance(strategy=InheritanceType.SINGLE_TABLE)  
  4. @DiscriminatorColumn(name="type",discriminatorType=DiscriminatorType.STRING)  
  5. public class Animal {  
  6.     private int id;   
  7.     private String name;  
  8.     private boolean sex;  
  9.   
  10.     @Id  
  11.     @GeneratedValue  
  12.     public int getId() {  
  13.         return id;  
  14.     }  
  15.     //省略get set 方法  
  16. }  
  17.   
  18. @Entity  
  19. @DiscriminatorValue(value="B")  
  20. public class Bird extends Animal {  
  21.     private int height;  
  22.     //省略get set 方法  
  23. }  
  24.   
  25. @Entity  
  26. @DiscriminatorValue(value="P")  
  27. public class Pig extends Animal {  
  28.     private int weight;  
  29.     //省略get set 方法   
  30. }  

2、具体表继承:共生成三张表,animal为公用属性表,bird 和pig 表存储各自特殊属性。

[java] view plain copy
  1. @Entity  
  2. @Table(name="t_animal")  
  3. @Inheritance(strategy=InheritanceType.JOINED)  
  4. public class Animal {  
  5.     private int id;   
  6.     private String name;      
  7.     private boolean sex;  
  8.     @Id  
  9.     @GeneratedValue  
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13. //省略get set   
  14. }  
  15.   
  16. @Entity  
  17. public class Bird extends Animal {  
  18.     private int height;  
  19.     //省略get set   
  20. }  
  21.   
  22. @Entity  
  23. public class Pig extends Animal {  
  24.   
  25.     private int weight;  
  26.     //省略get set  
  27. }  

3、类表继承:两张子类表,存储各自所有属性字段

[java] view plain copy
  1. @Entity  
  2. @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)  
  3. public class Animal {  
  4.     private int id;   
  5.     private String name;      
  6.     private boolean sex;  
  7.     @Id  
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.     //省略get set  
  12. }  
  13.   
  14. @Entity  
  15. public class Bird extends Animal {  
  16.     private int height;  
  17. }  
  18.   
  19. @Entity  
  20. public class Pig extends Animal {  
  21.     private int weight;  
  22.     //省略get set  
  23. }  

通过使用注解,取代了每个实体配置xml,使用标签创建关联,很大程度上减少了编码的数量,使得配置实体映射方便简洁,同时,注解的使用不仅体现在实体映射的创建,同时还体现在junit测试、SSH框架的整合,在项目的各个地方均可使用注解达到简化代码的作用,符合标准所以处处适用,简单易集成。


原创粉丝点击