1.Configuration

用于启动，加载，管理的的的Hiberante配置

1.自动加载

configuration sonfig=new configration ().config();

默认加载src下的hibernate.cfg.xml文件来

2·手动加载

configuration config=new configration().config(File file);

configuration config=new configration().config(String path);

configuration config=new configration().config(Document xml);

也可以

configuration config=new configuration ();

config.addResource("cn/itcast/domain/Customer.hkm.xml");//加载配置文件 

config.addClass(customer.class);//会默认查找customer.hbm.xml文件 

config.setProperty(Stirng name, String value);//加载配置项

    例如setProperty("hibernate.dialect", "org.hibernate.dialect.MysQLDialect")

2.SessionFactory

获取会话对象。
SessionFactory的的的是一个重量级组件。
可以针对于获取会话操作，进行抽取工具

public class HibernateUtils {
	private static final configuration config;
	private static final SessionFactory factory;
	
	static {
		config = new confiquration().confiqure();
		factory =config.buildsessionFactory();
	}
	public static Session getSession(){
		return factory.openSession();
	} 
}

SessionFactory的的对象，它维护的是休眠中的二级缓存。

它是线程安全的。

冬眠内部维护了一个连接池，我们都是从这个内部的连接池中获取的连接对象。

通过SessionFactory的的的可以获取会话对象。

1.openSession（）随机获取一个
2.getCurrentSession（）;

在休眠中使用C3P0连接池

1.在hibernate.sfg.xml文件中配置

hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider

代表当前要使用的连接池是c3p0连接池.

2，可以配置C3P0连接池属性，

<!--在连接池中可用的数据库连接的最少数具->

<property name="c3p0.min_size">5</property>

<!--在连接池中所有数据库连接的最大数且-->

<property name="c3p0.max_size">20</property>

<!--设定数据库连接的过期时间,以秒为单位,如果连接池中的某个数据库连接处于空困状态的时间超过了timeout时间,就会从连接池中清除->
<property name="c3p0.timeaut">120</property>

<!-每3000秒检查所有连接池中的空闲连接以秒为单位->

<property name="c3p0.idle_test_period">3000</property>

注意：需要导入c3p0的jar包hibernate \ lib \ optional \ c3p0

3.Session

代表hibernate操作会话对象，相对于Connection

session是一个单线程对象,线程不安全(在方法内部定义和使用Session,不会出现线程问题)
*每个线程方法调用栈,是线程私有的
session进行PO(Persistent object)对象常见持久化操作,存在一級缓存,

常用API

save 完成插入
update 完成修改
delete 完成删除
get/load 根据主键字段查询
createQuery，createSQLQery 创建查询对象 Query接收HQl, SQlguery接收sQL
createCriteria() 面向对象条件查询

4.Transaction

rallback () ; 事务回滚
commit (); 事务提交
wasCommitted() 返回boolean 判断事务是否提交
wasRollback() 返回boolean 判断事务是否回滚。

5.Query

1.session.createQuery(String hql);

1.list() 返回 List<Object> 代表查询出的所有信息

2.uniqureResult() 返回一个Object,查询结果只返回一个值时,可以使用

3.分页查询
setFirstResult (int firstResult)     设置返回结果从第几条开始 

setMaxResults (int maxResults)       设置本返回结果记录条数 
4.查询某一部分属性信息

1,例如,得到customer类的id与name属性

1.在Customer类中添加构造方法,构造方法参数id, name.

2.HQL语句 select new Customer (id, name) from Customer;

5.条件查询问题

1.可以使用"?"占位符

from Customer where name=?；

通过Query.setParameter (0,值)；从0开始记位,进行赋值。

2.可以直接给要赋值字段起个名称

from Customer where name=:abc;

通过Query.setParameter("abc","王五");

package com.qwl.test;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Test;

import com.qwl.domain.Customer;

import utils.HibernateUtils;

public class QueryTest {
	@Test
	public void hqlTest(){
		Session session =HibernateUtils.getSession();
		session.beginTransaction();
		
		//查询全部
		Query query=session.createQuery("from Customer");
		List<Customer> cs =query.list();
		
		for(Customer c:cs){
			System.out.println(c);
		}
		session.getTransaction().commit();
		session.close();
	}
	
	//根据条件查询
	@Test
	public void hqlTest2(){
		Session session =HibernateUtils.getSession();
		session.beginTransaction();
		
		//查询全部
		Query query=session.createQuery("from Customer where id=1");
		
		Customer c =(Customer) query.uniqueResult();//结果只返回一个值可以使用uniqueResult();
		System.out.println(c);
		session.getTransaction().commit();
		session.close();
	}
	
	//分页查询
	@Test
	public void hqlTest3(){
		Session session =HibernateUtils.getSession();
		session.beginTransaction();
		
		//查询全部
		Query query=session.createQuery("from Customer");
		
		query.setFirstResult(2);//从第几条开始查询
		query.setMaxResults(3);//查询几条
		List<Customer> cs= query.list();
		
		for(Customer c:cs){
			System.out.println(c);
		}
				
		session.getTransaction().commit();
		session.close();
	}
	
	//通过HQL只查询某些字段值
	@Test
	public void hqlTest4(){
		Session session =HibernateUtils.getSession();
		session.beginTransaction();
		
		//查询全部
		Query query=session.createQuery("select new Customer(id,name) from Customer");
		
		List<Customer> cs= query.list();
				
				for(Customer c:cs){
					System.out.println(c);
				}
				
		session.getTransaction().commit();
		session.close();
	}
		
	//条件查询--使用？占位符
		@Test
		public void hqlTest5(){
			Session session =HibernateUtils.getSession();
			session.beginTransaction();
			
			//查询全部
			Query query=session.createQuery("from Customer where name=?");
			
			query.setParameter(0, "李四");
			
			List<Customer> cs= query.list();
					
					for(Customer c:cs){
						System.out.println(c);
					}
					
			session.getTransaction().commit();
			session.close();
		}
		
	//条件查询--
			@Test
			public void hqlTest6(){
				Session session =HibernateUtils.getSession();
				session.beginTransaction();
				
				//查询全部
				Query query=session.createQuery("from Customer where name=:name");
				
				query.setParameter("name", "李四");
				List<Customer> cs= query.list();
						
						for(Customer c:cs){
							System.out.println(c);
						}
						
				session.getTransaction().commit();
				session.close();
			}
				
}

2.session.createSQLQuery(String sql);

默认情况

SQLQuery query = session.createSQLQuery ("select * from customer");

List<Obiect[]> list = query.list();

要封装到一个指定对象中;

SQLQuery query = session.createsQLQuery ("select * from customer");

query.addEntity (Customer.class); //将查询结果封装到customer对象中

List<Customer> list = query.list();

3.session.createCriteria(Object);

获取Criteria criteria = session.createCriteria (customer.class) ;

1.查询全部

criteria.list();

2·只返回一个值

criteria.uniqureResult();

3.条件查询

criteria.add(Criterion c)；

criterion获取方式---->Restrictions.xxx(1)；

4.分页

setFirstResult(); 从第几条记录开始查询

setMaxResult (); 查询几条记录

package com.qwl.test;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import com.qwl.domain.Customer;

import utils.HibernateUtils;

public class QBCTest {
	//查询所有的值
	@Test
	public void qbcTest1(){
		Session session =HibernateUtils.getSession();
		
		session.beginTransaction();
		
		Criteria criteria =session.createCriteria(Customer.class);
		List<Customer> cs =criteria.list();
		
		for (Customer c:cs){
			System.out.println(c);
		}
		session.getTransaction().commit();
		session.close();
				
	}
	
//只返回一个值
	@Test
	public void qbcTest2(){
		Session session =HibernateUtils.getSession();
		
		session.beginTransaction();
		
		Criteria criteria =session.createCriteria(Customer.class);

		criteria.add(Restrictions.eq("id", 1)).add(Restrictions.eq("name", "李四"));
		//criteria.add(Restrictions.and(Restrictions.eq("id", 1), Restrictions.eq("name", "李四")));
		
		Customer c=(Customer)criteria.uniqueResult();
		
		System.out.println(c);
		
		session.getTransaction().commit();
		session.close();
				
	}
	
//where id=1 or name="李四"
	@Test
	public void qbcTest3(){
		Session session =HibernateUtils.getSession();
		
		session.beginTransaction();
		
		Criteria criteria =session.createCriteria(Customer.class);

		criteria.add(Restrictions.or(Restrictions.eq("id", 1), Restrictions.eq("name", "李四")));
		List<Customer> cs =criteria.list();
				
				for (Customer c:cs){
					System.out.println(c);
				}
		
		session.getTransaction().commit();
		session.close();
				
	}
	
//分页
	@Test
	public void qbcTest4(){
		Session session =HibernateUtils.getSession();
		
		session.beginTransaction();
		
		Criteria criteria =session.createCriteria(Customer.class);

		criteria.setFirstResult(2);
		criteria.setMaxResults(3);
		
		List<Customer> cs =criteria.list();
				
				for (Customer c:cs){
					System.out.println(c);
				}
		
		session.getTransaction().commit();
		session.close();
				
	}
}

Hibernate的核心API

1.Configuration

2.SessionFactory

3.Session

4.Transaction

5.Query

猜你喜欢