JAVA—咖啡馆
JAVA—咖啡馆

阿里巴巴电面整理

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

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

 

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

   
   
   
   

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

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

你可能感兴趣的:(阿里巴巴电面整理)

  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 那个抄袭的大张伟 猫小努
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
  • 三大师传 beca酱
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
  • 感赏日志133 马姐读书
    图片发自App感赏自己今天买个扫地机，以后可以解放出来多看点书，让这个智能小机器人替我工作了。感赏孩子最近进步很大，每天按时上学，认真听课，认真背书，主动认真完成老师布置的作业。感赏自己明白自己容易受到某人的影响，心情不好，每当此刻我就会舒缓，感赏，让自己尽快抽离，想好的一面。感赏儿子今天在我提醒他事情时，告诉我谢谢妈妈对我的提醒我明白了，而不是说我啰嗦，管事情，孩子更懂事了，懂得感恩了。投射父母
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 勇士赢了，我把掌声给了骑士 复角度的生活
    今天，不参加高考，只看NBA总决赛第三场的较量。这么说有点得罪高考生了，不过我没有当他们面秀，也没有跑到考点外面得瑟，所以我内心毫无波澜。毫无疑问，考场里不乏骑士和勇士球迷，在紧张作答语文考卷同时还心系着球队，不过我希望今天的比赛不会让你们有所分心，毕竟高考不会像比赛录像那样可以再来。今天，好像起来赶考一样，我起得很早，然而事实是睡不着，挺郁闷的，又不是我高考，我紧张什么？九点我并没有准时打开浏览
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • mac电脑命令行获取电量 小米人er 我的博客macos命令行
    在macOS上，有几个命令行工具可以用来获取电量信息，最常用的是pmset命令。你可以通过以下方式来查看电池状态和电量信息：查看电池状态：pmset-gbatt这个命令会返回类似下面的输出：Nowdrawingfrom'BatteryPower'-InternalBattery-0(id=1234567)95%;discharging;4:02remainingpresent:true输出中包括电
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • 第二期心理咨询师培训 第1组分享第八天 张云511
    学会与问题共存—事情不会只有一个面读完本节，印象最深的点就是“扩大白色而非消灭黑色”。其实在班级管理中也是一样，我们暂时不要着急去消灭问题，而是注意学生哪些方面很不错，值得我们去扩大，我们要发现学生的资源与潜力，从正向的意义出发，发挥滴水穿石的力量，让一个个小改变汇集出巨大的改变！调整看事情的角度，不把生活问题扩大，是我们学习“与问题共存”的重要一步。换个角度看问题，会改变自己，也会感动别人！这样
  • 2022-08-28 蔚蓝一片晴
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
  • 九月班级管理工作反思 追梦蜂
    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
  • 2021-09-13一切向好发展 昀妡
    今天，一位学员在群里发了一条求助信息。问题是：一个学生小男孩3年级了，学习态度不端正不认真，也不和老师家长沟通，怎么办？我正好看到了这条消息，便加了她的微信。我问她是否方便电话沟通。在征求学员的同意后，我和她电话沟通了10分钟，给了她一些建议。通过这件事，我看到了自己积极主动的一面。之前，我总说自己消极被动，但其实，问题的根源在于目标不清晰。如果知道方向，还是会突破心理障碍往前走。比如，陌生感召。
  • 2020-8-19晨间日记：看过的电影 盐大虾
    今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
  • 好习惯和坏习惯 炫舞阳光
    好习惯和坏习惯文/炫舞阳光生活中有很多细节，可以体现出一个人的习惯。好的习惯让人保持清晰的头脑，坏的习惯常常让人丢东忘西，头脑混沌。生活中，我喜欢整理东西。厨房里，锅碗瓢盆各样东西我习惯各就其位。案板、勺子、铲子和刀具我习惯性的挂起来。大大小小的碗和盘子，我习惯性的立在收纳柜里。每次轮到我在家做饭时，我习惯于一边使用，一边收拾和擦拭归位。做好饭时，台面干干净净。我想把这种习惯影响和传递给家人。然而
  • (121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发FPGAIC
    1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
  • “晚节不保”与“浪子回头” 锦瑟_db50
    今天听音频，听到这两个熟悉的词——晚节不保、浪子回头。认真思量，对这两种情况，我们一般的认知中是缺乏公允的。我们听到“晚节不保”时，通常是痛惜不已，甚至感觉对方重要露出狐狸尾巴，有大快人心之感。很多人对古今名人，特别是对古今伟人的“背后的故事”很感兴趣，一方面是猎奇，一方面不能不说是一种险恶的用心——看看他也不过如此，和我们也没什么不同。这个“毁神”的过程，实际上是为自己的堕落找理由的方式。而“晚
  • 2022-02-15 百味人生摆渡人
    习惯她和他在谈恋时，就吵架，有时吵的还很厉害，不像其他恋人，恋爱期间有说不完的情话，享受不尽的温情，珍惜在一块的每一分每一秒。分手也分了无数次，不知怎的，就是没有分开。不见面时，特想见面，见了面时，说不了几句，又就开始吵，吵的次数多了，连他们自己也说不清值不值得吵，为什么吵。她妈妈说，这孩子从小就性格倔强。他爸爸说，这孩子从小就性格固执。想想其实也没什么大事。为吃什么吵为穿什么吵为说什么吵……日子
  • python批量读取tiff文件_Python Pillow批量转换tif格式到jpg weixin_39557797
    最近因为想要整下网站的壁纸，从网站下载了别人整理好的合集压缩包，解压之后，却发现里面的文件都是tif的，tif格式网站和电脑都不认的，根本不能作壁纸。这时候，就需要转换图片格式了，首先我找了几款转换格式的软件，发现效果都不好，要不是不支持tif格式，要不就是转换出来的图片糊的不行。最终，还是决定用Python的Pillow库来写一个脚本，完成这个任务。下面是整个的小脚本----importosim
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • 圣诞节后的人气又回来了？好丽友、特斯拉们的生意却不好做| 每周热点汇总 饭Sir看天下
    新的一年来了大家好，今天是2022年12月26日，星期一，农历十二月初四。这个月，相信我们很多人都遇到了身体不适的情况，饭Sir上周也因为发烧不得不停更了一周，这几天才刚刚恢复，好在这一切最后都能过去。疫情之外，一些好消息也逐渐到来，例如北京等多座大城市在年底的圣诞节期间又恢复了生机，一些迹象也在预示着久违的热闹春节要回来了。但另一方面，明年不确定的经济形势又带来一些不利的消息，不禁让人有些担心。
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 记录幸福（三月） 杨芸
    3月6日中午，匆匆忙忙与老爸和三妹在高铁站候车厅见了一面，两个南瓜包传递了亲人间的爱，那一刻好幸福好满足。他们进站后，我带着离别的忧伤，走到出口，突然想起朵儿喜欢吃的奥尔良鸡腿煲，便折回去，买了她和我，还有朵爸各自喜爱的。以前和亲人每次分开，都要难过许久，那天我竟然突然明白了一个道理，正因为爱家人，所以要让自己过的更开心更舒适，才能长寿，有更多的时间去爱他们。而不是忧心忡忡的过日子哦。最爱的家人回
  • 更改npm镜像源为淘宝镜像 骆小骆 基于node.js
    npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • 补充元象二面 Redstone Monstrosity 前端面试
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
  • Spring4.1新特性——Spring MVC增强 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • mysql 性能查询优化 annan211 javasql优化mysql应用服务器
    1 时间到底花在哪了？ mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了 检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方 花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
  • windows系统配置 cherishLC windows
    删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 类似的还有pagefile.sys msconfig 配置启动项 shutdown 定时关机 ipconfig 查看网络配置 ipconfig /flushdns
  • 人体的排毒时间 Array_06 工作
    ======================== ||  人体的排毒时间是什么时候？|| ======================== 转载于： http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
  • ZooKeeper cugfy zookeeper
    Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
  • 网络爬虫的乱码处理 随意而生 爬虫网络
    下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
  • Xcode常用快捷键 张亚雄 xcode
    一、总结的常用命令：     隐藏xcode command+h     退出xcode command+q     关闭窗口 command+w     关闭所有窗口 command+option+w     关闭当前
  • mongoDB索引操作 adminjun mongodb索引
    一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
  • 成都软件园实习那些话 aijuans 成都 软件园 实习
    无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
  • Linux下FTP服务器安装及配置 ayaoxinchao linuxFTP服务器vsftp
    检测是否安装了FTP [root@localhost ~]# rpm -q vsftpd 如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息   安装FTP 运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
  • 使用mongo-java-driver获取文档id和查找文档 BigBird2012 driver
    注：本文所有代码都使用的mongo-java-driver实现。   在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
  • JSONObject以及json串 bijian1013 jsonJSONObject
    一.JAR包简介     要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包：     1.commons-lang-2.0.jar     2.commons-beanutils-1.7.0.jar     3.commons-collections-3.1.jar &n
  • [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性 bit1129 zookeeper
    为了说明问题，看个简单的代码，   import org.apache.zookeeper.*; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocal
  • 【Scala十二】Scala核心六：Trait bit1129 scala
    Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
  • weblogic version 10.3破解 ronin47 weblogic
    版本：WebLogic Server 10.3 说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
  • 求第n个斐波那契数 BrokenDreams
            今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。         自己试了下，搞了好久。。。基础要加强了。           &nbs
  • 读《研磨设计模式》-代码笔记-访问者模式-Visitor bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; interface IVisitor { //第二次分派，Visitor调用Element void visitConcret
  • MatConvNet的excise 3改为网络配置文件形式 cherishLC matlab
    MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 主页： http://www.vlfeat.org/matconvnet/ 教程： http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet： http
  • ZK Timeout再讨论 chenchao051 zookeepertimeouthbase
    http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
  • CASE WHEN 用法介绍 daizj sqlgroup bycase when
    CASE WHEN 用法介绍 1. CASE WHEN 表达式有两种形式 --简单Case函数  CASE sex  WHEN '1' THEN '男'  WHEN '2' THEN '女'  ELSE '其他' END  --Case搜索函数  CASE WHEN sex = '1' THEN
  • PHP技巧汇总:提高PHP性能的53个技巧 dcj3sjt126com PHP
    PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
  • Yii框架中CGridView的使用方法以及详细示例 dcj3sjt126com yii
    CGridView显示一个数据项的列表中的一个表。 表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 实例代码如下：
  • Maven项目打包成可执行Jar文件 dyy_gusi assembly
    Maven项目打包成可执行Jar文件 在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 1、在项目中加入插件的依赖： <plugin>
  • php常见错误 geeksun PHP
    1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
  • 修改linux的用户名 hongtoushizi linuxchange password
    Change Linux Username 更改Linux用户名，需要修改4个系统的文件： /etc/passwd /etc/shadow /etc/group /etc/gshadow 古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： vipw vipw -s vigr vigr -s   具体的操作顺
  • 第五章 常用Lua开发库1-redis、mysql、http客户端 jinnianshilongnian nginxlua
    对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。   Redis客户端 lua-resty-r
  • zkClient 监控机制实现 liyonghui160com zkClient 监控机制实现
             直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
  • 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句 pda158 mysql
    在Mysql 众多表中查找一个表名或者字段名的 SQL 语句： 　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name'; 　　方法二：SELECT column_name from information_schema.colum
  • 程序员对英语的依赖 Smile.zeng 英语程序猿
    1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 以上一些问题，充分说明了英语对程序猿的重要性。骚年
  • Oracle学习笔记(8) 使用PLSQL编写触发器 vipbooks oraclesql编程活动Access
        时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！     这是第八章的学习笔记，学习完第七章的子程序和包之后
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他