Comment pourrais-je télécharger un gros fichier en plusieurs segments à l'aide de Java?

J'ai besoin de télécharger un gros fichier en plusieurs segments à l'aide de Java.

Est-il un exemple de code que je peux consulter?

Peut bas des électeurs commentaire sur pourquoi ils vers le bas voté?

OriginalL'auteur dojomedojo | 2011-05-20

*Il peut être fait à l'aide de plupload.
Voici un exemple de.
Mon index.html est la suivante:-

    <!DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
<title>Upload</title>
<!-- production -->
<script type="text/javascript" src="js/plupload.full.min.js"></script>
<!-- debug 
<script type="text/javascript" src="../js/moxie.js"></script>
<script type="text/javascript" src="../js/plupload.dev.js"></script>
-->
</head>
<body style="font: 13px Verdana; background: #eee; color: #333">
<div id="filelist"></div>
<br />
<button id="pickfiles" >Select file</button> 
<button id="uploadfiles" >Upload</button>
<div id="container">
</div>
<br />
<pre id="console"></pre>
<script type="text/javascript">
//Custom example logic
var uploader = new plupload.Uploader({
runtimes : 'html5',
browse_button : 'pickfiles', //you can pass an id...
container: document.getElementById('container'), //... or DOM Element itself
url : 'UploadAction',//upload.php
chunk_size : '1mb',
method:'POST',
flash_swf_url : 'js/Moxie.swf',
silverlight_xap_url : 'js/Moxie.xap',
filters : {
max_file_size : '100gb',
mime_types: [
{title : "Image files", extensions : "jpg,gif,png"},
{title : "Zip files", extensions : "zip,txt,vmdk"}
]
},
init: {
PostInit: function() {
document.getElementById('filelist').innerHTML = '';
document.getElementById('uploadfiles').onclick = function() {
uploader.start();
return false;
};
},
FilesAdded: function(up, files) {
plupload.each(files, function(file) {
document.getElementById('filelist').innerHTML += '<div id="' + file.id + '">' + file.name + ' (' + plupload.formatSize(file.size) + ') <b></b></div>';
});
},
UploadProgress: function(up, file) {
document.getElementById(file.id).getElementsByTagName('b')[0].innerHTML = '<span>' + file.percent + "%</span>";
},
Error: function(up, err) {
document.getElementById('console').appendChild(document.createTextNode("\nError #" + err.code + ": " + err.message));
}
}
});
uploader.init();
</script>
</body>
</html>
<!-- end snippet -->

Mon java backend code(Servlet) est la suivante:-

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItemIterator;
import org.apache.commons.fileupload.FileItemStream;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.util.Streams;
public class UploadAction extends HttpServlet {
private static final long serialVersionUID = 3447685998419256747L;
private static final String RESP_SUCCESS = "{\"jsonrpc\" : \"2.0\", \"result\" : \"success\", \"id\" : \"id\"}";
private static final String RESP_ERROR = "{\"jsonrpc\" : \"2.0\", \"error\" : {\"code\": 101, \"message\": \"Failed to open input stream.\"}, \"id\" : \"id\"}";
public static final String JSON = "application/json";
public static final int BUF_SIZE = 2 * 1024;
public static final String FileDir = "/home/asjha/uploads/";
private int chunk;
private int chunks;
private String name;
private String user;
private String time;
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String responseString = RESP_SUCCESS;
boolean isMultipart = ServletFileUpload.isMultipartContent(req);
if(isMultipart){
ServletFileUpload upload = new ServletFileUpload();
try {
FileItemIterator iter = upload.getItemIterator(req);
while (iter.hasNext()) {
FileItemStream item = iter.next();
InputStream input = item.openStream();
//Handle a form field.
if(item.isFormField()){
String fileName = item.getFieldName();
String value = Streams.asString(input);
if("name".equals(fileName)){
this.name = value;
}else if("chunks".equals(fileName)){
this.chunks = Integer.parseInt(value);
}else if("chunk".equals(fileName)){
this.chunk = Integer.parseInt(value);
}else if("user".equals(fileName)){
this.user = value;
}else if("time".equals(fileName)){
this.time = value;
}
}
//Handle a multi-part MIME encoded file.
else {
File dstFile = new File(FileDir);
if (!dstFile.exists()){
dstFile.mkdirs();
}
File dst = new File(dstFile.getPath()+ "/" + this.name);
saveUploadFile(input, dst);
}
}
}
catch (Exception e) {
responseString = RESP_ERROR;
e.printStackTrace();
}
}
//Not a multi-part MIME request.
else {
responseString = RESP_ERROR;
}
if(this.chunk == this.chunks - 1){
System.out.println("name"+this.name);
}
resp.setContentType(JSON);
byte[] responseBytes = responseString.getBytes();
resp.setContentLength(responseBytes.length);
ServletOutputStream output = resp.getOutputStream();
output.write(responseBytes);
output.flush();
}
private void saveUploadFile(InputStream input, File dst) throws IOException {
OutputStream out = null;
try {
if (dst.exists()) {
out = new BufferedOutputStream(new FileOutputStream(dst, true),
BUF_SIZE);
} else {
out = new BufferedOutputStream(new FileOutputStream(dst),
BUF_SIZE);
}
byte[] buffer = new byte[BUF_SIZE];
int len = 0;
while ((len = input.read(buffer)) > 0) {
out.write(buffer, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != input) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != out) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

Veuillez vous référer à plupload pour plus de détails et sur github, vous pouvez voir des exemples de projets par jakobadam et rocheux.

S'il vous plaît laissez-moi savoir si plusieurs d'upload de fichier est requis. À l'aide de plupload on peut télécharger n'importe quel nombre de fichiers de toutes tailles. Cet exemple est destiné à un seul téléchargement de fichiers de très grande taille.
n'oubliez pas d'inclure plupload.full.min.js. Espérons que cela aide*texte en gras**

Apache commons peuvent également être utilisés si nous n'avons aucun problème de délai d'attente comme avec nginx etc.. Plupload fournit de nombreux moyens pour charger à l'aide de flash,applet, etc..

OriginalL'auteur Ashutosh Jha

0

Utiliser un RandomAccessFile. Ceci a déjà été couvert, DONC je crois.

java fichier d'entrée avec rewind()/reset() capacité de

Fondamentalement, vous venais chercher au point de départ, écrire toutefois le nombre d'octets que vous voulez à partir de là, et n'oubliez pas le point que vous avez cessé d'écrire depuis.

Hein? C'est totalement inutile. Vous n'avez pas besoin de le faire. Je pense que la question est de s'interroger sur le côté client, pas le côté serveur, par la manière.
Je suppose que l'OP va décider, mais j'ai peut-être mal compris la question.

OriginalL'auteur KyleM
0

Vous pouvez simplement briser le fichier vous-même, et de l'envoyer à l'aide de la Socket API, et ré-assembler le fichier.

OriginalL'auteur Amir Afghani
0

Essayer Apache Commons télécharger. Il prend en charge la diffusion, peut être approprié pour vous.

OriginalL'auteur Jayan
0

Si vous êtes à l'aide de Java , l'utilisation Arivus Nioserver gradle dépendance -> compiler 'org.arivu:nioserver:1.0.3'. Pas de contrainte de taille de fichier.

OriginalL'auteur parthipang

Voici un exemple de code Java natif qui télécharge un fichier à l'aide de morceaux:

final String       LF = "\r\n"; //Line separator required by multipart/form-data. Can be static class constant
final String boundary = Long.toHexString(System.currentTimeMillis()); //Just generate some unique random value.
HttpURLConnection connection = (HttpURLConnection) new URL("http://some.com/upload").openConnection();
try {
connection.setDoOutput(true);
connection.setChunkedStreamingMode(4096);
connection.setRequestMethod("POST");
connection.addRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
connection.addRequestProperty("Accept", "application/json");
connection.addRequestProperty("Authorization", myToken);
try (OutputStream os = connection.getOutputStream();
Writer writer = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
writer.append("--").append(boundary).append(LF);
writer.append("Content-Disposition: form-data; name=\"dataFile\"; filename=\"file.zip\"").append(LF);
writer.append("Content-Type: application/zip").append(LF);
writer.append(LF);
writer.flush();
//Write body
writeBinaryBody(os);
writer.append(LF).append("--").append(boundary).append("--").append(LF);
writer.flush();
os.flush();
}
if (200 != connection.getResponseCode()) {
try (Reader reader = new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)) {
//Handle error here
}
}
} finally {
connection.disconnect();
}

Le code de cet exemple est basé sur cette réponse sur http de téléchargement de fichiers à partir de java. La différence, c'est l'appel à connection.setChunkedStreamingMode(4096); qui définit que les fragments de streaming devrait être utilisé.

OriginalL'auteur stenix

Vous devez vous connecter pour publier un commentaire.