Android 图片或者文件上传服务器（Android+Struts2）

在很多时候都遇到了客户端需要向服务器上传文件，但是网上的资料很多，但是仅仅只是说了手机上如何上传服务器，而服务器端没有描述。回过头来，其实无论是手机还是网页上，上传文件，其本质都是一样，这里我主要是使用http协议来进行上传。而服务器端，和普通的网页上传均是一样的的.。下面贴出代码。以后好用。。。这里的Android端代码Copy别人，忘记是哪位大神的了，不好意思。

首先是Android端：
1. 上传工具类

    package com.bruce.deiv.mobilesell.utils;

import android.util.Log;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.UUID;

/**
 * Created by bruce on 15/5/9.
 */
public class FileUpload {


private static final String TAG = "uploadFile";


private static final int TIME_OUT = 10 * 1000; // 超时时间


private static final String CHARSET = "utf-8"; // 设置编码


/**
 * Android上传文件到服务端
 *
 * @param file       需要上传的文件
 * @param RequestURL 请求的rul
 * @return 返回响应的内容
 */
public static String uploadFile(File file, String RequestURL) {
    String result = null;
    String BOUNDARY = UUID.randomUUID().toString(); // 边界标识 随机生成
    String PREFIX = "--", LINE_END = "\r\n";
    String CONTENT_TYPE = "multipart/form-data"; // 内容类型


    try {
        URL url = new URL(RequestURL);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(TIME_OUT);
        conn.setConnectTimeout(TIME_OUT);
        conn.setDoInput(true); // 允许输入流
        conn.setDoOutput(true); // 允许输出流
        conn.setUseCaches(false); // 不允许使用缓存
        conn.setRequestMethod("POST"); // 请求方式
        conn.setRequestProperty("Charset", CHARSET); // 设置编码
        conn.setRequestProperty("connection", "keep-alive");
        conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);


        if (file != null) {
            /**
             * 当文件不为空，把文件包装并且上传
             */
            DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
            StringBuffer sb = new StringBuffer();
            sb.append(PREFIX);
            sb.append(BOUNDARY);
            sb.append(LINE_END);
            /**
             * 这里重点注意： name里面的值为服务端需要key 只有这个key 才可以得到对应的文件
             * filename是文件的名字，包含后缀名的 比如:abc.png
             */


            sb.append("Content-Disposition: form-data; name=\"uploadfile\"; filename=\""
                    + file.getName() + "\"" + LINE_END);
            sb.append("Content-Type: application/octet-stream; charset=" + CHARSET + LINE_END);
            sb.append(LINE_END);
            dos.write(sb.toString().getBytes());
            InputStream is = new FileInputStream(file);
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = is.read(bytes)) != -1) {
                dos.write(bytes, 0, len);
            }
            is.close();
            dos.write(LINE_END.getBytes());
            byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINE_END).getBytes();
            dos.write(end_data);
            dos.flush();
            /**
             * 获取响应码 200=成功 当响应成功，获取响应的流
             */
            int res = conn.getResponseCode();
            Log.e(TAG, "response code:" + res);
            // if(res==200)
            // {
            Log.e(TAG, "request success");
            InputStream input = conn.getInputStream();
            StringBuffer sb1 = new StringBuffer();
            int ss;
            while ((ss = input.read()) != -1) {
                sb1.append((char) ss);
            }
            result = sb1.toString();
            Log.e(TAG, "result : " + result);
            // }
            // else{
            // Log.e(TAG, "request error");
            // }
        }
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}


/**
 * 通过拼接的方式构造请求内容，实现参数传输以及文件传输
 *
 * @param url    Service net address
 * @param params text content
 * @param files  pictures
 * @return String result of Service response
 * @throws IOException
 */
public static String post(String url, Map<String, String> params, Map<String, File> files)
        throws IOException, IOException {
    String BOUNDARY = java.util.UUID.randomUUID().toString();
    String PREFIX = "--", LINEND = "\r\n";
    String MULTIPART_FROM_DATA = "multipart/form-data";
    String CHARSET = "UTF-8";


    URL uri = new URL(url);
    HttpURLConnection conn = (HttpURLConnection) uri.openConnection();
    conn.setReadTimeout(10 * 1000); // 缓存的最长时间
    conn.setDoInput(true);// 允许输入
    conn.setDoOutput(true);// 允许输出
    conn.setUseCaches(false); // 不允许使用缓存
    conn.setRequestMethod("POST");
    conn.setRequestProperty("connection", "keep-alive");
    conn.setRequestProperty("Charsert", "UTF-8");
    conn.setRequestProperty("Content-Type", MULTIPART_FROM_DATA + ";boundary=" + BOUNDARY);


    // 首先组拼文本类型的参数
    StringBuilder sb = new StringBuilder();
    for (Map.Entry<String, String> entry : params.entrySet()) {
        sb.append(PREFIX);
        sb.append(BOUNDARY);
        sb.append(LINEND);
        sb.append("Content-Disposition: form-data; name=\"" + entry.getKey() + "\"" + LINEND);
        sb.append("Content-Type: text/plain; charset=" + CHARSET + LINEND);
        sb.append("Content-Transfer-Encoding: 8bit" + LINEND);
        sb.append(LINEND);
        sb.append(entry.getValue());
        sb.append(LINEND);
    }


    DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());
    outStream.write(sb.toString().getBytes());
    // 发送文件数据
    if (files != null)
        for (Map.Entry<String, File> file : files.entrySet()) {
            StringBuilder sb1 = new StringBuilder();
            sb1.append(PREFIX);
            sb1.append(BOUNDARY);
            sb1.append(LINEND);
            sb1.append("Content-Disposition: form-data; name=\"uploadfile\"; filename=\""
                    + file.getValue().getName() + "\"" + LINEND);
            sb1.append("Content-Type: application/octet-stream; charset=" + CHARSET + LINEND);
            sb1.append(LINEND);
            outStream.write(sb1.toString().getBytes());


            InputStream is = new FileInputStream(file.getValue());
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = is.read(buffer)) != -1) {
                outStream.write(buffer, 0, len);
            }


            is.close();
            outStream.write(LINEND.getBytes());
        }


    // 请求结束标志
    byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();
    outStream.write(end_data);
    outStream.flush();
    // 得到响应码
    int res = conn.getResponseCode();
    InputStream in = conn.getInputStream();
    StringBuilder sb2 = new StringBuilder();
    if (res == 200) {
        int ch;
        while ((ch = in.read()) != -1) {
            sb2.append((char) ch);
        }
    }
    outStream.close();
    conn.disconnect();
    return sb2.toString();
}


}

2. 工具类的使用：

class FileUpLoadSync extends AsyncTask<String,Integer,String>
{
    @Override
    protected String doInBackground(String... params) {
        final Map<String, String> param = new HashMap<String, String>();
        param.put("x", String.valueOf(visiteSure.getX()));
        param.put("y", String.valueOf(visiteSure.getY()));
        param.put("name",String.valueOf(visiteSure.getName()));

        final Map<String, File> files = new HashMap<String, File>();
        if(!TextUtils.isEmpty(visiteSure.getPhoto()))
        {
            files.put("file", new File(visiteSure.getPhoto()));

        }
        final String request;
        try {
            request = FileUpload.post(params[0], param, files);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        return request;
    }

}

使用该线程
new FileUpLoadSync().execute(Config.addTaskSure);
3. 接下来是服务器端。

服务器端接受数据需要和参数的名称相同，否则数据是接收不到的，当然也可以使用Request手动接收，那就另当别论了

private String fileContentType;// 封装文件类型
private String fileFileName;// 封装文件名
private String savePath;// 保存路径
private File uploadfile;
private String uploadfileContentType;
private String uploadfileFileName;

这些参数写上get set

主要这里的

    getSavePath()
{

return ServletActionContext.getServletContext().getRealPath(savePath);
}
我需要使用绝度路径，不然会出错
public void add(){
    //从网页接收数据成一个签到对象
    //通过service层的方法将新对象加入数据表
    System.out.println(sure);

System.out.println(savePath+","+uploadfile+","+uploadfileContentType+","+uploadfileFileName);
//查看接收都的参数      //null,null,null,/upload/visitesure,upload/upload_3869a819_887e_4b3c_9df5_3487b67c72ee_00000003.tmp,application/octet-stream; charset=UTF-8,20150509_033126.jpg

        try {
            if (uploadfile != null) {
                String filename = FileUpLoad.fileUpload(uploadfile,
                        this.getSavePath(), uploadfileFileName);
                sure.setPhoto("upload/visitesure/" + filename);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        visiteTaskSureService.create(sure);

    }

Action配置

<action name="visiteTaskSureAction_*" class="visiteTaskSureAction"
            method="{1}">
            <!-- 配置fileUpload拦截器 -->
            <interceptor-ref name="fileUpload">
                <!-- 配置允许上传的文件类型 -->
    <!--            <param name="allowedTypes">image/x-ms-bmp,image/jpeg,image/g
                    if,image/png,image/x-png,application/excel,application/vnd.ms-excel</param> -->
                <!-- 配置允许上传的文件大小 -->
                <param name="maximumSize">2048000</param>
            </interceptor-ref>
            <!-- 配置上传文件的保存的相对路径 -->
            <param name="savePath">/upload/visitesure</param>
            <result name="success">/page/visiteTaskSure/visiteTaskSure_index.jsp</result>

最后是服务器端的上传工具类

package com.tos.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import org.apache.commons.io.IOUtils;

public class FileUpLoad {

    public static String fileUpload(File file, String path, String fileFileName)
            throws IOException {
        // 读取内容到InputStream
        InputStream is = new FileInputStream(file);

        String filename = UUID.randomUUID()
                + fileFileName.substring(fileFileName.lastIndexOf('.'));

        File pathFile = new File(path);
        if (!pathFile.exists()) {
            pathFile.mkdirs();
        }
        System.out.println(pathFile.getAbsolutePath());
        File fileOT = new File(pathFile,filename);
    System.out.println(fileOT.getAbsolutePath());   


        // 创建输出流，生成新文件
        OutputStream os = new FileOutputStream(fileOT);
        // 将InputStream里的byte拷贝到OutputStream
        IOUtils.copy(is, os);
        os.flush();
        IOUtils.closeQuietly(is);
        IOUtils.closeQuietly(os);
        return filename;
    }
}