Ladefortschritt - bietet das diese Quelltextvorlage?

[Rex]

Ich bin mal so frei :

import java.net.URLConnection;
import java.net.URL;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.io.File;
import java.io.InputStream;
import java.util.Random;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.util.Iterator;
import javax.swing.JProgressBar;
import javax.swing.ProgressMonitorInputStream;

/**
 * 

Title: Client HTTP Request class</p>
 * 

Description: this class helps to send POST HTTP requests with various form data,
 * including files. Cookies can be added to be included in the request.</p>
 *
 * @author Vlad Patryshev
 * @version 1.0
 */
public class ClientHttpRequest {
    private static long filelength;
    URLConnection connection;
    OutputStream os = null;
    Map cookies = new HashMap();
    
    protected void connect() throws IOException {
        if (os == null) os = connection.getOutputStream();
    }
    
    protected void write(char c) throws IOException {
        connect();
        os.write(c);
    }
    
    protected void write(String s) throws IOException {
        connect();
        os.write(s.getBytes());
    }
    
    protected void newline() throws IOException {
        connect();
        write("\r\n");
    }
    
    protected void writeln(String s) throws IOException {
        connect();
        write(s);
        newline();
    }
    
    private static Random random = new Random();
    
    protected static String randomString() {
        return Long.toString(random.nextLong(), 36);
    }
    
    String boundary = "---------------------------" + randomString() + randomString() + randomString();
    
    private void boundary() throws IOException {
        write("--");
        write(boundary);
    }
    
    /**
     * Creates a new multipart POST HTTP request on a freshly opened URLConnection
     *
     * @param connection an already open URL connection
     * @throws IOException
     */
    public ClientHttpRequest(URLConnection connection) throws IOException {
        this.connection = connection;
        connection.setDoOutput(true);
        connection.setRequestProperty("Content-Type",
                "multipart/form-data; boundary=" + boundary);
        connection.addRequestProperty("Accept-Encoding", "gzip,deflate"); //Added: needed for PHP, CGI etc.
    }
    
    /**
     * Creates a new multipart POST HTTP request for a specified URL
     *
     * @param url the URL to send request to
     * @throws IOException
     */
    public ClientHttpRequest(URL url) throws IOException {
        this(url.openConnection());
    }
    
    /**
     * Creates a new multipart POST HTTP request for a specified URL string
     *
     * @param urlString the string representation of the URL to send request to
     * @throws IOException
     */
    public ClientHttpRequest(String urlString) throws IOException {
        this(new URL(urlString));
    }
    
    
    private void postCookies() {
        StringBuffer cookieList = new StringBuffer();
        
        for (Iterator i = cookies.entrySet().iterator(); i.hasNext();) {
            Map.Entry entry = (Map.Entry)(i.next());
            cookieList.append(entry.getKey().toString() + "=" + entry.getValue());
            
            if (i.hasNext()) {
                cookieList.append("; ");
            }
        }
        if (cookieList.length() > 0) {
            connection.setRequestProperty("Cookie", cookieList.toString());
        }
    }
    
    /**
     * adds a cookie to the requst
     * @param name cookie name
     * @param value cookie value
     * @throws IOException
     */
    public void setCookie(String name, String value) throws IOException {
        cookies.put(name, value);
    }
    
    /**
     * adds cookies to the request
     * @param cookies the cookie "name-to-value" map
     * @throws IOException
     */
    public void setCookies(Map cookies) throws IOException {
        if (cookies == null) return;
        this.cookies.putAll(cookies);
    }
    
    /**
     * adds cookies to the request
     * @param cookies array of cookie names and values (cookies[2*i] is a name, cookies[2*i + 1] is a value)
     * @throws IOException
     */
    public void setCookies(String[] cookies) throws IOException {
        if (cookies == null) return;
        for (int i = 0; i < cookies.length - 1; i+=2) {
            setCookie(cookies[i], cookies[i+1]);
        }
    }
    
    private void writeName(String name) throws IOException {
        newline();
        write("Content-Disposition: form-data; name=\"");
        write(name);
        write('"');
    }
    
    /**
     * adds a string parameter to the request
     * @param name parameter name
     * @param value parameter value
     * @throws IOException
     */
    public void setParameter(String name, String value) throws IOException {
        boundary();
        writeName(name);
        newline(); newline();
        writeln(value);
    }
    private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Die Anzahl gesendeter Bytes
         JProgressBar progress = new JProgressBar(0, 100);
        
        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                out.write(buf, 0, nread);
                total += nread;
                progress.setValue((int)(filelength / 100) * total); //Gesamnt durch 100 = 1% mal gesendet = aktuell-Prozent
            }
        }
        out.flush();
        buf = null;
    }
    
    /**
     * adds a file parameter to the request
     * @param name parameter name
     * @param filename the name of the file
     * @param is input stream to read the contents of the file from
     * @throws IOException
     */
    public void setParameter(String name, String filename, InputStream is) throws IOException {
        boundary();
        writeName(name);
        write("; filename=\"");
        write(filename);
        write('"');
        newline();
        write("Content-Type: ");
        String type = connection.guessContentTypeFromName(filename);
        if (type == null) type = "application/octet-stream";
        writeln(type);
        newline();
        pipe(is, os);
        newline();
    }
    
    /**
     * adds a file parameter to the request
     * @param name parameter name
     * @param file the file to upload
     * @throws IOException
     */
    public void setParameter(String name, File file) throws IOException {
        filelength = file.length();
        setParameter(name, file.getPath(), new FileInputStream(file));
    }
    
    /**
     * adds a parameter to the request; if the parameter is a File, the file is uploaded, otherwise the string value of the parameter is passed in the request
     * @param name parameter name
     * @param object parameter value, a File or anything else that can be stringified
     * @throws IOException
     */
    public void setParameter(String name, Object object) throws IOException {
        if (object instanceof File) {
            setParameter(name, (File) object);
        } else {
            setParameter(name, object.toString());
        }
    }
    
    /**
     * adds parameters to the request
     * @param parameters "name-to-value" map of parameters; if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
     * @throws IOException
     */
    public void setParameters(Map parameters) throws IOException {
        if (parameters == null) return;
        for (Iterator i = parameters.entrySet().iterator(); i.hasNext();) {
            Map.Entry entry = (Map.Entry)i.next();
            setParameter(entry.getKey().toString(), entry.getValue());
        }
    }
    
    /**
     * adds parameters to the request
     * @param parameters array of parameter names and values (parameters[2*i] is a name, parameters[2*i + 1] is a value); if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
     * @throws IOException
     */
    public void setParameters(Object[] parameters) throws IOException {
        if (parameters == null) return;
        for (int i = 0; i < parameters.length - 1; i+=2) {
            setParameter(parameters[i].toString(), parameters[i+1]);
        }
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added
     * @return input stream with the server response
     * @throws IOException
     */
    public InputStream post() throws IOException {
        boundary();
        writeln("--");
        os.close();
        return connection.getInputStream();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public InputStream post(Map parameters) throws IOException {
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public InputStream post(Object[] parameters) throws IOException {
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     * @see setCookies
     */
    public InputStream post(Map cookies, Map parameters) throws IOException {
        setCookies(cookies);
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     * @see setCookies
     */
    public InputStream post(String[] cookies, Object[] parameters) throws IOException {
        setCookies(cookies);
        setParameters(parameters);
        return post();
    }
    
    /**
     * post the POST request to the server, with the specified parameter
     * @param name parameter name
     * @param value parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name, Object value) throws IOException {
        setParameter(name, value);
        return post();
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2);
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2, name3, value3);
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @param name4 fourth parameter name
     * @param value4 fourth parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2, name3, value3, name4, value4);
    }
    
    /**
     * posts a new request to specified URL, with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public static InputStream post(URL url, Map parameters) throws IOException {
        return new ClientHttpRequest(url).post(parameters);
    }
    
    /**
     * posts a new request to specified URL, with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public static InputStream post(URL url, Object[] parameters) throws IOException {
        return new ClientHttpRequest(url).post(parameters);
    }
    
    /**
     * posts a new request to specified URL, with cookies and parameters that are passed in the argument
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setCookies
     * @see setParameters
     */
    public static InputStream post(URL url, Map cookies, Map parameters) throws IOException {
        return new ClientHttpRequest(url).post(cookies, parameters);
    }
    
    /**
     * posts a new request to specified URL, with cookies and parameters that are passed in the argument
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setCookies
     * @see setParameters
     */
    public static InputStream post(URL url, String[] cookies, Object[] parameters) throws IOException {
        return new ClientHttpRequest(url).post(cookies, parameters);
    }
    
    /**
     * post the POST request specified URL, with the specified parameter
     * @param name parameter name
     * @param value parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @param name4 fourth parameter name
     * @param value4 fourth parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3, name4, value4);
    }
}

An welcher Stelle
kann man
a) sehen, wieviele Bytes die Datei hat (f.getLength())
und
b) sehen, wieviele Bytes geflossen sind.

Ich habe bereits gesucht - aber keinen Anhaltspunkt gefunden.

Vielen Dank!
MFG
Rex

 

[SlaterB]

in

 private static void pipe(InputStream in, OutputStream out) throws IOException { 
        byte[] buf = new byte[500000]; 
        int nread; 
        int navailable; 
        int total = 0; //Die Anzahl gesendeter Bytes 
         JProgressBar progress = new JProgressBar(0, 100); 
        
        synchronized (in) { 
            while((nread = in.read(buf, 0, buf.length)) >= 0) { 
                out.write(buf, 0, nread); 
                total += nread; 
                progress.setValue((int)(filelength / 100) * total); //Gesamnt durch 100 = 1% mal gesendet = aktuell-Prozent 
            } 
        } 
        out.flush(); 
        buf = null; 
    }

wobei filelengh wohl nichts mit dem übergebenen in-Stream zu tun hat,
---

 /** 
     * adds a file parameter to the request 
     * @param name parameter name 
     * @param file the file to upload 
     * @throws IOException 
     */ 
    public void setParameter(String name, File file) throws IOException { 
        filelength = file.length(); 
        setParameter(name, file.getPath(), new FileInputStream(file)); 
    }

hier wird filelength gesetzt, aber auch file irgendwo verwendet?

 

[Rex]

Die JProgressBar ist leider nicht sichtbar in dem Applet meiner Klasse "DFApplet".

MFG
Rex

 

[Rex]

Frage an euch:
Warum nicht?

Vielen Dank!
MFG
Rex

 

[SlaterB]

das Erzeugen irgendeines Objekes muss noch nicht viele Auswirkungen haben,
ein JProgressbar-Objekt fügt sich z.B. nicht automatisch in irgendein Applet ein,
das musst du schon irgendwie einfügen (add())

von Applets weiß ich aber wenig, vielleicht nicht so einfach mit Swing-Komponenten,

wenn du das versuchst, dann auf jeden Fall testweise mit maximal 10 Zeilen Code dafür
(Z.B. auf einen Button-Klick hin auf 70% setzen)
und nicht 498 Zeilen

 

[thE_29]

Ohne den Code anzugucken!

Wenn du alles in einem Thread machst, wirst du die JProgressBar nie sehen

Die JProgressBar lässt normal starten (nach Button klick oder ähnliches) und die eigentliche Methode musst in einem Thread starten!

 

[Rex]

Vielen Dank, für Deine rasche Antwort.
Ehm... Ich habe keine so große Ahnung von Threads...
Muss man nicht erst eine eigene Klasse erstellen, die man dann als Thread verwenden kann?

Und wie greife ich dann auf die Schleife in meiner ClientHTTP-Request-Klasse zu?

Ist eine eigene Klasse überhaupt notwendig?

HELP!
MFG
vielen Dank!
REx

 

[Leroy42]

Thread-Programmierung

Und wie greife ich dann auf die Schleife in meiner ClientHTTP-Request-Klasse zu?

Du kannst nicht auf Schleifen zugreifen :autsch:

In der Schleife benachrichtigst du eine Instanz, die in deinem neuen Thread abläuft,
über aktuelle Zustände. Beispiel in der Art:

myProgress.setActualPercentage(70);

Ist eine eigene Klasse überhaupt notwendig?

Nein! Du brauchst nur eine Runnable-Instanz die du einer Thread-Instanz im Konstruktor übergibst.

Und falls: :shock:

dann siehe oben.

 

[Rex]

EDIT: Erledigt.


MFG
Rex

 

[L-ectron-X]

Dann hake ich das hier mal ab.
Du kannst dir das aber gleich mal angewöhnen: Frage zu deiner Zufriedenheit beantwortet? Dann abhaken!