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.还有很多实现异步回调方式，希望大家评论留言

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

猜你喜欢