Hibernate(五)

================================criteria（QBC）查询========================
QBC，（容器）又名对象查询：采用对象的方式（主要是criteria的实例）封装查询条件

criteria实例：SQL语句封装，以一个对象的形式展现

最大优势：动态查询

语法：
    步骤：
        1.创建criteria对象，createCriteria(Dept.class)
        2.Restrictions 条件查询
        3.添加条件实例，add
        4.获取数据表的数据，list()
    范例：
    1.查询所有的部门
        Criteria criteria = session.createCriteria(Dept.class);
        List<Dept> list = criteria.list();

Restrictions:限制结果集内容--条件查询
    常用方法：
        1.Restrictions.eq(持久化类的属性名，字段的数值 )
        2.Restrictions.in( )
        3.Restrictions.like( )
        4.Restrictions.and( )
        5.Restrictions.ilike( )        大小写不敏感
        6.Restrictions.or( )
        7.Restrictions.between( )
        8.Restrictions.gt( )
        9.Restrictions.ge( )
        10.Restrictions.lt( )
        11.Restrictions.le( )
        12.Restrictions.disjunction( )            多个条件(.add()形式的条件)
        13.Restrictions.sqlRestriction( )        多个条件(字符串形式的条件)
    范例：
    1.查询位置在"1楼"的部门
        Criteria criteria = session.createCriteria(Dept.class);
        Criterion critrion = Restrictions.eq("location", "1楼");
        criteria = criteria.add(critrion);
        List<Dept> list = criteria.list();
    2.查询年龄大于20，或者用户名中含有”马“的记录
        criteria.add(Restrictions.sqlRestriction(" age > 20 or username = '% 马 %' "));
    
排序：org.hibernate.criterion.Order
    语法：
        addOrder(Order.asc())
        addOrder(Order.desc())
        
    范例：先按工资升序排序，再按编号降序排序
        List<Emp> list = session.createCriteria(Emp.class)
            .add(Restrictions.gt("salary", 4000D))
            .addOrder(Order.asc("salary"))
            .addOrder(Order.desc("empNo")).list();

Example示例查询（QBE）：
    属性条件多，可以Example取代Restrictions。创建一个对象模板，以它为查询依据，查询出属性与之类似的对象
    范例：所有年龄等于21的用户信息

            
分页：
    方法：
        setFirstResult(int firstResult)
        setMaxResult(int maxResult)
    范例：查询出工资最高的两名员工
        List<Emp> list = session.createCriteria(Emp.class)
            .add(Restrictions.isNotNull("salary"))
            .addOrder(Order.desc("salary"))
            .setFirstResult(0)
            .setMaxResults(2).list();

查询唯一对象：
    方法            说明                                Query    Criteria
    list()            返回List集合                        支持    支持
    iterate()        返回Iterator迭代器，只查询出ID值。    支持    不支持
    uniqueResult()    返回唯一对象                        支持    支持
    
    范例：查询工资最高的员工
    Emp emp = (Emp) session.createCriteria(Emp.class)
        .add(Restrictions.isNotNull("salary"))
        .addOrder(Order.desc("salary"))
        .setMaxResults(1)
        .uniqueResult();
        
关联：建立内连接或迫切左外连接4
    方法：
        createCriteria()
        createAlias()
        
    范例：
    1.List<Emp> list = session.createCriteria(Emp.class)
        .add(Restrictions.ilike("empName", "a", MatchMode.ANYWHERE))
        .createCriteria("dept")
        .add(Restrictions.eq("deptName", "财务部").ignoreCase()) .list();
    2.List<Emp> list = session.createCriteria(Emp.class, "e")
        .createAlias("dept", "d")
        .add(Restrictions.ilike("e.empName", "a",MatchMode.ANYWHERE))
        .add(Restrictions.eq("d.deptName", "财务部").ignoreCase()).list();

投影：
    方法：
        org.hibernate.criterion.Projection接口
        org.hibernate.criterion.Projections类
        
    范例：
    1.List<String> list = session.createCriteria(Dept.class)
        .setProjection(Property.forName("deptName")).list();
    2.List<Object[]> list = session
        .createCriteria(Emp.class)
        .setProjection(Projections.projectionList()
                        .add(Property.forName("empName"))
                        .add(Property.forName("hiredate"))).list();
    
分组：投影实现分组统计功能
    方法：org.hibernate.criterion.Projections类提供了使用聚合函数查询的方法
            方法                                说明
        1.Projections.groupProperty()    分组
        2.Projections.rowCount( )        统计记录数
        3.Projections.avg()                统计平均值
        4.Projections.min()                统计最小值
        5.Projections.max()                统计最大值
        6.Projections.count()            统计某一字段的非空记录数
        7.Projections.sum()                统计某一字段的求和
        8.Projections.projectionList()    实现一次查询调用多个聚合查询方法
    范例：
        
==============================DetachedCriteria=============================
CriteriaSpecification-->Criteria-->DetachedCriteria

Criteria和DetachedCriteria均可使用Criteria与Projection设置条件查询。创建形式不同：
    Criteria，Session进行创建
    DetachedCriteria，创建无须Session

适用范围：
    在Web层，程序员使用DetachedCriteria构造查询条件。然后将DetachedCriteria作为方法调用参数传递给业务成对象。
    业务层对象获得DetachedCriteria后，可以在Session范围内直接构造Criteria进行查询。
    因此，查询语句的构造完全被搬离到Web层实现，而业务查询与查询条件构造完全解耦。
    
方法：
    createAlias()
    createCriteria()

    范例：
    1.DetachedCriteria detachedCriteria = DetachedCriteria
        .forClass(Emp.class, "e")
        .createAlias("e.dept", "d")
        .add(Restrictions.eq("d.deptName", "财务部"))
        .add(Restrictions.ilike("e.empName", "a", MatchMode.ANYWHERE));
     List<Emp> list = detachedCriteria.getExecutableCriteria(session).list();
    
    2.DetachedCriteria avgSalary = DetachedCriteria.forClass(Emp.class, "e")
        .setProjection(Property.forName("salary").avg());
      List<Emp> list = session.createCriteria(Emp.class)
        .add(Property.forName("salary").gt(avgSalary)).list();

======================================综合范例=======================================
1.entity包
a.Dept

package com.Elastic.HibernateDemo3.ivy.entity;
import java.io.Serializable;
import java.util.Set;
public class Dept implements Serializable {
    private static final long serialVersionUID = 2261199233032137882L;
    private Integer deptId;
    private String deptName;
    private String location;
    
    //多对一：一个部门有多个员工
    //set：唯一
    private Set<Emp> emps;
    
    public Set<Emp> getEmps() {
        return emps;
    }
    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

    public Integer getDeptId() {
        return deptId;
    }
    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }
    public String getDeptName() {
        return deptName;
    }
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
    public String getLocation() {
        return location;
    }
    public void setLocation(String location) {
        this.location = location;
    }
}

b.Dept.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>    
    <class name="com.Elastic.HibernateDemo4.ivy.entity.Dept" table="dept">
        <!-- 主键 -->
        <id name="deptId" column="deptid">
            <!-- 主键生成策略 -->
            <generator class="increment"></generator>
        </id>
        <property name="deptName" column="deptname"></property>
        <property name="location" column="location"></property>
        
        <!-- 多个员工 -->
        <set name="emps" cascade="all" inverse="true" order-by="empNo desc" lazy="extra">
            <key column="deptid"></key>
            <one-to-many class="com.Elastic.HibernateDemo4.ivy.entity.Emp"/>
        </set>
    </class>
</hibernate-mapping>

a1.Emp

package com.Elastic.HibernateDemo3.ivy.entity;
import java.io.Serializable;
public class Emp implements Serializable {
    private static final long serialVersionUID = -6182713107749938132L;
    private Integer empNo;
    private String empName;
    private Integer deptId;
    
    private Dept dept;
    
    public Integer getDeptId() {
        return deptId;
    }
    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public Integer getEmpNo() {
        return empNo;
    }
    public void setEmpNo(Integer empNo) {
        this.empNo = empNo;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
}

b1.Emp.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.Elastic.HibernateDemo4.ivy.entity.Emp" table="emp">
        <!-- 主键 -->
        <id name="empNo" column="empNo">
            <!-- 主键生成策略 -->
            <generator class="increment"></generator>
        </id>
        <property name="empName" column="empName"></property>
        <property name="deptId" column="deptId" insert="false" update="false"></property>
        
        <!-- 多对一的关系(多个员工属于一个部门) -->
        <many-to-one name="dept" class="com.Elastic.HibernateDemo4.ivy.entity.Dept" column="deptId" lazy="proxy"></many-to-one>
    </class>
    
    <!-- 配置HQL命名查询 -->
    <query name="findEmpByDeptName">
        <![CDATA[
        from Emp e where e.dept.deptName = :deptname and e.empName = :ename
        ]]>
    </query>
    
    <!-- 配置原生的SQL语句 -->
    <sql-query name="findEmp">
        <return alias="e" class="com.Elastic.HibernateDemo4.ivy.entity.Emp"></return>
        select * from emp e inner join dept d on e.deptId = d.deptId where e.empName = :ename and d.deptName = :deptname
    </sql-query>
</hibernate-mapping>

2.hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 连接数据库 -->
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernatedb</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        
        <!-- 数据库对应的实体类的映射文件路径 -->
        <mapping resource="com/Elastic/HibernateDemo4/ivy/entity/Dept.hbm.xml"></mapping>
        <mapping resource="com/Elastic/HibernateDemo4/ivy/entity/Emp.hbm.xml"></mapping>
        
    </session-factory>
</hibernate-configuration>

3.util包
a.HibernateUtil

package com.Elastic.HibernateDemo4.ivy.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public final class HibernateUtil {
    private static Configuration cfg = null;
    private static SessionFactory sessionFactory = null;
    
    //本地线程
    public static ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
    
    static{
        cfg = new Configuration().configure();
        sessionFactory = cfg.buildSessionFactory();
    }
    
    public static Session getSession(){
        Session session = threadLocal.get();
        if (null == session || !session.isOpen()) {
            session = sessionFactory.openSession();
            threadLocal.set(session);
        }
        return session;
    }
}

4.test包
a.对象查询的基本操作

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        
        //查询在1楼的所有部门
        criteria.add(Restrictions.eq("location", "1楼"));
        
        //查询1楼的所有部门
        criteria.add(Restrictions.like("location", "1楼"));
        
        //查询含1的楼层的所有部门
        criteria.add(Restrictions.like("location", "1", MatchMode.ANYWHERE));
        
        //查询部门编号为1或者位置在5楼的部门
        criteria.add(Restrictions.or(Restrictions.eq("deptId", 1), Restrictions.eq("location", "5楼")));
        
        //查询部门编号为1或者4的部门
        //in:第二个参数（字段值）数组或集合
        criteria.add(Restrictions.in("deptId", new Integer[]{1, 4}));
        
        //集合
        List<Integer> params = new ArrayList<Integer>();
        params.add(1);
        params.add(4);
        criteria.add(Restrictions.in("deptId", params));
        
        //返回集合（若没条件，就返回所有的数据）
        List<Dept> depts = criteria.list();
        for (Dept dept : depts) {
            System.out.println("部门编号：" + dept.getDeptId() + ",部门名称：" + dept.getDeptName() + ",部门位置：" + dept.getLocation() + "
");
        }
    }
}

b.多条件查询

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        //查询在5楼且部门编号为1的部门
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("location", "5楼");
        params.put("deptId", 1);
        for (String key : params.keySet()) {
            criteria.add(Restrictions.eq(key, params.get(key)));
        }
        //返回集合（若没条件，就返回所有的数据）
        List<Dept> depts = criteria.list();
        for (Dept dept : depts) {
            System.out.println("部门编号：" + dept.getDeptId() + ",部门名称：" + dept.getDeptName() + ",部门位置：" + dept.getLocation() + "
");
        }
    }
}

c.排序

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        //按部门编号降序排列
        criteria.addOrder(Order.desc("deptId"));
        //按部门位置升序排列
        criteria.addOrder(Order.asc("location"));
        //中文排序？？？
        criteria.addOrder(Order.desc("deptName"));
        //返回集合（若没条件，就返回所有的数据）
        List<Dept> depts = criteria.list();
        for (Dept dept : depts) {
            System.out.println("部门编号：" + dept.getDeptId() + ",部门名称：" + dept.getDeptName() + ",部门位置：" + dept.getLocation() + "
");
        }
    }
}

d.投影

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        //查询总条数
        criteria.setProjection(Projections.rowCount());
        int total = Integer.parseInt(criteria.uniqueResult().toString());
        System.out.println(total);
        System.out.println("记录数：" + criteria.list().iterator().next());
        
        //取消查询总条数
        criteria.setProjection(null);
    }
}

e.分页

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        criteria.setFirstResult(0);
        criteria.setMaxResults(2);
        
        //查询部门编号最大的部门信息
        criteria.addOrder(Order.desc("deptId"));
        criteria.setFirstResult(0);
        criteria.setMaxResults(1);
        Dept d = (Dept) criteria.uniqueResult();
        System.out.println("部门编号：" + d.getDeptId() + ",部门名称：" + d.getDeptName() + ",部门位置：" + d.getLocation() + "
");
    }
}

f.关联

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        //查询黎明所在的部门
        Criteria empCriteria = criteria.createAlias("emps", "emp");
        empCriteria.add(Restrictions.eq("emp.empName", "黎明"));
        List<Dept> depts = empCriteria.list();
        for (Dept dept : depts) {
            System.out.println("部门编号：" + dept.getDeptId() + ",部门名称：" + dept.getDeptName() + ",部门位置：" + dept.getLocation() + "
");
        }
        
        //只查询部门名称
        //org.hibernate.criterion.Property
        /*criteria.setProjection(Property.forName("deptName"));
        List<String> names = criteria.list();
        for (String name : names) {
            System.out.println(name);
        }*/
        
        //只查询部门的名称和编号
        /*criteria.setProjection(Projections.projectionList()
                .add(Property.forName("deptName"))
                .add(Property.forName("deptId")));
        List<Object[]> datas = criteria.list();
        for (Object[] objects : datas) {
            System.out.println(objects[0].toString() + objects[1]);
        }*/
        
        //统计部门编号的平均值
        /*criteria.setProjection(Projections.avg("deptId"));
        Object result = criteria.uniqueResult();
        System.out.println(result);*/
    }
}

g.DetachedCriteria查询

package com.Elastic.HibernateDemo4.ivy.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.ResultTransformer;
import com.Elastic.HibernateDemo4.ivy.entity.Dept;
import com.Elastic.HibernateDemo4.ivy.entity.Emp;
import com.Elastic.HibernateDemo4.ivy.util.HibernateUtil;
import com.sun.org.apache.xalan.internal.xsltc.util.IntegerArray;
public class Test {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSession();
        Criteria criteria = session.createCriteria(Dept.class);
        //查询销售部的王五的所在部门的楼层
        //方法1
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Dept.class);
        detachedCriteria.add(Restrictions.eq("deptName", "销售部"));
        DetachedCriteria empDetachedCriteria = detachedCriteria.createCriteria("emps");
        empDetachedCriteria.add(Restrictions.eq("empName", "王五"));
        Criteria deptCriteria = detachedCriteria.getExecutableCriteria(session);
        List<Dept> depts = deptCriteria.list();
        for (Dept dept : depts) {
            System.out.println(dept.getLocation());
        }
        
        //方法2
        criteria.setFetchMode("emps", FetchMode.JOIN);
        List<Dept> list = criteria.list();
        for (Dept dept : list) {
            System.out.println(dept.getDeptName());
            Set<Emp> emps = dept.getEmps();
            for (Emp emp : emps) {
                System.out.println("	" + emp.getEmpName());
            }
        }
    }
}

==============================注解===============================
Hibernate提供了Hibernate Annotations扩展包，使用注解完成映射

优势：
    替换hbm.xml文件。利用注解后，可不用定义持久化类对应的*.hbm.xml文件。直接以注解方式写入在持久化类中实现

步骤：
    1.添加jar包
    2.使用注解配置持久化类以及对象关联关系
    3.使用AnnotationConfiguration建立SessionFactory
    4.在Hibernate配置文件（hibernate.cfg.xml）中声明持久化类

配置持久化类:
    注解                含义和作用
    @Entity            将一个类声明为一个持久化类
    @Id                声明了持久化类的标识属性
    @GeneratedValue    定义标识属性值的生成策略
    @Table            为持久化类映射指定表
    @Column            将属性映射到列（字段）
    @Lob            将属性持久化为Blob或Clob类型
    @Transient        将忽略这些属性，不用持久化到数据库

配置关联关系:
    注解            含义和作用
    @OneToOne    建立持久化类之间的一对一关联关系
    @OneToMany    建立持久化类之间的一对多关联关系
    @ManyToOne    建立持久化类之间的多对一关联关系
    @ManyToMany    建立持久化类之间的多对多关联关系

配置命名查询--@NamedQuery
    范例：
    @Entity
    @Table(name = "EMP")
    @NamedQuery(name = "selectEmp", query = "from Emp where empName like :ename")
    public class Emp implements java.io.Serializable {  
        //缺省其他代码
    }

=================================同综合范例================================
1.entity包
a.Dept

package com.Elastic.HibernateDemo4.ivy.entity;
import java.io.Serializable;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name = "dept")
public class Dept implements Serializable {

    @Id
    /**
     * nullable:是否为空
     * nullable = false：非空
     */
    @Column(name = "deptid", nullable = false)
    private Integer deptId;
    @Column(name = "deptname", nullable = false)
    private String deptName;

    private String location;

    // 多对一: 一个部门有多个员工
    /**
     * @OneToMany--
     * mappedBy：指定“多”方的关联属性
     * 在双向关联中，有且只有一端作为主体端，负责维护更新。
     * 对于不需要维护这种关系的从表通过mappedBy声明，指向另一主体的关联性，相当于inverse="true"
     * fetch：指定关联关系获取方式，即是否采用延迟加载
     * cascade：指定级联操作
     * 1.CascadeType.REMOVE：级联删除
     * 2.CascadeType.PERSIST：级联新建
     * 3.CascadeType.MERGE：级联更新
     * 4.CascadeType.REFRESH：级联刷新
     * 5.CascadeType.ALL：包含所有级联操作
     * targetEntity：指定关联的实体类
     */
    @OneToMany(cascade = CascadeType.ALL, targetEntity = Emp.class, mappedBy = "deptId", fetch = FetchType.LAZY)
    private Set<Emp> emps;

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public Set<Emp> getEmps() {
        return emps;
    }

    public void setEmps(Set<Emp> emps) {
        this.emps = emps;
    }

}

b.Emp

package com.Elastic.HibernateDemo4.ivy.entity;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedNativeQuery;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
@Entity
@Table(name = "emp")

//命名查询@NamedQuery：name属性：名字，query属性：hql语句
@NamedQuery(name="findHql",query="from Emp e where e.dept.deptName = :deptname and e.empName = :ename")

//原生命名查询@NamedNativeQuery：name属性：名字，query属性：sql语句
@NamedNativeQuery(name="findSql",query="select * from emp e inner join dept d on e.deptId = d.deptId where e.empName = :ename and d.deptName = :deptname",resultClass=Emp.class)
public class Emp implements Serializable {

    @Id
    private Integer empNo;
    private String empName;

    /**
     * insertable：是否可插入。
     * false 不能；true 能
     * updatable：是否可更新
     * false 不能；true 能
     *
     * 这里的deptId是主表dept的主键，所以在从表中不能插入、更新deptId
     */
    @Column(insertable = false, updatable = false)
    private Integer deptId;

    // 部门对象
    /**
     * @oneToMany的”多“方，通过@JoinColumn指定”多“方定义的外键字段
     */
    @JoinColumn(name = "deptId")
    
    //多个员工对应一个部门@ManyToOne
    @ManyToOne(targetEntity = Dept.class)
    private Dept dept;

    public Integer getEmpNo() {
        return empNo;
    }

    public void setEmpNo(Integer empNo) {
        this.empNo = empNo;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

}

2.hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- 连接数据库 -->
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernatedb</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        
        <!-- 注解 -->
        <mapping class="com.Elastic.HibernateDemo4.ivy.entity.Dept"></mapping>
        <mapping class="com.Elastic.HibernateDemo4.ivy.entity.Emp"></mapping>
        
    </session-factory>
</hibernate-configuration>