servlet3.0 Asynchronous principle of

servlet I won't introduce the basics , Here is the introduction servlet3.0 An important new feature of ： asynchronous .
servlet3.0 Schematic diagram ：

1. tomcat After receiving the request from the client, the request will be AsyncContext To the business thread , such tomcat The worker thread can release the connection to handle other requests .
2. The business thread pool received AsyncContext after , You can handle the request business , After completing the business logic , according to AsyncContext obtain response, Return the response result .
3. AsyncListener Will listen AsyncContext act , We can make corresponding business processing according to specific behavior .

servlet3.0 take tomcat Separate worker threads from business threads , such tomcat Worker threads can handle more connection requests . Business threads mainly deal with business logic . In this mode , The number of business threads can be better allocated , Also according to different business , Set a different number of threads , More flexible .

Be careful ：tomcat Of NIO and servlet3.0 Asynchrony doesn't matter .tomcat NIO Pattern , Is for http Connection processing uses , The goal is to handle more connections with fewer threads .servlet3.0 Is in tomcat The processing logic of the working thread realizes the asynchronous processing function .

Use servlet3.0 Implement long polling

• What is long polling ：
  Long polling means that the client will always send requests to the server , It is applicable to the use of pushing data from the server to the client . Long polling should meet the following points ：

1. After the client initiates the request , When there is no data on the service side , Will not immediately return a null value , It is hold Live connection , Wait for data generation and return immediately .
2. The request has a timeout on the server , Not all the time hold live . When the timeout after , The server will return timeout information , After receiving the return, the client will initiate the request again .
3. After each request , The client will initiate the request again .

• Short polling 、 Long polling and long connection comparison ：

1. Short polling ： The client sends to the server regularly Ajax request , After receiving the request, the server immediately returns the response information and closes the connection .
   advantage ： Back end programming is easier , Suitable for small applications ..
   shortcoming ： Most of the requests are useless , Waste bandwidth and server resources .
   example ：
2. Long polling ： The client sends to the server Ajax request , The server receives the request hold Live connection , The response information is not returned and the connection is closed until there is a new message , After the client processes the response information, it sends a new request to the server .
   advantage ： Not frequent requests without messages .
   shortcoming ： The server hold Connections consume resources .
3. A long connection ： The client and the server establish a long connection socket
   advantage ： High reliability , Real time high .
   shortcoming ： The implementation is complex , To maintain the heartbeat , The server maintains the connection and consumes resources .

Long polling implementation

Schematic diagram ：

1. After the request came in, , Generate an event , Add the corresponding event set . The request is set 30s Timeout time , And add monitor .tomcat Worker thread release .
2. When the server data is ready , Trigger the corresponding event , Get subscription events from the container for execution . return when done response.
3. request timeout ,listener Trigger , Return timeout information .

Let's see the specific implementation ：

• Event definition , Here is just a simple event ：

package com.hiwe.demo.event;

import javax.servlet.AsyncContext;

public class HttpEvent {
    
    /** *  It can be a business data primary key , Use the request name here as a simple demo */
    private String requestName;
    private AsyncContext asyncContext;

    public HttpEvent(String requestName,AsyncContext asyncContext){
    
        this.requestName = requestName;
        this.asyncContext = asyncContext;
    }

    public String getRequestName() {
    
        return requestName;
    }

    public AsyncContext getAsyncContext() {
    
        return asyncContext;
    }
}

Event manager ：

package com.hiwe.demo.event;

import javax.servlet.AsyncContext;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

public class EventManager {
    
    private final static Map<String,HttpEvent> subHttpEvents = new HashMap<>();

    /** *  New event subscription  * @param event */
    public static void addHttpEvent(HttpEvent event){
    
        subHttpEvents.put(event.getRequestName(),event);
    }

    /** *  Triggering event  * @param requestName */
    public static void onEvent(String requestName){
    
        HttpEvent httpEvent = subHttpEvents.get(requestName);
        if(httpEvent==null){
    
            return;
        }
        AsyncContext asyncContext = httpEvent.getAsyncContext();
        try {
    
            PrintWriter writer = asyncContext.getResponse().getWriter();
            writer.print(requestName+" request success!");
            writer.flush();
            asyncContext.complete();
            subHttpEvents.remove(requestName);
        } catch (IOException e) {
    
            e.printStackTrace();
        }
    }
}

• Asynchronous request listener ：

package com.hiwe.demo.listener;

import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebListener;
import java.io.IOException;
import java.io.PrintWriter;

@WebListener
public class AppAsyncListener implements AsyncListener {
    
    @Override
    public void onComplete(AsyncEvent asyncEvent) throws IOException {
    
        System.out.println("AppAsyncListener onComplete");
        // we can do resource cleanup activity here
    }

    @Override
    public void onError(AsyncEvent asyncEvent) throws IOException {
    
        System.out.println("AppAsyncListener onError");
        //we can return error response to client
    }

    @Override
    public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
    
        System.out.println("AppAsyncListener onStartAsync");
        //we can log the event here
    }

    /** *  Timeout trigger  * @param asyncEvent * @throws IOException */
    @Override
    public void onTimeout(AsyncEvent asyncEvent) throws IOException {
    
        AsyncContext asyncContext = asyncEvent.getAsyncContext();
        ServletResponse response = asyncEvent.getAsyncContext().getResponse();
        PrintWriter out = response.getWriter();
        // return code code , So that the front end can identify , And rebuild the request 
        out.write(201+" longPolling timeout");
        out.flush();
        asyncContext.complete();
    }
}

• Long polling interface ：

package com.hiwe.demo.controller;

import com.hiwe.demo.listener.AppAsyncListener;
import com.hiwe.demo.event.EventManager;
import com.hiwe.demo.event.HttpEvent;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.AsyncContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@RestController
@RequestMapping("/app")
public class AsyncController {
    
    /** *  Long polling interface  * @param requestName * @param request * @param response */
    @GetMapping("/asyncGet")
    public void getDemo(@RequestParam(value = "requestName") String requestName, HttpServletRequest request, HttpServletResponse response){
    
        // Turn on Asynchronous Support 
        request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);
        AsyncContext asyncContext = request.startAsync();
        // Add listener 
        asyncContext.addListener(new AppAsyncListener());
        // Set timeout 
        asyncContext.setTimeout(30000);
        // Add to the event collection 
        HttpEvent httpEvent = new HttpEvent(requestName, asyncContext);
        EventManager.addHttpEvent(httpEvent);
    }

    /** *  Trigger events use  * @param requestName */
    @GetMapping("/trigger")
    public void triggerDemo(@RequestParam(value = "requestName") String requestName){
    
        EventManager.onEvent(requestName);
    }
}

The above simple long polling is realized , We can test ：
After starting the application, access ：http://localhost:8080/app/asyncGet?requestName=123
The server is not ready because the data is not ready , So will hold Request for accommodation . When waiting 30s The timeout information will be returned after ：

We are 30s Internal trigger event：http://localhost:8080/app/trigger?requestName=123
return ：

The whole long polling implementation above is completed , If there is an error , Welcome to correct ！