BlogJava-想飞就别怕摔-随笔分类-Hibernate

Hibernate Annotation -- (JPA)

生命的绽放 — Wed, 14 Jul 2010 14:31:00 GMT

摘要: User.java 1 package com.test.bean; 2 3 import java.util.Date; 4 import java.util.HashSet; 5 im... 阅读全文

生命的绽放 2010-07-14 22:31 发表评论

Hibernate学习（七）---【继承映射--每棵继承树映射成一张表】

生命的绽放 — Sun, 01 Nov 2009 10:45:00 GMT

每棵继承树映射成一张表

1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：
子类使用标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、理解如何存储
存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值
正确的加载对象

多态查询：在hibernate加载数据的时候能鉴别出正真的类型（instanceOf）

get支持多态查询
load只有在lazy=false，才支持多态查询
hql支持多态查询

package com.bjsxt.hibernate;

public class Animal {

    private int id;

    private String name;

    private boolean sex;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }
}

package com.bjsxt.hibernate;

public class Bird extends Animal {

    private int height;

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

package com.bjsxt.hibernate;

public class Pig extends Animal {

    private int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

xml version="1.0"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
    <class name="Animal" table="t_animal" lazy="false">
        <id name="id">
            <generator class="native"/>
        id>
        <discriminator column="type" type="string"/>
        <property name="name"/>
        <property name="sex"/>
        <subclass name="Pig" discriminator-value="P">
            <property name="weight"/>
        subclass>
        <subclass name="Bird" discriminator-value="B">
            <property name="height"/>
        subclass>
    class>
hibernate-mapping>

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class ExtendsTest extends TestCase {

    public void testSave1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            Pig pig = new Pig();
            pig.setName("猪猪");
            pig.setSex(true);
            pig.setWeight(100);
            session.save(pig);

            Bird bird = new Bird();
            bird.setName("鸟鸟");
            bird.setSex(false);
            bird.setHeight(50);
            session.save(bird);

            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用load，通过Pig查询
     */
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            Pig pig = (Pig)session.load(Pig.class, 1);
            System.out.println(pig.getName());

            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用load，通过Animal查询
     */
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            Animal animal = (Animal)session.load(Animal.class, 1);
            System.out.println(animal.getName());

            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用load，通过Animal查询
     */
    public void testLoad3() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            Animal animal = (Animal)session.load(Animal.class, 1);

            //因为load默认只是lazy，因为我们看到的是Animal的代理对象
            //所以通过instanceof是反应不出正真的对象类型的
            //因此load在默认情况下是不支持多态查询的
            if (animal instanceof Pig) {
                System.out.println(animal.getName());
            }else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用load，通过Animal查询,将标签上的lazy=false
     */
    public void testLoad4() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            Animal animal = (Animal)session.load(Animal.class, 1);
            //可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
            //此时load支持多态查询
            if (animal instanceof Pig) {
                System.out.println(animal.getName());
            }else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用get，通过Animal查询
     */
    public void testLoad5() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();

            //可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
            //get支持多态查询
            Animal animal = (Animal)session.get(Animal.class, 1);

            if (animal instanceof Pig) {
                System.out.println(animal.getName());
            }else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

    /**
     * 采用get，通过Animal查询
     */
    public void testLoad6() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
//            List animalList = session.createQuery("from Animal").list();
//            for (Iterator iter = animalList.iterator(); iter.hasNext();) {
//                Animal a = (Animal)iter.next();
//                //能够正确的鉴别出正真的类型，hql是支持多态查询的
//                if (a instanceof Pig) {
//                    System.out.println("是Pig");
//                }else if (a instanceof Bird) {
//                    System.out.println("是bird");
//                }
//            }

            List list = session.createQuery("from java.lang.Object").list();
            for (Iterator iter=list.iterator(); iter.hasNext();) {
                Object o = iter.next();
                if (o instanceof Pig) {
                    System.out.println("是Pig");
                }else if (o instanceof Bird) {
                    System.out.println("是bird");
                }
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }

}

生命的绽放 2009-11-01 18:45 发表评论

Hibernate学习（六）---【一对多双项】

生命的绽放 — Sun, 01 Nov 2009 08:30:00 GMT

package com.zzn.hibernate.oneToMany;

public class Student {
    private int id;
    private String name;
    private Classes classes;

    public Classes getClasses() {
        return classes;
    }
    public void setClasses(Classes classes) {
        this.classes = classes;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

package com.zzn.hibernate.oneToMany;

import java.util.Set;

public class Classes {
    private int id;
    private String name;
    private Set students;

    public Set getStudents() {
        return students;
    }
    public void setStudents(Set students) {
        this.students = students;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


}

xml version="1.0"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zzn.hibernate.oneToMany">
    <class name="Classes" table="CLASSES">
        <id name="id" column="id">
            <generator class="native" />
        id>
        <property name="name" />

        <set name="students" cascade="all" inverse="true">

            <key column="classesid"/>
            <one-to-many class="Student"/>
        set>
    class>
hibernate-mapping>

TEST

    public void OneToManySaveN() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            Classes classes = new Classes();
            classes.setName("俄罗斯");

            Student student = new Student();
            student.setName("列宁");
            student.setClasses(classes);
            session.save(student);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }

    public void OneToManyLoadN() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            Student    student = (Student)session.load(Student.class, 6);
            System.out.println(student.getName());
            System.out.println(student.getClasses().getName());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }

生命的绽放 2009-11-01 16:30 发表评论

Hibernate学习（五）---【一对多单项】

生命的绽放 — Sun, 01 Nov 2009 08:01:00 GMT

Classes和Student一对多。要站在classes这段来看。
classes.java

Student.java

package com.zzn.hibernate.oneToMany;

public class Student {
    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Class.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">
<hibernate-mapping package="com.zzn.hibernate.oneToMany">
    <class name="Classes" table="CLASSES">
        <id name="id" column="id">
            <generator class="native" />
        id>
        <property name="name" />

        <set name="students" cascade="all">

            <key column="classesid"/>
            <one-to-many class="Student"/>
        set>
    class>
hibernate-mapping>

Student.hbm.xml

test.java

package com.zzn.hibernate;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zzn.hibernate.hibernateUtil.HibernateUtils;
import com.zzn.hibernate.oneToMany.Classes;
import com.zzn.hibernate.oneToMany.Student;

public class OneToManyTest extends TestCase {

    @SuppressWarnings("unchecked")
    public void OneToManySave() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            Student student1 = new Student();
            student1.setName("刘德华");
            Student student2 = new Student();
            student2.setName("周杰伦");

            Set students = new HashSet();
            students.add(student1);
            students.add(student2);

            Classes classes = new Classes();
            classes.setName("中国");
            classes.setStudents(students);

            session.save(classes);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }

    @SuppressWarnings("unchecked")
    public void OneToManyLoad() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            Classes classes = (Classes)session.load(Classes.class, 1);
            Set students = classes.getStudents();
            for (Iterator iter=students.iterator(); iter.hasNext();){
                Student student = (Student)iter.next();
                System.out.println("student.name="+student.getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }
}

生命的绽放 2009-11-01 16:01 发表评论

Hibernate学习（四）---【一对一唯一外键双向关联】

生命的绽放 — Sun, 01 Nov 2009 06:07:00 GMT

Person.java

package com.zzn.hibernate.OneToOne;

public class Person {
    private int id;
    private String name;
    private int age;
    private IdCard idCard;

    public IdCard getIdCard() {
        return idCard;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

IdCard.java

package com.zzn.hibernate.OneToOne;

public class IdCard {
    private int id;
    private String cardNo;
    private Person person;
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }

}

Person.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">
<hibernate-mapping>
    <class name="com.zzn.hibernate.OneToOne.Person" table="PERSON">
        <id name="id" column="id">
            <generator class="native" />
        id>
        <property name="name" />
        <property name="age" />

        <many-to-one name="idCard" unique="true" cascade="all"/>
    class>
hibernate-mapping>

IdCard.hbm.xml

test.java

public class OneToOne_pk2 extends TestCase {
    public void OneToOne_pk2_1() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            IdCard idCard = new IdCard();
            Person person = new Person();

            idCard.setCardNo("333333");
            person.setName("刘德华");
            person.setAge(50);
            person.setIdCard(idCard);
            session.save(person);

            System.out.println("person's name = " + person.getName());
            System.out.println("idCard's cardNo = "
                    + person.getIdCard().getCardNo());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }
    public void OneToOne_3() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            IdCard idCard = (IdCard)session.load(IdCard.class,3);
            System.out.println("person's name = " +idCard.getPerson().getName());
            System.out.println("idCard's cardNo = "+idCard.getCardNo());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }
}

生命的绽放 2009-11-01 14:07 发表评论

Hibernate学习（二）---【一对一唯一外键单向关联】

生命的绽放 — Sun, 01 Nov 2009 04:54:00 GMT

一对一外键关联其实就是多对多特例。
person.java

package com.zzn.hibernate.OneToOne;

public class Person {
    private int id;
    private String name;
    private int age;
    private IdCard idCard;
    public IdCard getIdCard() {
        return idCard;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

IdCard.java

package com.zzn.hibernate.OneToOne;

public class IdCard {
    private int id;
    private String cardNo;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }

}

Person.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">
<hibernate-mapping>
    <class name="com.zzn.hibernate.OneToOne.Person" table="PERSON">
        <id name="id" column="id">
            <generator class="native" />
        id>
        <property name="name" />
        <property name="age" />

        <many-to-one name="idCard" unique="true" cascade="all"/>
    class>
hibernate-mapping>

IdCard.hbm.xml

test.java

public class OneToOne_pk2 extends TestCase {
    public void OneToOne_pk2_1() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            IdCard idCard = new IdCard();
            Person person = new Person();

            idCard.setCardNo("222222");
            person.setName("刘德华");
            person.setAge(50);
            person.setIdCard(idCard);
            session.save(person);

            System.out.println("person's name = " + person.getName());
            System.out.println("idCard's cardNo = "
                    + person.getIdCard().getCardNo());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }

    public void OneToOne_pk2_2() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            for (int i=1 ;i<=2;i++){
            Person person = (Person)session.load(Person.class, i);
            System.out.println("person's name = " + person.getName());
            System.out.println("idCard's cardNo = "
                    + person.getIdCard().getCardNo());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }
}

生命的绽放 2009-11-01 12:54 发表评论

Hibernate学习（三）---【一对一主键双向关联】

生命的绽放 — Sun, 01 Nov 2009 04:08:00 GMT

Person和IdCard一对一双向关联
Person.java

package com.zzn.hibernate.OneToOne;

public class Person {
    private int id;
    private String name;
    private int age;

    //双向关联需要加上Idcard的属性
    private IdCard idCard;
    public IdCard getIdCard() {
        return idCard;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

IdCard.java

package com.zzn.hibernate.OneToOne;

public class IdCard {
    private int id;
    private String cardNo;
    //双向关联需要加上person的属性；
    private Person person;

    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }

}

Person.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">
<hibernate-mapping>
    <class name="com.zzn.hibernate.OneToOne.Person" table="PERSON">
        <id name="id" column="id">
            <generator class="foreign">
                <param name="property">idCardparam>
            generator>
        id>
        <property name="name" />
        <property name="age" />
        <one-to-one name="idCard" constrained="true" />
    class>
hibernate-mapping>

Idcard.hbm.xml

test

package com.zzn.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zzn.hibernate.OneToOne.IdCard;
import com.zzn.hibernate.OneToOne.Person;
import com.zzn.hibernate.hibernateUtil.HibernateUtils;

public class OneToOne_pk2 extends TestCase {
    public void OneToOne_pk2_1() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            IdCard idCard = new IdCard();
            Person person = new Person();

            idCard.setCardNo("11111111");
            person.setName("刘德华");
            person.setAge(50);
            person.setIdCard(idCard);
            System.out.println("person's name = " + person.getName());
            System.out.println("idCard's cardNo = "
                    + person.getIdCard().getCardNo());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    tx.commit();
                    session.close();
                }
            }
        }
    }

    public void OneToOne_pk2_2() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            IdCard idCard = new IdCard();
            Person person = new Person();

            person.setName("周杰伦");
            person.setAge(30);
            idCard.setCardNo("2222222");
            idCard.setPerson(person);

            System.out.println("idCard's number = " + idCard.getCardNo());
            System.out.println("person's name = "
                    + idCard.getPerson().getName());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            tx.commit();
            HibernateUtils.closeSession(session);
        }
    }
}

生命的绽放 2009-11-01 12:08 发表评论

Hibernate学习（一）---【多对一】

生命的绽放 — Sat, 31 Oct 2009 11:17:00 GMT

User和Group，关系多对一。
注意：cascade是级联。也就是说对主表保存、更新、删除都会级联的操作附表。
User.java

1 public class User {
         private String id;
3     private String name;
4     private int age;
5     private Group group;
6     get(),set()省略
7 }

Group.java

1 public class Group {
2 private String id ;
3 private String name ;
...get(),set()省略

4 }

User.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">
<hibernate-mapping>
    <class name="com.zzn.hibernate.many2One.User" table="USER">
        <id name="id" column="id">
            <generator class="uuid" />
        id>
        <property name="name" />
        <property name="age" />
        <many-to-one name="group" column="GROUP_ID" cascade="all"/>
    class>
hibernate-mapping>

Group.hbm.xml

hibernate.cfg.xml

DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernateproperty>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty>
        <property name="hibernate.connection.username">rootproperty>
        <property name="hibernate.connection.password">rootproperty>
        <property name="hibernate.hbm2ddl.auto">updateproperty>
        <property name="show_sql">trueproperty>

        <mapping resource="com/zzn/hibernate/many2One/User.hbm.xml"/>
        <mapping resource="com/zzn/hibernate/many2One/Group.hbm.xml"/>
    session-factory>
hibernate-configuration>

test.java

package com.zzn.hibernate;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.zzn.hibernate.hibernateUtil.HibernateUtils;
import com.zzn.hibernate.many2One.Group;
import com.zzn.hibernate.many2One.User;

public class Many2OneTest extends TestCase {

    public void testSaveMany2One(){
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateUtils.getSession();
            transaction= session.beginTransaction();
            Group group = new Group();
            group.setName("11111");
            User user = new User();
            user.setName("刘德华");
            user.setAge(80);
            user.setGroup(group);

            User user2 = new User();
            user2.setName("周杰伦");
            user2.setAge(25);
            user2.setGroup(group);


            session.save(user1);
            session.save(user2);
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }
    public void testUpdateMany2One(){
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateUtils.getSession();
            transaction= session.beginTransaction();
            User user = (User)session.get(User.class, "402881e424a9fb110124a9fb124c0001");
            Group group = new Group();
            group.setName("无敌");
            user.setName("刘天王");
            user.setAge(22);
            user.setGroup(group);

            session.update(user);

            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }


    public void testDeleteMany2One(){
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateUtils.getSession();
            transaction= session.beginTransaction();
            User user = (User)session.get(User.class, "402881e424a9e7d80124a9e7d9270001");
            session.delete(user);
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }

}

生命的绽放 2009-10-31 19:17 发表评论

Hibernate 高级查询技巧——集合过滤与子查询(转)

生命的绽放 — Mon, 26 Oct 2009 14:48:00 GMT

转自：http://blog.csdn.net/javacoffe/archive/2007/08/09/1733579.aspx
1、集合过滤：

对于一个已经加载的Customer对象，假设对它的orders集合采用延迟加载机制，那么当调用customer.getOrders().iterator()时，Hibernate就会初始化orders集合，然后到数据库中去加载Customer对象所关联的Order对象，并且填充orders集合，但是很多时候我们其实只是需要关联对象中符合某些条件的一部分对象，而并不需要加载全部关联对象，而对性能带来无谓的开销。这时候我们就可以利用Hibernate的集合过滤功能，来处理关联对象的加载。我们看下面的代码：

List list=session.createFilter(customer.getOrders(),“where this.price>100 order by this.price”).list();

for(int i=0;i

Order order=(Order)list.get(i);

}

在上面代码中通过session.createFilter()方法，创建了一个集合过滤的查询对象，这个方法需要两个参数，第一个参数指定需要进行过滤操作的集合，第二个参数指定过滤集合的条件，方法返回Query对象。这个方法不要求它所要操作的集合对象已经初始化，但是要求包含这个集合对象的实体对象必须处于持久化状态。当执行list()方法时不管持久化对象的集合是否已经初始化，都会到数据库中去检索数据，为了保证在Hibernate缓存中不会出现OID相同的对象，如果集合对象已经初始化，list()方法不会创建新的关联实体对象，而仅仅返回已经存在的关联实体对象。如果集合对象还没有初始化，那么list()方法会创建关联实体对象，但是不会初始化容纳关联实体对象的集合。除了可以向集合对象添加过滤条件进行稽核过滤之外，还可以进行很多其他操作，看下面的代码：

① 、对集合对象进行分页：

List list=session.createFilter(customer.getOders(),”order by this.price asc”)

.setFirstResult(10)

.setMaxResults(50)

.list();

②、检索集合中关联对象的一个属性：

List list=session.createFilter(customer.getOrders(),”select this.ordernumber ”).list();

2、子查询：

子查询是SQL语句中非常重要的功能特性，它可以在SQL语句中利用另外一条SQL语句的查询结果，在Hibernate中HQL查询同样对子查询功能提供了支持。如下面代码所示：

List list=session.createQuery(“from Customer c where 1>(select count(o) from c.orders o)”).list();

上面的程序查询订单数超过1的所有客户，因此和上面子查询HQL语句对应的SQL语句为：

Select * from Customer c where 1>(select count(o.id) from Order o where c.id=o.customer_ID);

如果子查询返回多条记录，则可以使用下面关键字：

all:表示子查询语句返回的所有记录

any:表示子查询语句返回的任意一条结果

some:与”any”等价

in:与”=any”等价

exists:表示子查询语句至少返回一条记录

例如：查询存在一条订单价格大于100的客户

From Customer c where 100>any(select o.price from c.orders o);

如果在子查询中操作集合，HQL提供了一组操纵集合的函数和属性：

size()函数和size属性：获得集合中元素的数量

minIndex()函数和minIndex属性：对于建立了索引的集合获得最小索引值（关于集合索引参考第一部分映射值类型集合）

minElement()函数和minElement属性：对于包含基本类型的元素集合，获得集合中值最小的元素

maxElement()函数和maxElement属性：对于包含基本类型元素的集合，获得集合中值最大的元素

element()函数：获得集合中所有元素

例如：查询订单数大于0的客户

From Customer c where size(c.orders)>0;或者From Customer c where c.orders.size>0;

以上HQL语句会生成类似如下的SQL语句：

Select * from customer c where 0>(select count(o.id) from order where o. customer_ID =c.id);

注：在HQL中子查询必须出现在where子句中，而且必须用一对圆括号括起来。为什么必须要出现在where字句之后呢？其实我们大家仔细想一下也就知道了，在Hibernate中查询的任何一个实体对象都要有据可循，这个“据”就是Hibernate的主配置文件，也就是说凡是出现在HQL from字句中的实体对象，都必须要在Hibernate主配置文件中有明确的配置。所以在Hibernate中无法支持SQL语句中的那种出现在from字句之后的那种动态视图子查询。

生命的绽放 2009-10-26 22:48 发表评论

Hibernate学习（九）---【继承关系】

生命的绽放 — Tue, 30 Jun 2009 13:38:00 GMT

继承关系分为三种：一张表对应一整棵类继承树、一个类对应一张表、每一个具体类对应一张表。
三个java类Person、Student、Teacher，Student和Teacher继承Person类并且Student和Teacher没有任何关系
代码如下：
Person.java

package com.zzn.hibernate.model;

public class Person {
    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }


}

Student.java

package com.zzn.hibernate.model;

public class Student extends Person {
    private String cardId;

    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
}

Teacher.java

package com.zzn.hibernate.model;

public class Teacher extends Person {
    private int salary;
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
}

一张表对应一整棵类继承树时
Person.hbm.xml

xml version="1.0" encoding='gb2312'?>
DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.zzn.hibernate.model">

    <class name="Person" table="person">
        <id name="id" column="id">
            <generator class="identity" />
        id>
        <discriminator column="personType" type="java.lang.String" />

        <property name="name" type="java.lang.String" />
        <property name="age" type="java.lang.Integer" />

        <subclass name="Student" discriminator-value="student">
            <property name="cardId" type="java.lang.String" />
        subclass>
        <subclass name="Teacher" discriminator-value="teacher" >
            <property name="salary" type="java.lang.Integer" />
        subclass>

    class>

hibernate-mapping>

一个类对应一张表

xml version="1.0" encoding='gb2312'?>
DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.zzn.hibernate.model">

    <class name="Person" table="person">
        <id name="id" column="id">
            <generator class="identity" />
        id>
        <property name="name" type="java.lang.String" />
        <property name="age" type="java.lang.Integer" />
        <joined-subclass name="Student" table="student">
            <key column="id" />
            <property name="cardId" type="java.lang.String" />
        joined-subclass>

        <joined-subclass name="Teacher" table="teacher">
            <key column="id"/>
            <property name="salary" type="java.lang.Integer" />
        joined-subclass>
    class>

hibernate-mapping>

hibernate.hbm.xml

xml version='1.0' encoding='UTF-8'?>
DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="show_sql">trueproperty>
        <property name="hibernate.hbm2ddl.auto">updateproperty>
        <property name="connection.username">saproperty>
        <property name="connection.password">property>
        <property name="connection.url">jdbc:jtds:sqlserver://localhost:1433;databasename=hibernate_testproperty>
        <property name="dialect">org.hibernate.dialect.SQLServerDialectproperty>
        <property name="myeclipse.connection.profile">SQL2005property>
        <property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driverproperty>
        <mapping resource="com/zzn/hibernate/model/Person.hbm.xml"/>
    session-factory>
hibernate-configuration>

测试文件SubclassTest.java

package com.zzn.hibernate.test;

import java.util.Iterator;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.zzn.hibernate.model.Person;
import com.zzn.hibernate.model.Student;
import com.zzn.hibernate.model.Teacher;

public class SubClassTest {
    public static void main(String[] args) {
        add();
        select();
    }

    public static void add() {
        Configuration configuration = null;
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction transaction = null;
        Student student = new Student();
        Teacher teacher = new Teacher();
        try {
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();
            student.setName("shanshan");
            student.setAge(25);
            student.setCardId("123456");
            teacher.setName("xiaolan");
            teacher.setAge(25);
            teacher.setSalary(5000);
            session.save(student);
            session.save(teacher);
        } finally {
            if (session != null) {
                transaction.commit();
                session.close();
            }
        }
    }

    public static void select(){
        Configuration configuration = null;
        SessionFactory sessionFactory = null;
        Session session = null;
        try {
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
            session = sessionFactory.openSession();
            Query query = session.createQuery("from Person");
            Iterator iterator = query.list().iterator();
            while (iterator.hasNext()){
                Person person = (Person)iterator.next();
                System.out.println(person.getName());
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

生命的绽放 2009-06-30 21:38 发表评论

Hibernate学习（八）---【多对多】

生命的绽放 — Sun, 28 Jun 2009 05:36:00 GMT

举一个简单的例子：
Teacher.java

package zzn.hibernate.model;

import java.util.Set;

public class Teacher {
    private int id;
    private String name;
    private int age;
    private Set<Student> student;

    public Set<Student> getStudent() {
        return student;
    }

    public void setStudent(Set<Student> student) {
        this.student = student;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

Student.java

package zzn.hibernate.model;

import java.util.Set;

public class Student {
    private int id;
    private String name;
    private int age;
    private Set<Teacher> teacher;

    public Set<Teacher> getTeacher() {
        return teacher;
    }

    public void setTeacher(Set<Teacher> teacher) {
        this.teacher = teacher;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

Teacher.hbm.xml

Student.hbm.xml

hibernate-config.xml

xml version='1.0' encoding='gb2312'?>
DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="show_sql">trueproperty>
        <property name="hibernate.hbm2ddl.auto">updateproperty>
        <property name="connection.username">saproperty>
        <property name="connection.password">property>
        <property name="connection.url">jdbc:jtds:sqlserver://localhost:1433;databasename=hibernate_testproperty>
        <property name="dialect">org.hibernate.dialect.SQLServerDialectproperty>
        <property name="myeclipse.connection.profile">SQL2005property>
        <property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driverproperty>

        <mapping resource="zzn/hibernate/mappings/Teacher.hbm.xml"/>
        <mapping resource="zzn/hibernate/mappings/Student.hbm.xml"/>

    session-factory>

hibernate-configuration>

ManyToManyTest.java

package zzn.hibernate.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import zzn.hibernate.base.HibernateUtil;
import zzn.hibernate.model.Student;
import zzn.hibernate.model.Teacher;

public class ManyToManyTest {
    public static void main(String[] args) {
        add();
        get(1);
    }

    public static void add() {
        Configuration configuration = null;
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction transaction = null;

        Student student = new Student();
        Teacher teacher = new Teacher();

        try {
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            Set<Student> stu = new HashSet<Student>();
            student.setName("zhaozhaonan");
            student.setAge(25);
            stu.add(student);

            teacher.setName("zhangxiaolan");
            teacher.setAge(25);

            teacher.setStudent(stu);//建立关联
            session.save(student);
            session.save(teacher);
        } finally {
            if (session != null) {
                transaction.commit();
                session.close();
            }
        }
    }

    @SuppressWarnings("unchecked")
    public static void get(int id) {
        Session session = null;
        Transaction transaction = null;
        try {
            session = HibernateUtil.getSession();
            transaction = session.beginTransaction();
            Student student = (Student)session.get(Student.class, id);
            List list = new ArrayList (student.getTeacher());
            for(int i=0;i<list.size();i++){
                Teacher teacher = (Teacher)list.get(i);
                System.out.println(teacher.getName());
            }
        } finally {
            if (session != null) {
                transaction.commit();
                session.close();
            }
        }
    }
}

生命的绽放 2009-06-28 13:36 发表评论

Hibernate简单例子（面试题）

生命的绽放 — Sat, 27 Jun 2009 02:17:00 GMT

试题：在hibernate中根据姓名查询出表中符合条件的员工分别用 HQL 和SQL

package zzn.hibernate.model;

import java.util.Date;

public class Employ {
    private int id;
    private Integer empId;
    private String empName;
    private String empEname;
    private String gender;
    private String empNo;
    private Date birthday;
    private String idCard;
    private String address;

    public Integer getEmpId() {
        return empId;
    }
    public void setEmpId(Integer empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public String getEmpEname() {
        return empEname;
    }
    public void setEmpEname(String empEname) {
        this.empEname = empEname;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getEmpNo() {
        return empNo;
    }
    public void setEmpNo(String empNo) {
        this.empNo = empNo;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getIdCard() {
        return idCard;
    }
    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }


}

xml version="1.0" encoding='gb2312'?>
DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="zzn.hibernate.model">
    <class name="Employ" table="employ">
        <id name="id" column="id">
            <generator class="identity" />
        id>
        <property name="empName" column="emp_name" type="string" />
        <property name="empEname" column="emp_ename" type="string" />
        <property name="gender" column="gender" type="string" />
        <property name="empNo" column="emp_phone" type="string" />
        <property name="idCard" column="id_card" type="string" />
        <property name="address" column="adress" type="string" />
        <property name="empId" column="emp_id" type="integer" />
        <property name="birthday" column="birthday" type="date" />
    class>
hibernate-mapping>

package zzn.hibernate.test;

import java.util.Date;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import zzn.hibernate.model.Employ;

public class EmployTest {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        employAdd();
        @SuppressWarnings("unused")
        List<Employ> list = employHibernateQuery("zhaozhaonan");
        for(Employ emp : list){
            System.out.println("EmployId:~~~~" + emp.getEmpId()
                    + "   EmployeeName:~~~~" + emp.getEmpName()
                    + "   EmployeeEname:~~~~" + emp.getEmpEname()
                    + "   EmployeePhone:~~~~" + emp.getEmpNo()
                    + "   EmploueeBirthday:~~~~" + emp.getBirthday()
                    + "   EmploueeAddress:~~~~" + emp.getAddress()
                    + "   EmploueeGender:~~~~" + emp.getGender()
                    );
        }
    }

    @SuppressWarnings("unchecked")
    public static List employHibernateQuery(String name){
        Configuration configuration = null;
        SessionFactory sessionFactory = null;
        Session session = null;
        try {
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
            session = sessionFactory.openSession();
            String sql = "from Employ where emp_name=? ";
            Query query = session.createQuery(sql);
            query.setString(0, name);
            List employList = query.list();
            return employList;
        }finally{
            if(session != null){
                session.close();
                }
        }
    }

    public static void employAdd(){
        Configuration configuration = null;
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction transaction = null;
        Employ emp = new Employ();
        try{
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();
            emp.setEmpId(123);
            emp.setEmpName("zhaozhaonan");
            emp.setEmpEname("shanshan");
            emp.setEmpNo("13581937677");
            emp.setBirthday(new Date());
            emp.setAddress("huoying");
            emp.setGender("3");
            emp.setIdCard("152105198506120316");
            session.save(emp);

        }finally{
            if(session!=null){
                transaction.commit();
                session.close();
            }
        }
    }
}

生命的绽放 2009-06-27 10:17 发表评论

Hibernate三种状态的区分，以及save,update,saveOrUpdate,merge等的使用【转】

生命的绽放 — Tue, 23 Jun 2009 13:01:00 GMT

Hibernate的对象有3种状态，分别为：瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。
瞬时态
由new命令开辟内存空间的java对象，

eg. Person person = new Person("xxx", "xx");

如果没有变量对该对象进行引用，它将被java虚拟机回收。

瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

持久态
处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。

当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

持久对象具有如下特点：

1. 和session实例关联；

2. 在数据库中有与之关联的记录。

脱管态
当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。

脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

脱管对象具有如下特点：

1. 本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；

2. 比瞬时对象多了一个数据库记录标识值。

hibernate的各种保存方式的区(save,persist,update,saveOrUpdte,merge,flush,lock)及对象的三种状态
hibernate的保存
hibernate对于对象的保存提供了太多的方法，他们之间有很多不同，这里细说一下，以便区别。
一、预备知识
对于hibernate，它的对象有三种状态，transient、persistent、detached
下边是常见的翻译办法：
transient：瞬态或者自由态
(new DeptPo(1,”行政部”,20,”行政相关”)，该po的实例和session没有关联，该po的实例处于transient)
persistent：持久化状态
(和数据库中记录想影射的Po实例，它的状态是persistent, 通过get和load等得到的对象都是persistent)
detached：脱管状态或者游离态
(1)当通过get或load方法得到的po对象它们都处于persistent,但如果执行delete(po)时(但不能执行事务),该po状态就处于detached, (表示和session脱离关联),因delete而变成游离态可以通过save或saveOrUpdate()变成持久态
(2)当把session关闭时，session缓存中的persistent的po对象也变成detached
因关闭session而变成游离态的可以通过lock、save、update变成持久态
持久态实例可以通过调用 delete()变成脱管状态。
通过get()或load()方法得到的实例都是持久化状态的。
脱管状态的实例可以通过调用lock()或者replicate()进行持久化。

save()和persist()将会引发SQL的INSERT，delete()会引发SQLDELETE，
而update()或merge()会引发SQL UPDATE。对持久化（persistent）实例的修改在刷新提交的时候会被检测到，它也会引起SQL UPDATE。
saveOrUpdate()或者replicate()会引发SQLINSERT或者UPDATE
二、save 和update区别
把这一对放在第一位的原因是因为这一对是最常用的。
save的作用是把一个新的对象保存
update是把一个脱管状态的对象或自由态对象（一定要和一个记录对应）更新到数据库

三、update 和saveOrUpdate区别
这个是比较好理解的，顾名思义，saveOrUpdate基本上就是合成了save和update,而update只是update;引用hibernate reference中的一段话来解释他们的使用场合和区别
通常下面的场景会使用update()或saveOrUpdate()：
程序在第一个session中加载对象,接着把session关闭
该对象被传递到表现层
对象发生了一些改动
该对象被返回到业务逻辑层最终到持久层
程序创建第二session调用第二个session的update()方法持久这些改动

saveOrUpdate(po)做下面的事:
如果该po对象已经在本session中持久化了，在本session中执行saveOrUpdate不做任何事
如果savaOrUpdate(新po)与另一个与本session关联的po对象拥有相同的持久化标识(identifier)，抛出一个异常
org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [org.itfuture.www.po.Xtyhb#5]
saveOrUpdate如果对象没有持久化标识(identifier)属性，对其调用save() ，否则update() 这个对象

四、persist和save区别
这个是最迷离的一对，表面上看起来使用哪个都行，在hibernate reference文档中也没有明确的区分他们.
这里给出一个明确的区分。（可以跟进src看一下，虽然实现步骤类似，但是还是有细微的差别）
主要内容区别：
1，persist把一个瞬态的实例持久化，但是并"不保证"标识符(identifier主键对应的属性)被立刻填入到持久化实例中，标识符的填入可能被推迟到flush的时候。

2，save, 把一个瞬态的实例持久化标识符，及时的产生,它要返回标识符，所以它会立即执行Sql insert

五、saveOrUpdate,merge和update区别
比较update和merge
update的作用上边说了，这里说一下merge的
如果session中存在相同持久化标识(identifier)的实例，用用户给出的对象覆盖session已有的持久实例
(1)当我们使用update的时候，执行完成后，会抛出异常
(2)但当我们使用merge的时候，把处理自由态的po对象A的属性copy到session当中处于持久态的po的属性中，执行完成后原来是持久状态还是持久态，而我们提供的A还是自由态

六、flush和update区别
这两个的区别好理解
update操作的是在自由态或脱管状态(因session的关闭而处于脱管状态)的对象//updateSQL
而flush是操作的在持久状态的对象。
默认情况下，一个持久状态的对象的改动（包含set容器）是不需要update的，只要你更改了对象的值，等待hibernate flush就自动更新或保存到数据库了。hibernate flush发生在以下几种情况中：
1，调用某些查询的和手动flush(),session的关闭、SessionFactory关闭结合
get()一个对象，把对象的属性进行改变,把资源关闭。
2，transaction commit的时候（包含了flush）

七、lock和update区别
update是把一个已经更改过的脱管状态的对象变成持久状态
lock是把一个没有更改过的脱管状态的对象变成持久状态(针对的是因Session的关闭而处于脱管状态的po对象(2)，不能针对因delete而处于脱管状态的po对象)
对应更改一个记录的内容，两个的操作不同：
update的操作步骤是：
(1)属性改动后的脱管的对象的修改->调用update
lock的操作步骤是：
(2)调用lock把未修改的对象从脱管状态变成持久状态-->更改持久状态的对象的内容-->等待flush或者手动flush
八、clear和evcit的区别
clear完整的清除session缓存
evcit(obj)把某个持久化对象从session的缓存中清空。

生命的绽放 2009-06-23 21:01 发表评论

【原】Hibernate数据检索策略和.hbm.xml映射文件

生命的绽放 — Tue, 04 Nov 2008 05:51:00 GMT

一、Hibernate的数据检索策略是面向对象的策略，对与不同的检索情况，应使用不同的策略，以提高效率节省资源。经常使用的是立即检索和延迟检索，预先抓取和批量检索都是为了优化加载性能而设计的策略。检索一般是建立在表关联的基础上的所以我们先建立三张表Team与Student是一对多关系，Student和Certificate是一对一关系。
Team→id:String、teamName:String
Student→id:String、team_id、name、cardid、age
Certificate→id:String、describe
在这里Team相当于原对象Student相当于Team的附属物，Certificate相当于Student的附属物。当加载一个原对象时，原对象对附属物的使用有2中情况：(1)马上就用附属物的数据(2)可能一会用，可能不用。第一种情况适用于立即检索，第二种情况适用于延迟检索。
1.立即检索
立即检索的配置文件标识符为lazy="false"。

一般情况下我们把一对一和多对一这样后者为一的对象用于立即检索，因为是“一”的这段，所带来的性能消耗也有限。立即装载附属物有个好处，原对象脱离管理成为VO以后，仍然可以使用这些附属物。而对一对多和多对多关联对象则不适合立即检索。比如班级和学生是一对多的关系，当取得班级对象时，如过是立即检索，就会把班级的所有学生对象组装起来，这种资源消耗在这没有必要。
2.延迟检索
延迟检索的配置文件标识符为lazy="true"。
延迟检索就是等到需要用到时（比如调用了Team.getTeamName()。调用stu.getTeam()不行，必须以Team为主体取得附属物时，才会实现延迟加载）才会去取被关联对象Team。因此如果在Student对象的配置文件中设置了对Team进行延迟检索，则在取的学生1对象时，Hibernate仅把学生1对象设置为立即检索的对象和属性装配进学生1对象，而并不会立即去组装设为延迟检索的附属物，只有在同一个Session中使用到班级1时，Hibernate才会从数据库中查找数据并装配成班级1对象。
如果把班级对象纳入另一个Session中，使用org.hibernate.Hibernate这个类的initialize()方法，这时脱离Session管理仍然可以从班级对象中取出数据。
3.预先抓取
预先抓取的配置文件标识符为fetch="join"
如果把三个表之间的关系都设为立即检索，取得班级对象时，从而递归的得到学生和身份证对象。如果有100个学生，则要发送100条SQL语句去取100个身份证。这样会很大程度的降低性能。所以必须减少发送的SQL语句的数量。使用预先抓取只是用一条SQL语句就能代替立即检索的100条SQL语句。再具体点比如有一堆货物，原先有100个人排队顺序去背，现在让一个人一次背回来，反而影响性能。每次背的数量可用hibernate.max_fetch_depth来控制。还有一点需要注意，HQL使用外连接查询时忽略配置文件中配置的预先抓取策略，如：Query q = session .createQuery("from Strudent as s left join s.team");所以我们应该改为Query q = session .createQuery("from Strudent as s left join fetch s.team");
仅从使用角度来说。预先抓取和立即检索的效果一样，只不过预先抓取能减少SQL语句的条数。
4.批量加载
批量加载总是和立即或延迟加载联系在一起，分为批量立即加载和批量延迟加载。主要是控制发送SQL语句的条数，较少资源的消耗。
对于一对多、多对多在集合的配置中设置，以set为例：

一对一、多对一比如学生对班级是多对一关系，要实现对班级的批量加载，如下：

二、下面分析一下.hbm.xml文件
有3个实体，Team、Student、Certificate，Team与Student是一对多关系，Student和Certificate是一对一。
(1).Student.hbm.xml配置文件源码：

1xml version="1.0" encoding="UTF-8"?>
2DOCTYPE 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="model.Student" table="student" lazy="true">
6        <id name="id" unsaved-value="null">
7            <generator class="uuid.hex"/>
8        id>
9        <property name="cardid" type="string"/>
10        <property name="name" type="string"/>
11        <property name="age" type="int"/>
12        <one-to-one name="cer" class="model.Certificate" fetch="join" cascade="all"/>
13        <many-to-one name="team" class="model.Team" column="team_id" fetch="join"/>
14    class>
15hibernate-mapping>

Student.hbm.xml配置文件信息的解释如下：
第5行：model.Student类对应的数据库表是student表。lazy="true"当使用一对一、多对一方式加载Student类时，将采用延迟加载（前提是设置预先抓取为false）。
第6、7、8行：Student类有一个主键id，id由Hibernate自动生成，生成算法是uuid.hex。在内存中有很多对象，可以通过unsaved-value="null"来判断对象是持久化的还是临时状态。当对象的id值为unsaved-value指定的"null"时，认为未持久化，否则认为此对象是持久化或托管状态。注意int、long型的主键id的默认unsaved-value="0"。
第12行：一个一对一关联的对象属性，名为cer，fetch="join"在得到Student对象时。采用预先抓取得到cer对象。cascade="all"表示级联为all，说明Student的crud操作都会影响cer对象。
第13行：一个多对一关联的对象属性，名为Team，在Student表中通过team_id与Team对象发生关联，引用team中id成外键，没个Student对象对应唯一的team。team的实体类是model.Team。在取得Student实例时。使用预先抓取得到team对象。
(2).Certificate.hbm.xml配置文件源码：

1xml version="1.0" encoding="UTF-8"?>
2DOCTYPE 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="model.Certificate" table="certificate" lazy="true">
6       <id name="id">
7           <generator class="foreign">
8               <param name="property">stuparam>
9           generator>
10       id>
11       <one-to-one name="stu" class="model.Student" fetch="join" constrained="true">
12       one-to-one>
13       <property name="describe" column="describes" type="string">property>
14   class>
15hibernate-mapping>

Certificate.hbm.xml配置文件信息的解释如下：
第6、7、8、9、10行：Certificate和Student是一对一关联，使用的是以主键关联，即Certificate和Student公用一个主键值。Certificate的主键id生成使用外键方式(generator class="foreign")，此外键参考一对一引用中的"stu"变量。
第11行：一对一关联model.Student类，当取Certificate对象时，预先抓取Student类(fetch="join")，声明了constrained="true"。这个选项影响save()和delete()在级联执行的先后顺序以及决定该关联类能否被延迟加载（true时，此是的Student类才可被延迟加载）。
(3).Team.hbm.xml配置文件源码：

1xml version="1.0" encoding="UTF-8"?>
2DOCTYPE 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="model.Team" table="team" lazy="true">
6       <id name="id" unsaved-value="null">
7            <generator class="uuid.hex">
8            generator>
9        id>
10        <property name="teamName" type="string"/>
11        <set name="students" inverse="true" fetch="select" lazy="true">
12            <key column="team_id"/>
13            <one-to-many class="model.Student"/>
14        set>
15    class>
16hibernate-mapping>

Team.hbm.xml配置文件信息的解释如下：
第11、12、13、14行：一个Set集合名为students，采用延迟加载，在实体对象Student对象的student表中。一team_id列对应Team对象。

(4)需要在说一下的问题：
cascade属性的用法：
save-update：在执行save/update/saveOrUpdate时进行关联操作。
delete：在执行delete时进行关联操作。
none：所有情况下均不进行关联操作。这是默认值。
all的意思是save-update + delete 。
all-delete-orphan 的意思是当对象图中产生孤儿节点时,在数据库中删除该节点。
举个例子说一下all-delete-orphan，Category与Item是一对多的关系,也就是说Category类中有个Set类型的变量items.
举个例子,现items中存两个Item, item1,item2,如果定义关系为all-delete-orphan ，当items中删除掉一个item(比如用remove()方法删除item1),那么被删除的Item类实例，将变成孤儿节点,当执行category.update(),或session.flush()时
hibernate同步缓存和数据库,会把数据库中item1对应的记录删掉。
在多对多关系中不可以把cascade设置为all和delete，这样问题就大了，想想会有什么后果。
unique属性的用法：
以外间关联的一对一，本质上变成了一对多的双向关联了，编写以一对多和多对一要求编写，最后在many-to-one这一边加上unique="true"即说明它只不过是一对多的特例（“多”这一方只有一个对象）。
constrained属性的用法：
对one-to-one关系进行延迟加载和其他关系相比稍微有些不同。many-to-one的延迟加载是在配置文件的class标签设置lazy="true"，one-to-many和many-tomany的延迟加载在Set标签设置lazy="true"，而one-to-one不只要在class标签设置lazy="true"，而且要在one-to-one标签中设置constrained="true"。也就是说one-to-one关系，constrained="true"和附属物的lazy="true"才能实现延迟加载，并忽略默认的预先抓取。（这里说的是默认，如果指定fetch="join"，则无论如何都是预先抓取）。
inverse属性的用法：
两个表设置了双相关联，inverse="true"表示双方的关系将由对方去维护。
一对多应该让“多”的这一端有主动权，也就是在“一”这一端设置inverse="true"。
多对多关联关系中，如果双方都有控制权，这时会有一些问题，比如双方都引起插入语句，这就会违反数据库的主键约束，原因是试图插入重复主键。说以在某一方设置inverse="true"，然后在执行语句时使用主控方进行操作（也就是没有设置inverse="true"的一方）。这样就解决了。

本文章只是本人在学习中总结的自己的一些知识，希望各位看到不足和错误之处给予指出，我会加以改正。在此先致谢了。

生命的绽放 2008-11-04 13:51 发表评论

Hibernate中操纵实体对象

生命的绽放 — Sun, 28 Sep 2008 04:20:00 GMT

摘要: 一、Session的保存、删除及更新 1.save()方法：将一个对象的属性取出放入PreparedStatement语句中，然后向数据库中插入n语句。例： //打开Session，开启事务 Students students = new Students(); ... 阅读全文

生命的绽放 2008-09-28 12:20 发表评论

Hibernate创建数据库表（一对一and一对多）

生命的绽放 — Fri, 25 Jul 2008 03:02:00 GMT

摘要: 使用的数据库是MSSQL，库名hibernate，预建立的表有3张。分别是Student（学生）表，字段名：id、team_di、name、cardId、age。 team（班级）表，字段名：id、team_id。 Certificate（身份证）表，字段名：id、describe。 Student与Certificate是一对一的关系，team与Student是一对多的关系。 1.建... 阅读全文

生命的绽放 2008-07-25 11:02 发表评论

Hibernate学习（二） ---【一对一主键单向关联】

生命的绽放 — Thu, 24 Jul 2008 04:42:00 GMT

为了简洁，我们创建两张表分别是Student和Certificate，它们只有主键ID和另外一个对象的引用标识符。从student可以加载certificate。单向

Certificate Student.getCer();//返回Certificate对象
Student Certificate.gerStu();//返回Student对象

1.主键关联
所谓以主键关联，是指两张数据库表通过主键取得一对一的关联关系，也就是说一张表的主键是引用另一张表的外键。例如，对于Student和Certificate对象，一般来说是Student是主体，Certificate对象依附Student存在。它们主键关联的一对一关系就是在数据库中Student和Certificate表使用相同的主键值，这个由Student对象生成。Certificate应用这个主键值。它们共享同一主键值，这通过在Certificate表中设置外键来实现。一对一主键关联映射中默认cascade="true"；
2.一对一以主键关联的使用
既然它们是共用一个主键值，关键是如何让另一张表引用已经生成的主键值。这在Hibernate中使用的是主键的foreign生成机制。
下面是Student和Certificate类的配置源码。
Student.hbm.xml

<hibernate-mapping>
    <class name="model.Student" table="student" lazy="true">
        <id name="id" unsaved-value="null">
            <generator class="uuid.hex" />
        id>
        <property name="name" type="String">
        <property name="carId" type="String">
        <property name="age" type="int">
        <one-to-one name="cer"
         class="model.Certificate"
         fetch="join" cascade="all" constrained="true"/>
     class>
hibernate-mapping>

以上的one-to-one设置为cascade="all"，表示增加、删除、及修改Student对象时，都会级联增加、删除、修改Certificate对象。
constrained="true"约束这句话也要加上
Certificate.hbm.xml

<hibernate-mapping>
    <class name="model.Certificate" table="certificate" lazy="true">
        <id name="id">

            <generator class="foreign">
                 <param name="property">stuparam>
            genetator>
        id>
        <property name="describe" column="describe"type="String">
     class>
hibernate-mapping>

上述的两个配置文件在one-to-one中都没有设置column属性(其实他本身就没有column属性)。两个表是通过主键值得以连接的。现在建立一个学生和身份证对象，将他们设置为一对一关联存入数据库。

    //建立身份证
    Certificate cer = new Certificate();
    cer.setDescribe("spark");
    //新建学生
    Student stu = new Student();
    stu.setName("spark");
    stu.setCardid("10001");
    stu.setAge(22);
    //设置学生和身份证之间的关联
    stu.setCer(cer);
    StudentDAO.saveObj(stu);

生命的绽放 2008-07-24 12:42 发表评论

初学Hibernate3

生命的绽放 — Wed, 23 Jul 2008 02:45:00 GMT

摘要: 我只用的是Eclipse3.2+MyEclipse6.0+JDK6+Tomcat+MSSQL-2000。 1.首先建立数据库表（非常简单就不用说了）。 DROP TABLE person ; CREATE TABLE person ( id varchar(32) not null primary key , name varchar(20) not null , ... 阅读全文

生命的绽放 2008-07-23 10:45 发表评论