compile group: 'cn.ymotel', name: 'dactor', version:'1.1.1'

   <actor id="randomTxt" parent="actorhttpcore" beginBeanId="randomTxtActor">
        <steps>
            <step fromBeanId="randomTxtActor" toBeanId="placeholderActor" conditon=""/>
            <step fromBeanId="placeholderActor" toBeanId="endActor" conditon=""/>
        </steps>
    </actor>

  public class BeginActor implements Actor {

    /* (non-Javadoc)
     * @see com.ymotel.util.actor.Actor#HandleMessage(com.ymotel.util.actor.Message)
     */
    @Override
    public Object HandleMessage(Message message) throws Exception {
        return message;

    }

}

    public Object HandleMessage(final Message message) throws Exception {
        Map context = message.getContext();

//		
        HttpUriRequest request = getHttpBuild(message.getContext()).build();

        if (referer != null) {
            request.addHeader("Referer", referer);
        }


        /**
         * 通过此处可共用会话，进行类似登录后交易
         */
        HttpClientContext tmplocalContext = null;
        if (context.containsKey(HTTPCLIENT_CONTEXT)) {
            tmplocalContext = (HttpClientContext) context.get(HTTPCLIENT_CONTEXT);
        } else {
            tmplocalContext = HttpClientContext.create();
            CookieStore cookieStore = new BasicCookieStore();
            tmplocalContext.setCookieStore(cookieStore);
            context.put(HTTPCLIENT_CONTEXT, tmplocalContext);
        }

        final HttpClientContext localContext = tmplocalContext;
//        CookieStore cookieStore = new BasicCookieStore();
//        localContext.setCookieStore(cookieStore);
        if (logger.isInfoEnabled()) {
            logger.info("HandleMessage(Message) - httpclient----" + request); //$NON-NLS-1$
        }
//		 final HttpGet httpget = new HttpGet(uri);

        final String tmpcontent = content;
        final String tmpcharset = charset != null ? charset : (String) context.get(CHARSET);


        httpClientHelper.getHttpclient().execute(request, localContext, new FutureCallback<HttpResponse>() {

            public void completed(final HttpResponse response) {
                try {
                    /**
                     * 完成后及时清除
                     */
                    message.getContext().remove(tmpcontent);

                    actorHttpClientResponse.handleResponse(response, localContext, tmpcharset, message);
//					String responseString=HandleResponse((String)message.getContext().get(CHARSET),response);
//					message.getContext().put(RESPONSE, responseString);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    if (logger.isErrorEnabled()) {
                        logger.error("$FutureCallback<HttpResponse>.completed(HttpResponse)", e); //$NON-NLS-1$
                    }
                    message.setException(e);
                    message.getControlMessage().getMessageDispatcher().sendMessage(message);
                }
//                  System.out.println(httpget.getRequestLine() + "->" + response.getStatusLine());
            }

            public void failed(final Exception ex) {
                if (logger.isErrorEnabled()) {
                    logger.error("$FutureCallback<HttpResponse>.failed(Exception)", ex); //$NON-NLS-1$
                }
                message.setException(ex);
                message.getControlMessage().getMessageDispatcher().sendMessage(message);

//                  System.out.println(httpget.getRequestLine() + "->" + ex);
            }

            public void cancelled() {
                Exception exception = new Exception("已取消");
                message.setException(exception);
                message.getControlMessage().getMessageDispatcher().sendMessage(message);

//                  System.out.println(httpget.getRequestLine() + " cancelled");
            }

        });
        return null;
    }

  <actor:global id="actorglobal">
         <actor:param name="beginBeanId" value="beginActor"/>
         <actor:param name="endBeanId" value="endActor"/>
   </actor:global>

    <actor:actor id="actorhttpcore"   parent="chainparent" chain="unLoginChain"  handleException="true"  endBeanId="FinishActor" >

        <actor:steps>
            <actor:step xpoint="" ypont="" fromBeanId="beginActor"  conditon="" toBeanId="placeholderActor"/>
             <actor:step xpoint="" ypont="" fromBeanId="beginActor"  conditon="" async="true"  toBeanId="placeholderActor"/>
           <actor:step xpoint="" ypont=""  fromBeanId="placeholderActor" conditon="context._SUFFIX=='json'"  toBeanId="JsonViewResolverActor"/>
            <actor:step xpoint="" ypont=""  fromBeanId="placeholderActor" conditon="exception==null" toBeanId="ViewResolveActor"/>
            <actor:step xpoint="" ypont=""   fromBeanId="placeholderActor" conditon="exception!=null"  toBeanId="ErrorViewResolveActor"/>
        </actor:steps>
             <results>
                    <result name="success">htmlstream:</result>
             </results>
    </actor:actor>

   <actor:chain id="isLoginChain">
          <list>
              <ref bean="actorhttpcore"></ref>
              <ref bean="isLoginActor1"></ref>
  
          </list>
      </actor:chain>

 <actor:actors xmlns="http://www.ymotel.cn/schema/dactor"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:aop="http://www.springframework.org/schema/aop"
               xmlns:actor="http://www.ymotel.cn/schema/dactor"
               xmlns:beans="http://www.springframework.org/schema/beans"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 	http://www.ymotel.cn/schema/dactor http://www.ymotel.cn/schema/dactor.xsd"  namespace="np">
     <!-- parent 和beginBeanId为全局name,randomTxt2在Spring中的全程是np.randomTxt2-->
     <actor id="randomTxt2" parent="actorhttpcore" beginBeanId="randomTxtActor">
     </actor>
 </actor:actors>

<actor id="randomTxt1" parent="randomTxt" beginBeanId="randomTxtActor">
    </actor>

通过getBean('randomTxt1')即可得到ActorTransactionCfg对象。  
blocked为是否阻塞，一般在交易初次放入队列是为false,表示如果队列满，则直接扔给客户端进行处理。为true则一般为内部交易,必须提交给队列进行处理。   sendMessage方法内部调用，用于将处理完毕的Message重新放入队列，继续下一步流程。  cn.ymotel.dactor.core.disruptor.MessageRingBufferDispatcher是MessageDispatcher的接口实现类。,在启动Spring是需要在配置中加上  ```

 MessageRingBufferDispatcher的strategy、bufferSize、threadNumber为三个可设置属性.正常情况下使用默认设置即可。  
 strategy默认使用ringBuffer的BlockingWaitStrategy策略进行调度，如果交易量比较大，可调整此策略。  
 bufferSize默认使用1024。   
 threadNumber默认使用CPU个数的线程数。   
 ## 其他默认Actor说明
 cn.ymotel.dactor.message.Message.Actor,所有需要在执行的交易都必须继承此接口。   
 public Object HandleMessage(Message message) throws Exception;程序通过调用HandleMessage对象,如果返回的不是message对象或者为NULL,则认为此交易是异步执行,不再自行调度。由异步交易在收到请求后，自己调用将Message再此放入队列中。  
 cn.ymotel.dactor.action.PlaceholderActor 交易为特殊交易，用来将当前队列暂存，并调用子交易。  
 cn.ymotel.dactor.action.BeginActor 为Actor中step的默认开始交易。  
 cn.ymotel.dactor.action.EndActor 为Actor中step的默认结束交易。
 cn.ymotel.dactor.action.JsonViewResolverActor为需要返回Json的J2EE view
  cn.ymotel.dactor.action.ViewResolveActor为需要返回J2EE view的统一处理Actor  
  cn.ymotel.dactor.action.httpclient.HttpClientActor 提供的异步调用httpClient的Actor  
cn.ymotel.dactor.action.netty.aysnsocket.TcpClientActor 提供的异步调用netty的Actor  
 ## 交易流程举例说明