Hibernate----@Annotation----一对多----级联

一对多,双向,"一"的一方

 

Java代码  
  1. package com.pegasus.domain;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. import javax.persistence.CascadeType;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.FetchType;  
  9. import javax.persistence.GeneratedValue;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.JoinColumn;  
  12. import javax.persistence.OneToMany;  
  13. import javax.persistence.Table;  
  14.   
  15. //在实体类的类名前  
  16. //标注是实体  
  17. //对应的表名  
  18. //相当于xml的  
  19. //<class name="com.pegasus.domain.Group" table="t_group"></class>  
  20. @Entity  
  21. @Table(name="t_group")  
  22. public class Group {  
  23.     private int id;  
  24.     private String name;  
  25.     private Set<User> users = new HashSet<User>();  
  26.   
  27.     //在主键的get方法前  
  28.     //标注主键,以及生成主键策略  
  29.     //相当于<id name="id"><generator class="native"></generator></id>  
  30.     @Id  
  31.     @GeneratedValue  
  32.     public int getId() {  
  33.         return id;  
  34.     }  
  35.     public void setId(int id) {  
  36.         this.id = id;  
  37.     }  
  38.   
  39.     //在一般属性的get方法前  
  40.     //一般的列名前不需要标注  
  41.     //相当于<property name="name"></property>  
  42.     public String getName() {  
  43.         return name;  
  44.     }  
  45.     public void setName(String name) {  
  46.         this.name = name;  
  47.     }  
  48.   
  49.     //在一对多"一"的一方关联的集合前  
  50.     //使用@OneToMany标注,并标明"mappedBy",即关联的"多"的一方所对应的类的属性
  51. //mapped by 即 inverse=true 由多一方控制 

  52. mapped用于指定在双向关系中两个实体中被哪个实体是被关联处理的. 

    在你的department和employee的一对多关系中,当你指定department中的mappedBy后,你的关系只能被employee来主动维护.也就是employee级联的处理department.  
  53.     //cascade参数标明级联的方式,如果不需要级联可以省略  
  54.     //相当于<set name="users">  
  55.     //             <key column="groupId"></key>  
  56.     //             <one-to-many class="com.pegasus.domain.User"/>  
  57.         //         </set>  
  58.     @OneToMany(mappedBy="group",  
  59.         cascade={CascadeType.ALL}  
  60.         )  
  61.       
  62.     public Set<User> getUsers() {  
  63.         return users;  
  64.     }  
  65.     public void setUsers(Set<User> users) {  
  66.         this.users = users;  
  67.     }  
  68. }  

 

 一对多,双向,"多"的一方

 

Java代码  
  1. package com.pegasus.domain;  
  2.   
  3. import javax.persistence.CascadeType;  
  4. import javax.persistence.Entity;  
  5. import javax.persistence.FetchType;  
  6. import javax.persistence.GeneratedValue;  
  7. import javax.persistence.Id;  
  8. import javax.persistence.ManyToOne;  
  9. import javax.persistence.Table;  
  10. //在实体类的类名前  
  11. //标注是实体  
  12. //对应的表名  
  13. //相当于xml的  
  14. //<class name="com.pegasus.domain.User" table="t_user"></class>  
  15. @Entity  
  16. @Table(name="t_user")  
  17. public class User {  
  18.     private int id;  
  19.     private String name;  
  20.     private Group group;  
  21.       
  22.     //在主键的get方法前  
  23.     //标注主键,以及生成主键策略  
  24.     //相当于<id name="id"><generator class="native"></generator></id>  
  25.     @Id  
  26.     @GeneratedValue  
  27.     public int getId() {  
  28.         return id;  
  29.     }  
  30.     public void setId(int id) {  
  31.         this.id = id;  
  32.     }  
  33.       
  34.     //在一般属性的get方法前  
  35.     //一般的列名前不需要标注  
  36.     //相当于<property name="name"></property>  
  37.     public String getName() {  
  38.         return name;  
  39.     }  
  40.     public void setName(String name) {  
  41.         this.name = name;  
  42.     }  
  43.     //在一对多"多"的一方关联的属性get方法前  
  44.     //使用@ManyToOne标注  
  45.     //cascade参数标明级联的方式,如果不需要级联可以省略  
  46.     //相当于<many-to-one name="group" column="groupId"></many-to-one>  
  47.     @ManyToOne(cascade={CascadeType.ALL})  
  48.     public Group getGroup() {  
  49.         return group;  
  50.     }  
  51.     public void setGroup(Group group) {  
  52.         this.group = group;  
  53.     }  
  54. }  

 单元测试类

 

Java代码  
  1. package com.pegasus.domain;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.AnnotationConfiguration;  
  6. import org.hibernate.tool.hbm2ddl.SchemaExport;  
  7. import org.junit.AfterClass;  
  8. import org.junit.BeforeClass;  
  9. import org.junit.Test;  
  10.   
  11. public class HibernateORMappingTest {  
  12.     private static SessionFactory sessionFactory;  
  13.       
  14.     @BeforeClass  
  15.     public static void beforeClass() {  
  16.         new SchemaExport(new AnnotationConfiguration().configure()).create(falsetrue);  
  17.         sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();  
  18.     }  
  19.     @AfterClass  
  20.     public static void afterClass() {  
  21.         sessionFactory.close();  
  22.     }  
  23.     /**级联保存*/  
  24.     @Test  
  25.     public void testSaveUser() {  
  26.         System.out.print("begin to testSaveUser()");  
  27.         User u = new User();  
  28.         u.setName("u1");  
  29.         Group g = new Group();  
  30.         g.setName("g1");  
  31.         u.setGroup(g);  
  32.         Session s = sessionFactory.getCurrentSession();  
  33.         s.beginTransaction();  
  34.         //s.save(g);  
  35.         s.save(u);  
  36.         s.getTransaction().commit();  
  37.     }  
  38.       
  39. //  @Test  
  40. //  public void testSaveGroup() {  
  41. //      System.out.print("begin to testSaveGroup()");  
  42. //      User u1 = new User();  
  43. //      u1.setName("u1");  
  44. //      User u2 = new User();  
  45. //      u2.setName("u2");  
  46. //      Group g = new Group();  
  47. //      g.setName("g1");  
  48. //      g.getUsers().add(u1);  
  49. //      g.getUsers().add(u2);  
  50. //      u1.setGroup(g);  
  51. //      u2.setGroup(g);  
  52. //      Session s = sessionFactory.getCurrentSession();  
  53. //      s.beginTransaction();  
  54. //      s.save(g);  
  55. //      s.getTransaction().commit();  
  56. //  }  
  57.     /**级联查询*/  
  58.     @Test  
  59.     public void testGetUser() {  
  60.         System.out.print("begin to testGetUser()");  
  61. //      testSaveGroup();  
  62.           
  63.         Session s = sessionFactory.getCurrentSession();  
  64.         s.beginTransaction();  
  65.         User u = (User)s.get(User.class1);  
  66.           
  67.         s.getTransaction().commit();  
  68.         System.out.println(u.getGroup().getName());  
  69.     }  
  70.       
  71. //  @Test  
  72. //  public void testDeleteUser() {  
  73. //      System.out.print("begin to testDeleteUser()");    
  74. //      testSaveGroup();  
  75. //        
  76. //      Session s = sessionFactory.getCurrentSession();  
  77. //      s.beginTransaction();  
  78. //      //User u = (User)s.load(User.class, 1);  
  79. //      //u.setGroup(null);  
  80. //      //s.delete(u);  
  81. //      s.createQuery("delete from User u where u.id = 1").executeUpdate();  
  82. //      s.getTransaction().commit();  
  83. //        
  84. //  }  
  85.   
  86.     /**级联修改*/  
  87.     @Test  
  88.     public void testUpdateUser() {  
  89.         System.out.print("begin to testUpdateUser()");    
  90. //      testSaveGroup();  
  91.           
  92.         Session s = sessionFactory.getCurrentSession();  
  93.         s.beginTransaction();  
  94.         User u = (User)s.get(User.class1);  
  95.           
  96.         s.getTransaction().commit();  
  97.           
  98.         u.setName("user");  
  99.         u.getGroup().setName("group");  
  100.           
  101.         Session s2 = sessionFactory.getCurrentSession();  
  102.         s2.beginTransaction();  
  103.         s2.update(u);  
  104.           
  105.         s2.getTransaction().commit();  
  106.     }  
  107.       
  108.     /**级联删除*/  
  109.     @Test  
  110.     public void testDeleteGroup() {  
  111.         System.out.print("begin to testDeleteGroup()");   
  112.         testSaveGroup();  
  113.           
  114.         Session s = sessionFactory.getCurrentSession();  
  115.         s.beginTransaction();  
  116.         //User u = (User)s.load(User.class, 1);  
  117.         //u.setGroup(null);  
  118.         //s.delete(u);  
  119.         Group g = (Group)s.load(Group.class1);  
  120.         s.delete(g);  
  121.         //s.createQuery("delete from User u where u.id = 1").executeUpdate();  
  122.         s.getTransaction().commit();  
  123.           
  124.     }     
  125.       
  126.       
  127. //  @Test  
  128. //  public void testSchemaExport() {  
  129. //      new SchemaExport(new AnnotationConfiguration().configure()).create(true, true);  
  130. //  }  
  131.       
  132. //  public static void main(String[] args) {  
  133. //      beforeClass();  
  134. //  }  
  135. }  

 hibernate.cfg.xml

 

Xml代码  
  1. <?xml version='1.0' encoding='utf-8'?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  5.   
  6. <hibernate-configuration>  
  7.   
  8.     <session-factory>  
  9.   
  10.            
  11.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
  12.         <property name="connection.url">jdbc:mysql://localhost/hibtest</property>  
  13.         <property name="connection.username">root</property>  
  14.         <property name="connection.password">123</property>  
  15.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
  16.          
  17.         <!-- JDBC connection pool (use the built-in) -->  
  18.         <property name="connection.pool_size">1</property>  
  19.   
  20.         <!-- Enable Hibernate's automatic session context management -->  
  21.         <property name="current_session_context_class">thread</property>  
  22.   
  23.         <!-- Disable the second-level cache  -->  
  24.         <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>  
  25.   
  26.         <!-- Echo all executed SQL to stdout -->  
  27.         <property name="show_sql">true</property>  
  28.         <!-- <property name="format_sql">true</property> -->  
  29.   
  30.         <!-- Drop and re-create the database schema on startup  
  31.         <property name="hbm2ddl.auto">update</property>  
  32.          -->  
  33.         <!--    
  34.           
  35.         <mapping resource="com/pegasus/domain/Group.hbm.xml"/>  
  36.          <mapping resource="com/pegasus/domain/User.hbm.xml"/>  
  37.          -->  
  38.          <mapping class="com.pegasus.domain.Group"/>  
  39.         <mapping class="com.pegasus.domain.User"/>  
  40.           
  41.     </session-factory>  
  42.   
  43. </hibernate-configuration>  

你可能感兴趣的:(Hibernate----@Annotation----一对多----级联)