FileWriter

[manuche]

Hallo!
Ich habe vor mir einen FileWriter für mein Programm anzulegen, der dokumentiert was das Programm wann macht.
Eine Art Trace halt.
Der FileWriter ansich ist nicht das Problem und ich hab schon nachgelesen wie man ihn erstellt und wie man ihn benutzt.
Mein Problem ist, dass ich nicht weiss wie ich ihn deklarieren soll. Da mein Programm mehrere Methoden hat, wäre ein globaler FileWriter auf den immer und überall zugegriffen wird ideal. Da wäre es doch durchaus sinnvoll wenn ich nicht jedesmal einen try&catch-Block schreiben würde sondern einmal mit dem "throws IOException" arbeite und gut ists. Hat nur leider nicht geklappt xD. Ich hab auch probiert, den FileWriter in eine eigene Methode zu schreiben die bei Bedarf aufgerufen wird und an die die Informationen übergeben werden! Leider ohne Erfolg.
Ich hoffe ihr könnt mir helfen einen globalen FileWriter zu erstellen, der Traces protokollieren kann!!
Gruß manuche

 

[maki]

Nimm doch einfach log4j bevor du das Rad neu erfindest

http://logging.apache.org/log4j/1.2/index.html

 

[manuche]

Ist ja schön und gut und ganz sicher eine tolles Ding nur brauch ich nichts komplexes... Es ist eigentlich ne Übung für mich da ich erst seit kurzem mit Java programmiere! Würde es halt gern selbst programmieren! Trotzdem danke für den Link! Habs mir auf jeden Fall zugelegt für später

 

[Murray]

Wenn du von einer Klasse ein einziges Objekt überall verfügbar machen willst, dann kannst du das mit einer statischen Methode machen:

public class MyFileWriter {

  //--- singleton-object
  private static MyFileWriter instance;
  
  //--- statische Methode; liefert bei jedem Aufruf die gleiche Instanz zurück
  public static MyFileWriter getInstance() { //--- EDIT: hier fehlte der Return-Type 
    if ( instance == null) instance = new MyFileWriter(); //--- EDIT: Konstruktoraufruf war falsch
    return instance;
  }

  //--- privater Konstruktor, damit Instanziierungen nur über statische Methode
  //--- erfolgen können
  private MyFileWriter() {

  }
}

Den Abschnitt mit der Exception-Behandlung habe ich nicht verstanden.

 

[manuche]

Ok ich probiers mal aus... Also überall wo ich was mit dem Filewwriter gelsen hab stand da das an die methode "throws IOException" drangehangen werden muss falls nicht in das File reingeschrieben werden kann... alternativ geht das ganze auch mit nem try&catch-Block...

*edit: So habs probiert aber irgendwie Blick ich deine Methode nich so ganz...
Ich hatte eigentlich gedacht, es würde ähnlich wie "System.out.print(...)" gehen nur das nen textfile geschrieben wird und nicht auf die konsole geschrieben wird aber anscheinend is das gar nicht so einfach

 

[Murray]

Ich dachte, du hättest deine FileWriter schon fertig und suchst jetzt nur einen Weg, den von überall verwenden zu können. Zur Implementierung des FileWriters sagt mein Beispiel ja nichts aus.

Zur Fehlerbehandlung: in diesem Fall würde ich dazu tendieren, die Fehlerbehandlung mit einem try-catch-Block innerhalb des speziellen FileWriters zu machen, damit man nicht überall dort, wo man etwas loggen will, gezwungen wird, die IOExcepions zu behandeln.

 

[manuche]

Ja sagen wir so: ich wüsste wie ich einen erstelle bzw. hab tuts dazu gesehen (die mir in meinem fall leider nicht viel weiter helfen)...
Mein Problem ist es jetzt, das ich ihn so implementiere, dass ich leicht überall drauf zugreifen kann...
Eigene Klasse? irgendwo in der klasse von meinem Programm implementieren? wie drauf zurück greifen? das sind so die fragen die mich beschäftigen und die ich bis jetzt auch noch nich selbst lösen konnte...

 

[maki]

Mein Problem ist es jetzt, das ich ihn so implementiere, dass ich leicht überall drauf zugreifen kann...

Die Antwort hat dir Murray schon genannt

Du kannst ein sog. "Singleton" werwenden, dass ist eine Klasse, von der es nur eine einzige Instanz gibt.

Benutzen würdest du es so:

    MyFileWriter fw= MyFileWriter.getInstance();

Wo immer du so auf deinen MyFileWriter zurückgreifst, wird dieselbe Instanz zurückgegeben.

 

[Murray]

Wo implementieren? Auf jeden Fall in einer eigenen Klasse. Wie zugreifen? Zum Beispiel wie in meinem Codefragment.

 

[manuche]

Ey jetzt überfordert ihr mich nen bisschen

Ich hab grad die Klasse für den FileWriter angelegt... Jetzt möchte ich in einer Methode in meine Programm eine Zeile in eine txt Datei schreiben! Dazu hab ich in die Methode den Schnipsel von maki eingefügt... Beim kompilieren kommt folgender Fehler

Sudokusolver.java:554:17: invalid method declaration; return type required
public static getInstance() {[\quote]

Und wo kann ich meinem FileWriter jetzt sagen was er schreiben soll bzw. worein???

 

[Murray]

Tut mir leid, da war ein Fehler im Code; ist jetzt korrigiert.

 

[Murray]

Und wo kann ich meinem FileWriter jetzt sagen was er schreiben soll bzw. worein???

Ich denke, du hast deinen FileWriter schon geschrieben? Dazu müssten diesen Fragen doch wohl schon beantwortet sein?
Eigentlich müsste es in deinem FileWriter doch eine (von dir implementierte!) Methode println() geben. Dann verwendet man das so:

MyFileWriter.getInstance().println( "Huhu!");

 

[manuche]

Ich denke, du hast deinen FileWriter schon geschrieben? Dazu müssten diesen Fragen doch wohl schon beantwortet sein?
Eigentlich müsste es in deinem FileWriter doch eine (von dir implementierte!) Methode println() geben.

Ich hab mir welche im Internet angeguckt die mir eingeleuchtet haben... Sowas hier:

import java.io.*;

class WriteTextFile {

  public static void main ( String[] args ) throws IOException {
    String fileName = "trace.txt" ;

    FileWriter writer = new FileWriter( fileName );

    writer.write( "Behold her, single in the field,\n"  );  
    writer.write( "Yon solitary Highland Lass!\n"  );  
    writer.write( "Reaping and singing by herself;\n" );  
    writer.write( "Stop here, or gently pass!\n"  );  

    writer.close();
  }
}

Hab aber nicht geschafft sie für mich nutzen zu können, weshalb ich die Frage ans Forum gerichtet hab! Ansonsten hab ich die Codeschnipsel die hier gepostet wurden und versuche sie nachzuvollziehen!

 

[Murray]

Wieder ungetestet:

import java.io.FileWriter;
import java.io.IOException;

public class MyFileWriter {

  //--- singleton-object
  private static MyFileWriter instance;

  //--- interner FileWriter
  private FileWriter fw;
 
  //--- statische Methode; liefert bei jedem Aufruf die gleiche Instanz zurück
  public static MyFileWriter getInstance() {
    if ( instance == null) instance = new MyFileWriter();
    return instance;
  }

  //--- privater Konstruktor, damit Instanziierungen nur über statische Methode
  //--- erfolgen können
  private MyFileWriter() {
    fw = new FileWriter( "trace.txt", true); //---Datei im APPEND-Modus oeffnen
  }

  //--- oeffentliche Methode zur Ausgabe einer Zeichenkette in das Log-File
  public void println( String s) {
    try {
      fw.write( s);
      fw.write( System.getProperty( "line.separator")); //--- Zeilenumbruch-Zeichen vom System erfragen
      fw.flush();
    }catch ( IOException e) {
      System.err.println( "IOException beim Zugriff auf das Log-File:" + e.getMessage());
      e.printStackTrace();
    }
  }
}

Verwenden kann man das dann wie beschrieben mit

MyFileWriter.getInstance().println( "Huhu!");

 

[manuche]

Super... War so ganz gut hat nur noch ein try&catch-Block gefehlt... Endlich kann ichs auch nachvollziehen... zumindest einigermaßen *hust*

import java.io.FileWriter; 
import java.io.IOException; 

public class MyFileWriter { 

  //--- singleton-object 
  private static MyFileWriter instance; 

  //--- interner FileWriter 
  private FileWriter fw; 

  //--- statische Methode; liefert bei jedem Aufruf die gleiche Instanz zurück 
  public static MyFileWriter getInstance() { 
    if ( instance == null) instance = new MyFileWriter(); 
    return instance; 
  } 

  //--- privater Konstruktor, damit Instanziierungen nur über statische Methode 
  //--- erfolgen können 
  private MyFileWriter() { 
    try {
      fw = new FileWriter( "trace.txt", true); //---Datei im APPEND-Modus oeffnen 
    }catch (IOException e){
      //Catch-Block
    }
  } 

  //--- oeffentliche Methode zur Ausgabe einer Zeichenkette in das Log-File 
  public void println( String s) { 
    try { 
      fw.write( s); 
      fw.write( System.getProperty( "line.separator")); //--- Zeilenumbruch-Zeichen vom System erfragen 
      fw.flush(); 
    }catch ( IOException e) { 
      System.err.println( "IOException beim Zugriff auf das Log-File:" + e.getMessage()); 
      e.printStackTrace(); 
    } 
  } 
}

Danke an alle beteiligten

 

[manuche]

So...
Sorry wenn ich das ganze nochmal aufrolle... Mich interessiert, ob ich bei dieser vorgehensweise überprüfen kann ob es das File schon gibt...
Also Idee war, solange reinschreiben zu können wie mein Programm läuft. Beim neuStart wird geprüft ob das File schon existiert und falls das der Fall ist wirds erstmal gelöscht...
Geht das mit dieser Klasse oder muss da dann erst wieder alles übern haufen geschmissen werden?

 

[JPKI]

Überprüfen, ob's die Datei schon gibt?

if (file.exists()) { //mach was

Ich weiss jetzt nicht, wie's bei FileWriter ist, aber bei FileOutputStream wird die Datei standardmäßig einfach überschreiben, es sei denn, man übergibt im Konstruktor als zweites Argument ein true, dann wird das neue Zeug einfach hinten dran gehängt...

 

[manuche]

Ok! Danke aber ich war grad dabei meine Lösung die ich in der zwischenzeit gefunden hab zu lösen und ich habs tatsächlich geschafft ^^
Ich hab einfach ein File Objekt angelegt... is zwar jetzt nach meiner einschätzung ein wenig mischmasch aber es funktioniert:

import java.io.FileWriter;
import java.io.IOException;
import java.io.File;

public class Trace {

  private static Trace instance;
  private File logfile = new File("trace.txt");
  private FileWriter fw;

  public static Trace getInstance() {
    if (instance == null){
      instance = new Trace();
    }
    return instance;
  }

  private Trace() {
    try {
      if (logfile.exists()){
        logfile.delete();
      }
      fw = new FileWriter ("trace.txt", true);
    }catch (IOException e){
      System.err.println ("IOException beim Zugriff auf das Log-File: "+ e.getMessage());
    }
  }

  public void println (String s) {
    try {
      fw.write (s);
      fw.write (System.getProperty ("line.separator"));
      fw.flush();
    }catch (IOException e) {
      System.err.println ("IOException beim Zugriff auf das Log-File: " + e.getMessage());
    }
  }
}

 

[manuche]

Nöchstes folge Problem...
In meiner "Haupt"-Klasse mit meinem Programm würde ich gern feststellen ob eine Datei schon besteht um aus ihr laden zu können... Kann ich das mit der Klasse von oben realisieren? Also eine weitere Methode schreiben, die zurück gibt ob das File da ist oder nich???
Also ich denk mal es geht auf jeden Fall nur ich habs noch nich gesschafft....