[Java] 详解SpringBoot中异步请求和异步调用(看完这一篇就够了)

@requestmapping(value = "/email/servletreq", method = get)
 public void servletreq (httpservletrequest request, httpservletresponse response) {
  asynccontext asynccontext = request.startasync();
  //设置监听器:可设置其开始、完成、异常、超时等事件的回调处理
 asynccontext.addlistener(new asynclistener() {
   @override
   public void ontimeout(asyncevent event) throws ioexception {
  system.out.println("超时了...");
  //做一些超时后的相关操作...
   }
   @override
   public void onstartasync(asyncevent event) throws ioexception {
  system.out.println("线程开始");
   }
   @override
   public void onerror(asyncevent event) throws ioexception {
  system.out.println("发生错误："+event.getthrowable());
   }
   @override
   public void oncomplete(asyncevent event) throws ioexception {
  system.out.println("执行完成");
  //这里可以做一些清理资源的操作...
   }
  });
  //设置超时时间
  asynccontext.settimeout(20000);
  asynccontext.start(new runnable() {
   @override
   public void run() {
  try {
   thread.sleep(10000);
   system.out.println("内部线程：" + thread.currentthread().getname());
   asynccontext.getresponse().setcharacterencoding("utf-8");
   asynccontext.getresponse().setcontenttype("text/html;charset=utf-8");
   asynccontext.getresponse().getwriter().println("这是异步的请求返回");
  } catch (exception e) {
   system.out.println("异常："+e);
  }
  //异步请求完成通知
  //此时整个请求才完成
  asynccontext.complete();
   }
  });
  //此时之类 request的线程连接已经释放了
  system.out.println("主线程：" + thread.currentthread().getname());
 }

@requestmapping(value = "/email/callablereq", method = get)
 @responsebody
 public callable<string> callablereq () {
  system.out.println("外部线程：" + thread.currentthread().getname());
  return new callable<string>() {
   @override
   public string call() throws exception {
  thread.sleep(10000);
  system.out.println("内部线程：" + thread.currentthread().getname());
  return "callable!";
   }
  };
 }
 @configuration
 public class requestasyncpoolconfig extends webmvcconfigureradapter {
 @resource
 private threadpooltaskexecutor mythreadpooltaskexecutor;
 @override
 public void configureasyncsupport(final asyncsupportconfigurer configurer) {
  //处理 callable超时
  configurer.setdefaulttimeout(60*1000);
  configurer.settaskexecutor(mythreadpooltaskexecutor);
  configurer.registercallableinterceptors(timeoutcallableprocessinginterceptor());
 }
 @bean
 public timeoutcallableprocessinginterceptor timeoutcallableprocessinginterceptor() {
  return new timeoutcallableprocessinginterceptor();
 }
}

@requestmapping(value = "/email/webasyncreq", method = get)
@responsebody
public webasynctask<string> webasyncreq () {
 system.out.println("外部线程：" + thread.currentthread().getname());
 callable<string> result = () -> {
  system.out.println("内部线程开始：" + thread.currentthread().getname());
  try {
   timeunit.seconds.sleep(4);
  } catch (exception e) {
   // todo: handle exception
  }
  logger.info("副线程返回");
  system.out.println("内部线程返回：" + thread.currentthread().getname());
  return "success";
 };
 webasynctask<string> wat = new webasynctask<string>(3000l, result);
 wat.ontimeout(new callable<string>() {
 
  @override
  public string call() throws exception {
   // todo auto-generated method stub
   return "超时";
  }
 });
 return wat;
}

@requestmapping(value = "/email/deferredresultreq", method = get)
@responsebody
public deferredresult<string> deferredresultreq () {
 system.out.println("外部线程：" + thread.currentthread().getname());
 //设置超时时间
 deferredresult<string> result = new deferredresult<string>(60*1000l);
 //处理超时事件 采用委托机制
 result.ontimeout(new runnable() {
 
  @override
  public void run() {
   system.out.println("deferredresult超时");
   result.setresult("超时了!");
  }
 });
 result.oncompletion(new runnable() {
 
  @override
  public void run() {
   //完成后
   system.out.println("调用完成");
  }
 });
 mythreadpooltaskexecutor.execute(new runnable() {
 
  @override
  public void run() {
   //处理业务逻辑
   system.out.println("内部线程：" + thread.currentthread().getname());
   //返回结果
   result.setresult("deferredresult!!");
  }
 });
 return result;
}

异步请求的处理。除了异步请求，一般上我们用的比较多的应该是异步调用。通常在开发过程中，会遇到一个方法是和实际业务无关的，没有紧密性的。比如记录日志信息等业务。这个时候正常就是启一个新线程去做一些业务处理，让主线程异步的执行其他业务。

• 需要在启动类加入@enableasync使异步调用@async注解生效
  
• 在需要异步执行的方法上加入此注解即可@async(“threadpool”),threadpool为自定义线程池
  
• 代码略。。。就俩标签，自己试一把就可以了
  

• 在默认情况下，未设置taskexecutor时，默认是使用simpleasynctaskexecutor这个线程池，但此线程不是真正意义上的线程池，因为线程不重用，每次调用都会创建一个新的线程。可通过控制台日志输出可以看出，每次输出线程名都是递增的。所以最好我们来自定义一个线程池。
  
• 调用的异步方法，不能为同一个类的方法（包括同一个类的内部类），简单来说，因为spring在启动扫描时会为其创建一个代理类，而同类调用时，还是调用本身的代理类的，所以和平常调用是一样的。其他的注解如@cache等也是一样的道理，说白了，就是spring的代理机制造成的。所以在开发中，最好把异步服务单独抽出一个类来管理。下面会重点讲述。。
  

• 调用的是静态(static )方法
  
• 调用(private)私有化方法
  

@controller
@requestmapping("/app")
public class emailcontroller {
 //获取applicationcontext对象方式有多种,这种最简单,其它的大家自行了解一下
 @autowired
 private applicationcontext applicationcontext;
 
  @requestmapping(value = "/email/asynccall", method = get)
  @responsebody
  public map<string, object> asynccall () {
  map<string, object> resmap = new hashmap<string, object>();
  try{
  //这样调用同类下的异步方法是不起作用的
    //this.testasynctask();
  //通过上下文获取自己的代理对象调用异步方法
   emailcontroller emailcontroller = (emailcontroller)applicationcontext.getbean(emailcontroller.class);
   emailcontroller.testasynctask();
    resmap.put("code",200);
  }catch (exception e) {
  resmap.put("code",400);
    logger.error("error!",e);
  }
  return resmap;
  }
 //注意一定是public,且是非static方法
 @async
  public void testasynctask() throws interruptedexception {
  thread.sleep(10000);
  system.out.println("异步任务执行完成！");
  }
}

@service
@transactional(value = "transactionmanager", readonly = false, propagation = propagation.required, rollbackfor = throwable.class)
public class emailservice {
  @autowired
  private applicationcontext applicationcontext;
  @async
  public void testsynctask() throws interruptedexception {
  thread.sleep(10000);
  system.out.println("异步任务执行完成！");
  }
  public void asynccalltwo() throws interruptedexception {
  //this.testsynctask();
//  emailservice emailservice = (emailservice)applicationcontext.getbean(emailservice.class);
//  emailservice.testsynctask();
  boolean isaop = aoputils.isaopproxy(emailcontroller.class);//是否是代理对象；
  boolean iscglib = aoputils.iscglibproxy(emailcontroller.class); //是否是cglib方式的代理对象；
  boolean isjdk = aoputils.isjdkdynamicproxy(emailcontroller.class); //是否是jdk动态代理方式的代理对象；
  //以下才是重点!!!
 emailservice emailservice = (emailservice)applicationcontext.getbean(emailservice.class);
  emailservice proxy = (emailservice) aopcontext.currentproxy();
  system.out.println(emailservice == proxy ? true : false);
  proxy.testsynctask();
  system.out.println("end!!!");
  }
}

• 两者的使用场景不同，异步请求用来解决并发请求对服务器造成的压力，从而提高对请求的吞吐量；而异步调用是用来做一些非主线流程且不需要实时计算和响应的任务，比如同步日志到kafka中做日志分析等。
  
• 异步请求是会一直等待response相应的，需要返回结果给客户端的；而异步调用我们往往会马上返回给客户端响应，完成这次整个的请求，至于异步调用的任务后台自己慢慢跑就行，客户端不会关心。
  

• 异步请求和异步调用的使用到这里基本就差不多了，有问题还希望大家多多指出。
  
• 这边文章提到了动态代理，而spring中aop的实现原理就是动态代理，后续会对动态代理做详细解读，还望多多支持哈~