Erste Schritte "non-static method" oder "XYZ can not be resolved"

Bitte aktiviere JavaScript!
Hallo community,

ich habe ein Problem. Unter https://wiki.byte-welt.net/wiki/HttpClient_(Jakarta) habe ich mir den funktionierenden Code 1:1 in Netbeans kopiert. Wenn ich dann ausführen will, kommt die Fehlermeldung "non-static method cannot be referenced from a static context". Wenn ich es in Eclipse 1:1 einfüge, kommt der Fehler: "XYZ can not be resolved".

1. Frage: Warum zeigen die IDE zwei verschiedene Fehler an und nicht beide den gleichen?
2. Frage: Was ist der Fehler und wie kann der Fehler behoben werden, möglichst in beiden IDE?
 
habe ich mir den funktionierenden Code 1:1 in Netbeans kopiert. Wenn ich dann ausführen will, kommt die Fehlermeldung "non-static method cannot be referenced from a static context".
Da scheint der "funktionierende Code" irgendwie doch nicht zu funktionieren, oder?

Ohne Deinen Code gesehen zu haben (auf der Seite gibt es zig Schnipsel mit Code), kann ich nur vermuten, dass Du in der main-Methode eine Instanzmethode einer Klasse unmittelbar aufrufst, ohne zuvor ein Objekt davon erzeugt zu haben.
 
Also Du gibst nur wehr wenig Informationen über das, was Du genau gemacht hast.
Die erste Fehlermeldung besagt, dass Du aus einer statischen Methode auf eine nicht statische Methode versuchst zuzugreifen.
Wenn Du uns hier Details zeigst, dann sollten wir auch helfen können.

Der zweite Fehler kommt wohl, weil Du eine Abhängigkeit nicht eingebunden hast oder eben Du hast Dich irgendwo verschrieben. Aber Du scheinst nicht einmal die Fehlermeldung 1:1 kopiert zu haben, oder hast Du irgendwo versucht auf eine Klasse XYZ zuzugreifen? -> Details zeigen!

Ohne Details können wir Dir aber nicht weiter helfen.
 
Ok, Entschuldigung. Kein Problem: (XYZ war nur als Beispiel genannt ;) )

Java:
import java.io.*;
import javax.swing.*;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;

public class AbloadUpload {

    HttpClient httpClient;
    //Erzeugen wir einen neuen HTTP-Client. Stellen Sie sich das wie einen Browser vor.

    public void uploadFile(File datei) throws HttpException, IOException {
        MultipartPostMethod multipartPost = new MultipartPostMethod(
                "http://www.abload.de/xuploaded.php");
                //Erstellen Sie ein MultipartPostMethod-Objekt. Wie vorher schon erwähnt, benutzen
                //wir diese Klasse, weil das Attribut "enctype" gleich "multipart/form-data" ist.
                //Das ist nunmal bei Datei-Upload im Internet so.

        httpClient.setConnectionTimeout(8000);
                //Wenn wir nach 8 Sekunden (= 8.000 Millisekunden) keine Antwort vom Server
                //erhalten, schlägt der Upload fehl. Dies machen wir, weil wir den Benutzer nicht
                //verunsichern wollen, wenn der Server vom Dienst mal nicht läuft.

        multipartPost.addParameter("xupload1file", datei);
                //Die Datei
        multipartPost.addParameter("gallery", "none");
                //Wir schicken unter der Gallerie immer "none" ab, da wir keinen Login schreiben
                //werden. <!-- änder -->
        multipartPost.addParameter("resize", "no-resize");
                //Unter resize geben wir immer "no-resize" an - wenn Sie wollen, schreiben Sie auch
                //eine Unterstützung für das Verkleinern von Bildern! Allerdings vergessen Sie
                //nicht, zu prüfen, ob die Werte auch realistisch sind (also keine negativen
                //Werte), und ob in dem String ein "x" vorkommt, und um das "x" Ganzzahlen
                //stehen...
                //Am besten empfiehlt es sich, eine neue Klasse namens "Resizing" zu schreiben.

        httpClient.executeMethod(multipartPost);
                //Der HTTP-Client (der "Browser") führt eine HTTP-Anfrage mit den angegebenen
                //Parametern auf die Seite
                //http://www.abload.de/xuploaded.php aus.

        System.out.println(multipartPost.getResponseBodyAsString());
                //Geben wir den zurückbekommenen HTML-Code auf der Kommandozeile aus.

        multipartPost.releaseConnection();
        //Trennen wir die Verbindung.
    }
 
 
 
    public void uploadURL(String url) throws HttpException, IOException {
        //Unter url empfangen wir die URL.
        //Noch gibt diese Methode nichts zurück, aber bald werden wir die Links aus dem
        //HTML-Code heraussuchen.
    MultipartPostMethod multipartPost = new MultipartPostMethod(
            "http://www.abload.de/xuploaded.php");
            //Neue MultipartPostMethod
            //(Die URL, auf die die Daten gesendet werden, ändert sich nicht)
    httpClient.setConnectionTimeout(8000);
 
    multipartPost.addParameter("xupload2url", url);
            //Unser neuer Parameter xupload2url - hier steckt die URL drin.
            //Z. B. http://www.google.de/intl/de_de/images/logo.gif (bitte nicht verwenden!!!)
    multipartPost.addParameter("gallery", "none");
    multipartPost.addParameter("resize", "no-resize");
 
    httpClient.executeMethod(multipartPost);
            //Anfrage ausführen
 
    System.out.println(multipartPost.getResponseBodyAsString());
            //Rückgabe auswerfen
 
    multipartPost.releaseConnection();
            //Verbindung beenden
    }
 
}
Java:
public class AbloadFile {
    private String gallery;
    private String id;

    private AbloadFile() {
    }

    public AbloadFile(String gallery, String id) {
        this.gallery = gallery;
        this.id = id;
    }

    public void setGallerie(String arg) {
        gallery = arg;
    }

    public void setDateiName(String arg) {
        id = arg;
    }

    public String getGallerie() {
        return gallery;
    }

    public String getID() {
        return id;
    }

    public String getDirektLink() {
        return "http://www.abload.de/img/" + getID();
    }

    public String getShowLink() {
        return "http://www.abload.de/image.php?img=" + getID();
    }
}
Java:
import java.io.*;
import org.apache.commons.httpclient.*; //Diesen Import brauchen wir wegen der
                                        //HttpException.

public class UploadTestURL {

    public static void main(String[] args) {
        new UploadTestURL().los();
    }

    private void los() {
        String url = "http://www.test.de/img/mein_test.gif";

        try {
            AbloadUpload.uploadURL(url);
        } catch (HttpException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}
 
das hier?

Java:
public class AbloadUpload {

    HttpClient httpClient;
    //Erzeugen wir einen neuen HTTP-Client. Stellen Sie sich das wie einen Browser vor.
aber hast Recht. Da kommt eine NullPointerException bei:
Java:
httpClient.setConnectionTimeout(8000);
 
Ja, ohne Erzeugung eines HttpClient-Objekts wird das nichts.

Java:
public class AbloadUpload {

    HttpClient httpClient = new HttpClient();
 
Ich hab nen "fertigen" Imageupload für Java gesucht. Und da kam mir dieser fertige Code gerade recht, da dieser ja scheinbar alles beinhaltet. Leider funktioniert dieser nun doch nicht -.-
 
Sehe ich das richtig, dass es dann ungefähr so aufgerufen wird?

Java:
String command = "curl --location --request POST https://api.imgbb.com/1/upload?key=YOUR_CLIENT_API_KEY" --form "image=www.meinbild.de/test.jpg";
Process process = Runtime.getRuntime().exec(command);
Ich bekomme ja dann ein response in JSON. Muss ich das irgendwo abfragen oder wie komme ich an die Daten aus dem JSON? Geht das über
Java:
process.exe > C:\tmp.txt
und die txt lese ich dann ein?
 
Also das arbeiten mit externen Prozessen ist so mit das letzte, was Du machen solltest.

a) GANZ schlecht: Ja, man könnte die Ausgabe umleiten um dann die Datei zu lesen. Ist aber Unsinn.

b) IMMER NOCH ganz schlecht: Man kann getOutputStream vom Prozess aufrufen, um dann die Ausgabe zu lesen.

c) curl ruft ja nur eine Webseite auf. Dazu gibt es nun wirklich genug Libraries. So Dir curl gefällt: Selbst da gibt es dann Libraries, die das implementieren. Aber üblich ist hier wohl die Nutzung von Apache.httpclient (http://hc.apache.org/httpcomponents-client-ga/index.html) und ähnlichen Libraries.

Und für das Verarbeiten von json gibt es auch genug Libraries. Auf https://stackoverflow.com/questions/2591098/how-to-parse-json-in-java findet man die üblichen Kandidaten (org.json, gson und Jackson)
 
Also das arbeiten mit externen Prozessen ist so mit das letzte, was Du machen solltest.
Auch wenn du wahrscheinlich zu 100% recht hast, war das die Möglichkeit, welche mit cURL, BufferedReader und StreamReader als erstes auf Anhieb fehlerfrei geklappt hat -.-
Das JSON-Objekt kommt zwar über Console mit escapetem String zurück ( \/ \/ \" \" ), aber das kann man ja umbiegen. Ist sicher alles n bißchen "russisch", aber es ging schnell und einfach und funktioniert "leider" eben auch zu 100%.
 
Du hast da jetzt den Erfolgsfall abgebildet. Nun willst du aber ggf Fehler erkennen und je nach Fehler unterschiedlich reagieren. Das wird bei Dir relativ komplex. Hinzu kommen mögliche Fehler durch externe Abhängigkeiten...

Und den curl Aufruf kannst du mit einer curl Library 1:1 im Code abbilden. Aber ich halte diesen BlackBox Ansatz für falsch. Das http Protokoll mag am Anfang komplex wirken, aber man sollte verstehen, was man da tut. Dieses ‚Es funktioniert aber ich habe keine Ahnung wieso‘ halte ich für gefährlich. Nach Murphy fällt Dir das in Produktion auf die Füße, wo die Funktionalität dringend gebraucht wird und Du keine Zeit hast, Dir das Wissen strukturiert anzueignen.
 
Hier mal was zusammengeschustert:

Java:
import java.net.HttpURLConnection;
import java.io.*;
import java.util.UUID;

public class Jimgbb {
    public static class Response {
        public final int code;
        public final String content;
        
        public Response(int code, String content) {
            this.code = code;
            this.content = content;
        }
    }

    private String apiKey;


    public Jimgbb(String apiKey) {
        this.apiKey = apiKey;
    }

    public Response upload(HttpURLConnection conn, InputStream is,
            String filename) throws IOException {
        return upload(conn, is, filename, null);
    }

    public Response upload(HttpURLConnection conn, InputStream is, 
            String filename, String name) throws IOException {
        return upload(conn, is, getContentType(filename), filename, name);
    }

    public Response upload(HttpURLConnection conn, InputStream is, 
            String contentType, String filename, String name) throws IOException {

        String boundary = Long.toHexString(System.currentTimeMillis());

        conn.setDoOutput(true);
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Accept", "*/*");
        conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=\"" + boundary + "\"");

        try(OutputStream os = conn.getOutputStream();
                PrintWriter writer = new PrintWriter(new OutputStreamWriter(os, "UTF-8"))) {
            writeText(writer, boundary, "key", apiKey);
            writeText(writer, boundary, "name", name);
            writeFile(writer, boundary, "image", filename, contentType);
            copy(is, os);
            writer.append("\r\n--" + boundary + "--\r\n").flush();
        }

        return readResponse(conn);
    }

    private Response readResponse(HttpURLConnection conn) throws IOException {
        int response = conn.getResponseCode();
        if (response >= 400) {
            try(InputStream is = conn.getErrorStream()) {
                return read(is, response);
            }
        } else {
            try(InputStream is = conn.getInputStream()) {
                return read(is, response);
            }
        }
    }

    private Response read(InputStream is, int response) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        copy(is, bos);
        return new Response(response, bos.toString("UTF-8"));
    }

    private String getContentType(String filename) {
        String mimeType = HttpURLConnection.guessContentTypeFromName(filename);
        return mimeType == null ? "application/binary" : mimeType;
    }       

    private void writeFile(PrintWriter writer, String boundary,
            String fieldName, String filename, String contentType) throws IOException {
        writer.append(
                "\r\n--" + boundary + "\r\n" +
                "Content-Disposition: form-data; name=\"image\"" +
                   "; filename=\"" + filename +  "\"\r\n" +
                "Content-Type: " + contentType + "\r\n" +
                "Content-Transfer-Encoding: binary\r\n\r\n").flush();
    }
        
    private void writeText(PrintWriter writer, String boundary,
            String fieldName, String text) throws IOException {
        if (text != null) {
            writer.append(
                    "--" + boundary + "\r\n" +
                    "Content-Disposition: form-data; name=\"" + fieldName + "\"\r\n" +
                    "Content-Type: text/plain; charset=UTF-8\r\n\r\n" +
                    text + "\r\n").flush();
        }
    }

    private void copy(InputStream is, OutputStream os) throws IOException {
        byte[] buf = new byte[8192];
        int n;
        while ((n = is.read(buf)) != -1) {
            os.write(buf, 0, n);
        }
    }
}
Benutzung z. B.
Java:
URL url = new URL("https://api.imgbb.com/1/upload");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
Jimgbb imgbb = new Jimgbb("dein API key"); 
Jimgbb.Response response = imgbb.upload(conn, inputStream, fileName);
Dabei ist inputStream der InputStream zum Bild und fileName... naja, sollte klar sein.

Das Jimgbb.Response-Objekt enthält neben der eigentlichen Antwort (content) den HTTP-Status-Code und gibt es tatsächlich nur aufgrund mangelnder Dokumentation. Ggf. kannst Du darauf verzichten und direkt den String zurückgeben. Der String content enthält in der Regel das JSON-Objekt, das Du mir einer JSON-Library Deiner Wahl auswerten kannst (z. B. JSR-374, JSON-P).
 
Oder einfach den java.net.http.HttpClient nutzen :)
Ja, wird bei so einer API bestimmt gehen. Bei Amazon habe ich mir damit etwas die Zähne ausgebissen. Aber es war auch eine Schnappsidee, da über die Webseite gehen zu wollen :)
Fakt ist aber, dass meine HttpURLConnection immer ein 503 bekommen hat. Also irgendwas scheint Amazon da noch zu prüfen am Header. Eine curl Library hatte da dann sofort brauchbare Inhalte.

Aber die genauen Details kann ich jetzt nicht mehr sagen. MWS wird ja angeboten - nur eben die Kosten sind blöd, wenn man da nur als Entwickler was machen will (Man braucht halt ein Professional Verkäuferkonto).
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben