学习Hibernate笔记之Hibernate配置（二）
学习Hibernate笔记之Hibernate配置（二）
Hibernate开发流程
(1) 创建Hibernate的配置文件：该文件负责初始化Hibernate配置，包括数据库配置和映射文件配置。
(2) 创建Hibernate的映射文件：每一个数据表对应一个映射文件，该文件描述了数据库中表的信息，也描述了对应的持久化类的信息。
(3) 创建持久化类：每一个类对应一个数据库表，通过映射文件进行关联。
以上3步是开发Hibernate要实现的关键内容。接下来就要面向Web应用层进行编码，通常会分为DAO层和Service层。（分两层目的：解耦）
l DAO层（数据层）：负责调用Hibernate API 实现CRUD操作（数据访问接口）
l Service层（业务层）：编写业务层实现，调用DAO层类代码。
配置文件：
Hibernate的数据库连接信息是从配置文件中加载的，在配置文件中包含了一系列属性的配置，Hibernate将根据这些属性来连接数据库。
Hibernate的配置文件有两种形式：一种是properties属性文件，另一种是XML格式的文件。
XML格式的文件除了基本的Hibernate配置信息，还可以指定具体的持久化类的映射文件，这可以避免将持久化类配置文件硬编码在程序中。
这两种格式的文件可以同时使用，当XML比properties的优先级高！
包文件（重要的包）
l hibernate3.jar
l cglib-2.1.jar , asm-attrs.jsr , asm.jar
l dom4j-1.5.2.jar
l commons-collections-2.1.1.jar
l commons-logging-1.0.4.jsr , log4j-1.2.9.jar
Hibernate自动生成工具
l MiddleGen
l XDoclet
l AndroMDA
学习中遇到的问题：
1、持久类为什么要实现一个默认的无参构造方法？
答：所有的持久化类都必须有一个默认的构造方法（可以不是public），这样Hibernate就可以使用Constructor.newInstance()来实例它们了。（Java核心技术不过关，不懂？）
补：因为hibernate框架会调用这个默认构造方法来构造实例对象。即Class类的newInstance方法这个方法就是通过调用默认构造方法来创建实例对象的 ，
另外再提醒一点，如果你没有提供任何构造方法，虚拟机会自动提供默认构造方法（无参构造器），但是如果你提供了其他有参数的构造方法的话，虚拟机就不再为你提供默认构造方法，这时必须手动把无参构造器写在代码里，否则new Xxxx()是会报错的，所以默认的构造方法不是必须的，只在有多个构造方法时才是必须的，这里“必须”指的是“必须手动写出来”
2、什么是辅助类ThreadLocal?（JAVA概念）
答：threadlocal的介绍(转)
ThreadLocal是什么
ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单， 就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每 一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支 持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。
ThreadLocal的设计
首先看看ThreadLocal的接口：
Object get() ; // 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值
void set(Object value); // 设置当前线程的线程局部变量副本的值
ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实 现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行， 并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：
| protected Object initialValue() { return null; } |
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：
| public class ThreadLocal |
当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。
ThreadLocal的使用
如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：
| public class SerialNum |
SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：
| int serial = SerialNum.get(); |
即可。
在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。
ThreadLocal与其它同步机制的比较
ThreadLocal和其它同步机制相比有什么优势呢？ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普 通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量 进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角 度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的 变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进 ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。
由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal< T>类将从中受益。也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。
总结
当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信 的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。所 以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程 序，使程序更加易读、简洁。
最近对Hibernate的ThreadLocal Session模式有点兴趣。于是根据曹晓钢翻译的Hibernate Reference做了个小测验，结果发现了一个小bug。
代码很简单，都是利用Hibernate Reference中现成的代码。
首先是一个辅助的得到线程安全的session的HibernateUtil类，
public class HibernateUtil {
public static final SessionFactory sessionFactory;
static{
try {
sessionFactory = new Configuration().configure().buildSessionFactory();
}
catch(Throwable ex){
throw new ExceptionInInitializerError(ex);
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session currentSession()
{
Session s = (Session) session.get();
if (s==null )
{
s = sessionFactory.getCurrentSession();
session.set(s);
}
return s;
}
public static void closeSession()
{
Session s = (Session) session.get();
if (s!=null)
s.close();
session.set(null);
}
public static SessionFactory getSessionFactory()
{
return sessionFactory;
}
}
然后是一个测试插入数据的代码。也很简单，也是仿Hibernate Reference上面的代码。
public class InsertUser {
public static void main(String[] args) {
Sessionsession = HibernateUtil.currentSession();
Transaction tx= session.beginTransaction();
TUser user = new TUser();
user.setName("Emma");
session.save(user);
tx.commit();
HibernateUtil.closeSession();
}
}
就这么简单一个程序，运行到最后，出现一个错误。
org.hibernate.SessionException: Session was already closed
at org.hibernate.impl.SessionImpl.close(SessionImpl.java:270)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.hibernate.context.ThreadLocalSessionContext$TransactionProtectionWrapper.invoke(ThreadLocalSessionContext.java:301)
at $Proxy0.close(Unknown Source)
at Util.HibernateUtil.closeSession(HibernateUtil.java:36)
at test.InsertUser.main(InsertUser.java:20)
Exception in thread "main"
错误出现在 HibernateUtil.closeSession(); 这一行，意思是session已经关闭了，再次关闭它就引起异常了。
不过前面的代码中只有个tx.commit(); 提交事务 而已，并没有自动关闭session啊？
于是把DEBUG信息调用出来，发现了以下几句提示：
DEBUG [main] - after transaction completion
DEBUG [main] - automatically closing session
DEBUG [main] - closing session
DEBUG [main] - connection already null in cleanup : no action
DEBUG [main] - allowing proxied method [close] to proceed to real session
DEBUG [main] - closing session
org.hibernate.SessionException: Session was already closed
特别是下面这3句话引起了我的注意，果然是session关闭了，而且是在 事务结束以后自动关闭的。
DEBUG [main] - after transaction completion
DEBUG [main] - automatically closing session
DEBUG [main] - closing session
那么这个机制是怎么发生的呢？
打开了Hibernate3的源码，我找到了答案。
首先，根据sessionFactory = new Configuration().configure().buildSessionFactory();
打开Configuration类的buildSessionFactory()方法，找到sessionFactory的生成语句
return new SessionFactoryImpl(
this,
mapping,
settings,
getInitializedEventListeners()
);
，然后找到SessionFactoryImpl的getCurrentSession方法，发现是这么定义的。
public org.hibernate.classic.Session getCurrentSession() throws HibernateException {
if ( currentSessionContext == null ) {
throw new HibernateException( "No CurrentSessionContext configured!" );
}
return currentSessionContext.currentSession();
}
他调用的是一个currentSessionContext的currentSession方法。查找currentSessionContext变量，
currentSessionContext = buildCurrentSessionContext();
，知道了buildCurrentSessionContext方法产生了这个currentSessionContext 对象。
private CurrentSessionContext buildCurrentSessionContext() {
String impl = properties.getProperty( Environment.CURRENT_SESSION_CONTEXT_CLASS );
// for backward-compatability
if ( impl == null && transactionManager != null ) {
impl = "jta";
}
if ( impl == null ) {
return null;
}
else if ( "jta".equals( impl ) ) {
return new JTASessionContext( this );
}
else if ( "thread".equals( impl ) ) {
return new ThreadLocalSessionContext( this );
}
else {
try {
Class implClass = ReflectHelper.classForName( impl );
return ( CurrentSessionContext ) implClass
.getConstructor( new Class[] { SessionFactoryImplementor.class } )
.newInstance( new Object[] { this } );
}
catch( Throwable t ) {
log.error( "Unable to construct current session context [" + impl + "]", t );
return null;
}
}
}
这个方法就是用来判断使用JTA管理这个SessionContext还是用ThreadLocal来管理SessionContext的。
在我们这里是用 ThreadLocal 来管理的，于是找到了currentSessionContext 的实现类是 ThreadLocalSessionContext。
找到该类的currentSession方法
public final Session currentSession() throws HibernateException {
Session current = existingSession( factory );
if (current == null) {
current = buildOrObtainSession();
// register a cleanup synch
current.getTransaction().registerSynchronization( buildCleanupSynch() );
// wrap the session in the transaction-protection proxy
if ( needsWrapping( current ) ) {
current = wrap( current );
}
// then bind it
doBind( current, factory );
}
return current;
}
然后跟踪到 buildOrObtainSession(),就是这里，打开了session。
protected Session buildOrObtainSession() {
return factory.openSession(
null,
isAutoFlushEnabled(),
isAutoCloseEnabled(),
getConnectionReleaseMode()
);
}
注意第三个参数：isAutoCloseEnabled
打开Session这个接口，看到 openSession方法中这个参数是如下描述的：
* @param autoCloseSessionEnabled Should the session be auto-closed after
* transaction completion?
，就是说session是否应该在事务提交后自动关闭。
然后打开 ThreadLocalSessionContext 的isAutoCloseEnabled()方法。
/**
* Mainly for subclass usage. This impl always returns true.
*
* @return Whether or not the the session should be closed by transaction completion.
*/
protected boolean isAutoCloseEnabled() {
return true;
}
看到如下提示：Whether or not the the session should be closed by transaction completion ，即无论如何session应该在事务完成后关闭。
答案就在这里，就是说在ThreadLocal Session模式下面，只要提交了事务，那么session就自动关闭了，因此我参照Hibernate Refernece上面的代码写的在事务关闭以后再调用HibernateUtil.closeSession();是不对的，这句代码是完全多余的。
总结：加强JAVA核心技术的学习才是根
本！！！框架只是会用和不会用的问
题！！！！