JAVA面试题

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

 

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

 

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

 

 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代码 

1.int hash = (key == null) ? 0 : hash(key.hashCode());   

2.-----   

3.static int hash(int h) {   

4.        h ^= (h >>> 20) ^ (h >>> 12);   

5.        return h ^ (h >>> 7) ^ (h >>> 4);   

6.    }  

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代码 

1.int hash = key.hashCode();  

int hash = key.hashCode(); 

 

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

 

HashMap: 

 

Java代码 

1.static final int DEFAULT_INITIAL_CAPACITY = 16;   

2.static final float DEFAULT_LOAD_FACTOR = 0.75f;   

3.public HashMap() {   

4.     this.loadFactor = DEFAULT_LOAD_FACTOR;   

5.     threshold=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);   

6.     table = new Entry[DEFAULT_INITIAL_CAPACITY];   

7.     init();   

8.}      

9.………………………………  

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代码 

1.public Hashtable() {   

2.    this(11, 0.75f);   

3.}   

4.-----   

5. public Hashtable(int initialCapacity, float loadFactor) {   

6.        ..........   

7.    this.loadFactor = loadFactor;   

8.    table = new Entry[initialCapacity];   

9.    threshold = (int)(initialCapacity * loadFactor);   

10.    }     

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的区别： 

 

1. 毫无疑问，第一点就是两者的内部数据结构不同， ArrayList内部元素容器是一个Object的数组， 

而LinkedList内部实际上一个链表的数据结构，其有一个内部类来表示链表.

 

Java代码 

1.(ArrayList)   

2.private transient Object[] elementData;    

3.  

4.………………………………………………………………………………   

5.  

6.(LinkedList)   

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

8.  

9.//内部链表类.   

10.private static class Entry<E> {   

11.    E element; //数据元素   

12.    Entry<E> next; // 前驱   

13.    Entry<E> previous;//后驱   

14.    Entry(E element, Entry<E> next, Entry<E> previous) {   

15.        this.element = element;   

16.        this.next = next;   

17.        this.previous = previous;   

18.    }   

19.}     

(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;

}

}  

2.两者的父类不同，也就决定了两者的存储形式不同。 ArrayList继承于 AbstractList,而LinkedList继承于AbstractSequentialList. 两者都实现了List的骨干结构，只是前者的访问形式趋向于 “随机访问”数据存储（如数组），后者趋向于 “连续访问”数据存储（如链接列表）

 

 

Java代码 

1.public class ArrayList<E> extends AbstractList<E>      

2.---------------------------------------------------------------------------------------   

3.public class LinkedList<E> extends AbstractSequentialList<E>      

public class ArrayList<E> extends AbstractList<E>

---------------------------------------------------------------------------------------

public class LinkedList<E> extends AbstractSequentialList<E>  

3.再有就是两者的效率问题， ArrayList基于数组实现，所以毫无疑问可以直接用下标来索引，其索引数据快，插入元素设计到数组元素移动，或者数组扩充，所以插入元素要慢。LinkedList基于链表结构，插入元素只需要改变插入元素的前后项的指向即可，故插入数据要快，而索引元素需要向前向后遍历，所以索引元素要慢。

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

上一点谈到了ArrayList的特点，这里略，重点来看其内部容器的扩充：

Java代码 

1.public void ensureCapacity(int minCapacity) {   

2.        modCount++;   

3.        int oldCapacity = elementData.length;   

4.        if (minCapacity > oldCapacity) {   

5.            Object oldData[] = elementData;   

6.             //这里扩充的大小为原大小的大概 60%   

7.            int newCapacity = (oldCapacity * 3) / 2 + 1;   

8.            if (newCapacity < minCapacity)   

9.                newCapacity = minCapacity;   

10.            //创建一个指定大小的新数组来覆盖原数组   

11.            elementData = Arrays.copyOf(elementData, newCapacity);   

12.        }   

13.    }     

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代码 

1.<SPAN style="FONT-WEIGHT: normal">public synchronized void load(InputStream inStream) throws IOException {   

2.        // 将输入流转换成LineReader   

3.        load0(new LineReader(inStream));   

4.    }   

5.  

6.    private void load0(LineReader lr) throws IOException {   

7.        char[] convtBuf = new char[1024];   

8.        int limit;   

9.        int keyLen;   

10.        int valueStart;   

11.        char c;   

12.        boolean hasSep;   

13.        boolean precedingBackslash;   

14.        // 一行一行处理   

15.        while ((limit = lr.readLine()) >= 0) {   

16.            c = 0;   

17.            keyLen = 0;   

18.            valueStart = limit;   

19.            hasSep = false;   

20.            precedingBackslash = false;   

21.            // 下面用2个循环来处理key,value   

22.            while (keyLen < limit) {   

23.                c = lr.lineBuf[keyLen];   

24.                // need check if escaped.   

25.                if ((c == '=' || c == ':') && !precedingBackslash) {   

26.                    valueStart = keyLen + 1;   

27.                    hasSep = true;   

28.                    break;   

29.                } else if ((c == ' ' || c == '\t' || c == '\f')   

30.                        && !precedingBackslash) {   

31.                    valueStart = keyLen + 1;   

32.                    break;   

33.                }   

34.                if (c == '\\') {   

35.                    precedingBackslash = !precedingBackslash;   

36.                } else {   

37.                    precedingBackslash = false;   

38.                }   

39.                keyLen++;   

40.            }   

41.  

42.            while (valueStart < limit) {   

43.                c = lr.lineBuf[valueStart];   

44.                if (c != ' ' && c != '\t' && c != '\f') {   

45.                    if (!hasSep && (c == '=' || c == ':')) {   

46.                        hasSep = true;   

47.                    } else {   

48.                        break;   

49.                    }   

50.                }   

51.                valueStart++;   

52.            }   

53.  

54.            String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);   

55.            String value = loadConvert(lr.lineBuf, valueStart, limit   

56.                    - valueStart, convtBuf);   

57.            // 存入内部容器中，这里用的是Hashtable 内部的方法.   

58.            put(key, value);   

59.        }   

60.    }</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代码 

1.<SPAN style="FONT-WEIGHT: normal">class LineReader {   

2.        public LineReader(InputStream inStream) {   

3.            this.inStream = inStream;   

4.            inByteBuf = new byte[8192];   

5.        }   

6.  

7.        public LineReader(Reader reader) {   

8.            this.reader = reader;   

9.            inCharBuf = new char[8192];   

10.        }   

11.  

12.        byte[] inByteBuf;   

13.        char[] inCharBuf;   

14.        char[] lineBuf = new char[1024];   

15.        int inLimit = 0;   

16.        int inOff = 0;   

17.        InputStream inStream;   

18.        Reader reader;   

19.  

20.        /**  

21.         * 读取一行  

22.         *   

23.         * @return  

24.         * @throws IOException  

25.         */  

26.        int readLine() throws IOException {   

27.            int len = 0;   

28.            char c = 0;   

29.            boolean skipWhiteSpace = true;// 空白   

30.            boolean isCommentLine = false;// 注释   

31.            boolean isNewLine = true;// 是否新行.   

32.            boolean appendedLineBegin = false;// 加 至行开始   

33.            boolean precedingBackslash = false;// 反斜杠   

34.            boolean skipLF = false;   

35.            while (true) {   

36.                if (inOff >= inLimit) {   

37.                    // 从输入流中读取一定数量的字节并将其存储在缓冲区数组inCharBuf/inByteBuf中,这里区分字节流和字符流   

38.                    inLimit = (inStream == null) ? reader.read(inCharBuf)   

39.                            : inStream.read(inByteBuf);   

40.                    inOff = 0;   

41.                    // 读取到的为空.   

42.                    if (inLimit <= 0) {   

43.                        if (len == 0 || isCommentLine) {   

44.                            return -1;   

45.                        }   

46.                        return len;   

47.                    }   

48.                }   

49.                if (inStream != null) {   

50.                    // 由于是字节流，需要使用ISO8859-1来解码   

51.                    c = (char) (0xff & inByteBuf[inOff++]);   

52.                } else {   

53.                    c = inCharBuf[inOff++];   

54.                }   

55.  

56.                if (skipLF) {   

57.                    skipLF = false;   

58.                    if (c == '\n') {   

59.                        continue;   

60.                    }   

61.                }   

62.                if (skipWhiteSpace) {   

63.                    if (c == ' ' || c == '\t' || c == '\f') {   

64.                        continue;   

65.                    }   

66.                    if (!appendedLineBegin && (c == '\r' || c == '\n')) {   

67.                        continue;   

68.                    }   

69.                    skipWhiteSpace = false;   

70.                    appendedLineBegin = false;   

71.                }   

72.                if (isNewLine) {   

73.                    isNewLine = false;   

74.                    if (c == '#' || c == '!') {   

75.                        // 注释行，忽略.   

76.                        isCommentLine = true;   

77.                        continue;   

78.                    }   

79.                }   

80.                // 读取真正的属性内容   

81.                if (c != '\n' && c != '\r') {   

82.                    // 这里类似于ArrayList内部的容量扩充，使用字符数组来保存读取的内容.   

83.                    lineBuf[len++] = c;   

84.                    if (len == lineBuf.length) {   

85.                        int newLength = lineBuf.length * 2;   

86.                        if (newLength < 0) {   

87.                            newLength = Integer.MAX_VALUE;   

88.                        }   

89.                        char[] buf = new char[newLength];   

90.                        System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);   

91.                        lineBuf = buf;   

92.                    }   

93.                    if (c == '\\') {   

94.                        precedingBackslash = !precedingBackslash;   

95.                    } else {   

96.                        precedingBackslash = false;   

97.                    }   

98.                } else {   

99.                    // reached EOL 文件结束   

100.                    if (isCommentLine || len == 0) {   

101.                        isCommentLine = false;   

102.                        isNewLine = true;   

103.                        skipWhiteSpace = true;   

104.                        len = 0;   

105.                        continue;   

106.                    }   

107.                    if (inOff >= inLimit) {   

108.                        inLimit = (inStream == null) ? reader.read(inCharBuf)   

109.                                : inStream.read(inByteBuf);   

110.                        inOff = 0;   

111.                        if (inLimit <= 0) {   

112.                            return len;   

113.                        }   

114.                    }   

115.                    if (precedingBackslash) {   

116.                        len -= 1;   

117.                        skipWhiteSpace = true;   

118.                        appendedLineBegin = true;   

119.                        precedingBackslash = false;   

120.                        if (c == '\r') {   

121.                            skipLF = true;   

122.                        }   

123.                    } else {   

124.                        return len;   

125.                    }   

126.                }   

127.            }   

128.        }   

129.    }   </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代码 

1.<SPAN style="FONT-WEIGHT: normal"> public XmlConfigurationProvider() {   

2.        this("xwork.xml", true);   

3.}</SPAN>  

 public XmlConfigurationProvider() {

        this("xwork.xml", true);

} 同样的，Struts2的初始化也是这样的一个类，只不过它继承于Xwork原有的类，并针对Struts2做了一些特别的定制。

Java代码 

1.<SPAN style="FONT-WEIGHT: normal">public class StrutsXmlConfigurationProvider    

2.   extends XmlConfigurationProvider {   

3.    public StrutsXmlConfigurationProvider(boolean errorIfMissing)   

4.    {   

5.        this("struts.xml", errorIfMissing, null);   

6.    }   

7.……  </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代码 

1.<SPAN style="FONT-WEIGHT: normal">public void init(FilterConfig filterConfig)    

2.throws ServletException {   

3.        try {   

4.            this.filterConfig = filterConfig;   

5.            initLogging();   

6.            dispatcher = createDispatcher(filterConfig);   

7.            dispatcher.init();初始化Dispatcher.   

8.            dispatcher.getContainer().inject(this);   

9.            staticResourceLoader.setHostConfig(new FilterHostConfig(filterConfig));   

10.        } finally {   

11.            ActionContext.setContext(null);   

12.        }   

13.    }   </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代码 

1.<SPAN style="FONT-WEIGHT: normal">//这里是加载配置文件， 真正初始化Struts2的Action实例还没开始，   

2.public void init() {   

3.        if (configurationManager == null) {   

4.            configurationManager =    

5.new ConfigurationManager(BeanSelectionProvider.DEFAULT_BEAN_NAME);   

6.        }   

7.        init_DefaultProperties(); // [1]   

8.        init_TraditionalXmlConfigurations(); // [2]   

9.        init_LegacyStrutsProperties(); // [3]   

10.        init_CustomConfigurationProviders(); // [5]   

11.        init_FilterInitParameters() ; // [6]   

12.        init_AliasStandardObjects() ; // [7]   

13.        Container container = init_PreloadConfiguration();   

14.        container.inject(this);   

15.        init_CheckConfigurationReloading(container);   

16.        init_CheckWebLogicWorkaround(container);   

17.        if (!dispatcherListeners.isEmpty()) {   

18.            for (DispatcherListener l : dispatcherListeners) {   

19.                l.dispatcherInitialized(this);   

20.            }   

21.        }   

22.    }   </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代码 

1.<SPAN style="FONT-WEIGHT: normal">public void doFilter(ServletRequest req, ServletResponse res,   

2. FilterChain chain) throws IOException, ServletException {   

3.……            

4.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代码 

1.<SPAN style="FONT-WEIGHT: normal"> public void serviceAction(HttpServletRequest request,   

2. HttpServletResponse response, ServletContext context,   

3.  ActionMapping mapping) throws ServletException {   

4.      ……   

5.     ActionProxy proxy =config.getContainer().getInstance(   

6.                                                      ActionProxyFactory.class).   

7.                                                     createActionProxy(namespace,    

8.                                                                                          name,    

9.                                                                                        method,    

10.                                                                                   extraContext,   

11.                                                                                       true, false);   

12.  

13.    ……</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代码 

1.return callInContext(new ContextualCallable<T>() {   

2.  public T call(InternalContext context) {   

3.    return getInstance(type, context);   

4.  }   

5.});   

    return callInContext(new ContextualCallable<T>() {

      public T call(InternalContext context) {

        return getInstance(type, context);

      }

    });

  }

 返回的是你传入的对象，而在这里就是：ActionProxyFactory（也是接口，真正返回的是com.opensymphony.xwork2.DefaultActionProxyFactory）

 

 

 

而现在，到了真正开始处理加载Action实例的时候了：

Java代码 

1.public ActionProxy createActionProxy(ActionInvocation inv, String namespace, String actionName, String methodName,    

2.boolean executeResult, boolean cleanupContext) {   

3.        DefaultActionProxy proxy = new DefaultActionProxy(inv,   

4. namespace, actionName, methodName, executeResult, cleanupContext);   

5.        container.inject(proxy);   

6.        proxy.prepare();   

7.        return proxy;   

8.    }  

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代码 

1.protected void prepare()  {   

2.      ……   

3.          invocation.init(this);   

4.……   

5.    }  

protected void prepare()  {

      ……

          invocation.init(this);

……

} 

 OK， 我们进去看看，这里发生了什么？

 

这里也是面向接口编程，真实情况是，它调用了

com.opensymphony.xwork2.DefaultActionInvocation的init(ActionProxy)方法

Java代码 

1.public void init(ActionProxy proxy) {   

2.        ……   

3.  

4.        createAction(contextMap);   

5.  

6.        ……   

7.    }  

public void init(ActionProxy proxy) {

        ……

 

        createAction(contextMap);

 

        ……

} 

OK， 我们终于追踪到我们所需要了解的地方了， 到底Struts2/Xwork的Action是如何创建的呢？ 

Java代码 

1.protected void createAction(Map<String, Object> contextMap) {   

2.        // load action   

3.        String timerKey = "actionCreate: " + proxy.getActionName();   

4.       ……   

5.action =   

6. objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);   

7.      ……  

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代码 

1.public Object buildAction(String actionName, String namespace, ActionConfig config, Map<String, Object> extraContext)    

2.throws Exception {   

3.        return buildBean(config.getClassName(), extraContext);   

4.    }   

5.                       

6.       

7.public Object buildBean(String className, Map<String, Object> extraContext, boolean injectInternal) throws Exception {   

8.        Class clazz = getClassInstance(className);//根据Action的名字，进行初始化   

9.        Object obj = buildBean(clazz, extraContext);   

10.//利用反射来做实例初始化.   

11.        if (injectInternal) {   

12.            injectInternalBeans(obj);   

13.        }   

14.        return obj;   

15.        }      

16. public Class getClassInstance(String className) throws ClassNotFoundException {   

17.        if (ccl != null) {   

18.            return ccl.loadClass(className);   

19.        }   

20.        return    

21.ClassLoaderUtil.loadClass(className, this.getClass());   

22.}      

23.public Object buildBean(Class clazz, Map<String, Object> extraContext) throws Exception {   

24.        return clazz.newInstance();   

25.   }      

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类来进行业务处理。