Java框架之Hibernate（二）
本文主要介绍：
1 Criteria 接口
2 用 myeclipse 反向生成
3 hibernate 主键生成策略
4 多对一
5 一对多
6 使用List 集合的一对多
7 多对多
一、Criteria 接口
//例一 public static AdminInfo getLoginAdminCriteria(String adminName,String password){ try{ Session s=HibUtil.getSession(); Criteria c=s.createCriteria(AdminInfo.class); c.add(Restrictions.eq("adminName", adminName)); c.add(Restrictions.eq("password", password)); return (AdminInfo) c.uniqueResult(); }finally{ HibUtil.closeSession(); } }
QBC常用限定方法
Restrictions.eq --> equal,等于.
Restrictions.allEq --> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq的效果
Restrictions.gt --> great-than > 大于
Restrictions.ge --> great-equal >= 大于等于
Restrictions.lt --> less-than, < 小于
Restrictions.le --> less-equal <= 小于等于
Restrictions.between --> 对应SQL的between子句
Restrictions.like --> 对应SQL的LIKE子句
Restrictions.in --> 对应SQL的in子句
Restrictions.and --> and 关系
Restrictions.or --> or 关系
Restrictions.isNull --> 判断属性是否为空,为空则返回true
Restrictions.isNotNull --> 与isNull相反
Restrictions.sqlRestriction --> SQL限定的查询
Order.asc --> 根据传入的字段进行升序排序
Order.desc --> 根据传入的字段进行降序排序
MatchMode.EXACT --> 字符串精确匹配.相当于"like 'value'"
MatchMode.ANYWHERE --> 字符串在中间匹配.相当于"like '%value%'"
MatchMode.START --> 字符串在最前面的位置.相当于"like 'value%'"
MatchMode.END --> 字符串在最后面的位置.相当于"like '%value'"
//例子 Criteria c=s.createCriteria(AdminInfo.class); // 查询 id在 10 到 30 之间的用户 c.add(Restrictions.between("id",10,30)).list(); //查询 adminName 在 张三,李四,王五之间的 String [] names={"张三","李四","王五"}; //这里也可以用集合 只要是从Collection派生的都可以 c.add(Restrictions.in("userName",names)).list(); //查询 note为空的用户 c.add(Restrictions.isNull("note")).list(); //查询年龄为空,或名字为admin的 c.add(Restrictions.or(Restrictions.eq("adminName", "admin"),Restrictions.isNull("age")));
//使用 QBC实现动态查询(以前的例子) public List<AdminInfo> getAdminList(String adminName,String password,String note) { String sql="select * from adminInfo where 1=1 "; if(adminName!=null){ sql+=" and adminName='"+addminName+"'"; } if(password!=null){ sql+=" and adminName='"+password+"'"; } if(note!=null){ sql+=" and adminName='"+note+"'"; } }
//上例使用 QBC public static List<AdminInfo> getLoginAdminList(String adminName,String password,String note){ try { Session s=HibUtil.getSession(); Criteria c=s.createCriteria(AdminInfo.class); if(adminName!=null){ c.add(Restrictions.eq("adminName", adminName)); } if(password!=null){ c.add(Restrictions.eq("password", password)); } if(note!=null){ c.add(Restrictions.eq("note", note)); } return c.list(); }finally{ HibUtil.closeSession(); } } //官方推荐使用HQL
二、用 myeclipse 反向生成
Hibernate 的开发流程
1) 由domain对象开始 bean -> 生成xml -> 生成数据库表
2) 由数据库表开始, 由表生成 bean 和 配置文件
3) 由配置文件开始
关于 <property name="hbm2ddl.auto">update</property> 这个配置
#Hibernate.hbm2ddl.auto create-drop //创建,用完之后再删除
#Hibernate.hbm2ddl.auto create //这个操作会重新创建表
#Hibernate.hbm2ddl.auto update //会把对象模型的变化,表现在关系模型上
#Hibernate.hbm2ddl.auto validate //当对象模型和关系模不一样的时候,会发生错误(通常生产环境下用)
三、Hibernate 主键生成策略
所有的主键生成器都实现了 org.Hibernate.id.IdentifierGenerator 接口
常用的主键生成器
1) increament: 适合所有的数据库, 由hiberante来维护主键的生成(先查询最大的,再加1), 有线程安全问题,不适合多个进程的情况。用于 long ,short ,int ,生成的是数字型的自增的唯一标识,在集群的情况下不要用实测,在mysql下,无论原来是否设置了自增主键,用它都可以
2) identity: 适合于mysql , mssqlserver 等支持自增主键的数据库,主键不由 Hibernate 来维护,类型是 int, short,long。oracle中不能用 (无法将 NULL 插入 ("SA"."USERINFO"."ID") 这样的异常)
3) sequence: (顺列) 适合于oracle等支持序列的数据库, 主键值不由Hibernate维护。mysql不支持(出现 Dialect does not support sequences 这样的异常), 在 oracle中直接这样写: <generator class="sequence" /> 它会对所有的表使用同一个序列。
4) native: 和底层数据库的具体特性有关, 如果是mysql或 mssqlserver ,它就会选择 identity, 如果是oracle 它会选 sequence
5) hilo: 高低位 根据 hilo算法 生成主键,支持所有的数据库, 需要一张额外的表生成的表名 默认是 Hibernate_unique_key 里面就一列 next_hi
<id name="id" type="java.lang.Integer">
<column name="id" />
<generator class="hilo" >
<param name="table">t_key</param>
<param name="column">f_nextval</param>
<param name="max_lo">100</param>
</generator>
</id>
6) uuid : Hibernate 来维护的主键 ,支持所有数据库
<id name="id" >
<column name="id" />
<generator class="uuid" />
</id>
//附 用java程序生成uuid => UUID.randomUUID().toString() c6204dc1-b9b6-40a9-a03a-a35ab6e6adc
7) assigned : 主键由用户来维护, 如果选择了这种生成方式,则Hibernate不再帮我们生成主键,主键要由用户。在程序中指定,不指定将出错 ids for this class must be manually assigned before calling save():
四、多对一
//对象模型 //尼姑 public class NiGu { private int id; private String fahao; private NiGuAn niguan; // 用的是NiGuAn 对象 这样就建立起了一对多的关联 } //尼姑庵 public class NiGuAn { private int id; private String name; }
//映射文件 (NiGuAn.hbm.xml) <Hibernate-mapping> <class name="cat.beans.NiGuAn" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="name" /> </class> </Hibernate-mapping> NiGu.hbm.xml <Hibernate-mapping> <class name="cat.beans.NiGu" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="fahao" /> <many-to-one name="niguan" column="niguan_id" /> //让它生成的外键这列的名字叫 niguan_id </class> </Hibernate-mapping>
//添加的方法 public static void add(){ try{ NiGuAn niguan= new NiGuAn(); niguan.setName("普渡寺"); NiGu nigu=new NiGu(); nigu.setFahao("灭绝师太"); //建立起两对象模型的关联 nigu.setNiguan(niguan); Session s=HibUtil.getSession(); Transaction tx=s.beginTransaction(); s.save(niguan); //先存的是尼姑庵 s.save(nigu); tx.commit(); } finally{ HibUtil.closeSession(); } }
总结:：
1) 只要对象模型建好了,生成关系模型(数据库表)的时候,也能正确的生成
2) 如果把上面的
s.save(niguan); 反过来写,会多生成一条sql语句,用来维护关联关系
s.save(nigu);
3) 如果不 s.save(niguan); 将出现下面的异常信息
object references an unsaved transient instance - save the transient instance before flushing: cat.beans.NiGuAn
对象引用了一个没有保存的瞬时对象
//查询 public static void main(String[] args) { NiGu nigu=searchNiGu(); System.out.println(nigu.getFahao()); //可以输出结果 /* 被关联的对象,查询的时候默认是使用懒加载的 如果下面的代码中没有 Hibernate.initialize(nigu.getNiguan()); 这句,将引发 could not initialize proxy - no Session */ System.out.println(nigu.getNiguan().getName()); } //关于查询的例二 public static NiGu searchNiGu(){ try{ Session s=HibUtil.getSession(); NiGu nigu= (NiGu) s.get(NiGu.class,1 ); Hibernate.initialize(nigu.getNiguan()); //通知Hibernate 直接把关联的数据查询出来 return nigu; }finally{ HibUtil.closeSession(); } } //关于查询的例一 public static void search(){ try{ Session s=HibUtil.getSession(); NiGu nigu= (NiGu) s.get(NiGu.class,1 ); System.out.println(nigu.getFahao()); System.out.println(nigu.getNiguan().getName()); //能否把关联的数据查出来 ? }finally{ HibUtil.closeSession(); } }
五、一对多
//对象模型 //尼姑庵 public class NiGuAn { private int id; private String name; private Set<NiGu>niguList; //一对多关联 }
//映射文件(NiGuAn.hbm.xml) <Hibernate-mapping> <class name="cat.beans.NiGuAn" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="name" /> <set name="niguList"> <key column="niguan_id" /> <one-to-many class="NiGu" /> </set> </class> </Hibernate-mapping>
//映射文件 (NiGuAn.hbm.xml) <Hibernate-mapping> <class name="cat.beans.NiGuAn" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="name" /> </class> </Hibernate-mapping> NiGu.hbm.xml <Hibernate-mapping> <class name="cat.beans.NiGu" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="fahao" /> <many-to-one name="niguan" column="niguan_id" /> //让它生成的外键这列的名字叫 niguan_id </class> </Hibernate-mapping>
//添加的方法 public static void add(){ NiGuAn niguan=new NiGuAn(); niguan.setName("少林寺"); NiGu nigu1=new NiGu(); nigu1.setNiguan(niguan); nigu1.setFahao("空闻"); NiGu nigu2=new NiGu(); nigu2.setNiguan(niguan); nigu2.setFahao("玄苦"); try{ Session s=HibUtil.getSession(); Transaction tx=s.beginTransaction(); /* Set<NiGu> niguList=new HashSet<NiGu>(); niguList.add(nigu1); niguList.add(nigu2); niguan.setNiguList(niguList); */ s.save(niguan); s.save(nigu1); s.save(nigu2); tx.commit(); }finally{ HibUtil.closeSession(); } public static void main(String[] args) { // add(); NiGuAn niguan= search2(); System.out.println(niguan.getName()); for(NiGu n:niguan.getNiguList()){ System.out.println(n.getFahao()); } } public static NiGuAn search2(){ try{ Session s=HibUtil.getSession(); NiGuAn niguan= (NiGuAn) s.get(NiGuAn.class, 4); Hibernate.initialize(niguan.getNiguList()); return niguan; }finally{ HibUtil.closeSession(); } } public static void search(){ try{ Session s=HibUtil.getSession(); NiGuAn niguan =(NiGuAn) s.get(NiGuAn.class, 4); System.out.println(niguan.getName()); Set<NiGu> niguList= niguan.getNiguList(); for (NiGu n:niguList) { System.out.println(n.getFahao()); } }finally{ HibUtil.closeSession(); } }
六、使用List 集合的一对多
对象模型中的set 要换成list
<!-- 把它换成下面的配置即可 <set name="niguList"> <key column="niguan_id" /> <one-to-many class="NiGu" /> </set> --> <list name="niguList"> <key column="niguan_id" /> <index column="indexNo" /> <one-to-many class="NiGu" /> </list>
//如果对象模型还是使用list,但关系模型中不要排序列,可以用bag 来配置 <bag name="niguList"> <key column="niguan_id" /> <one-to-many class="NiGu" /> </bag>
//添加方法 public static void add(){ NiGuAn niguan=new NiGuAn(); niguan.setName("九峰寺"); NiGu nigu1=new NiGu(); nigu1.setNiguan(niguan); nigu1.setFahao("空空大师"); NiGu nigu2=new NiGu(); nigu2.setNiguan(niguan); nigu2.setFahao("玄玄"); NiGu nigu3=new NiGu(); nigu3.setNiguan(niguan); nigu3.setFahao("灭绝"); try{ Session s=HibUtil.getSession(); Transaction tx=s.beginTransaction(); List<NiGu> niguList=new ArrayList<NiGu>(); niguList.add(nigu1); niguList.add(nigu2); niguList.add(nigu3); niguan.setNiguList(niguList); s.save(niguan); s.save(nigu1); s.save(nigu2); s.save(nigu3); tx.commit(); //说明 /* List<NiGu> nlist=niguan.getNiguList(); 没有问题 ArrayList<NiGu> nlist=(ArrayList<NiGu> )niguan.getNiguList(); 将出现异常 ClassCastException: org.Hibernate.collection.PersistentBag cannot be cast to java.util.ArrayList */ }finally{ HibUtil.closeSession()
七、多对多
//对象模型 public class Student { private int id; private String stuName; private Set<Teacher> teacherList; } public class Teacher { private int id; private String teacherName; private Set<Student> stuList; //建立关联 }
//Teacher.hbm.xml <Hibernate-mapping package="cat.beans"> <class name="Teacher" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="teacherName" /> <set name="stuList" table= "teacher_student" lazy="false"> //指明不要懒加载 <key column="teacher_id" /> <!-- 将来根据 teacher_id列表中间表找学生 --> <many-to-many class="Student" column="stucent_id" /> </set> </class> </Hibernate-mapping>
//Student.hbm.xml <Hibernate-mapping package="cat.beans"> <class name="Student" > <id name="id"> <column name="id" /> <generator class="native" /> </id> <property name="stuName" /> <set name="teacherList" table= "teacher_student"> <key column="student_id" /> <many-to-many class="Teacher" column="teacher_id" /> </set> </class> </Hibernate-mapping>
//测试 public static void main(String[] args) { Teacher t=search(); System.out.println(t.getTeacherName()); for(Student stu:t.getStuList()){ System.out.println(stu.getStuName()); } } public static Teacher search(){ return (Teacher) HibUtil.get(Teacher.class, 1); } public static void add(){ //老师的数据 Teacher t1=new Teacher(); t1.setTeacherName("成秀秀"); Teacher t2=new Teacher(); t2.setTeacherName("史老师"); Set<Teacher> teacherList=new HashSet<Teacher>(); teacherList.add(t1); teacherList.add(t2); //学生的数据 Student stu1=new Student(); stu1.setStuName("刘冰"); Student stu2=new Student(); stu2.setStuName("侯晨阳"); Set<Student> studentList=new HashSet<Student>(); studentList.add(stu1); studentList.add(stu2); t1.setStuList(studentList); //建立起老师和学生的关联 t2.setStuList(studentList); ///////有没有必要////// //stu1.setTeacherList(teacherList); //stu2.setTeacherList(teacherList); ////////////////////// Session s=HibUtil.getSession(); Transaction tx=s.beginTransaction(); s.save(t1); s.save(t2); s.save(stu1); s.save(stu2); tx.commit(); s.close(); }
高低位: 附:它的算法
next_hi * (max_lo + 1) + lo
1. 读取并记录数据库的Hibernate_unique_key表中next_hi字段的值，数据库中此字段值加1 并保存
2. nHibernate取得lo值（从0循环到（max_lo-1），到max_lo的时候，再执行步骤1，然后 lo继续从 0循环到（max_lo-1））
3. 最后根据公式计算主键值。
注意：
所谓的hilo性能比identity好的前提是在同一Session里批量添加记录的时候（id不用每添加一条记录都从数据库里返回）；
如果两条记录在不同的Session添加，那么每条记录的id值会相隔32767的差值（max_lo默认值是 32767时）。
由于我们多数都是一条一条记录的添加的，这样如果按 max_lo的默认值32767来生成主键的话，其值很快就会暴增，甚至会出现溢出的可能。
