美文网首页android开源库
[Android网络库]快速使用Android网络

[Android网络库]快速使用Android网络

作者: Darren老师 | 来源:发表于2022-06-29 18:18 被阅读0次

    关于 Fast Android 网络库

    Fast Android Networking Library 是一个强大的库，用于在 Android 应用程序中进行任何类型的网络，它建立在OkHttp 网络层之上。

    快速的 Android 网络库负责处理所有事情。因此，您无需执行任何操作，只需发出请求并听取响应即可。

    为什么使用快速安卓网络？

    • 最近在 Android Marshmallow(Android M) 中删除了 HttpClient，这使得其他网络库过时了。
    • 没有其他单个库可以完成所有操作，例如发出请求、下载任何类型的文件、上传文件、在 ImageView 中从网络加载图像等。有一些库，但它们已经过时了。
    • 没有其他库提供简单的接口来执行网络中的所有类型的事情，例如设置优先级、取消等。
    • 由于它使用Okio，因此在 android 应用程序中没有更多的 GC 开销。 Okio用于在分配内存时处理 GC 开销。 Okio做了一些聪明的事情来节省 CPU 和内存。
    • 它使用OkHttp，更重要的是它支持 HTTP/2。

    要求

    Fast Android Networking Library 可以包含在任何 Android 应用程序中。

    Fast Android Networking Library 支持 Android 2.3 (Gingerbread) 及更高版本。

    在您的应用程序中使用快速 Android 网络库

    将此添加到您的 build.gradle

    implementation 'com.amitshekhar.android:android-networking:1.0.2'

    如果清单中不存在，请不要忘记在清单中添加互联网权限

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

    然后在应用类的 onCreate() 方法中初始化：

    AndroidNetworking.initialize(getApplicationContext());

    通过一些自定义对其进行初始化，因为它使用OkHttp作为网络层，您可以在初始化时传递自定义 okHttpClient。

    // Adding an Network Interceptor for Debugging purpose :
OkHttpClient okHttpClient = new OkHttpClient() .newBuilder()
                        .addNetworkInterceptor(new StethoInterceptor())
                        .build();
AndroidNetworking.initialize(getApplicationContext(),okHttpClient);

    使用带有 Jackson Parser 的快速 Android 网络

    implementation 'com.amitshekhar.android:jackson-android-networking:1.0.2'

    // Then set the JacksonParserFactory like below
AndroidNetworking.setParserFactory(new JacksonParserFactory());

    发出 GET 请求

    AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                 .addPathParameter("pageNumber", "0")
                 .addQueryParameter("limit", "3")
                 .addHeaders("token", "1234")
                 .setTag("test")
                 .setPriority(Priority.LOW)
                 .build()
                 .getAsJSONArray(new JSONArrayRequestListener() {
                    @Override
                    public void onResponse(JSONArray response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

    发出 POST 请求

    AndroidNetworking.post("https://fierce-cove-29863.herokuapp.com/createAnUser")
                 .addBodyParameter("firstname", "Amit")
                 .addBodyParameter("lastname", "Shekhar")
                 .setTag("test")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

    您还可以像这样在 POST 请求中发布 java 对象、json、文件等。

    User user = new User();
user.firstname = "Amit";
user.lastname = "Shekhar";

AndroidNetworking.post("https://fierce-cove-29863.herokuapp.com/createUser")
                 .addBodyParameter(user) // posting java object
                 .setTag("test")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .getAsJSONArray(new JSONArrayRequestListener() {
                    @Override
                    public void onResponse(JSONArray response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

JSONObject jsonObject = new JSONObject();
try {
    jsonObject.put("firstname", "Amit");
    jsonObject.put("lastname", "Shekhar");
} catch (JSONException e) {
  e.printStackTrace();
}

AndroidNetworking.post("https://fierce-cove-29863.herokuapp.com/createUser")
                 .addJSONObjectBody(jsonObject) // posting json
                 .setTag("test")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .getAsJSONArray(new JSONArrayRequestListener() {
                    @Override
                    public void onResponse(JSONArray response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

AndroidNetworking.post("https://fierce-cove-29863.herokuapp.com/postFile")
                 .addFileBody(file) // posting any type of file
                 .setTag("test")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

    将它与您自己的 JAVA 对象一起使用 - JSON Parser

    /*--------------Example One -> Getting the userList----------------*/
AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                .addPathParameter("pageNumber", "0")
                .addQueryParameter("limit", "3")
                .setTag(this)
                .setPriority(Priority.LOW)
                .build()
                .getAsObjectList(User.class, new ParsedRequestListener<List<User>>() {
                    @Override
                    public void onResponse(List<User> users) {
                      // do anything with response
                      Log.d(TAG, "userList size : " + users.size());
                      for (User user : users) {
                        Log.d(TAG, "id : " + user.id);
                        Log.d(TAG, "firstname : " + user.firstname);
                        Log.d(TAG, "lastname : " + user.lastname);
                      }
                    }
                    @Override
                    public void onError(ANError anError) {
                     // handle error
                    }
                });
/*--------------Example Two -> Getting an user----------------*/
AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAnUserDetail/{userId}")
                .addPathParameter("userId", "1")
                .setTag(this)
                .setPriority(Priority.LOW)
                .build()
                .getAsObject(User.class, new ParsedRequestListener<User>() {
                     @Override
                     public void onResponse(User user) {
                        // do anything with response
                        Log.d(TAG, "id : " + user.id);
                        Log.d(TAG, "firstname : " + user.firstname);
                        Log.d(TAG, "lastname : " + user.lastname);
                     }
                     @Override
                     public void onError(ANError anError) {
                        // handle error
                     }
                 }); 
/*-- Note : YourObject.class, getAsObject and getAsObjectList are important here --*/

    从服务器下载文件

    AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });

    上传文件到服务器

    AndroidNetworking.upload(url)
                 .addMultipartFile("image",file)    
                 .addMultipartParameter("key","value")
                 .setTag("uploadTest")
                 .setPriority(Priority.HIGH)
                 .build()
                 .setUploadProgressListener(new UploadProgressListener() {
                    @Override
                    public void onProgress(long bytesUploaded, long totalBytes) {
                      // do anything with progress 
                    }
                 })
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // do anything with response                
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error 
                    }
                 });

    在另一个线程执行器中获取响应和完成

    （注意：错误和进度将始终在应用程序的主线程中返回）

    AndroidNetworking.upload(url)
                 .addMultipartFile("image",file)  
                 .addMultipartParameter("key","value")  
                 .setTag("uploadTest")
                 .setPriority(Priority.HIGH)
                 .build()
                 .setExecutor(Executors.newSingleThreadExecutor()) // setting an executor to get response or completion on that executor thread
                 .setUploadProgressListener(new UploadProgressListener() {
                    @Override
                    public void onProgress(long bytesUploaded, long totalBytes) {
                      // do anything with progress 
                    }
                 })
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // below code will be executed in the executor provided
                      // do anything with response                
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error 
                    }
                 });

    如果请求已完成给定阈值，则设置不取消请求的百分比阈值

    AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .setPercentageThresholdForCancelling(50) // even if at the time of cancelling it will not cancel if 50% 
                 .build()                                 // downloading is done.But can be cancalled with forceCancel.
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });

    取消请求。

    任何带有给定标签的请求都可以被取消。就这样吧。

    AndroidNetworking.cancel("tag"); // All the requests with the given tag will be cancelled.
AndroidNetworking.forceCancel("tag");  // All the requests with the given tag will be cancelled , even if any percent threshold is
                                       // set , it will be cancelled forcefully. 
AndroidNetworking.cancelAll(); // All the requests will be cancelled.  
AndroidNetworking.forceCancelAll(); // All the requests will be cancelled , even if any percent threshold is
                               // set , it will be cancelled forcefully.

    从网络加载图像到 ImageView

          <com.androidnetworking.widget.ANImageView
          android:id="@+id/imageView"
          android:layout_width="100dp"
          android:layout_height="100dp"
          android:layout_gravity="center" />

      imageView.setDefaultImageResId(R.drawable.default);
      imageView.setErrorImageResId(R.drawable.error);
      imageView.setImageUrl(imageUrl);

    使用某些指定参数从 url 获取位图

    AndroidNetworking.get(imageUrl)
                 .setTag("imageRequestTag")
                 .setPriority(Priority.MEDIUM)
                 .setBitmapMaxHeight(100)
                 .setBitmapMaxWidth(100)
                 .setBitmapConfig(Bitmap.Config.ARGB_8888)
                 .build()
                 .getAsBitmap(new BitmapRequestListener() {
                    @Override
                    public void onResponse(Bitmap bitmap) {
                    // do anything with bitmap
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

    错误代码处理

    public void onError(ANError error) {
   if (error.getErrorCode() != 0) {
        // received error from server
        // error.getErrorCode() - the error code from server
        // error.getErrorBody() - the error body from server
        // error.getErrorDetail() - just an error detail
        Log.d(TAG, "onError errorCode : " + error.getErrorCode());
        Log.d(TAG, "onError errorBody : " + error.getErrorBody());
        Log.d(TAG, "onError errorDetail : " + error.getErrorDetail());
        // get parsed error object (If ApiError is your class)
        ApiError apiError = error.getErrorAsObject(ApiError.class);
   } else {
        // error.getErrorDetail() : connectionError, parseError, requestCancelledError
        Log.d(TAG, "onError errorDetail : " + error.getErrorDetail());
   }
}

    从缓存中删除位图或清除缓存

    AndroidNetworking.evictBitmap(key); // remove a bitmap with key from LruCache
AndroidNetworking.evictAllBitmap(); // clear LruCache

    预取请求（以便在需要时立即从缓存中返回）

    AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                .addPathParameter("pageNumber", "0")
                .addQueryParameter("limit", "30")
                .setTag(this)
                .setPriority(Priority.LOW)
                .build()
                .prefetch();

    为特定请求自定义 OkHttpClient

    OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
                .addInterceptor(new GzipRequestInterceptor())
                .build();

AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                 .addPathParameter("pageNumber", "0")
                 .addQueryParameter("limit", "3")
                 .addHeaders("token", "1234")
                 .setTag("test")
                 .setPriority(Priority.LOW)
                 .setOkHttpClient(okHttpClient) // passing a custom okHttpClient 
                 .build()
                 .getAsJSONArray(new JSONArrayRequestListener() {
                    @Override
                    public void onResponse(JSONArray response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                    // handle error
                    }
                });

    提出条件请求（构建请求）

    ANRequest.GetRequestBuilder getRequestBuilder = new ANRequest.GetRequestBuilder(ApiEndPoint.BASE_URL + ApiEndPoint.CHECK_FOR_HEADER);

if(isHeaderRequired){
 getRequestBuilder.addHeaders("token", "1234");
}

if(executorRequired){
 getRequestBuilder.setExecutor(Executors.newSingleThreadExecutor());
}

ANRequest anRequest = getRequestBuilder.build();       

anRequest.getAsJSONObject(new JSONObjectRequestListener() {
    @Override
    public void onResponse(JSONObject response) {
      // do anything with response
    }
    @Override
    public void onError(ANError error) {
      // handle error
    }
});

    ConnectionClass Listener 获取当前网络质量和带宽

    // Adding Listener
AndroidNetworking.setConnectionQualityChangeListener(new ConnectionQualityChangeListener() {
            @Override
            public void onChange(ConnectionQuality currentConnectionQuality, int currentBandwidth) {
              // do something on change in connectionQuality
            }
        });

// Removing Listener   
AndroidNetworking.removeConnectionQualityChangeListener();

// Getting current ConnectionQuality
ConnectionQuality connectionQuality = AndroidNetworking.getCurrentConnectionQuality();
if(connectionQuality == ConnectionQuality.EXCELLENT) {
  // do something
} else if (connectionQuality == ConnectionQuality.POOR) {
  // do something
} else if (connectionQuality == ConnectionQuality.UNKNOWN) {
  // do something
}
// Getting current bandwidth
int currentBandwidth = AndroidNetworking.getCurrentBandwidth(); // Note : if (currentBandwidth == 0) : means UNKNOWN

    通过设置 AnalyticsListener 来获取请求的分析

    AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .setAnalyticsListener(new AnalyticsListener() {
                      @Override
                      public void onReceived(long timeTakenInMillis, long bytesSent, long bytesReceived, boolean isFromCache) {
                          Log.d(TAG, " timeTakenInMillis : " + timeTakenInMillis);
                          Log.d(TAG, " bytesSent : " + bytesSent);
                          Log.d(TAG, " bytesReceived : " + bytesReceived);
                          Log.d(TAG, " isFromCache : " + isFromCache);
                      }
                  })
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });  
Note : If bytesSent or bytesReceived is -1 , it means it is unknown

    在响应中获取 OkHttpResponse

    AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAnUserDetail/{userId}")
                .addPathParameter("userId", "1")
                .setTag(this)
                .setPriority(Priority.LOW)
                .setUserAgent("getAnUser")
                .build()
                .getAsOkHttpResponseAndParsed(new TypeToken<User>() {
                }, new OkHttpResponseAndParsedRequestListener<User>() {
                    @Override
                    public void onResponse(Response okHttpResponse, User user) {
                      // do anything with okHttpResponse and user
                    }
                    @Override
                    public void onError(ANError anError) {
                      // handle error
                    }
                });

    发出同步请求

    ANRequest request = AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                        .addPathParameter("pageNumber", "0")
                        .addQueryParameter("limit", "3")
                        .build();
ANResponse<List<User>> response = request.executeForObjectList(User.class);
if (response.isSuccess()) {
   List<User> users = responseTwo.getResult();
} else {
   //handle error
}

    缓存如何工作？

    • 首先，服务器必须在标头中发送缓存控制，以便开始工作。
    • 响应将根据缓存控制 max-age,max-stale 进行缓存。
    • 如果互联网已连接并且年龄未过期，它将从缓存中返回。
    • 如果互联网已连接并且年龄已过期，并且如果服务器返回 304（未修改），它将从缓存中返回。
    • 如果您使用 getResponseOnlyIfCached() 时未连接互联网 - 即使日期已过期，它也会从缓存中返回。
    • 如果未连接互联网，如果您不使用 getResponseOnlyIfCached() - 它不会返回任何内容。
    • 如果您使用 getResponseOnlyFromNetwork() ，它只会在服务器验证后返回响应。
    • 如果设置了缓存控制，它将根据服务器返回的 max-age,max-stale 工作。
    • 如果未连接互联网，则获取缓存响应的唯一方法是使用 getResponseOnlyIfCached()。

    启用日志记录

    AndroidNetworking.enableLogging(); // simply enable logging
AndroidNetworking.enableLogging(LEVEL.HEADERS); // enabling logging with level

    启用从客户端到服务器的 GZIP

    // Enabling GZIP for Request (Not needed if your server doesn't support GZIP Compression), anyway responses 
// from server are automatically unGzipped if required. So enable it only if you need your request to be 
// Gzipped before sending to server(Make sure your server support GZIP Compression).
OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
                .addInterceptor(new GzipRequestInterceptor())
                .build();
AndroidNetworking.initialize(getApplicationContext(),okHttpClient);

    重要的提示

    • 谨慎使用 IMMEDIATE 优先级 - 仅在需要 1 或 2 个（最多 2 个）IMMEDIATE 请求时才在适当的位置使用。否则使用高优先级。

    • 已知错误：如果您在客户端到服务器之间使用 GZIP 拦截器，则上传进度在 Multipart 中无法正常工作。

      如果您将 Proguard 与 Gradle 构建系统一起使用（通常是这种情况），则无需执行任何操作。将自动应用相应的 Proguard 规则。如果还需要应用中的规则proguard-rules.pro，如下：

      -dontwarn okio.**

    快速 Android 网络库支持

    • Fast Android Networking Library 支持所有类型的 HTTP/HTTPS 请求，例如 GET、POST、DELETE、HEAD、PUT、PATCH
    • Fast Android Networking Library 支持下载任何类型的文件
    • Fast Android Networking Library 支持上传任何类型的文件（支持分段上传）
    • Fast Android Networking Library 支持取消请求
    • Fast Android Networking Library 支持为任何请求设置优先级（LOW、MEDIUM、HIGH、IMMEDIATE）
    • Fast Android Networking Library 支持RxJava

    由于它使用OkHttp作为网络层，它支持：

    • Fast Android Networking Library 支持 HTTP/2 支持允许对同一主机的所有请求共享一个套接字
    • Fast Android Networking Library 使用连接池来减少请求延迟（如果 HTTP/2 不可用）
    • 透明 GZIP 缩小下载大小
    • Fast Android Networking Library 支持响应缓存，完全避免网络重复请求

    与其他网络库的区别

    • 在 Fast Android Networking Library 中，OkHttpClient 可以很容易地为每个请求定制——比如每个请求的超时定制等。
    • 由于 Fast Android Networking Library 使用OkHttp和Okio，因此速度更快。
    • 适用于所有类型网络的单一库。
    • 支持 RxJava、RxJava2 。
    • 可以获取当前的带宽和连接质量来决定代码的逻辑。
    • Executor 可以传递给任何请求以在另一个线程中获取响应。
    • 可以获得任何请求的完整分析。
    • 所有类型的定制都是可能的。
    • 即时请求现在真的是即时的。
    • 可以对任何请求进行预取，以便在需要时从缓存中提供即时数据。
    • 适当的请求取消。
    • 如果完成的请求超过特定阈值百分比，则防止取消请求。
    • 一个简单的接口，可以发出任何类型的请求。
    • 适当的响应缓存——这会导致带宽使用减少。

    全部

    • 与其他库集成
    • 当然还有许多功能和错误修复

    学分

    • Square - 由于Fast Android Networking 使用的OkHttp和Okio 都是由Square开发的。
    • Volley-As Fast Android Networking 使用由Volley开发的 ImageLoader 。
    • Prashant Gupta - 对于 RxJava，RxJava2 支持 - RxJava 支持。

    作者：amitshekhariitbhu
    链接：https://github.com/amitshekhariitbhu/Fast-Android-Networking

    相关文章

      网友评论

        本文标题：[Android网络库]快速使用Android网络

        本文链接：https://www.haomeiwen.com/subject/siqxbrtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        android

        开源库

        关于我们|服务条款|联系我们|[Android网络库]快速使用Android网络|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！