面试题

===================================================



你对Java的集合框架了解吗？ 能否说说常用的类？



说说Hashtable与HashMap的区别： 源代码级别的区别呢？



平时用过的List有哪些？ （除了ArrayList和LinkedList），ArrayList和LinkedList的区别？[size=large][/size]



ArrayList的特点，内部容器是如何扩充的？



Properties类的特点？ 线程安全?



===============================================

平时使用过的框架有哪些？ (我提到了Struts2)



请说一下Struts2的初始化？和类的创建？(从源代码角度出发)



据你了解，除了反射还有什么方式可以动态的创建对象？（我提到了CGLIB…… 我以为他会接着问CGLIB,揪心中……，结果他没问）



请说一下Struts2 是如何把Action交给Spring托管的？它是单例的还是多例？ 你们页面的表单对象是多例还是单例？



请说一下你们业务层对象是单例还是多例的？



请说一下Struts2源代码中有哪些设计模式？



======================================================



请说一下，你觉得你最熟悉的技术特点？ （我提到了并发编程）



请说一下线程安全出现的原因？



请说一下线程池的中断策略(4个)？ 各有什么特点？



请说一下Tomcat配置不同应用的不同端口如何配置？ 如何配置数据源？ 如何实现动态部署？



请说一下Java常用的优化？



你了解最新的Servlet规范吗？ 简单说一下？（我提到了推）



那请你说一下“推”是如何实现的？



线程安全下，StringBuffer与StringBuilder的区别？ 它们是如何扩充内部数组容量的？ （源代码）



请说一下Tomcat中的设计模式？（我提到观察者模式）



是否可以说说Java反射的相关优化机制？ （我说我不太清楚…… 他说没关系 - -！）



请说一些Mysql的常用优化策略？



因为我之前有提到过“推”，他可能对我的知识面比较感兴趣，要我说说平时都看些什么书，还了解一些什么其他的技术范畴。

（他首先提到SOA，我说有了解，并且是未来的趋势，还有提到云计算，我说有过一定了解，但是并未深究）



=====================================================

之后是几个职业方面的问题？



你觉得你的潜力？ 你在团队中的位置？ 你觉得跟团队中最好的还有哪些差距？你要花多少时间赶上他们？



你对阿里巴巴还有什么疑问吗？ （我很囧的问了，“阿里巴巴的牛人平时都跟你们有互动吗？-----本意是指培训，但是话没说清楚……”，囧了……）



PS，下面是时候对问题的整理，里面纯粹仅限于个人浅见，如果有错误，还希望各位能指点一二。
==================================================================
你对Java的集合框架了解吗？ 能否说说常用的类？ 
Java集合框架类图：



我常用的类：
HashMap,Hashtable,HashSet,ArrayList,Vector,LinkedList,Collections,Arrays;


说说Hashtable与HashMap的区别(源代码级别)

       1.最明显的区别在于Hashtable 是同步的(每个方法都是synchronized)，而HashMap则不是.

       2.HashMap继承至AbstractMap,Hashtable继承至Dictionary ,前者为Map的骨干， 其内部已经实现了Map所需           要做的大部分工作， 它的子类只需要实现它的少量方法即可具有Map的多项特性。而后者内部都为抽象方法，需要           它的实现类一一作自己的实现，且该类已过时

        3.两者检测是否含有key时，hash算法不一致，HashMap内部需要将key的hash码重新计算一边再检测，而                    Hashtable则直接利用key本身的hash码来做验证。

HashMap:



Java代码
int hash = (key == null) ? 0 : hash(key.hashCode());  
-----  
static int hash(int h) {  
        h ^= (h >>> 20) ^ (h >>> 12);  
        return h ^ (h >>> 7) ^ (h >>> 4);  
    } 

int hash = (key == null) ? 0 : hash(key.hashCode());
-----
static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

Hashtable：



Java代码
int hash = key.hashCode(); 

int hash = key.hashCode();

4.两者初始化容量大小不一致，HashMap内部为 16*0.75 , Hashtable 为 11*0.75

HashMap:



Java代码
static final int DEFAULT_INITIAL_CAPACITY = 16;  
static final float DEFAULT_LOAD_FACTOR = 0.75f;  
public HashMap() {  
     this.loadFactor = DEFAULT_LOAD_FACTOR;  
     threshold=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);  
     table = new Entry[DEFAULT_INITIAL_CAPACITY];  
     init();  
}     
……………………………… 

static final int DEFAULT_INITIAL_CAPACITY = 16;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap() {
     this.loadFactor = DEFAULT_LOAD_FACTOR;
     threshold=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);
     table = new Entry[DEFAULT_INITIAL_CAPACITY];
     init();
}
………………………………

Hashtable:



Java代码
public Hashtable() {  
    this(11, 0.75f);  
}  
-----  
public Hashtable(int initialCapacity, float loadFactor) {  
        ..........  
    this.loadFactor = loadFactor;  
    table = new Entry[initialCapacity];  
    threshold = (int)(initialCapacity * loadFactor);  
    }    

public Hashtable() {
this(11, 0.75f);
}
-----
public Hashtable(int initialCapacity, float loadFactor) {
    ..........
this.loadFactor = loadFactor;
table = new Entry[initialCapacity];
threshold = (int)(initialCapacity * loadFactor);
    }

   其实后续的区别应该还有很多， 这里先列出4点。



平时除了ArrayList和LinkedList外，还用过的List有哪些？
ArrayList和LinkedList的区别？


事实上，我用过的List主要就是这2个， 另外用过Vector.

ArrayList和LinkedList的区别：



毫无疑问，第一点就是两者的内部数据结构不同， ArrayList内部元素容器是一个Object的数组，
而LinkedList内部实际上一个链表的数据结构，其有一个内部类来表示链表.
Java代码
(ArrayList)  
private transient Object[] elementData;   
 
………………………………………………………………………………  
 
(LinkedList)  
private transient Entry<E> header = new Entry<E>(null, null, null);/链表头   
 
//内部链表类.  
private static class Entry<E> {  
    E element; //数据元素  
    Entry<E> next; // 前驱  
    Entry<E> previous;//后驱  
    Entry(E element, Entry<E> next, Entry<E> previous) {  
        this.element = element;  
        this.next = next;  
        this.previous = previous;  
    }  
}    

(ArrayList)
private transient Object[] elementData;

………………………………………………………………………………

(LinkedList)
private transient Entry<E> header = new Entry<E>(null, null, null);/链表头

//内部链表类.
private static class Entry<E> {
E element; //数据元素
Entry<E> next; // 前驱
Entry<E> previous;//后驱
Entry(E element, Entry<E> next, Entry<E> previous) {
    this.element = element;
    this.next = next;
    this.previous = previous;
}
}  
两者的父类不同，也就决定了两者的存储形式不同。 ArrayList继承于 AbstractList,而LinkedList继承于AbstractSequentialList. 两者都实现了List的骨干结构，只是前者的访问形式趋向于 “随机访问”数据存储（如数组），后者趋向于 “连续访问”数据存储（如链接列表）

Java代码
public class ArrayList<E> extends AbstractList<E>     
---------------------------------------------------------------------------------------  
public class LinkedList<E> extends AbstractSequentialList<E>     

public class ArrayList<E> extends AbstractList<E>
---------------------------------------------------------------------------------------
public class LinkedList<E> extends AbstractSequentialList<E>  
再有就是两者的效率问题， ArrayList基于数组实现，所以毫无疑问可以直接用下标来索引，其索引数据快，插入元素设计到数组元素移动，或者数组扩充，所以插入元素要慢。LinkedList基于链表结构，插入元素只需要改变插入元素的前后项的指向即可，故插入数据要快，而索引元素需要向前向后遍历，所以索引元素要慢。
ArrayList的特点，内部容器是如何扩充的？
上一点谈到了ArrayList的特点，这里略，重点来看其内部容器的扩充：
Java代码
public void ensureCapacity(int minCapacity) {  
        modCount++;  
        int oldCapacity = elementData.length;  
        if (minCapacity > oldCapacity) {  
            Object oldData[] = elementData;  
             //这里扩充的大小为原大小的大概 60%  
            int newCapacity = (oldCapacity * 3) / 2 + 1;  
            if (newCapacity < minCapacity)  
                newCapacity = minCapacity;  
            //创建一个指定大小的新数组来覆盖原数组  
            elementData = Arrays.copyOf(elementData, newCapacity);  
        }  
    }    

public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
             //这里扩充的大小为原大小的大概 60%
int newCapacity = (oldCapacity * 3) / 2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
            //创建一个指定大小的新数组来覆盖原数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

Properties类的特点？ 线程安全吗? 
Properties 继承于Hashtable,,所以它是线程安全的.
其特点是:
它表示的是一个持久的属性集，它可以保存在流中或者从流中加载，属性列表的每一个键和它所对应的值都是一个“字符串”
     其中，常用的方法是load()方法，从流中加载属性：
Java代码
<SPAN style="FONT-WEIGHT: normal">public synchronized void load(InputStream inStream) throws IOException {  
        // 将输入流转换成LineReader  
        load0(new LineReader(inStream));  
    }  
 
    private void load0(LineReader lr) throws IOException {  
        char[] convtBuf = new char[1024];  
        int limit;  
        int keyLen;  
        int valueStart;  
        char c;  
        boolean hasSep;  
        boolean precedingBackslash;  
        // 一行一行处理  
        while ((limit = lr.readLine()) >= 0) {  
            c = 0;  
            keyLen = 0;  
            valueStart = limit;  
            hasSep = false;  
            precedingBackslash = false;  
            // 下面用2个循环来处理key,value  
            while (keyLen < limit) {  
                c = lr.lineBuf[keyLen];  
                // need check if escaped.  
                if ((c == '=' || c == ':') && !precedingBackslash) {  
                    valueStart = keyLen + 1;  
                    hasSep = true;  
                    break;  
                } else if ((c == ' ' || c == '\t' || c == '\f')  
                        && !precedingBackslash) {  
                    valueStart = keyLen + 1;  
                    break;  
                }  
                if (c == '\\') {  
                    precedingBackslash = !precedingBackslash;  
                } else {  
                    precedingBackslash = false;  
                }  
                keyLen++;  
            }  
 
            while (valueStart < limit) {  
                c = lr.lineBuf[valueStart];  
                if (c != ' ' && c != '\t' && c != '\f') {  
                    if (!hasSep && (c == '=' || c == ':')) {  
                        hasSep = true;  
                    } else {  
                        break;  
                    }  
                }  
                valueStart++;  
            }  
 
            String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);  
            String value = loadConvert(lr.lineBuf, valueStart, limit  
                    - valueStart, convtBuf);  
            // 存入内部容器中，这里用的是Hashtable 内部的方法.  
            put(key, value);  
        }  
    }</SPAN> 

public synchronized void load(InputStream inStream) throws IOException {
// 将输入流转换成LineReader
load0(new LineReader(inStream));
}

private void load0(LineReader lr) throws IOException {
char[] convtBuf = new char[1024];
int limit;
int keyLen;
int valueStart;
char c;
boolean hasSep;
boolean precedingBackslash;
// 一行一行处理
while ((limit = lr.readLine()) >= 0) {
c = 0;
keyLen = 0;
valueStart = limit;
hasSep = false;
precedingBackslash = false;
// 下面用2个循环来处理key,value
while (keyLen < limit) {
c = lr.lineBuf[keyLen];
// need check if escaped.
if ((c == '=' || c == ':') && !precedingBackslash) {
valueStart = keyLen + 1;
hasSep = true;
break;
} else if ((c == ' ' || c == '\t' || c == '\f')
&& !precedingBackslash) {
valueStart = keyLen + 1;
break;
}
if (c == '\\') {
precedingBackslash = !precedingBackslash;
} else {
precedingBackslash = false;
}
keyLen++;
}

while (valueStart < limit) {
c = lr.lineBuf[valueStart];
if (c != ' ' && c != '\t' && c != '\f') {
if (!hasSep && (c == '=' || c == ':')) {
hasSep = true;
} else {
break;
}
}
valueStart++;
}

String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);
String value = loadConvert(lr.lineBuf, valueStart, limit
- valueStart, convtBuf);
// 存入内部容器中，这里用的是Hashtable 内部的方法.
put(key, value);
}
} LineReader类，是Properties内部的类：
Java代码
<SPAN style="FONT-WEIGHT: normal">class LineReader {  
        public LineReader(InputStream inStream) {  
            this.inStream = inStream;  
            inByteBuf = new byte[8192];  
        }  
 
        public LineReader(Reader reader) {  
            this.reader = reader;  
            inCharBuf = new char[8192];  
        }  
 
        byte[] inByteBuf;  
        char[] inCharBuf;  
        char[] lineBuf = new char[1024];  
        int inLimit = 0;  
        int inOff = 0;  
        InputStream inStream;  
        Reader reader;  
 
        /** 
         * 读取一行 
         *  
         * @return 
         * @throws IOException 
         */ 
        int readLine() throws IOException {  
            int len = 0;  
            char c = 0;  
            boolean skipWhiteSpace = true;// 空白  
            boolean isCommentLine = false;// 注释  
            boolean isNewLine = true;// 是否新行.  
            boolean appendedLineBegin = false;// 加 至行开始  
            boolean precedingBackslash = false;// 反斜杠  
            boolean skipLF = false;  
            while (true) {  
                if (inOff >= inLimit) {  
                    // 从输入流中读取一定数量的字节并将其存储在缓冲区数组inCharBuf/inByteBuf中,这里区分字节流和字符流  
                    inLimit = (inStream == null) ? reader.read(inCharBuf)  
                            : inStream.read(inByteBuf);  
                    inOff = 0;  
                    // 读取到的为空.  
                    if (inLimit <= 0) {  
                        if (len == 0 || isCommentLine) {  
                            return -1;  
                        }  
                        return len;  
                    }  
                }  
                if (inStream != null) {  
                    // 由于是字节流，需要使用ISO8859-1来解码  
                    c = (char) (0xff & inByteBuf[inOff++]);  
                } else {  
                    c = inCharBuf[inOff++];  
                }  
 
                if (skipLF) {  
                    skipLF = false;  
                    if (c == '\n') {  
                        continue;  
                    }  
                }  
                if (skipWhiteSpace) {  
                    if (c == ' ' || c == '\t' || c == '\f') {  
                        continue;  
                    }  
                    if (!appendedLineBegin && (c == '\r' || c == '\n')) {  
                        continue;  
                    }  
                    skipWhiteSpace = false;  
                    appendedLineBegin = false;  
                }  
                if (isNewLine) {  
                    isNewLine = false;  
                    if (c == '#' || c == '!') {  
                        // 注释行，忽略.  
                        isCommentLine = true;  
                        continue;  
                    }  
                }  
                // 读取真正的属性内容  
                if (c != '\n' && c != '\r') {  
                    // 这里类似于ArrayList内部的容量扩充，使用字符数组来保存读取的内容.  
                    lineBuf[len++] = c;  
                    if (len == lineBuf.length) {  
                        int newLength = lineBuf.length * 2;  
                        if (newLength < 0) {  
                            newLength = Integer.MAX_VALUE;  
                        }  
                        char[] buf = new char[newLength];  
                        System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);  
                        lineBuf = buf;  
                    }  
                    if (c == '\\') {  
                        precedingBackslash = !precedingBackslash;  
                    } else {  
                        precedingBackslash = false;  
                    }  
                } else {  
                    // reached EOL 文件结束  
                    if (isCommentLine || len == 0) {  
                        isCommentLine = false;  
                        isNewLine = true;  
                        skipWhiteSpace = true;  
                        len = 0;  
                        continue;  
                    }  
                    if (inOff >= inLimit) {  
                        inLimit = (inStream == null) ? reader.read(inCharBuf)  
                                : inStream.read(inByteBuf);  
                        inOff = 0;  
                        if (inLimit <= 0) {  
                            return len;  
                        }  
                    }  
                    if (precedingBackslash) {  
                        len -= 1;  
                        skipWhiteSpace = true;  
                        appendedLineBegin = true;  
                        precedingBackslash = false;  
                        if (c == '\r') {  
                            skipLF = true;  
                        }  
                    } else {  
                        return len;  
                    }  
                }  
            }  
        }  
    }   </SPAN> 

class LineReader {
public LineReader(InputStream inStream) {
this.inStream = inStream;
inByteBuf = new byte[8192];
}

public LineReader(Reader reader) {
this.reader = reader;
inCharBuf = new char[8192];
}

byte[] inByteBuf;
char[] inCharBuf;
char[] lineBuf = new char[1024];
int inLimit = 0;
int inOff = 0;
InputStream inStream;
Reader reader;

/**
* 读取一行
*
* @return
* @throws IOException
*/
int readLine() throws IOException {
int len = 0;
char c = 0;
boolean skipWhiteSpace = true;// 空白
boolean isCommentLine = false;// 注释
boolean isNewLine = true;// 是否新行.
boolean appendedLineBegin = false;// 加 至行开始
boolean precedingBackslash = false;// 反斜杠
boolean skipLF = false;
while (true) {
if (inOff >= inLimit) {
// 从输入流中读取一定数量的字节并将其存储在缓冲区数组inCharBuf/inByteBuf中,这里区分字节流和字符流
inLimit = (inStream == null) ? reader.read(inCharBuf)
: inStream.read(inByteBuf);
inOff = 0;
// 读取到的为空.
if (inLimit <= 0) {
if (len == 0 || isCommentLine) {
return -1;
}
return len;
}
}
if (inStream != null) {
// 由于是字节流，需要使用ISO8859-1来解码
c = (char) (0xff & inByteBuf[inOff++]);
} else {
c = inCharBuf[inOff++];
}

if (skipLF) {
skipLF = false;
if (c == '\n') {
continue;
}
}
if (skipWhiteSpace) {
if (c == ' ' || c == '\t' || c == '\f') {
continue;
}
if (!appendedLineBegin && (c == '\r' || c == '\n')) {
continue;
}
skipWhiteSpace = false;
appendedLineBegin = false;
}
if (isNewLine) {
isNewLine = false;
if (c == '#' || c == '!') {
// 注释行，忽略.
isCommentLine = true;
continue;
}
}
// 读取真正的属性内容
if (c != '\n' && c != '\r') {
// 这里类似于ArrayList内部的容量扩充，使用字符数组来保存读取的内容.
lineBuf[len++] = c;
if (len == lineBuf.length) {
int newLength = lineBuf.length * 2;
if (newLength < 0) {
newLength = Integer.MAX_VALUE;
}
char[] buf = new char[newLength];
System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);
lineBuf = buf;
}
if (c == '\\') {
precedingBackslash = !precedingBackslash;
} else {
precedingBackslash = false;
}
} else {
// reached EOL 文件结束
if (isCommentLine || len == 0) {
isCommentLine = false;
isNewLine = true;
skipWhiteSpace = true;
len = 0;
continue;
}
if (inOff >= inLimit) {
inLimit = (inStream == null) ? reader.read(inCharBuf)
: inStream.read(inByteBuf);
inOff = 0;
if (inLimit <= 0) {
return len;
}
}
if (precedingBackslash) {
len -= 1;
skipWhiteSpace = true;
appendedLineBegin = true;
precedingBackslash = false;
if (c == '\r') {
skipLF = true;
}
} else {
return len;
}
}
}
}
} 这里特别的是，实际上，Properties从流中加载属性集合，是通过将流中的字符或者字节分成一行行来处理的。


请说一下Struts2的初始化？和类的创建？(从源代码角度出发)
（我当时回答这个问题的思路我想应该对了， 我说是通过反射加配置文件来做的）
由于这个问题研究起来可以另外写一篇专门的模块，这里只列出相对简单的流程，后续会希望有时间整理出具体的细节:
首先，Struts2是基于Xwork框架的，如果你有仔细看过Xwork的文档，你会发现，它的初始化过程基于以下几个类：
Configuring XWork2 centers around the following classes:-
1. ConfigurationManager
2. ConfigurationProvider
3. Configuration
而在ConfigurationProvider的实现类XmlConfigurationProvider 的内部，你可以看到下面的代码
Java代码
<SPAN style="FONT-WEIGHT: normal"> public XmlConfigurationProvider() {  
        this("xwork.xml", true);  
}</SPAN> 

public XmlConfigurationProvider() {
        this("xwork.xml", true);
} 同样的，Struts2的初始化也是这样的一个类，只不过它继承于Xwork原有的类，并针对Struts2做了一些特别的定制。
Java代码
<SPAN style="FONT-WEIGHT: normal">public class StrutsXmlConfigurationProvider   
   extends XmlConfigurationProvider {  
    public StrutsXmlConfigurationProvider(boolean errorIfMissing)  
    {  
        this("struts.xml", errorIfMissing, null);  
    }  
……  </SPAN> 

public class StrutsXmlConfigurationProvider
   extends XmlConfigurationProvider {
public StrutsXmlConfigurationProvider(boolean errorIfMissing)
{
        this("struts.xml", errorIfMissing, null);
    }
…… 如果你要查看这个类在哪里调用了，你会追踪到Dispatch的类，
记得吗? 我们使用Struts2，第一步就是在Web.xml中配置一个过滤器 FilterDispatcher,
没错，在web容器初始化过滤器的时候, 同时也会初始化Dispatch..


FilterDispatch.init():
Java代码
<SPAN style="FONT-WEIGHT: normal">public void init(FilterConfig filterConfig)   
throws ServletException {  
        try {  
            this.filterConfig = filterConfig;  
            initLogging();  
            dispatcher = createDispatcher(filterConfig);  
            dispatcher.init();////初始化Dispatcher.  
            dispatcher.getContainer().inject(this);  
            staticResourceLoader.setHostConfig(new FilterHostConfig(filterConfig));  
        } finally {  
            ActionContext.setContext(null);  
        }  
    }   </SPAN> 

public void init(FilterConfig filterConfig)
throws ServletException {
        try {
            this.filterConfig = filterConfig;
            initLogging();
            dispatcher = createDispatcher(filterConfig);
            dispatcher.init();////初始化Dispatcher.
            dispatcher.getContainer().inject(this);
            staticResourceLoader.setHostConfig(new FilterHostConfig(filterConfig));
        } finally {
            ActionContext.setContext(null);
        }
    } Dispatch.init():
Java代码
<SPAN style="FONT-WEIGHT: normal">//这里是加载配置文件， 真正初始化Struts2的Action实例还没开始，  
public void init() {  
        if (configurationManager == null) {  
            configurationManager =   
new ConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);  
        }  
        init_DefaultProperties(); // [1]  
        init_TraditionalXmlConfigurations(); // [2]  
        init_LegacyStrutsProperties(); // [3]  
        init_CustomConfigurationProviders(); // [5]  
        init_FilterInitParameters() ; // [6]  
        init_AliasStandardObjects() ; // [7]  
        Container container = init_PreloadConfiguration();  
        container.inject(this);  
        init_CheckConfigurationReloading(container);  
        init_CheckWebLogicWorkaround(container);  
        if (!dispatcherListeners.isEmpty()) {  
            for (DispatcherListener l : dispatcherListeners) {  
                l.dispatcherInitialized(this);  
            }  
        }  
    }   </SPAN> 

//这里是加载配置文件， 真正初始化Struts2的Action实例还没开始，
public void init() {
    if (configurationManager == null) {
    configurationManager =
new ConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);
    }
    init_DefaultProperties(); // [1]
        init_TraditionalXmlConfigurations(); // [2]
        init_LegacyStrutsProperties(); // [3]
        init_CustomConfigurationProviders(); // [5]
        init_FilterInitParameters() ; // [6]
        init_AliasStandardObjects() ; // [7]
        Container container = init_PreloadConfiguration();
        container.inject(this);
        init_CheckConfigurationReloading(container);
        init_CheckWebLogicWorkaround(container);
        if (!dispatcherListeners.isEmpty()) {
            for (DispatcherListener l : dispatcherListeners) {
                l.dispatcherInitialized(this);
            }
        }
    } 到初始化Action类的时候， 你需要去FilterDispatcher的doFilter方法去看代码， 你会发现：
Java代码
<SPAN style="FONT-WEIGHT: normal">public void doFilter(ServletRequest req, ServletResponse res,  
FilterChain chain) throws IOException, ServletException {  
……           
dispatcher.serviceAction(request, response, servletContext, mapping);</SPAN> 

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
……        
dispatcher.serviceAction(request, response, servletContext, mapping); 再追踪到Dispatcher类，看到这个方法：
Java代码
<SPAN style="FONT-WEIGHT: normal"> public void serviceAction(HttpServletRequest request,  
HttpServletResponse response, ServletContext context,  
  ActionMapping mapping) throws ServletException {  
      ……  
     ActionProxy proxy =config.getContainer().getInstance(  
                                                      ActionProxyFactory.class).  
                                                     createActionProxy(namespace,   
                                                                                          name,   
                                                                                        method,   
                                                                                   extraContext,  
                                                                                       true, false);  
 
    ……</SPAN> 

public void serviceAction(HttpServletRequest request,
HttpServletResponse response, ServletContext context,
  ActionMapping mapping) throws ServletException {
      ……
     ActionProxy proxy =config.getContainer().getInstance(
                                                      ActionProxyFactory.class).
                                                     createActionProxy(namespace,
                                                                                          name,
                                                                                        method,
                                                                                   extraContext,
                                                                                       true, false);

…… 这行代码已经明确的告诉你了， 它的作用就是创建ActionProxy,而我们想要知道的是，
他是如何创建的;
而上面代码中的config，实际上是Xwork中的.Configuration， 如果你打开Xwork源代码，你会发现，他其实是一个接口， 真正做处理的，这里是
com.opensymphony.xwork2.config.impl.DefaultConfiguration类， 通过它的getContainer()方法，获取到一个Container类型的实例，而Container也是一个接口， 其实现类是：


com.opensymphony.xwork2.inject.ContainerImpl
他的getInstance(Class clazz):

public <T> T getInstance(final Class<T> type) {

Java代码
return callInContext(new ContextualCallable<T>() {  
  public T call(InternalContext context) {  
    return getInstance(type, context);  
  }  
});  

    return callInContext(new ContextualCallable<T>() {
      public T call(InternalContext context) {
        return getInstance(type, context);
      }
    });
  }
返回的是你传入的对象，而在这里就是：ActionProxyFactory（也是接口，真正返回的是com.opensymphony.xwork2.DefaultActionProxyFactory）



而现在，到了真正开始处理加载Action实例的时候了：
Java代码
public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName,   
boolean executeResult, boolean cleanupContext) {  
        DefaultActionProxy proxy = new DefaultActionProxy(inv,  
namespace, actionName, methodName, executeResult, cleanupContext);  
        container.inject(proxy);  
        proxy.prepare();  
        return proxy;  
    } 

public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName,
boolean executeResult, boolean cleanupContext) {
        DefaultActionProxy proxy = new DefaultActionProxy(inv,
namespace, actionName, methodName, executeResult, cleanupContext);
        container.inject(proxy);
        proxy.prepare();
        return proxy;
    }


       这里，我们主要关心的是：
Java代码
protected void prepare()  {  
      ……  
          invocation.init(this);  
……  
    } 

protected void prepare()  {
      ……
          invocation.init(this);
……
}
OK， 我们进去看看，这里发生了什么？

这里也是面向接口编程，真实情况是，它调用了
com.opensymphony.xwork2.DefaultActionInvocation的init(ActionProxy)方法
Java代码
public void init(ActionProxy proxy) {  
        ……  
 
        createAction(contextMap);  
 
        ……  
    } 

public void init(ActionProxy proxy) {
        ……

        createAction(contextMap);

        ……
}
OK， 我们终于追踪到我们所需要了解的地方了， 到底Struts2/Xwork的Action是如何创建的呢？
Java代码
protected void createAction(Map<String, Object> contextMap) {  
        // load action  
        String timerKey = "actionCreate: " + proxy.getActionName();  
       ……  
action =  
objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);  
      …… 

protected void createAction(Map<String, Object> contextMap) {
        // load action
        String timerKey = "actionCreate: " + proxy.getActionName();
       ……
action =
objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
      …… 继续跟进去看看，你会发现， 事情确实如此：
Java代码
public Object buildAction(String actionName, String namespace, ActionConfig config, Map<String, Object> extraContext)   
throws Exception {  
        return buildBean(config.getClassName(), extraContext);  
    }  
                      
      
public Object buildBean(String className, Map<String, Object> extraContext, boolean injectInternal) throws Exception {  
        Class clazz = getClassInstance(className);//根据Action的名字，进行初始化  
        Object obj = buildBean(clazz, extraContext);  
//利用反射来做实例初始化.  
        if (injectInternal) {  
            injectInternalBeans(obj);  
        }  
        return obj;  
        }     
public Class getClassInstance(String className) throws ClassNotFoundException {  
        if (ccl != null) {  
            return ccl.loadClass(className);  
        }  
        return   
ClassLoaderUtil.loadClass(className, this.getClass());  
}     
public Object buildBean(Class clazz, Map<String, Object> extraContext) throws Exception {  
        return clazz.newInstance();  
   }     

public Object buildAction(String actionName, String namespace, ActionConfig config, Map<String, Object> extraContext)
throws Exception {
        return buildBean(config.getClassName(), extraContext);
    }
           

public Object buildBean(String className, Map<String, Object> extraContext, boolean injectInternal) throws Exception {
        Class clazz = getClassInstance(className);//根据Action的名字，进行初始化
        Object obj = buildBean(clazz, extraContext);
//利用反射来做实例初始化.
        if (injectInternal) {
            injectInternalBeans(obj);
        }
        return obj;
    }
public Class getClassInstance(String className) throws ClassNotFoundException {
        if (ccl != null) {
            return ccl.loadClass(className);
        }
        return
ClassLoaderUtil.loadClass(className, this.getClass());
}
public Object buildBean(Class clazz, Map<String, Object> extraContext) throws Exception {
        return clazz.newInstance();
   } OK, 整体来说，这个问题说清楚很难，因为你无法记住你追踪到的所有的类，但是有一点是肯定的，那就是流程： 基本上我的理解就是 通过一系列配置文件的初始化，将文件转换成对象，加载进内存中，再在处理请求时候(注意，只有当FilterDispatcher的doFilter第一次被调用时，才会去初始化Action类)，加载Action类来进行业务处理。


先整理这几个问题…… 累呀！希望这几天能把这些题目整理完， 整理过程中也顺带复习复习