import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; 
import java.util.concurrent.Executor;
 
@Configuration
@EnableAsync  // 啟用異步任務(wù)
public class AsyncConfig {
 
    // 聲明一個線程池(并指定線程池的名字)
    @Bean("AsyncThread")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心線程數(shù)5：線程池創(chuàng)建時候初始化的線程數(shù)
        executor.setCorePoolSize(5);
        //最大線程數(shù)5：線程池最大的線程數(shù)，只有在緩沖隊列滿了之后才會申請超過核心線程數(shù)的線程
        executor.setMaxPoolSize(10);
        //緩沖隊列500：用來緩沖執(zhí)行任務(wù)的隊列
        executor.setQueueCapacity(500);
        //允許線程的空閑時間60秒：當(dāng)超過了核心線程出之外的線程在空閑時間到達之后會被銷毀
        executor.setKeepAliveSeconds(60);
        //線程池名的前綴：設(shè)置好了之后可以方便我們定位處理任務(wù)所在的線程池
        executor.setThreadNamePrefix("AsyncThread-");
        executor.initialize();
        return executor;
    }
}

    @Async("AsyncThread")
    @RequestMapping(value = "/addBlog")
    public CompletableFuture<String> addBlog(HttpSession httpSession, Blog blog, String blogId, boolean tempSave) {
        System.out.println("\n\n----------------------------------------------");
        System.out.println(Thread.currentThread().getName() + "正在處理請求");
        System.out.println("----------------------------------------------");
        String result = "請求失敗";
        //....你的業(yè)務(wù)邏輯
        return CompletableFuture.completedFuture(result);
    }

    @RestController
    public class HelloController {undefined     
        private static final Logger logger = LoggerFactory.getLogger(HelloController.class);        
        @Autowired
        private HelloService hello;
     
        @GetMapping("/helloworld")
        public String helloWorldController() {undefined
            return hello.sayHello();
        }
     
        /**
         * 異步調(diào)用restful
         * 當(dāng)controller返回值是Callable的時候，springmvc就會啟動一個線程將Callable交給TaskExecutor去處理
         * 然后DispatcherServlet還有所有的spring攔截器都退出主線程，然后把response保持打開的狀態(tài)
         * 當(dāng)Callable執(zhí)行結(jié)束之后，springmvc就會重新啟動分配一個request請求，然后DispatcherServlet就重新
         * 調(diào)用和處理Callable異步執(zhí)行的返回結(jié)果， 然后返回視圖
         *
         * @return
         */
        @GetMapping("/hello")
        public Callable<String> helloController() {undefined
            logger.info(Thread.currentThread().getName() + " 進入helloController方法");
            Callable<String> callable = new Callable<String>() {undefined
     
                @Override
                public String call() throws Exception {undefined
                    logger.info(Thread.currentThread().getName() + " 進入call方法");
                    String say = hello.sayHello();
                    logger.info(Thread.currentThread().getName() + " 從helloService方法返回");
                    return say;
                }
            };
            logger.info(Thread.currentThread().getName() + " 從helloController方法返回");
            return callable;
        }
    }

    @RestController
    public class HelloController {undefined     
        private static final Logger logger = LoggerFactory.getLogger(HelloController.class);        
        @Autowired
        private HelloService hello;     
            /**
         * 帶超時時間的異步請求 通過WebAsyncTask自定義客戶端超時間
         *
         * @return
         */
        @GetMapping("/world")
        public WebAsyncTask<String> worldController() {undefined
            logger.info(Thread.currentThread().getName() + " 進入helloController方法");
     
            // 3s鐘沒返回，則認為超時
            WebAsyncTask<String> webAsyncTask = new WebAsyncTask<>(3000, new Callable<String>() {undefined
     
                @Override
                public String call() throws Exception {undefined
                    logger.info(Thread.currentThread().getName() + " 進入call方法");
                    String say = hello.sayHello();
                    logger.info(Thread.currentThread().getName() + " 從helloService方法返回");
                    return say;
                }
            });
            logger.info(Thread.currentThread().getName() + " 從helloController方法返回");
     
            webAsyncTask.onCompletion(new Runnable() {undefined
     
                @Override
                public void run() {undefined
                    logger.info(Thread.currentThread().getName() + " 執(zhí)行完畢");
                }
            });
     
            webAsyncTask.onTimeout(new Callable<String>() {undefined
     
                @Override
                public String call() throws Exception {undefined
                    logger.info(Thread.currentThread().getName() + " onTimeout");
                    // 超時的時候，直接拋異常，讓外層統(tǒng)一處理超時異常
                    throw new TimeoutException("調(diào)用超時");
                }
            });
            return webAsyncTask;
        }
     
        /**
         * 異步調(diào)用，異常處理，詳細的處理流程見MyExceptionHandler類
         *
         * @return
         */
        @GetMapping("/exception")
        public WebAsyncTask<String> exceptionController() {undefined
            logger.info(Thread.currentThread().getName() + " 進入helloController方法");
            Callable<String> callable = new Callable<String>() {undefined
     
                @Override
                public String call() throws Exception {undefined
                    logger.info(Thread.currentThread().getName() + " 進入call方法");
                    throw new TimeoutException("調(diào)用超時!");
                }
            };
            logger.info(Thread.currentThread().getName() + " 從helloController方法返回");
            return new WebAsyncTask<>(20000, callable);
        }     
    }

    @Component
    public class LongTimeTask {undefined
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
        @Async
        public void execute(DeferredResult<String> deferred){undefined
            logger.info(Thread.currentThread().getName() + "進入 taskService 的 execute方法");
            try {undefined
                // 模擬長時間任務(wù)調(diào)用，睡眠2s
                TimeUnit.SECONDS.sleep(2);
                // 2s后給Deferred發(fā)送成功消息，告訴Deferred，我這邊已經(jīng)處理完了，可以返回給客戶端了
                deferred.setResult("world");
            } catch (InterruptedException e) {undefined
                e.printStackTrace();
            }
        }
    }

    @RestController
    public class AsyncDeferredController {undefined
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
        private final LongTimeTask taskService;        
        @Autowired
        public AsyncDeferredController(LongTimeTask taskService) {undefined
            this.taskService = taskService;
        }
        
        @GetMapping("/deferred")
        public DeferredResult<String> executeSlowTask() {undefined
            logger.info(Thread.currentThread().getName() + "進入executeSlowTask方法");
            DeferredResult<String> deferredResult = new DeferredResult<>();
            // 調(diào)用長時間執(zhí)行任務(wù)
            taskService.execute(deferredResult);
            // 當(dāng)長時間任務(wù)中使用deferred.setResult("world");這個方法時，會從長時間任務(wù)中返回，繼續(xù)controller里面的流程
            logger.info(Thread.currentThread().getName() + "從executeSlowTask方法返回");
            // 超時的回調(diào)方法
            deferredResult.onTimeout(new Runnable(){undefined
            
                @Override
                public void run() {undefined
                    logger.info(Thread.currentThread().getName() + " onTimeout");
                    // 返回超時信息
                    deferredResult.setErrorResult("time out!");
                }
            });
            
            // 處理完成的回調(diào)方法，無論是超時還是處理成功，都會進入這個回調(diào)方法
            deferredResult.onCompletion(new Runnable(){undefined
            
                @Override
                public void run() {undefined
                    logger.info(Thread.currentThread().getName() + " onCompletion");
                }
            });            
            return deferredResult;
        }
    }

    @Component
    public class MyAsyncHandlerInterceptor implements AsyncHandlerInterceptor {undefined        
        private static final Logger logger = LoggerFactory.getLogger(MyAsyncHandlerInterceptor.class);     
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {undefined
            return true;
        }
     
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {undefined
    //        HandlerMethod handlerMethod = (HandlerMethod) handler;
            logger.info(Thread.currentThread().getName()+ "服務(wù)調(diào)用完成，返回結(jié)果給客戶端");
        }
     
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {undefined
            if(null != ex){undefined
                System.out.println("發(fā)生異常:"+ex.getMessage());
            }
        }
     
        @Override
        public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {undefined            
            // 攔截之后，重新寫回數(shù)據(jù)，將原來的hello world換成如下字符串
            String resp = "my name is chhliu!";
            response.setContentLength(resp.length());
            response.getOutputStream().write(resp.getBytes());            
            logger.info(Thread.currentThread().getName() + " 進入afterConcurrentHandlingStarted方法");
        }     
    }