`

hibernate注解demo

 
阅读更多

用一个简单的例子，来记一下，hibernate的部分注解的使用和配置。我这里还是举出一些最常见的，如单向和双向的一对多，单向和双向的多对多。新建个Java工程，做测试类来说明，我打算这样干。

首先是单向的一对多，代码如下，先是两个实体类：

Java代码
  1. packagecn.serup.model;
  3. importjava.util.Set;
  5. importjavax.persistence.Entity;
  6. importjavax.persistence.GeneratedValue;
  7. importjavax.persistence.Id;
  8. importjavax.persistence.JoinColumn;
  9. importjavax.persistence.OneToMany;
  12. @Entity
  13. publicclassOrganization{
  15. privateintid;
  17. privateStringorgName;
  19. privateSet<Company>company;
  21. @OneToMany
  22. @JoinColumn(name="orgid")
  23. /**
  24. *一对多注解@OneToMany（单向）
  25. *如果只写@OneToMany的话，hibernate会建一张中间表来
  26. *维护他们之间的关系，
  27. *加上@JoinColumn(name="orgid")，则不会建中间表，他会在
  28. *多的一端加上外键orgid，来维护他们之间的关系
  29. */
  30. publicSet<Company>getCompany(){
  31. returncompany;
  32. }
  34. @Id
  35. @GeneratedValue
  36. publicintgetId(){
  37. returnid;
  38. }
  40. publicStringgetOrgName(){
  41. returnorgName;
  42. }
  44. publicvoidsetCompany(Set<Company>company){
  45. this.company=company;
  46. }
  48. publicvoidsetId(intid){
  49. this.id=id;
  50. }
  52. publicvoidsetOrgName(StringorgName){
  53. this.orgName=orgName;
  54. }
  55. }

Java代码
  1. packagecn.serup.model;
  3. importjavax.persistence.Entity;
  4. importjavax.persistence.GeneratedValue;
  5. importjavax.persistence.Id;
  7. @Entity
  8. publicclassCompany{
  10. privateintid;
  12. privateStringcompayName;
  14. @Id
  15. @GeneratedValue
  16. publicintgetId(){
  17. returnid;
  18. }
  20. publicvoidsetId(intid){
  21. this.id=id;
  22. }
  24. publicStringgetCompayName(){
  25. returncompayName;
  26. }
  28. publicvoidsetCompayName(StringcompayName){
  29. this.compayName=compayName;
  30. }
  31. }

然后，测试类代码如下：

Java代码
  1. packagecn.serup.hibernate.test;
  3. importjava.util.HashSet;
  4. importjava.util.Iterator;
  5. importjava.util.Set;
  7. importorg.hibernate.Session;
  8. importorg.hibernate.SessionFactory;
  9. importorg.hibernate.cfg.AnnotationConfiguration;
  10. importorg.hibernate.tool.hbm2ddl.SchemaExport;
  11. importorg.junit.AfterClass;
  12. importorg.junit.BeforeClass;
  13. importorg.junit.Test;
  15. importcn.serup.model.Company;
  16. importcn.serup.model.Organization;
  18. publicclassMany2One{
  20. privatestaticSessionFactorysessionFactory;
  22. @SuppressWarnings("unchecked")
  23. @Test
  24. publicvoidtestSaveOne2One(){
  25. Organizationo=newOrganization();
  26. o.setOrgName("谷度培训机构");
  28. Companyc=newCompany();
  29. c.setCompayName("广州分公司");
  31. Companyc1=newCompany();
  32. c1.setCompayName("成都分公司");
  34. Companyc2=newCompany();
  35. c2.setCompayName("天津分公司");
  37. Setset=newHashSet();
  38. set.add(c);
  39. set.add(c1);
  40. set.add(c2);
  42. o.setCompany(set);
  44. Sessionsession=sessionFactory.getCurrentSession();
  45. session.beginTransaction();
  47. session.save(o);
  48. session.save(c);
  49. session.save(c1);
  50. session.save(c2);
  52. session.beginTransaction().commit();
  53. }
  55. @SuppressWarnings("unchecked")
  56. @Test
  57. publicvoidtestLoadOne2One(){
  58. Sessionsession=sessionFactory.getCurrentSession();
  59. session.beginTransaction();
  61. Organizationo=(Organization)session.load(Organization.class,1);
  63. System.out.println(o.getId()+""+o.getOrgName());
  65. Setlist=o.getCompany();
  67. for(Iteratorit=list.iterator();it.hasNext();){
  68. Companyc=(Company)it.next();
  69. System.out.println(c.getId()+""+c.getCompayName());
  70. }
  72. session.beginTransaction().commit();
  73. }
  75. @Test
  76. publicvoidtestDeleteOne2One(){
  77. Sessionsession=sessionFactory.getCurrentSession();
  78. session.beginTransaction();
  80. //Companyc=(Company)session.load(Company.class,1);
  82. //session.delete(c);
  84. session.beginTransaction().commit();
  85. }
  87. @BeforeClass
  88. publicstaticvoidbeforeClass(){
  89. newSchemaExport(newAnnotationConfiguration().configure())
  90. .create(true,true);
  92. sessionFactory=newAnnotationConfiguration().configure()
  93. .buildSessionFactory();
  94. }
  96. @AfterClass
  97. publicstaticvoidafterClass(){
  98. sessionFactory.close();
  99. }
  101. }

最后是hibernate的cfg.xml配置，代码如下：

Xml代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <!DOCTYPEhibernate-configurationPUBLIC
  3. "-//Hibernate/HibernateConfigurationDTD3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6. <session-factory>
  7. <propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  8. <propertyname="hibernate.connection.password">123456</property>
  9. <propertyname="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
  10. <propertyname="hibernate.connection.username">root</property>
  11. <propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  12. <propertyname="show_sql">true</property>
  13. <!--独立线程运行，如果通过getCurrentSession()来获得Session，需要设置如下-->
  14. <propertyname="current_session_context_class">thread</property>
  15. <!--<propertyname="hibernate.hbm2ddl.auto">create</property>-->
  16. <!--映射持久化类-->
  18. <mappingclass="cn.serup.model.Company"/>
  19. <mappingclass="cn.serup.model.Organization"/>
  22. </session-factory>
  23. </hibernate-configuration>

以上则是单向的一对多，即company里有organization的对象，organization里没有其他关联对象。

下面就是双向的一对多，即company里有organization的对象，organization里有company的set。只需要修改上面的代码即可，实体类代码如下（就是修改一点点就可以了）：

Java代码
  1. packagecn.serup.model;
  3. importjava.util.Set;
  5. importjavax.persistence.Entity;
  6. importjavax.persistence.GeneratedValue;
  7. importjavax.persistence.Id;
  8. importjavax.persistence.JoinColumn;
  9. importjavax.persistence.OneToMany;
  12. @Entity
  13. publicclassOrganization{
  15. privateintid;
  17. privateStringorgName;
  19. privateSet<Company>company;
  22. @OneToMany(mappedBy="org")
  23. @JoinColumn(name="orgid")
  24. /**
  25. *一对多双向，在一的一端中设置mappedBy
  26. *说明多的一端为主导
  27. *如果指定了外键字段名称，则多的一端也需要指定相同的字段名称
  28. */
  29. publicSet<Company>getCompany(){
  30. returncompany;
  31. }
  33. publicvoidsetCompany(Set<Company>company){
  34. this.company=company;
  35. }
  37. publicStringgetOrgName(){
  38. returnorgName;
  39. }
  41. publicvoidsetOrgName(StringorgName){
  42. this.orgName=orgName;
  43. }
  45. @Id
  46. @GeneratedValue
  47. publicintgetId(){
  48. returnid;
  49. }
  51. publicvoidsetId(intid){
  52. this.id=id;
  53. }
  56. }

Java代码
  1. packagecn.serup.model;
  3. importjavax.persistence.Entity;
  4. importjavax.persistence.GeneratedValue;
  5. importjavax.persistence.Id;
  6. importjavax.persistence.JoinColumn;
  7. importjavax.persistence.ManyToOne;
  9. @Entity
  10. publicclassCompany{
  12. privateintid;
  14. privateStringcompayName;
  16. privateOrganizationorg;
  18. @ManyToOne
  19. @JoinColumn(name="orgid")
  20. /**
  21. *一对多双向
  22. *需要指定外键与一的一端给的外键名称一致，@JoinColumn(name="orgid")
  23. *也可以不指定，如果在多的一端不指定，则一的一端也不能指定
  24. *否则为生成两个外键
  25. */
  26. publicOrganizationgetOrg(){
  27. returnorg;
  28. }
  30. publicvoidsetOrg(Organizationorg){
  31. this.org=org;
  32. }
  34. @Id
  35. @GeneratedValue
  36. publicintgetId(){
  37. returnid;
  38. }
  40. publicvoidsetId(intid){
  41. this.id=id;
  42. }
  44. publicStringgetCompayName(){
  45. returncompayName;
  46. }
  48. publicvoidsetCompayName(StringcompayName){
  49. this.compayName=compayName;
  50. }
  53. }

单向的多对多的测试代码如下，至于hibernate的cfg.xml就不用变了：

Java代码
  1. packagecn.serup.hibernate.test;
  3. importjava.util.Iterator;
  4. importjava.util.Set;
  6. importorg.hibernate.Session;
  7. importorg.hibernate.SessionFactory;
  8. importorg.hibernate.cfg.AnnotationConfiguration;
  9. importorg.hibernate.tool.hbm2ddl.SchemaExport;
  10. importorg.junit.AfterClass;
  11. importorg.junit.BeforeClass;
  12. importorg.junit.Test;
  14. importcn.serup.model.Company;
  15. importcn.serup.model.Organization;
  17. publicclassMany2One{
  19. privatestaticSessionFactorysessionFactory;
  21. @Test
  22. publicvoidtestSaveOne2One(){
  23. Organizationo=newOrganization();
  24. o.setOrgName("谷度培训机构");
  26. Companyc=newCompany();
  27. c.setCompayName("广州分公司");
  28. c.setOrg(o);
  30. Companyc1=newCompany();
  31. c1.setCompayName("成都分公司");
  32. c1.setOrg(o);
  34. Companyc2=newCompany();
  35. c2.setCompayName("天津分公司");
  36. c2.setOrg(o);
  40. Sessionsession=sessionFactory.getCurrentSession();
  41. session.beginTransaction();
  43. session.save(o);
  44. session.save(c);
  45. session.save(c1);
  46. session.save(c2);
  48. session.beginTransaction().commit();
  49. }
  51. @SuppressWarnings("unchecked")
  52. @Test
  53. publicvoidtestLoadOne2One(){
  54. Sessionsession=sessionFactory.getCurrentSession();
  55. session.beginTransaction();
  57. Organizationo=(Organization)session.load(Organization.class,1);
  59. System.out.println(o.getId()+""+o.getOrgName());
  61. Setset=o.getCompany();
  63. for(Iteratorit=set.iterator();it.hasNext();){
  64. Companyc=(Company)it.next();
  65. System.out.println(c.getId()+""+c.getCompayName());
  66. }
  68. session.beginTransaction().commit();
  69. }
  71. @Test
  72. publicvoidtestDeleteOne2One(){
  73. Sessionsession=sessionFactory.getCurrentSession();
  74. session.beginTransaction();
  76. //Companyc=(Company)session.load(Company.class,1);
  78. //session.delete(c);
  80. session.beginTransaction().commit();
  81. }
  83. @BeforeClass
  84. publicstaticvoidbeforeClass(){
  85. newSchemaExport(newAnnotationConfiguration().configure())
  86. .create(true,true);
  88. sessionFactory=newAnnotationConfiguration().configure()
  89. .buildSessionFactory();
  90. }
  92. @AfterClass
  93. publicstaticvoidafterClass(){
  94. sessionFactory.close();
  95. }
  97. }

以上则是单向和双向的一对多的配置与测试。下面是单向和双向的多对多的配置和测试。

------------------------------------------------------------------------------------------------------------------------------------

单向的多对多，实体类代码如下：

Java代码
  1. packagecn.serup.model;
  3. importjava.util.HashSet;
  4. importjava.util.Set;
  6. importjavax.persistence.Entity;
  7. importjavax.persistence.GeneratedValue;
  8. importjavax.persistence.Id;
  9. importjavax.persistence.JoinColumn;
  10. importjavax.persistence.JoinTable;
  11. importjavax.persistence.ManyToMany;
  13. @Entity
  14. publicclassUser{
  16. privateintid;
  18. privateStringusername;
  20. privateSet<Role>role=newHashSet<Role>();
  22. @Id
  23. @GeneratedValue
  24. publicintgetId(){
  25. returnid;
  26. }
  28. publicvoidsetId(intid){
  29. this.id=id;
  30. }
  32. publicStringgetUsername(){
  33. returnusername;
  34. }
  36. publicvoidsetUsername(Stringusername){
  37. this.username=username;
  38. }
  40. @ManyToMany
  41. /**
  42. *多对多映射：注解@ManyToMany（单向）
  43. *默认情况下，hibernate会自动的创建一张中间表，
  44. *来维护多对多关系
  45. *默认中间表的名称：user_role中间表，字段的名称user_idrole_id
  46. *如果想更换表名和字段名称，注解如下：
  47. */
  48. @JoinTable(name="t_u_r",
  49. joinColumns={@JoinColumn(name="u_id")},
  50. inverseJoinColumns={@JoinColumn(name="r_id")}
  51. )
  52. publicSet<Role>getRole(){
  53. returnrole;
  54. }
  56. publicvoidsetRole(Set<Role>role){
  57. this.role=role;
  58. }
  61. }

Java代码
  1. packagecn.serup.model;
  4. importjavax.persistence.Entity;
  5. importjavax.persistence.GeneratedValue;
  6. importjavax.persistence.Id;
  8. @Entity
  9. publicclassRole{
  11. privateintid;
  13. privateStringroleName;
  15. /*privateSet<User>user=newHashSet<User>();
  17. @ManyToMany
  18. publicSet<User>getUser(){
  19. returnuser;
  20. }
  22. publicvoidsetUser(Set<User>user){
  23. this.user=user;
  24. }*/
  26. @Id
  27. @GeneratedValue
  28. publicintgetId(){
  29. returnid;
  30. }
  32. publicvoidsetId(intid){
  33. this.id=id;
  34. }
  36. publicStringgetRoleName(){
  37. returnroleName;
  38. }
  40. publicvoidsetRoleName(StringroleName){
  41. this.roleName=roleName;
  42. }
  44. }

测试类代码如下：

Java代码
  1. packagecn.serup.hibernate.test;
  3. importjava.util.HashSet;
  4. importjava.util.Iterator;
  5. importjava.util.Set;
  7. importorg.hibernate.Session;
  8. importorg.hibernate.SessionFactory;
  9. importorg.hibernate.cfg.AnnotationConfiguration;
  10. importorg.junit.AfterClass;
  11. importorg.junit.BeforeClass;
  12. importorg.junit.Test;
  14. importcn.serup.model.Role;
  15. importcn.serup.model.User;
  17. publicclassMany2ManyTest{
  19. privatestaticSessionFactorysessionFactory=null;
  21. @Test
  22. publicvoidtestSaveUR(){
  23. Roler1=newRole();
  24. r1.setRoleName("项目组长");
  26. Roler3=newRole();
  27. r3.setRoleName("项目经理");
  29. Roler2=newRole();
  30. r2.setRoleName("技术总监");
  33. Useru1=newUser();
  34. u1.setUsername("唐骏");
  36. Useru2=newUser();
  37. u2.setUsername("李开复");
  39. Useru3=newUser();
  40. u3.setUsername("柳传志");
  42. Set<Role>s1=newHashSet<Role>();
  43. s1.add(r1);
  44. s1.add(r3);
  46. Set<Role>s2=newHashSet<Role>();
  47. s2.add(r1);
  48. s2.add(r2);
  50. Set<Role>s3=newHashSet<Role>();
  51. s3.add(r1);
  52. s3.add(r2);
  53. s3.add(r3);
  55. u1.setRole(s1);
  56. u2.setRole(s2);
  57. u3.setRole(s3);
  59. Sessionsession=sessionFactory.getCurrentSession();
  60. session.beginTransaction().begin();
  62. session.save(r1);
  63. session.save(r2);
  64. session.save(r3);
  66. session.save(u1);
  67. session.save(u2);
  68. session.save(u3);
  70. session.beginTransaction().commit();
  71. }
  73. @Test
  74. publicvoidtestLoadUR(){
  75. Sessionsession=sessionFactory.getCurrentSession();
  76. session.beginTransaction().begin();
  78. Useru=(User)session.get(User.class,3);
  80. System.out.println("用户："+u.getUsername());
  82. Set<Role>s1=u.getRole();
  83. System.out.print("拥有职务：");
  84. for(Iterator<Role>it=s1.iterator();it.hasNext();){
  85. Roler=(Role)it.next();
  86. System.out.print("\t【"+r.getRoleName()+"】");
  87. }
  89. session.beginTransaction().commit();
  90. }
  93. @BeforeClass
  94. publicstaticvoidbeforeClass(){
  95. sessionFactory=newAnnotationConfiguration().configure().buildSessionFactory();
  96. }
  98. @AfterClass
  99. publicstaticvoidafterClass(){
  100. sessionFactory.close();
  101. }
  103. }

接下来是双向的多对多，实体类代码如下：

Java代码
  1. packagecn.serup.model;
  3. importjava.util.HashSet;
  4. importjava.util.Set;
  6. importjavax.persistence.Entity;
  7. importjavax.persistence.GeneratedValue;
  8. importjavax.persistence.Id;
  9. importjavax.persistence.JoinColumn;
  10. importjavax.persistence.JoinTable;
  11. importjavax.persistence.ManyToMany;
  13. @Entity
  14. publicclassUser{
  16. privateintid;
  18. privateStringusername;
  20. privateSet<Role>role=newHashSet<Role>();
  22. @Id
  23. @GeneratedValue
  24. publicintgetId(){
  25. returnid;
  26. }
  28. publicvoidsetId(intid){
  29. this.id=id;
  30. }
  32. publicStringgetUsername(){
  33. returnusername;
  34. }
  36. publicvoidsetUsername(Stringusername){
  37. this.username=username;
  38. }
  40. @ManyToMany
  41. /**
  42. *多对多映射：注解@ManyToMany（单向）
  43. *默认情况下，hibernate会自动的创建一张中间表，
  44. *来维护多对多关系
  45. *默认中间表的名称：user_role中间表，字段的名称u_idr_id
  46. *如果想更换表名和字段名称，注解如下：
  47. */
  48. @JoinTable(name="t_u_r",
  49. joinColumns={@JoinColumn(name="u_id")},
  50. inverseJoinColumns={@JoinColumn(name="r_id")}
  51. )
  52. /**
  53. *@JoinTable(name="t_u_r",
  54. *指定中间表的表名
  55. *joinColumns={@JoinColumn(name="u_id")},
  56. *指定当前对象的外键
  57. *inverseJoinColumns={@JoinColumn(name="r_id")}
  58. *指定关联对象的外键
  59. */
  61. publicSet<Role>getRole(){
  62. returnrole;
  63. }
  65. publicvoidsetRole(Set<Role>role){
  66. this.role=role;
  67. }
  70. }

Java代码
  1. packagecn.serup.model;
  4. importjava.util.HashSet;
  5. importjava.util.Set;
  7. importjavax.persistence.Entity;
  8. importjavax.persistence.GeneratedValue;
  9. importjavax.persistence.Id;
  10. importjavax.persistence.ManyToMany;
  12. @Entity
  13. publicclassRole{
  15. privateintid;
  17. privateStringroleName;
  19. privateSet<User>user=newHashSet<User>();
  21. @ManyToMany(mappedBy="role")
  22. /**
  23. *多对多,双向关联映射
  24. */
  25. publicSet<User>getUser(){
  26. returnuser;
  27. }
  29. publicvoidsetUser(Set<User>user){
  30. this.user=user;
  31. }
  33. @Id
  34. @GeneratedValue
  35. publicintgetId(){
  36. returnid;
  37. }
  39. publicvoidsetId(intid){
  40. this.id=id;
  41. }
  43. publicStringgetRoleName(){
  44. returnroleName;
  45. }
  47. publicvoidsetRoleName(StringroleName){
  48. this.roleName=roleName;
  49. }
  51. }

测试代码如下：

Java代码
  1. packagecn.serup.hibernate.test;
  3. importjava.util.HashSet;
  4. importjava.util.Iterator;
  5. importjava.util.Set;
  7. importorg.hibernate.Session;
  8. importorg.hibernate.SessionFactory;
  9. importorg.hibernate.cfg.AnnotationConfiguration;
  10. importorg.junit.AfterClass;
  11. importorg.junit.BeforeClass;
  12. importorg.junit.Test;
  14. importcn.serup.model.Role;
  15. importcn.serup.model.User;
  17. publicclassMany2ManyTest{
  19. privatestaticSessionFactorysessionFactory=null;
  21. publicvoidtestSaveUR(){
  22. Roler1=newRole();
  23. r1.setRoleName("项目组长");
  25. Roler3=newRole();
  26. r3.setRoleName("项目经理");
  28. Roler2=newRole();
  29. r2.setRoleName("技术总监");
  32. Useru1=newUser();
  33. u1.setUsername("唐骏");
  35. Useru2=newUser();
  36. u2.setUsername("李开复");
  38. Useru3=newUser();
  39. u3.setUsername("柳传志");
  41. Set<Role>s1=newHashSet<Role>();
  42. s1.add(r1);
  43. s1.add(r3);
  45. Set<Role>s2=newHashSet<Role>();
  46. s2.add(r1);
  47. s2.add(r2);
  49. Set<Role>s3=newHashSet<Role>();
  50. s3.add(r1);
  51. s3.add(r2);
  52. s3.add(r3);
  54. u1.setRole(s1);
  55. u2.setRole(s2);
  56. u3.setRole(s3);
  58. Sessionsession=sessionFactory.getCurrentSession();
  59. session.beginTransaction().begin();
  61. session.save(r1);
  62. session.save(r2);
  63. session.save(r3);
  65. session.save(u1);
  66. session.save(u2);
  67. session.save(u3);
  69. session.beginTransaction().commit();
  70. }
  72. @Test
  73. publicvoidtestLoadUR(){
  74. Sessionsession=sessionFactory.getCurrentSession();
  75. session.beginTransaction().begin();
  77. Useru=(User)session.get(User.class,3);
  79. System.out.println("用户："+u.getUsername());
  81. Set<Role>s1=u.getRole();
  82. System.out.print("拥有职务：");
  83. for(Iterator<Role>it=s1.iterator();it.hasNext();){
  84. Roler=(Role)it.next();
  85. System.out.print("\t【"+r.getRoleName()+"】");
  86. }
  88. session.beginTransaction().commit();
  89. }
  91. @Test
  92. publicvoidtestLoadRU(){
  93. Sessionsession=sessionFactory.getCurrentSession();
  94. session.beginTransaction().begin();
  96. Roler=(Role)session.get(Role.class,1);
  98. System.out.println("职务："+r.getRoleName());
  100. Set<User>s1=r.getUser();
  101. System.out.print("谁拥有该职务：");
  102. for(Iterator<User>it=s1.iterator();it.hasNext();){
  103. Useru=(User)it.next();
  104. System.out.print("\t【"+u.getUsername()+"】");
  105. }
  107. session.beginTransaction().commit();
  108. }
  111. @BeforeClass
  112. publicstaticvoidbeforeClass(){
  113. sessionFactory=newAnnotationConfiguration().configure().buildSessionFactory();
  114. }
  116. @AfterClass
  117. publicstaticvoidafterClass(){
  118. sessionFactory.close();
  119. }
  121. }

以上，就是双向的多对多的配置和测试。还有的，就是一些别的属性的配置，如级联啊，fetch策略之类的。

级联（cascade）属性
1、CascadeType.ALL（包括增、删、改、查，联动操作），其实查不算在内，查Fetch
2、CascadeType.MERGE（合并的join）--不重要
3、CascadeType.PERSIST（保存的时候在级联）
4、CascadeType.REFRESH（刷新说明：比如现在我查询出了数据，另外一个人在我查询数据之后，他对数据做了修改，这是才会级联上，hibernate会自动刷新我查询出来的数据）
5、CascadeType.REMOVE （只要在删除操作时才会级联）
6、我们一般都只设置CascadeType.ALL就OK了，
7、Cascade不是必须的，他的作用只是可以让我们快速的开发，我们也可以通过手动增、删、改、查

Fetch捉取策略
1、FetchType.EAGER（渴望的，希望马上得到）
a) 一对多关系，比如通过get()方法来get出一的一端，他只会出一条SQL语句，不会自动去查询多的一端，如果设置FetchType.EAGER，会讲他的关联对象查询出来
b) 如果是load的话，他不会发出SQL语句，因为load支持延迟加载，只有真正获取数据时才会发SQL
2、FetchType.LAZY（懒加载）
a) 只有真正获取数据时才发出SQL语句
3、默认是：FetchType.LAZY（一对多）
4、默认是：FetchType.EAGER（多对一）
5、一般使用默认就可以了

分享到：
| hibernate注解demo
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springmvc spring hibernate整合Demo

    4. 创建实体类：定义与数据库表对应的Java类，使用Hibernate的注解（如@Entity、@Table、@Id等）进行ORM映射。 5. 定义DAO：创建数据访问对象（DAO）接口，包含CRUD操作。这些接口通常由Spring管理，通过代理模式...

    springmvc+hibernate注解框架整合 demo

    这个"springmvc+hibernate注解框架整合 demo"是一个示例项目，展示了如何通过注解方式将这两个框架无缝集成。 **Spring MVC 框架** Spring MVC 是 Spring 框架的一部分，它提供了处理HTTP请求、转发响应以及管理...

    HibernateDemo

    【标题】"HibernateDemo"是一个基于Java的开源对象关系映射框架示例，它用于简化数据库操作。这个压缩包提供了一个简单的入门项目，帮助初学者理解如何使用Hibernate框架。通过这个例子，我们可以深入学习Hibernate...

    springMvc+hibernate Demo

    这个 "springMvc+hibernate Demo" 压缩包文件很可能是为了展示如何将这两个框架整合在一起，创建一个完整的数据驱动的 Web 应用。 **Spring MVC 框架** Spring MVC 是 Spring 框架的一部分，设计用于构建可维护、松...

    spring3.2 hibernate4 demo CRUD 完整例子

    在本示例中，我们探讨的是一个基于...总之，这个“spring3.2 hibernate4 demo CRUD”实例提供了一个完整的、实战性的学习平台，帮助开发者快速上手Spring和Hibernate的整合，理解如何在Java Web开发中有效地管理数据。

    hibernate+maven demo项目工程

    【hibernate+maven demo项目工程】是一个基于Hibernate ORM框架和Maven构建工具的示例项目，旨在帮助开发者理解和实践如何在实际开发中整合这两项技术。该项目的主要目的是展示如何利用Maven管理依赖，以及如何配置...

    Springmvc+hibernate整合Demo

    在这个“Springmvc+hibernate整合Demo”中，我们将会探讨如何将这两个框架结合在一起，以创建一个功能丰富的客户关系管理（CRM）系统。 **Spring MVC 框架** Spring MVC 是 Spring 框架的一部分，提供了一个用于...

    hibernate validator demo

    - **约束注解**: Hibernate Validator 提供了一系列的预定义注解，如 `@NotNull`、`@Size`、`@Pattern` 等，用于在字段上声明验证规则。 - **验证器**: 验证器是执行验证逻辑的组件，它会根据注解上的规则检查对象的...

    spring+hibernate整合demo

    标题"spring+hibernate整合demo"表明这是一个示例项目，展示了如何将Spring和Hibernate这两个框架结合使用。整合Spring和Hibernate可以使应用程序更易于管理，因为Spring可以控制Hibernate的生命周期，并提供事务...

    spring+hibernate框架demo

    这个"spring+hibernate框架demo"提供了一个整合这两个框架的小项目，便于初学者理解和学习。 Spring 框架： 1. **依赖注入**：Spring 的核心特性之一，它允许通过配置文件或注解来管理对象及其依赖关系，降低了组件...

    Hibernate简单的demo

    1. **实体（Entity）**: 在Hibernate中，实体通常对应数据库中的表，它们是Java类，通过注解或XML配置与数据库表进行映射。 2. **对象关系映射（ORM）**: Hibernate 提供了ORM工具，将Java对象与数据库表之间的映射...

    springMVC+hibernate搭建的一个demo帮助新人

    这个“springMVC+hibernate搭建的一个demo”旨在为初学者提供一个快速入门的实例，帮助他们理解和配置这些技术的集成环境。 SpringMVC是Spring框架的一部分，它提供了处理HTTP请求、管理控制器、数据绑定、视图解析...

    hibernate基础demo

    总结起来，"hibernate基础demo"是一个关于如何使用Hibernate框架的教程，特别是通过注解的方式来简化数据库操作。它涵盖了Hibernate的基本配置、实体类的注解映射、会话工厂和会话的使用、以及查询和事务管理等核心...

    Hibernate注解、注释大全

    《Hibernate注解详解》 Hibernate 是一款强大的Java对象关系映射（ORM）框架，它极大地简化了数据库操作。在Hibernate中，注解是用于描述Java类及其属性如何映射到数据库表的重要工具。本文将全面解析Hibernate中的...

    hibernate框架demo

    在“hibernate框架demo”项目中，开发者可能已经创建了一个简单的Java应用，演示了如何使用Hibernate进行数据操作。通过查看源代码，你可以学习到如何配置SessionFactory，如何创建和管理Session，以及如何执行基本...

    hibernateDemo.rar

    在本项目中，"hibernateDemo.rar" 是一个压缩包，包含了一个使用Spring Boot、JPA、Hibernate和Redis构建的示例应用。这个项目旨在展示如何整合这些技术来实现高效的数据存储和缓存管理。以下是对每个组件的详细解释...

    sping hibernate Annotation(注释配置) demo（例子）

    本文将深入探讨如何结合 Spring 的注解配置与 Hibernate 实现数据持久化，通过一个实际的 demo 示例来阐述整个过程。 首先，Spring 框架以其依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented ...

    hibernateSearch+demo

    这个“hibernateSearch+demo”项目提供了一个实战示例，帮助开发者理解并应用 Hibernate Search 的核心概念和功能。 在 Hibernate Search 中，主要涉及以下关键知识点： 1. **全文索引**：Hibernate Search 使用 ...

    hibernate的demo

    【hibernate的demo】 在Java开发中，Hibernate是一个非常重要的对象关系映射（ORM）框架，它极大地简化了数据库操作。本demo旨在提供一个基本的Hibernate使用示例，帮助理解其核心概念和功能。 一、Hibernate概述 ...

Magicbox
Global site tag (gtag.js) - Google Analytics