现在的位置: 首页 > 综合 > 正文

淘宝电面总结

2013年02月07日 ⁄ 综合 ⁄ 共 18511字 ⁄ 字号 小 中 大 ⁄ 评论关闭

  今天中午接到阿里巴巴的电话面试，电面了将近一个小时左右。感觉自己发挥得并不好，好多基础的只是还是一知半解的， 虽然看过一些东西的源代码,但是，很多东西，也只是限看过而且，但是一到用的时候，或者被问到的时候， 却突然失忆……, 这里记录一下今天问到的问题。给自己长长记性。

 

 

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

 

  PS 凭着记忆来把他问的问题整理一下，并列出来，准备一一理解清楚

 

  最开始的几个问题我现在已经记不清楚了， 估计当时紧张了。

 

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

 

 你对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.     }  

 

 Hashtable：

 

Java代码  收藏代码
  1. 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. ………………………………  

 

 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.     }     

 

   其实后续的区别应该还有很多， 这里先列出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. }     

     

  2. 两者的父类不同，也就决定了两者的存储形式不同。 ArrayList继承于 AbstractList,而LinkedList继承于AbstractSequentialList. 两者都实现了List的骨干结构，只是前者的访问形式趋向于 “随机访问”数据存储（如数组），后者趋向于 “连续访问”数据存储（如链接列表）
    Java代码  收藏代码
    1. public class ArrayList<E> extends AbstractList<E>     
    2. ---------------------------------------------------------------------------------------  
    3. 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.     }     


 

  • 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>  
 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>  
 这里特别的是，实际上，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>  
 同样的，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>  

 如果你要查看这个类在哪里调用了，你会追踪到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>  
 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>  
 到初始化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>  
 再追踪到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>  
 这行代码已经明确的告诉你了， 它的作用就是创建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. });  

 返回的是你传入的对象，而在这里就是：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.     }  
 
       这里，我们主要关心的是： 
Java代码  收藏代码
  1. protected void prepare()  {  
  2.       ……  
  3.           invocation.init(this);  
  4. ……  
  5.     }  

 

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

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

 

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.       ……  

 继续跟进去看看，你会发现， 事情确实如此：

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.    }      
 OK, 整体来说，这个问题说清楚很难，因为你无法记住你追踪到的所有的类，但是有一点是肯定的，那就是流程： 基本上我的理解就是 通过一系列配置文件的初始化，将文件转换成对象，加载进内存中，再在处理请求时候(注意，只有当FilterDispatcher的doFilter第一 次被调用时，才会去初始化Action类)，加载Action类来进行业务处理。
 
 先整理这几个问题…… 累呀！希望这几天能把这些题目整理完， 整理过程中也顺

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞