Hochgeladene Bytes anzeigen

[pixel-shock]

Hallo zusammen,

ich hoffe ich habe richtig gesucht - gefunden habe ich nämlich leider nichts, was mir weiterhilft.

Ich habe ein Applet, Dateien auf meinen FTP hochlädt, funktioniert auch wunderbar, aber ich schaffe es einfach nicht, während dem Upload den aktuellen Status zurückzugeben - ich kann während dem Upload auch nichts im Applet machen - als wenn das Applet völlig ausgelastet wäre.

Ich habe meine AppletKlasse "ImageUploader" u.a. mit folgendem Code:

for (int listI = 0; listI < this.dateien.length; listI++) {
    File f = new File(this.dateien[listI]);	    		
    try {
        fh.upload(f, f.getName());		
        this.progress.setText("Bisher hochgeladen: " + fh.getBytesLoaded());					
    } catch (IOException e1) {
	e1.printStackTrace();
    }
}

Und eine Klasse "FTPHandler" mit u.a. folgenden Methoden, die ich hier im Forum entdeckt habe - THX an dieser Stelle!

    public void upload(File fil, String name) throws IOException {
    	if (!fil.exists()){
    		throw new IllegalArgumentException ("The file doesn't exist");
    	}
    	OutputStream os = ftpc.put(name);
    	InputStream is = new FileInputStream (fil);
    	len = 0; 
    	byte[] buf = new byte[1024];
    	while ((len = is.read(buf)) >= 0){
    		os.write(buf, 0, len);
    		uploadedBytes+=len;			
    	}
    	is.close();
    	os.close();
    }
    
    public int getBytesLoaded() {
    	return this.uploadedBytes;
    }

Jetzt habe ich gedacht ich kann in der for-Schleife der ImageUploader- Klasse das so abfangen, aber ich bekomme er die Anzahl der Bytes, wenn der Upload fertig ist.

Ich habs schon mit Threads versucht (auch nach einem Tutorial hier aus dem Forum), aber das hat auch nicht geklappt.

Hat jemand von euch da eine Idee, wie man das am besten umsetzen könnte?

LG & DANKE im Voraus
Tino

 

[xysawq]

du solltest beim inputstream mal versuchen ein fixe länge beim read(...) einzustellen, ansonsten saugt der so viel aus dem stream wie er kann, kurz gesagt alles und mach nur ein update von uploadedBytes

 

[SlaterB]

> wie man das am besten umsetzen könnte?

mit Threads,
was immer du damit gemacht hast und hier nicht postest, war dann wahrscheinlich falsch

was soll
> 1. fh.upload(f, f.getName());
> 2. this.progress.setText("Bisher hochgeladen: " + fh.getBytesLoaded());
bedeuten?
normalerweise wird der zweite Befehl erst ausgeführt, wenn der erste komplett fertig ist,
selbst wenn dem nicht so wäre, würde der zweite Befehl doch maximal einmal ausgeführt werden, du willst sicher mehrmals?

a)
entweder muss der zweite Befehl in upload in der Schleife stehen,

b)
oder die upload-Arbeit muss in einen Thread, damit der Aufrufer danach weiterarbeiten kann,
z.B. in einer while-Schleife immer x Millisekunden schlafen und dann den aktuellen Status abfragen


egal ob a) oder b),
höchstwahrscheinlich muss die gesamte Arbeit auch in einem Thread stehen,
denn solange etwa ein ActionListener einer GUI etwas macht,
ist die GUI blockiert,
zumindest bei AWT/ Swing ist das so


---------

Tipp: übe das ganze in einem normalen Programm ohne Applet und Netzwerkzugriff,
nur mit einem Dummy-Arbeitsthread und System.out.println





-----

edit: da du eine for-Schleife über mehrere Dateien hast, reicht dir vielleicht genau eine progress-Aufruf pro Datei,
dann ist das oben bemängelte weitgehend korrekt, und du brauchst nur noch, was bei "egal ob a) oder b)" steht


der "Tipp" hilt in diesem Fall dann auch nicht mehr, weil das Problem nur bei der GUI des Applets auftritt

 

[xysawq]

ich beharre erstmal noch auf meinen lösungsansatz

 

[pixel-shock]

Hi ihr beiden,

DANKE für eure schnellen Antworten, ich lese mal fix durch und probiere

LG
Tino

 

[xysawq]

Edit: du solltest in deiner while()-schleife mit dem read etc dann auch mal noch ein sleep oder so einbauen, sonst ist dein system bei ner großen datei ganz schnell mit 100% ausgelastet

 

[xysawq]

hab grad nochmal nachgelesen... wenn du nur read(array[]) machst, dann liest der soviele byte wie das array lang ist, also ist mein tipp wohl fürn popo, naja.

und sleep bringts auch nur, wenn der rest dann mal geht

und außerdem kann slaterb sovieso besser proggen als ich

 

[xysawq]

ach ja... jetzt hab ichs auch gesehen was slaterb meinte... also die variable uploadedBytes wird natürlich korrekt hochgezählt, aber deine for-schleife ist müll, da dort erst die ausgabe kommt, nachdem die übertragung fertig ist ^^

 

[xysawq]

d.h. mach aus dem:

uploadedBytes+=len;

doch einfach

progress.setText("Bisher hochgeladen: " + (uploadedBytes+=len));

danach noch ein:

Thread.sleep(1);

und es dürfte besser laufen

 

[SlaterB]

man eh, wie kann man nur soviel Mist posten.. :roll:

 

[pixel-shock]

Hi nochmal

Ich gebe zu ich stelle mich absolut doof an, aber ich raff das einfach nicht.

Klasse ImageUploader:

public class ImageUploader extends JApplet implements ActionListener, Runnable {

public ImageUploader() {
   new Thread(this);
   this.start();
}

public void run() {
   // Hier weiß ich nichts mit anzufangen so richtig, 
   // meinem Verständnis nach ist die run- Methode die Methode, 
   // die den Thread am leben erhält und "sagt", was währenddessen zu tun ist,
   // oder verstehe ich das falsch? 
}
[...]

Hier mal die ganze FTPHandler Klasse:

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.net.InetAddress;
import java.net.UnknownHostException;

import sun.net.ftp.FtpClient;


public class FTPHandler extends Thread {
	
	private InetAddress inet;	
	private FtpClient ftpc;
	private int len;
	private int uploadedBytes = 0;
        private JLabel progress;
	
	public FTPHandler (JLabel progress, String serverAdress, String username, String pass) throws IOException {
		try {
			inet = InetAddress.getByName(serverAdress);
		} catch (UnknownHostException e1) {
			e1.printStackTrace();
		}
		ftpc = new FtpClient ();
		ftpc.openServer (inet.getHostName());
		ftpc.login (username, pass);
		ftpc.binary();
		
                this.progress = progress;

		new Thread(this);
		this.start();
	}
    
	public void cd (String to) throws IOException {
    	ftpc.cd (to);
    }
    
	public void binary() throws IOException  {
    	ftpc.binary();
    }
    
	public void ascII() throws IOException {
    	ftpc.ascii();
    }
   
	public void noop() throws IOException {
    	ftpc.noop();
    }

    public void upload(File fil, String name) throws IOException {
    	if (!fil.exists()){
    		throw new IllegalArgumentException ("The file doesn't exist");
    	}
    	OutputStream os = ftpc.put(name);
    	InputStream is = new FileInputStream (fil);
    	len = 0; 
    	byte[] buf = new byte[1024];
    	uploadedBytes = 0;
    	while ((len = is.read(buf)) >= 0){
    		os.write(buf, 0, len);
    		uploadedBytes+=len;		
    		try {
                                progress.setText(uploadedBytes/1000+"");
				this.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
    	}
    	is.close();
    	os.close();
    }
    
    public int getBytesLoaded() {
    	return this.uploadedBytes;
    }

    public void download(File fil, String name) throws IOException  {
    	OutputStream os = new FileOutputStream (fil, false);
    	InputStream is = ftpc.get(name);
    	int len; byte[] buf = new byte[1024];
    	while ((len = is.read(buf)) >= 0){
    		os.write(buf, 0, len);
    	}
    	is.close();
    	os.close();
    }

    public void quit() {
    	try {
			ftpc.closeServer();
		} catch (IOException e) {
			e.printStackTrace();
		}
    }

}

und wenn ich jetzt in der ImageUploader- Klasse das hier aufrufe:

[...]
public void actionPerformed(ActionEvent e) {
                if (n == JOptionPane.NO_OPTION) {
	    		for (int listI = 0; listI < this.dateien.length; listI++) {
	    			File f = new File(this.dateien[listI]);	    		
		    		try {
						fh.upload(f, f.getName());	
					} catch (IOException e1) {
						e1.printStackTrace();
					}
	    		}
	    		fh.quit();
	    	}
}
[...]

Dann passiert trotzdem wären dem Schreiben der Datei nichts in der GUI, sondern erst hinterher.

Sorry, wenn ich mich sehr doof anstelle.

LG
Tino

 

[SlaterB]

wie geschrieben:
die GUI reagiert erst wieder wenn die for-Schleife beendet wurde und der ActionListener verlassen wird,
der gesamte Code des ActionListeners muss in einen Thread,
im ActionListener steht nur thread.start();

natürlich kannst du den Code quasi auch im ActionListener lassen, z.B. in einem anoym erzeugten Thread:

Runnable r = new Runnable() {
public void run() {

// hier den Code rein

}
}

new Thread(r).start();

 

[pixel-shock]

Sorry SlaterB, ich muss nochmal nachhaken (DANKE für deine Geduld)

Ich habe den ActionListener als interne Klasse von meinem Applet geschrieben und diese auch von Thread abgeleitet.

Nun sollte ja der ActionListener ein einzelnen Thread sein:

class ButtonListener extends Thread implements ActionListener {

ebenso mein FTPHandler:

public class FTPHandler extends Thread() {}

Somit ist dieser auch in einem einzelnen Thread.

Meine "Hauptklasse" ImageUploader kann ich haber nicht in die run() schreiben, weil das Applet ja die init() Methode braucht um anzulaufen.

Wenn ich das alles richtig verstehe sollte das ja theoretisch so laufen:

- Applet (ImageUploader) wird als Thread erzeugt
- Listener (ButtonListener) wird als Thread erzeugt
- FTPHandler (FTPHandler) wird als Thread erzeugt

Nun könnte man diese Threads beliebig pausieren, fortsetzen und stoppen.

Beim Upload:

- ActionListener reagiert
- ActionListener wird pausiert
- Upload beginnt
- während des Uploads wird der FTPHandler in der whileSchleife pausiert (sleep(1)) und setzt mir im Applet selber den Progress bzw. schreibt mir die KB Anzahl
- ActionListener wird wieder gestartet (bzw. fortgesetzt)
- das ganze von vorne

Ich glaube ich habe irgendwo noch einen riesen Denkfehler drin und denke zu kompliziert.

LG
Tino[/list]

 

[SlaterB]

ein Thread ist keine Wundertüte, es bringt gar nix wenn der ActionListener ein Thread ist,
erstens wird dessen run-Operation von niemanden aufgerufen, was sollte da auch drinstehen und mit der actionPerformed zu tun haben?
und zweitens ruft die GUI die actionPerformed-Operation auf, die ganz normal im Thread der GUI ausgeführt wird, egal ob die Klasse ein Thread ist der noch nicht gestartet, läuft oder schon zu Ende ist,

es geht nur so wie es beschrieben habe,
von der ActionPerformed muss ein neuer Thread mit start() gestartet werden

 

[pixel-shock]

Hi,

ich habs soeben "rausgefunden" - DANK DEINER HILFE!

Ich lasse für jeden UploadProzess in der for-Schleife einen Thread anlaufen und zack - die GUI hängt nicht mehr und ich kann super den Fortschritt abfangen

DANKE

LG
Tino

 

[pixel-shock]

Hab die Methode zum starten der Uploads auch direkt in die FTPHandler geschmissen, ich glaube da ist sie logischer aufgehoben:

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.net.InetAddress;
import java.net.UnknownHostException;

import javax.swing.JLabel;
import javax.swing.JProgressBar;

import sun.net.ftp.FtpClient;


public class FTPHandler extends Thread {
	
	private InetAddress inet;	
	private FtpClient ftpc;
	private int len;
	private double uploadedBytes = 0;
	private double prozent = 0;
	private JProgressBar progressBar;
	private int mom=0;
	private int max=0;
	
	public FTPHandler (JLabel ftpStatus, JProgressBar progressBar,String serverAdress, String username, String pass) throws IOException {
		try {
			inet = InetAddress.getByName(serverAdress);
		} catch (UnknownHostException e1) {
			e1.printStackTrace();
			ftpStatus.setText("Fehler beim Verbinden...");
		}
		ftpc = new FtpClient ();
		ftpStatus.setText("Auflösen des Hostnamens...");
		ftpc.openServer (inet.getHostName());
		ftpStatus.setText("Einloggen auf " + inet.getHostName() +"...");
		ftpc.login (username, pass);
		ftpStatus.setText("Uploadmodus auf binär...");
		ftpc.binary();
		
		this.progressBar = progressBar;
		ftpStatus.setText("Servernachricht: " + ftpc.welcomeMsg);
		
		new Thread(this);
		this.start();
	}
    
	public void cd (String to) throws IOException {
    	ftpc.cd (to);
    }
    
	public void binary() throws IOException  {
    	ftpc.binary();
    }
    
	public void ascII() throws IOException {
    	ftpc.ascii();
    }
   
	public void noop() throws IOException {
    	ftpc.noop();
    }
	
	public void startUpload(final String[] dateien, final double overAllFileSize) {
		prozent = 0;
		max = dateien.length;
		Thread t = new Thread() {
			public void run() {
					for (int listI = 0; listI < dateien.length; listI++) {
					mom = listI+1;
					File f = new File(dateien[listI]);	    		
		    		try {    						
						upload(f, f.getName(), overAllFileSize);
					} catch (IOException e1) {
						e1.printStackTrace();
					}
				}
			}			
		};
		t.start();
	}

    public void upload(File fil, String name, double overAllFileSize) throws IOException {
    	if (!fil.exists()){
    		throw new IllegalArgumentException ("The file doesn't exist");
    	}
    	OutputStream os = ftpc.put(name);
    	InputStream is = new FileInputStream (fil);
    	
    	len = 0; 
    	byte[] buf = new byte[1024];    	
    	while ((len = is.read(buf)) >= 0){
    		os.write(buf, 0, len);
    		uploadedBytes+=len;
    		prozent = Math.ceil((uploadedBytes/overAllFileSize)*100);
    		progressBar.setValue(new Double(prozent).intValue());
    		progressBar.setString(mom + "/" + max + " (gesamt " + prozent+"%)");
    	}
    	is.close();
    	os.close();
    }
    
    public double getBytesLoaded() {
    	return this.uploadedBytes;
    }

    public void download(File fil, String name) throws IOException  {
    	OutputStream os = new FileOutputStream (fil, false);
    	InputStream is = ftpc.get(name);
    	int len; byte[] buf = new byte[1024];
    	while ((len = is.read(buf)) >= 0){
    		os.write(buf, 0, len);
    	}
    	is.close();
    	os.close();
    }

    public void quit() {
    	try {
			ftpc.closeServer();
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
}

LG
Tino