servlet3.0使用

异步servlet使用 基于springboot


@WebServlet(urlPatterns = "/address", asyncSupported = true)
public class ServletAsync extends HttpServlet {

    private static Logger logger = Logger.getLogger(ServletAsync.class);

    private Gson gson = new Gson();

    private final static int permits = 200;

    private Semaphore semaphore = new Semaphore(permits);

    private static ThreadPoolExecutor executor = null;

    static {
        executor = new ThreadPoolExecutor(80, 100, 60L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(100),
                new ThreadFactory("theard-1"),
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        try {
                            Processor process = (Processor ) r;
                            process.writerError("系统繁忙,请稍后再试!");
                            //这里直接处理不重新入队列
                            process.getAsyncContext().complete();
                        } catch (Throwable e) {
                            logger.error("--RejectedExecutionHandler-->", e);
                        }
                    }
                });
    }

    @Override
    public void destroy() {
        super.destroy();
        executor.shutdown();
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        response.setCharacterEncoding("utf-8");
        response.setContentType("application/json;charset=utf-8");

        //写业务代码
      
        //结束
    
        if (executor.getActiveCount() > permits) {
            Result orr = new Result (false, "-1", "xxxxxx");
            response.getWriter().write(gson.toJson(orr));
            return;
        } else if (semaphore.tryAcquire()) {
            try {
                request.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);
                AsyncContext asyncCtx = request.startAsync();
                // 设置回调监听器
                asyncCtx.addListener(new AsyncListener() {
                    @Override
                    public void onComplete(AsyncEvent event) throws IOException {
                        long end = System.currentTimeMillis();
                        logger.info("调用总耗时：" + (end - start) + "ms");
                    }

                    @Override
                    public void onTimeout(AsyncEvent event) throws IOException {
                        ServletResponse response = event.getAsyncContext().getResponse();
                        PrintWriter out = response.getWriter();
                        Result orr = new Result (false, "-1", "cainiao timeout 2s");
                        out.write(gson.toJson(orr));
                        out.flush();
                        out.close();
                    }

                    @Override
                    public void onError(AsyncEvent event) throws IOException {
                        ServletResponse response = event.getAsyncContext().getResponse();
                        PrintWriter out = response.getWriter();
                        Result orr = new Result (false, "-1", "cainiao system error");
                        out.write(gson.toJson(orr));
                        out.flush();
                        out.close();
                    }

                    @Override
                    public void onStartAsync(AsyncEvent event) throws IOException {

                    }
                });
                //设置超时时间
                asyncCtx.setTimeout(6000);
                executor.execute(new Processor(asyncCtx, req));
            } finally {
                //释放
                semaphore.release();
            }
        } else {
            Result rr= new Result(false, "-1", "XXXXX");
            response.getWriter().write(gson.toJson(rr));
            return;
        }
    }