Hibernate注解开发
在Hibernate中我们一般都会使用注解,这样可以帮助我们大大简化hbm映射文件的配置。下面我就来为大家详细介绍。
PO类注解配置
首先肯定是搭建好Hibernate的开发环境啦,我在此也不过多赘述,读者自行实践。接着在src目录下创建一个cn.itheima.domain包,并在该包下创建一个Book实体类,由于Book实体类中写有注解配置,所以就不用编写那个映射配置文件啦!
@Entity
@Table(name="t_book",catalog="hibernateTest")
public class Book {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
@Column(name="c_name", length=30, nullable=true)
private String name;
@Temporal(TemporalType.TIMESTAMP)
private Date publicationDate;
@Type(type="double")
private Double price;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getPublicationDate() {
return publicationDate;
}
public void setPublicationDate(Date publicationDate) {
this.publicationDate = publicationDate;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
}
下面我就来详细说一下Book实体类中的注解。
@Entity
:声明一个实体。-
@Table
:来描述类与表之间的对应关系。
@Entity
@Table(name="t_book",catalog="hibernateTest")
public class Book {
......
}
@id
:声明一个主键。-
@GeneratedValue
:用它来声明一个主键生成策略。默认情况是native主键生成策略。可以选择的主键生成策略有:AUTO、IDENTITY、SEQUENCE。
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
-
@Column
:定义列。
@Column(name="c_name", length=30, nullable=true)
private String name;
注意:对于PO类中所有属性,如果你不写注解,默认情况下也会在表中生成对应的列,列的名称就是属性的名称,列的类型也即属性的类型。
-
@Temporal
:声明日期类型。
@Temporal(TemporalType.TIMESTAMP)
private Date publicationDate;
日期类型可以选择的有:
- TemporalType.DATA:只有年月日。
- TemporalType.TIME:只有小时分钟秒。
- TemporalType.TIMESTAMP:有年月日小时分钟秒。
-
@Type
:可允许你去指定Hibernate里面的一些类型。
@Type(type="double")
private Double price;
编写完上述Book实体类之后,千万不要忘记下面这一步:我们最终需要在hibernate.cfg.xml文件中将我们类中的注解配置引用生效。即需要在Hibernate核心配置文件中添加如下配置:
<mapping class="cn.itheima.domain.Book"/>
最后我们在src目录下创建一个cn.itheima.test包,在该包下编写一个HibernateAnnotationTest单元测试类,并在该类中编写一个用于测试PO类的注解开发的方法:
public class HibernateAnnotationTest {
@Test
public void test1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Book b = new Book();
b.setName("情书");
b.setPrice(56.78);
b.setPublicationDate(new Date());
session.save(b);
session.getTransaction().commit();
session.close();
}
}
现在来思考两个问题:
- 如果主键生成策略我们想使用UUID类型呢?
- 如何设定类的属性不在表中映射?
这两个问题我们一起解决。废话不多说,直接上例子。在cn.itheima.domain包下再编写一个Person实体类,同样使用注解配置。
@Entity
@Table(name="t_person", catalog="hibernateTest")
public class Person {
@Id
@GenericGenerator(name="myuuid", strategy="uuid")
@GeneratedValue(generator="myuuid")
private String id;
@Type(type="string")
private String name;
@Transient
private String msg;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
当然不要忘记这一步了:我们最终需要在hibernate.cfg.xml文件中将我们类中的注解配置引用生效,故需要在Hibernate核心配置文件中添加如下配置:
<mapping class="cn.itheima.domain.Person"/>
最后在HibernateAnnotationTest单元测试类中编写如下一个方法:
public class HibernateAnnotationTest {
@Test
public void test2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Person p = new Person();
p.setName("李四");
p.setMsg("这是一个好人");
session.save(p);
session.getTransaction().commit();
session.close();
}
}
至此,两个问题就解决了。
注意:对于我们以上讲解的关于属性配置的注解,我们也可以在其对应的getXxx方法去使用。
Hibernate关联映射——一对多(多对一)
仍以客户(Customer)和订单(Order)为例来开始我的表演。
在src目录下创建一个cn.itheima.oneToMany包,并在该包编写这两个实体类:
-
客户(Customer)类
@Entity
@Table(name="t_customer")
public class Customer {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
@OneToMany(targetEntity=Order.class,mappedBy="c")
private Set<Order> orders = new HashSet<Order>();
public Set<Order> getOrders() {
return orders;
}
public void setOrders(Set<Order> orders) {
this.orders = orders;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
-
订单(Order)类
@Entity
@Table(name="t_order")
public class Order {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private Double money;
private String receiverInfo;
@ManyToOne(targetEntity=Customer.class)
@JoinColumn(name="c_customer_id")
private Customer c;
public Customer getC() {
return c;
}
public void setC(Customer c) {
this.c = c;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
public String getReceiverInfo() {
return receiverInfo;
}
public void setReceiverInfo(String receiverInfo) {
this.receiverInfo = receiverInfo;
}
}
这儿用到了@OneToMany
和@ManyToOne
这两个注解。
以上两个实体类编写好之后,可以很明显的看出我们不需要写它们对应的映射配置文件了,是不是很爽呢!接下来,我就要编写测试程序测试一下了。现在我的需求是保存客户时,顺便保存订单,对于这种情况我们需要在Customer类中配置cascade操作,即配置cascade="save-update"
,配置的方式有两种,下面我细细说来:
-
第一种方式,可以使用JPA提供的注解。
那么@OneToMany
注解就应修改为:
@OneToMany(targetEntity=Order.class,mappedBy="c",cascade=CascadeType.ALL)
private Set<Order> orders = new HashSet<Order>();
-
第二种方式,可以使用Hibernate提供的注解。
那么@OneToMany
注解就应修改为:
@OneToMany(targetEntity=Order.class,mappedBy="c")
@Cascade(CascadeType.SAVE_UPDATE)
private Set<Order> orders = new HashSet<Order>();
两种方式都可以,口味任君选择,不过我倾向于第二种方式。
接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试:
public class HibernateAnnotationTest {
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("叶子");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("天门");
c.getOrders().add(o1);
c.getOrders().add(o2);
session.save(c);
session.getTransaction().commit();
session.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
这时运行以上方法,会发现虽然客户表的那条记录插进去了,但是订单表就变成这个鬼样了:
订单表中没有关联客户的id,这是为什么呢?原因是我们在Customer类中配置了mappedBy=”c”
,它代表的是外键的维护由Order方来维护,而Customer不维护,这时你在保存客户时,级联保存订单,是可以的,但是不能维护外键,所以,我们必须在代码中添加订单与客户之间的关系。所以须将test3方法修改为:
public class HibernateAnnotationTest {
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("叶子");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("天门");
o1.setC(c);
o2.setC(c);
c.getOrders().add(o1);
c.getOrders().add(o2);
session.save(c);
session.getTransaction().commit();
session.close();
}
}
这时再测试,就没有任何问题啦!
扩展
Hibernate注解@Cascade
中的DELETE_ORPHAN已经过时了,如下:
可使用下面方案来替换过时方案:
Hibernate关联映射——多对多
以学生与老师为例开始我的表演,我是使用注解完成这种多对多的配置。使用@ManyToMany
注解来配置多对多,只需要在一端配置中间表,另一端使用mappedBy表示放置外键的维护权。
在src目录下创建一个cn.itheima.manyToMany包,并在该包编写这两个实体类:
-
学生类
@Entity
@Table(name="t_student")
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
@ManyToMany(targetEntity=Teacher.class)
@JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")})
private Set<Teacher> teachers = new HashSet<Teacher>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
}
-
老师类
@Entity
@Table(name="t_teacher")
public class Teacher {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
@ManyToMany(targetEntity=Student.class, mappedBy="teachers")
private Set<Student> students = new HashSet<Student>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
}
接下来,我就要编写测试程序测试一下了。 从上面可看出我们将外键的维护权利交由Student类来维护,现在我们演示保存学生时,将老师也级联保存,对于这种情况我们需要在Student类中配置cascade操作,即配置cascade=”save-update”,如下:
@JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")})
@Cascade(CascadeType.SAVE_UPDATE)
private Set<Teacher> teachers = new HashSet<Teacher>();
接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试:
public class HibernateAnnotationTest {
// 测试多对多级联保存(保存学生时同时保存老师)
@Test
public void test4() {
Session session = HibernateUtils.openSession()
session.beginTransaction()
// 1.创建两个老师
Teacher t1 = new Teacher()
t1.setName("Tom")
Teacher t2 = new Teacher()
t2.setName("Fox")
// 2.创建两个学生
Student s1 = new Student()
s1.setName("张丹")
Student s2 = new Student()
s2.setName("叶紫")
// 3.学生关联老师
s1.getTeachers().add(t1)
s1.getTeachers().add(t2)
s2.getTeachers().add(t1)
s2.getTeachers().add(t2)
// 保存学生同时保存老师
session.save(s1)
session.save(s2)
session.getTransaction().commit()
session.close()
}
}
运行以上方法,一切正常。
接着我们测试级联删除操作。见下图:
可在HibernateAnnotationTest单元测试类中编写如下方法进行测试:
public class HibernateAnnotationTest {
@Test
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Student s = session.get(Student.class, 1);
session.delete(s);
session.getTransaction().commit();
session.close();
}
}
运行以上方法,所有表的数据都删光光了,所以实际开发中我们要慎用哟!!!
Hibernate关联映射——一对一
以人与身份证为例开始我的表演。一对一操作有两种映射方式:
- 在任意一方添加外键
- 主键映射
外键映射
我先讲外键映射,这个在实际开发中用的比较多,而且比较容易掌握哟!
在src目录下创建一个cn.itheima.oneToOne包,并在该包编写这两个实体类:
-
User类
@Entity
@Table(name="t_user")
public class User {
@Id
@GenericGenerator(strategy="uuid",name="myuuid")
@GeneratedValue(generator="myuuid")
private String id;
private String name;
@OneToOne(targetEntity=IDCard.class,mappedBy="user")
private IDCard idCard;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public IDCard getIdCard() {
return idCard;
}
public void setIdCard(IDCard idCard) {
this.idCard = idCard;
}
}
上述配置使得t_user表放弃对外键的维护权利。
-
IDCard类
@Entity
@Table(name="t_idcard")
public class IDCard {
@Id
@GenericGenerator(strategy="uuid",name="myuuid")
@GeneratedValue(generator="myuuid")
private String id;
private String cardNum;
@OneToOne(targetEntity=User.class)
@JoinColumn(name="c_user_id")
@Cascade(CascadeType.SAVE_UPDATE)
private User user;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getCardNum() {
return cardNum;
}
public void setCardNum(String cardNum) {
this.cardNum = cardNum;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
@JoinColumn
用于指定外键列的名称,当前配置的外键是在t_idcard表中。而且还设置了级联保存操作,即保存身份证时,可以顺便保存人。
接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试:
public class HibernateAnnotationTest {
@Test
public void test6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
User user = new User();
user.setName("叶子");
IDCard idCard = new IDCard();
idCard.setCardNum("429006199010241657");
idCard.setUser(user);
session.save(idCard);
session.getTransaction().commit();
session.close();
}
}
测试以上方法,一切正常。
主键映射(了解)
主键映射挺复杂的,我们只须了解即可,而且实际开发中用到的并不是很多。但我还是简单介绍一下。
以Husband与Wife为例进行讲解。
同样也是在cn.itheima.oneToOne包下编写这两个实体类:
-
Wife类
@Entity
@Table(name="t_wife")
public class Wife {
@Id
@GenericGenerator(name="myuuid",strategy="uuid")
@GeneratedValue(generator="myuuid")
private String id;
private String name;
@OneToOne
@PrimaryKeyJoinColumn
@Cascade(CascadeType.SAVE_UPDATE)
private Husband husband;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
}
从上面可以看出t_wife表的主键生成策略是uuid,@PrimaryKeyJoinColumn
注解说明了Husband类与Wife类是使用了主键映射。而且还设置了级联保存操作,即保存妻子时,可以顺便丈夫。
-
Husband类
@Entity
@Table(name="t_husband")
public class Husband {
@Id
@GenericGenerator(name="myForeignKey",strategy="foreign",parameters={
@Parameter(name="property",value="wife")})
@GeneratedValue(generator="myForeignKey")
private String id;
private String name;
@OneToOne(mappedBy="husband")
@PrimaryKeyJoinColumn
private Wife wife;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Wife getWife() {
return wife;
}
public void setWife(Wife wife) {
this.wife = wife;
}
}
t_husband表的主键我们设置成了参考t_wife表的主键的方式。
最后在HibernateAnnotationTest单元测试类中编写如下方法进行测试:
public class HibernateAnnotationTest {
@Test
public void test7() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Husband husband = new Husband();
husband.setName("武大郎");
Wife wife = new Wife();
wife.setName("潘金莲");
husband.setWife(wife);
wife.setHusband(husband);
session.save(wife);
session.getTransaction().commit();
session.close();
}
}