由于在数据表之间可以通过外键进行关联,在使用Hibernate操作映射到存在关联关系的数据表的对象时,需要将对象的关联关系与数据表的外键关联进行映射。
首先建立hibernate.cfg.xml和会话工厂类HibernateUtil,然后添加两个待操作的实体类和相应的映射文件。
HibernateUtil如下:
![](https://img.laitimes.com/img/9ZDMuAjOiMmIsIjOiQnIsIiZpdmLrN2bsJEZlR3YhJHdu92Qvw1cy9GdhNWak5WSn5WaulGb0V3TvwVbvNmLzd2bsJmbj5ycldWYtl2Lc9CX6MHc0RHaiojIsJye.gif)
package com.zzh.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory sessionFactory;
private static Session session;
static {
// 创建Configuration对象,读取hibernate.cfg.xml文件,完成初始化
Configuration config = new Configuration().configure();
StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder()
.applySettings(config.getProperties());
StandardServiceRegistry ssr=ssrb.build();
sessionFactory=config.buildSessionFactory(ssr);
}
//获取SessionFactory
public static SessionFactory getSessionFactory(){
return sessionFactory;
}
//获取Session
public static Session getSession(){
session=sessionFactory.openSession();
return session;
}
//关闭Session
public static void closeSession(Session session){
if(session!=null){
session.close();
}
}
}
View Code
两个实体类班级Grade和学生Student
package com.zzh.entity;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
public class Grade implements Serializable {
private int gid;
private String gname;
private String gdesc;
public int getGid() {
return gid;
}
public void setGid(int gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public String getGdesc() {
return gdesc;
}
public void setGdesc(String gdesc) {
this.gdesc = gdesc;
}
public Grade() {
super();
}
public Grade(int gid, String gname, String gdesc) {
super();
this.gid = gid;
this.gname = gname;
this.gdesc = gdesc;
}
public Grade(String gname, String gdesc) {
super();
this.gname = gname;
this.gdesc = gdesc;
}
}
package com.zzh.entity;
import java.io.Serializable;
public class Student implements Serializable {
private int sid;
private String sname;
private String sex;
//在多方定义一个一方的引用
private Grade grade;
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Student() {
super();
}
public Student(String sname, String sex) {
super();
this.sname = sname;
this.sex = sex;
}
}
可以看出我在Student类中使用Grade类声明了grade属性,并添加了getter和setter,以体现实体类Student对Grade的关联关系,在下面的映射表中只需要在“多”的一方配置。注意,Student类中添加的grade属性为Grade,它是一个持久化类Grade的对象属性,不是一个基本类型属性,因此不能用<property>元素来映射grade属性,又因为是多对一关联关系,要使用<many-to-one>元素。
Grade.hbm.xml:
![](https://img.laitimes.com/img/9ZDMuAjOiMmIsIjOiQnIsIiZpdmLrN2bsJEZlR3YhJHdu92Qvw1cy9GdhNWak5WSn5WaulGb0V3TvwVbvNmLzd2bsJmbj5ycldWYtl2Lc9CX6MHc0RHaiojIsJye.gif)
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-31 11:19:40 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
<class name="com.zzh.entity.Grade" table="GRADE">
<id name="gid" type="int">
<column name="GID" />
<generator class="increment"/>
</id>
<property name="gname" type="java.lang.String">
<column name="GNAME" />
</property>
<property name="gdesc" type="java.lang.String">
<column name="GDESC" />
</property>
</class>
</hibernate-mapping>
Student.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-8-31 11:19:40 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
<class name="com.zzh.entity.Student" table="STUDENT">
<id name="sid" type="int">
<column name="SID" />
<generator class="increment" />
</id>
<property name="sname" type="java.lang.String">
<column name="SNAME" />
</property>
<property name="sex" type="java.lang.String">
<column name="SEX" />
</property>
<many-to-one name="grade" class="com.zzh.entity.Grade" fetch="join">
<column name="GRADE" />
</many-to-one>
</class>
</hibernate-mapping>
<many-to-one>元素中的name指定Student类中关联类的属性名,column指定数据表关联的外键。换句话说,实体类Student对Grade的多对一关联在本质上是通过数据表student中的外键GRADE与数据表grade关联实现的,但Hibernate将表之间的关联通过<many-to-one>元素进行了封装。
2.编写与数据库交互的UserDAO接口和其实现类UserDAOImpl,将数据的添加,查找,修改,删除等方法封装其中。
UserDAO:
package com.zzh.dao;
public interface UserDAO {
void save(Object obj);
Object findById(int id,Object obj);
void delete(Object obj);
void update(Object obj);
}
UserDAOImpl:
package com.zzh.dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.zzh.util.*;
public class UserDAOImpl implements UserDAO {
@Override
public void save(Object obj) {
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
try {
session.save(obj);
tx.commit();
} catch (Exception e) {
e.printStackTrace();
tx.rollback();
} finally {
HibernateUtil.closeSession(session);
}
}
@Override
public Object findById(int id, Object obj) {
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
try {
obj = session.get(obj.getClass(), id);
tx.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
HibernateUtil.closeSession(session);
}
return obj;
}
@Override
public void delete(Object obj) {
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
try {
session.delete(obj);
tx.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
HibernateUtil.closeSession(session);
}
}
@Override
public void update(Object obj) {
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
try {
session.update(obj);
tx.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
HibernateUtil.closeSession(session);
}
}
}
注意:我的这个DAO使用的是Object对象,很多书上都是针对多个的对象建立多个DAO,也就是拆分为StudentDAOImpl和GradeDAOImpl,这样里面的Object就变为了相应的Student或者Grade。
如果你要改写为我这样的通用DAO,尤其要注意里面的findById()方法,对于拆分写的DAO,这个方法很简单,只需要传入参数id然后Grade grade=(Grade) session.get(Grade.class, id);而我的方法因为是通用的,所有要传入id和对应的实体对象,obj = session.get(obj.getClass(), id),这里面运用了java的有关反射的知识,顺便拓展一下。
1.利用对象调用getClass()方法获取该对象的Class实例。比如 Students s = new Students(); Class c = s.getClass();2.使用Class的静态方法forName(),用类的名字获取一个Class实例;比如 Class c = Class.forName("Students");3.运用.class的方式获取Class实例,对基本数据类型的封装类,还可以采用.TYPE来获取对应的基本数据类型的Class实例;Class c = Students.class; 所以对于我的例子而言,就是利用了obj.getClass()等价于Object.class这个特性来修改这个方法,大家可以自己试试。
3.添加测试案例JUnit
请注意看我上面给出的hbm.xml文件,主键生成机制是increment
现在问题又来了!!!当我用工具通过实体类生成hbm.xml文件时,主键生成机制是
assigned表示对象标识符由应用程序产生,如果不指定<generator>节点,则默认使用该策略。此时数据表还没有建立,当我开始测试的时候,Hibernate根据cfg.xml中的数据库信息和相关映射信息建立表,问题来了,Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry '0' for key 'PRIMARY'。 数据表grade中出现 “0 Java一班 Java软件开发一班 ”一条记录,数据表student中出现 “ 0 慕女神 女 0 ”一条记录,提示已经告诉我们主键重复,0主键已经存在,不能再进行添加了。assigned表示主键有程序代码负责,你要保证这个主键数据是唯一的。这时我在想,那我用identity生成策略会怎么样,identity表示对象标识符由底层数据库的自增主键生成机制产生。这样一搞 Caused by: java.sql.SQLException: Field 'SID' doesn't have a default value,马上反应过来自己没有在数据库设置AUTO_increment,需要去设置两个表的这个值。
这样一搞,就可以正常添加了。
当我设置好自动递增后,又想试试assigned,于是又改为了assigned,问题又来了Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1 ;百度之后,有人这样解释:这个异常是由于主键设置为自增长,而在我们插入记录的时候设置了ID的值导致的。懵逼了,到现在我还在找怎样解决,如果你有答案请告诉我。
之后我选用了increment生成策略,这个策略不需要在数据库中设置自动递增,感觉应付这种小例子很方便,不过他的局限性在于如果有多个应用实例向同一张表中插入数据时,则会出现重复的主键。需谨慎使用。
4.总结
这篇文章感觉挺凌乱的,一会是DAO修改一会又是反射,最后还自己搞了一堆BUG,自己还是需要慢慢积累知识才行,如果你觉得这篇文章有点用,请帮忙点个赞,谢谢观看。
作者:六月的余晖
出处:http://www.cnblogs.com/zhaozihan/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接,否则保留追究法律责任的权利。