BlogJava-业精于勤荒于嬉，行成于思毁于随-文章分类-ORMFramework

温故知新:hibernate_13_常用HQL

都较瘦 — Wed, 21 Jan 2015 06:13:00 GMT

摘要: 通过hibernate进行数据的查询，一般会采用HQL语句，HQL是将数据表对象化的查询语言，和SQL类似，但却是通过面向对象的方式去书写，更易于理解。写一个测试类，将一般情况下会用到的HQL写法记录下来。Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--... 阅读全文

都较瘦 2015-01-21 14:13 发表评论

温故知新:hibernate_12_表关联_多对多双向关联（注解配置）

都较瘦 — Wed, 21 Jan 2015 03:22:00 GMT

和基于配置的多对多双向关联大体一致，修改实体类，添加注解，更改hibernate.cfg.xml，引入实体类
只列出实体类的变动
Course

1 package domain;
2
3 import java.util.Set;
4
5 import javax.persistence.Entity;
6 import javax.persistence.GeneratedValue;
7 import javax.persistence.Id;
8 import javax.persistence.OneToMany;
9 import javax.persistence.Table;
10
11 @Entity
12 @Table(name="t_course")
13 public class Course {
14
15     private int id;
16     private String name;
17
18     private Set studentCourses;
19
20     public Course() {
21         super();
22     }
23
24     public Course(int id, String name, Set studentCourses) {
25         super();
26         this.id = id;
27         this.name = name;
28         this.studentCourses = studentCourses;
29     }
30
31     @Id
32     @GeneratedValue
33     public int getId() {
34         return id;
35     }
36
37     public void setId(int id) {
38         this.id = id;
39     }
40
41     public String getName() {
42         return name;
43     }
44
45     public void setName(String name) {
46         this.name = name;
47     }
48
49     @OneToMany(mappedBy="course")
50     public Set getStudentCourses() {
51         return studentCourses;
52     }
53
54     public void setStudentCourses(Set studentCourses) {
55         this.studentCourses = studentCourses;
56     }
57
58 }
59

Student

1 package domain;
2
3 import java.util.Set;
4
5 import javax.persistence.Entity;
6 import javax.persistence.GeneratedValue;
7 import javax.persistence.Id;
8 import javax.persistence.OneToMany;
9 import javax.persistence.Table;
10
11 @Entity
12 @Table(name="t_student")
13 public class Student {
14
15     private int id;
16     private String name;
17
18     private Set studentCourses;
19
20     public Student() {
21         super();
22     }
23
24     public Student(int id, String name, Set studentCourses) {
25         super();
26         this.id = id;
27         this.name = name;
28         this.studentCourses = studentCourses;
29     }
30
31     @Id
32     @GeneratedValue
33     public int getId() {
34         return id;
35     }
36
37     public void setId(int id) {
38         this.id = id;
39     }
40
41     public String getName() {
42         return name;
43     }
44
45     public void setName(String name) {
46         this.name = name;
47     }
48
49     @OneToMany(mappedBy="student")
50     public Set getStudentCourses() {
51         return studentCourses;
52     }
53
54     public void setStudentCourses(Set studentCourses) {
55         this.studentCourses = studentCourses;
56     }
57
58 }
59

StudentCourse

1 package domain;
2
3 import javax.persistence.Entity;
4 import javax.persistence.GeneratedValue;
5 import javax.persistence.Id;
6 import javax.persistence.JoinColumn;
7 import javax.persistence.ManyToOne;
8 import javax.persistence.Table;
9
10 @Entity
11 @Table(name="t_student_course")
12 public class StudentCourse {
13
14     private int id;
15     private int point;
16
17     private Student student;
18     private Course course;
19     public StudentCourse() {
20         super();
21     }
22     public StudentCourse(int id, int point, Student student, Course course) {
23         super();
24         this.id = id;
25         this.point = point;
26         this.student = student;
27         this.course = course;
28     }
29
30     @Id
31     @GeneratedValue
32     public int getId() {
33         return id;
34     }
35     public void setId(int id) {
36         this.id = id;
37     }
38     public int getPoint() {
39         return point;
40     }
41     public void setPoint(int point) {
42         this.point = point;
43     }
44
45     @ManyToOne
46     @JoinColumn(name="sid")
47     public Student getStudent() {
48         return student;
49     }
50     public void setStudent(Student student) {
51         this.student = student;
52     }
53     @ManyToOne
54     @JoinColumn(name="cid")
55     public Course getCourse() {
56         return course;
57     }
58     public void setCourse(Course course) {
59         this.course = course;
60     }
61
62 }
63

都较瘦 2015-01-21 11:22 发表评论

温故知新:hibernate_11_表关联_一对一双向关联（注解配置）

都较瘦 — Wed, 21 Jan 2015 03:03:00 GMT

和基于配置的一对一双向关联大体一致，修改实体类，添加注解，更改hibernate.cfg.xml，引入实体类
只列出实体类的变动
Card

1 package domain;
2
3 import javax.persistence.Entity;
4 import javax.persistence.GeneratedValue;
5 import javax.persistence.Id;
6 import javax.persistence.JoinColumn;
7 import javax.persistence.OneToOne;
8 import javax.persistence.Table;
9
10 @Entity
11 @Table(name="t_card")
12 public class Card {
13
14     private int id;
15     private String no;
16     private Person person;
17
18     public Card() {
19         super();
20     }
21
22     public Card(int id, String no, Person person) {
23         super();
24         this.id = id;
25         this.no = no;
26         this.person = person;
27     }
28
29     @Id
30     @GeneratedValue
31     public int getId() {
32         return id;
33     }
34     public void setId(int id) {
35         this.id = id;
36     }
37     public String getNo() {
38         return no;
39     }
40     public void setNo(String no) {
41         this.no = no;
42     }
43     @OneToOne
44     @JoinColumn(name="pid")
45     //设置外键名称
46     public Person getPerson() {
47         return person;
48     }
49     public void setPerson(Person person) {
50         this.person = person;
51     }
52
53 }
54

Person

1 package domain;
2
3 import javax.persistence.Entity;
4 import javax.persistence.GeneratedValue;
5 import javax.persistence.Id;
6 import javax.persistence.OneToOne;
7 import javax.persistence.Table;
8
9 @Entity
10 @Table(name="t_person")
11 public class Person {
12
13     private int id;
14     private String name;
15     private Card card;
16
17     public Person() {
18         super();
19     }
20
21     public Person(int id, String name, Card card) {
22         super();
23         this.id = id;
24         this.name = name;
25         this.card = card;
26     }
27
28     @Id
29     @GeneratedValue
30     public int getId() {
31         return id;
32     }
33     public void setId(int id) {
34         this.id = id;
35     }
36     public String getName() {
37         return name;
38     }
39     public void setName(String name) {
40         this.name = name;
41     }
42     @OneToOne(mappedBy="person")
43     //关系控制交由对方
44     public Card getCard() {
45         return card;
46     }
47     public void setCard(Card card) {
48         this.card = card;
49     }
50
51 }
52

都较瘦 2015-01-21 11:03 发表评论

温故知新:hibernate_10_表关联_多对一双向关联（注解配置）

都较瘦 — Wed, 21 Jan 2015 02:41:00 GMT

和基于配置文件的多对一双向关联大体一致，测试类无需变动，撤销XML的配置文件，将hibernate.cfg.xml中hbm的引入换成class的引入，如下

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 <hibernate-configuration>
6     <session-factory name="sessionFactory">
7         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>
8         <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_beginproperty>
9         <property name="hibernate.connection.username">rootproperty>
10         <property name="hibernate.connection.password">rootproperty>
11         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialectproperty>
12         <property name="hibernate.hbm2ddl.auto">updateproperty>
13         <property name="show_sql">trueproperty>
14
17         <mapping class="domain.Student"/>
18         <mapping class="domain.Teacher"/>
19     session-factory>
20 hibernate-configuration>
21

同时为相关的实体类添加注解
Student

1 package domain;
2
3 import javax.persistence.Entity;
4 import javax.persistence.GeneratedValue;
5 import javax.persistence.Id;
6 import javax.persistence.JoinColumn;
7 import javax.persistence.ManyToOne;
8 import javax.persistence.Table;
9
10 @Entity
11 @Table(name="t_student")
12 public class Student {
13
14     private int id;
15     private String name;
16     private String grade;
17     private Teacher teacher;
18
19     public Student() {
20         super();
21     }
22
23     public Student(String name, String grade, Teacher teacher) {
24         super();
25         this.name = name;
26         this.grade = grade;
27         this.teacher = teacher;
28     }
29
30     //设置自增主键
31     @Id
32     @GeneratedValue
33     public int getId() {
34         return id;
35     }
36     public void setId(int id) {
37         this.id = id;
38     }
39     public String getName() {
40         return name;
41     }
42     public void setName(String name) {
43         this.name = name;
44     }
45     public String getGrade() {
46         return grade;
47     }
48     public void setGrade(String grade) {
49         this.grade = grade;
50     }
51
52     //为实体类添加映射和外键
53     @ManyToOne
54     @JoinColumn(name="tid")
55     public Teacher getTeacher() {
56         return teacher;
57     }
58     public void setTeacher(Teacher teacher) {
59         this.teacher = teacher;
60     }
61
62 }
63

Teacher

1 package domain;
2
3 import java.util.Set;
4
5 import javax.persistence.Entity;
6 import javax.persistence.GeneratedValue;
7 import javax.persistence.Id;
8 import javax.persistence.OneToMany;
9 import javax.persistence.Table;
10
11 import org.hibernate.annotations.LazyCollection;
12 import org.hibernate.annotations.LazyCollectionOption;
13
14 @Entity
15 @Table(name="t_teacher")
16 public class Teacher {
17
18     private int id;
19     private String name;
20     private String course;
21     private Set studs;
22
23     public Teacher() {
24         super();
25     }
26
27     public Teacher(String name, String course) {
28         super();
29         this.name = name;
30         this.course = course;
31     }
32
33     @Id
34     @GeneratedValue
35     public int getId() {
36         return id;
37     }
38     public void setId(int id) {
39         this.id = id;
40     }
41     public String getName() {
42         return name;
43     }
44     public void setName(String name) {
45         this.name = name;
46     }
47     public String getCourse() {
48         return course;
49     }
50     public void setCourse(String course) {
51         this.course = course;
52     }
53
54     //mappedBy就意为将关系维护给到对方的teacher属性，相当于inverse=true
55     @OneToMany(mappedBy = "teacher")
56     //LazyCollectionOption.EXTRA相当于lazy="extra"
57     @LazyCollection(LazyCollectionOption.EXTRA)
58     public Set getStuds() {
59         return studs;
60     }
61
62     public void setStuds(Set studs) {
63         this.studs = studs;
64     }
65
66 }
67

都较瘦 2015-01-21 10:41 发表评论

温故知新:hibernate_09_表关联_多对多双向关联

都较瘦 — Wed, 21 Jan 2015 02:09:00 GMT

多对多双向关联比较麻烦，一般添加第三个表变为两个多对一进行处理，以学生和课程之间的关系为例，实体类和配置如下
Course

1 package domain;
2
3 import java.util.Set;
4
5 public class Course {
6
7     private int id;
8     private String name;
9
10     private Set studentCourses;
11
12     //get/set和构造省略，但实际不可省略
13
14 }
15

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4 <hibernate-mapping>
5     <class name="domain.Course" table="COURSE">
6         <id name="id" type="int">
7             <column name="ID" />
8             <generator class="native" />
9         id>
10         <property name="name" type="java.lang.String">
11             <column name="NAME" />
12         property>
13         <set name="studentCourses" inverse="true" lazy="extra">
14             <key column="cid"/>
15             <one-to-many class="domain.StudentCourse" />
16         set>
17     class>
18 hibernate-mapping>
19

Student

1 package domain;
2
3 import java.util.Set;
4
5 public class Student {
6
7     private int id;
8     private String name;
9
10     private Set studentCourses;
11
12 //get/set和构造省略，但实际不可省略
13
14 }
15

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4 <hibernate-mapping>
5     <class name="domain.Student" table="STUDENT">
6         <id name="id" type="int">
7             <column name="ID" />
8             <generator class="native" />
9         id>
10         <property name="name" type="java.lang.String">
11             <column name="NAME" />
12         property>
13         <set name="studentCourses" inverse="true" lazy="extra">
14             <key column="sid"/>
15             <one-to-many class="domain.StudentCourse"/>
16         set>
17     class>
18 hibernate-mapping>
19

1 package domain;
2
3 public class StudentCourse {
4
5     private int id;
6     private int point;
7
8     private Student student;
9     private Course course;
10 //get/set和构造省略，但实际不可省略
11
12 }
13

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4 <hibernate-mapping>
5     <class name="domain.StudentCourse" table="STUDENTCOURSE">
6         <id name="id" type="int">
7             <column name="ID" />
8             <generator class="native" />
9         id>
10         <property name="point" type="int">
11             <column name="POINT" />
12         property>
13         <many-to-one column="sid" name="student" class="domain.Student"/>
14         <many-to-one column="cid" name="course" class="domain.Course"/>
15     class>
16 hibernate-mapping>
17

书写测试代码

1 package demo;
2
3 import org.hibernate.Session;
4 import org.junit.Test;
5
6 import domain.Course;
7 import domain.Student;
8 import domain.StudentCourse;
9 import util.HibernateUtil;
10
11 public class App
12 {
13
14     @Test
15     /**
16      * manyTomany中，需要添加第三个表来维护两个提示之间的关系，但是一般来说，第三个表，还会添加其他的一些内容
17      * 就比如，学生和课程之间的关系，在关系表中还会添加成绩这一个字段
18      */
19     public void addTest() {
20         Session session = null;
21         try {
22             session = HibernateUtil.openSession();
23             session.beginTransaction();
24
25             Student student = new Student();
26             student.setName("二愣子");
27             session.save(student);
28
29             Student student2 = new Student();
30             student2.setName("大棒槌");
31             session.save(student2);
32
33             Course course = new Course();
34             course.setName("高达驾驶技术");
35             session.save(course);
36
37             Course course2 = new Course();
38             course2.setName("外星语言");
39             session.save(course2);
40
41             StudentCourse studentCourse = new StudentCourse();
42             studentCourse.setPoint(99);
43             studentCourse.setStudent(student);
44             studentCourse.setCourse(course);
45             session.save(studentCourse);
46
47             session.getTransaction().commit();
48         } catch (Exception e) {
49             if (session != null) {
50                 session.getTransaction().rollback();
51             }
52         } finally {
53             if (session != null) {
54                 session.close();
55             }
56         }
57     }
58
59     @Test
60     /**
61      * 最佳实践：多对多双向关联比较麻烦，不仅添加时需要很多操作，而且查询的时候由于延迟加载会发很多sql
62      * 实际应用中可以考虑直接使用原生sql查询
63      */
64     public void addTest02() {
65         Session session = null;
66         try {
67             session = HibernateUtil.openSession();
68             session.beginTransaction();
69
70             Student student = (Student) session.load(Student.class, 1);
71             System.out.println(student.getName());
72
73             for (StudentCourse s : student.getStudentCourses()) {
74                 System.out.println(s.getCourse().getName() + ":" + s.getPoint());
75             }
76
77             session.getTransaction().commit();
78         } catch (Exception e) {
79             if (session != null) {
80                 session.getTransaction().rollback();
81             }
82         } finally {
83             if (session != null) {
84                 session.close();
85             }
86         }
87     }
88 }
89

都较瘦 2015-01-21 10:09 发表评论

温故知新:hibernate_08_表关联_一对一双向关联

都较瘦 — Wed, 21 Jan 2015 01:39:00 GMT

一对一双向关联，在一对一的单向的基础上，在不维护关系的那一端添加one-to-one配置
实体类和配置如下

package domain;

public class Card {

    private int id;
    private String no;
    private Person person;
    //get/set和构造省略，但实际不可省略

}

package domain;

public class Person {

    private int id;
    private String name;
    private Card card;
  //get/set和构造省略，但实际不可省略

}

书写测试类

1 package demo;
  2
  3 import org.hibernate.Session;
  4 import org.junit.Test;
  5
  6 import domain.Card;
  7 import domain.Person;
  8 import util.HibernateUtil;
  9
10 public class App
11 {
12     @Test
13     /**
14      * 一对一双向，关系由card的控制
15      */
16     public void test01(){
17
18         Session session = null;
19         try {
20             session = HibernateUtil.openSession();
21             session.beginTransaction();
22
23             Person person = new Person();
24             person.setName("Nick");
25             session.save(person);
26
27             Card card = new Card();
28             card.setNo("#1");
29             card.setPerson(person);
30
31             session.save(card);
32
33             session.getTransaction().commit();
34
35         } catch (Exception e) {
36             e.printStackTrace();
37             if (session!=null) {
38                 session.getTransaction().rollback();
39             }
40         }finally{
41             if (session!=null) {
42                 session.close();
43             }
44         }
45
46     }
47
48     @Test
49     /**
50      * 一对一双向，关系由card的控制，重复添加多个card给一个person会报外键约束的异常
51      */
52     public void test02(){
53
54         Session session = null;
55         try {
56             session = HibernateUtil.openSession();
57             session.beginTransaction();
58
59             Person person = (Person) session.load(Person.class, 1);
60
61             Card card = new Card();
62             card.setNo("#8");
63             card.setPerson(person);
64
65             session.save(card);
66
67             session.getTransaction().commit();
68
69         } catch (Exception e) {
70             e.printStackTrace();
71             if (session!=null) {
72                 session.getTransaction().rollback();
73             }
74         }finally{
75             if (session!=null) {
76                 session.close();
77             }
78         }
79
80     }
81
82     @Test
83     /**
84      * 一对一双向关联，需要使用load方法取不维护关系的一端，会直接取得关联的一端，不使用懒加载
85      * 因为不维护关系，也就不存在外键，不存在外键也就不存在懒加载，一对一双向关联在实际开发中
86      * 不建议使用，因为查询其中一方，如果设置不当，会产生嵌套查询
87      */
88     public void test03(){
89
90         Session session = null;
91         try {
92             session = HibernateUtil.openSession();
93             session.beginTransaction();
94
95             Person person = (Person) session.load(Person.class, 1);
96
97             System.out.println(person.getName());
98             System.out.println(person.getCard().getNo());
99
100             session.getTransaction().commit();
101
102         } catch (Exception e) {
103             e.printStackTrace();
104             if (session!=null) {
105                 session.getTransaction().rollback();
106             }
107         }finally{
108             if (session!=null) {
109                 session.close();
110             }
111         }
112     }
113
114     @Test
115     /**
116      * 一对一双向关联，使用load方法取维护关系的一端，不会直接取得关联的一端，使用懒加载
117      * 但是一旦取得不维护关系的一端，会发现不维护关系的一端关联另一个实体，会直接查询，这样
118      * 会导致冗余操作
119      */
120     public void test04(){
121
122         Session session = null;
123         try {
124             session = HibernateUtil.openSession();
125             session.beginTransaction();
126
127             Card card = (Card) session.load(Card.class, 1);
128
129             System.out.println(card.getNo());
130             System.out.println(card.getPerson().getName());
131
132             session.getTransaction().commit();
133
134         } catch (Exception e) {
135             e.printStackTrace();
136             if (session!=null) {
137                 session.getTransaction().rollback();
138             }
139         }finally{
140             if (session!=null) {
141                 session.close();
142             }
143         }
144     }
145
146 }
147

都较瘦 2015-01-21 09:39 发表评论

温故知新:hibernate_07_表关联_一对一单向关联

都较瘦 — Tue, 20 Jan 2015 11:54:00 GMT

一对一和多对一在配置上基本一致，只是需要在配置关联的一方添加unique="true"（基于XML配置而言），以人和身份证为例。

Idcard

1 package domain;
2
3 public class Idcard {
4
5     private int id;
6     private String num;
7     private Person person;
8     //get/set和构造省略，但实际不可省略
9
10 }
11

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4
5 <hibernate-mapping>
6     <class name="domain.Idcard" table="IDCARD">
7         <id name="id" type="int">
8             <column name="ID" />
9             <generator class="native" />
10         id>
11         <property name="num" type="java.lang.String">
12             <column name="NUM" />
13         property>
14
15
16         <many-to-one name="person" column="pid" class="domain.Person" unique="true" />
17     class>
18 hibernate-mapping>
19

1 package domain;
2
3 public class Person {
4
5     private int id;
6     private String name;
7 //get/set和构造省略，但实际不可省略
8
9 }
10

书写测试类

1 package demo;
2
3 import org.hibernate.Session;
4 import org.junit.Test;
5
6 import domain.Idcard;
7 import domain.Person;
8 import util.HibernateUtil;
9
10 public class App
11 {
12
13     /**
14      * 一对一单向关联
15      */
16     @Test
17     public void addTest01() {
18         Session session = null;
19         try {
20             session = HibernateUtil.openSession();
21             session.beginTransaction();
22
23             Person person = new Person();
24             person.setName("Nick");
25             session.save(person);
26
27             Idcard idcard = new Idcard();
28             idcard.setNum("#2");
29             idcard.setPerson(person);
30             session.save(idcard);
31
32             session.getTransaction().commit();
33
34         } catch (Exception e) {
35             if (session != null) {
36                 session.getTransaction().rollback();
37             }
38         } finally{
39             if (session != null) {
40                 session.close();
41             }
42         }
43     }
44
45     /**
46      * 一对一单向关联，idcard一方维护一对一的关系，所以一个人不能有两个idcard
47      * 此处有异常
48      */
49     @Test
50     public void addTest02() {
51         Session session = null;
52         try {
53             session = HibernateUtil.openSession();
54             session.beginTransaction();
55
56             Person person = (Person) session.load(Person.class, 1);
57
58             Idcard idcard = new Idcard();
59             idcard.setNum("#2");
60             idcard.setPerson(person);
61             session.save(idcard);
62
63             session.getTransaction().commit();
64
65         } catch (Exception e) {
66             e.printStackTrace();
67             if (session != null) {
68                 session.getTransaction().rollback();
69             }
70         } finally{
71             if (session != null) {
72                 session.close();
73             }
74         }
75     }
76 }
77

都较瘦 2015-01-20 19:54 发表评论

温故知新:hibernate_06_表关联_多对一双向关联

都较瘦 — Tue, 20 Jan 2015 11:38:00 GMT

和多对一单向关联类似，但是双向关联需要在关联的两方都添加配置。实体类和配置文件如下，还是以老师和学生为例。
Student

1 package domain;
2
3
4 public class Student {
5
6     private int id;
7     private String name;
8     private String grade;
9
10     private Teacher teacher;
11
12     //get/set和构造省略，但实际不可省
13
14 }
15

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4
5 <hibernate-mapping>
6     <class name="domain.Student" table="STUDENT">
7         <id name="id" type="int">
8             <column name="ID" />
9             <generator class="native" />
10         id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         property>
14         <property name="grade" type="java.lang.String">
15             <column name="GRADE" />
16         property>
17         <many-to-one name="teacher" class="domain.Teacher" fetch="join">
18
19             <column name="tid" />
20         many-to-one>
21     class>
22 hibernate-mapping>
23

Teacher

1 package domain;
2
3 import java.util.HashSet;
4 import java.util.Set;
5
6 public class Teacher {
7
8     private int id;
9     private String name;
10     private String course;
11
12     private Set students;
13
14   //get/set和构造省略，但实际不可省
15
16 }
17

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4
5 <hibernate-mapping>
6     <class name="domain.Teacher" table="TEACHER">
7         <id name="id" type="int">
8             <column name="ID" />
9             <generator class="native" />
10         id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         property>
14         <property name="course" type="java.lang.String">
15             <column name="COURSE" />
16         property>
17
18
19         <set name="students" lazy="extra" inverse="true">
20             <key>
21
22                 <column name="tid" />
23             key>
24             <one-to-many class="domain.Student"/>
25         set>
26     class>
27 hibernate-mapping>
28

书写测试类

1 package demo;
2
3 import org.hibernate.Session;
4 import org.junit.Test;
5
6 import domain.Student;
7 import domain.Teacher;
8 import util.HibernateUtil;
9
10
11 public class App
12 {
13     @Test
14     /**
15      * oneToMany双向关联，设置多的一方维护关系。最佳实践就是：先添加一的一方，之后再添加多的一方
16      * 这样不会造成冗余的sql
17      */
18     public void addTest() {
19         Session session = null;
20         try {
21             session = HibernateUtil.openSession();
22             session.beginTransaction();
23
24             //添加一的一方
25             Teacher teacher = new Teacher();
26             teacher.setName("张老师");
27             teacher.setCourse("物理");
28             session.save(teacher);
29
30             //添加多的一方，设置一的一方，因为多的一方需要维护关系
31             Student stu1 = new Student();
32             stu1.setName("小明");
33             stu1.setGrade("一");
34             stu1.setTeacher(teacher);
35             session.save(stu1);
36
37             Student stu2 = new Student();
38             stu2.setName("小红");
39             stu2.setGrade("二");
40             stu2.setTeacher(teacher);
41             session.save(stu2);
42
43             session.getTransaction().commit();
44
45         } catch (Exception e) {
46             if (session != null) {
47                 session.getTransaction().rollback();
48             }
49         } finally{
50             if (session != null) {
51                 session.close();
52             }
53         }
54     }
55 }
56

都较瘦 2015-01-20 19:38 发表评论

温故知新:hibernate_05_表关联_多对一单向关联

都较瘦 — Tue, 20 Jan 2015 09:29:00 GMT

hibernate中，配置表关系可以说是比较绕人的，先记一个最简单的配置
多对一单向关联，配置学生和老师之间的多对一关系
实体类和配置
Student

1 package domain;
2
3 public class Student {
4
5     private int id;
6     private String name;
7     private String grade;
8     private Teacher teacher;
9     //get/set和构造省略，但是不可不写
10
11 }
12

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4
5 <hibernate-mapping>
6     <class name="domain.Student" table="STUDENT">
7         <id name="id" type="int">
8             <column name="ID" />
9             <generator class="native" />
10         id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         property>
14         <property name="grade" type="java.lang.String">
15             <column name="GRADE" />
16         property>
17
18
21         <many-to-one name="teacher" class="domain.Teacher" fetch="join">
22             <column name="TEACHER_ID" />
23         many-to-one>
24     class>
25 hibernate-mapping>
26

Teacher

1 package domain;
2
3 public class Teacher {
4
5     private int id;
6     private String name;
7     private String course;
8     //get/set和构造省略，但是不可不写
9
10 }
11

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4
5 <hibernate-mapping>
6     <class name="domain.Teacher" table="TEACHER">
7         <id name="id" type="int">
8             <column name="ID" />
9             <generator class="native" />
10         id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         property>
14         <property name="course" type="java.lang.String">
15             <column name="COURSE" />
16         property>
17     class>
18 hibernate-mapping>
19

配置至此基本完成，现在书写测试类

1 package demo;
  2
  3 import org.hibernate.Session;
  4 import org.junit.Test;
  5
  6 import domain.Student;
  7 import domain.Teacher;
  8 import util.HibernateUtil;
  9
10 public class App
11 {
12     @Test
13     /**
14      * ManyToOne中，需要先添加一的一方，再添加多的一方，这样效率高
15      * 在案例中，先保存一个teacher对象，在保存两个学生对象，这样只会使用三个insert语句完成操作
16      */
17     public void addTest() {
18         Session session = null;
19         try {
20             session = HibernateUtil.openSession();
21             session.beginTransaction();
22
23             Teacher teacher = new Teacher();
24             teacher.setName("张老师");
25             teacher.setCourse("物理");
26             session.save(teacher);
27
28             Student stu1 = new Student();
29             stu1.setName("小明");
30             stu1.setGrade("一");
31             stu1.setTeacher(teacher);
32             session.save(stu1);
33
34             Student stu2 = new Student();
35             stu2.setName("小红");
36             stu2.setGrade("二");
37             stu2.setTeacher(teacher);
38             session.save(stu2);
39
40             session.getTransaction().commit();
41
42         } catch (Exception e) {
43             if (session != null) {
44                 session.getTransaction().rollback();
45             }
46         } finally{
47             if (session != null) {
48                 session.close();
49             }
50         }
51     }
52
53     @Test
54     /**
55      * 下个案例中，先添加了多的一方，再添加一的一方，这样会导致冗余的sql语句，会多出两个Updatesql
56      * 所以最佳实践就是：添加的时候先添加一的一方，然后再添加多的一方
57      */
58     public void addTest2() {
59         Session session = null;
60         try {
61             session = HibernateUtil.openSession();
62             session.beginTransaction();
63
64             Student stu1 = new Student();
65             stu1.setName("小明");
66             stu1.setGrade("一");
67             session.save(stu1);
68
69             Student stu2 = new Student();
70             stu2.setName("小红");
71             stu2.setGrade("二");
72             session.save(stu2);
73
74             Teacher teacher = new Teacher();
75             teacher.setName("张老师");
76             teacher.setCourse("物理");
77             session.save(teacher);
78
79             stu1.setTeacher(teacher);
80             stu2.setTeacher(teacher);
81
82             session.getTransaction().commit();
83
84         } catch (Exception e) {
85             if (session != null) {
86                 session.getTransaction().rollback();
87             }
88         } finally{
89             if (session != null) {
90                 session.close();
91             }
92         }
93     }
94
95     @Test
96     /**
97      * 关于延迟加载，多对一关系中，若取得的多的一方的对象，没有进一步取得一的一方的对象，则不会立刻查询
98      * 除非需要进一步取得一的一方的内容
99      */
100     public void addTest3() {
101         Session session = null;
102         try {
103             session = HibernateUtil.openSession();
104             session.beginTransaction();
105
106             Student student = (Student) session.load(Student.class, 10);
107             System.err.println(student.getName());
108             System.err.println(student.getTeacher().getName());
109
110             session.getTransaction().commit();
111
112         } catch (Exception e) {
113             if (session != null) {
114                 session.getTransaction().rollback();
115             }
116         } finally{
117             if (session != null) {
118                 session.close();
119             }
120         }
121     }
122
123     @Test
124     /**
125      * 级联的设置,若在配置文件中添加了cascade，则会自动生成一个外键对象并保存
126      * 注意：cascade级联操作，不要在多的一方添加级联，这样在删除的时候会导致一些异常，
127      * 要添加也是在一的一方添加，而且不是特殊要求的情况下，不要添加级联
128      */
129     public void addTest4() {
130         Session session = null;
131         try {
132             session = HibernateUtil.openSession();
133             session.beginTransaction();
134
135             Teacher teacher = new Teacher();
136             teacher.setName("白老师");
137             teacher.setCourse("物理");
138             //session.save(teacher);
139             //此处没有保存Teacher对象，直接保存不会成功
140
141             Student stu1 = new Student();
142             stu1.setName("小黑");
143             stu1.setGrade("一");
144             stu1.setTeacher(teacher);
145             session.save(stu1);
146
147             session.getTransaction().commit();
148
149         } catch (Exception e) {
150             if (session != null) {
151                 session.getTransaction().rollback();
152             }
153         } finally{
154             if (session != null) {
155                 session.close();
156             }
157         }
158     }
159 }
160

都较瘦 2015-01-20 17:29 发表评论

温故知新:hibernate_04常见主键策略

都较瘦 — Tue, 20 Jan 2015 08:21:00 GMT

在配置实体类和数据库之间的映射时，hibernate提供了多种主键生成策略

虽然很全面，但是常用的确是个别，一般来说，很少会把策略直接写为increment或者sequence，常见为native，可理解为数据库原生自增策略，根据数据库的不同而不同
以一个hbm配置文件为例

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4 <hibernate-mapping>
5     <class name="domain.Student" table="STUDENT">
6         <id name="id" type="int">
7             <column name="ID" />
8
9
10
11
15             <generator class="native" />
16         id>
17         <property name="name" type="java.lang.String">
18             <column name="NAME" />
19         property>
20         <property name="grade" type="java.lang.String">
21             <column name="GRADE" />
22         property>
23     class>
24 hibernate-mapping>
25

都较瘦 2015-01-20 16:21 发表评论

温故知新:hibernate_03延迟加载

都较瘦 — Tue, 20 Jan 2015 06:57:00 GMT

延迟加载作为一种提升效率的机制，利弊共存，优点是，在查询中，某些对象可能在查询之后，不会使用，比如User对象关联了Department对象，在只需要使用User对象的时候，如果不获取Deaprtment的相关信息，则不会查询Deparment对象的内容。但是弊端也显而易见，延迟加载在session关闭之后会失效，如果延迟加载使用不当，很容出现无法取得对象的情况。

1 package demo;
2
3 import org.hibernate.Session;
4 import org.junit.Test;
5
6 import domain.Student;
7 import util.HibernateUtil;
8
9 public class App
10 {
11     //省略实体类和相关配置
12     @Test
13     public void lazyLoad() {
14         Session session = null;
15         try {
16             session = HibernateUtil.openSession();
17             session.beginTransaction();
18
19             //s对象在load完毕之后是一个托管对象，只有一个id属性，如果不使用该对象，则不会进行查询
20             //但是，不论是否能够查询到，s对象不是空，是一个含有id的代理对象
21             Student s = (Student) session.load(Student.class, 99);
22             //System.out.println(s.getId());
23
24             //get方法不存在延迟加载机制，会直接查询,但是查询不到会返回null
25             //而不是一个代理对象
26             Student s1 = (Student) session.get(Student.class, 5);
27             System.out.println(s1);
28
29             //取得s2对象之后，若不进一步取得s2所包含的department属性，则不会进一步发送sql去
30             //取得department的信息
31             Student s2 = (Student) session.load(Student.class, 10);
32             //System.out.println(s2.getDepartment().getName());
33
34             session.getTransaction().commit();
35
36         } catch (Exception e) {
37             if (session != null) {
38                 session.getTransaction().rollback();
39             }
40         } finally{
41             if (session != null) {
42                 session.close();
43             }
44         }
45     }
46
47 }
48
49

都较瘦 2015-01-20 14:57 发表评论

温故知新:hibernate_02对象状态

都较瘦 — Tue, 20 Jan 2015 00:57:00 GMT

hibernate对象含有三种状态，瞬时，持久和离线。简而言之就是，瞬时对象和hibernate session没关系，持久对象就是和hibernate session有关系，并且当前事物还没有提交，持久对象的所有变化都会反映到数据库中，最后，离线对象就是和hiberante session有过关系，但是事物已经提交了，离线对象已经脱离了hibernate session的管理，自身的状态不会反映到数据库中。下面通过几个测试案例感受一下。

1 package demo;
  2
  3 import org.hibernate.Session;
  4 import org.junit.Test;
  5
  6 import domain.Student;
  7 import util.HibernateUtil;
  8
  9 public class App
10 {
11
12     //省略相关工具类和实体类
13     @Test
14     public void testTransien() {
15         Session session = null;
16         try {
17             session = HibernateUtil.openSession();
18             session.beginTransaction();
19
20             //对hibernate而言，stu1对象和session没有任何关联，所以该对象不会反映到数据库中
21             Student stu1 = new Student();
22             stu1.setName("小明");
23             stu1.setGrade("一");
24
25             session.getTransaction().commit();
26
27         } catch (Exception e) {
28             if (session != null) {
29                 session.getTransaction().rollback();
30             }
31         } finally{
32             if (session != null) {
33                 session.close();
34             }
35         }
36     }
37
38     @Test
39     public void testPersistent() {
40         Session session = null;
41         try {
42             session = HibernateUtil.openSession();
43             session.beginTransaction();
44             //当一个对象变为持久对象之后便被session所管理，在事务提交之前
45             //持久对象若有变更，则会更新
46             Student stu1 = new Student();
47             stu1.setName("xiaoxiaoming");
48             stu1.setGrade("六");
49             session.save(stu1);
50             //此处如果发送多条save，update，均没有意义，save命令发出之后，只会发送一条insert指令
51             //在最后事物提交之前，stu1会和session中的stu1缓存对象进行对比，将最后的结果反映到数据库中
52             //session.save(stu1);
53             //session.update(stu1);
54
55             //对象变为持久对象之后，对象本身所做的变更会反映到数据库中去，这里会发送update语句更新数据
56             stu1.setName("dadaMing");
57
58             session.getTransaction().commit();
59
60         } catch (Exception e) {
61             if (session != null) {
62                 session.getTransaction().rollback();
63             }
64         } finally{
65             if (session != null) {
66                 session.close();
67             }
68         }
69     }
70
71     @Test
72     public void testDetach() {
73         Session session = null;
74         try {
75             session = HibernateUtil.openSession();
76             session.beginTransaction();
77
78             //某对象在数据库中存在记录，但是在session没有被管理，那么他就不会和数据库
79             //进行状态同步
80             Student stud = (Student) session.load(Student.class, 9);
81             session.clear();
82             //但是，如果没有清空session，那么stud对象就在session的管辖之内，stud对象的变更
83             //都会以update语句反映到数据库中
84             stud.setName("newName");
85             session.getTransaction().commit();
86
87         } catch (Exception e) {
88             if (session != null) {
89                 session.getTransaction().rollback();
90             }
91         } finally{
92             if (session != null) {
93                 session.close();
94             }
95         }
96     }
97
98 }
99
100

都较瘦 2015-01-20 08:57 发表评论

温故知新:hibernate_01感受基本使用

都较瘦 — Sun, 18 Jan 2015 12:43:00 GMT

作为一个ORM框架，hibernate对JDBC进行了轻量级的封装，使得我们在开发时能够把更多的精力放在业务实现上，不过这毕竟是一把双刃剑，在提供了方便的同时，也降低了程序员理解数据库、SQL语句的门槛，所以在平时，还是需要花一些时间在数据库上，至少是SQL上。下面记录的是平时学习，工作中可能用到的一些技术点，或者心得，记录下来，以备查看。

先交代一下和使用环境相关的信息
IDE：Eclipse Kepler Service Release 2
Mysql：5.0.96
使用Maven构建测试项目，所需依赖如下（在实际的使用中，可能涉及更多的依赖，尤其在框架间整合时）

1
2     <dependency>
3       <groupId>junitgroupId>
4       <artifactId>junitartifactId>
5       <version>3.8.1version>
6       <scope>testscope>
7     dependency>
8
9
10     <dependency>
11         <groupId>org.hibernategroupId>
12         <artifactId>hibernate-entitymanagerartifactId>
13         <version>4.3.5.Finalversion>
14     dependency>
15
16
17     <dependency>
18         <groupId>log4jgroupId>
19         <artifactId>log4jartifactId>
20         <version>1.2.16version>
21     dependency>
22
23
24     <dependency>
25         <groupId>mysqlgroupId>
26         <artifactId>mysql-connector-javaartifactId>
27         <version>5.1.6version>
28     dependency>

单独使用hibernate时，需要为其指定一个创建sessionFactory的配置文件hibernate.cfg.xml，常规内容如下，放置于项目classpath下

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 <hibernate-configuration>
6     <session-factory name="sessionFactory">
7
8         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>
9
10         <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_beginproperty>
11         <property name="hibernate.connection.username">rootproperty>
12         <property name="hibernate.connection.password">rootproperty>
13
14         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialectproperty>
15
16         <property name="hibernate.hbm2ddl.auto">updateproperty>
17
18         <property name="show_sql">trueproperty>
19
20         <mapping resource="domain/Student.hbm.xml"/>
21     session-factory>
22 hibernate-configuration>
23

配置完毕之后，我们只需通过sessionFactory来获取session，之后通过session对数据库进行操作即可，通常来说，项目中会把sessionFactory的获取写进一个工具类中，通过工具类获取session，如下

1 package util;
2
3 import org.hibernate.Session;
4 import org.hibernate.SessionFactory;
5 import org.hibernate.boot.registry.StandardServiceRegistry;
6 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
7 import org.hibernate.cfg.Configuration;
8
9 /**
10  * Hibernate工具类，用于通过配置文件构建session工厂，通过工厂返回session
11  * @author Alvin Du
12  *
13  */
14 public class HibernateUtil {
15     //SessionFactory是线程安全的，对资源占用较高，一般需要定义为单例的
16     private static final SessionFactory FACTORY = buildSessionFactory();
17
18     private static SessionFactory buildSessionFactory() {
19
20         Configuration configuration = new Configuration().configure();
21         //hibernate 4中使用standardServiceRegistryBuilder创建standardServiceRegistry
22         StandardServiceRegistryBuilder standardServiceRegistryBuilder =
23                 new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
24         StandardServiceRegistry standardServiceRegistry = standardServiceRegistryBuilder.build();
25         SessionFactory sessionFactory = configuration.buildSessionFactory(standardServiceRegistry);
26
27         return sessionFactory;
28     }
29
30     /**
31      * 获取工厂
32      * @return the factory
33      */
34     public static SessionFactory getFactory() {
35         return FACTORY;
36     }
37
38     /**
39      * 获取hibernate session
40      * @return
41      */
42     public static Session openSession(){
43         return FACTORY.openSession();
44     }
45
46     /**
47      * 关闭hibernate session
48      * @param session
49      */
50     public static void closeSession(Session session){
51         if(session !=null){
52             session.close();
53         }
54     }
55
56 }
57

之后，我们需要为hibernate配置实体类和表的映射，此处为演示，一切从简，定义Student实体类和对应的hbm配置文件，类和hbm一般习惯放置于同一个包下
（表和实体类之间的映射还可以使用注解的方式进行配置，后续会再记录）
Student.java

1 package domain;
2
3 public class Student {
4
5     private int id;
6     private String name;
7     private String grade;
8     //get/set方法和构造器省略，但是实际不可不写
9
10 }
11

Student.hbm.xml

1 xml version="1.0"?>
2 DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4 <hibernate-mapping>
5
6     <class name="domain.Student" table="STUDENT">
7
8         <id name="id" type="int">
9             <column name="ID" />
10             <generator class="native" />
11         id>
12         <property name="name" type="java.lang.String">
13             <column name="NAME" />
14         property>
15         <property name="grade" type="java.lang.String">
16             <column name="GRADE" />
17         property>
18     class>
19 hibernate-mapping>
20

至此，环境的搭建就告一段落，书写测试类进行测试

1 package demo;
2
3 import java.util.List;
4
5 import org.hibernate.Session;
6 import org.junit.Test;
7
8 import domain.Student;
9 import util.HibernateUtil;
10
11 public class App
12 {
13     @Test
14     public void addTest() {
15         //session使用结束之后注意记得释放资源
16         Session session = null;
17         try {
18             //一般使用，考虑采用如下写法
19             session = HibernateUtil.openSession();
20             //开启事物
21             session.beginTransaction();
22
23             Student stu1 = new Student();
24             stu1.setName("小明");
25             stu1.setGrade("一");
26             session.save(stu1);
27
28             Student stu2 = new Student();
29             stu2.setName("小红");
30             stu2.setGrade("二");
31             session.save(stu2);
32
33             session.getTransaction().commit();
34
35         } catch (Exception e) {
36             //异常时回滚事物
37             if (session != null) {
38                 session.getTransaction().rollback();
39             }
40         } finally{
41             if (session != null) {
42                 session.close();
43             }
44         }
45     }
46
47 }
48
49

以上就是hibernate最简单的使用

都较瘦 2015-01-18 20:43 发表评论