将本地图片上传到服务器中

上次讲了如何拍照上传并保存图片至sd下，但只实现了拍照功能，却没有实现上传，这次补上咯...

其实对于上传自己也写过，也参考过别人的代码但是没有实现，无奈，只好去下载别人的源码了，这次终于实现了..

不多说，源码附上

1、当前类实现OnUploadProcessListener

它的方法是：这里用Handler去处理

    //上传完成
    @Override
    public void onUploadDone(int responseCode, String message) {
        Message msg = Message.obtain();
        msg.what = 3;
        msg.arg1 = responseCode;
        msg.obj = message;
        handler.sendMessage(msg);
    }

    //正在上传
    @Override
    public void onUploadProcess(int uploadSize) {
        Message msg=Message.obtain();
        msg.what=2;
        msg.arg1=uploadSize;
        handler.sendMessage(msg);
    }

    //开始上传
    @Override
    public void initUpload(int fileSize) {
        Message msg=Message.obtain();
        msg.what=1;
        msg.arg1=fileSize;
        handler.sendMessage(msg);
    }

2、实现上传调用方法（携带的参数正是图片所在sd路径）

 //上传图片（当前图片的路径：imgpath、服务器的路径：requestURL，参数：param）
    public void uploadMyPhoto(String imgpath){
        if(imgpath!=null){
            String filekey="img";//设置格式
            UploadUtil uploadUtil = UploadUtil.getInstance();;
            uploadUtil.setOnUploadProcessListener(this);//设置监听器监听上传状态
            Map<String,String> param=new HashMap<String,String>();
            uploadUtil.uploadFile(imgpath, filekey, requestURL, param);
        }
    }

3、客户端上传的源码（UploadUtil工具类）

package com.techrare.utils;

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.Iterator;
import java.util.Map;
import java.util.UUID;

import android.util.Log;

//上传工具类 支持上传文件和参数
public class UploadUtil {
    private static UploadUtil uploadUtil;
    private static final String BOUNDARY =  UUID.randomUUID().toString(); // 边界标识 随机生成
    private static final String PREFIX = "--";
    private static final String LINE_END = "
";
    private static final String CONTENT_TYPE = "multipart/form-data"; // 内容类型
    private UploadUtil() {

    }
    /**
     * 单例模式获取上传工具类
     * @return
     */
    public static UploadUtil getInstance() {
        if (null == uploadUtil) {
            uploadUtil = new UploadUtil();
        }
        return uploadUtil;
    }

    private static final String TAG = "UploadUtil";
    private int readTimeOut = 10 * 1000; // 读取超时
    private int connectTimeout = 10 * 1000; // 超时时间
    private static int requestTime = 0;    //请求使用多长时间
    private static final String CHARSET = "utf-8"; // 设置编码
    public static final int UPLOAD_SUCCESS_CODE = 1; //上传成功
    //文件不存在
    public static final int UPLOAD_FILE_NOT_EXISTS_CODE = 2;
    //服务器出错
    public static final int UPLOAD_SERVER_ERROR_CODE = 3;
    protected static final int WHAT_TO_UPLOAD = 1;
    protected static final int WHAT_UPLOAD_DONE = 2;
    
    /**
     * android上传文件到服务器
     * 
     * @param filePath
     *            需要上传的文件的路径
     * @param fileKey
     *            在网页上<input type=file name=xxx/> xxx就是这里的fileKey
     * @param RequestURL
     *            请求的URL
     */
    public void uploadFile(String filePath, String fileKey, String RequestURL,
            Map<String, String> param) {
        if (filePath == null) {
            sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");
            return;
        }
        try {
            File file = new File(filePath);
            uploadFile(file, fileKey, RequestURL, param);
        } catch (Exception e) {
            sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");
            e.printStackTrace();
            return;
        }
    }

    /**
     * android上传文件到服务器
     * 
     * @param file
     *            需要上传的文件
     * @param fileKey
     *            在网页上<input type=file name=xxx/> xxx就是这里的fileKey
     * @param RequestURL
     *            请求的URL
     */
    public void uploadFile(final File file, final String fileKey,
            final String RequestURL, final Map<String, String> param) {
        if (file == null || (!file.exists())) {
            sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");
            return;
        }

        Log.i(TAG, "请求的URL=" + RequestURL);
        Log.i(TAG, "请求的fileName=" + file.getName());
        Log.i(TAG, "请求的fileKey=" + fileKey);
        new Thread(new Runnable() {  //开启线程上传文件
             
            public void run() {
                toUploadFile(file, fileKey, RequestURL, param);
            }
        }).start();
        
    }

    private void toUploadFile(File file, String fileKey, String RequestURL,
            Map<String, String> param) {
        String result = null;
        requestTime= 0;
        
        long requestTime = System.currentTimeMillis();
        long responseTime = 0;

        try {
            URL url = new URL(RequestURL);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(readTimeOut);
            conn.setConnectTimeout(connectTimeout);
            conn.setDoInput(true); // 允许输入流
            conn.setDoOutput(true); // 允许输出流
            conn.setUseCaches(false); // 不允许使用缓存
            conn.setRequestMethod("POST"); // 请求方式
            conn.setRequestProperty("Charset", CHARSET); // 设置编码
            conn.setRequestProperty("connection", "keep-alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);
//            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            
            //当文件不为空，把文件包装并且上传
            DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
            StringBuffer sb = null;
            String params = "";
            
            /***
             * 以下是用于上传参数
             */
            if (param != null && param.size() > 0) {
                Iterator<String> it = param.keySet().iterator();
                while (it.hasNext()) {
                    sb = null;
                    sb = new StringBuffer();
                    String key = it.next();
                    String value = param.get(key);
                    sb.append(PREFIX).append(BOUNDARY).append(LINE_END);
                    sb.append("Content-Disposition: form-data; name="").append(key).append(""").append(LINE_END).append(LINE_END);
                    sb.append(value).append(LINE_END);
                    params = sb.toString();
                    Log.i(TAG, key+"="+params+"##");
                    dos.write(params.getBytes());
//                    dos.flush();
                }
            }
            
            sb = null;
            params = null;
            sb = new StringBuffer();
            /**
             * 这里重点注意： name里面的值为服务器端需要key 只有这个key 才可以得到对应的文件
             * filename是文件的名字，包含后缀名的 比如:abc.png
             */
            sb.append(PREFIX).append(BOUNDARY).append(LINE_END);
            sb.append("Content-Disposition:form-data; name="" + fileKey
                    + ""; filename="" + file.getName() + """ + LINE_END);
            sb.append("Content-Type:image/pjpeg" + LINE_END); // 这里配置的Content-type很重要的 ，用于服务器端辨别文件的类型的
            sb.append(LINE_END);
            params = sb.toString();
            sb = null;
            
            Log.i(TAG, file.getName()+"=" + params+"##");
            dos.write(params.getBytes());
            /**上传文件*/
            InputStream is = new FileInputStream(file);
            onUploadProcessListener.initUpload((int)file.length());
            byte[] bytes = new byte[1024];
            int len = 0;
            int curLen = 0;
            while ((len = is.read(bytes)) != -1) {
                curLen += len;
                dos.write(bytes, 0, len);
                onUploadProcessListener.onUploadProcess(curLen);
            }
            is.close();
            
            dos.write(LINE_END.getBytes());
            byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINE_END).getBytes();
            dos.write(end_data);
            dos.flush();    
            //dos.write(tempOutputStream.toByteArray());
            
            //获取响应码 200=成功 当响应成功，获取响应的流
            int res = conn.getResponseCode();
            responseTime = System.currentTimeMillis();
            this.requestTime = (int) ((responseTime-requestTime)/1000);
            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);
                sendMessage(UPLOAD_SUCCESS_CODE, "上传结果："
                        + result);
                return;
            } else {
                Log.e(TAG, "request error");
                sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：code=" + res);
                return;
            }
        } catch (MalformedURLException e) {
            sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：error=" + e.getMessage());
            e.printStackTrace();
            return;
        } catch (IOException e) {
            sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：error=" + e.getMessage());
            e.printStackTrace();
            return;
        }
    }

    //发送上传结果
    private void sendMessage(int responseCode,String responseMessage)
    {
        onUploadProcessListener.onUploadDone(responseCode, responseMessage);
    }
    
    //自定义的回调函数，用到回调上传文件是否完成
    public static interface OnUploadProcessListener {
        /**
         * 上传响应
         * @param responseCode
         * @param message
         */
        void onUploadDone(int responseCode, String message);
        /**
         * 上传中
         * @param uploadSize
         */
        void onUploadProcess(int uploadSize);
        /**
         * 准备上传
         * @param fileSize
         */
        void initUpload(int fileSize);
    }
    private OnUploadProcessListener onUploadProcessListener;
    

    public void setOnUploadProcessListener(OnUploadProcessListener onUploadProcessListener) {
        this.onUploadProcessListener = onUploadProcessListener;
    }

    public int getReadTimeOut() {
        return readTimeOut;
    }

    public void setReadTimeOut(int readTimeOut) {
        this.readTimeOut = readTimeOut;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }
    //获取上传使用的时间
    public static int getRequestTime() {
        return requestTime;
    }

    public static interface uploadProcessListener{
        
    }
}

4、服务端的源码（服务端是用struts实现的）

package com.techrare.web;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.text.DecimalFormat;

import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class UploadAction extends ActionSupport {

    private String savePath;
    /**这里的名字和html的名字必须对称*/
    private File img;
    /**要上传的文件类型*/
    private String imgContentType;                                       
    /**文件的名称*/
    private String imgFileName;
    /**
     * 指定的上传类型   zip 和   图片格式的文件
     */
    private static final String[] types = { "application/x-zip-compressed",
            "ZIP", "image/pjpeg","image/x-png" };  //"application/octet-stream; charset=utf-8",
    /***
     * 判断文件的类型是否为指定的文件类型
     * @return
     */
    public boolean filterType() {
        boolean isFileType = false;
        String fileType = getImgContentType();
        System.out.println(fileType);
        for (String type : types) {
            if (type.equals(fileType)) {
                isFileType = true;
                break;
            }
        }
        return true;
    }

    public String getSavePath() {
        String realPath = ServletActionContext.getRequest().getRealPath(savePath);
        System.out.println("savePaht -- 保存地址" + realPath);
        return realPath;
    }

    /**
     * 取得文件夹大小
     * @param f
     * @return
     * @throws Exception
     */
    public long getFileSize(File f) throws Exception {
        return f.length();
    }

    public String FormetFileSize(long fileS) {// 转换文件大小
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        if (fileS < 1024) {
            fileSizeString = df.format((double) fileS) + "B";
        } else if (fileS < 1048576) {
            fileSizeString = df.format((double) fileS / 1024) + "K";
        } else if (fileS < 1073741824) {
            fileSizeString = df.format((double) fileS / 1048576) + "M";
        } else {
            fileSizeString = df.format((double) fileS / 1073741824) + "G";
        }
        return fileSizeString;
    }

    /**
     * 上传文件操作
     * @return
     * @throws Exception
     */
    public String upload() throws Exception {
        
        String ct  =  ServletActionContext.getRequest().getHeader("Content-Type");
        System.out.println("Content-Type=（访问头文件）"+ct);
        String result = "unknow error";
        
        PrintWriter out = ServletActionContext.getResponse().getWriter();
        if (!filterType()) {
            System.out.println("文件类型不正确");
            ServletActionContext.getRequest().setAttribute("typeError",
                    "您要上传的文件类型不正确");

            result = "error:" + getImgContentType() + " type not upload file type";
        } else {
            System.out.println("当前文件大小为："
                    + FormetFileSize(getFileSize(getImg())));
            FileOutputStream fos = null;
            FileInputStream fis = null;
            try {
                // 保存文件那一个路径
                fos = new FileOutputStream(getSavePath() + "\"
                        + getImgFileName());
                fis = new FileInputStream(getImg());
                byte[] buffer = new byte[1024];
                int len = 0;
                while ((len = fis.read(buffer)) > 0) {
                    fos.write(buffer, 0, len);
                }
                //result = "上传成功!";
                result = "Upload File Success !";
            } catch (Exception e) {
                result = "Upload File Failed ! ";
                e.printStackTrace();
            } finally {
                fos.close();
                fis.close();
            }
        }
        out.print(result);
        return null;
    }
    
    public File getImg() {
        return img;
    }

    public String getImgFileName() {
        return imgFileName;
    }

    public void setSavePath(String value) {
        this.savePath = value;
    }

    public void setImgFileName(String imgFileName) {
        this.imgFileName = imgFileName;
    }

    public void setImg(File img) {
        this.img = img;
    }

    public String getImgContentType() {
        return imgContentType;
    }

    public void setImgContentType(String imgContentType) {
        this.imgContentType = imgContentType;
    }
}

到这、拍照上传图片已经基本上实现了...