阿里巴巴校园招聘面试试题合集总结


1 forward redirect区

1址栏显示说
forward服务器请求资源服务器直接访问目标址URLURL响应容读取然容发浏览器浏览器根知道服务器发送容里址栏原址
redirect服务端根逻辑发送状态码告诉浏览器重新请求址址栏显示新URL
2数享说
forward转发页面转发页面享request里面数
redirect享数
3运方说
forward般户登陆时候根角色转发相应模块
redirect般户注销登陆时返回页面跳转网站等
4效率说
forward高
redirect低


2 servlet方法 doget dopost区
3 ArrayList里装Person类象样根Person类属性年龄排序
4 HashMap键值否意象



面试总结
首先介绍
1        面试官着简历会挑中项目然说出框架流程
2        画出框架流程图会问部分干什
3        针2问题做web项目框架中servlet应部分
4        前两问题牵引出webxml文件配置中属性作
5        spring解
6        spring赖注入方式种（注意spring注入方式赖注入）
7        关事物问题做项目中做事物关事物控制写
8        触发器存储程说点
9        项目开发中果遇问题知道该什技术解决解决该查
10    三年项目开发验觉优势方
11    会问公司什解机会问问题


1介绍做项目擅长技术
2框架擅长？
3知道MVC框架？
4常什样网站什样算规划
5喜欢技术（喜欢）举例子说明喜欢技术
6前项目中没加班频率加班时间长度加班法
7前项目中做什容SE级开发
8项目组样做项目没详细设计做？
9Struts什版
10Struts2？Struts1什区
11SpringAOP解项目方面
12前项目规模
                          
1     首先介绍
2     问熟悉项目
3     画出STRUTS框架响应jsp流程图
4     针2问题做web项目框架中servlet应部分
5     前两问题牵引出webxml文件配置中属性作
6     spring解
7     spring赖注入方式种（注意spring注入方式赖注入）
8     关事物问题做项目中做事物关事物控制写
9     Struts底层相关知识
10     项目开发中果遇问题知道该什技术解决解决该查
11     三年项目开发验觉优势方
12     会问公司什解机会问问题


1     首先介绍
2     框架中较喜欢
3     问做项目中收获收获什
4     ibatis Hibernate 区
5     servlet 生命周期
6     spring 两特性(AOP IOC)
7     说理解J2EE什
8     什说JBOSS 符合J2EE求TOMCAT 符合J2EE求
9     Hibernate 优点缺点
10     认项目中重什
11     分务感完成困难会办
12     支付宝什问

次杭州支付宝面试面试官开发框架方面技术问少部分根问项目延伸Sql UML等问题简历项目中果快钱项目准备快钱项目非常感兴趣问题：

1        首先面试官介绍然介绍
2        家公司？年出生？年毕业？工作年？问题回答简历样简历没作假回答定考虑
3        协力员工法？
4        生规划职业规划样？
5        项目加班什法？加班极限少？
6        熟悉新框架需长时间？（支付宝框架）
7        说出认影响深项目说出原
8        Oracle中分页Sql写？
9        简单懂计算机说明java态
10    说知道java设计模式
11    strutsspring中应写java设计模式？
12    说spring代理模式画spring代理模式类图
13    快钱项目中担模块根回答展开问题
14    宝钢物流项目入库模块开发中致类？接口？画UML图
问题问题根回答延伸
                                
1 简单介绍
2 根介绍提问
3 mvc开发模式模式
4 生规划
5 业余爱
6 做项目中做模块
7 做项目
总结根面试官喜欢面试官喜欢做事计划


 Java集合框架解？ 否说说常类？ 
 
 说说HashtableHashMap区： 源代码级区呢？
 
 时List？ （ArrayListLinkedList）ArrayListLinkedList区？
 
 ArrayList特点部容器扩充？
 
 Properties类特点？ 线程安全 
 

 时框架？ (提Struts2)
 
 请说Struts2初始化？类创建？(源代码角度出发)
 
 解反射什方式动态创建象？（提CGLIB…… 会接着问CGLIB揪心中……结果没问）
 
 请说Struts2 Action交Spring托？单例例？ 页面表单象例单例？
 
 请说业务层象单例例？
 
 请说Struts2源代码中设计模式？
 

 
 请说觉熟悉技术特点？ （提发编程）
 
 请说线程安全出现原？ 
 
 请说线程池中断策略(4)？ 什特点？
 
 请说Tomcat配置应端口配置？ 配置数源？ 实现动态部署？
 
 请说Java常优化？ 
 
 解新Servlet规范？ 简单说？（提推）
 
 请说推实现？
 
 线程安全StringBufferStringBuilder区？ 扩充部数组容量？ （源代码）
 
 请说Tomcat中设计模式？（提观察者模式）
 
 否说说Java反射相关优化机制？ （说太清楚…… 说没关系 ）
 
 请说Mysql常优化策略？
 
 前提推知识面较感兴趣说说时什书解什技术范畴
 （首先提SOA说解未趋势提云计算说定解未深究）
 
 
 职业方面问题？
 
 觉潜力？ 团队中位置？ 觉团队中差距？花少时间赶？
 
 阿里巴巴什疑问？ （囧问阿里巴巴牛时互动？意指培训话没说清楚……囧……）

PS面时候问题整理里面纯粹仅限浅见果错误希位指点二

· Java集合框架解？ 否说说常类？ 
Java集合框架类图：


 
常类：
HashMapHashtableHashSetArrayListVectorLinkedListCollectionsArrays

· 说说HashtableHashMap区(源代码级)

       1明显区Hashtable 步(方法synchronized)HashMap
       2HashMap继承AbstractMapHashtable继承Dictionary 前者Map骨干 部已实现Map需           做部分工作 子类需实现少量方法具Map项特性者部抽象方法需           实现类作实现该类已时
        3两者检测否含key时hash算法致HashMap部需keyhash码重新计算边检测                    Hashtable直接利key身hash码做验证
HashMap
 
Java代码
1 int hash  (key  null)  0  hash(keyhashCode())   
2   
3 static int hash(int h) {   
4         h ^ (h >>> 20) ^ (h >>> 12)   
5         return h ^ (h >>> 7) ^ (h >>> 4)   
6     }  
Java代码
1 int hash  (key  null)  0  hash(keyhashCode())   
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(keyhashCode())

static int hash(int h) {
h ^ (h >>> 20) ^ (h >>> 12)
return h ^ (h >>> 7) ^ (h >>> 4)
}
 
  Hashtable：
 
Java代码
1 int hash  keyhashCode()  
Java代码
1 int hash  keyhashCode()  
int hash keyhashCode()
 
  4两者初始化容量致HashMap部 16*075 Hashtable 11*075
HashMap
 
Java代码
1 static final int DEFAULT_INITIAL_CAPACITY  16   
2 static final float DEFAULT_LOAD_FACTOR  075f   
3 public HashMap() {   
4      thisloadFactor  DEFAULT_LOAD_FACTOR   
5      threshold(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR)   
6      table  new Entry[DEFAULT_INITIAL_CAPACITY]   
7      init()   
8 }      
9 ………………………………  
Java代码
1 static final int DEFAULT_INITIAL_CAPACITY  16   
2 static final float DEFAULT_LOAD_FACTOR  075f   
3 public HashMap() {   
4      thisloadFactor  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 075f
public HashMap() {
thisloadFactor 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 075f)   
3 }   
4   
5  public Hashtable(int initialCapacity float loadFactor) {   
6            
7     thisloadFactor  loadFactor   
8     table  new Entry[initialCapacity]   
9     threshold  (int)(initialCapacity * loadFactor)   
10     }     
Java代码
1 public Hashtable() {   
2     this(11 075f)   
3 }   
4   
5  public Hashtable(int initialCapacity float loadFactor) {   
6            
7     thisloadFactor  loadFactor   
8     table  new Entry[initialCapacity]   
9     threshold  (int)(initialCapacity * loadFactor)   
10     }     
public Hashtable() {
this(11 075f)
}

public Hashtable(int initialCapacity float loadFactor) {

thisloadFactor loadFactor
table new Entry[initialCapacity]
threshold (int)(initialCapacity * loadFactor)
}
 
   实续区应该 里先列出4点
 
· 时ArrayListLinkedList外List？
ArrayListLinkedList区？
 
事实List2 外Vector
ArrayListLinkedList区：
 
1 毫疑问第点两者部数结构 ArrayList部元素容器Object数组
LinkedList部实际链表数结构部类表示链表
Java代码
1 (ArrayList)   
2 private transient Object[] elementData    
3   
4 ………………………………………………………………………………   
5   
6 (LinkedList)   
7 private transient Entry header  new Entry(null null null)链表头    
8   
9 部链表类   
10 private static class Entry {   
11     E element 数元素   
12     Entry next  前驱   
13     Entry previous驱   
14     Entry(E element Entry next Entry previous) {   
15         thiselement  element   
16         thisnext  next   
17         thisprevious  previous   
18     }   
19 }     
Java代码
20 (ArrayList)   
21 private transient Object[] elementData    
22   
23 ………………………………………………………………………………   
24   
25 (LinkedList)   
26 private transient Entry header  new Entry(null null null)链表头    
27   
28 部链表类   
29 private static class Entry {   
30     E element 数元素   
31     Entry next  前驱   
32     Entry previous驱   
33     Entry(E element Entry next Entry previous) {   
34         thiselement  element   
35         thisnext  next   
36         thisprevious  previous   
37     }   
38 }     
(ArrayList)
private transient Object[] elementData

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

(LinkedList)
private transient Entry header new Entry(null null null)链表头

部链表类
private static class Entry {
E element 数元素
Entry next 前驱
Entry previous驱
Entry(E element Entry next Entry previous) {
thiselement element
thisnext next
thisprevious previous
}
}
 
2 两者父类决定两者存储形式 ArrayList继承 AbstractListLinkedList继承AbstractSequentialList 两者实现List骨干结构前者访问形式趋 机访问数存储（数组）者趋 连续访问数存储（链接列表）
Java代码
1 public class ArrayList extends AbstractList      
2   
3 public class LinkedList extends AbstractSequentialList      
Java代码
4 public class ArrayList extends AbstractList      
5   
6 public class LinkedList extends AbstractSequentialList      
public class ArrayList extends AbstractList

public class LinkedList extends AbstractSequentialList
 
3 两者效率问题 ArrayList基数组实现毫疑问直接标索引索引数快插入元素设计数组元素移动者数组扩充插入元素慢LinkedList基链表结构插入元素需改变插入元素前项指插入数快索引元素需前遍历索引元素慢
· ArrayList特点部容器扩充？
点谈ArrayList特点里略重点部容器扩充：
Java代码
1 public void ensureCapacity(int minCapacity) {   
2         modCount++   
3         int oldCapacity  elementDatalength   
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  ArrayscopyOf(elementData newCapacity)   
12         }   
13     }     
Java代码
1 public void ensureCapacity(int minCapacity) {   
2         modCount++   
3         int oldCapacity  elementDatalength   
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  ArrayscopyOf(elementData newCapacity)   
12         }   
13     }     
public void ensureCapacity(int minCapacity) {
modCount++
int oldCapacity elementDatalength
if (minCapacity > oldCapacity) {
Object oldData[] elementData
里扩充原概 60
int newCapacity (oldCapacity * 3) 2 + 1
if (newCapacity < minCapacity)
newCapacity minCapacity
创建指定新数组覆盖原数组
elementData ArrayscopyOf(elementData newCapacity)
}
}
 
· Properties类特点？ 线程安全 
Properties 继承Hashtable线程安全 特点 表示持久属性集保存流中者流中加载属性列表键应值字符串 中常方法load()方法流中加载属性：
Java代码
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  lrreadLine()) > 0) {   
            c  0   
            keyLen  0   
            valueStart  limit   
            hasSep  false   
            precedingBackslash  false   
             面2循环处理keyvalue   
            while (keyLen < limit) {   
                c  lrlineBuf[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  lrlineBuf[valueStart]   
                if (c  ＇ ＇ && c  ＇＼t＇ && c  ＇＼f＇) {   
                    if (hasSep && (c  ＇＇ || c  ＇＇)) {   
                        hasSep  true   
                    } else {   
                        break   
                    }   
                }   
                valueStart++   
            }   
  
            String key  loadConvert(lrlineBuf 0 keyLen convtBuf)   
            String value  loadConvert(lrlineBuf valueStart limit   
                     valueStart convtBuf)   
             存入部容器中里Hashtable 部方法   
            put(key value)   
        }   
    }  
Java代码
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  lrreadLine()) > 0) {   
            c  0   
            keyLen  0   
            valueStart  limit   
            hasSep  false   
            precedingBackslash  false   
             面2循环处理keyvalue   
            while (keyLen < limit) {   
                c  lrlineBuf[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  lrlineBuf[valueStart]   
                if (c  ＇ ＇ && c  ＇＼t＇ && c  ＇＼f＇) {   
                    if (hasSep && (c  ＇＇ || c  ＇＇)) {   
                        hasSep  true   
                    } else {   
                        break   
                    }   
                }   
                valueStart++   
            }   
  
            String key  loadConvert(lrlineBuf 0 keyLen convtBuf)   
            String value  loadConvert(lrlineBuf valueStart limit   
                     valueStart convtBuf)   
             存入部容器中里Hashtable 部方法   
            put(key value)   
        }   
    }  
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 lrreadLine()) > 0) {
c 0
keyLen 0
valueStart limit
hasSep false
precedingBackslash false
面2循环处理keyvalue
while (keyLen < limit) {
c lrlineBuf[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 lrlineBuf[valueStart]
if (c ＇ ＇ && c ＇＼t＇ && c ＇＼f＇) {
if (hasSep && (c ＇＇ || c ＇＇)) {
hasSep true
} else {
break
}
}
valueStart++
}

String key loadConvert(lrlineBuf 0 keyLen convtBuf)
String value loadConvert(lrlineBuf valueStart limit
valueStart convtBuf)
存入部容器中里Hashtable 部方法
put(key value)
}
}
 LineReader类Properties部类：
Java代码
class LineReader {   
        public LineReader(InputStream inStream) {   
            thisinStream  inStream   
            inByteBuf  new byte[8192]   
        }   
  
        public LineReader(Reader reader) {   
            thisreader  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) {   
                     输入流中读取定数量字节存储缓区数组inCharBufinByteBuf中里区分字节流字符流   
                    inLimit  (inStream  null)  readerread(inCharBuf)   
                             inStreamread(inByteBuf)   
                    inOff  0   
                     读取空   
                    if (inLimit < 0) {   
                        if (len  0 || isCommentLine) {   
                            return 1   
                        }   
                        return len   
                    }   
                }   
                if (inStream  null) {   
                     字节流需ISO88591解码   
                    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  lineBuflength) {   
                        int newLength  lineBuflength * 2   
                        if (newLength < 0) {   
                            newLength  IntegerMAX_VALUE   
                        }   
                        char[] buf  new char[newLength]   
                        Systemarraycopy(lineBuf 0 buf 0 lineBuflength)   
                        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)  readerread(inCharBuf)   
                                 inStreamread(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   
                    }   
                }   
            }   
        }   
    }     
Java代码
class LineReader {   
        public LineReader(InputStream inStream) {   
            thisinStream  inStream   
            inByteBuf  new byte[8192]   
        }   
  
        public LineReader(Reader reader) {   
            thisreader  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) {   
                     输入流中读取定数量字节存储缓区数组inCharBufinByteBuf中里区分字节流字符流   
                    inLimit  (inStream  null)  readerread(inCharBuf)   
                             inStreamread(inByteBuf)   
                    inOff  0   
                     读取空   
                    if (inLimit < 0) {   
                        if (len  0 || isCommentLine) {   
                            return 1   
                        }   
                        return len   
                    }   
                }   
                if (inStream  null) {   
                     字节流需ISO88591解码   
                    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  lineBuflength) {   
                        int newLength  lineBuflength * 2   
                        if (newLength < 0) {   
                            newLength  IntegerMAX_VALUE   
                        }   
                        char[] buf  new char[newLength]   
                        Systemarraycopy(lineBuf 0 buf 0 lineBuflength)   
                        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)  readerread(inCharBuf)   
                                 inStreamread(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   
                    }   
                }   
            }   
        }   
    }     
class LineReader {
public LineReader(InputStream inStream) {
thisinStream inStream
inByteBuf new byte[8192]
}

public LineReader(Reader reader) {
thisreader 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) {
输入流中读取定数量字节存储缓区数组inCharBufinByteBuf中里区分字节流字符流
inLimit (inStream null) readerread(inCharBuf)
inStreamread(inByteBuf)
inOff 0
读取空
if (inLimit < 0) {
if (len 0 || isCommentLine) {
return 1
}
return len
}
}
if (inStream null) {
字节流需ISO88591解码
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 lineBuflength) {
int newLength lineBuflength * 2
if (newLength < 0) {
newLength IntegerMAX_VALUE
}
char[] buf new char[newLength]
Systemarraycopy(lineBuf 0 buf 0 lineBuflength)
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) readerread(inCharBuf)
inStreamread(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代码
 public XmlConfigurationProvider() {   
        this(xworkxml true)   
}  
Java代码
 public XmlConfigurationProvider() {   
        this(xworkxml true)   
}  
public XmlConfigurationProvider() {
this(xworkxml true)
}
 样Struts2初始化样类继承Xwork原类针Struts2做特定制
Java代码
1 public class StrutsXmlConfigurationProvider    
2    extends XmlConfigurationProvider {   
3     public StrutsXmlConfigurationProvi








1 JDK5支持泛型泛型实现应反射API操作泛型变量时泛型起作
2 ClassforName(oracleddddriver)newInstance()？new出实例什作？什newInstance（）

文档香网(httpswwwxiangdangnet)户传

《香当网》用户分享的内容，不代表《香当网》观点或立场，请自行判断内容的真实性和可靠性！
该内容是文档的文本内容，更好的格式请下载文档