Java Web（3）Hibernate 的增删改查

1. 在能能够对hibernate 初始化后，就能够经过SessionFactory来获取一个Session来对Object来操做，不用再进行编写SQL语句来经过jdbc的dao来对数据库来操做。例如：

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Demo{
    private static String DBURL="jdbc:mysql://localhost:3306/test";
    private static String DBUSER="root";	
    private static String DBPASSWORD="123456";	
    private static String DBDRIVER="org.gjt.mm.mysql.Driver";	
    private Connection conn=null;	
    public Demo(){    
        try{			
            Class.forName(DBDRIVER);			
            this.conn=DriverManager.getConnection(DBURL,DBUSER,DBPASSWORD);		
        }catch(Exception e){			
            e.printStackTrace();		
        }	
    }
    public static void main(String args[]){
        String sql = "select * from user ;";
        PreparedStatement pst = conn.prepareStatement(sql);
        ResultSet re = pstat.executeQuery();
    }
}

使用JDBC来操做数据库，无非就是经过数据库的url和数据库的用户密码，加上数据库对应的JDBC驱动获取一个Connection链接来链接到数据库，而后再经过Connection来获取一个PreparedStatement，经过PreparedStatement来获取一个ResultSet结果集

2. 如何使用Hibernate的话，就是经过一个工具类，来把SessionFactory封装成单例模式，而后能够经过这个工具类获取对SessionFactory的引用来获取Session.

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
public class HiberanteUtil {
    private static SessionFactory factory;
    static{
        try{
             Configuration cfg  = new Configuration().configure();
             StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                                              .applySettings(cfg.getProperties()).build();
             factory = cfg.buildSessionFactory(registry);
        }catch (Throwable ex) { 
             System.err.println("Failed to create sessionFactory object." + ex);
             throw new ExceptionInInitializerError(ex); 
      }
    }
    public SessionFactory getSessionFactory( ){
        return this.factory;
    }
}

3.编写一个DAO的操做类

package cn.tian.dao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import cn.tian.vo.User;

public class UserDaoImpl implements UserDao{
	private SessionFactory factory;
	
	public RoleDaoImpl(SessionFactory sessionFactory){
		this.factory = sessionFactory;
	}
	/*
	数据库添加一行记录
	*/
	@Override
	public Serializable insert(User user) {
		// TODO Auto-generated method stub
		//获取Session
		Session session = factory.openSession();
		//Hiberante事务管理
		 Transaction tx = null;
		 Serializable serializable = null;
		 try {
		     //开启一个新的事务
		     tx = session.beginTransaction();
		     //将对象变成持久状态，至关对insert into 操做
		     serializable = session.save(user);
		     //事务提交
		     tx.commit();
		 }
		 catch (Exception e) {
		     if (tx!=null) tx.rollback();
		     log.debug("UserDao: can't insert "+user);
		 }
		 finally {
		     //关闭session会话，释放系统资源
		     session.close();		     
		 }
		 return serializable;
	}
        //更新操做
	@Override
	public Role update(User user) {
		// TODO Auto-generated method stub
		Session session = factory.openSession();
		Transaction tx =  null;
		try{
			tx = session.beginTransaction();
			session.update(user);
			tx.commit();
		}catch(Exception e){
			if(tx!=null)
				tx.rollback();
			log.debug("UserDao: can't update "+user);			
		}
		finally{
			session.close();
		}
		return user;
	}
        //删除操做
	@Override
	public Role delete(User user) {
		// TODO Auto-generated method stub
		Session session = factory.openSession();
		Transaction tx = null;
		try{
			tx = session.beginTransaction();
			session.delete(user);
			tx.commit();
		}
		catch(Exception e){
			if(tx!=null)
				tx.rollback();
			log.debug("UserDao: can't delete "+user);
		}
		finally{
			session.close();
		}
		return user;
	}
        //查询，获取所有记录
	@Override
	public List<User> getList() {
		// TODO Auto-generated method stub
		String hql = "from User u";
		List<User> list = null;
		Session session = factory.openSession();
		Transaction tx = null;
		try{
			tx = session.beginTransaction();
			Query query = session.createQuery(hql);
			//在这里须要特别注意list的泛型转换，由于hibernate返回的都是Object类型的，须要转换为对应的Class
			list = query.list();
			tx.commit();
			
		}catch(Exception e){
			if(tx!=null)
				tx.rollback();
			log.debug("UserDao: can't select from user");
		}finally{
			session.close();
		}
		return list;
	}
        //只查询一条记录
	@Override
	public User get(Long id) {
		// TODO Auto-generated method stub
		Session session = factory.openSession();
		User user = null;
		try{
		        //由于返回的是Object，因此强制转换为对应的Class
			user = (Role)session.get(User.class,id);			
		}catch(Exception e ){
			log.debug("UserDao: can't find "+id);
		}
		finally{
			session.close();
		}
		return user;
	}

}

与之对比，在Hibernate对数据库的添加删除修改的时候，比JDBC少了SQL的硬编码，但须要注意其返回的类型转换