精华内容
参与话题
问答
  • 网络请求框架

    2016-08-11 11:09:26
    网络请求框架
    展开全文
  • 1.Volley的GET请求 2.Volley的Post请求 3.Volley的ImageRequest加载图片请求 4.Volley的ImageLoader加载图片请求 5.Volley的NetWorkImageView加载图片使用 6.Volley提交JSON数据


    题记——

            人来到这个世界上,只有两件事情,生与死,

            一件事完了,另一件事还急什么?

            有缘而来,无缘而去,

            识自本心,见自本性

            不起妄缘,无心无为

            自由自在,动静自如

            冷暖自知,则是修行






    1、初始化一个消息请求队列以及网络请求工具类对象


    /**
     * Created by androidlongs on 16/7/1.
     * 网络请求访问框架
     */
    public class VollyRequestUtils {
        /**
         * Volley框架使用工具类对象
         */
        private static VollyRequestUtils vollyRequestUtils;
        /**
         * 网络消息请求队列
         */
        private static RequestQueue requestQueue;
        private VollyRequestUtils() {
            /**
             * 初始化请求消息队列
             */
            getVolleyQueyInstanse();
        }
    
        /**
         * 获取消息工具类请求对象实体
         *
         * @return
         */
        public static VollyRequestUtils getInstance() {
            if (vollyRequestUtils == null) {
                synchronized (VollyRequestUtils.class) {
                    if (vollyRequestUtils == null) {
                        vollyRequestUtils = new VollyRequestUtils();
                    }
                }
            }
            return vollyRequestUtils;
        }
    
        /**
         * 获取消息请求队列
         */
        public void getVolleyQueyInstanse() {
            if (requestQueue == null) {
                synchronized (VollyRequestUtils.class) {
                    if (requestQueue == null) {
                        requestQueue = Volley.newRequestQueue(App.getContext());
                    }
                }
            }
    
        }
    
    }


    备注说明:

            这里采用单例设计模式,其中创建请求消息队列 requestQueue传入的是一个Application对象 

    public class App extends Application {
        private  static Context context;
        @Override
        public void onCreate() {
            super.onCreate();
            context = this;
        }
        public static  Context getContext(){
            return context;
        }
    }

    切记要在程序的清单文件中引入


    2、Get网络请求返回String 

        /**
         * get 请求
         *
         * @param url           网络请求url
         * @param netTag        网络请求标识
         * @param isCache       设置缓存标识
         * @param listener      请求成功回调
         * @param errorlistener 请求失败回调
         */
        public void asyGetStringRequest(String url, String netTag, boolean isCache, Response.Listener<String> listener, Response.ErrorListener errorlistener) {
    
            /**
             * 在发起请求前先取消队列中有此标签的网络,避免多次重复请求问题
             */
            requestQueue.cancelAll(netTag);
            /**
             * 获取请求对象
             * 并设置相关的监听
             */
            StringRequest request = new StringRequest(Request.Method.GET, url, listener, errorlistener);
            /**
             * 设置网络请求标识
             */
            request.setTag(netTag);
            /**
             * 设置网络请求缓存
             */
            request.setShouldCache(isCache);
            /**
             * 添加到队列中
             */
            requestQueue.add(request);
        }
    
    

    使用方法:

            final String url = "http://172.19.1.45:8080/OkhttpAppLication/test";
            final String netTag = "getString";
            
            VollyRequestUtils.getInstance().asyGetStringRequest(url, netTag, false, new Response.Listener<String>() {
                @Override
                public void onResponse(String s) {
                    System.out.println("get String success " + s);
                }
    
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError volleyError) {
                    System.out.println("get String onErrorResponse " + volleyError.getMessage());
                }
            });


    3、POST请求提交参数形式为KEY - VALUE 形式请求


        /**
         * post请求 提交KEY - VALEU 形式的数据
         *
         * @param url
         * @param netTag
         * @param map
         * @param isCache
         * @param listener
         * @param errorListener
         */
        public void asyncPostStringQuest(String url, String netTag, final Map<String, String> map, boolean isCache, Response.Listener<String> listener, Response.ErrorListener errorListener) {
    
            /**
             * 取消此标识下的所有网络请求,避免重复提交
             */
            requestQueue.cancelAll(netTag);
            /**
             * 获取Request对象 并封装相应的参数
             */
            StringRequest request = new StringRequest(Request.Method.POST, url, listener, errorListener) {
                @Override
                protected Map<String, String> getParams() throws AuthFailureError {
                    /**
                     * 封装请求参数
                     */
                    if (map != null && !map.isEmpty()) {
                        return map;
                    } else {
                        return super.getParams();
                    }
                }
            };
            /**
             * 设置缓存
             */
            request.setShouldCache(isCache);
            /**
             * 设置网络请求标识
             */
            request.setTag(netTag);
            requestQueue.add(request);
        }
    
    使用方法:

            final String url = "http://172.19.1.45:8080/OkhttpAppLication/test";
            final String netTag = "postString";
            
            Map<String, String> map = new HashMap<>();
            map.put("username", "postUsername");
            map.put("password", "postPassword");
            
            VollyRequestUtils.getInstance().asyncPostStringQuest(url, netTag, map, false, new Response.Listener<String>() {
                @Override
                public void onResponse(String s) {
                    System.out.println("post String success " + s);
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError volleyError) {
                    System.out.println("post String onErrorResponse " + volleyError.getMessage());
                }
            });
        }
    

    4、post请求提交参数为JSON形式


        /**
         * 提交 JSON数据到服务器
         *
         * @param url           网络请求URL
         * @param netTag        网络请求标识
         * @param map           网络请求提交参数
         * @param isCache       缓存请求标识
         * @param listener      成功监听
         * @param errorListener 失败监听
         */
        public void asynePostJsonObjRequest(String url, String netTag, final Map<String, String> map, boolean isCache, Response.Listener<JSONObject> listener, Response.ErrorListener errorListener) {
    
            requestQueue.cancelAll(netTag);
            /**
             * 封装参数
             */
            JSONObject object = new JSONObject();
            try {
    
                if (map != null && !map.isEmpty()) {
                    for (Map.Entry<String, String> entry : map.entrySet()) {
                        object.put(entry.getKey(), entry.getValue());
                    }
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            /**
             * 创建请求Request
             */
            JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.POST, url, object, listener, errorListener);
            /**
             * 设置网络请求标识
             */
            jsonObjectRequest.setTag(netTag);
            /**
             * 设置缓存
             */
            jsonObjectRequest.setShouldCache(isCache);
            requestQueue.add(jsonObjectRequest);
        }
    
    

    使用方法:

            final String url = "http://172.19.1.45:8080/OkhttpAppLication/test";
            final String netTag = "postString";
            
            Map<String, String> map = new HashMap<>();
            map.put("username", "postUsername---45");
            map.put("password", "postPassword---45");
            
            VollyRequestUtils.getInstance().asynePostJsonObjRequest(url,netTag,map,false,new Response.Listener<JSONObject>(){
    
                @Override
                public void onResponse(JSONObject jsonObject) {
                    JSONObject j = jsonObject;
                }
            },new Response.ErrorListener(){
    
                @Override
                public void onErrorResponse(VolleyError volleyError) {
    
                }
            });



    5、加载图片请求

     /**
         * 加载图片请求
         * @param url            加载图片的URL
         * @param netTag         加载图片的网络请求标识
         * @param imageMaxWidth  加载图片的最大宽度
         * @param imageMaxHeight 加载图片的最大高度
         * @param listener       加载成功监听
         * @param errorListener  加载失败监听
         */
        public void asyPostImageRequest(String url, String netTag, int imageMaxWidth, int imageMaxHeight, Response.Listener<Bitmap> listener, Response.ErrorListener errorListener) {
            requestQueue.cancelAll(netTag);
    
            /**
             * 创建获取request
             * 并设置相关的监听与参数
             */
    
            ImageRequest request = new ImageRequest(url, listener, imageMaxWidth, imageMaxHeight, ImageView.ScaleType.MATRIX, Bitmap.Config.ARGB_8888, errorListener);
    
            /**
             * 设置加载缓存
             */
            request.setShouldCache(true);
            /**
             * 设置网络请求标识
             */
            request.setTag(netTag);
            /**
             * 设置请求超时时间
             */
            request.setRetryPolicy(new DefaultRetryPolicy(15000,3000,3000));
            requestQueue.add(request);
        }
    


    使用方法

     final String url = "http://e.hiphotos.baidu.com/image/pic/item/14ce36d3d539b600be63e95eed50352ac75cb7ae.jpg";
            final String netTag = "imagerequest";
            
            VollyRequestUtils.getInstance().asyPostImageRequest(url, netTag, screeWidht, screeHeight, new Response.Listener<Bitmap>() {
                @Override
                public void onResponse(Bitmap bitmap) {
                    System.out.println("image request success ");
                    if (bitmap != null) {
                        imageView.setImageBitmap(bitmap);
                    }
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError volleyError) {
                    System.out.println("image request faile ");
                }
            });



    6、使用Volley内置ImageLoader 加载图片


        /**
         * 加载多张图片
         *
         * @param url
         * @param imageView
         * @param imageMaxWidth
         * @param imageMaxHeight
         */
        public void asyVolleyImageLoaderRequest(String url, ImageView imageView, int imageMaxWidth, int imageMaxHeight) {
            ImageLoader imageLoaderInstance = getImageLoaderInstance();
            // getImageListener(imageView控件对象,默认图片地址,失败图片地址);
            ImageLoader.ImageListener listener = ImageLoader.getImageListener(imageView, android.R.drawable.ic_menu_rotate, android.R.drawable.ic_delete);
            // get(图片地址,listener,宽,高);自动帮你处理图片的宽高再也不怕大图片的oom了
            imageLoaderInstance.get(url, listener, imageMaxWidth, imageMaxHeight, ImageView.ScaleType.MATRIX);
        }
    
        private static ImageLoader imageLoader;
    
        /**
         * 获取 Imageloader对象 
         * @return
         */
        private ImageLoader getImageLoaderInstance() {
            if (imageLoader == null) {
                synchronized (VollyRequestUtils.class) {
                    if (imageLoader == null) {
                        imageLoader = new ImageLoader(requestQueue, new BitmapLruCache());
                    }
                }
            }
            return imageLoader;
        }
    
    

    使用方法

            final String url = "http://e.hiphotos.baidu.com/image/pic/item/14ce36d3d539b600be63e95eed50352ac75cb7ae.jpg";
            final String netTag = "postString";
            
            VollyRequestUtils.getInstance().asyVolleyImageLoaderRequest(url, imageView, screeWidht, screeHeight);

    在这里使用到了一个缓存对象类

    public class  BitmapLruCache extends LruCache<String, Bitmap> implements ImageLoader.ImageCache {
        /**
         * LruCache 原理:Cache保存一个强引用来限制内容数量,每当Item被访问的时候,此Item就会移动到队列的头部。 
         * 当cache已满的时候加入新的item时,在队列尾部的item会被回收。
         * 解释:当超出指定内存值则移除最近最少用的图片内存
         */
        public static int getDefaultLruCacheSize() {
            // 拿到最大内存
            final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
            // 拿到内存的八分之一来做图片内存缓存
            final int cacheSize = maxMemory / 8;
    
            return cacheSize;
        }
    
        public BitmapLruCache() {
            this(getDefaultLruCacheSize());
        }
    
        public BitmapLruCache(int sizeInKiloBytes) {
            super(sizeInKiloBytes);
        }
    
        @Override
        protected int sizeOf(String key, Bitmap value) {
            return value.getRowBytes() * value.getHeight() / 1024;
        }
    
        @Override
        public Bitmap getBitmap(String url) {
            return get(url);
        }
    
        @Override
        public void putBitmap(String url, Bitmap bitmap) {
            put(url, bitmap);
        }
    
    }


    7、使用Volley提供的NetworkImageView加载图片


    布局文件中的xml中使用方法

     <com.android.volley.toolbox.NetworkImageView
            android:layout_marginTop="10dp"
            android:id="@+id/network_image_view"
            android:layout_width="100dp"
            android:layout_height="100dp" />
        

    java代码中的操作

     /**
         * 这个控件在被从父控件detach的时候,会自动取消网络请求的,即完全不用我们担心相关网络请求的生命周期问题,而且NetworkImageView还会根据你对图片设置的width和heigh自动压缩该图片不会产生多的内存,还有NetworkImageView在列表中使用不会图片错误
         *
         * @param iv
         * @param url
         */
        private void networkImageViewUse(NetworkImageView iv, String url) {
            ImageLoader imLoader = new ImageLoader(Volley.newRequestQueue(App.getContext()), new BitmapLruCache());
            iv.setDefaultImageResId(android.R.drawable.ic_menu_rotate);
            iv.setErrorImageResId(android.R.drawable.ic_delete);
            iv.setImageUrl(url, imLoader);
        }
    


    8、自定义Request请求




    展开全文
  • 4. Post请求提交参数形式为Key - Value  5.Post提交JSON数据到服务器 6.上传单个文件(这里上传的是图片) 7.上传多个文件: 8.其他


    题记:——

    很累,累到想要放弃,但是放弃之后将会是一无所有,又不能放弃,

    唯有坚持,唯有给自忆打气,才能更勇敢的走下去,因为无路可退,只能前行,

    时光一去不复返,每一天都不可追回,所以要更珍惜每一存光阴


    不阅世界百态,怎懂沧桑世故四字,

    不观千娇百媚花开,岂知繁华与浮华,

    唯有经历,才能明了



    使用思路简析与准备工作:





    1.获取网络请求工具类对象实例(在这里是新建了一个网络请求工具类)


    public class RetrofitRxJavaHttpUtils {
        public static final String BASE_URL = "http://192.168.1.103:8080/";
    
    
    
        private RetrofitRxJavaHttpUtils() {
            /**
             * 在调用构造的时候分别对OkhttpClient 与Retrofit进行初时化操作
             */
            client = getHttpClientInstance();
            retrofit = getRetrofitInstance();
        }
        /**
         * 获取网络请求工具类单例对象
         */
        private static RetrofitRxJavaHttpUtils utils;
        public static RetrofitRxJavaHttpUtils getInstance() {
            if (utils == null) {
                synchronized (RetrofitRxJavaHttpUtils.class) {
                    utils = new RetrofitRxJavaHttpUtils();
                }
            }
            return utils;
        }
    }

    2.获取OkhttpClient实例对象 (在工具类的构造中进行调用)

    在获取okhttpClient实例对象的时候,设置了一些通用的信息,例如请求头信息,请求参数信息,以及网络超时,Cookie等等所以下面的这一段代码量比较大

     /**
         * 获取oKhttpClient 的实例
         * 在初始化的时候设置一些统一性的操作
         */
        private static OkHttpClient client;
    
        private OkHttpClient getHttpClientInstance() {
            if (client == null) {
                synchronized (RetrofitRxJavaHttpUtils.class) {
                    OkHttpClient.Builder builder = new OkHttpClient.Builder();
                    /**
                     *  设置添加公共的请求参数
                     */
                    Interceptor addQueryParameterInterceptor = new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {
                            Request originalRequest = chain.request();
                            Request request;
                            String method = originalRequest.method();
                            Headers headers = originalRequest.headers();
                            HttpUrl modifiedUrl = originalRequest.url().newBuilder()
                                    // Provide your custom parameter here
                                    .addQueryParameter("commonKey", "android")
                                    .addQueryParameter("version", "1.0.0")
                                    .build();
                            request = originalRequest.newBuilder().url(modifiedUrl).build();
                            return chain.proceed(request);
                        }
                    };
    
    
                    builder.addInterceptor(addQueryParameterInterceptor);
    
                    /**
                     * 添加请求头
                     */
                    Interceptor headerInterceptor = new Interceptor() {
                        @Override
                        public Response intercept(Chain chain) throws IOException {
                            Request originalRequest = chain.request();
                            Request.Builder requestBuilder = originalRequest.newBuilder()
                                    .header("AppType", "TPOS")
                                    .header("Content-Type", "application/json")
                                    .header("Accept", "application/json")
                                    .method(originalRequest.method(), originalRequest.body());
                            Request request = requestBuilder.build();
                            return chain.proceed(request);
                        }
                    };
                    builder.addInterceptor(headerInterceptor);
    
                    /**
                     * 服务端可能需要保持请求是同一个cookie,主要看各自需求
                     * compile 'com.squareup.okhttp3:okhttp-urlconnection:3.2.0'
                     */
                    CookieManager cookieManager = new CookieManager();
                    cookieManager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
                    builder.cookieJar(new JavaNetCookieJar(cookieManager));
    
                    /**
                     * 设置请求超时时间
                     */
                    builder.connectTimeout(15, TimeUnit.SECONDS);
                    builder.readTimeout(20, TimeUnit.SECONDS);
                    builder.writeTimeout(20, TimeUnit.SECONDS);
                    /**
                     * 设置请求加载错误不重新连接
                     */
                    builder.retryOnConnectionFailure(false);
    
                    client = builder.build();
    
                }
            }
    
            return client;
        }
    



    3.获取Retrofit实例对象


     /**
         * 获取Retrofit实例
         * 这里面使用到了OkhttpClient ,在这之前先要将client对象进行初始化操作
         */
        private  static  Retrofit retrofit;
        private Retrofit getRetrofitInstance(){
            if (retrofit==null){
                synchronized (RetrofitRxJavaHttpUtils.class){
                    if(retrofit==null){
                        retrofit = new Retrofit.Builder()
                                .baseUrl(BASE_URL)
                                //设置 Json 转换器
                                .addConverterFactory(GsonConverterFactory.create())
                                //RxJava 适配器
                                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                                .client(client)
                                .build();
                    }
                }
            }
            return retrofit;
        }
    


    4. Post请求提交参数形式为Key - Value 

    在发起请求的时候 ,先通过retrofit对象create服务对象,然后再调起异步请求


    定义服务请求接口

    public interface RetrofitRxInterface {
    
        /**
         * 提交KEY VALEU 形式的参数到服务器
         * @param retrofit
         * @param str
         * @return
         */
        @POST("/OkhttpAppLication//test")
        Observable<HttpResult> request(@Query("username") String retrofit, @Query("password") String str);
    
        /**
         * 提交一个Json数据到服务器
         * @param apiInfo
         * @return
         */
        @POST("/OkhttpAppLication//test")
        Call<ResponseBody> username(@Body UserInfo apiInfo);
    
        /**
         * 提交一个数组信息到服务器
         * @param id
         * @param linked
         * @return
         */
        @GET("/OkhttpAppLication//test")
        Call<ResponseBody> submitArray(@Query("id") String id, @Query("linked[]") String... linked);
    
    
        /**
         * 上传单个文件
         * @param description
         * @param imgs
         * @return
         */
        @Multipart
        @POST("/OkhttpAppLication/LoadFileServlet")
        Call<ResponseBody> uploadFile(@Part("fileName") String description,
                                 @Part("file")RequestBody imgs);
    
        /**
         * 上传多个文件
         * @param pictureName
         * @param params
         * @return
         */
        @Multipart
        @POST("/OkhttpAppLication/LoadFileServlet")
        Call<ResponseBody> uploadFiles(@Part("pictureName") RequestBody pictureName, @PartMap Map<String, RequestBody> params);
    }

    然后再在发起请求的时候通过retrofit来使用

        /**
         * 提交参数为KEY - VALUE 形式
         * @param name
         * @param password
         */
        public void asyncPostKeyValueRequest(String name, String password) {
    
            RetrofitRxInterface user = retrofit.create(RetrofitRxInterface.class);
    
            Observable<HttpResult> observable = user.request(name, password);
    
            observable.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Subscriber<HttpResult>() {
                        @Override
                        public void onCompleted() {
                            /**
                             * 请求执行完毕执行此方法
                             */
                            System.out.println("complete ");
                        }
    
                        @Override
                        public void onError(Throwable e) {
                            System.out.println("error: " + e.getMessage());
                        }
    
                        @Override
                        public void onNext(HttpResult user) {
                            /**
                             * 获取服务器数据
                             */
                            System.out.println("" + user.toString());
                        }
                    });
    
        }
    

    在页面中的使用方法

    public class MainActivity extends AppCompatActivity {
      
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            String username = "admin";
            String password = "12345";
    
            RetrofitRxJavaHttpUtils.getInstance().asyncPostKeyValueRequest(username,password);
    
    
    }
    }

    备注:

    1.使用到了一个RetrofitRxInterface,这是为Retrofit网络请求框架进行服务的接口,

    2.使用到了一个HttpResult,这个类是用来接收服务器返回数据的与服务器端保持一至就可以,


    5.Post请求提交JSON数据到服务器

     /**
         * 提交JSON数据到服务器
         */
        public void asyncPostJsonRequest(){
    
            /**
             * 获取服务接口
             */
            RetrofitRxInterface user1 = retrofit.create(RetrofitRxInterface.class);
    
            /**
             * 构造提交数据
             */
            UserInfo userInfo = new UserInfo();
            userInfo.username = "xhao longs";
            userInfo.password = "admin";
    
            /**
             * 发起回调请求
             */
            Call<ResponseBody> username = user1.username(userInfo);
    
            username.enqueue(new Callback<ResponseBody>() {
                @Override
                public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {
                    /**
                     * 请求成功相关回调
                     */
                    ResponseBody body = response.body();
                    try {
                        String string = body.string();
                        System.out.println(string);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    String s = body.toString();
    
                    System.out.println("body string "+s);
                }
    
                @Override
                public void onFailure(Call<ResponseBody> call, Throwable t) {
    
                }
            });
        }

    调用方法:

    public class MainActivity extends AppCompatActivity {
        public static final String BASE_URL = "http://192.168.1.103:8080/OkhttpAppLication/test";
        
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
    
            RetrofitRxJavaHttpUtils.getInstance().asyncPostJsonRequest();
    
    
    }}


    提交的数据格式 为:

    {"password":"admin","username":"xhao longs"}


    6. 上传单个文件 (这里上传的是图片)


     <pre name="code" class="java">public void asyncUpLoadFile(){
    
            String filename = "/storage/emulated/0/custom/2016/6/18//20160623135328.PNJE";
    
            /**
             * 封装上传文件
             */
            File picture= new File(filename);
            RequestBody requestFile = RequestBody.create(MediaType.parse("application/octet-stream"), picture);
    
            /**
             * 调起上传单文件服务请求接口并发起回调请求
             */
            RetrofitRxInterface user = retrofit.create(RetrofitRxInterface.class);
            /**
             * 这里上传的文件名称为dsf
             */
            Call<ResponseBody> responseBodyCall = user.uploadFile("dsf", requestFile);
            responseBodyCall.enqueue(new Callback<ResponseBody>() {
                @Override
                public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {
                    ResponseBody body = response.body();
                    try {
                        String string = body.string();
                        System.out.println(string);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                @Override
                public void onFailure(Call<ResponseBody> call, Throwable t) {
                    System.out.println("err:_ "+t.getMessage());
                }
            });
        }

    
    

    调用方法:

    public class MainActivity extends AppCompatActivity {
        
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
    
            RetrofitRxJavaHttpUtils.getInstance().asyncUpLoadFile();
    
    
    }
    }
    
    


    7. 上传多文件 

    public void asyncUpLoadFiles(){
    
            String filename = "/storage/emulated/0/custom/2016/6/18//20160623135328.PNJE";
    
            RequestBody pictureNameBody = RequestBody.create(MediaType.parse("Content-Disposition"), "form-data;name=pictureName");
            /**
             * 封装文件
             */
            File picture= new File(filename);
            /**
             * 获取请求RequestBody
             */
            RequestBody requestFile = RequestBody.create(MediaType.parse("application/octet-stream"), picture);
            /**
             * 封装上传文件信息
             * 这里只封装了一张图片
             */
            Map<String, RequestBody> params = new HashMap<>();
            params.put("picture\"; filename=\"" + picture.getName() + "", requestFile);
    
            /**
             * 调起服务请求接口并发起回调请求
             */
            RetrofitRxInterface user = retrofit.create(RetrofitRxInterface.class);
    
            Call<ResponseBody> responseBodyCall = user.uploadFiles(pictureNameBody, params);
    
            responseBodyCall.enqueue(new Callback<ResponseBody>() {
                @Override
                public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {
                    ResponseBody body = response.body();
                    try {
                        String string = body.string();
                        System.out.println(string);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                @Override
                public void onFailure(Call<ResponseBody> call, Throwable t) {
                    System.out.println("err:_ "+t.getMessage());
                }
            });
        }

    调用方法与上传单文件方法一至


    展开全文
  • Android网络请求框架

    2016-10-14 12:57:50
    Android网络请求框架包含okhttp、volley、httpclient、xutils等jar包
  • Android网络请求框架Volley

    万次阅读 热门讨论 2016-08-25 10:32:25
    主要熟悉Volley框架的简单使用,适用于初级开发者!

    首先上效果图


    Logcat日志信息on Reponse


    Volley特别适合数据量不大但是通信频繁的场景,像文件上传下载不适合!

    首先第一步

    用到的RequetQueue

    RequestQueue.java

      RequestQueue请求队列首先得先说一下,ReuqestQueue是如何对请求进行管理的...RequestQueue是对所有的请求进行保存...然后通过自身的start()方法开启一个CacheDispatcher线程用于缓存调度,开启若干个NetWorkDispatcher线程用于网络调度...那么为什么要这样设计呢?

      因为一个请求如果已经提交了一次,那么就只需要处理这一次结果就可以了,对于多次重复的请求,我们完全可以使用一个缓存来进行保存..从而减少一些不必要的网络请求,减小服务器的负担...如果一个请求在缓存中没存在过,那么我们再执行网络请求就可以了

      总而言之,设计理念就是从RequestQueue取出请求,先判断缓存是否命中,如果缓存命中,则从缓存中取出数据,如果缓存没有命中,则提交网络请求,从服务器端获取数据


    导入volley.jar 到您的Project libs里面,然后Add to Build path

    然后创建NetCacheActivity类

    package com.android.xiong.gridlayoutTest;


    import android.app.Activity;
    import android.graphics.Bitmap;
    import android.graphics.Bitmap.Config;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    import android.widget.ImageView;
    import android.widget.Toast;


    import com.android.volley.Request.Method;
    import com.android.volley.RequestQueue;
    import com.android.volley.Response;
    import com.android.volley.VolleyError;
    import com.android.volley.toolbox.ImageRequest;
    import com.android.volley.toolbox.StringRequest;
    import com.android.volley.toolbox.Volley;


    public class NetCacheActivity extends Activity {
    private static final String URL = "http://sina.com";//请求的url
    private RequestQueue mRequestQueue;
    private Button btn_request;
    private ImageView iv_request;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    initView();
     mRequestQueue = Volley.newRequestQueue(getApplicationContext());   
    }


    private void initView() {
    // TODO Auto-generated method stub
    btn_request = (Button) findViewById(R.id.btn_request);
    iv_request=(ImageView) findViewById(R.id.iv_request);
    }


    public void onClick(View v) {
    //volleyRequest();从网络上获取图片
    imageRequest();

    LoadImageView();//ImageLoader加载图片


    }
    private void imageRequest() {
    // TODO Auto-generated method stub
     ImageRequest mImageRequest=new ImageRequest("http://www.bz55.com/uploads/allimg/130716/1-130G6111637.jpg", new Response.Listener<Bitmap>() {
                            //需要的注意的是导入Response.Listener<Bitmap>别导错包!

    @Override
    public void onResponse(Bitmap response) {
    // 将网络请求的图片返回并显示在ImageView中
       try {
    Thread.sleep(3000);//休眠3秒 
    iv_request.setImageBitmap(response);
    Toast.makeText(getApplicationContext(), " onResponse", Toast.LENGTH_SHORT).show();
    Log.d(" onResponse", response.toString());
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }

    }
    },0, 0, Config.RGB_565, new Response.ErrorListener() {


    @Override
    public void onErrorResponse(VolleyError error) {
    // 默认加载图片资源
    iv_request.setImageResource(R.drawable.ic_launcher);
    Toast.makeText(getApplicationContext(), " onErrorResponse", Toast.LENGTH_SHORT).show();
    Log.d(" onErrorResponse", error.toString());
    }
    });
     mRequestQueue.add(mImageRequest);//强图片请求添加到请求队列

    }
    public void LoadImageView() {
    // 利用ImageLoader异步加载图片
    final ImageLoader mImageLoader = new ImageLoader(mquest,
    new BitmapCache());
    ImageListener listener = ImageLoader.getImageListener(iv_request,
    R.drawable.voice_to_short, R.drawable.ic_launcher);

                    //get请求方式
    mImageLoader
    .get("https://img-my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",
    listener);
    Log.d("ImageLoader", mImageLoader.toString());
    }

    // import com.android.volley.Response.ErrorListener;
    private void volleyRequest() {
    StringRequest mRequest = new StringRequest(Method.GET, URL,
    new Response.Listener<String>() {


    @Override
    public void onResponse(String response) {
    // TODO Auto-generated method stub
    Toast.makeText(getApplicationContext(), "onResponse ",
    Toast.LENGTH_LONG).show();
    Log.d("on onResponse", response.toString());//请求成功
    }
    }, new Response.ErrorListener() {


    @Override
    public void onErrorResponse(VolleyError error) {
    // TODO Auto-generated method stub
    Toast.makeText(getApplicationContext(),
    "onErrorResponse", Toast.LENGTH_SHORT).show();
    Log.d("on ErrorReponse", error.toString());//请求失败

    }
    });
              mRequestQueue.add(mRequest);
              }
    }

    BitmapCache

    package com.weixin.cache;


    import android.graphics.Bitmap;
    import android.support.v4.util.LruCache;


    import com.android.volley.toolbox.ImageLoader.ImageCache;


    public class BitmapCache implements ImageCache {  
     
       private LruCache<String, Bitmap> cache;  
     
       public BitmapCache() {  
           cache = new LruCache<String, Bitmap>(8 * 1024 * 1024) {  
               @Override  
               protected int sizeOf(String key, Bitmap bitmap) {  
                   return bitmap.getRowBytes() * bitmap.getHeight();  
               }  
           };  
       }  
     
       @Override  
       public Bitmap getBitmap(String url) {  
           return cache.get(url);  
       }  
     
       @Override  
       public void putBitmap(String url, Bitmap bitmap) {  
           cache.put(url, bitmap);  
       }  
    }  




    布局文件activity_main.xml

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/RelativeLayout1"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical" >

        <ImageView
            android:id="@+id/iv_request"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:scaleType="fitXY"
            android:src="@drawable/bitmap" />


        <Button
            android:id="@+id/btn_request"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_centerHorizontal="true"
            android:onClick="onClick"
            android:text="获取网络请求信息" />


    </RelativeLayout>

    需要讨论的小伙伴直接加群群号 576077608当然也可以扫码



    展开全文
  • 主要介绍了Flutter 网络请求框架封装详解,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • okhttp网络请求框架
  • Android之解剖网络请求框架Volley

    万次阅读 2017-09-21 16:30:27
    Volley介绍Volley是Google推出的网络请求库,包含的特性有JSON、图像等的异步下载、网络请求的排序(scheduling)、网络请求的优先级处理、缓存、多级别取消请求、和Activity和生命周期的联动(Activity结束时同时...
  • 网络请求框架okhttp封装

    万次阅读 2017-09-18 14:35:38
    //首先是考入点的两个样子到drawable //然后写主布局 android:layout_width="match_parent" android:layout_height="match_parent" android:id="@+id/vp">;font-weight
  • 实现自己的简单网络请求框架,使用系统api,无其他框架引用,灵活扩展
  • axios网络请求框架源码解析

    千次阅读 2019-06-13 17:11:18
    并且做了对请求参数拼接、Json对象序列化等基本功能。 到0.19.0版本时,内部请求已经变为了在Node环境下与主流浏览器的支持,其中Node环境下支持http请求与https请求。并且支持取消、拦截。 Axios执行开始之初,首先...
  • 使用Android Volley网络请求框架请求数据步骤
  • URLConnection是个抽象类,它有两个直接子类分别是HttpURLConnection和... 每个 HttpURLConnection 实例都可用于生成单个请求,但是其他实例可以透明地共享连接到 HTTP 服务器的基础网络请求后在 Http
  • android 网络请求框架

    千次阅读 2019-04-17 13:49:05
    compile 'com.squareup.okhttp:okhttp-urlconnection:2.3.0' compile 'com.squareup.okhttp:okhttp:2.3.0' compile 'com.squareup.retrofit:retrofit:1.9.0' NetWorkService.java package com.newingsc...
  • android一些比较常用的网络请求框架如Xutils,volley,内部有线程池吗?如果没有,如何配合自己编写的线程池进行网络请求?
  • 目前使用较为广泛的Android网络请求框架xUtil
  • 这是我的博客Android框架 之网络请求框架系列文章第二弹的HttpUrilConnection封装的源码
  • http网络请求框架

    2019-06-15 13:48:02
    之前做项目都是用别人的网络框架,类似retrofit 、 okhttp、 fresco等框架,用的多了,发现这几个网络请求框架,无非都是 按解决以下几个问题为导向的: 1.怎么发请求? 2.Cookie的问题。 3.如何停止请求(好像...
  • 快捷使用Retrofit网络请求框架(get请求,post请求,上传文件)
  • 网络请求框架Retrofit

    2017-03-11 15:19:37
    网络请求框架,自从开发以来经历过多个网络访问框架了HttpURLConnection---> HttpClient--->Async Http Client--->Volley--->okhttp  以上这些不做重点介绍,以后可能会单独发个博客来对比他们的优缺点,想当初刚开始...
  • OkGo 网络请求框架

    千次阅读 2018-08-31 16:17:40
    //okgo implementation 'com.lzy.net:okgo:3.0.4'   package com.upenv.hnpolluction.application; import android.app.Application; import com.lzy.okgo.OkGo; import ...import...
  • Android网络请求框架之Retrofit实践

    千次阅读 2016-04-04 10:12:02
    网络访问框架经过了从使用最原始的AsyncTask构建简单的网络访问框架(甚至不能称为框架),后来使用开源的android-async-http库,再到使用google发布的volley库,一直不懈的寻找更好的解决方案,到现在也没找到,...
  • Android主流网络请求框架

    万次阅读 多人点赞 2016-10-13 16:16:51
    google推出的异步网络请求框架和图片加载框架。特别适合数据量小,通信频繁的网络操作。android绝大多数都属于这种类型,但是对于数据量比较大的操作,比如:下载,就不太适用了。 来源:...
  • 主要为大家详细介绍了Android最基本的异步网络请求框架,感兴趣的小伙伴们可以参考一下
  • okhttp网络请求框架

    2016-06-28 21:37:45
    * okhttp是非常高效的网络请求,它是基于http/http2。 * * 1、允许同一主机的所有请求共享一个socket * 2、减少网络请求时间Connection pooling reduces request latency (if HTTP/2 isn’t available). * 3、使用...
  • Retrofit网络请求框架

    2017-10-18 15:00:54
    Retrofit是 Square 公司出品的默认基于 OkHttp 封装的一套 RESTful 网络请求框架,RESTful 是目前流行的一套 api 设计的风格但并不是标准。  Retrofit 的封装可以说是很强大,里面涉及到一堆的设计模式,可以通过...
  • 网络请求 框架okhttp

    2017-11-19 22:26:50
    网络请求中,用原始的请求httpconnection请求会有很多要考虑的比如线程,流效率还有字符字节转换,这个时候我们可以使用框架,我们目前需要知道有什么联网的成熟框架,在最近两年中主要有okhttp,还有Retrofit....
  • 网络请求框架OKHttp

    2016-07-15 19:08:57
    1 前言Android为我们提供了两种Http交互方式:HttpURLConnetcion和Apach HTTP Client,虽然两者都支持HTTPS,流的上传和下载,配置超时,Ipv6和连接池,已经足够满足我们各种HTTP请求的需求。但更高效的HTTP可以让...

空空如也

1 2 3 4 5 ... 20
收藏数 10,446
精华内容 4,178
关键字:

网络请求框架