精华内容
下载资源
问答
  • java 异步发送请求

    2019-01-04 15:06:27
     * 转发异步请求  * @param bodyStr  * @param xbwRedirectUrl  */  private void redirectRequest(String bodyStr, String xbwRedirectUrl) {  private ExecutorUtils exec = new Executor...

    /**

         * 转发异步请求

         * @param bodyStr

         * @param xbwRedirectUrl

         */

        private void redirectRequest(String bodyStr, String xbwRedirectUrl) {

      private ExecutorUtils exec = new ExecutorUtils();

            exec.execute(new Runnable() {

                             @Override

                             public void run() {

                                // 发送请求

                                 HttpUtils.sendStr(bodyStr, xbwRedirectUrl, Constants.contentType_xml);

                             }

                         }

            );

        }

    展开全文
  • 1、简单介绍一下Ajax(Asynchronous JavaScript and XML)异步请求: Ajax 不是一种新的编程语言,而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。 2、简单介绍一下Json数据: JSON(JavaScriptObject...

    前言:本篇就是简单说了一下前后台交互的一种方式,适用于小白。

    1、简单介绍一下Ajax(Asynchronous JavaScript and XML)异步请求:

    在这里插入图片描述
    Ajax 不是一种新的编程语言,而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

    2、简单介绍一下Json数据:

    JSON(JavaScriptObject Notation JS 对象简谱) 是一种轻量级的数据交换格式。它基于ECMAScript(欧洲计算机协会制定的js规范)的一个子集,采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。
    JSON 最常见的用法之一,是从 web 服务器上读取 JSON 数据(作为文件或作为 HttpRequest),将 JSON 数据转换为 JavaScript 对象,然后在网页中运用js使用该数据渲染出页面。

    3、本篇demo的简单介绍:

    前台:html+jquery+ajax
    后台:Java+Servlet
    Ide:Myeclipse
    jdk:1.7以上
    简述:前台为普通的html页面,使用ajax发起一个get请求到后台,后台返回提前拼接好的json数据

    4、前台代码如下:

    在这里插入图片描述
    4.1、index.html的代码(jquery的扩展自己去百度下载一个就好记住改index.html的引用):

    <!DOCTYPE html>
    <html>
      <head>
        <title>解析json数据</title>
    	
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="this is my page">
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        
        <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
      <script src="jquery-1.8.2.min.js"></script>
      </head>
      
      <body>
    	<input id="xuan" type="button" value="获取解析json数据">
        <table id="ta" cellspacing="0" border="1px solid" style="border-color:red;">
        	<tr>
    			<td>name</td>
    			<td>age</td>
        	</tr>
        	
        </table>
      </body>   
    
      <script>
    	$(function(){
    		$("#xuan").click(function(){
    			$.ajax({
    				//这个url根据你自己的环境去改一下就行了
    				url:"http://127.0.0.1:8080/AjaxAndJsonTest/alldata",
    				data:"",
    				Type:"get",
    				dataType:"json",
    				success:function(res){
    					//组装第一个取出数据组装网页html标签元素
    					var td1 = $("<td>"+res.name+"</td>")
    					//组装第二个td
    					var td2 = $("<td>"+res.age+"</td>")
    					//组装tr
    					var tr = $("<tr></tr>");
    					//把td表格追加到tr的子元素后面
    					$(tr).append(td1).append(td2);
    					//追加到table子元素后面
    					$("#ta").append(tr);
    				},
    				error:function(err){
    					alert(err)
    				}
    			})
    		})
    	})
      </script>
      </html>
    

    5、后台代码如下:

    5.1、点击下方链接去下载项目(导入是web项目哦!别导错了!):
    链接:https://pan.baidu.com/s/1rS5vLkfKSlMMQ5vhlrNlsA
    提取码:yu5p
    5.2、代码主要逻辑如下图所示(具体点上方下载链接并且导入进去仔细看逻辑都有注释的):
    在这里插入图片描述

    6、效果如下:

    在这里插入图片描述

    7、遇到困难可以评论(有信必回)小轩微信号tangchenxuan1999

    展开全文
  • SpringBoot异步请求

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

    何为异步请求

    在Servlet 3.0之前,Servlet采用Thread-Per-Request的方式处理请求,即每一次Http请求都由某一个线程从头到尾负责处理。如果一个请求需要进行IO操作,比如访问数据库、调用第三方服务接口等,那么其所对应的线程将同步地等待****IO操作完成, 而IO操作是非常慢的,所以此时的线程并不能及时地释放回线程池以供后续使用,在并发量越来越大的情况下,这将带来严重的性能问题。其请求流程大致为:

    而在Servlet3.0发布后,提供了一个新特性:异步处理请求。可以先释放容器分配给请求的线程与相关资源,减轻系统负担,释放了容器所分配线程的请求,其响应将被延后,可以在耗时处理完成(例如长时间的运算)时再对客户端进行响应。其请求流程为:

    在Servlet 3.0后,我们可以从HttpServletRequest对象中获得一个**AsyncContext**对象,该对象构成了异步处理的上下文,Request和Response对象都可从中获取。AsyncContext可以从当前线程传给另外的线程,并在新的线程中完成对请求的处理并返回结果给客户端,初始线程便可以还回给容器线程池以处理更多的请求。如此,通过将请求从一个线程传给另一个线程处理的过程便构成了Servlet 3.0中的异步处理。

    随着Spring5发布,提供了一个响应式Web框架:Spring WebFlux。之后可能就不需要Servlet容器的支持了。以下是其先后对比图:

    左侧是传统的基于Servlet的Spring Web MVC框架,右侧是5.0版本新引入的基于Reactive Streams的Spring WebFlux框架,从上到下依次是Router Functions,WebFlux,Reactive Streams三个新组件。

    原生异步请求API说明

    在编写实际代码之前,我们来了解下一些关于异步请求的api的调用说明。

    • 获取AsyncContext:根据HttpServletRequest对象获取。

    AsyncContext asyncContext = request.startAsync();

    • 设置监听器:可设置其开始、完成、异常、超时等事件的回调处理

    其监听器的接口代码:

    public interface AsyncListener extends EventListener {
        void onComplete(AsyncEvent event) throws IOException;
        void onTimeout(AsyncEvent event) throws IOException;
        void onError(AsyncEvent event) throws IOException;
        void onStartAsync(AsyncEvent event) throws IOException;
    }

    说明:

    1. onStartAsync:异步线程开始时调用
    2. onError:异步线程出错时调用
    3. onTimeout:异步线程执行超时调用
    4. onComplete:异步执行完毕时调用

    一般上,我们在超时或者异常时,会返回给前端相应的提示,比如说超时了,请再次请求等等,根据各业务进行自定义返回。同时,在异步调用完成时,一般需要执行一些清理工作或者其他相关操作。

    需要注意的是只有在调用request.startAsync前将监听器添加到AsyncContext,监听器的onStartAsync方法才会起作用,而调用startAsync前AsyncContext还不存在,所以第一次调用startAsync是不会被监听器中的onStartAsync方法捕获的,只有在超时后又重新开始的情况下onStartAsync方法才会起作用。

    • 设置超时:通过setTimeout方法设置,单位:毫秒。

    一定要设置超时时间,不能无限等待下去,不然和正常的请求就一样了。。

    Servlet方式实现异步请求

    前面已经提到,可通过HttpServletRequest对象中获得一个**AsyncContext**对象,该对象构成了异步处理的上下文。所以,我们来实际操作下。

    1、编写一个简单控制层

    /**
     * 使用servlet方式进行异步请求
     *
     */
    @Slf4j
    @RestController
    public class ServletController {
        
        @RequestMapping("/servlet/orig")
        public void todo(HttpServletRequest request,HttpServletResponse response) throws Exception {
            //这里来个休眠
            Thread.sleep(100);
            response.getWriter().println("这是【正常】的请求返回");
        }
        
        @RequestMapping("/servlet/async")
        public void todoAsync(HttpServletRequest request,HttpServletResponse response) {
            AsyncContext asyncContext = request.startAsync();
            asyncContext.addListener(new AsyncListener() {
                
                @Override
                public void onTimeout(AsyncEvent event) throws IOException {
                    log.info("超时了:");
                    //做一些超时后的相关操作
                }
                
                @Override
                public void onStartAsync(AsyncEvent event) throws IOException {
                    // TODO Auto-generated method stub
                    log.info("线程开始");
                }
                
                @Override
                public void onError(AsyncEvent event) throws IOException {
                    log.info("发生错误:",event.getThrowable());
                }
                
                @Override
                public void onComplete(AsyncEvent event) throws IOException {
                    log.info("执行完成");
                    //这里可以做一些清理资源的操作
                    
                }
            });
            //设置超时时间
            asyncContext.setTimeout(200);
            //也可以不使用start 进行异步调用
    //        new Thread(new Runnable() {
    //            
    //            @Override
    //            public void run() {
    //                编写业务逻辑
    //                
    //            }
    //        }).start();
            
            asyncContext.start(new Runnable() {            
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                        log.info("内部线程:" + Thread.currentThread().getName());
                        asyncContext.getResponse().setCharacterEncoding("utf-8");
                        asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                        asyncContext.getResponse().getWriter().println("这是【异步】的请求返回");
                    } catch (Exception e) {
                        log.error("异常:",e);
                    }
                    //异步请求完成通知
                    //此时整个请求才完成
                    //其实可以利用此特性 进行多条消息的推送 把连接挂起。。
                    asyncContext.complete();
                }
            });
            //此时之类 request的线程连接已经释放了
            log.info("线程:" + Thread.currentThread().getName());
        }
    
    }

    注意:异步请求时,可以利用ThreadPoolExecutor自定义个线程池。

    1.启动下应用,查看控制台输出就可以获悉是否在同一个线程里面了。同时,可设置下等待时间,之后就会调用超时回调方法了。

    使用过滤器时,需要加入asyncSupported为true配置,开启异步请求支持。

    @WebServlet(urlPatterns = "/okong", asyncSupported = true )  
    public  class AsyncServlet extends HttpServlet ...

    题外话:其实我们可以利用在未执行asyncContext.complete()方法时请求未结束这特性,可以做个简单的文件上传进度条之类的功能。但注意请求是会超时的,需要设置超时的时间下。

    Spring方式实现异步请求

    在Spring中,有多种方式实现异步请求,比如callable、DeferredResult或者WebAsyncTask。每个的用法略有不同,可根据不同的业务场景选择不同的方式。以下主要介绍一些常用的用法

    Callable

    使用很简单,直接返回的参数包裹一层callable即可。

    用法

        @RequestMapping("/callable")
        public Callable<String> callable() {
            log.info("外部线程:" + Thread.currentThread().getName());
            return new Callable<String>() {
    
                @Override
                public String call() throws Exception {
                    log.info("内部线程:" + Thread.currentThread().getName());
                    return "callable!";
                }
            };
        }

    控制台输出:

     

    超时、自定义线程设置

    从控制台可以看见,异步响应的线程使用的是名为:MvcAsync1的线程。第一次再访问时,就是MvcAsync2了。若采用默认设置,会无限的创建新线程去处理异步请求,所以正常都需要配置一个线程池及超时时间。

    编写一个配置类

    @Configuration
    public class JavaConfig {
        /**
         * 配置线程池
         * @return
         */
        @Bean(name = "asyncPoolTaskExecutor")
        public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() {
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            //此方法返回可用处理器的虚拟机的最大数量; 不小于1
            int core = Runtime.getRuntime().availableProcessors();
            taskExecutor.setCorePoolSize(core);
            taskExecutor.setMaxPoolSize(core*2 + 1);
            taskExecutor.setQueueCapacity(25);
            taskExecutor.setKeepAliveSeconds(200);
            taskExecutor.setThreadNamePrefix("callable-");//线程名称前缀
            // 线程池对拒绝任务(无线程可用)的处理策略,目前只支持AbortPolicy、CallerRunsPolicy;默认为后者
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            taskExecutor.initialize();
            return taskExecutor;
        }
    }

    DeferredResult

    相比于callable,DeferredResult可以处理一些相对复杂一些的业务逻辑,最主要还是可以在另一个线程里面进行业务处理及返回,即可在两个完全不相干的线程间的通信。

    /**
     * 线程池
     */
    public static ExecutorService FIXED_THREAD_POOL = Executors.newFixedThreadPool(30);
    
    @RequestMapping("/deferredresult")
    public DeferredResult<String> deferredResult(){
        log.info("外部线程:" + Thread.currentThread().getName());
        //设置超时时间
        DeferredResult<String> result = new DeferredResult<String>(60*1000L);
        //处理超时事件 采用委托机制
        result.onTimeout(new Runnable() {
    
            @Override
            public void run() {
                log.error("DeferredResult超时");
                result.setResult("超时了!");
            }
        });
        result.onCompletion(new Runnable() {
    
            @Override
            public void run() {
                //完成后
                log.info("调用完成");
            }
        });
        FIXED_THREAD_POOL.execute(new Runnable() {
    
            @Override
            public void run() {
                //处理业务逻辑
                log.info("内部线程:" + Thread.currentThread().getName());
                //返回结果
                result.setResult("DeferredResult!!");
            }
        });
        return result;
    }

    注意:返回结果时记得调用下setResult方法。

    题外话:利用DeferredResult可实现一些长连接的功能,比如当某个操作是异步时,我们可以保存这个DeferredResult对象,当异步通知回来时,我们在找回这个DeferredResult对象,之后在setResult会结果即可。提高性能。

    WebAsyncTask

    使用方法都类似,只是WebAsyncTask是直接返回了。

    @RequestMapping("/webAsyncTask")
        public WebAsyncTask<String> webAsyncTask() {
            log.info("外部线程:" + Thread.currentThread().getName());
            WebAsyncTask<String> result = new WebAsyncTask<String>(60*1000L, new Callable<String>() {
    
                @Override
                public String call() throws Exception {
                    log.info("内部线程:" + Thread.currentThread().getName());
                    return "WebAsyncTask!!!";
                }
            });
            result.onTimeout(new Callable<String>() {
                
                @Override
                public String call() throws Exception {
                    // TODO Auto-generated method stub
                    return "WebAsyncTask超时!!!";
                }
            });
            result.onCompletion(new Runnable() {
                
                @Override
                public void run() {
                    //超时后 也会执行此方法
                    log.info("WebAsyncTask执行结束");
                }
            });
            return result;
        }

    展开全文
  • 报错信息: ... actual size: 318730) 接口表现出来的是数据传输不完整,丢包, 接口返回 json , ...使用Postman请求,数据正常,但是返回慢,猜测数据量太大返回时请求未完成,所以设置下CloseableHttpClient超时时间

    项目是Spring-boot的,两个项目(A和B) , A调用B

    报错信息:

    org.apache.http.TruncatedChunkException: Truncated chunk ( expected size: 720896; actual size: 318730)

    • 接口表现出来的是数据传输不完整,丢包, 接口返回 json , 接收到的数据可能会少一截,偶尔为空,json 数据说不定会少个 } ,然后反序列化失败。
    • 使用Postman请求,数据正常,但是返回慢,猜测数据量太大返回时请求未完成,所以设置下CloseableHttpClient 超时时间

    代码修改

    原来的:

        private static String doHttp(HttpRequestBase request) throws Exception {
            // 通过连接池获取连接对象
            CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build();
    
            return doRequest(httpClient, request);
        }

    更改后:

        /**
         * 发送 HTTP 请求
         *
         * @param request
         * @return
         * @throws Exception
         */
        private static String doHttp(HttpRequestBase request) throws Exception {
            // 通过连接池获取连接对象
            CloseableHttpClient httpClient = HttpClients.custom()
                    .setConnectionManager(cm)
                    .setConnectionTimeToLive(5, TimeUnit.SECONDS) // 连接存活时间
    //                .setConnectTimeout(1000) //连接超时时间
    //                .setConnectionRequestTimeout(1000) //从连接池中取的连接的最长时间
    //                .setSocketTimeout(10 * 1000) //数据传输的超时时间
    //                .setStaleConnectionCheckEnabled(true) //提交请求前测试连接是否可用
    
                    .build();
    
            return doRequest(httpClient, request);
        }

    再次运行,成功解决!

    展开全文
  • 同时发送两个ajax请求, 如果第一个请求响应失败, 第二个请求的响应数据浏览器还会接收到吗?
  • springMVC整合异步请求特性

    千次阅读 2017-03-16 15:25:10
    springMVC中也整合了异步请求的特性,我们只需要配置好支持异步请求特性,然后结合java自带的回调函数处理就可以实现简单的异步请求,但是这样的异步请求往往是不能满足我们需求的,所以最终我们还是会使用比较完整...
  • HttpClient 发起请求到servlet 或者 Webservice 1.发送请求servlet,类似ajax异步调用 import java.net.HttpURLConnection; public void do(){ String url =“http://localhost:8081/servlet.do”; java...
  • 有个需求,某个异步请求函数可能被多次调用,重复调用消耗资源,需要对其进行优化 每次调用该函数都能取到返回值 只发送一次异步请求 这个和节流、防抖功能不一样,节流防抖会丢弃掉中间的请求,中间的请求获取不...
  • Servlet3-异步请求-DeferredResult

    千次阅读 2017-07-31 16:24:48
    第22章 异步请求 Servlet3.0规范新增了对异步请求的支持,spring MVC也在此基础上对异步请求提供了方便。异步请求是在处理比较耗时的业务时先将request返回,然后另起线程处理耗时的业务,处理完后再返回给用户...
  • 使用原生JS发送ajax异步请求

    千次阅读 2018-02-08 18:42:00
    Ajax Ajax: Asynchronous javaScript and xml (异步的JavaScript和xml技术)。当我们向服务器发起请求的时候,服务器不会像...异步请求:不需要其他请求结束就可以向服务器发起请求。 Ajax的优点: 1、ajax是异步...
  • DeferredResult——异步请求处理

    万次阅读 多人点赞 2018-07-12 12:59:28
    大家都知道,Callable和DeferredResult可以用来进行异步请求处理。利用它们,我们可以异步生成返回值,在具体处理的过程中,我们直接在controller中返回相应的Callable或者DeferredResult,在这之后,serv...
  • java.net  or  org.apache.http  libraries for network access, it's up to you. I've found the  java.net  libraries to be quiet pleasant to use when simply trying to issue a  GET  and read ...
  • [springboot] 异步开发之异步请求

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

    千次阅读 2017-06-13 16:00:03
    更多请移步: 我的博客第22章 异步请求Servlet3.0规范新增了对异步请求的支持,Spring MVC也在此基础上对异步请求提供了方便。异步请求是在处理比较耗时的业务时先将request返回,然后另起线程处理耗时的业务,处理...
  • AJAX技术是一种异步请求技术。它在web中主要使用在页面的局部刷新。比如某个视频网站提供了推荐视频的刷新按钮。点击它只会刷新推荐视频列表而不会刷新正在播放的视频。 随着这个前后端的分离和众多优秀的前端框架。...
  • 同步请求和异步请求的区别

    千次阅读 2019-04-01 08:50:15
    同步请求和异步请求的区别 先解释一下同步和异步的概念 同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包...
  • java发送http请求时处理异步回调结果

    万次阅读 2019-04-10 10:59:44
    //执行异步操作 请求完成后 @Override public void completed(final HttpResponse response) { latch.countDown(); //响应内容 int a = response.getStatusLine().getStatusCode(); System.out.println("状态...
  • 我正在开发一个需要连续测试1000个代理服务器的应用程序.该应用程序基于Spring Boot. 我正在使用的当前方法是@Async装饰的方法,该方法...我到处都读到Java异步的知识,人们将线程中的并行执行与无阻塞IO混合在一...
  • Java实现多线程异步处理请求Java实现多线程异步处理请求,即一个服务请求启动一个新线程处理请求,每个服务请求异步处理。 设计如下: Main:程序入口,发起多个服务请求。 Server:服务请求类,接受请求,...
  • 调用 axios 对象的方法来发起异步请求。 调用 axios 对象的方法来处理响应的数据。 案列结构 前端代码(test.html) <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8">
  • ajax异步请求防止重复提交的方法

    万次阅读 2017-10-10 12:15:14
    JS通过ajax发起异步请求时,经常会出现一个按钮快速多次点击时,请求进行了多次提交,可能导致很多不必要的问题出现,比如写入某些脏数据等。  此处针对ajax发起请求多次提交的问题进行JS代码处理的简单方法有如下...
  • 同步请求和异步请求的区别   先解释一下同步和异步的概念 同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指:发送方发出数据后,不等接收方发回响应,接着发送...
  • 如何实现异步请求

    2019-09-15 20:38:36
    在程序执行的过程中,发起一个请求,起一个线程去之前另一件事情,而且不需要该事情的返回结果。表明两个类似分支的情况, 例子如: public void doSomeThing(userId){ // 执行代码 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,366
精华内容 19,346
关键字:

java发起异步请求

java 订阅