使用Volley上传头像图片

android

在Gooogle I/O 2013年的大会上面，展示的Volley库，已经成为android开发中最常用的处理和缓存网络请求的库。
如果你还没有看过Gooogle　I/O中关于Volley的介绍,在继续这篇文章之前我建议你先去看看关于Volley的介绍，对它有一些基本的理解。
中文的话可以看下这篇翻译的文章。
关于Volley的使用网上有很多的教程，这里主要讲一下如何使用Volley上传图片的问题。
这里上传的图片是头像，所以图片的大小已经固定好了。
我们有两种方式可以完成上传图片到服务器：

  • 使用Multipart Request
  • 发送图片的字符串到服务器
    我们使用Volley都可以实现。

    使用Multipart Request的方式

    Multipart Request是一种HTTP请求，可以通过HTTP客户端或者浏览器发送文件和数据到HTTP服务器，Volley 支持这种类型。

主要思路：
将需要上传的图片转换为MultipartRequest请求内容需要的数组格式，通过MultipartRequest上传到服务器，在服务器端解析。

1. 首先将我们需要上传的图片转换为数组数据。
1
2
3
4
5
6
7
8
//将图片转换为数组
public byte[] getImageBytes(Bitmap bmp){
    if(bmp==null)return null;
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	bmp.compress(Bitmap.CompressFormat.JPEG,100,baos);
	byte[] imageBytes = baos.toByteArray();
    return imageBytes;
}
2. 调用MultipartRequest请求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//设置请求的内容类型
private final String boundary = "apiclient-" + System.currentTimeMillis();
private final String mimeType = "multipart/form-data;boundary=" + boundary;
//保存内容的数组集合
private byte[] multipartBody;
//需要上传的图片
private Bitmap bitmap;
//通过MultipartRequest上传图片的方法
private void uploadAvatarByMultipart(){
    //根据图片的路径，将其转换为bitmap类型
    File file = new File(ImageUtils.getAvatarPath(activity, "user_avatar"), username + ".jpg");
    String path = file.getAbsolutePath();
    bitmap = BitmapFactory.decodeFile(path);
    //调用图片转数组的方法，获得图片的数组数据
    multipartBody = getImageBytes(bitmap);
    //上传图片到服务器的请求地址
    String url=Application.SERVER_ROOT+"?"+I.KEY_REQUEST+"="+I.REQUEST_UPLOAD_AVATAR;
    //执行MultipartRequest请求，设置上传的内容和内容类型，executeRequest会将请求添加到请求队列中。
    executeRequest(new MultipartRequest<MessageBean>(url,MessageBean.class,null, uploadAvatarByMultipartListener(),errorListener(),mimeType, multipartBody));
}
3. 自定义回调函数，可以添加对服务器请求结果的处理
1
2
3
4
5
6
7
8
private Response.Listener<MessageBean> uploadAvatarByMultipartListener() {
    return new Response.Listener<MessageBean>() {
        @Override
        public void onResponse(MessageBean messageBean) {
            Utils.showToast(mContext,"upload avatar success!!!",Toast.LENGTH_SHORT);
        }
    };
}
4. 自定义MultipartRequest，需要继承Request，并且重写getBodyContentType方法和getBody方法，分别返回传过来的内容和内容类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class MultipartRequest<T> extends Request<T> {
    private final Gson mGson = new Gson();
    private final Class<T> mClazz;
    private final Listener<T> mListener;
    private final Map<String, String> mHeaders;
    private final String mMimeType;
    private final byte[] mMultipartBody;

    public MultipartRequest(String url, Class<T> clazz, Map<String, String> headers, Listener<T> listener, ErrorListener errorListener, String mimeType, byte[] multipartBody) {
        this(Method.POST, url, clazz, headers,mimeType, multipartBody, listener, errorListener);
    }

    public MultipartRequest(int method, String url, Class<T> clazz, Map<String, String> headers, String mimeType, byte[] multipartBody, Listener<T> listener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mClazz = clazz;
        this.mHeaders = headers;
        this.mListener = listener;
        this.mMimeType = mimeType;
        this.mMultipartBody = multipartBody;
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return (mHeaders != null) ? mHeaders : super.getHeaders();
    }

    @Override
    public String getBodyContentType() {
        return mMimeType;
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        return mMultipartBody;
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
            return Response.success(mGson.fromJson(json, mClazz), HttpHeaderParser.parseCacheHeaders(response));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }
}
5. 服务器端解析数据并处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
private void uploadAvatar(HttpServletRequest request, HttpServletResponse response) throws IOException {
    String userName=request.getParameter("userName");
    String path=I.AVATAR_PATH;
    String fileName=userName+".jpg";
    System.out.println("头像上传路径:" + path + fileName);
    File file = new File(path,fileName);
    FileOutputStream fos = new FileOutputStream(file);
    byte[] buffer = new byte[1024 * 8];
    int len;
    while ((len = request.getInputStream().read(buffer)) != -1) {
    	fos.write(buffer, 0, len);
    }

    boolean isSuccess =false;
    UserBean user = biz.findUserByUserName(userName);
    user.setAvatar(typeAvatar+"/" + fileName);
    isSuccess = biz.updateUser(user);

    ObjectMapper om=new ObjectMapper();
    if(isSuccess){
    	om.writeValue(response.getOutputStream(), "上传头像成功");
    }else{
    	om.writeValue(response.getOutputStream(), "上传头像失败");
    }
    fos.close();
}

使用发送图片字符串的方式

我们这里使用的图片字符串为Base64编码的字符串。

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base64来将一个较长的唯一标识符（一般为128-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base64编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。

主要思路：
将需要上传的图片转换为Base64编码的字符串，通过Volley的StringRequest请求发生给服务器，并在服务器端解码。

1. 根据图片存储的地址，将其转化为Base64编码字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//图片转化成base64字符串
public static String getImageStr(String filePath) {
    //将图片文件转化为字节数组字符串，并对其进行Base64编码处理
    InputStream in = null;
    byte[] data = null;
    //读取图片字节数组
    try {
        in = new FileInputStream(filePath);
        data = new byte[in.available()];
        in.read(data);
        in.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    //对字节数组Base64编码
    //返回Base64编码过的字节数组字符串
    return Base64.encodeToString(data,Base64.DEFAULT);
}
2. 使用Volley的StringRequest请求，并重写getParams方法，将图片的字符串以参数的形式传递。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void uploadAvatar(){
    //此处添加progress dialog
    //设置服务器请求地址
    String url=Application.SERVER_ROOT+"?"+I.KEY_REQUEST+"="+I.REQUEST_UPLOAD_AVATAR;
    //执行StringRequest请求，请求类型为post，自定义uploadResponseListener回调函数，添加父类中公共的errorListener方法
    executeRequest(new StringRequest(Request.Method.POST,url,uploadResponseListener(),errorListener()){
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            //获取图片文件
            File file = new File(ImageUtils.getAvatarPath(activity, "user_avatar"), username + ".jpg");
            //获取图片存放地址的绝对路径
            String path = file.getAbsolutePath();
            //将图片转换为字符串
            String image = GetImageStr(path);
            //创建参数集合
            Map<String,String> params = new Hashtable<String, String>();
            //将图片字符串添加到参数集合中
            params.put("image", image);
            params.put("userName", username);
            //返回参数集合
            return params;
        }
    });
}
3. 自定义回调函数，可以添加对服务器请求结果的处理
1
2
3
4
5
6
7
8
private Response.Listener<String> uploadResponseListener() {
    return new Response.Listener<String>() {
        @Override
        public void onResponse(String s) {
            Utils.showToast(mContext,"upload avatar success!",Toast.LENGTH_SHORT);
        }
    };
}
4. 服务器端解析数据并处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private void uploadAvatar(HttpServletRequest request, HttpServletResponse response) throws IOException {
    String userName=request.getParameter("userName");
    String image = request.getParameter("image");
    String path=I.AVATAR_PATH;
    String fileName=userName+".jpg";
    System.out.println("头像上传路径:" + path + fileName);
    File file = new File(path,fileName);
    FileOutputStream fos = new FileOutputStream(file);
    BASE64Decoder decoder = new BASE64Decoder();  
    try {  
        //Base64解码  
        byte[] b = decoder.decodeBuffer(image);  
        fos.write(b);  
        fos.flush();  
        fos.close();  
    } catch (Exception e)  {  
    	System.out.print(e);
    }

    boolean isSuccess =false;
    UserBean user = biz.findUserByUserName(userName);
    user.setAvatar(typeAvatar+"/" + fileName);
    isSuccess = biz.updateUser(user);

    ObjectMapper om=new ObjectMapper();
    if(isSuccess){
        om.writeValue(response.getOutputStream(), "上传头像成功");
    }else{
        om.writeValue(response.getOutputStream(), "上传头像失败");
    }
}

好啦，以上就是使用Volley上传图片的两种方法，希望能帮助到大家。

参考：
Android Volley Tutorial to Upload Image to Server
Working POST Multipart Request with Volley and without HttpEntity