将音频文件从android发送到servlet

Question

如何从Android手机向servlet发送音频文件。我已经浏览了这么多网站但没有得到正确的解决方案。任何人都可以帮助我。有多少方法可以将音频文件从android发送到服务器。

Answer 1

<强> HttpRequestWithEntity.java

import java.net.URI;
import java.net.URISyntaxException;

import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;

public class HttpRequestWithEntity extends HttpEntityEnclosingRequestBase {

    private String method;

    public HttpRequestWithEntity(String url, String method) {
        if (method == null || (method != null && method.isEmpty())) {
            this.method = HttpMethod.GET;
        } else {
            this.method = method;
        }
        try {
            setURI(new URI(url));
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getMethod() {
        return this.method;
    }

}

如果您想要上传照片或视频，可以在此处显示进度条。

public static class UploadPhoto extends AsyncTask<String, Void, InputStream> {
    private static final String TAG = "UploadImage";
    byte[] buffer;
    byte[] data;
    //private long dataLength = 0;
    private INotifyProgressBar iNotifyProgressBar;
    private int user_id;
    private IAddNewItemOnGridView mAddNewItemOnGridView;
    public UploadPhoto(INotifyProgressBar iNotifyProgressBar, 
            IAddNewItemOnGridView mAddNewItemOnGridView, int user_id) {
        this.iNotifyProgressBar = iNotifyProgressBar;
        this.user_id = user_id;
        this.mAddNewItemOnGridView = mAddNewItemOnGridView;
    }

    @Override
    protected InputStream doInBackground(String... names) {
        File mFile = null;
        FileBody mBody = null;
        File dcimDir = null;
        try {
            String fileName = names[0];
            dcimDir = Environment
                    .getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM);
            mFile = new File(dcimDir, Def.PHOTO_TEMP_DIR + fileName);
            if (!mFile.isFile()) {
                iNotifyProgressBar.notify(0, UploadStatus.FAILED);
                return null;
            }
            HttpClient httpClient = new DefaultHttpClient();
            HttpPost postRequest = new HttpPost(Def.BASE_URL 
                    + String.format("/%d/list", this.user_id));
            final int maxBufferSize = 10 * 1024;
            mBody = new FileBody(mFile, fileName, "image/jpeg", "UTF-8"){
                int bytesRead, bytesAvailable, bufferSize;
                InputStream mInputStream = super.getInputStream();
                int dataLength = mInputStream.available();
                @Override
                public void writeTo(OutputStream out) throws IOException {
                    bytesAvailable = mInputStream.available();
                    bufferSize = Math.min(bytesAvailable, maxBufferSize);
                    buffer = new byte[bufferSize];
                    bytesRead = mInputStream.read(buffer, 0, bufferSize);
                    while (bytesRead > 0) {
                        out.write(buffer, 0, bufferSize);
                        bytesAvailable = mInputStream.available();
                        bufferSize = Math.min(bytesAvailable, maxBufferSize);
                        bytesRead = mInputStream.read(buffer, 0, bufferSize);
                        int progress = (int) (100 - ((bytesAvailable * 1.0) / dataLength) * 100);
                        Log.d(TAG, "Result: " + progress + "%");
                        if (progress == 100) {
                            iNotifyProgressBar.notify(progress, UploadStatus.SUCCESS);
                        } else {
                            iNotifyProgressBar.notify(progress, UploadStatus.UPLOADING);
                        }
                    }
                }
                @Override
                protected void finalize() throws Throwable {
                    super.finalize();
                    if (mInputStream != null) {
                        mInputStream.close();
                    }
                }   
            };

            MultipartEntity reqEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);              
            reqEntity.addPart("photo", mBody);
            postRequest.setEntity(reqEntity);
            HttpResponse response = httpClient.execute(postRequest);
            InputStream mInputStream = response.getEntity().getContent();
            return mInputStream == null ? null : mInputStream;
        } catch (IOException e) {
            Log.e(TAG, "Error causes during upload image: " + e.getMessage());
            e.printStackTrace();
            iNotifyProgressBar.notify(0, UploadStatus.FAILED);
        } finally {
            Log.v(TAG, "Close file");
            if (mFile != null) {
                mFile = null;
            }
            if (mBody != null) {
                mBody = null;
            }
            if (dcimDir != null) {
                dcimDir = null;
            }
        }
        return null;
    }

    @Override
    protected void onPostExecute(InputStream result) {
        if (result == null) {
            iNotifyProgressBar.notify(0, UploadStatus.FAILED);
        } else {
            PhotoInfo mPhotoInfo = ApiUtils.convertStreamToPhotoInfo(result);
            if (mAddNewItemOnGridView != null && mPhotoInfo != null) {
                mAddNewItemOnGridView.notifyAdded(mPhotoInfo);
                Log.d(TAG, "Upload completed!!");
            } else {
                Log.d(TAG, "Upload is failed!!");
                iNotifyProgressBar.notify(0, UploadStatus.FAILED);
            }
        }
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }
}

<强>的Servlet

    package jp.co.bits.cpa.controller;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.io.FileUtils;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.rest.DefaultHttpHeaders;
import org.apache.struts2.rest.HttpHeaders;

@ParentPackage(value="json-default")
@Namespace("/api/users/{user_id}")
@Result(
        name=MyAction.GETDATA, type="json", 
        params={
                "excludeNullProperties", "true",
                "excludeProperties", "list.*\\.owner_id"
        })
public class ListController implements Status, MyAction { //ModelDriven<Object>, 
    private static int STATUS = REQUEST_INVALID;
    private File file;
    private String contentType;
    private String filename;
    private String contentDisposition = "inline";
    private String user_id;
    private String sort; // asc || desc
    private String type; // thumbnail || full
    private String photo_id;    
    private PhotoHandler photoHandler = new PhotoHandler();
    private HttpServletRequest request = ServletActionContext.getRequest();
    private InputStream fileInputStream;
    private String photoUrl;
    private List<Photo> list = new ArrayList<Photo>();
    private Photo photo;

    @Actions(    
            value={
                    @Action(results={
                            @Result(name=SUCCESS, type="stream",  
                                    params={
                                    "contentType", "image/jpeg",
                                    "inputName", "fileInputStream",
                                    "contentDisposition", "filename=\"photo.jpg\"",
                                    "bufferSize", "1024",
                                    "allowCaching", "false"
                            }),
                            @Result(name=UPLOAD, type="json", params={
                                    "excludeNullProperties", "true",
                                    "allowCaching", "false",
                                    "excludeProperties", "contentType,photoFilename"
                            })
                        })
            }
    )

    public HttpHeaders execute() throws FileNotFoundException {
        HttpMethod method = HttpMethod.valueOf(request.getMethod());
        String action = GETDATA;
        switch (method) {
            case GET: {
                System.out.println("GET...");
                if (this.sort != null && this.type == null) {
                    System.out.println(this.user_id);
                    STATUS = photoList();
                } else if (this.type != null){
                    STATUS = download();
                    if (STATUS == CREATED) {
                        fileInputStream = new FileInputStream(new File(photoUrl));
                        if (fileInputStream != null) {
                            System.out.println("FileInputStream: " + fileInputStream.toString());
                        }
                    }
                    return new DefaultHttpHeaders(STATUS == CREATED ? SUCCESS : GETDATA).withStatus(STATUS);
                } else {
                    STATUS = REQUEST_INVALID;
                }
                break;
            }
            case POST: {
                System.out.println("Upload file...");
                STATUS = saveFile();
                System.out.println("Status: " + STATUS);
                action = UPLOAD;
                break;
            }
            default:
                break;
        }
        System.out.println("Status: " + STATUS);
        return new DefaultHttpHeaders(action).withStatus(STATUS);
    }

    public InputStream getFileInputStream() {
        if (this.fileInputStream != null) {
            return this.fileInputStream;
        } else {
            return null;
        }
    }
    /**
     * 
     * Get list photo by user_id and sort type (asc || desc)
     * @return status code
     */
    public int photoList() {
        System.out.println("Get list...");
        list.clear();
        if (user_id == null || this.sort == null) {
            return REQUEST_INVALID;
        } else {
            if (sort.equalsIgnoreCase(Def.SORT_ASC) || 
                    sort.equalsIgnoreCase(Def.SORT_DESC)) {
                List<Photo> mPhotos = photoHandler.getList(user_id, this.sort);
                if (mPhotos.size() == 0) {
                    return NO_PHOTO;
                } else {
                    list.addAll(mPhotos);
                    return OK;
                }
            } else {
                return REQUEST_INVALID;
            }
        }
    }

    /**
     * using download image by using photo_id and type of photo (thumbnail || full)
     * @return status code
     */
    public int download() {
        list.clear();
        System.out.println("Download...");
        if (type == null) {
            type = Def.PHOTO_THUMBNAIL;
        } else {
            if (photo_id == null) {
                return REQUEST_INVALID;
            }
        }
        if (type.equalsIgnoreCase(Def.PHOTO_THUMBNAIL) || 
                type.equalsIgnoreCase(Def.PHOTO_FULL)) {
            String url = photoHandler.getUrl(this.photo_id, this.type);
            if (url == null) {
                return NO_PHOTO;
            } else {
                request = ServletActionContext.getRequest();
                @SuppressWarnings("deprecation")
                String path = request.getRealPath("/images/files/");
                photoUrl = path + "/" + url;
                return CREATED;
            }
        } else {
            return REQUEST_INVALID;
        }
    }

    /**
     * 
     * @param pathImage
     * @return true or false
     */
    private boolean cropImage(String pathImage) {
        Image originalImage;
        BufferedImage thumbImage;
        try {
            originalImage = ImageIO.read(this.file);
            thumbImage = Utils.makeThumbnail(originalImage, 100, 100, true);
            File thumbFile = new File(pathImage);
            System.out.println("Crop... " + pathImage);
            return ImageIO.write(thumbImage, Def.DEFAULT_PHOTO_TYPE, 
                    thumbFile);
        } catch (Exception e) {
            System.out.println("Error at CropIMAGE: " + e.getMessage());
            return false;
        }
    }

    private int saveFile() {
        try {
            int userId = Integer.parseInt(this.user_id); // Parse user_id can be failed

            if (file != null && new UserHandler().isExisted(userId)) { // user_id always != null, please change to check user_id existed
                System.out.println("Save File...");
                request = ServletActionContext.getRequest();
                @SuppressWarnings("deprecation")
                String path = request.getRealPath("/images/files/");
                System.out.println("Path-->: " + path);
                System.out.println(this.filename); // Save file name to database

                File fileToCreate = new File(path, this.filename);        
                String thumb_url = Def.THUMBNAIL_PREFIX + this.filename;
                try {
                    FileUtils.copyFile(this.file, fileToCreate);
                    if (fileToCreate.isFile()) {
//                      int photoId = photoHandler.insertGetId(new Photo(
//                              Integer.parseInt(this.user_id), this.filename, 
//                              this.filename, thumb_url));
                        if (cropImage(path + "/" + thumb_url)) {
                            this.photo = photoHandler.insertGetPhoto(new Photo(
                                    Integer.parseInt(this.user_id), this.filename, 
                                    this.filename, thumb_url));
                            if (photo != null) {
                                return CREATED;
                            } else {
                                return REQUEST_INVALID;
                            }
                        } else {
                            System.out.println("Crop failed");
                            return REQUEST_INVALID;
                        }
                    } else {
                        System.out.println("create failed");
                        return REQUEST_INVALID;
                    }
                } catch (IOException e) {
                    System.out.println("Error at Save file: " + e.getMessage());
                    if (fileToCreate.isFile()) { // Sometime, we upload fail but the filename or file still created.
                        fileToCreate.delete();
                    }
                    return REQUEST_INVALID;
                }
            } else {
                System.out.println("File not found");
                return REQUEST_INVALID;
            }           
        } catch (Exception e) {
            return REQUEST_INVALID;
        }
    }

    public void setPhoto(File file) {
        System.out.println("Set Photo File...");
        this.file = file;
    }

    public void setPhotoContentType(String contentType) {
        this.setContentType(contentType);
    }

    public void setPhotoFileName(String filename) {
        this.filename = filename;
    }

    /**
     * 
     * Get list for parse json
     * @return list for parse json
     */
    public List<Photo> getList() {
        if (list.size() > 0) {
            return list;
        } else {
            return null;
        }
    }
    public String getPhotoFilename() {
        if (this.filename == null) {
            return null;
        }
        if (this.filename.isEmpty()) {
            return null;
        }
        return this.filename;

    }
    public void setServletRequest(HttpServletRequest servletRequest) {
        this.request = servletRequest;
    }   
    public void setPhotoContentDisposition(String contentDisposition) {
        this.setContentDisposition(contentDisposition);
    } 
    public void setContentDisposition(String contentDisposition) {
        this.contentDisposition = contentDisposition;
    }
    public String getContentDisposition() {
        if (this.contentDisposition == null) {
            return null;
        }
        if (this.contentDisposition.isEmpty()) {
            return null;
        }
        if (this.contentDisposition.equals("inline")) {
            return null;
        }
        return this.contentDisposition;
    }
    public String getContentType() {
        if (this.contentType == null) {
            return null;
        }
        if (this.contentType.isEmpty()) {
            return null;
        }
        return this.contentType;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    public void setSort(String sort) {
        this.sort = sort.trim();
    }
    public void setPhoto_id(String photo_id) {
        this.photo_id = photo_id.trim();
    }
    public void setType(String type) {
        this.type = type.trim();
    }
    public void setContentType(String contentType) {
        this.contentType = contentType;
    }   

    public Photo getPhoto() {
        return photo;
    }

    public void setPhoto(Photo detail) {
        this.photo = detail;
    }
}

Answer 2

最后，我成功地将音频文件从android发送到servlet。以下是我的客户端代码

public class MainActivity extends Activity {

//   static final String UPLOAD_URL = "http://192.168.223.1:8080/ReceiveFileServlet/RecFileServlet";
     static final int BUFFER_SIZE = 4096;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new sendFile().execute(new String[] { "http://10.0.2.2:8080/ReceiveFileServlet/RecFileServlet" });
    }
    private class sendFile extends AsyncTask<String, Void, String>
    {

        @Override
        protected String doInBackground(String... urls) {
            HttpURLConnection httpConn=null;

            try
            {
            String file = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Tdt.aac";
            File uploadFile = new File(file);
            FileInputStream inputStream = new FileInputStream(uploadFile);

            System.out.println("File to upload: " + file);

            // creates a HTTP connection
            URL url1 = new URL(urls[0]);
            httpConn = (HttpURLConnection) url1.openConnection();
            httpConn.setUseCaches(false);
            httpConn.setDoOutput(true);
            httpConn.setRequestMethod("POST");
            httpConn.setRequestProperty("fileName", uploadFile.getName());
            httpConn.connect();
            // sets file name as a HTTP header

            Log.i("fileName", uploadFile.getName());
            // opens output stream of the HTTP connection for writing data

            OutputStream outputStream = httpConn.getOutputStream();

            // Opens input stream of the file for reading data


            byte[] buffer = new byte[BUFFER_SIZE];
            int bytesRead = -1;

            System.out.println("Start writing data...");

            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }

            System.out.println("Data was written.");
            outputStream.close();
            inputStream.close();
            }
            catch(SocketTimeoutException e)
            {
                 Log.e("Debug", "error: " + e.getMessage(), e);
            }
            catch (MalformedURLException ex)
             {
                  Log.e("Debug", "error: " + ex.getMessage(), ex);
             }
             catch (IOException ioe)
             {
                  Log.e("Debug", "error: " + ioe.getMessage(), ioe);
             }

            try
            {

            // always check HTTP response code from server
            int responseCode = httpConn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                // reads server's response
                BufferedReader reader = new BufferedReader(new InputStreamReader(httpConn.getInputStream()));
                String response = reader.readLine();
                System.out.println("Server's response: " + response);
            } else {
                System.out.println("Server returned non-OK code: " + responseCode);
            }
            }
             catch (IOException ioex){
                  Log.e("Debug", "error: " + ioex.getMessage(), ioex);
             }
            return null;
        }
        @Override
        protected void onPostExecute(String result) {             
        }

        @Override
        protected void onPreExecute() {
        }

        @Override
        protected void onProgressUpdate(Void... values) {
        }
    }
}

这是我的servlet代码

public class RecFileServlet extends HttpServlet {
   static final String SAVE_DIR = "D:/temp/";
    static final int BUFFER_SIZE = 4096;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         doPost(req, resp);
    }


    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {

        // Gets file name for HTTP header
        String fileName = request.getHeader("fileName");
        File saveFile = new File(SAVE_DIR + fileName);

        // prints out all header values
        System.out.println("===== Begin headers =====");
        Enumeration<String> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String headerName = names.nextElement();
            System.out.println(headerName + " = " + request.getHeader(headerName));
        }
        System.out.println("===== End headers =====\n");

        // opens input stream of the request for reading data
        InputStream inputStream = request.getInputStream();

        // opens an output stream for writing file
        FileOutputStream outputStream = new FileOutputStream(saveFile);

        byte[] buffer = new byte[BUFFER_SIZE];
        int bytesRead = -1;
        System.out.println("Receiving data...");

        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
        }

        System.out.println("Data received.");
        outputStream.close();
        inputStream.close();

        System.out.println("File written to: " + saveFile.getAbsolutePath());

        // sends response to client
        response.getWriter().print("UPLOAD DONE");
    }

}