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、一般使用默认就可以了