Überwachen des err-Streams?

Status
Nicht offen für weitere Antworten.

hdi

Top Contributor
Hallo, fragt mich jetzt nicht wieso, aber ich habe mich gerade gefragt, ob es irgendwie möglich ist, den System.err Stream zu "überwachen".

Ohne lange rumzulabern, Pseudo-Code:

Java:
new Thread(){
     @Override
     public void run(){
           while(true){
                Thread.sleep(1000);
                if(System.err.somethingHasBeenWritten()){ 
                       // hier könnte man jetzt auf einen Laufzeitfehler reagieren,
                       // weil ja in Java Exceptions default-mäßig ihren StackTrace in
                       // den err-Stream schreiben.
                       // Man könnte dann dem User eine Message anzeigen, damit er weiss
                       // warum irgendwie grad alles hängt ;)
                }
            }
      }
}.start();

geht sowas? Wäre ja nicht schlecht ins Programm einzubauen, für den Fall der Fälle, falls echt mal was schlimmes passiert, dann steht weder der User noch der Entwickler (an den das weitergereicht werden könnte) doof da, sondern man weiss zumindest was jetzt passiert ist... Oder :bahnhof:
 

0din

Bekanntes Mitglied
Du meinst die Lustigen roten zeilen abfragen die kommen wenn was schief geht?
Oder meinst du selbstgeschriebene System.err.klamotten?

Bei ersterem, schau dir mal Exceptions/Try-catch an
Bei zweiterem, schau dir mal Exceptions/Try-catch/Exceptions werfen an :D
System.err.klamotte sollte eig nich wirklich gebraucht werdn, dafür hat man immerhin fangbare exceptions (meine meinung)

Edit;
Hab übersehn das du dich über exceptions beschwerst...
Exceptions printen ihren Stacktrace nur wenn sie nirgends gefangen werden (bzw man sie fängt un sagt dasse des machn solln)

Java:
try
{
exceptionWerfen();
}
catch(Exception e)
{
e.printStackTrace(); //zeigt den StackTrace wie du ihn kennst.
//sonst kannste aber auch alles andere rein schreiben
}
 
Zuletzt bearbeitet:

hdi

Top Contributor
Ja Fehlerbehandlung habe ich natürlich schon.
Aber es geht eben um Dinge, die absolut unerwartet auftreten. Ich meine Java kann überall Exceptions werfen, und ich will nicht um jede Methode einen riesigen try{}catch{Exception} Block bauen.
Es geht mir eben um Exceptions, die ich als Programmierer nicht erwarte und daher nicht behandle. Solche, die zB (bei mir) sehr oft während der Entwicklung geschmissen werden. Eine unerwartete NullPointerException vllt, die halt zur Laufzeit fliegen könnte, und ich das auch beim Testen nicht merke weil das nur in einer ganz speziellen Situation passierne kann, an die ich nicht denke.

Für solche Fälle, eben sozusagen in letzter Instanz, damit das Programm selber mitbekommt, das was nicht abgefangen wurde, und der User nicht plötzlich mit einem Programm arbeitet, indem intern lauter Folge-Fehler entstehen, die natürlich niemand mitkriegt weil man im Endprogramm keine Konsole hat.

Ich fände das schon ganz gut, und wenn ich den err irgendwie auf diese
Lustigen roten zeilen
prüfen könnte, könnte ich darauf reagieren. Da würden ja wirklich nur diejenigen Exceptions landen, die ich nicht abfange, denn bei denen, bei denen ich das tue, rufe ich kein printStackTrace() auf.
 

0din

Bekanntes Mitglied
Also den stream abfragen wüsst ich nich...

aber 3 lösungen wüsst ich da evtl.
die eine is lückenlos programmiern und eingaben (oder das zeug was der user unerwartetes rein geben könnte) in tests ausprobiern bzw vom programm gleich als falsch ausgeben lassen.

die zweite wäre etwas arg ... schlampig ...
eine exception fliegt die hirarchie hoch, d.h. jede exception durchfliegn die klasse mit der main/init methode, wenne die hier abfängst kannste selbst entscheidn was damit passiert.

die dritte, assert
Link
 
Zuletzt bearbeitet:

hdi

Top Contributor
Also ich muss ganz ehrlich sagen: Ich finde das absolut nicht schlampig mit dem try-catch um die komplette Main-Methode.
Die ist meist sowieso nur sehr mager, und es ist doch sehr gut wenn man dem User da was anzeigt, falls eine durchkommt. Schon klar, dass das nicht passieren sollte!

Also das find ich schon mal genial, werd ich ab jetzt in jedes meiner Programm einbauen. Vllt lacht ihr Profis mich ja jetzt aus, aber mal ehrlich: Was ist daran schlecht?

...aber leider ist das alleine noch nicht sooo genial, denn sehr viele Fehler passieren auf dem EDT, nicht auf dem das Programm aufrufenden Thread.
Komm ich da vllt auch irgendwie rein um da nen try-catch drumzubauen?
 

0din

Bekanntes Mitglied
Ich weiß zwar nich genau was du nu im sinn hast was schief gehn könnte aber ich geh mal von user eingaben aus.

Ein programm sollte user eingaben schon prüfen bzw. noch sicher im sattel bleiben wenn der "kuddelmuddel" einführt. Da is assert praktisch weils halt abbricht. Das heißt bei 20 mal Ok knopp passiert nie wat, bis was passendes im JTextField steht.
 

hdi

Top Contributor
Neee... wir reden bisschen aneinander vorbei ;)

Es geht nicht um Usereingaben. Es geht hier darum, dass ein Java-Programm (damit meine ich also die API) überall Exceptions werfen kann. Besonders der EDT kann das extrem gut :D

Und es kann ja sein, dass man als Programmierer bestimmte Abläufe nicht berücksichtigt, weil man daran nicht denkt, oder weil man einen bestimmten Zusammenhang nicht findet. Whatever, angenommen der EDT kommt mit ner netten ArrayIndexOutOfBounds weil ein User durch irgendeine Kombination von Listen durchklicken, markieren, abbrechen und Tab-Wechsel (es ist ja egal, ist ja theoretisch), eben diese verursacht hat. Und solche Exceptions beenden ein Programm nicht, und geben außer einem printStackTrace keinen Mucks. Wenn die JList plötzlich nicht mehr anklickbar ist, hat man ja noch Glück. Aber es gibt auch "leise" Fehler. Und weil man an einem JFrame i.d.R. nicht eine Konsole angebracht hat, auf der out und err läuft, merkt das kein Mensch.

Der User arbeitet jetzt glücklich weiter, aber wegen der Exception werden zB jegliche Änderungen die er gerade an seinem superwichtigen Dokument macht, nicht übernommen.

Also verstehst du was ich meine? Es wäre IMHO extrem gut, wenn man eine Möglichkeit hat zu sagen: Hey pass auf, ich hab mit bestem Wissen und Gewissen gecodet, aber falls jetzt irgendwas schiefläuft, was nirgendwo abgefangen wird, dann bitte schmeiß den StackTrace zumindest in eine JOptionPane und zeig das dem User an! Damit er weiss...ok evlt erstmal Programm neustarten weil da jetzt was nicht mehr so ganz passt.

Und mit deiner Idee mit nem try-catch um die Main löst man das für alle Exceptions, die von diesem Thread kommen.
Für weitere Threads kann man sowas ja auch machen, nen abstrakten Thread der einfach ein try-catch um seine run-Methode hält, passt ja.

Und genau sowas fänd ich jetzt für den EDT halt auch genial!
 

0din

Bekanntes Mitglied
ok, geht wirklich etwas an einander vorbei...

Ich würds glaub ich no immer net so machen aber das hängt immer stark vom code ab.
Ohne dein Prog zu kennen würd ich sagen das dir mit dem try um die main am ehesten geholfen is. Obwohl ich das hier offen lassn würde un ma schaun wat die profis morgen dazu sagn (Ich bin au nur Student)
 

André Uhres

Top Contributor
Versuch's mal hiermit. Im Konstruktor deines Hauptprogamms instanzierst du einfach nur folgende Klasse:
Java:
new Konsole();
Fertig. Und hier noch die Klasse:
Java:
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;

public class Konsole extends JFrame implements WindowListener, ActionListener, Runnable {

    private JTextPane textPane;
    private StyledDocument textArea;
    private Thread reader;
    private boolean quit;
    private final PipedInputStream pin = new PipedInputStream();
    private SimpleAttributeSet red;

    /** Default constructor of Konsole
     * The goal of the game is to redirect the classical output for serr.
     * To do so, we will use an independant thread.
     *
     * Creating the object and the window:
     */
    public Konsole() {
        setTitle("Java Konsole");
        textPane = new JTextPane();
        textArea = textPane.getStyledDocument();
        red = new SimpleAttributeSet();
        StyleConstants.setForeground(red, Color.red);
        textPane.setEditable(false);
        textPane.setFont(new Font("Monospaced", Font.PLAIN, 11));
        JButton button = new JButton("Clear");
        getContentPane().setLayout(new BorderLayout());
        getContentPane().add(new JScrollPane(textPane), BorderLayout.CENTER);
        getContentPane().add(button, BorderLayout.SOUTH);
        this.addWindowListener(this);
        button.addActionListener(this);
        redirect();
        setDefaultCloseOperation(HIDE_ON_CLOSE);
        setSize(800, 600);
    }

    /**
     * Redirection of the stream
     *
     */
    private void redirect() {
        try {
            PipedOutputStream pout = new PipedOutputStream(pin);
            System.setErr(new PrintStream(pout, true));
        } catch (java.io.IOException io) {
            try {
                textArea.insertString(textArea.getLength(), "Couldn't redirect STDERR to this konsole\n" + io.getMessage(), null);
            } catch (BadLocationException exception) {
            }
        } catch (SecurityException se) {
            try {
                textArea.insertString(textArea.getLength(), "Couldn't redirect STDERR to this konsole\n" + se.getMessage(), null);
            } catch (BadLocationException exception) {
            }
        }
        quit = false; // signals the Thread that it should exit
// Starting thread to read from the PipedInputStream
//
        reader = new Thread(this);
        reader.setDaemon(true);
        reader.start();
    }

    public synchronized void actionPerformed(ActionEvent evt) {
        try {
            textArea.remove(0, textArea.getLength());
        } catch (BadLocationException exception) {
        }
    }

    /**
     * Running the threads
     */
    public synchronized void run() {
        try {
            while (Thread.currentThread() == reader) {
                try {
                    this.wait(100);
                } catch (InterruptedException ie) {
                }
                if (pin.available() != 0) {
                    String input = this.readLine(pin);
                    textArea.insertString(textArea.getLength(), input, red);
                    if (!isVisible()) {
                        setVisible(true);
                    }
                }
                if (quit) {
                    return;
                }
            }
        } catch (Exception e) {
            try {
                textArea.insertString(textArea.getLength(), "\nKonsole reports an Internal error.", null);
                textArea.insertString(textArea.getLength(), "The error is: " + e, null);
            } catch (BadLocationException exception) {
            }
        }
    }

    /**
     * Reading standard output
     */
    protected synchronized String readLine(PipedInputStream in) throws IOException {
        String input = "";
        do {
            int available = in.available();
            if (available == 0) {
                break;
            }
            byte[] b = new byte[available];
            in.read(b);
            input = input + new String(b, 0, b.length);
        } while (!input.endsWith("\n") && !input.endsWith("\r\n") && !quit);
        return input;
    }

    public void windowClosing(WindowEvent e) {
        setVisible(false);
    }

    public void windowClosed(WindowEvent e) {
        quit = true;
        this.notifyAll(); // stop all threads
        try {
            reader.join(1000);
            pin.close();
        } catch (Exception ex) {
        }
    }

    public void windowOpened(WindowEvent e) {
    }

    public void windowIconified(WindowEvent e) {
    }

    public void windowDeiconified(WindowEvent e) {
    }

    public void windowActivated(WindowEvent e) {
    }

    public void windowDeactivated(WindowEvent e) {
    }
}
 
Zuletzt bearbeitet:
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
J OOP Überwachen, ob ein Objekt erzeugt wird Allgemeine Java-Themen 9
C Überwachen der Zwischenablage, aber wie? Allgemeine Java-Themen 10
8u3631984 Frage zu Java Streams min / max Allgemeine Java-Themen 17
Z Mit Java 8+ Streams Zeilen nummern zu Zeilen hinzufügen Allgemeine Java-Themen 17
F Streams als Alternative für dieses Problem ? Allgemeine Java-Themen 15
Monokuma Lesbarkeit von Streams Allgemeine Java-Themen 6
Monokuma Foreach Schleifen in Streams umändern Allgemeine Java-Themen 23
J Streams Allgemeine Java-Themen 6
LimDul Streams und Exception Allgemeine Java-Themen 8
LimDul Mittels Streams aus Strings A B C den String A, B und C machen Allgemeine Java-Themen 12
K Lesbarkeit von Streams Allgemeine Java-Themen 5
X Ermittlung eines doppelte Paars mit Streams Allgemeine Java-Themen 50
mihe7 Lesbarkeit von Streams Allgemeine Java-Themen 5
N Streams wann .filtern? Allgemeine Java-Themen 2
A Lambda und Streams verstehen Allgemeine Java-Themen 4
J IO Streams Allgemeine Java-Themen 13
M Wie funktionieren parallele Java Streams? Allgemeine Java-Themen 1
R Collections BiPredicate in Java 8 Streams Allgemeine Java-Themen 7
F Umgehen mit übergebenen Streams Allgemeine Java-Themen 3
N read streams umleiten Allgemeine Java-Themen 2
DEvent GZIP Streams und gzip Allgemeine Java-Themen 2
S Streams zusammenfügen Allgemeine Java-Themen 4
J Objekt in Datei speichern mittels Streams Allgemeine Java-Themen 6
F Double mit Streams aus Datei einlesen Allgemeine Java-Themen 3
C in Streams Allgemeine Java-Themen 4
M Sind Streams asynchron? Allgemeine Java-Themen 2
Saxony DOS Konsole und deren Streams Allgemeine Java-Themen 5
B Probleme mit Streams Allgemeine Java-Themen 5
T Zwei Streams verbinden Allgemeine Java-Themen 3
L Die Wahl des richtigen Streams? Allgemeine Java-Themen 3
G Video Streams mit Servlets Allgemeine Java-Themen 3
P Streams per Mail mit JavaMailAPI versenden Allgemeine Java-Themen 3
A Streams: merkwürdiges Verhalten Allgemeine Java-Themen 7
A Streams - merkwürdiges Verhalten Allgemeine Java-Themen 2
thE_29 Problem mit Streams Allgemeine Java-Themen 6

Ähnliche Java Themen


Oben