java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java发送http请求时处理异步回调结果

java发送http请求时如何处理异步回调结果

作者:JAVA叶知秋

这篇文章主要介绍了java发送http请求时如何处理异步回调结果问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

java发送http请求时处理异步回调结果

maven依赖

<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpasyncclient</artifactId>
			<version>4.1.1</version>
		</dependency>

1.线程类 负责处理业务

package com.ruoyi.test;
 
import java.io.UnsupportedEncodingException;
 
/**
 * Created with IDEA
 * author:QinWei
 * Date:2019/4/10
 * Time:10:28
 */
public class Business extends Thread{
    // 回答1+1,很简单的问题不需要线程
    public int add(int num1, int num2) {
        return num1 + num2;
    }
 
    // 重写run方法
    @Override
    public void run() {
        // 回答地球为什么是圆的
        askquestion();
        super.run();
    }
 
    // 回调接口的创建,里面要有一个回调方法
    //回调接口什么时候用呢?这个思路是最重要的
    //
 
    public static interface Calls {
        public void call(String question);
    }
 
    // 回调接口的对象
    Calls calls;
 
    // 回答地球为什么是圆的
    private void askquestion()  {
        System.err.println("开始查找资料!");
        try {
           // 业务请求处理
            String succes = Test.main();
 
            // 把答案返回到回调接口的call方法里面
            if (calls!=null) {//提问者实例化callPhone对象,相当于提问者已经告诉我,我到时用什么方式回复答案
                //这个接口的方法实现是在提问者的类里面
                calls.call(succes);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
 
 
    }
}

2.请求接口类

package com.ruoyi.test;
 
import com.ruoyi.common.json.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;
 
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.concurrent.CountDownLatch;
 
/**
 * Created with IDEA
 * author:QinWei
 * Date:2019/4/10
 * Time:9:15
 */
public class Test {
 
    public static String main() throws UnsupportedEncodingException {
        final String[] resData = new String[1];
        CloseableHttpAsyncClient client = HttpAsyncClients.createDefault();
        client.start();
        final CountDownLatch latch = new CountDownLatch(1);
        final HttpPost post = new HttpPost("http://127.0.0.1:8088/login");
        String param1="loginName=6210308024916652&password=123456&captcha=10";
        JSONObject param2= new JSONObject();
        param2.put("loginName", "6210308024916652");
        param2.put("password", "123456");
        param2.put("captcha", "4");
        //设置请求头    这里根据个人来定义
        post.addHeader("Content-type", "application/json; charset=utf-8");
        post.setHeader("Accept", "application/json");
        StringEntity stringEntity = new StringEntity(param2.toString());
        post.setEntity(stringEntity);
        //执行
        client.execute(post, new FutureCallback<HttpResponse>() {
            //执行异步操作  请求完成后
            @Override
            public void completed(final HttpResponse response) {
                latch.countDown();
                //响应内容
                int a = response.getStatusLine().getStatusCode();
                System.out.println("状态码:"+a);
                if (a == 200) {
                    HttpEntity entity = response.getEntity();
                    try {
                        resData[0] = EntityUtils.toString(entity);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println("成功!");
                } else {
                    try {
                        //输出响内容
                        System.out.println(response.getStatusLine().getStatusCode()
                                + "  " + EntityUtils.toString(response.getEntity(), "UTF-8"));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
 
            //请求失败处理
            @Override
            public void failed(final Exception ex) {
                latch.countDown();
            }
 
            //请求取消后处理
            @Override
            public void cancelled() {
                latch.countDown();
            }
 
        });
 
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //关闭
        try {
            client.close();
        } catch (IOException ignore) {
 
        }
        return resData[0];
    }
}

3.测试类

package com.ruoyi.test;
 
/**
 * Created with IDEA
 * author:QinWei
 * Date:2019/4/10
 * Time:10:28
 */
public class MainClass {
 
    /**
     * java回调方法的使用
     * 实际操作时的步骤:(以本实例解释)
     * 1.在回答者的类内创建回调的接口
     * 2.在回答者的类内创建回调接口的对象,
     * 3.在提问者类里面实例化接口对象,重写接口方法
     * 2.-3.这个点很重要,回调对象的实例化,要在提问者的类内实例化,然后重写接口的方法
     * 相当于提问者先把一个联络方式给回答者,回答者找到答案后,通过固定的联络方式,来告诉提问者答案。
     * 4.调用开始新线程的start方法
     * 5.原来的提问者还可以做自己的事
     * */
    public static void main(String[] args) {
        // 小王问小张1+1=?,线程同步
        Business xiaoZhang = new Business();
        int i = xiaoZhang.add(1, 1);//回答1+1的答案
 
        // 问小张地球为什么是圆的?回调方法的使用
        //这相当于先定好一个返答案的方式,再来执行实际操作
 
        // 实例化回调接口的对象
        Business.Calls call = new Business.Calls() {
            @Override
            public void call(String question) {
                //回答问题者,回答后,才能输出答案
                System.err.println(question);
            }
        };
 
        //把回调对象赋值给回答者的回调对象,回答问题者的回调对象才能回答问题
        xiaoZhang.calls = call;
 
        System.out.println("吩咐完毕!");
        //相关交代完毕之后再执行查询操作
        xiaoZhang.start();
 
        //小王做自己的事!
        System.out.println("处理自己的业务");
    }
}

4.请求结果

总结

1.最好在服务端做一个sleep等待,这样可以更好的模拟效果

2.开启一个子线程去执行请求不影响主线程运行,请求完毕后回调给用户

3.还有很多实现异步回调方式,就不多赘述了

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文