Android 封装HttpURLConnection网络请求

最新推荐文章于 2024-07-27 14:51:42 发布
最新推荐文章于 2024-07-27 14:51:42 发布
阅读量701 收藏 5
点赞数 2
分类专栏： 网络请求 文章标签： 网络 java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48440239/article/details/118570574
版权

本次封装只针对get和post请求。

需要的权限和依赖

<uses-permission android:name="android.permission.INTERNET"/>

implementation 'com.google.code.gson:gson:2.8.5'

准备工作：

public class HttpCode {
    public static final int CODE_200 = 200;

    public static final int CODE_9999 = 9999;

    public static final String CODE_9999_MSG = "网络或系统异常";
}

定义错误码和提示信息。

public class NetConstant {
    public static final String NULL = "null";
    public static final String NULL_SLASH = "\"null\"";
}

保证接收消息不为null要用到的。

public class RequestEntity implements Serializable {

    private static final String REQUEST_SUFFIX = "Request";

    public String getUrlName() {
        String clsName = this.getClass().getSimpleName();
        if (clsName.endsWith(REQUEST_SUFFIX)) {
            String action = clsName.substring(0, clsName.length() - 7);
            return action.substring(0, 1).toLowerCase()+ action.substring(1);
        } else {
            return clsName.substring(0, 1).toLowerCase()+ clsName.substring(1);
        }
    }
}

public class ResponseEntity implements Serializable {
    /**
     * 响应码
     */
    private int code;
    /**
     * 提示消息
     */
    private String msg;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

RequestEntity和ResponseEntity分别时请求体和接收数据的基类。

public class FilterGson extends MyGson {

    /**
     * 过滤字段
     */
    private static String[] filterFields = {};

    public FilterGson() {
        super(filter());
    }

    private static Gson filter() {
        return new GsonBuilder().addSerializationExclusionStrategy(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes f) {
                for (String exclude : filterFields) {
                    if (exclude.equals(f.getName())) {
                        return true;
                    }
                }
                return false;
            }

            @Override
            public boolean shouldSkipClass(Class<?> clazz) {
                return false;
            }
        }).create();
    }
}

FilterGson的filterFields用来过滤字段

public class JsonParse {

    private ResponseEntity responseEntity;
    private Object responseBodyResult;

    public ResponseEntity getResponseEntity() {
        return responseEntity;
    }

    public Object getResponseBodyResult() {
        return responseBodyResult;
    }

    /**
     * 请求体转请求json字符串
     *
     * @param requestEntity 请求对象
     * @return params字符串
     */
    public String toGetJson(RequestEntity requestEntity) {
        StringBuilder params = new StringBuilder("?");
        try {
            Class cls = requestEntity.getClass();
            Field[] fields = cls.getDeclaredFields();
            for (Field field : fields) {
                params.append(field.getName());
                params.append("=");
                params.append(field.get(requestEntity));
                params.append("&");
            }

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return params.substring(0, params.length() - 1);
    }
    /**
     * 请求体转 请求json字符串
     *
     * @param requestEntity 请求消息体
     * @return json字符串
     */
    public String toPostJson(RequestEntity requestEntity) {
        return new FilterGson().toJson(requestEntity);
    }

    /**
     * 解析json 转对象 包括：请求头、请求体、解密
     *
     * @param json 完整的json字符串
     * @param type 对象类型
     */
    public void parseJson(String json, Type type, HttpConnectionManager.BaseResultCallback callback) {
        try {
            JSONObject jsonObject = new JSONObject(json);
            responseEntity = new FilterGson().fromJson(json, ResponseEntity.class);
            if (callback.isSuccess(responseEntity.getCode())) {
                String jsonBody = jsonObject.get("data").toString();
                if (NetConstant.NULL.equals(jsonBody) || NetConstant.NULL_SLASH.equals(jsonBody)) {
                    try {
                        jsonBody = "{}";
                        responseBodyResult = new FilterGson().fromJson(jsonBody, type);
                    } catch (Exception e) {
                        jsonBody = "[]";
                        responseBodyResult = new FilterGson().fromJson(jsonBody, type);
                    }
                }else {
                    responseBodyResult = new FilterGson().fromJson(jsonBody, type);
                }
                if (responseBodyResult == null) {
                    responseEntity.setCode(HttpCode.CODE_9999);
                    responseEntity.setMsg(HttpCode.CODE_9999_MSG);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            responseEntity.setCode(HttpCode.CODE_9999);
            responseEntity.setMsg(HttpCode.CODE_9999_MSG);
        }
    }
}

public class MyGson {

    private Gson gson;

    public MyGson() {
        this.gson = new Gson();
    }

    public MyGson(Gson gson) {
        this.gson = gson;
    }

    public <T> T fromJson(String json, Type typeOfT) {
        try {
            return gson.fromJson(json, typeOfT);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
            return null;
        }
    }

    public String toJson(Object src) {
        return gson.toJson(src);
    }
}

负责具体的数据解析。

主体：

public class HttpConnectionManager {

    private ThreadPoolExecutor threadPoolExecutor;
    private Handler mHandler;

    private HttpConnectionManager() {

    }

    public static HttpConnectionManager getInstance() {
        return HttpHolder.HTTP_CONNECTION_MANAGER;
    }

    private static class HttpHolder {
        private static final HttpConnectionManager HTTP_CONNECTION_MANAGER = new HttpConnectionManager();
    }

    /**
     * 初始化线程池
     */
    public synchronized void init() {
        if (null == threadPoolExecutor) {
            threadPoolExecutor = new ThreadPoolExecutor(3, 5, 0L, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<Runnable>(), new CheckThreadFactory());
        }
        if (null == mHandler) {
            mHandler = new Handler(Looper.getMainLooper());
        }
    }

    /**
     * get请求
     *
     * @param url           地址
     * @param requestEntity 请求体
     */
    public void get(final String url, RequestEntity requestEntity, final BaseResultCallback callback) {
        final String params = new JsonParse().toGetJson(requestEntity);
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                HttpURLConnection mHttpUrlConnection = null;
                try {
                    URL mUrl = new URL(url + params);
                    mHttpUrlConnection = (HttpURLConnection) mUrl.openConnection();
                    //设置连接超时时间
                    mHttpUrlConnection.setConnectTimeout(15000);
                    //设置读取超时时间
                    mHttpUrlConnection.setReadTimeout(15000);
                    //设置请求方式
                    mHttpUrlConnection.setRequestMethod("GET");
                    //添加Header
                    mHttpUrlConnection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
                    // 设置输入可用
                    mHttpUrlConnection.setDoInput(true);
                    // 设置输出可用
                    mHttpUrlConnection.setDoOutput(true);
                    // 设置缓存不可用
                    mHttpUrlConnection.setUseCaches(false);
                    //开始连接
                    mHttpUrlConnection.connect();

                    int responseCode = mHttpUrlConnection.getResponseCode();
                    if (responseCode == HttpURLConnection.HTTP_OK) {
                        InputStream inputStream = mHttpUrlConnection.getInputStream();
                        String result = inputStreamString(inputStream);
                        if (null != result && null != callback) {
                            JsonParse jsonParse = new JsonParse();
                            jsonParse.parseJson(result, callback.mType, callback);
                            ResponseEntity responseEntity = jsonParse.getResponseEntity();
                            if (HttpCode.CODE_200 == responseEntity.getCode() || callback.isSuccess(responseEntity.getCode())) {
                                sendSuccessCallBack(callback, jsonParse.getResponseBodyResult());
                            } else {
                                sendFailCallback(callback, responseEntity.getCode(), responseEntity.getMsg());
                            }
                        } else {
                            sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                        }
                    } else {
                        sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                } finally {
                    if (null != mHttpUrlConnection) {
                        mHttpUrlConnection.disconnect();
                    }
                }
            }
        });
    }

    public void post(final String url, RequestEntity requestEntity, final BaseResultCallback callback) {
        final String json = new JsonParse().toPostJson(requestEntity);
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                HttpURLConnection mHttpUrlConnection = null;
                try {
                    URL mUrl = new URL(url);
                    mHttpUrlConnection = (HttpURLConnection) mUrl.openConnection();
                    //设置连接超时时间
                    mHttpUrlConnection.setConnectTimeout(15000);
                    //设置读取超时时间
                    mHttpUrlConnection.setReadTimeout(15000);
                    //设置请求方式
                    mHttpUrlConnection.setRequestMethod("POST");
                    //添加Header
                    mHttpUrlConnection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
                    // 设置输入可用
                    mHttpUrlConnection.setDoInput(true);
                    // 设置输出可用
                    mHttpUrlConnection.setDoOutput(true);
                    // 设置缓存不可用
                    mHttpUrlConnection.setUseCaches(false);
                    //开始连接
                    mHttpUrlConnection.connect();

                    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(mHttpUrlConnection.getOutputStream(), "UTF-8"));
                    writer.write(json);
                    writer.close();

                    int responseCode = mHttpUrlConnection.getResponseCode();
                    if (responseCode == HttpURLConnection.HTTP_OK) {
                        InputStream inputStream = mHttpUrlConnection.getInputStream();
                        String result = inputStreamString(inputStream);
                        if (null != result && null != callback) {
                            JsonParse jsonParse = new JsonParse();
                            jsonParse.parseJson(result, callback.mType, callback);
                            ResponseEntity responseEntity = jsonParse.getResponseEntity();
                            if (HttpCode.CODE_200 == responseEntity.getCode() || callback.isSuccess(responseEntity.getCode())) {
                                sendSuccessCallBack(callback, jsonParse.getResponseBodyResult());
                            } else {
                                sendFailCallback(callback, responseEntity.getCode(), responseEntity.getMsg());
                            }
                        }else {
                            sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                        }
                    } else {
                        sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    sendFailCallback(callback, HttpCode.CODE_9999, HttpCode.CODE_9999_MSG);
                } finally {
                    if (null != mHttpUrlConnection) {
                        mHttpUrlConnection.disconnect();
                    }
                }
            }
        });
    }

    /**
     * UI线程中执行操作成功回调
     *
     * @param callback     回调类
     * @param responseBody 服务器响应的body
     */
    private void sendSuccessCallBack(final BaseResultCallback callback, final Object responseBody) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (null != callback) {
                    callback.onSuccess(responseBody);
                }
            }
        });
    }

    /**
     * UI线程中执行操作失败回调
     *
     * @param callback 回调类
     * @param code     错误码
     * @param msg      错误信息
     */
    private void sendFailCallback(final BaseResultCallback callback, final int code, final String msg) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (null != callback) {
                    callback.onFailure(code, msg);
                }
            }
        });
    }

    /**
     * 字节流转换成字符串
     *
     * @param inputStream 输入流
     * @return 字符串
     */
    private String inputStreamString(InputStream inputStream) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        byte[] bytes = new byte[1024];
        int len;
        try {
            while (-1 != (len = inputStream.read(bytes))) {
                outputStream.write(bytes, 0, len);
            }
            return new String(outputStream.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private static class CheckThreadFactory implements ThreadFactory {

        private AtomicInteger atomicInteger = new AtomicInteger();

        @Override
        public Thread newThread(@NonNull Runnable r) {
            int index = atomicInteger.incrementAndGet();
            System.out.println("create no " + index + " thread");
            return new Thread(r, "Thread-" + index);
        }
    }

    /**
     * http请求回调类,回调方法在UI线程中执行
     *
     * @param <T> ResponseBody的子类
     */
    public static abstract class BaseResultCallback<T> {
        Type mType;

        public BaseResultCallback() {
            mType = getSuperclassTypeParameter(getClass());
        }

        static Type getSuperclassTypeParameter(Class<?> subclass) {
            Type superclass = subclass.getGenericSuperclass();
            if (superclass instanceof Class) {
                throw new RuntimeException("Enter generics in BaseResultCallback");
            }
            ParameterizedType parameterized = (ParameterizedType) superclass;
            return parameterized.getActualTypeArguments()[0];
        }

        /**
         * 判断服务器返回code是否为成功
         *
         * @param code 返回码
         * @return 是否成功
         */
        public boolean isSuccess(int code) {
            return HttpCode.CODE_200 == code;
        }

        /**
         * 请求成功回调
         *
         * @param result 响应结果实体或集合
         */
        public abstract void onSuccess(T result);

        /**
         * 请求失败回调
         *
         * @param code 错误码
         * @param msg  失败原因
         */
        public abstract void onFailure(int code, String msg);
    }
}

HttpManager

public class HttpManager {

    public static void init(String ip, String post) {
        HttpConnectionManager.getInstance().init();
        baseIp = ip;
        basePort = post;
    }

    private static String baseIp;
    private static String basePort;

    private static String getRequestUrl(String action) {
        String baseUrl = "http://%s:%s/online/%s/";
        return String.format(baseUrl, baseIp, basePort, action);
    }

    public static void get(RequestEntity requestEntity, HttpConnectionManager.BaseResultCallback callback) {
        HttpConnectionManager.getInstance().get(getRequestUrl(requestEntity.getUrlName()), requestEntity, callback);
    }

    public static void post(RequestEntity requestEntity, HttpConnectionManager.BaseResultCallback callback) {
        HttpConnectionManager.getInstance().post(getRequestUrl(requestEntity.getUrlName()), requestEntity, callback);
    }
}

到这就算封装完成。

例子：

首先初始化

public class BaseApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        HttpManager.init("ip", "port");
    }
}

然后创建实体

public class LoginRequest extends RequestEntity {
    public String userName;
    public String password;
}

public class LoginResponse extends ResponseEntity {
  public String username;
  public String uid;
  public String rolename；
  public String rid;
}

最后调用

 LoginRequest loginRequest = new LoginRequest();
        loginRequest.userName = "张三";
        loginRequest.password = MD5("123456");
        HttpManager.post(loginRequest, new HttpConnectionManager.BaseResultCallback<LoginResponse>() {
            @Override
            public void onSuccess(LoginResponse result) {
                Log.d("===",result.user.username);
            }

            @Override
            public void onFailure(int code, String msg) {

            }
        });
asahi_xin
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简单封装HttpUrlConnection异步请求
u010963053的博客
04-02 2188
package com.zwk.ezandroid.common; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.util.Log; import com.zwk.ezandroid.App; import com.zwk.ezandroid.com...
Android-HttpURLConnection:一款封装HttpURLConnection实现的简单的网络请求的事例
05-30
Android-HttpURLConnection说明lib-http 后续不再单独在此维护，统一合并到AndroidAppFactory 中继续维护，对应Git地址为：AndroidAppFactory：对应组件库为：LibHttpCommon & LibHttpAdvanced调用事例参考：简介一...
android httpurlconnection封装,Android HttpURLConnection 封装
weixin_35668158的博客
05-26 364
初始化HttpURLConnectionpublic HttpURLConnection initHttp(String url, String method, Map headers)throws IOException {URL _url =new URL(url);HttpURLConnection http = (HttpURLConnection) _url.openConnection...
Android中封装OkHttp，处理网络请求
zhangsp_dev_dxdc的博客
06-25 174
Android中封装OkHttp，处理网络请求
Android发起HttpURLConnection网络请求
探索丶挑战丶突破
02-27 979
文章作者：总李写代码 文章出处：https://www.cnblogs.com/whoislcj/p/5520384.html Android发起HttpURLConnection网络请求一、前言二、HttpURLConnection介绍三、HttpURLConnection实例1、Get请求实现2、 POST请求实现3、处理网络流：将输入流转换成字符串（工具方法必加）4、 文件下载5、文件上...
android 网络访问封装,Android访问网络HttpURLConnection OkHttp 封装
weixin_35850219的博客
05-25 152
Android中常用的应用都会大量使用网络，比如QQ、微信、访问网页等等。通过使用网络，可以展示网页，发起Http请求获取数据或提交数据。WebView控件有时我们可能需要让我们自己的应用展示网页，我们可以使用Android内置的控件WebView。public class MainActivity extends AppCompatActivity {@Overrideprotected voi...
Android 网络请求 HttpURLConnection 原生网络请求
Mr_Liangxiaobai的博客
01-31 699
HttpURLConnection package com.example.administrator.words.http; import android.os.AsyncTask; import android.text.TextUtils; import android.util.Log; import com.example.administrator.words.util.ToastUtil; import com.google.gson.Gson; import java.io..
Android安卓HttpUrlConnection请求POST,GET封装
qq_37196621的博客
11-03 554
新建httpfun类 2.新建一个receive接口 3.接口内代码 package com.example.httpurlconnectionfun;public interface Receive { void onFinish(String data); void onError(Exception e);} 4.httpfun类内代码 public class HttpFun { public static void sendH...
Android 使用HttpURLConnection网络请求，通过JSONObject 解析Json数据
u012514113的专栏
02-26 3905
项目场景： 在Android系统app源码里面做一个网络请求的需求，由于是系统级别的App（如：Settings， SystemUI）,有很多方便的网络请求，数据解析第三方库（如：com.squareup.okhttp3， com.google.code.gson）无法直接使用 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override public void run() { byte....
HttpURLConnection封装
www？的博客
04-04 963
HttpURLConnection封装 思考： 如果在一个应用程序中需要多次使用网络功能，而发送HTTP请求的代码基本都是相同的，难道我们每次都要去编写一遍发送HTTP请求的代码？ 解决办法：封装 方式一： 将通用的网络操作提取到一个公共类中，外提供一个静态方法。 public class HttpUtil{ //通过sendHttpRequest() 发送HTTP请求 //返回数据类型为String public static String sendHttpRequest(
Android HttpUrlConnection 实现 post 请求
记录移动开发相关的知识
08-01 1974
Android中经常会用到使用post方式请求json格式的数据。请求参数也是json格式的数据，在这里封装一下，方便日后查找。
Android网络请求框架基于HttpUrlConnection的封装
12-05
在封装HttpUrlConnection时，我们需要考虑以下几个方面： 1. **异步处理**：为了不阻塞主线程，通常会采用AsyncTask、Handler、RxJava等手段实现网络请求的异步化。 2. **错误处理**：包括网络异常、超时、状态码...
android 网络请求封装
08-18
以下是一些关于“Android网络请求封装”的详细知识点： 1. **异步网络请求**： - Android中的网络操作必须在非UI线程中执行，否则会导致ANR（Application Not Responding）错误。因此，通常使用AsyncTask、Handler...
Android中HttpURLConnection与HttpClient的使用与封装
01-05
 本文并不针对HTTP协议的具体内容，仅探讨android开发中使用HTTP协议访问网络的两种方式——HttpURLConnection和HttpClient  因为需要访问网络，需在AndroidManifest.xml中添加如下权限 <uses android:name=...
Android封装的http请求实用工具类
09-04
`NetUtils` 类是 Android 平台上用于封装 HTTP 请求的实用工具类，它主要提供了 GET 和 POST 两种常见的网络请求方法，并且包含了一个检查网络连接是否可用的辅助方法。这个工具类通常在 Android 应用开发中用于与...
Linux网络工具“瑞士军刀“集合
分享不一样的技术，与你一起共同成长!
07-26 308
下面结合之前的一些使用经验为大家介绍一下一些经典应用场景下，这个网络命令工具如何使用的。例如怎么查看当前服务器监听哪些端口、连接目标主机端口情况如何?平常我们在进行Linux服务器相关运维的时候，总会遇到一些网络相关的问题。我们可以借助这些小巧、功能强悍的工具帮助我们排查问题、解决问题...
S5730举例
最新发布
jjjxxxhhh123的博客
07-27 779
例子： 假设在校园网络中，某些交换机之间存在多个连接（可能是多个光纤），如果没有STP，这些多个连接可能导致数据包在网络中无限制地传输，形成网络风暴，导致整个网络瘫痪。PIM-SM通过仅在需要时在网络中传输组播数据包，减少网络带宽的占用，提高数据传输效率。[sysname-GigabitEthernet0/0/1] ospf cost 10 // 设置接口的OSPF成本，影响路径选择。综上所述，这些网络技术和配置在大学校园网络中起到关键作用，确保网络运行高效、安全和可靠，同时满足用户的多样化需求。
DNS域名管理系统、搭建DNS服务
十四的博客
07-23 940
DNS概述。
Android网络请求封装示例
07-27
Android网络请求可以使用HttpURLConnection类进行封装，以简化代码量。首先，需要在AndroidManifest.xml文件中配置网络权限，包括ACCESS_NETWORK_STATE和INTERNET权限。\[2\]接下来，可以创建一个自定义的网络请求类，例如MyRequest。在该类中，可以定义一个post方法来发送POST请求。\[3\]在该方法中，可以使用HttpURLConnection类来建立连接，并设置请求的URL和请求方法为POST。然后，可以设置请求的参数，并将其写入输出流中。接着，可以获取服务器的响应，并将其读取为字符串。最后，可以返回响应结果。通过这种方式，可以封装网络请求的过程，使其更加简洁和易于使用。 #### 引用[.reference_title] - *1* *2* *3* [Android studio 发起网络请求（GET、POST）网络请求的二次封装](https://blog.csdn.net/qq_45834492/article/details/118147284)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值