使用hibernate进行CRUD_javaee3.实现多对多关系的crud功能,要求cud使用hibernate的接口实现,r需要采用

一. 查询操作

Criteria  – 查询JavaBean. – session.createCriteria(JavaBean.class);
Query      － 用于执行HQL – session.createQuery(HQL);
SQLQuery  － 用于执行原生的SQL. – session.createSQLQuery(SQL);
条件查询    - Restrictions- Restrictions.eq(propertyName,”value”);
1：查询：
A：全部查询，使用Criteri(完全限定名－类名)进行查询
B：全部查询，使用Query - 不执行SQL-语句，执行的是HQL - Hibernate Query Language.
C：全部查询，使用SQLQuery类，此类执行原生的SQL语句。

2：条件查询
A：对于Criteria类，必须使用add方法设置条件。
B：对于Query类，应该使用?（占位符）或是命名（where id=:myId）查询
C：普通查询

3：如果一个查询的它的条件不确定,应该怎么弄?

3.1全部查询-使用Criteria进行查询

@Test   // 标准化查询接口
public void test2(){
	Criteria  cr = sess.createCriteria(Stud.class);   // 按类名查询
	Criterion cn = Restrictions.eq("name", "c");  // 每个Criterion对象表示一个查询条件
	cr.add(cn);  // 增加条件
	List<Stud> studs = cr.list();		// 查询的结果是已经封装好的
	System.err.println(studs);
}

3.2全部查询-使用Query进行查询

@Test
public void test3(){   // 使用HQL语句进行查询，HQL语句是面向类的,不是面向表的,所以Stud同javabean
	String hql = "from Stud";    // select开始的语句，但select可以省略
	Query query = sess.createQuery(hql);  
	List<Stud> studs = query.list();
	System.err.println(studs);
}

3.3全部查询-使用SQLQuery进行查询

@Test
public void test4(){
	String sql = "select * from stud";
	this.getSession().createSQLQuery(sql).addEntity(Rl_employee_info.class).list()
	// SQLQuery sqlQuery = sess.createSQLQuery(sql);
	// List list = sqlQuery.list();    //返回的是什么? List<Object[]>    里面存的是数组
	// sqlQuery.setResultTransformer(Transformers.aliasToBean(Stud.class));  //转成List<Stud>类型
	// for(Object o : list){		
	// 	Object[] oo= (Object[])o;
	//	   System.err.println(">ID:"+oo[0]+",Name:"+oo[1]);
	// }
}

Criteria类，使用add方法设置条件

@Test
public void query1(){		  // 使用Criteria查询id为4的用户  Jack  %j%
	Session sess = HibernateUtils.getSession();
	sess.beginTransaction();
	Criteria c = sess.createCriteria(Stud.class);
	Criteria c = sess.createCriteria(Stud.class,”s”);     // 第二个参数为别名
	//设置条件，通过add方法
	//c.add(Restrictions.eq("id",4));  //  第一个参数是Stud的id属性的名，第二个参数是对比的值，相当于id=4
	//List<Stud> list = c.list();	
 
	//对于使用主键的查询，可以使用另一种方式
	//c.add(Restrictions.idEq(3));			     //直接使用主键等于什么值的方式
	c.add(Restrictions.ge("id", 3));			// 获取id>3 的
	//再添加一个条件
	c.add(Restrictions.eq("name", "22"));       // name为varchar类型
	c.add(Restrictions.like("name", "K",MatchMode.ANYWHERE));    // k - %k% = 全于
	List<Stud> list = c.list();
	sess.getTransaction().commit();
}

Query类，使用命名查询

@Test
public void query2(){
	Session sess = HibernateUtils.getSession();
	sess.beginTransaction();
	String hql = "from Stud where id=:myId and name=:yourName";		//使用命名的查询
	Query query = sess.createQuery(hql);
	query.setInteger("myId",3);
	query.setString("yourName","Jack");
	
	Stud stud = (Stud) query.uniqueResult();			//只要根据id查询则返回一行，则可以使用uniqueResult的方法
	System.err.println(">>>:"+stud);
	sess.getTransaction().commit();
}

//		c.add(Restrictions.allEq(param));    // param为一个HashMap
//		List list = c.list();
Query query = se.createQuery(hql);
query.setProperties(param);///一次设置可变参数
List list = query.list();
System.err.println(">>:"+list);

二. 插入操作

//@Test
public void test1(){
	Session sess = HibernateUtils.getSession();	//打开一个新的session
	Transaction tx =  sess.beginTransaction();		
	Stud s = new Stud();     //不需要设置主键，由hibernate自动分配主键
	s.setName("张三");
	sess.save(s);
	tx.commit();
}

三. 更新操作

//@Test
public void test1(){
	Session sess = HibernateUtils.getSession();	//打开一个新的session
	Transaction tx =  sess.beginTransaction();		
	Stud s = new Stud();     //不需要设置主键，由hibernate自动分配主键
	s.setName("张三");
	sess.save(s);
	tx.commit();
}

在customer.hbm.xml文件的class标签中增加select-before-update=”true” (在执行更新之前查询)

目的: 把要更新的信息又放置到session的一级缓存中,快照有一份

         再更新时,拿缓存中的数据和快照比对,没有变化,所以不再产生update语句
 
saveOrUpdate: 该方法同时包含save和update方法,

* 如果在javabean中id为Integer类型(private Integer id)

      * 如果id==null(临时对象)执行save操作

      * 如果id!=null(游离对象)就用update方法

      * 如果是持久化对象就直接返回

* 如果在javabean中id为int类型(private int id) 此时id的默认值为0

      * 如果javabean中id属性的值与unsaved-value=”0” 相同,执行insert操作

      * 如果javabean中id属性的值与unsaved-value=”0” 不相同,执行update操作

四. 删除操作

五. 工具类:HibernateUtils.java

public class HibernateUtils {
	private static SessionFactory sf = null;
	static {
		Configuration config = new Configuration();
		config.configure("hibernate.cfg.xml"); // hibernate.cfg.xml放置在src目录下
		sf = config.buildSessionFactory();
	}
 
	// 获取session
	public static Session getSession() {
		if (sf != null) {
			return sf.openSession();
		}
		return null;
	}
 
	// 关闭session
	public static void closeSession(Session session) {
		if (session != null && session.isOpen()) {
			session.close();
		}
	}
 
	// 开启事务
	public static Transaction beginTransaction(Session session) {
		if (session != null && session.isOpen()) {
			return session.beginTransaction();
		}
		return null;
	}
 
	// 提交事务
	public static void commitTransaction(Transaction ts) {
		if (ts != null && !ts.wasCommitted()) {
			ts.commit();
		}
	}
 
	// 回滚事务
	public static void rollbackTransaction(Transaction ts) {
		if (ts != null && !ts.wasRolledBack()) {
			ts.rollback();
		}
	}
}

六. Dao的标准写法CRUD

public class CustomerDao {   
	public void saveCustomer(Customer customer){     // 1. 插入记录
		Session session = null;
		Transaction ts = null;
		try{
			session = HibernateUtils.getSession();
			ts = HibernateUtils.beginTransaction(session);
			if(session!=null){
				session.save(customer);
			}
			HibernateUtils.commitTransaction(ts);
		}catch(HibernateException e){
			HibernateUtils.rollbackTransaction(ts);
			throw new RuntimeException(e);
		}finally{
			HibernateUtils.closeSession(session);
		}
	}
	
	public void updateCustomer(Customer customer){  // 2. 更新记录
		Session session = null;
		Transaction ts = null;
		try{
			session = HibernateUtils.getSession();
			if(session!=null){
				ts = HibernateUtils.beginTransaction(session);
				session.update(customer);
				HibernateUtils.commitTransaction(ts);
			}
		}catch(HibernateException e){
			HibernateUtils.rollbackTransaction(ts);
			throw new RuntimeException(e);
		}finally{
			HibernateUtils.closeSession(session);
		}
	}
	
	public Customer getCustomerById(int i){    // 3. 通过id查找
		Session session = null;
		Transaction ts = null;
		Customer customer = null;
		try{
			session = HibernateUtils.getSession();
			if(session!=null){
				ts = HibernateUtils.beginTransaction(session);
				customer = (Customer)session.get(Customer.class, i);
				HibernateUtils.commitTransaction(ts);
			}
		}catch(HibernateException e){
			HibernateUtils.rollbackTransaction(ts);
			throw new RuntimeException(e);
		}finally{
			HibernateUtils.closeSession(session);
		}
		return customer;
	}
	
	public List<Customer> findCustomers(){    // 4. 获取所有记录
		Session session = null;
		Transaction ts = null;
		List<Customer> list = null;
		try{
			session = HibernateUtils.getSession();
			if(session!=null){
				ts = HibernateUtils.beginTransaction(session);
				Query query = session.createQuery("from Customer c");
				list = query.list();
				HibernateUtils.commitTransaction(ts);
			}
		}catch(HibernateException e){
			HibernateUtils.rollbackTransaction(ts);
			throw new RuntimeException(e);
		}finally{
			HibernateUtils.closeSession(session);
		}
		return list;
	}
	public void deleteCustomerById(int id){   // 5. 删除记录
		Session session = null;
		Transaction ts = null;
		try{
			session = HibernateUtils.getSession();
			if(session!=null){
				ts = HibernateUtils.beginTransaction(session);
				Customer customer = (Customer)session.get(Customer.class, id);
				session.delete(customer);
				HibernateUtils.commitTransaction(ts);
			}
		}catch(HibernateException e){
			HibernateUtils.rollbackTransaction(ts);
			throw new RuntimeException(e);
		}finally{
			HibernateUtils.closeSession(session);
		}
	}
}