Hibenrate_基于单实例配置及使用_初级小结_初级配置

 Hibernate是一个基于JDBC的主流持久化框架，是一个ORM的实现
ORM（对象-关系映射机制）
创建Hibernate步骤:
1：Hibernate配置文件：
 文件默认名为："hibernate.cfg.xml"，
                文件类型为"-//Hibernate-configuration DTD 3.0//EN"(注：不要搞错了！！！)
/..
<session-factory>
 
 <property name="dialect">                               <!-- 指定数据连接的语言 -->
      org.habernate.dialect.SqlServerDialect
 </property>
 
 <property name="connection.driver_class">     <!-- 指定数据连接的驱动 -->
      net.sourceforge.jtds.jdbc.Driver
 </property>
 
 <property name="connection.url">                    <!-- 指定数据连接的URL -->
      jdbc:jtds:sqlserver://127.0.0.1:1433/DB_Haber
 </property>
 
 <property name="connection.username">         <!-- 指定数据连接的用户名 -->
      sa
 </property>
 
 <property name="connection.password">         <!-- 指定数据连接的密码 -->
      sa     
 </property>

 <property name="show_sql">                            <!-- 指定在运行时输出执行的SQL语句 -->
      true
 </property>

 <!-- 这里指定了与之映射的实体类映射文件，完整路径，包名"/"到映射文件名 -->
 <mapping resource="com/sllereak/hab/entity/Member.hbm.xml"/>  
</session-factory>
/..

 

2:实体类和与之映射的文件
(这里举出一个简单的实体类Member.java)
import java.io.Serializable;
public class Member implements Serializable {
 private static final long serialVersionUID = 2861317560659750439L; 
 private Long memID;
 private String memName;
 private Integer memAge; 
 public Member(){}
 public Long getMemID() {
  return memID;
 }
 public void setMemID(Long memID) {
  this.memID = memID;
 }
 public String getMemName() {
  return memName;
 }
 public void setMemName(String memName) {
  this.memName = memName;
 }
 public Integer getMemAge() {
  return memAge;
 }
 public void setMemAge(Integer memAge) {
  this.memAge = memAge;
 } 
}

在实体类中，实现类的序列化是有必要的，类中的数据类型必须为包装类型。如：Long，Integer等
现在创建与Member.java映射的XML文件
映射文件名即为Member.hbm.xml
文件类型为"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
(也不要弄错了，在框架的搭建中，需要大量的配置文件，而配置文件的文件类型各有差异。
个人小技巧，因为这是一个表示映射关系的配置文件，而配置文件名为..Hibernate Mapping..
Mapping即为映射的意思，所以在选择配置文件的类型时也不易搞错)

映射文件需与实体类在同一包中。
若Member.java在com.sllereak.hab.orm下，那么Member.hbm.xml也应该在此目录下。
下面详细介绍Member.hbm.xml配置

/..
<hibernate-mapping>
 <!--
       class标签用于指定与之映射的类，
       name代表类名 而table代表数据库中的表名,
                      类名和表名无需一样也可
 -->
 <class name="Member" table="MEMBER">
  <!--
        id标签指定了表中的主键与类中与主键相对应的字段名称及类型
                       name为字段名，type为字段类型（这里字段类型也为包装类型）
       -->
  <id name="memID" type="long">
   <!--
        column标签指定了在数据库中与ID标签中name所赋予的字段对应的列名,
        这里name为数据库的字段名称，length为数据的大小，not-null="true"
        当然就是指定了该字段不能为空咯,在数据库中与实体类中对应的字段
        名也无需一样。
    -->
   <column name="memID" length="8" not-null="true" />
   <!-- generator标签用于指定主键的生成策略 class="identity"是指定生成策略为自增-->
   <generator class="identity" /> 
  </id>
  <!-- property标签则用于指定在实体类中与数据库中对应的非主键字段 -->
  <property name="memName" type="string" >
   <column name="memName" length="20" not-null="true" />
  </property>
  <porperty>
   <!-- default属性指定了该字段的默认值 -->
   <column name="memAge" length="4" not-null="true" default="20"/>
  </property>
 </class>
</hibernate-mapping>
/..

3:创建HibernateSessionFactory
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

public class HibernateSessionFactory {
//设置hibernate配置文件路径，不为final是因为方便修改
private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
//创建用于存放Session的泛型线程对象，为当前线程的分支。
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
//创建Configuration对象
private static Configuration configuration = new Configuration();
//定义用于创建Session的工厂
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;
//在静态块中用Configuration对象的configure(configFile)方法加载配置文件
//接着用Configuration的buildSessionFactory()方法获得org.hibernate.SessionFactory类的实体
static {
   try {
  configuration.configure(configFile);
  sessionFactory = configuration.buildSessionFactory();
 } catch (Exception e) {
  System.err.println("%%%% Error Creating SessionFactory %%%%");
  e.printStackTrace();
 }
}
private HibernateSessionFactory() {}
//用于获取Session对象的方法
public static Session getSession() throws HibernateException {
//通过ThreadLocal对象的get()方法 返回一个ThreadLocal对象，再强转为Session对象，Session诞生了
Session session = (Session) threadLocal.get();
 //当session为空或者session状态为非开启并且org.hibernate.SessionFactory
 //为null时调用rebuildSessionFactory()方法 再次创建org.hibernate.SessionFactory对象
 //并且如果org.hibernate.SessionFactory对象不为空则返回由org.hibernate.SessionFactory对象的openSession()
 //方法获取的Session否则返回空，最后将session添加到ThreadLocal对象中
 if (session == null || !session.isOpen()) {
  if (sessionFactory == null) {
   rebuildSessionFactory();
  }
  session = (sessionFactory != null) ? sessionFactory.openSession(): null;
  threadLocal.set(session);
 }
                return session;
}
//当org.hibernate.SessionFactory对象为null时调用 用于创建org.hibernate.SessionFactory对象
public static void rebuildSessionFactory() {
 try {
  configuration.configure(configFile);
  sessionFactory = configuration.buildSessionFactory();
 } catch (Exception e) {
  System.err.println("%%%% Error Creating SessionFactory %%%%");
  e.printStackTrace();
 }
}
//在此方法中，首先获得当前session然后将ThreadLocal对象中的session设置为null
//如果session还不等于null 则讲其关闭
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);
       
        if (session != null) {
            session.close();
        }
    }
     //获取org.hibernate.SessionFactory对象
 public static org.hibernate.SessionFactory getSessionFactory() {
  return sessionFactory;
 }
 //设置读取的配置文件
 public static void setConfigFile(String configFile) {
  HibernateSessionFactory.configFile = configFile;
  sessionFactory = null;
 }
 //获取Configuration对象
 public static Configuration getConfiguration() {
  return configuration;
 }

}