1. MultipartEntityBuilder for File Upload

　　test The addBinaryBody is selected. Among them, the value of the first parameter name is defined by the server. The server will read the file stream we uploaded according to this field, and if it does not match, it will report an error. For contentType, you can refer to http://tool.oschina.net/commons, the type corresponding to different file extensions. file/stream and fileName are the information we need to upload files. When usedBrowser When the developer tool looks at API requests, we see that these / parameters are basically in API requests. Request Payload field.

5. Finally, call the HttpClient object to send the request and get the response of the server.

Prior to HttpCient 4.3, MultipartEntity was the main class for uploading files, but it is no longer recommended for this class. The class that replaces it is MultipartEntityBuilder.

Introduction of MultipartEntityBuilder Class

MultipartEntityBuilder is a class used to create HttpEntity. Its main methods are:

The main methods are as follows:

The addBinaryBody, addPart, and addTextBody methods are used to add data to be uploaded. From the table above, you can see that the methods used to add data are all key-value types. So on the server side, we can get the corresponding key data by request.getPart("keyname"). You can also get all the data submitted by the client through request.getParts().

1. File, InputStream, byte [] data can be added directly by addBinaryBody method.

2. Only data of Content Body type can be added by addPart method. Subclasses of String, File and InputStream corresponding to Content Body type, such as FileBody, InputStream Body and StringBody, have been provided in the org.apache.http.entity.mime.content package, through which we can convert data of String, File and InputStream type into data of Body type.

3. Through the addTextBody method, we can easily add text data.

3. Implement by HttpCient Upload File Core Code

The Android side needs to be added httpcore-4.3.2.jar,httpmime-4.3.5.jar Two bags. Two bags are indispensable. Here I use the latest version of HTTP Cient, you can from http://hc.apache.org/downloads.cgi Download the required jar package, if the above website can not be opened, you need not worry, I have uploaded the jar package needed in the project to CSDN.< httpcomponents-client-4.3.5-bin.zip > Need friends can download.

3.1 Android-side project core code:

HttpClient client=new DefaultHttpClient();// Open a client HTTP request 
HttpPost post = new HttpPost(url);//Create HTTP POST requests  
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.setCharset(Charset.forName("uft-8"));//Set the encoding format of the request
builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);//Setting Browser Compatibility Mode
int count=0;
for (File file:files) {
	builder.addBinaryBody("file"+count, file);
	count++;
}		
builder.addTextBody("method", params.get("method"));//Setting Request Parameters
builder.addTextBody("fileTypes", params.get("fileTypes"));//Setting Request Parameters
HttpEntity entity = builder.build();// Generating HTTP POST Entities  	
post.setEntity(entity);//Setting Request Parameters
HttpResponse response = client.execute(post);// Initiate the request and return the response to the request
if (response.getStatusLine().getStatusCode()==200) {
	return true;
}
return false;		

Code analysis:

The above code mainly realizes multi-file upload. In order to save files on the server side, the above code sets parameters named fileTypes. FileTypes is a string composed of uploaded file type names, such as ".jpg.png.docx";

3.2 Core code of server-side project:

The server side can get the type of file to be saved by taking a parameter named fileTypes and splitting it into character arrays. Server segment is mainly used in Servlet 3.0 API. The main methods used are:

request.getParameter(");// Gets the String type data added by the client through the addTextBody method.

request.getPart(");// Gets the specified data added by the client through the addBinaryBody, addPart, addTextBody methods, and returns the object of type Part.

3. request.getParts(); // Gets all the data added by the client through the addBinaryBody, addPart, addTextBody methods, and returns the Collection < Part > type object.

part.getName(); // Get the name of the uploaded file, which is the key specified when uploading.

5. part.getSize()// Gets the size of the uploaded file in bytes.

String fileTypes=request.getParameter("fileTypes");//Get all file types uploaded by the client
String[]typeArray=fileTypes.substring(1).split("\\.");//Split the file type string into String arrays
try {
	Iterator<Part>iterator=request.getParts().iterator();
	int count=0;
	while (iterator.hasNext()) {//Traverse all files uploaded by the client				
		if (count>=typeArray.length)break;//Jump out of the loop if you exceed the size of an array of file types		
		Part part = (Part) iterator.next();				
		System.out.println("part.getSize()"+part.getSize());//Get the size of the uploaded file
		System.out.println("part.getName()"+part.getName());//Get the name of the uploaded file and the key name when adding data
		File file=new File("E:\\upload\\"+count+"."+typeArray[count++]);
		InputStream inputStream=part.getInputStream();
		FileOutputStream fos=new FileOutputStream(file);
		byte[]buffer=new byte[1024];
		int len=0;
		while ((len=inputStream.read(buffer))!=-1) {
			fos.write(buffer,0, len);
		}
		inputStream.close();
		fos.close();					
	}
}catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

Code analysis:

The server side is implemented through a Servlet, which accesses all file types uploaded by the client by calling request.getParameters ("fileTypes"), and then splits the file type string into String arrays. All data uploaded by client through addBinaryBody, addPart and addTextBody are extracted by request.getParts() method, and then files can be saved by traversing the data set.

Because of the prior agreement with the client, the order of adding uploaded files is before adding request parameters, so the number of uploaded files can be determined according to the length of the split file type array. So when the above code traverses beyond the length of the type array, the program jumps out of the loop and no longer saves the files, because the following Part s are parameters, not to be saved. Save the file.

3.3 Program Running Effect Chart:

IV. Project Code