hibernate学习笔记2--对简单例子的代码的解释与简单优化（规范）

一、开发流程：
1.由Domain object ->mapping->db.(官方推荐)
2.由DB开始，用工具生成mapping和Domain object。（使用较多）
3.由映射文件开始。

二、Domain object的限制
1.默认的构造方法（无参构造，如果没有明确书写，java会使用缺省的默认构造方法。）（必须的）
2.有无意义的标示符id（主键）（可选）
3.非final的（类和方法等），对懒加载有影响的（可选）
三、映射配置文件
1.<hibernate-mapping package="cn.itcast.hibernate.domain">
class标签类的位置
2.<class name="User" table="tb_User">
class标签：代表一个类（javabean或是domain）
table：对应数据库中的表名。可以不写：表名与类名一样
3.<id name="id" column="id">                         
     <!-- 指定主键生成方式。          
          native根据方言判定生成主键的方式
           -->                           
      <generator class="native"/>     
    </id>   
    
    id：映射主键 column：指定与之对应的列，缺省则同名  
    generator：指定主键生成器
    
4.  <property name="name" column="name" />     
 property：指定类中的属性，  column：指定表中与之对应的字段
四、代码的分析
//对hibernate初始化----注册驱动,解析映射文件、解析配置文件等耗时，一般只做一次                          
  Configuration cfg = new Configuration();
  cfg.configure();                       

五、对代码的优化与规范

1.将hibernate初始化只进行一次，因为初始化很耗时、耗资源

package cn.itcast.hibernate;

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

/*
 * 想让初始化创建只执行一次
 * 方式1：单例模式
 * 方式2: 静态语句块等
 * 
 * 由于只想让初始化执行一次，不想让其他类继承所以此类用final修饰，不想被其他类初始化所以默认构造用private修饰,由于在静态语句块中所以加static
 * 
 * 
 */
public final class HIbernateUtil {


 private static SessionFactory sessionfactory;
 private HIbernateUtil(){
  
 }
 
 static {
  Configuration cfg = new Configuration();
  cfg.configure();
  //cfg.configure("filename"); 可以通过filename来指定配置文件的位置和配置文件名（如果不在默认classpath的位置下）
  //所用的src下的文件都会经行编译，最后字节码文件在classpath下，bin是classpath下的一部分
  sessionfactory = cfg.buildSessionFactory();
 }
 /*
  * 创建出对象，通过getter方法方便外接使用
  * 
  */
 public static SessionFactory getSessionfactory() {
  return sessionfactory;
 }
 
 /**
  * 此session包为org.hibernate.Session;
  * @return
  * 定义方法返回session,session你可以理解为jdbc的数据库连接
  */
 public static Session getSession(){
  return sessionfactory.openSession();
 }
}

2.对调用方法进行规范添加异常捕获机制代码

package cn.itcast.hibernate;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.itcast.hibernate.domain.User;



public class Base {
	public static void main(String []args){
		//对hibernate初始化----注册驱动,解析映射文件、解析配置文件等耗时，一般只做一次
//		Configuration cfg = new Configuration();
//		cfg.configure();
//		Session s = sf.openSession();
//		//工厂类
//		SessionFactory sf = cfg.buildSessionFactory();
		
		Session s = HIbernateUtil.getSession();
		
		//此段代码没有控制异常
		//打开事务
		Transaction tx=s.beginTransaction();
		
		User user = new User();
		user.setBirthday(new Date());
		user.setName("name");
		
		s.save(user);
		tx.commit();//提交事务
		s.close(); // 应该在finaly中释放
		System.out.println("end");
		
	}
	
	/**
	 * 写一个相对规范的代码
	 * @param user
	 */
	static void addUser(User user){
		Session s = null;
		Transaction tx =null;
		 try {
			s= HIbernateUtil.getSession();
			 tx=s.beginTransaction();
			 s.save(user);
			 tx.commit();
		} catch (HibernateException e) {
			if(tx!=null)
				tx.rollback();
			throw e;//捕获的异常处理不了，必须抛出去
			
		}finally{
			if(s!=null){
				s.close();//必须释放掉这宝贵的资源
			}
		}
	}
	
	/**
	 * 简化下上一段代码，效果和上一段是一样的
	 * 原理：一般数据库如果收不到提交请求的话，会回滚事务。
	 * 所以遇到异常的时候就会往外抛异常，由于db没有收到提交请求，事务就回归滚
	 * @param user
	 */
	static void addUser1(User user){
		Session s = null;
		Transaction tx =null;
		 try {
			s= HIbernateUtil.getSession();
			 tx=s.beginTransaction();
			 s.save(user);
			 tx.commit();
		} finally{
			if(s!=null){
				s.close();//必须释放掉这宝贵的资源
			}
		}
	}
}