精华内容
下载资源
问答
  • Java异步请求

    2019-04-08 15:25:38
    传统web交互模型,浏览器直接将请求发送给服务器,服务器回送响应,直接发给浏览器, Ajax交互模型,浏览器首先将请求 发送 Ajax引擎(以XMLHttpRequest为核心),AJax引擎再将请求发送给 服务器,服务器回送响应先...
  • import java.util.concurrent.Callable; @Slf4j @RestController public class AsyncCallableController { @Autowired private BusinessService businessService; @GetMapping(value = "/getData") public Callable...

    1、Callable

    1)Runnable,执行独立的任务,但不返回值。如希望任务完成后有返回值,可以使用Callable接口实现;

    2)Callable,是一个具有类型参数的范型,他的类型参数方法表示为方法call()而不是run()中返回的值,并且必须使用ExecutorService.submint()方法进行调用。

    区别:

    1.Callable,接受一个泛型,然后在call()方法中返回一个这个类型的值;然而,Runnable的run()方法无返回值;
    2.Callable,其call()方法可抛出异常,而Runnable的run()方法是不抛出异常的。

    2、业务场景:

            HTTP请求中,业务处理流程耗时较长,比如大的查询,远程调用等场景,接受http请求的主线程会被一直占用,而tomcat线程池线程数量又是有限的,所以,单位时间内接受http请求量就会下降。

    3、代码示例

    1)controller

    package com.liuxd.controller;
    
    import com.liuxd.entity.Responses;
    import com.liuxd.service.BusinessService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.concurrent.Callable;
    
    @Slf4j
    @RestController
    public class AsyncCallableController {
    
        @Autowired
        private BusinessService businessService;
    
        @GetMapping(value = "/getData")
        public Callable<Responses<String>> getData() {
    
            log.info("收到HTTP请求...");
    
            Callable<Responses<String>> data = (() -> {
                return businessService.getData();
            });
    
            log.info("接收HTTP请求线程任务已完成,退出!");
    
            return data;
        }
    
    }
    

    2、service

    package com.liuxd.service;
    
    import com.liuxd.entity.Responses;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    @Slf4j
    @Service
    public class BusinessService {
    
        public Responses<String> getData(){
    
            log.info("调用service方法,开始执行...");
    
            try {
                Thread.sleep(2500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            log.info("调用service方法,执行结束!!");
    
            return new Responses<>(0,"操作完成","SUCCESS");
    
        }
    
    }
    

    3)打印结果

     

     

     

    展开全文
  • 这是一个javaweb样例工程,实现的是jquery+ajax传输
  • 使用maven构建,前端使用jquery,jquery-form插件,后台使用springmvc框架,主要目的为满足某些特殊情况要求在弹窗上进行上传文件。
  • JavaWeb之异步处理请求

    千次阅读 2019-10-04 23:20:33
    1、servlet3.0-异步请求:   引用:在Servlet 3.0之前,Servlet采用Thread-Per-Request的方式处理请求,即每一次Http请求都由某一个线程从头到尾负责处理,当过来一个请求之后,会从tomcat的线程池中拿出一个线程...

    1、servlet3.0-异步请求: 

      引用:在Servlet 3.0之前,Servlet采用Thread-Per-Request的方式处理请求,即每一次Http请求都由某一个线程从头到尾负责处理,当过来一个请求之后,会从tomcat的线程池中拿出一个线程去处理这个请求,处理完成之后再将该线程归还到线程池图,如图一所示。但是线程池的数量是有限的,如果一个请求需要进行IO操作,比如访问数据库(或者调用第三方服务接口等),那么其所对应的线程将同步地等待IO操作完成, 而IO操作是非常慢的,所以此时的线程并不能及时地释放回线程池以供后续使用,在并发量越来越大的情况下,这将带来严重的性能问题。即便是像Spring、Struts这样的高层框架也脱离不了这样的桎梏,因为他们都是建立在Servlet之上的。为了解决这样的问题,Servlet 3.0引入了异步处理如图二,在Servlet 3.1中又引入了非阻塞IO来进一步增强异步处理的性能。

                            图一 同步模式

     

                            图二 异步模式

     

    例:

    @WebServlet(value="/async",asyncSupported=true)
    public class HelloAsyncServlet extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //1、支持异步处理asyncSupported=true
            //2、开启异步模式
            System.out.println("主线程开始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
            AsyncContext startAsync = req.startAsync();
            //3、业务逻辑进行异步处理;开始异步处理
            startAsync.start(() -> {
                try {
                    System.out.println("副线程开始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
                    sayHello();
                    startAsync.complete();
                    //获取到异步上下文
                    AsyncContext asyncContext = req.getAsyncContext();
                    //4、获取响应
                    ServletResponse response = asyncContext.getResponse();
                    response.getWriter().write("hello async...");
                    System.out.println("副线程结束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
                } catch (Exception e) {
                }
            });
            System.out.println("主线程结束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
        }
    
        public void sayHello() throws Exception{
            System.out.println(Thread.currentThread()+" processing...");
            Thread.sleep(3000);
        }
    }

     

    2、SpringMVC-异步请求

      Spring MVC很好的支持了Servlet 3.0异步请求,所有我们可以直接使用SpringMVC来实现异步请求:通过控制器返回DeferredResult或Callable来实现

    1)使用 Callable

       @ResponseBody
        @RequestMapping("/async01")
        public Callable<String> async01(){
            System.out.println("主线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
            
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("副线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
                    Thread.sleep(2000);
                    System.out.println("副线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
                    return "Callable<String> async01()";
                }
            };
            
            System.out.println("主线程结束..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
            return callable;
        }

    结果:

        preHandle.../springmvc-annotation/async01
        主线程开始...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
        主线程结束...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
        =========DispatcherServlet及所有的Filter退出线程============================

        ================等待Callable执行==========
        副线程开始...Thread[MvcAsync1,5,main]==>1513932494707
        副线程开始...Thread[MvcAsync1,5,main]==>1513932496708
        ================Callable执行完成==========

        ================再次收到之前重发过来的请求========
        preHandle.../springmvc-annotation/async01
        postHandle...(Callable的之前的返回值就是目标方法的返回值)
        afterCompletion...

     
     

    说明:

      1、控制器返回Callable

      2、Spring异步处理,将Callable 提交到 TaskExecutor 使用一个隔离的线程进行执行

      3、DispatcherServlet和所有的Filter退出web容器的线程,但是response 保持打开状态

      4、Callable返回结果,SpringMVC将请求重新派发给容器,恢复之前的处理

      5、根据Callable返回的结果。SpringMVC继续进行视图渲染流程等(从收请求-视图渲染)

    普通的拦截器不能拦截异步处理请求的方法,可以使用Servlet原生API的AsyncListener或实现SpringMVC中的AsyncHandlerInterceptor来拦截异步方法的执行

     

    2)使用DeferredResult

    @GetMapping("/quotes")
    @ResponseBody
    public DeferredResult<String> quotes() {
       DeferredResult
    <String> deferredResult = new DeferredResult<String>((long)3000, "timeout..."); // Save the deferredResult somewhere.. return deferredResult; } // From some other thread... deferredResult.setResult(data);

    说明:

      1)控制器返回DeferredResult

      2)可以将DeferredResult保存起来

      3)使用其他线程调用DeferredsetResult.setResult方法

      4)SpringMVC将请求重新派发给容器,恢复之前的处理

      

      

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

      

    转载于:https://www.cnblogs.com/qzlcl/p/11106162.html

    展开全文
  • javaweb异步处理程序

    2019-08-03 01:03:18
    NULL 博文链接:https://jic.iteye.com/blog/1985523
  • java异步处理耗时请求

    千次阅读 2019-03-18 20:18:35
    模拟异步调用 import com.springdemo2.service.helloService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.spring...

    模拟异步调用

    import com.springdemo2.service.helloService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.concurrent.Callable;
    
    @RestController
    public class HelloController2 {
    
        private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
    
        @Autowired
        private helloService hello;
    
        @GetMapping("/helloworld")
        public String helloWorldController() {
            logger.info(Thread.currentThread().getName() + " 进入helloWorldController方法");
            String say = hello.sayHello();
            logger.info("请求完成");
            return say;
        }
    
        /**
         * 异步调用restful
         * 当controller返回值是Callable的时候,springmvc就会启动一个线程将Callable交给TaskExecutor去处理
         * 然后DispatcherServlet还有所有的spring拦截器都退出主线程,然后把response保持打开的状态
         * 当Callable执行结束之后,springmvc就会重新启动分配一个request请求,然后DispatcherServlet就重新
         * 调用和处理Callable异步执行的返回结果, 然后返回视图
         *
         * @return
         */
        @GetMapping("/hello1")
        public Callable<String> helloController() {
            logger.info(Thread.currentThread().getName() + " 进入helloController方法");
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    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;
        }
    }
    

    模拟耗时请求

    import org.springframework.stereotype.Component;
    
    @Component
    public class helloService {
    
       public String sayHello(){
           try {
               Thread.sleep(10000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           return "aa";
       }
    }
    

    日志

    helloController调用新线程处理任务,而helloWorldController为当前线程处理,阻塞当前线程

    2019-03-18 20:13:56.171  INFO 7495 --- [io-8080-exec-10] c.s.contorller.HelloController           : http-nio-8080-exec-10 进入helloController方法
    2019-03-18 20:13:56.171  INFO 7495 --- [io-8080-exec-10] c.s.contorller.HelloController           : http-nio-8080-exec-10 从helloController方法返回
    2019-03-18 20:13:56.172  INFO 7495 --- [         task-9] c.s.contorller.HelloController           : task-9 进入call方法
    2019-03-18 20:13:57.222  INFO 7495 --- [nio-8080-exec-1] c.s.contorller.HelloController           : http-nio-8080-exec-1 进入helloController方法
    2019-03-18 20:13:57.222  INFO 7495 --- [nio-8080-exec-1] c.s.contorller.HelloController           : http-nio-8080-exec-1 从helloController方法返回
    2019-03-18 20:13:57.223  INFO 7495 --- [        task-10] c.s.contorller.HelloController           : task-10 进入call方法
    2019-03-18 20:13:58.084  INFO 7495 --- [nio-8080-exec-2] c.s.contorller.HelloController           : http-nio-8080-exec-2 进入helloController方法
    2019-03-18 20:13:58.084  INFO 7495 --- [nio-8080-exec-2] c.s.contorller.HelloController           : http-nio-8080-exec-2 从helloController方法返回
    2019-03-18 20:13:58.084  INFO 7495 --- [        task-11] c.s.contorller.HelloController           : task-11 进入call方法
    2019-03-18 20:14:06.176  INFO 7495 --- [         task-9] c.s.contorller.HelloController           : task-9 从helloService方法返回
    2019-03-18 20:14:07.223  INFO 7495 --- [        task-10] c.s.contorller.HelloController           : task-10 从helloService方法返回
    2019-03-18 20:14:08.087  INFO 7495 --- [        task-11] c.s.contorller.HelloController           : task-11 从helloService方法返回
    
    
    2019-03-18 20:14:20.996  INFO 7495 --- [nio-8080-exec-7] c.s.contorller.HelloController           : http-nio-8080-exec-7 进入helloWorldController方法
    2019-03-18 20:14:22.051  INFO 7495 --- [nio-8080-exec-8] c.s.contorller.HelloController           : http-nio-8080-exec-8 进入helloWorldController方法
    2019-03-18 20:14:22.836  INFO 7495 --- [nio-8080-exec-9] c.s.contorller.HelloController           : http-nio-8080-exec-9 进入helloWorldController方法
    2019-03-18 20:16:56.858  INFO 7499 --- [nio-8080-exec-1] c.s.contorller.HelloController           : http-nio-8080-exec-1请求完成
    2019-03-18 20:16:57.424  INFO 7499 --- [nio-8080-exec-2] c.s.contorller.HelloController           : http-nio-8080-exec-2请求完成
    2019-03-18 20:16:58.058  INFO 7499 --- [nio-8080-exec-3] c.s.contorller.HelloController           : http-nio-8080-exec-3请求完成
    
    展开全文
  • Java编写的山寨QQ,多人聊天+用户在线 21个目标文件 摘要:JAVA源码,媒体网络,山寨QQ,Java聊天程序 Java编写的山寨QQ,多人聊天+用户在线,程序分服务端和客户端,典型C/S结构, 当用户发送第一次请求的时候,验证...
  • 2、异步处理 开启新线程,处理数据并赋值返回。 3、代码示例 1)controller package com.liuxd.controller; import com.liuxd.entity.Responses; import com.liuxd.service.TaskService2; import lo...

    1、DeferredResult

    spring 支持http异步返回

    2、异步处理

    开启新线程,处理数据并赋值返回。

    3、代码示例

    1)controller

    package com.liuxd.controller;
    
    import com.liuxd.entity.Responses;
    import com.liuxd.service.TaskService2;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.context.request.async.DeferredResult;
    
    @Slf4j
    @RestController
    public class AsyncCtr2 {
    
        @Autowired
        private TaskService2 taskService2;
    
        @GetMapping(value = "/getResult")
        public DeferredResult<Responses<String>> getResult() {
            log.info("收到HTTP请求...");
            long startTime = System.currentTimeMillis();
    
            DeferredResult<Responses<String>> deferredResult = new DeferredResult<Responses<String>>();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    taskService2.getData(deferredResult);
                }
            }).start();
    
            log.info("接收HTTP请求线程任务已完成,退出!");
            long endTime = System.currentTimeMillis();
            log.info("http请求总耗时: " + (endTime - startTime) + "ms");
    
            return deferredResult;
    
        }
    }
    

    2)service

    package com.liuxd.service;
    
    import com.liuxd.entity.Responses;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    import org.springframework.web.context.request.async.DeferredResult;
    
    @Slf4j
    @Service
    public class TaskService2 {
    
        public void getData(DeferredResult<Responses<String>> deferredResult) {
    
            log.info("调用service异步有返回方法,开始执行...");
            long startTime = System.currentTimeMillis();
    
            try {
                Thread.sleep(2500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            log.info("调用service异步有返回方法,执行结束!!");
    
            long endTime = System.currentTimeMillis();
            log.info("调用service异步有返回方法总耗时: " + (endTime - startTime) + "ms");
    
            deferredResult.setResult(new Responses<>(0, "异步处理完成", "SUCCESS"));
    
        }
    
    
    }
    

    3)Responses

    package com.liuxd.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class Responses<T> {
    
        private Integer code;
    
        private String msg;
    
        private T data;
    
    }
    

    4)打印结果

    5)结果分析

    1)http主线程接受请求,处理完请求后线程结束

    2)异步线程结束后,返回 

    展开全文
  • Web服务请求异步化介绍

    千次阅读 2016-12-11 10:51:42
    本文从概念的角度对于应用系统异步化,Web服务请求异步化和Web请求异步化规范及实现三方面做一个介绍,为系统异步化改造做好基础准备。(同样,文中大部分都是个人意见和想法,非完全正确,欢迎讨论) 应用系统异步...
  • 1、使用java有返回的线程 interfaceCallable<V> 2、代码示例 package com.listen.demo.ctr; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.Bean; import org....
  • 异步Web方法调用例子-Java源码,此为完整代码
  • Web请求异步处理和海量数据即时分析在淘宝开放平台的实践
  • Java知识体系最强总结(2021版)

    万次阅读 多人点赞 2019-12-18 10:09:56
    本人从事Java开发已多年,平时有记录问题解决方案和总结知识点的习惯,整理了一些有关Java的知识体系,这不是最终版,会不定期的更新。也算是记录自己在从事编程工作的成长足迹,通过博客可以促进博主与阅读者的共同...
  • 异步Web系统设计 主要技术:servlet3,JDK8 CompletableFuture,支持异步Callback调用的RPC框架。   先看一下处理流程图: servlet3:Servlet 接收到请求之后,可能首先需要对请求携带的数据进行一些预处理;接着...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 使用纯Java实现一个WebSSH项目

    万次阅读 多人点赞 2020-03-10 13:18:21
    使用纯Java语言实现的WebSSH项目。 技术:SpringBoot+WebSockey+jsch+xterm.js
  • java异步调用外部接口

    千次阅读 2020-12-24 14:42:35
    public void sendReptile(String keyword){ //CompletableFuture实现异步调用 CompletableFuture future = CompletableFuture.supplyAsync(() -> { //你自己的逻辑代码,通过restTemplate.exchange调用外部接口 ...
  • 1、简单介绍一下Ajax(Asynchronous JavaScript and XML)异步请求: Ajax 不是一种新的编程语言,而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。 2、简单介绍一下Json数据: JSON(JavaScriptObject...
  • 1、异步请求与同步请求 特点: 可以先释放容器分配给请求的线程与相关资源,减轻系统负担,释放了容器所分配线程的请求,其响应将被延后,可以在耗时处理完成(例如长时间的运算)时再对客户端进行响应。 一句话: ...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java中使用RabbitMQ的异步Web-Worker模型 正如在“文章中所解释的那样,Web请求应尽快完成。 如果操作可能需要很长时间,则最好将其发送给工人测功机以在后台进行处理。 本文通过使用Spring 和以及Heroku 的示例...
  • Java异步处理REST服务

    千次阅读 2018-06-28 11:08:22
    一:首先,来看看同步处理和异步处理有什么区别: 那么为什么要有异步处理,从上图当中可以看出,同步处理请求进入时,主线程负责处理所有的业务逻辑结束之后,才发出HTTP响应的,我们知道,像Tomcat这种服务器能够...
  • 1. 同步和异步web中的实例 如果只用简单的form表单提交请求,网页会有一次闪烁(加载整个网页)然后才会返回结果,这是一种同步提交请求的方法,但是在使用Ajax之后 ,无需重新加载整个网页的情况下,能够更新...
  • ajax异步请求详解   ajxa定义:异步的javascript和xml   1、XMLHttpRequst的出现才有了异步处理   2、创建XmlHttpRequest对象 var request=new XMLHttpRequest(); 注意:如果要兼容IE6以下浏览器则需要...
  • [springboot] 异步开发之异步请求

    千次阅读 2019-01-08 18:15:19
    何为异步请求 在Servlet 3.0之前,Servlet采用Thread-Per-Request的方式处理请求,即每一次Http请求都由某一个线程从头到尾负责处理。如果一个请求需要进行IO操作,比如访问数据库、调用第三方服务接口等,那么其所...
  • Spring 的异步HTTP请求AsyncRestTemplate

    万次阅读 2019-01-30 23:02:04
    如果你是第一次看到这篇文章,那么我建议你先去看一下上一篇《Spring 的异步HTTP请求AsyncRestTemplate》 还是那个套路 熟悉使用RestTemplate的,不会觉得AsyncRestTemplate很难,因为的确很相似。在Spring 看来,...
  • 场景假设在web环境下有一个线程A需要10分钟后调用操作B。好在只要调用就可以不需要知道B的返回结果。这种场景下实际上可以通过发送延迟消息队列来完成,A执行时发送一个延迟消息队列,它就可...
  • 同步请求异步请求的区别

    千次阅读 2019-04-01 08:50:15
    同步请求异步请求的区别 先解释一下同步和异步的概念 同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包...
  • Ajax:(Asynchronous JavaScript And XML)只刷新局部页面的技术。 它不是一种新的编程语言,而是一种用于创建更好更快以及交互性更...2、 XML:一般用于请求数据和响应数据的封装 3、 XMLHttpRequest对象:发送请

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,441
精华内容 44,176
关键字:

java异步web请求

java 订阅