关于hibernate

Question

public static Session getSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
threadLocal.set(session);
}
        return session;
    } public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}初学hibernate，我知道这里的session相当于获取连接，然后产生一个对象，用这个对象操作数据库，但这里的
sessionFactory 在经过rebuildSessionFactory（）后里面包含什么？这段代码的意义是什么？

Answer 1

貌似设置什么   然后对sessionFactory 重新赋值  这得看具体代码  这么看很难看出根本

Answer 2

是每个工厂都有自己的session,我想知道 这句是什么意思Session session = (Session) threadLocal.get();用来做什么的？
下面是一个jar包里的public class ThreadLocal<T> {
        private final int threadLocalHashCode = nextHashCode();
       private static AtomicInteger nextHashCode = 
new AtomicInteger();        private static final int HASH_INCREMENT = 0x61c88647;        private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT); 
    }       protected T initialValue() {
        return null;
    }        public ThreadLocal() {
    }       public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }       public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }        public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }        void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }       static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }        T childValue(T parentValue) {
        throw new UnsupportedOperationException();
    }        static class ThreadLocalMap {                
        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }               private static final int INITIAL_CAPACITY = 16;               private Entry[] table;                private int size = 0;               private int threshold; // Default to 0                private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }              private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }                private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }                ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }               private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    ThreadLocal key = e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }                private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
                 private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;            while (e != null) {
                ThreadLocal k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }