封装的OkHttp

最新推荐文章于 2023-02-26 23:16:28 发布
最新推荐文章于 2023-02-26 23:16:28 发布
阅读量152 收藏
点赞数
分类专栏： 安卓 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29074895/article/details/103060749
版权

封装的OkHttp 可以直接使用 包含了 同步异步的get。post请求，文件以及图片的操作

废话不多说 上代码

package com.example.okhttpmanager;

import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.widget.ImageView;

import com.google.gson.Gson;
import com.google.gson.internal. G s o n Gson GsonTypes;
import com.squareup.okhttp.Call;
import com.squareup.okhttp.Callback;
import com.squareup.okhttp.FormEncodingBuilder;
import com.squareup.okhttp.Headers;
import com.squareup.okhttp.MediaType;
import com.squareup.okhttp.MultipartBuilder;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.Request;
import com.squareup.okhttp.RequestBody;
import com.squareup.okhttp.Response;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.net.CookieManager;
import java.net.CookiePolicy;
import java.net.FileNameMap;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

  • Created by hyj 2019 11 14
    */
    public class OkHttpClientManager {
    private static OkHttpClientManager mInstance;
    private OkHttpClient mOkHttpClient;
    private Handler mDelivery;
    private Gson mGson;

    private static final String TAG = “OkHttpClientManager”;

    @SuppressLint(“NewApi”)
    private OkHttpClientManager() {
    mOkHttpClient = new OkHttpClient();
    // cookie enabled
    mOkHttpClient.setCookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER));
    mOkHttpClient.setConnectTimeout(30000, TimeUnit.SECONDS);
    mDelivery = new Handler(Looper.getMainLooper());
    mGson = new Gson();
    }

    public static OkHttpClientManager getInstance() {
    if (mInstance == null) {
    synchronized (OkHttpClientManager.class) {
    if (mInstance == null) {
    mInstance = new OkHttpClientManager();
    }
    }
    }
    return mInstance;
    }

    /**

    • 同步的Get请求
    • @param url
    • @return Response
      */
      private Response _getAsyn(String url) throws IOException {
      final Request request = new Request.Builder().url(url).build();
      Call call = mOkHttpClient.newCall(request);
      Response execute = call.execute();
      return execute;
      }

    /**

    • 同步的Get请求
    • @param url
    • @return 字符串
      */
      private String _getAsString(String url) throws IOException {
      Response execute = _getAsyn(url);
      return execute.body().string();
      }

    /**

    • 异步的get请求
    • @param url
    • @param callback
      */
      private void _getAsyn(String url, final ResultCallback callback) {
      final Request request = new Request.Builder().url(url).build();
      deliveryResult(callback, request);
      }

    /**

    • 同步的Post请求
    • @param url
    • @param params
    •        post的参数
    • @return
      */
      private Response _post(String url, Param… params) throws IOException {
      Request request = buildPostRequest(url, params);
      Response response = mOkHttpClient.newCall(request).execute();
      return response;
      }

    /**

    • 同步的Post请求
    • @param url
    • @param params
    •        post的参数
    • @return 字符串
      */
      private String _postAsString(String url, Param… params) throws IOException {
      Response response = _post(url, params);
      return response.body().string();
      }

    /**

    • 异步的post请求
    • @param url
    • @param callback
    • @param params
      */
      private void _postAsyn(String url, final ResultCallback callback, Param… params) {
      Request request = buildPostRequest(url, params);
      deliveryResult(callback, request);
      }

    /**

    • 异步的post请求
    • @param url
    • @param callback
    • @param params
      */
      private void _postAsyn(String url, final ResultCallback callback, Map<String, String> params) {
      Param[] paramsArr = map2Params(params);
      Request request = buildPostRequest(url, paramsArr);
      deliveryResult(callback, request);
      }

    /**

    • 同步基于post的文件上传
    • @param params
    • @return
      */
      private Response _post(String url, File[] files, String[] fileKeys, Param… params) throws IOException {
      Request request = buildMultipartFormRequest(url, files, fileKeys, params);
      return mOkHttpClient.newCall(request).execute();
      }

    private Response _post(String url, File file, String fileKey) throws IOException {
    Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, null);
    return mOkHttpClient.newCall(request).execute();
    }

    private Response _post(String url, File file, String fileKey, Param… params) throws IOException {
    Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, params);
    return mOkHttpClient.newCall(request).execute();
    }

    /**

    • 异步基于post的文件上传
    • @param url
    • @param callback
    • @param files
    • @param fileKeys
    • @throws IOException
      */
      private void _postAsyn(String url, ResultCallback callback, File[] files, String[] fileKeys, Param… params)
      throws IOException {
      Request request = buildMultipartFormRequest(url, files, fileKeys, params);
      deliveryResult(callback, request);
      }

    /**

    • 异步基于post的文件上传，单文件不带参数上传
    • @param url
    • @param callback
    • @param file
    • @param fileKey
    • @throws IOException
      */
      private void _postAsyn(String url, ResultCallback callback, File file, String fileKey) throws IOException {
      Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, null);
      deliveryResult(callback, request);
      }

    /**

    • 异步基于post的文件上传，单文件且携带其他form参数上传
    • @param url
    • @param callback
    • @param file
    • @param fileKey
    • @param params
    • @throws IOException
      */
      private void _postAsyn(String url, ResultCallback callback, File file, String fileKey, Param… params)
      throws IOException {
      Request request = buildMultipartFormRequest(url, new File[] { file }, new String[] { fileKey }, params);
      deliveryResult(callback, request);
      }

    /**

    • 异步下载文件

    • @param url

    • @param destFileDir

    •        本地文件存储的文件夹

    • @param callback
      */
      private void _downloadAsyn(final String url, final String destFileDir, final ResultCallback callback) {
      final Request request = new Request.Builder().url(url).build();
      final Call call = mOkHttpClient.newCall(request);
      call.enqueue(new Callback() {
      @Override
      public void onFailure(final Request request, final IOException e) {
      sendFailedStringCallback(request, e, callback);
      }

       @Override
 public void onResponse(Response response) {
 	InputStream is = null;
 	byte[] buf = new byte[2048];
 	int len = 0;
 	FileOutputStream fos = null;
 	try {
 		is = response.body().byteStream();
 		File file = new File(destFileDir, getFileName(url));
 		fos = new FileOutputStream(file);
 		while ((len = is.read(buf)) != -1) {
 			fos.write(buf, 0, len);
 		}
 		fos.flush();
 		// 如果下载文件成功，第一个参数为文件的绝对路径
 		sendSuccessResultCallback(file.getAbsolutePath(), callback);
 	} catch (IOException e) {
 		sendFailedStringCallback(response.request(), e, callback);
 	} finally {
 		try {
 			if (is != null)
 				is.close();
 		} catch (IOException e) {
 		}
 		try {
 			if (fos != null)
 				fos.close();
 		} catch (IOException e) {
 		}
 	}

 }

      });
      }

    private String getFileName(String path) {
    int separatorIndex = path.lastIndexOf("/");
    return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());
    }

    /**

    • 加载图片

    • @param view

    • @param url

    • @throws IOException
      */
      private void _displayImage(final ImageView view, final String url, final int errorResId) {
      final Request request = new Request.Builder().url(url).build();
      Call call = mOkHttpClient.newCall(request);
      call.enqueue(new Callback() {
      @Override
      public void onFailure(Request request, IOException e) {
      setErrorResId(view, errorResId);
      }

       @Override
 public void onResponse(Response response) {
 	InputStream is = null;
 	try {
 		is = response.body().byteStream();
 		ImageUtils.ImageSize actualImageSize = ImageUtils.getImageSize(is);
 		ImageUtils.ImageSize imageViewSize = ImageUtils.getImageViewSize(view);
 		int inSampleSize = ImageUtils.calculateInSampleSize(actualImageSize, imageViewSize);
 		try {
 			is.reset();
 		} catch (IOException e) {
 			response = _getAsyn(url);
 			is = response.body().byteStream();
 		}

 		BitmapFactory.Options ops = new BitmapFactory.Options();
 		ops.inJustDecodeBounds = false;
 		ops.inSampleSize = inSampleSize;
 		final Bitmap bm = BitmapFactory.decodeStream(is, null, ops);
 		mDelivery.post(new Runnable() {
 			@Override
 			public void run() {
 				view.setImageBitmap(bm);
 			}
 		});
 	} catch (Exception e) {
 		setErrorResId(view, errorResId);

 	} finally {
 		if (is != null)
 			try {
 				is.close();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 	}
 }

      });

    }

    private void setErrorResId(final ImageView view, final int errorResId) {
    mDelivery.post(new Runnable() {
    @Override
    public void run() {
    view.setImageResource(errorResId);
    }
    });
    }

    // *对外公布的方法

    public static Response getAsyn(String url) throws IOException {
    return getInstance()._getAsyn(url);
    }

    public static String getAsString(String url) throws IOException {
    return getInstance()._getAsString(url);
    }

    public static void getAsyn(String url, ResultCallback callback) {
    getInstance()._getAsyn(url, callback);
    }

    public static Response post(String url, Param… params) throws IOException {
    return getInstance()._post(url, params);
    }

    public static String postAsString(String url, Param… params) throws IOException {
    return getInstance()._postAsString(url, params);
    }

    public static void postAsyn(String url, final ResultCallback callback, Param… params) {
    getInstance()._postAsyn(url, callback, params);
    }

    public static void postAsyn(String url, final ResultCallback callback, Map<String, String> params) {
    getInstance()._postAsyn(url, callback, params);
    }

    public static Response post(String url, File[] files, String[] fileKeys, Param… params) throws IOException {
    return getInstance()._post(url, files, fileKeys, params);
    }

    public static Response post(String url, File file, String fileKey) throws IOException {
    return getInstance()._post(url, file, fileKey);
    }

    public static Response post(String url, File file, String fileKey, Param… params) throws IOException {
    return getInstance()._post(url, file, fileKey, params);
    }

    public static void postAsyn(String url, ResultCallback callback, File[] files, String[] fileKeys, Param… params)
    throws IOException {
    getInstance()._postAsyn(url, callback, files, fileKeys, params);
    }

    public static void postAsyn(String url, ResultCallback callback, File file, String fileKey) throws IOException {
    getInstance()._postAsyn(url, callback, file, fileKey);
    }

    public static void postAsyn(String url, ResultCallback callback, File file, String fileKey, Param… params)
    throws IOException {
    getInstance()._postAsyn(url, callback, file, fileKey, params);
    }

    public static void displayImage(final ImageView view, String url, int errorResId) throws IOException {
    getInstance()._displayImage(view, url, errorResId);
    }

    public static void displayImage(final ImageView view, String url) {
    getInstance()._displayImage(view, url, -1);
    }

    public static void downloadAsyn(String url, String destDir, ResultCallback callback) {
    getInstance()._downloadAsyn(url, destDir, callback);
    }

    // ****************************

    private Request buildMultipartFormRequest(String url, File[] files, String[] fileKeys, Param[] params) {
    params = validateParam(params);

     MultipartBuilder builder = new MultipartBuilder().type(MultipartBuilder.FORM);

 for (Param param : params) {
 	builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + param.key + "\""),
 			RequestBody.create(null, param.value));
 }
 if (files != null) {
 	RequestBody fileBody = null;
 	for (int i = 0; i < files.length; i++) {
 		File file = files[i];
 		String fileName = file.getName();
 		fileBody = RequestBody.create(MediaType.parse(guessMimeType(fileName)), file);
 		// TODO 根据文件名设置contentType
 		builder.addPart(Headers.of("Content-Disposition",
 				"form-data; name=\"" + fileKeys[i] + "\"; filename=\"" + fileName + "\""), fileBody);
 	}
 }

 RequestBody requestBody = builder.build();
 return new Request.Builder().url(url).post(requestBody).build();

    }

    private String guessMimeType(String path) {
    FileNameMap fileNameMap = URLConnection.getFileNameMap();
    String contentTypeFor = fileNameMap.getContentTypeFor(path);
    if (contentTypeFor == null) {
    contentTypeFor = “application/octet-stream”;
    }
    return contentTypeFor;
    }

    private Param[] validateParam(Param[] params) {
    if (params == null)
    return new Param[0];
    else
    return params;
    }

    private Param[] map2Params(Map<String, String> params) {
    if (params == null)
    return new Param[0];
    int size = params.size();
    Param[] res = new Param[size];
    Set<Map.Entry<String, String>> entries = params.entrySet();
    int i = 0;
    for (Map.Entry<String, String> entry : entries) {
    res[i++] = new Param(entry.getKey(), entry.getValue());
    }
    return res;
    }

    private static final String SESSION_KEY = “Set-Cookie”;
    private static final String mSessionKey = “JSESSIONID”;

    private Map<String, String> mSessions = new HashMap<String, String>();

    private void deliveryResult(final ResultCallback callback, Request request) {
    mOkHttpClient.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(final Request request, final IOException e) {
    sendFailedStringCallback(request, e, callback);
    Log.e(“OkHttpClientManager”, “onFailure===z” + request.toString());

     	}

 	@Override
 	public void onResponse(final Response response) {
 		try {
 			final String string = response.body().string();
 			Log.e("OkHttpClientManager", "onResponse===" + response.toString());
 			Log.e("OkHttpClientManager", "json===" + string.toString());
 			if (callback.mType == String.class) {
 				sendSuccessResultCallback(string, callback);
 			} else {
 				Object o = mGson.fromJson(string, callback.mType);
 				sendSuccessResultCallback(o, callback);
 			}

 		} catch (IOException e) {
 			sendFailedStringCallback(response.request(), e, callback);
 		} catch (com.google.gson.JsonParseException e)// Json解析的错误
 		{
 			sendFailedStringCallback(response.request(), e, callback);
 		}

 	}
 });

    }

    private void sendFailedStringCallback(final Request request, final Exception e, final ResultCallback callback) {
    mDelivery.post(new Runnable() {
    @Override
    public void run() {
    if (callback != null)
    callback.onError(request, e);
    }
    });
    }

    private void sendSuccessResultCallback(final Object object, final ResultCallback callback) {
    mDelivery.post(new Runnable() {
    @Override
    public void run() {
    if (callback != null) {
    callback.onResponse(object);
    }
    }
    });
    }

    private Request buildPostRequest(String url, Param[] params) {
    if (params == null) {
    params = new Param[0];
    }
    FormEncodingBuilder builder = new FormEncodingBuilder();
    for (Param param : params) {
    builder.add(param.key, param.value);
    }
    RequestBody requestBody = builder.build();
    return new Request.Builder().url(url).post(requestBody).build();
    }

    public static abstract class ResultCallback {
    Type mType;

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

 static Type getSuperclassTypeParameter(Class<?> subclass) {
 	Type superclass = subclass.getGenericSuperclass();
 	if (superclass instanceof Class) {
 		throw new RuntimeException("Missing type parameter.");
 	}
 	ParameterizedType parameterized = (ParameterizedType) superclass;
 	return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
 }

 public abstract void onError(Request request, Exception e);

 public abstract void onResponse(T response);

    }

    public static class Param {
    public Param(String id, int i) {
    }

     public Param(String key, String value) {
 	this.key = key;
 	this.value = value;
 }

 String key;
 String value;

    }

}

如果需要图片操作 在导入

package com.example.okhttpmanager;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Base64;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.lang.reflect.Field;

public class ImageUtils
{

public static ImageSize getImageSize(InputStream imageStream) {
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(imageStream, null, options);
    return new ImageSize(options.outWidth, options.outHeight);
}

public static class ImageSize {
    int width;
    int height;

    public ImageSize() {
    }

    public ImageSize(int width, int height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public String toString() {
        return "ImageSize{" +
                "width=" + width +
                ", height=" + height +
                '}';
    }
}

public static int calculateInSampleSize(ImageSize srcSize, ImageSize targetSize) {
    int width = srcSize.width;
    int height = srcSize.height;
    int inSampleSize = 1;

    int reqWidth = targetSize.width;
    int reqHeight = targetSize.height;

    if (width > reqWidth && height > reqHeight) {
        int widthRatio = Math.round((float) width / (float) reqWidth);
        int heightRatio = Math.round((float) height / (float) reqHeight);
        inSampleSize = Math.max(widthRatio, heightRatio);
    }
    return inSampleSize;
}

public static ImageSize getImageViewSize(View view) {

    ImageSize imageSize = new ImageSize();

    imageSize.width = getExpectWidth(view);
    imageSize.height = getExpectHeight(view);

    return imageSize;
}

private static int getExpectHeight(View view) {
    int height = 0;
    if (view == null) return 0;
    final ViewGroup.LayoutParams params = view.getLayoutParams();
    if (params != null && params.height != ViewGroup.LayoutParams.WRAP_CONTENT) {
        height = view.getWidth();
    }
    if (height <= 0 && params != null) {

         height = params.height;
    }

    if (height <= 0) {
        height = getImageViewFieldValue(view, "mMaxHeight");
    }

    if (height <= 0) {
        DisplayMetrics displayMetrics = view.getContext().getResources()
                .getDisplayMetrics();
        height = displayMetrics.heightPixels;
    }

    return height;
}

private static int getExpectWidth(View view) {
    int width = 0;
    if (view == null) return 0;

    final ViewGroup.LayoutParams params = view.getLayoutParams();
    if (params != null && params.width != ViewGroup.LayoutParams.WRAP_CONTENT) {
        width = view.getWidth();
    }
    if (width <= 0 && params != null) {
        width = params.width;
    }

    if (width <= 0) {
        width = getImageViewFieldValue(view, "mMaxWidth");
    }
    if (width <= 0) {
        DisplayMetrics displayMetrics = view.getContext().getResources()
                .getDisplayMetrics();
        width = displayMetrics.widthPixels;
    }

    return width;
}

private static int getImageViewFieldValue(Object object, String fieldName) {
    int value = 0;
    try {
        Field field = ImageView.class.getDeclaredField(fieldName);
        field.setAccessible(true);
        int fieldValue = field.getInt(object);
        if (fieldValue > 0 && fieldValue < Integer.MAX_VALUE) {
            value = fieldValue;
        }
    } catch (Exception e) {}
    return value;

}
// 根据路径获得图片并压缩，返回bitmap用于显示
public static Bitmap getSmallBitmap(String filePath) {
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(filePath, options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, 480, 800);

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;

    return BitmapFactory.decodeFile(filePath, options);
}

//计算图片的缩放值
public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {
        final int heightRatio = Math.round((float) height/ (float) reqHeight);
        final int widthRatio = Math.round((float) width / (float) reqWidth);
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
    }
    return inSampleSize;
}


//把bitmap转换成String
public static String bitmapToString(String filePath) {
    Bitmap bm = getSmallBitmap(filePath);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    //1.5M的压缩后在100Kb以内，测试得值,压缩后的大小=94486字节,压缩后的大小=74473字节
    //这里的JPEG 如果换成PNG，那么压缩的就有600kB这样
    bm.compress(Bitmap.CompressFormat.JPEG, 40, baos);
    byte[] b = baos.toByteArray() ;
    Log.d("d", "压缩后的大小=" + b.length);
    return Base64.encodeToString(b, Base64.DEFAULT);
}
//把bitmap转换成String
public static String bitmapToString2(Bitmap bm ) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    //1.5M的压缩后在100Kb以内，测试得值,压缩后的大小=94486字节,压缩后的大小=74473字节
    //这里的JPEG 如果换成PNG，那么压缩的就有600kB这样
    bm.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    byte[] b = baos.toByteArray();
    Log.d("d", "压缩后的大小=" + b.length);
    return Base64.encodeToString(b, Base64.DEFAULT);
}

}

//-----------------------------------------
然后就可以直接使用了

一位不愿意透漏姓名的胡英杰先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OkHttp请求完美封装（并带工具类）
03-16
MD5、RSA、Base64Utils、DialogUtil、ZXingUtils、GlideUtil、、、工具类 自己总结了一些必备的工具类，可直接放入工程，简单调用 对OkHttp进行了封装，简单调用，便于操作 进行了post、get、文件上传等进行封装
okhttp发送post请求携带json数据，并接收json数据
weixin_39654286的博客
12-18 1万+
okhttp工具类： package tools; import com.squareup.okhttp.*; import java.io.File; import java.io.IOException; import java.util.concurrent.TimeUnit; /** * @Auther: * @Date: 2018/12/14 11:47 * @Des...
okhttp同步异步请求工具
臣本布衣，躬耕于南阳
01-18 585
package com.tairanchina.common.util; import com.squareup.okhttp.Callback; import com.squareup.okhttp.MediaType; import com.squareup.okhttp.OkHttpClient; import com.squareup.okhttp.Request; import co...
okhttp使用
danwuxie的博客
04-29 282
一、添加依赖 compile 'com.squareup.okhttp:okhttp:2.4.0' 二、主程序 package com.example.mpcc.listviewrefrsh; import android.os.Handler; import android.support.v7.app.AppCompatActivity; import android.os.Bu...
OkHttp用法详解
liuqinhou的博客
02-26 1693
okhttp
封装 okhttp
03-27
自己封装 okhttp 工具类，可用于商业项目
简单封装okhttp的使用.rar
06-10
一、为什么要进行封装？ 1、在实际开发中，我们有很多的业务模块，每一个业务模块都具有相应的网络请求。 2、如果每一个业务模块都依赖具体的网络实现，随着技术的发展，当有更好的网络请求框架出现时，如果对现有...
okhttp框架封装
04-10
一个良好的http请求框架的封装，支持接口的链式请求，能够更加灵便的使用
Android 封装Okhttp+Retrofit+RxJava,外加拦截器实例
08-28
下面小编就为大家分享一篇Android封装Okhttp+Retrofit+RxJava,外加拦截器实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Android-简易封装OkHttp
08-13
简易封装OkHttp
Okhttp使用
gaojing694855420的博客
05-06 738
布局： xml version="1.0" encoding="utf-8"?> RelativeLayout android:layout_width="match_parent" android:layout_height="match_parent" xmlns:android="http://schemas.android.com/apk/res/androi
商城之OKHTTP
LLLigj博客
10-04 312
1.Tips:国内镜像： allprojects {     repositories { //        jcenter()         maven{ url 'http://maven.oschina.net/content/groups/public/'}     } } 2.gradle导入： compile 'com.squareup.okhttp:o
okhttp
鑫的专栏
06-06 686
Android系统提供了两种HTTP通信类，HttpURLConnection和HttpClient。 关于HttpURLConnection和HttpClient的选择>>官方博客 尽管Google在大部分安卓版本中推荐使用HttpURLConnection，但是这个类相比HttpClient实在是太难用，太弱爆了。 OkHttp是一个相对成熟的解决方案，据说Android4.4的源码中可以
OkHttp官方教程解析-彻底入门OkHttp使用
weixin_30700099的博客
05-03 6108
最近半年来身边开发的朋友越来越多的提到OkHttp，上谷歌百度一下，确实OkHttp成了时下最火的HTTP框架，于是我也开始放下Volley，转而关注OkHttp，五一期间仔细看了官方WiKi介绍（我喜欢学习官方的文档），现在把自己整理的官方教程分享给大家，希望给初学者带来帮助。 OkHttp官网地址：http://square.github.io...
OkHttp联网访问工具类
72的博客
10-14 185
package com.example.mvplibrary.net; import android.annotation.SuppressLint; import android.os.Message; import com.example.mvplibrary.iml.HttpListener; import com.squareup.okhttp.Callback; import co...
一个极简的Http请求client推荐，一行搞玩外部请求
热门推荐
LoveSummer
11-12 2万+
在Java的世界中，Http客户端之前一直是Apache家的HttpClient占据主导，但是由于此包较为庞大，API又比较难用，因此并不使用很多场景。而新兴的OkHttp、Jodd-http固然好用，但是面对一些场景时，学习成本还是有一些的。很多时候，我们想追求轻量级的Http客户端，并且追求简单易用。而OKHttp是一套处理 HTTP 网络请求的依赖库，由 Square 公司设计研发并开源，目前可以在 Java 和 Kotlin 中使用。对于 Android App。
OkHttp简单封装
weixin_46019555的博客
04-10 5487
简单封装OkHttp框架，单例模式。一句话即可使用。 返回值已进行JSON转换，拿到响应数据后的回调运行在主线程，可以直接修改UI。 已写get请求、post方式提交字符串、post方式提交表单、post方式上传图片，后续再添加。 依赖： ```groovy //OkHttp implementation 'com.squareup.okhttp3:okhttp:4.9.3' //Gson implementation 'com.google.code.gson:gson:
OkHttp的封装
indeedes的博客
09-12 2674
通过前面的操作，发现使用HttpURLConnection的写法 还是比较复杂的，那么使用OkHttp会变得简单吗？ 一、重写HttpUtil类 public class HttpUtil{ public static void sendOkHttpRequest(String address,okhttp3.Callback callback){ OkHttpClient client = new OkHttpClient(); Req...
okhttp 封装
无问西东的博客
08-29 2681
okhttp get/post基本用法 okhttp upload/download 上传和下载 对应的项目下载地址：NetFramework 全部单例模式创建方式：单例模式例子中用到了静态内部类创建单例，对此不了解的可以参考这篇 前两篇文章实践了使用okhttp3.0进行简单的网络交互、获取网络资源等操作，但是可以预料代码会有冗余的情况，我们可以写的更加优雅一点，例子中只是个别的网络请...
android okhttp封装
最新发布
09-14
2. 创建一个封装类，例如OkHttpUtils，用于封装OkHttp的相关操作。 3. 在封装类中，可以定义一些常用的请求方法，例如GET请求、POST请求、上传文件、下载文件等。其中，可以使用OkHttpClient来创建一个OkHttp的实例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值