Spring Servlet3 扩展模块笔记

Servlet 3.0

AsyncWebRequest.java

• 异步请求接口,继承NativeWebRequest

接口

       
 /**
         * Set the time required for concurrent handling to complete.
         * This property should not be set when concurrent handling is in progress,
         * i.e. when {@link #isAsyncStarted()} is {@code true}.
         * @param timeout amount of time in milliseconds; {@code null} means no
         *  timeout, i.e. rely on the default timeout of the container.
         */
        //设置超时时间
        void setTimeout(Long timeout);

        /**
         * Add a handler to invoke when concurrent handling has timed out.
         */
        //增加超时处理类
        void addTimeoutHandler(Runnable runnable);

        /**
         * Add a handle to invoke when request processing completes.
         */
        //增加请求处理完成处理类
        void addCompletionHandler(Runnable runnable);

        /**
         * Mark the start of asynchronous request processing so that when the main
         * processing thread exits, the response remains open for further processing
         * in another thread.
         * @throws IllegalStateException if async processing has completed or is not supported
         */
        //标示异步请求开始，返回异步Context
        void startAsync();

        /**
         * Whether the request is in async mode following a call to {@link #startAsync()}.
         * Returns "false" if asynchronous processing never started, has completed,
         * or the request was dispatched for further processing.
         */
        //判断是否是当前线程是否启动异步模式，false表示没有启动异步模式，或者已经完成，否则请求被分发到其他线程处理
        boolean isAsyncStarted();

        /**
         * Dispatch the request to the container in order to resume processing after
         * concurrent execution in an application thread.
         */
        //分发请求到容器，唤醒其他线程处理
        void dispatch();

        /**
         * Whether asynchronous processing has completed.
         */
        //判断异步处理是否完成
        boolean isAsyncComplete();

StandardServletAsyncWebRequest.java

• 继承ServletWebRequest,实现AsyncWebRequest, AsyncListener，一个标准异步web请求的实现类。

代码

     
/**
      * {@inheritDoc}
      * <p>In Servlet 3 async processing, the timeout period begins after the
      * container processing thread has exited.
      */
     public void setTimeout(Long timeout) {
         Assert.state(!isAsyncStarted(), "Cannot change the timeout with concurrent handling in progress");//断言状态没有启动异步
         this.timeout = timeout;
     }

     public boolean isAsyncStarted() {
         return ((this.asyncContext != null) && getRequest().isAsyncStarted());//异步状态不为空，请求是否启动异步处理模式,如果请求被AsyncContext.dispatch()到容器，或 AsynContext.complete ，则返回false.


     }

     /**
      * Whether async request processing has completed.
      * <p>It is important to avoid use of request and response objects after async
      * processing has completed. Servlet containers often re-use them.
      */
     public boolean isAsyncComplete() {
         return this.asyncCompleted.get();//请求的异步处理是否完成
     }

     public void startAsync() {
         Assert.state(getRequest().isAsyncSupported(),
                 "Async support must be enabled on a servlet and for all filters involved " +
                 "in async request processing. This is done in Java code using the Servlet API " +
                 "or by adding \"<async-supported>true</async-supported>\" to servlet and " +
                 "filter declarations in
                web.xml.");//判断请求是否支持异步处理
         Assert.state(!isAsyncComplete(), "Async processing has already completed");
         if (isAsyncStarted()) {//判断状态是否已经启动异步处理模式
             return;
         }
         this.asyncContext = getRequest().startAsync(getRequest(), getResponse());
         this.asyncContext.addListener(this);
         if (this.timeout != null) {
             this.asyncContext.setTimeout(this.timeout);
         }
     }

     public void dispatch() {
         Assert.notNull(this.asyncContext, "Cannot dispatch without an AsyncContext");
         this.asyncContext.dispatch();
     }

     // ---------------------------------------------------------------------
     // Implementation of AsyncListener methods
     // ---------------------------------------------------------------------

     public void onStartAsync(AsyncEvent event) throws IOException {
     }

     public void onError(AsyncEvent event) throws IOException {
     }

     public void onTimeout(AsyncEvent event) throws IOException {
         for (Runnable handler : this.timeoutHandlers) {
             handler.run();
         }
     }

     public void onComplete(AsyncEvent event) throws IOException {
         for (Runnable handler : this.completionHandlers) {
             handler.run();
         }
         this.asyncContext = null;
         this.asyncCompleted.set(true);//设置异步处理已经完成
     }

NoSupportAsyncWebRequest.java

• 不支持异步处理模式的web请求

DeferredResultProcessingInterceptor.java

• DeferredResult处理过程拦截器
• 在start async前，超时后/异步处理完成后/网络超时后触发拦截

DeferredResultProcessingInterceptorAdapter.java

• 抽象类实现DeferredResultProcessingInterceptor,做空实现

DeferredResultInterceptorChain.java

• 调用DeferredResultProcessingInterceptor的辅助类

DeferredResult.java

• 递延结果，在两个线程中传递的对象结果
• 实现Comparable接口以保证加入PriorityQueue队列的正确顺序

CallableProcessingInterceptor.java

• Callable拦截器

CallableProcessingInterceptorAdapter.java

• 抽象类实现CallableProcessingInterceptor接口，空实现

CallableInterceptorChain.java

• 调用CallableProcessingInterceptor的辅助类

TimeoutCallableProcessingInterceptor.java

• 继承CallableProcessingInterceptorAdapter
• 实现超时处理方法

TimeoutDeferredResultProcessingInterceptor.java

• 继承DeferredResultProcessingInterceptorAdapter
• 实现超时处理方法

WebAsyncTask.java

• web异步任务
• 包含一个Callable类，一个超时时间，一个任务执行着或名字

WebAsyncUtils.java

• 实现getAsyncManager
• 实现createAsyncWebRequest

WebAsyncManager.java

• 对Callables和DeferredResults启动的管理，包括拦截器的注入，Excutor的注入等
• 异步处理的入口类