阿里巴巴电面整理(二)

  还是接着昨天的帖子来吧， 题目都在上一篇《阿里巴巴电面整理》，

  昨天发的被管理员移到求职招聘区了，今天主动一点，自己移过来， 这次整理的东西比较少，但是也花了一点时间。

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

 首先，来看看如何让Spring 来管理Action.

1.在struts.xml中加入 <constant name="struts.objectFactory" value="spring"/> 
有两种整合方式：
     (1) 将Struts的业务逻辑控制器类配置在Spring的配置文件中，Action中引用的业务类一并注入。

                (这样的处理，必须将action类的scope配置成property)

<bean id="LoginAction" class="yaso.struts.action.LoginAction">
   <property name="loginDao" ref="LoginDao"/>
</bean> 

 接着，在struts.xml或者等效的Struts2配置文件中配置Action时，指定<action>的class属性为Spring配置文件中相应bean的id或者name值。示例如下： 
 

<action name=”LoginAction” class=”LoginAction”>
                     <result name=”success”>/index.jsp</result>
 </action> 

 

         (2) 业务类在Spring配置文件中配置，Action不需要配置，Struts2的Action像没有整合Spring之前一样配置，

           <action>的class属性指定业务逻辑控制器类的全限定名。  Action中引用的业务类不需要自己去初始化，

Struts2的Spring插件会使用bean的自动装配将业务类注入进来，其实Action也不是Struts2创建的，

而是Struts2的Spring插件创建的。默认情况下，插件使用by name的方式装配，

可以通过增加Struts2常量来修改匹配方式：设置方式

为：struts.objectFactory.spring.autoWire = typeName，

可选的装配参数如下：

name:相当于spring配置的autowrie="byName"(默认)
type:相当于spring配置的autowrie="byType"
auto:相当于spring 配置的autowrie="autodetect"
constructor: 相当于spring配置的autowrie="constructor"

           OK，这里说了配置部分，但是，这里有一个问题， 就是Spring管理Action，如果按照第一方式，那么只要通过  

           scope="property"来配置为每个请求创建一个Action实例。 那么第二种方式，我们并没有指定Action的作用域

          （好似也没有地方可配……），那么，这样的整合方式，Action的创建到底是单例还是多例的呢？
            答案也是每个请求一个实例，我这里通过一个很笨的办法，来证明它：

我会写一个Action的构造函数， 并在里面打上一句话，加入断点，如果说，每次请求都会进入断点，那么就意味着，每个请求都有一个新的实例是正确的。

第一次进入的时候，是在容器启动的时候：

 

第一次进入的时候，是在容器启动的时候：

 

 

我们请求Action:

 

再次进入断点，说明，每个请求都有一个Action实例来处理。 

 

对于这点的原因，我还是没有弄清楚，为什么按照第2种方式配置，不用指定scope，就会自动的为每个action创建一个实例？(希望懂的朋友，可以指点指点)

对于我们项目中的页面表单对象， 毫无疑问，它也是多例的.

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

简单罗列一下：
单例模式-- 典型应用： 类：
org.apache.struts2.config.ServletContextSingleton

 

模版方法模式：
  在org.apache.struts2.components包中大量运用

 

责任连模式：
 在拦截器部分使用.

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

           我们都知道线程安全是指什么，我的理解是， 当一个类的“状态”（实例变量）被多个线程所修改时，

            那么这个类的状态的“正确”性得不到保证，我们就可以理解成线程安全出现。

            当然，如果一个没有状态的类，那么它永远都是线程安全的。

 

            再深入一点来看， 我们从Java虚拟机的层面来看这个问题，答案就很明朗了：
              Java程序在运行时创建的所有类实例或数组，都存放在同一个堆中，而一个JVM实例中只存在一个堆空间，

因此，它被所有的线程共享着，这样的情况下，就可能出现，多个线程访问对象（堆数据）的同步问题了。

 

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

         这里所指的线程池是concurrent包中的ThreadPoolExecutor,而中断策略实际上是指饱和策略

           （concurent包中的RejectedExecutionHandler接口)，
             这里需要先解释一下，什么叫饱和策略， 实际就是说， 线程池中的线程容器已经放不下先的任务了，

             饱和了， 必须要有一个相应的策略来处理。
               ThreadPoolExecutor内部，已经定义了4种饱和策略：

          

 
 

默认的饱和策略是： （中止）， 既如果放不下了，既中止新加入的任务。

private static final RejectedExecutionHandler defaultHandler =new AbortPolicy(); 

 
源代码中调用如下

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
            else if (!addIfUnderMaximumPoolSize(command))
                    //容不下新的任务了，默认是中止掉
                reject(command); // is shutdown or saturated
        }
    } 

如果需要设置饱和策略，可以调用ThreadPoolExecutor的setRejectExecutionHandler方法，

JDK提供了4种不同策略的实现(4种实现都定义在ThreadPoolExecutor类中，有兴趣可以查看一下源代码)：

下面介绍一下4种实现的特点：
AbortPolicy: （中止）它是默认的策略。
CallerRunsPolicy: (调用者运行), 它既不会丢弃任务，也不会抛出任何异常，它会把任务推回到调用者那里去,以此缓解任务流
DiscardPolicy: （遗弃）策略，它默认会放弃这个任务
DiscardOldestPolicy:（遗弃最旧的），它选择的丢弃的任务，是它本来要执行的（可怜的娃，就这样被新加入的给排挤了）,

 

 

 

/**
     * 饱和策略之----调用者运行策略
     */
public static class CallerRunsPolicy implements 
	RejectedExecutionHandler {
 public CallerRunsPolicy() { }
 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
  }
}

    /**
     * 饱和策略之----中止（默认的）
     */
public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }

        /**
         * 直接抛异常，中止
         */
        public void rejectedExecution(Runnable r, 
                                        ThreadPoolExecutor e) {
            throw new RejectedExecutionException();
        }
    }

    /**
     * 饱和策略之----遗弃策略
     */
public static class DiscardPolicy implements ejectedExecutionHandler{
        
        public DiscardPolicy() { }

        /**
         * 不做任何处理，直接无视
         */
        public void rejectedExecution(Runnable r, 
                                      ThreadPoolExecutor e) {
        }
    }

    /**
     * 饱和策略之----遗弃最旧策略
     */
public static class DiscardOldestPolicy implements   
                                   RejectedExecutionHandler {
        public DiscardOldestPolicy() { }
        public void rejectedExecution(Runnable r,
                                       ThreadPoolExecutor e) {
        	//遗弃最旧的， 如果是用优先级队列存储池中的任务，
          //则会丢弃优先级最高的
            if (!e.isShutdown()) {
                e.getQueue().poll();//丢弃
                e.execute(r);//执行新任务
            }
        }
    }	

 

 

      到目前为止，题目差不多整理了2/3了， 基本上我在整理的同时有相当于复习了一遍。 很受用，当然，这些题目都是些基础知识， 帖子的本意并非是要炫耀什么，当然，我也没什么可炫耀的。 我的本意就是简单的知识共享，予人予己都有好处。 如果你觉得这贴对你没用，那就请直接无视吧……  

  

     帖子里面的题目都是先整理到word ，再发来je的，发发牢骚，JE的排版操作起来不容易呀，要是有直接从word里面导，该多好呀……， 这里我把Word发上来，要的朋友就拿去吧。

    

评论

30 楼 cnlw1985 2010-07-05  

<div class="quote_title"> </div>
<div class="quote_div">
<ul>
<li>
<h2> </h2>
</li>
</ul>
<p style="padding-left: 30px;">                (这样的处理，必须将action类的scope配置成property)</p>
<p style="padding-left: 90px;"> </p>
<p>           OK，这里说了配置部分，但是，这里有一个问题， 就是Spring管理Action，如果按照第一方式，那么只要通过   </p>
<p>           scope="property"来配置为每个请求创建一个Action实例。</p>
</div>
<p><br>lz这里写错了,scope="property",这个单词不是这样写的，是scope="prototype",小心误人子弟</p>

29 楼 wnick 2010-07-05  

<div class="quote_title">風一樣的男子 写道</div>
<div class="quote_div">
<div class="quote_title">Spring 里的 bean 默认都是单例的，这个 struts2 的 Action 能单例吗？</div>
</div>
<p><br>能啊,看是否有状态来决定啊</p>
<p>eg:</p>
<pre name="code" class="java">public class DoNothingAction extends ActionSupport{

private static final long serialVersionUID = -4211885847645132411L;

public String execute() throws Exception{
return SUCCESS;
}

}</pre>
<p> 配置:</p>
<pre name="code" class="java">&lt;action name="*Redirect" class="doNothingAction"&gt;
&lt;result&gt;/{1}.jsp&lt;/result&gt;
&lt;/action&gt;</pre>
<p> </p>

28 楼 風一樣的男子 2010-07-05  

<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">
<div class="quote_title">風一樣的男子 写道</div>
<div class="quote_div">
<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">
<p> </p>
<pre name="code" class="xml">&lt;bean id="LoginAction" class="yaso.struts.action.LoginAction"&gt;
   &lt;property name="loginDao" ref="LoginDao"/&gt;
&lt;/bean&gt;</pre>
<p> </p>
</div>
<p>LZ 不觉得这段配置有问题吗？</p>
</div>
<p> 没加scope？</p>
</div>
<p>Spring 里的 bean 默认都是单例的，这个 struts2 的 Action 能单例吗？</p>

27 楼 Rainbamboo 2010-07-05  

LZ面的哪个部门?还考Struts?

26 楼 joseph_he 2010-07-05  

多谢LZ。
祝LZ拿到OFFER

25 楼 gogole_09 2010-07-04  

<div class="quote_title">風一樣的男子 写道</div>
<div class="quote_div">
<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">
<p> </p>
<pre name="code" class="xml">&lt;bean id="LoginAction" class="yaso.struts.action.LoginAction"&gt;
   &lt;property name="loginDao" ref="LoginDao"/&gt;
&lt;/bean&gt;</pre>
<p> </p>
</div>
<p>LZ 不觉得这段配置有问题吗？</p>
</div>
<p> 没加scope？</p>

24 楼 風一樣的男子 2010-07-04  

<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">
<p> </p>
<pre name="code" class="xml">&lt;bean id="LoginAction" class="yaso.struts.action.LoginAction"&gt;
   &lt;property name="loginDao" ref="LoginDao"/&gt;
&lt;/bean&gt;</pre>
<p> </p>
</div>
<p>LZ 不觉得这段配置有问题吗？</p>

23 楼 phz50 2010-07-04  

lz真是个有心人

22 楼 gogole_09 2010-07-04  

<div class="quote_title">starfeng 写道</div>
<div class="quote_div">
<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">对于这点的原因，我还是没有弄清楚，为什么按照第2种方式配置，不用指定scope，就会自动的为每个action创建一个实例？(希望懂的朋友，可以指点指点)</div>
<p> </p>
<p>struts2与spring集成通过plugin "struts2-spring"实现, 这个插件提供了一个新的对象工厂: org.apache.struts2.spring.StrutsSpringObjectFactory, 并且, 它通过struts.objectFactory=spring来激活这个新的工厂.</p>
<p>当struts2要创建action时, 通过如下方式切入到spring:</p>
<p>buildAction--&gt;buildBean--&gt;</p>
<p>try {<br>    o = appContext.getBean(beanName);  // 注1: 有正确配置的情况下,在这里结束new instance<br>} catch (NoSuchBeanDefinitionException e) {  // 注2: 在spring找不到相关配置时,它又转入了默认的struts构建方式<br>    Class beanClazz = getClassInstance(beanName);<br>    o = buildBean(beanClazz, extraContext);<br>}</p>
<p>--&gt;</p>
<p>bean = autoWiringFactory.autowire(clazz, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);</p>
<p>所以, 你第二次方式做的, 每次都会建新的实例.</p>
<p> </p>
<p>但, 我要说明一点的是, 第二种方式是一种相对低效的方式, 即然用spring就全部用spring的方式去配你的action比较好.</p>
<p> </p>
<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">           我们都知道线程安全是指什么，我的理解是， 当一个类的“状态”（实例变量）被多个线程所修改时，<br><br>            那么这个类的状态的“正确”性得不到保证，我们就可以理解成线程安全出现。<br><br><br>            当然，如果一个没有状态的类，那么它永远都是线程安全的。<br><br><br><br>            再深入一点来看， 我们从Java虚拟机的层面来看这个问题，答案就很明朗了：<br>              Java 程序在运行时创建的所有类实例或数组，都存放在同一个堆中，而一个JVM实例中只存在一个堆空间，<br><br>因此，它被所有的线程共享着，这样的情况下，就可能出现，多个线程访问对象（堆数据）的同步问题了。</div>
<p> </p>
<p>虽然你这里看起来每句话都是对的, 但却又有点没解释到根本上.</p>
<p>类的状态...你发明了一个不太好的词, "当一个类的“状态”（实例变量）被多个线程所修改时",  漏洞有点多, 多个实例呢, 这个状态怎么算? 通常我们只会说实例的状态.</p>
<p>换个说法可能更好理解一点: <strong>同一实例</strong>的属性<strong>同时</strong>被<strong>多个</strong>线程<strong>修改</strong> (注意不是调用)</p>
<p> </p>
<p>所以,</p>
<p>实例没属性,自然也没法被"<strong>修改</strong>", 自然也是线程安全</p>
<p>每个实例只被一个线程修改(也即每个线程自已创建实例), 自然没法被"<strong>多个</strong>", 也是线程安全</p>
<p>加上同步关键字, 没法被"<strong>同时</strong>", 自然也是线程安全 </p>
<p>采用锁, 没法被"<strong>同时</strong>", 也是线程安全</p>
<p>...</p>
<p> </p>
<p>深入部份你这讲了一半, 还有另一半:</p>
<p>深入JVM去理解, 要抛开OO, 抛开public, private之类, 不然, 你会想当然的认为某些安全是理所当然的.</p>
<p>比方, 为什么方法内的东西就是线程安全? 如下:</p>
<p>public void method() {</p>
<p>    int i = 0;</p>
<p>    i = i + 1;</p>
<p>}</p>
<p>凭什么 i = i + 1就会一定由0变成1, 而不是由0变成2或3...</p>
<p>当然, 本身原因也简单, 只不过不要从public/private的角度去理解为: 外部访问不到所以安全. 要知道jvm这个层面是没有这个东西的.</p>
<p> </p>
<p>首先,JVM中只有一块堆也只有一块栈,所以"一块"不是全不安全的理由, 其原因在用法上面.</p>
<p> 在某一时刻,实例有属性状态,方法运行状态, 属性的放堆, 方法的放栈.</p>
<p>方法的运行在栈中, 多个方法的同时运行要依靠多个线程(这里不讨论进程), 而线程为保证方法相互不干扰, 会为每个方法开辟独立的栈区, 即压栈. 因而对于方法来说, 都在属于某一线程所在的栈中,因为方法间不会相互干扰, 因而没有线程问题.  虽然没有线程问题, 但是呢, 线程间也没法通过栈来沟通信息.</p>
<p>实例属性, 就有点不同了, 每个线程不会再copy一份新的, 多个线程会共用同一个, 所以, 线程问题就出来了. </p>
<p> </p>
<p>不想再深讲下去了, 感觉后面的话题一问接一问可以深太入太多. 有兴趣的看大学教材的线程部份,以及网上找文章JVM字节码相关部份.</p>
</div>
<p> </p>
<p> 非常感谢你非常详尽地解答了我的疑问，而且附上了源代码，很受用。</p>
<p>   另外，对于线程安全，我接受你指出的我解释中的问题，用词确实不太严谨。 </p>
<p> 并多谢你补充JVM部分的内容。 </p>

21 楼 acboboly 2010-07-04  

感谢楼主!

20 楼 puccaje 2010-07-04  

楼主，就凭你这个贴，就知道你能力不错

19 楼 starfeng 2010-07-03  

<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">对于这点的原因，我还是没有弄清楚，为什么按照第2种方式配置，不用指定scope，就会自动的为每个action创建一个实例？(希望懂的朋友，可以指点指点)</div>
<p> </p>
<p>struts2与spring集成通过plugin "struts2-spring"实现, 这个插件提供了一个新的对象工厂: org.apache.struts2.spring.StrutsSpringObjectFactory, 并且, 它通过struts.objectFactory=spring来激活这个新的工厂.</p>
<p>当struts2要创建action时, 通过如下方式切入到spring:</p>
<p>buildAction--&gt;buildBean--&gt;</p>
<p>try {<br>    o = appContext.getBean(beanName);  // 注1: 有正确配置的情况下,在这里结束new instance<br>} catch (NoSuchBeanDefinitionException e) {  // 注2: 在spring找不到相关配置时,它又转入了默认的struts构建方式<br>    Class beanClazz = getClassInstance(beanName);<br>    o = buildBean(beanClazz, extraContext);<br>}</p>
<p>--&gt;</p>
<p>bean = autoWiringFactory.autowire(clazz, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);</p>
<p>所以, 你第二次方式做的, 每次都会建新的实例.</p>
<p> </p>
<p>但, 我要说明一点的是, 第二种方式是一种相对低效的方式, 即然用spring就全部用spring的方式去配你的action比较好.</p>
<p> </p>
<div class="quote_title">gogole_09 写道</div>
<div class="quote_div">           我们都知道线程安全是指什么，我的理解是， 当一个类的“状态”（实例变量）被多个线程所修改时，<br><br>            那么这个类的状态的“正确”性得不到保证，我们就可以理解成线程安全出现。<br><br><br>            当然，如果一个没有状态的类，那么它永远都是线程安全的。<br><br><br><br>            再深入一点来看， 我们从Java虚拟机的层面来看这个问题，答案就很明朗了：<br>              Java 程序在运行时创建的所有类实例或数组，都存放在同一个堆中，而一个JVM实例中只存在一个堆空间，<br><br>因此，它被所有的线程共享着，这样的情况下，就可能出现，多个线程访问对象（堆数据）的同步问题了。</div>
<p> </p>
<p>虽然你这里看起来每句话都是对的, 但却又有点没解释到根本上.</p>
<p>类的状态...你发明了一个不太好的词, "当一个类的“状态”（实例变量）被多个线程所修改时",  漏洞有点多, 多个实例呢, 这个状态怎么算? 通常我们只会说实例的状态.</p>
<p>换个说法可能更好理解一点: <strong>同一实例</strong>的属性<strong>同时</strong>被<strong>多个</strong>线程<strong>修改</strong> (注意不是调用)</p>
<p> </p>
<p>所以,</p>
<p>实例没属性,自然也没法被"<strong>修改</strong>", 自然也是线程安全</p>
<p>每个实例只被一个线程修改(也即每个线程自已创建实例), 自然没法被"<strong>多个</strong>", 也是线程安全</p>
<p>加上同步关键字, 没法被"<strong>同时</strong>", 自然也是线程安全 </p>
<p>采用锁, 没法被"<strong>同时</strong>", 也是线程安全</p>
<p>...</p>
<p> </p>
<p>深入部份你这讲了一半, 还有另一半:</p>
<p>深入JVM去理解, 要抛开OO, 抛开public, private之类, 不然, 你会想当然的认为某些安全是理所当然的.</p>
<p>比方, 为什么方法内的东西就是线程安全? 如下:</p>
<p>public void method() {</p>
<p>    int i = 0;</p>
<p>    i = i + 1;</p>
<p>}</p>
<p>凭什么 i = i + 1就会一定由0变成1, 而不是由0变成2或3...</p>
<p>当然, 本身原因也简单, 只不过不要从public/private的角度去理解为: 外部访问不到所以安全. 要知道jvm这个层面是没有这个东西的.</p>
<p> </p>
<p>首先,JVM中只有一块堆也只有一块栈,所以"一块"不是全不安全的理由, 其原因在用法上面.</p>
<p> 在某一时刻,实例有属性状态,方法运行状态, 属性的放堆, 方法的放栈.</p>
<p>方法的运行在栈中, 多个方法的同时运行要依靠多个线程(这里不讨论进程), 而线程为保证方法相互不干扰, 会为每个方法开辟独立的栈区, 即压栈. 因而对于方法来说, 都在属于某一线程所在的栈中,因为方法间不会相互干扰, 因而没有线程问题.  虽然没有线程问题, 但是呢, 线程间也没法通过栈来沟通信息.</p>
<p>实例属性, 就有点不同了, 每个线程不会再copy一份新的, 多个线程会共用同一个, 所以, 线程问题就出来了. </p>
<p> </p>
<p>不想再深讲下去了, 感觉后面的话题一问接一问可以深太入太多. 有兴趣的看大学教材的线程部份,以及网上找文章JVM字节码相关部份.</p>

18 楼 gogole_09 2010-07-02  

phoenixfm 写道

网址的后缀竟然是 aspx.....

  采用伪.NET形式访问 ……

17 楼 hlzhou 2010-07-02  

向楼主学习！膜拜膜拜

16 楼 phoenixfm 2010-07-02  

网址的后缀竟然是 aspx.....

15 楼 hujiqiang 2010-07-02  

Struts2是多例模式，因为是多例也就没有线程安全的问题，每个请求一个线程，相互并没有影响。

14 楼 gogole_09 2010-07-02  

zhangsheng79 写道

创建和销毁这种类的实例，应该是性能的大忌

   OK， 你可能没有使用S2,所以这个问题讨论起来也只是单纯的从感觉出发。
   S2取代S1的单例本质上并不会带来多大的性能问题，否则也不会用多个实例了。
  S2的本质是为了避免S1中Action的线程安全问题。
  同时，多实例带来的好处也将S1的ActionForm给取消了。
 
  另外，我从S2的官方文档中确实也没找到关于多实例带来的性能问题， 关于创建与销毁的性能消耗，我未曾测试，所以这里也无法说你的是对还是错。
ps:
     S1与S2的区别的官方说法：
     http://struts.apache.org/2.1.8.1/docs/comparing-struts-1-and-2.html

13 楼 zhangsheng79 2010-07-02  

创建和销毁这种类的实例，应该是性能的大忌

12 楼 gogole_09 2010-07-02  

zhangsheng79 写道

另外说一嘴，你测试单列的不好，做个变量，访问设置值两次看看值就可以了

是的，打断点只是为了方便起见。

11 楼 gogole_09 2010-07-02  

zhangsheng79 写道

我是没有用过struts2，不过我个人觉得为了性能也不可能多例的

你这必然的根据是什么，  而且Struts2的action就是多例的。 你所说的性能问题是指哪些？ 愿闻其详细.