五 hibernate3的增删查改操作实现

基本功能练习
实验步骤：
1.设计domain对象User。
2.设计UserDao接口。
3.加入hibernate.jar和其依赖的包。
4.编写User.hbm.xml映射文件，可以基于hibernate/eg目录下的org/hibernate/auction/User.hbm.xml修改。
5.编写hibernate.cfg.xml配置文件，可以基于hibernate/etc/hibernate.cfg.xml修改；必须提供的几个参数：
	connection.driver_class、connection.url、connection.username、connection.password、dialect、hbm2ddl.auto。
6.编写HibernateUtils类，主要用来完成Hibnerate初始化和提供一个获得Session的方法；这步可选。
7.实现UserDao接口。

1 设计对象
package cn.domain;

import java.util.Date;

/**
 * Domain是一个领域模型 
 * 什么是领域模型呢 比如说一个人员 就有姓名 性别  年龄 职位等信息 
 * 这些信息组合在一起就是领域模型 
 * 当前这是一个人员实体类的领域模型 
 * @author Administrator
 */
public class Person {
	//id 
   private int pid; 
   //姓名
   private String pname; 
   //性别
   private String psex;
   //年龄
   private int page;
   //职业
   private String pduty;
   //出生日
   private Date birthday;
public int getPid() {
	return pid;
}
public void setPid(int pid) {
	this.pid = pid;
}
public String getPname() {
	return pname;
}
public void setPname(String pname) {
	this.pname = pname;
}
public String getPsex() {
	return psex;
}
public void setPsex(String psex) {
	this.psex = psex;
}
public int getPage() {
	return page;
}
public void setPage(int page) {
	this.page = page;
}
public String getPduty() {
	return pduty;
}
public void setPduty(String pduty) {
	this.pduty = pduty;
}
public Date getBirthday() {
	return birthday;
}
public void setBirthday(Date birthday) {
	this.birthday = birthday;
}
}

2.设计接口。
package cn.domain.dao;

import java.util.List;

import cn.domain.Person;

public interface PersonDao {
    public void savePerson(Person person)throws Exception;
    public void deleteByidPerson(int id);
    public void deletePerson(Person person)throws Exception;
    public List findPerson();
    public List findPersonName(String name);
    public List findPersonPsex(String psex);
    public Person findbyidPerson(int id);
    public boolean updatePerson(Person person)throws Exception;
}



3.加入hibernate.jar和其依赖的包。
4.编写Person.hbm.xml映射文件，可以基于hibernate/eg目录下的org/hibernate/auction/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 
	package="cn.domain">

	<class name="Person">
		<id name="pid">
			<generator class="native"/>
		</id>
		<property name="pname"/>
		<property name="psex"/>
		<property name="page"/>
		<property name="pduty"/>
		<property name="birthday"/>
	</class>
	
</hibernate-mapping>


5.编写hibernate.cfg.xml配置文件，可以基于hibernate/etc/hibernate.cfg.xml修改；必须提供的几个参数：
	connection.driver_class、connection.url、connection.username、connection.password、dialect、hbm2ddl.auto。

<!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="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<property name="connection.url">jdbc:mysql:///test</property>
	<property name="connection.username">root</property>
	<property name="connection.password">root</property>
	<!-- 指定其方言 方言的作用就是告诉hibernate是哪种数据库 -->
	<property name="dialect">
		org.hibernate.dialect.MySQLDialect
	</property>
	<!-- 指定其hibernate是否根据映射文件自动创建表 -->
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<mapping resource="cn/domain/Person.hbm.xml" />

</session-factory>
</hibernate-configuration>

6.编写HibernateUtils类，主要用来完成Hibnerate初始化和提供一个获得Session的方法；这步可选。
package cn.domain.uitl;

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

public class HibernateUtil {
     private static SessionFactory sessionFactory;
     /**
      * 不可继承
      */
     private HibernateUtil(){
    	 
     }
     /**
      * 单例
      */
     static{
    	 Configuration cfg=new Configuration().configure();
    	 /**
    	  * 获取SessionFactory对象 这个对象保存的就是配置文件中的 session-factory配置的信息
    	  */
    	 sessionFactory=cfg.buildSessionFactory();
    	 System.out.print("打开连接成功！");
     }
     
     public static SessionFactory getSessionFactory(){
    	 return sessionFactory;
     }
     
     public static Session getSession(){
    	  return sessionFactory.openSession();
     }
} 

7.实现UserDao接口。
package cn.domain.dao.imp;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;

import cn.domain.Person;
import cn.domain.dao.PersonDao;
import cn.domain.uitl.HibernateUtil;

public class PersonDaoimp implements PersonDao {

	@Override
	public void deleteByidPerson(int id) {
		Session session = null;
		Transaction tx = null;
			try {
				session = HibernateUtil.getSession();
				tx=session.beginTransaction();
				String hql = "delete from Person as p where p.pid=:id";
				Query q = session.createQuery(hql);
				q.setInteger("id", id);
				q.executeUpdate();
				tx.commit();
			} catch (Exception e) {
				tx.rollback();
				e.printStackTrace();
			} finally {
                 if(session!=null) {
                	 session.close();
                 }
			}
	}

	@Override
	public void deletePerson(Person person) throws Exception {
		Session session = null;
		Transaction tx = null;
			try {
				session = HibernateUtil.getSession();
				 tx=session.beginTransaction();
				session.delete(person);
			} catch (Exception e) {
				tx.rollback();
				e.printStackTrace();
			} finally {
                 if(session!=null) {
                	 session.close();
                 }
			} 
	}

	@Override
	public List findPerson() {
		List list=null;
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			String hql = "from Person as p";
			Query q = session.createQuery(hql);
			list=q.list();
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
           if(session!=null)session.close();
		}
		return list;
	}

	@Override
	public List findPersonName(String name) {
		List list=null;
		Session session = null;
		try {
			session = HibernateUtil.getSession();
		    Criteria ct=session.createCriteria(Person.class);
		    ct.add(Restrictions.eq("pname", name));
		    list=ct.list();
		    return list;
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
           if(session!=null)session.close();
		}
		return list;
	}

	@Override
	public List findPersonPsex(String psex) {
		List list=null;
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			String hql = "from Person as p where p.psex=?";
			Query q = session.createQuery(hql);
			q.setString(0,psex);
			list=q.list();
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
           if(session!=null)session.close();
		}
		return list;
	}

	@Override
	public Person findbyidPerson(int id) {
		List list=null;
		Session session = null;
		Person person=new Person();
		try {
			session = HibernateUtil.getSession();
			person =(Person)session.get(Person.class, id);
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
           if(session!=null)session.close();
		}
		return person;
	}

	@Override
	public void savePerson(Person person) throws Exception {
		Session session = null;
		Transaction tx = null;
			try {
				session = HibernateUtil.getSession();
				tx=session.beginTransaction();
				session.save(person);
	            tx.commit();
			} catch (Exception e) {
				tx.rollback();
				e.printStackTrace();
			} finally {
                 if(session!=null) {
                	 session.close();
                 }
			}
         
	}

	@Override
	public boolean updatePerson(Person person) throws Exception {
		boolean flg=false;
		Session session = null;
		Transaction tx = null;
			try {
				session = HibernateUtil.getSession();
				tx=session.beginTransaction();
				session.update(person);
	            tx.commit();
	            flg=true;
			} catch (Exception e) {
				tx.rollback();
				e.printStackTrace();
			} finally {
                 if(session!=null) {
                	 session.close();
                 }
			}
		 return flg;
	}

}



测试 

package cn.domain.test;

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

import cn.domain.Person;
import cn.domain.dao.PersonDao;
import cn.domain.dao.imp.PersonDaoimp;

public class PersonTest {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws Exception {
		PersonDao pd=new PersonDaoimp();
//		Person person=new Person();
//		person.setPname("力大力");
//		person.setPsex("女");
//		person.setPage(26);
//		person.setBirthday(new Date());
//		person.setPduty("高级开发人员");
	    //pd.savePerson(person);
	    
	    //pd.deleteByidPerson(1);
	    List list=null;
//	    list=pd.findPerson();
//	    Iterator iter = list.iterator() ; 
//	    while(iter.hasNext()){
//	    	Person p=(Person)iter.next();
//	    	System.out.println(p.getPname());
//	    }
	    
//	      list=pd.findPersonName("许春荣");
//	      Iterator iter=list.iterator();
//	      while(iter.hasNext()){
//	    	  Person p=(Person)iter.next();
//	    	  System.out.println(p.getPname()+"--------->"+p.getPduty());
//	      }
	     // pd.deleteByidPerson(9);
	    
	    Person person=new Person();
	    person.setPid(10);
		person.setPname("蔡国庆");
		person.setPsex("女");
		person.setPage(23);
		person.setBirthday(new Date());
		person.setPduty("高级开发人员");
		pd.updatePerson(person);
	}

}


总结：在接口的实现类中 不要去使用定义一个无参的构造方法，在这个构造方法中实现连接工厂的获取 SessionFactory 
Session， Transaction的事务开启 因为这样在实现的方法中的Session的对象的关闭就不好控制，它是基于一个对象，比如说
在实现的方法中执行了关闭Session对象 这样做的目的是为了减少内存不必要的开销，优化性能，但是这样一来，如果连续进行跟
数据库的访问，那么就会出现会话关闭，而无法访问的情况 所以必须在实现的方法中去获取连接Session对象和Transaction的事务
操作对象 


end