Hibernate程序设计.ppt

Hibernate程序设计,第一讲 Hibernate概述 第二讲 对象关系映射基础 第三讲 复杂实体映射 第四讲 关联映射 第五讲 Hibernate查询,Hibernate 程序设计,第一讲 Hibernate 概述,Hibernate概述,一个主流的持久化框架 在JDBC基础上进行分装 只需要少量代码就可以完成持久化工作 一个优秀的ORM（对象-关系映射）机制 通过映射文件保存映射信息 在业务层以面向对象的方式编程，封装对数据库的访问细节.,应用程序中对象(O),姓名:mary 性别:女 年龄:20,ORM（对象-关系映射）： 完成对象数据到关系型数据映射的机制称为对象-关系映射，简称ORM。,持 久 化 层,什么是ORM？,数据库,关系型数据(R),优点: Productivity, Maintainability , Performance , Vendor independence,Hibernate 优势,开源 成熟 流行(约13 000 downloads/month) 自定义API JBoss用Hibernate3实现Entity Beans,下载及设置hibernate,/,第一个Hibernate案例,问题描述: 利用Hibernate API对Customer数据表增加记录 步骤: 添加Hibernate库 配置hibernate.cfg.xml 添加POJO对象类Customer 配置映射文件Customer.hbm.xml 在程序中实现对数据库的操作,hibernate.cfg.xml oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:localhost:1521:oradb scott tiger org.hibernate.dialect.Oracle9Dialect ,配置JDBC驱动,配置JDBC连库URL,用户名密码,指定数据库方言,Customer.hbm.xml cust_seq ,实体类到表的映射,主键生成方式,属性到字段的映射,7个步骤： Configuration 创建SessionFactory 打开Session 开始一个事务 持久化操作 save/update/delete/find 提交事务 关闭Session,在程序中实现对数据库的操作,public class Test01 private static SessionFactory factory; static Configuration cfg = new Configuration(); cfg.configure(); cfg.addClass(Customer.class); factory = cfg.buildSessionFactory(); public static void main(String args) Test01 test = new Test01(); test.testSave(); /* * 用于演示session的save方法 */,public void testSave() Session session = factory.openSession(); Customer c = new Customer(); c.setName(“peter“); c.setBirthday(new Date(0); Transaction tx = null; try tx = session.beginTransaction(); System.out.println(c); / 1 session.save(c); / 2 System.out.println(c); / 3 mit(); catch (HibernateException ex) ex.printStackTrace(); if (tx != null) tx.rollback(); finally session.close(); ,第二个Hibernate案例,利用Hibernate API对Customer数据表增加、修改、删除、查找记录,public void testDelete() Session session = factory.openSession(); Transaction tx = null; try tx = session.beginTransaction(); Customer c = (Customer) session.load(Customer.class, new Long(1); session.delete(c); mit(); catch (HibernateException ex) ex.printStackTrace(); if (tx != null) tx.rollback(); finally session.close(); ,public void testUpdate() Session session = factory.openSession(); Transaction tx = null; try tx = session.beginTransaction(); Customer c = new Customer(); c.setId(new Long(1); c.setName(“chris“); c.setBirthday(new Date(0); session.update(c); / 1 System.out.println(c); / 2 mit(); catch (HibernateException ex) ex.printStackTrace(); if (tx != null) tx.rollback(); finally session.close(); ,Hibernate 程序设计,第二讲 Hibernate 映射基础,Hibernate基本配置,Hibernate 配置文件： hibernate.cfg.xml POJO对象：Customer.class 映射文件：Customer.hbm.xml 应用程序：Test01.class,hibernate.cfg.xml, oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:localhost:1521:oradb scott tiger org.hibernate.dialect.Oracle9Dialect ,Hibernate配置文件,Hibernate映射文件Customer.hbm.xml, cust_seq ,Hibernate基本数据类型,Hibernate主键生成方式,Hibernate主键生成方式,Hibernate 架构,实体对象（Persistent Object） 持久化的对象 Hibernate配置文件 配置数据库连接信息 Hibernate映射文件 配置对象和关系表的映射信息,Hibernate核心API,Configuration对象负责管理数据库的配置信息 Configuration对象通过加载配置文件(hibernate.cfg.xml)获取并管理这些信息,Configuration config = new Configuration(); config.configure(); File file = new File(“C:myhibernate.xml”); Configuration config = new Configuration().configure(file);,通过classpath找配置文件,自定义配置文件的位置,Hibernate核心API,SessionFactory 负责创建Session对象 SessionFactory 对象中保存当前的数据库配置信息和所有映射关系以及预定义的SQL语句 SessionFactory负责维护Hibernate的二级缓存 SessionFactory对象采取了线程安全的设计方式,如何创建 SessionFactory对象?,Configuration config = new Configuration().configure(); SessionFactory factory = config.buildSessionFactory();,Hibernate核心API,Session 对象的添加、更新、删除和查询 Session的设计是非线程安全的 Session对象由SessionFactory对象创建,Configuration config = new Configuration().configure(); SessionFactory factory = config.buildSessionFactory(); Session session = factory.openSession();,Hibernate核心API,Transaction Hibernate本身没有事务管理功能，需要依赖JDBC或JTA的事务事务管理功能 使用Hibernate进行操作时（增、删、改）必须显式的调用Transaction（默认：autoCommit=false）,Transaction tx = session.beginTransaction();,持久化对象的生命周期,持久化对象的状态,Transient Objects： 使用new 操作符初始化的对象的状态是瞬时的，如果没有任何跟数据库表相关联的行为，只要应用不再引用这些对象，它们的状态将会丢失，并由垃圾回收机制回收。 Persist Objects： 如果内存中的对象和数据库的记录有对应关系，即和session对象相关，则此对象处于Persistent状态，在当事务提交时它们的状态和数据库进行同步 Detached Objects： Session关闭之后，持久化对象就变为detached对象。表示这个对象不能再与数据库保持同步，它们不再受Hibernate管理。,Hibernate 程序设计,第三讲 Hibernate 高级映射,实体映射（1）联合主键,在数据表设计时使用两个列作为联合主键时，用Hibernate API来完成对象关系映射 CREATE TABLE students ( firstname varchar2(16) NOT NULL, lastname varchar2(16) NOT NULL, major varchar2(100), PRIMARY KEY (firstname,lastname) );,实体映射（1）联合主键,StudentsId.java public class StudentsId implements java.io.Serializable private String firstname; private String lastname; Students.java public class Students implements java.io.Serializable private StudentsId id; private String major; ,实体映射（1）联合主键,实体映射（1）联合主键,Students student = new Students(); StudentsId pk = new StudentsId(); pk.setFirstname(“Michael“); pk.setLastname(“Scofield“); student.setId(pk); student.setMajor(“Building“); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(student); mit(); HibernateSessionFactory.closeSession(); 案例：02_UnionKey,实体映射（2）组合关系映射,CREATE TABLE Person( id number primary key, name varchar2(20), address_city varchar2(50), address_street varchar2(50), address_zipcode char(6), mailing_city varchar(50), mailing_street varchar(50), mailing_zipcode varchar(6) ); 有必要把其中的city, street, zipcode提取出来单独组成一个Address类，将这个类作为Person对象的一个组成部分出现。,实体映射（2）组合关系映射,Address.java public class Address private String city; private String street; private String zipcode; Person.java public class Person implements java.io.Serializable / Fields private Long id; private String name; private Address address; private Address mailAddress; ,实体映射（2）组合关系映射,映射组合关系 person_seq ,实体映射（2）组合关系映射,Person person = new Person(); person.setName(“peter“); Address address1 = new Address(“beijing“, “changan street“, “100080“); Address address2 = new Address(“tianjin“, “weijin street“, “300300“); person.setAddress(address1); person.setMailAddress(address2); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(person); mit(); HibernateSessionFactory.closeSession(); 案例：03_Component,实体映射（3）大对象类型映射,create table users( id number primary key, name varchar2(20), password varchar2(20), image blob, resume clob );,实体映射（3）大对象类型映射, . 0 ,Oracle JDBC不允许使用批处理方式进行操作，所以需要在Hibernate配置文件中，将hibernate.jdbc.batch_size设为0.,实体映射（3）大对象类型映射,Users.java public class Users implements java.io.Serializable / Fields private Long id; private String name; private String password; private Blob image; private Clob resume; ,实体映射（3）大对象类型映射, users_seq ,实体映射（3）大对象类型映射,Users user = new Users(); user.setName(“Scofield“); user.setPassword(“1234“); user.setResume(Hibernate.createClob(“ “); user.setImage(Hibernate.createBlob(new byte1); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(user); session.flush(); FileInputStream fileInputStream = new FileInputStream(“tomcat.gif“); session.refresh(user, LockMode.UPGRADE);/SELECT FOR UPDATE user.setResume(Hibernate.createClob(“a lots of words“); user.setImage(Hibernate.createBlob(fileInputStream); session.save(user); mit(); fileInputStream.close(); HibernateSessionFactory.closeSession();,Hibernate 程序设计,第四讲 Hibernate 关联映射,关联映射（1）集合类映射,映射集合类关系：一本书，可能属于多个类别 CREATE TABLE book( id number primary key, bookname varchar2(20) NOT NULL ) ; CREATE TABLE topic( id number, topicname varchar2(20) NOT NULL ) ; ALTER TABLE topic ADD PRIMARY KEY (id, topicname); ALTER TABLE topic ADD FOREIGN KEY (id) REFERENCES book (id);,关联映射（1） 集合类映射,Book.java public class Book implements java.io.Serializable private Long id; private String bookname; private Set topics = new HashSet(0); ,关联映射（1） 集合类映射, book_seq ,关联映射（1） 集合类映射,Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); Book book1 = new Book(); book1.setTopics(new HashSet(); book1.setBookname(“hibernate“); book1.addTopic(“java“); book1.addTopic(“O-R Mapping“); Book book2 = new Book(); book2.setTopics(new HashSet(); book2.setBookname(“struts“); book2.addTopic(“java“); book2.addTopic(“MVC“); session.save(book1); session.save(book2); mit(); HibernateSessionFactory.closeSession();,关联映射（2）一对多/多对一,一对多关联直接连接两个类对应的表,而没有连接表，两个表之间通过唯一的外键关联。 外键与另一个类的主键对应。 一对多的关联经常见到，如一个部门有很多员工，一个学校有很多学生等。,关联映射（2）一对多/多对一,Employee.java public class Employee implements java.io.Serializable private Long empid; private String ename; private Department department; Department.java public class Department implements java.io.Serializable / Fields private Long deptid; private String dname; private String location; private Set employees = new HashSet(0); ,关联映射（2）一对多/多对一, employee_seq ,关联映射（2）一对多/多对一, department_seq ,关联映射（2）一对多/多对一,Employee emp1 = new Employee(); emp1.setEname(“King“); Employee emp2 = new Employee(); emp2.setEname(“Scott“); Department dept1 = new Department(); dept1.setDname(“Accounting“); dept1.setEmployees(new HashSet(); dept1.addEmployee(emp1); dept1.addEmployee(emp2); emp1.setDepartment(dept1); emp2.setDepartment(dept1); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(dept1); mit(); HibernateSessionFactory.closeSession();,案例：06_one-to-many,Set集合,Set集合,name 集合属性的名称 table （可选）目标关联数据库表 lazy (可选默认为false)允许延迟加载（lazy initialization ） inverse (可选默认为false) 标记有哪一方来维护关联关系（双向关联中使用）。 cascade (可选默认为none) 让操作级联到子实体 order-by (可选, 仅用于jdk1.4) 指定表的字段(一个或几个)再加上asc或者desc(可选), 定义Map,Set和Bag的迭代顺序 where (可选) 指定任意的SQL where条件 outer-join(可选-默认为auto)是否使用外联接,cascade级联操作,关联映射（3）一对一：外键关联,一对一关联指两个表之间的记录是一一对应的关系。分为两种：外键关联和主键关联。 比如一家公司(Company)和它所在的地址(Address)。在业务逻辑中要求一家公司只有唯一的地址，一个地址也只有一家公司。 下图表现为外键关联关系。,关联映射（3）一对一：外键关联,Company.java public class Company implements java.io.Serializable private Long id; private String name; private Address address; ,Address.java public class Address implements java.io.Serializable / Fields private Long id; private String city; private String country; private Company company; ,关联映射（3）一对一：外键关联, company_seq ,关联映射（3）一对一：外键关联, address_seq ,关联映射（3）一对一：外键关联,Company company1 = new Company(); company1.setName(“OriStand“); Address address1 = new Address(); address1.setCity(“BeiJing“); address1.setCountry(“China“); company1.setAddress(address1); Company company2 = new Company(); company2.setName(“IBM“); Address address2 = new Address(); address2.setCity(“New York“); address2.setCountry(“American“); company2.setAddress(address2); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(company1); session.save(company2); mit(); HibernateSessionFactory.closeSession();,案例：07_one-to-one,关联映射（4）一对一：主键关联,一对一的另一种解决方式就是主键关联，在这种关联关系中，要求两个对象的主键必须保持一致，通过两个表的主键建立关联关系，无须外键参与。,关联映射（4）一对一：主键关联,POJO对象的结构和一对一关系中的外键关联方式相同。,关联映射（4）一对一：主键关联, company_seq ,关联映射（4）一对一：主键关联, company ,关联映射（4）一对一：主键关联,Company company1 = new Company(); company1.setName(“OriStand“); Address address1 = new Address(); address1.setCity(“BeiJing“); address1.setCountry(“China“); company1.setAddress(address1);/company-address address1.setCompany(company1);/address-company Company company2 = new Company(); company2.setName(“IBM“); Address address2 = new Address(); address2.setCity(“New York“); address2.setCountry(“American“); company2.setAddress(address2); address2.setCompany(company2); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(company1); session.save(company2); mit(); HibernateSessionFactory.closeSession();,案例：07_one-to-one,关联映射（5）多对多,多对多的实体关系模型也是很常见的，比如学生和课程的关系。一个学生可以选修多门课程，一个课程可以被多名学生选修。在关系型数据库中对于多对多关联关系的处理一般采用中间表的形式，将多对多的关系转化成两个一对多的关系。,关联映射（5）多对多,Student.java public class Student implements java.io.Serializable private Long id; private String name; private Set courses = new HashSet(0); ,Course.java public class Course implements java.io.Serializable private Long id; private String name; private Set students = new HashSet(0); ,关联映射（5）多对多, student_seq ,关联映射（5）多对多, course_seq ,关联映射（5）多对多,Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); Student student1 = new Student(); student1.setName(“peter“); student1.setCourses(new HashSet(); Student student2 = new Student(); student2.setName(“scott“); student2.setCourses(new HashSet(); Course course1 = new Course(); course1.setName(“Java“); Course course2 = new Course(); course2.setName(“Oracle“); student1.addCourse(course1); student1.addCourse(course2); student2.addCourse(course1); student2.addCourse(course2); session.save(student1); session.save(student2); mit(); HibernateSessionFactory.closeSession();,案例：08_many-to-many,关联映射（6）继承关系映射,在业务逻辑的设计中，继承关系是非常常见的。对于继承关系在数据库中数据表上的映射方式， Hibernate支持三种不同的基本继承映射策略。以第一种为例：类继承关系树中每个类共用一个表（table per class hierarchy）。,关联映射（6）继承关系映射,Employee.java public class Employee implements java.io.Serializable private Long id; private String name; private Double salary; private String position; private Manager mgr; Manager.java public class Manager extends Employee Set clerks; Clerk.java public class Clerk extends Employee Manager manager; ,关联映射（6）继承关系映射, employee_seq ,关联映射（6）继承关系映射,Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); Manager m = new Manager(); m.setName(“king“); m.setSalary(3000.00); Clerk c1 = new Clerk(); Clerk c2 = new Clerk(); c1.setName(“peter“); c2.setName(“scott“); c1.setManager(m); c1.setSalary(1000.00); c2.setManager(m); c2.setSalary(1200.00); HashSet clerks = new HashSet(); clerks.add(c1); clerks.add(c2); m.setClerks(clerks); session.save(m); mit(); session.close();,案例：09_Inherit,Hibernate 程序设计,第五讲 Hibernate 查询,查询概述,Hibernate语言查询（Hibernate Query Language HQL）： 完全面向对象的查询语句，查询功能非常强大，具备继承、多态和关联等特性 。 Hibernate官方推荐使用HQL进行查询。 标准化对象查询(Criteria Query)： 以对象的方式进行查询，将查询语句封装为对象操作。 优点：可读性好，符合Java 程序员的编码习惯。 缺点：不够成熟，不支持投影（projection）或统计函数（aggregation） Native SQL Queries（原生SQL查询）： 直接使用数据库提供的SQL方言进行查询。,HQL 基本查询,HQL查询过程中操作对象是类、实例或属性，而不是表列行等概念，HQL可以理解如继承关联等面向对象概念 基本的HQL查询有： from Employee select , dept.description from Department as dept order by desc select distinct emp.deptno from Employee as emp select new Department(,dept.description) from Department as dept order by asc,HQL 基本查询,Session session = factory.openSession(); Query query =session.createQuery(“from Customer “); List customers=query.list(); Iterator iterator=customers.iterator(); while(iterator.hasNext() Customer customer=(Customer)iterator.next(); System.out.println(customer.getID()+“t“+ customer.getName()+“t“+ customer.getSalary(); ,是对象类型而非数据表,结果集为对象集,不用处理复杂的resultSet,HQL 基本查询,Session session = factory.openSession(); Query query =session.createQuery( “select ,c.salary from Customer as c“); List customers=query.list(); Iterator iterator=customers.iterator(); while(iterator.hasNext() Object obj=(Object )iterator.next(); System.out.prin