二、持久层框架（Hibernate）

一、Hibernate对象的状态

　　实体类对象在Hibernate中有3中状态：瞬时，持久，脱管。

瞬时：没有和Hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，对象就消失了

持久：一个对象和Hibernate发生联系，有对应的Session，并且在数据库中有对应的一条记录

脱管：一个对象虽然在数据库中有对应的一条记录，但是它所对应的Session已经关闭了。

　　首先new一个Product()对像，数据库中还没有对应的记录，这个时候Product对象状态是瞬时的

通过Session的save方法把对象保存在了数据库中，对象也和Session产生了联系，此时状态是持久的

最后把Session关闭了，这个对象在数据库中有对应的数据，但是已经和Session失去了联系，就是脱管的。

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        Product p=new Product();
        p.setName("demo");//创建实体对象，然后赋值，此时只是瞬时
        System.out.println("此时p是瞬时状态");
        s.save(p);//调用Session的save()方法
        System.out.println("此时p是持久状态");
        s.close();//关闭Session连接后
        System.out.println("此时p是脱管状态");
        sf.close();
    }
}

二、Hibernate插入对象

　　我们可以通过for循环插入对象到数据库，使用Session的save()方法插入数据。

import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        for(int i=0;i<10;i++){
            Product p=new Product();
            p.setName("demo"+i);
            p.setPrice(i);
            s.save(p);
        }
        s.getTransaction().commint();
        s.close();
        sf.close();
    }

三、Hibernate获取对象

　　通过id获取对象有两种方式，get和load

区别：1、延迟加载　　2、对于id不存在时候的处理

load:延迟加载，只有属性被访问的时候才会调用sql语句，id不存在的时候，get方式会抛出异常

get：非延迟加载，无论后面代码是否访问属性，都会后执行sql语句，id不存在的时候会返回null。

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        Product p1=(Product)s.get(Product.class,1);
        System.out.println("id=1的产品名称是："+p1.getName());
        Product p2=(Product)s.load(Product.class,1);//前面参数为实体类全名，后面参数为id
        System.out.println("id=1的产品名称是："+p2.getName());
        
        //id=1000不存在的时候
        Product p3=(Product)s.get(Product.class,1000);
        System.out.println("id=1000的产品名称是："+p3.getName());//null
        Product p4=(Product)s.load(Product.class,1000);
        System.out.println("id=1000的产品名称是："+p4.getName());//抛出异常
        
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}

四、Hibernate删除对象

　　通过id把对象从数据表中删除。在Hibernate删除一条数据之前，1、首先要通过id把这条数据取出来。2、通过Session的delete方法进行删除数据。

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        Product p1=(Product)s.get(Product.class,1);//取出id=1的产品
        s.delete(p1);//调用Session的delete()方法进行删除
        
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}

五、Hibernate修改对象

　　1、通过id获取到该对象。2、然后修改该对象的属性。3、通过Session的update方法把变化更新到数据库中。

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        Product p1=(Product)s.get(Product.class,1);//取出id=1的产品
        System.out.println(p1.getName());//原来的属性值加入是demo
        p1.setName("Helloworld");
        s.update(p1);//修改属性值
        
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}

六、Hibernate的查询。

　　查询有三种：

1、利用HQL(Hibernate Query Language)。

2、查询Criteria：完全是面向对象的方式在查询数据，将不再看到有sql语句的痕迹

3、查询标准的SQL：Hibernate依然保留了对标准SQL语句的支持，在多表关联查询，分组统计函数等情况下，标准SQL的语句已然效率高选择。

 

1、使用HQL，根据name进行模糊查询（通过Session对象的createQuery()方法）

步骤：1.1、根据hql创建一个Query对象

　　   1.2、设置参数

　　   1.3、通过Query对象的list()方法返回查询结果

使用hql的时候，用的是类名Product，而不是表名product_table，而且使用hql时候，不需要再前面加上"select *"

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        String name="demo";
        Query q=s.createQuery("from Product p where p.name like ?");
        q.setString(0,"%"+name+"%");//前后都模糊然后代替hql的问号部分
        List<Product> list=q.list();//利用Query对象的list()方法获取查询结果集
        for(Product p:list){//遍历查询结果集
            System.out.println(p.getName());
        }
        
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}

2、使用Criteria，根据name进行模糊查询（通过Session对象的createCriteria()方法）

步骤：2.1、通过session的createCriteria创建一个Criteria对象

　　    2.2、Criteria.add增加查询时候的约束条件

　　    2.3、调用list()方法返回查询结果集

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        String name="demo";
        Criteria criteria=s.createCriteria(Product.class);//通过Session对象的createCriteria()方法创建一个Criteria对象
        criateria.add(Restrictions.like("name","%"+name+"%"));//Criteria.add增加约束条件
        List<Product> list=criteria.list();//利用Query对象的list()方法获取查询结果集
        for(Product p:list){//遍历查询结果集
            System.out.println(p.getName());
        }
        
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}

3、使用标准SQL，根据name进行模糊查询（通过Session对象的createSQLQuery()方法）

步骤：3.1、使用Session的createSQLQuery()方法执行标准SQL语句。

由于标准SQL语句可能返回各种各样的结果，比如多表查询，分组统计结果等，结果不能装进一个Product对象中，所以返回的结果集合的每一个元素是一个对象数组，可以通过下标把这个对象数组中的数据取出来。

package com.demo.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.demo.pojo.Product;
public class TestHibernate{
    public static void main(String[] args){
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session s=sf.opneSession();
        s.beginTransaction();
        
        String name="demo";
        String strSql=" SELECT * FROM product_table WHERE name LIEK '%"+name+"%' ";
        Query q=s.createSQLQuery(strSql);//通过Session的createSQLQuery()方法执行SQL语句
        List<Object[]> list=q.list();//通过Query对象的list()方法返回结果集，结果集是一个对象数组
        for(Object[] os:list){
            for(Obejct value:os){
                System.out.print(value+"\t");
            }
        }
        s.getTransaction().commint();
        s.close();
        sf.close();
    }
}