streamlined logging

- log via logger, if stdout, just wrap in Handler
- logger instance property since handlers are being removed/ added
- java bundled logger uses MessageFormat, so add indexes in curly braces

FabianUtil.java

@@ -1,20 +1,28 @@
-package de.vorsorge.theo.util;
+package FIXME;
 
-import java.io.IOException;
+import java.io.*;
 import java.math.BigDecimal;
 import java.math.MathContext;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.text.DecimalFormat;
 import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.SimpleFormatter;
+import java.util.logging.StreamHandler;
 
+@SuppressWarnings("unused")
 public class FabianUtil {
 
+   private static final Logger LOG = new Logger(FabianUtil.class);
+
    private static final String STD_DIR_TEMP = "/FIXME/temp/";
+   private static final String TEST_OUTPUT_DIR = "testOutput/";
    public static final String ENDING_TXT = "txt";
    public static final String ENDING_JSON = "json";
    public static final String ENDING_HTML = "html";
@@ -25,12 +33,96 @@ public class FabianUtil {
    private FabianUtil() {}
 
 
+   public static class Logger extends java.util.logging.Logger {
+
+      public Logger(Class<?> clazz) {
+         this(java.util.logging.Logger.getLogger(clazz.getName()));
+      }
+
+
+      public Logger(java.util.logging.Logger logger) {
+         super(logger.getName(), logger.getResourceBundleName());
+      }
+
+
+      public void severe(String msg, Object param) {
+         log(Level.SEVERE, msg, param);
+      }
+
+
+      public void severe(String msg, Object... params) {
+         log(Level.SEVERE, msg, params);
+      }
+
+
+      public void warning(String msg, Object param) {
+         log(Level.WARNING, msg, param);
+      }
+
+
+      public void warning(String msg, Object... params) {
+         log(Level.WARNING, msg, params);
+      }
+
+
+      public void info(String msg, Object param) {
+         log(Level.INFO, msg, param);
+      }
+
+
+      public void info(String msg, Object... params) {
+         log(Level.INFO, msg, params);
+      }
+
+
+      public void config(String msg, Object param) {
+         log(Level.CONFIG, msg, param);
+      }
+
+
+      public void config(String msg, Object... params) {
+         log(Level.CONFIG, msg, params);
+      }
+
+
+      public void fine(String msg, Object param) {
+         log(Level.FINE, msg, param);
+      }
+
+
+      public void fine(String msg, Object... params) {
+         log(Level.FINE, msg, params);
+      }
+
+
+      public void finer(String msg, Object param) {
+         log(Level.FINER, msg, param);
+      }
+
+
+      public void finer(String msg, Object... params) {
+         log(Level.FINER, msg, params);
+      }
+
+
+      public void finest(String msg, Object param) {
+         log(Level.FINEST, msg, param);
+      }
+
+
+      public void finest(String msg, Object... params) {
+         log(Level.FINEST, msg, params);
+      }
+   }
+
+
    public static class ProgressHandler {
 
       private static final DecimalFormat TIME_DECIMAL_FORMAT = new DecimalFormat("00");
       protected static final int DEFAULT_LOG_DISTANCE = 50;
       protected static final int DEFAULT_TIME_LOG_DISTANCE = 15;
 
+      protected final Logger log;
       private final ZonedDateTime startTime;
       private final BigDecimal logDistance;
       private final int timeLogDistance;
@@ -39,19 +131,31 @@ public class FabianUtil {
 
 
       public ProgressHandler() {
-         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE);
+         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE, null);
       }
 
 
       public ProgressHandler(int logDistance) {
-         this(logDistance, DEFAULT_TIME_LOG_DISTANCE);
+         this(logDistance, DEFAULT_TIME_LOG_DISTANCE, null);
       }
 
 
       public ProgressHandler(int logDistance, int timeLogDistance) {
+         this(logDistance, timeLogDistance, null);
+      }
+
+
+      public ProgressHandler(int logDistance, int timeLogDistance, OutputStream printer) {
          startTime = ZonedDateTime.now();
          this.logDistance = validateBD(logDistance, "Log-Distanz");
          this.timeLogDistance = validateInt(timeLogDistance, "Zeitbasierte Log-Distanz");
+         log = new Logger(getClass());
+         if (printer != null) {
+            for (Handler handler : log.getHandlers()) {
+               log.removeHandler(handler);
+            }
+            log.addHandler(new StreamHandler(printer, new SimpleFormatter()));
+         }
       }
 
 
@@ -68,12 +172,12 @@ public class FabianUtil {
       }
 
 
-      protected synchronized BigDecimal getCounter() {
+      protected final synchronized BigDecimal counter() {
          return counter;
       }
 
 
-      protected synchronized int getTimeLogDistance() {
+      protected final synchronized int timeLogDistance() {
          return timeLogDistance;
       }
 
@@ -103,7 +207,7 @@ public class FabianUtil {
 
 
       protected synchronized boolean shouldLog() {
-         return counter.remainder(logDistance).signum() == 0 || isBored();
+         return log.isLoggable(Level.INFO) && (counter.remainder(logDistance).signum() == 0 || isBored());
       }
 
 
@@ -120,7 +224,7 @@ public class FabianUtil {
 
       public synchronized void log() {
          Duration timePassed = getTimePassed();
-         System.out.println(counter + " Stück erledigt. " + formatDuration(timePassed) + " vergangen.");
+         log.info("{0} Stück erledigt. {1} vergangen.", counter, formatDuration(timePassed));
          updateLastLoggedAt();
       }
 
@@ -147,7 +251,7 @@ public class FabianUtil {
 
       public synchronized void logFinal() {
          Duration timePassed = getTimePassed();
-         System.out.println(counter + " Stück (100 %) erledigt. " + formatDuration(timePassed) + " vergangen.");
+         log.info("{0} Stück (100 %) erledigt. {1} vergangen.", counter, formatDuration(timePassed));
       }
    }
 
@@ -155,36 +259,42 @@ public class FabianUtil {
    public static class ProgressHandlerWithTotal extends ProgressHandler {
 
       private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
+      private static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
 
       private final BigDecimal total;
 
 
       public ProgressHandlerWithTotal(int total) {
-         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE, total);
+         this(DEFAULT_LOG_DISTANCE, DEFAULT_TIME_LOG_DISTANCE, total, null);
       }
 
 
       public ProgressHandlerWithTotal(int logDistance, int total) {
-         this(logDistance, DEFAULT_TIME_LOG_DISTANCE, total);
+         this(logDistance, DEFAULT_TIME_LOG_DISTANCE, total, null);
       }
 
 
       public ProgressHandlerWithTotal(int logDistance, int timeLogDistance, int total) {
-         super(logDistance, timeLogDistance);
+         this(logDistance, timeLogDistance, total, null);
+      }
+
+
+      public ProgressHandlerWithTotal(int logDistance, int timeLogDistance, int total, OutputStream printer) {
+         super(logDistance, timeLogDistance, printer);
          this.total = validateBD(total, "Gesamt-Anzahl");
       }
 
 
       @Override
       protected synchronized boolean shouldLog() {
-         return super.shouldLog() && getCounter().compareTo(total) <= 0;
+         return super.shouldLog() && counter().compareTo(total) <= 0;
       }
 
 
       @Override
       public synchronized void log() {
-         BigDecimal counter = getCounter();
+         BigDecimal counter = counter();
-         BigDecimal percentage = BigDecimal.valueOf(100).divide(total, MathContext.DECIMAL64).multiply(counter);
+         BigDecimal percentage = ONE_HUNDRED_PERCENT.divide(total, MathContext.DECIMAL64).multiply(counter);
          Duration timePassed = getTimePassed();
 
          String remainingTimePart = "";
@@ -197,8 +307,8 @@ public class FabianUtil {
          }
 
          String counterPrint = total.compareTo(BigDecimal.TEN) >= 0 ? formatNumber(counter) : counter.toString();
-         System.out.println(counterPrint + " Stück von " + total + " (" + PERCENTAGE_FORMAT.format(percentage) + " %) erledigt. "
+         log.info("{0} Stück von {1} ({2} %) erledigt. {3} vergangen{4}.",
-             + formatDuration(timePassed) + " vergangen" + remainingTimePart + ".");
+             counterPrint, total, PERCENTAGE_FORMAT.format(percentage), formatDuration(timePassed), remainingTimePart);
          updateLastLoggedAt();
       }
 
@@ -209,11 +319,11 @@ public class FabianUtil {
 
 
       private synchronized void logTimeBased() {
-         while (getCounter().compareTo(total) != 0) {
+         while (counter().compareTo(total) != 0) {
             logIf();
             long timeSinceLastLogged = getTimeSinceLastLogged();
             try {
-               TimeUnit.SECONDS.sleep(timeSinceLastLogged - getTimeLogDistance());
+               TimeUnit.SECONDS.sleep(timeSinceLastLogged - timeLogDistance());
             } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                return;
@@ -224,22 +334,27 @@ public class FabianUtil {
 
 
    public static void writeTestOutput(String filename, String ending, String content) {
-      writeTestOutput(filename, ending, strToBytes(content));
+      writeToFile(STD_DIR_TEMP + TEST_OUTPUT_DIR, filename, ending, content);
-   }
-
-
-   public static byte[] strToBytes(String str) {
-      return str.getBytes(StandardCharsets.UTF_8);
    }
 
 
    public static void writeTestOutput(String filename, String ending, byte[] content) {
-      writeToFile(STD_DIR_TEMP + "testOutput/", filename, ending, content);
+      writeToFile(STD_DIR_TEMP + TEST_OUTPUT_DIR, filename, ending, content);
+   }
+
+
+   public static void writeTestOutput(String filename, String ending, InputStream content) {
+      writeToFile(STD_DIR_TEMP + TEST_OUTPUT_DIR, filename, ending, content);
+   }
+
+
+   public static void writeTestOutput(String filename, String ending, Reader content) {
+      writeToFile(STD_DIR_TEMP + TEST_OUTPUT_DIR, filename, ending, content);
    }
 
 
    public static void writeDump(String ending, String content) {
-      writeDump(ending, strToBytes(content));
+      writeToFile(STD_DIR_TEMP, "dump", ending, content);
    }
 
 
@@ -248,8 +363,18 @@ public class FabianUtil {
    }
 
 
+   public static void writeDump(String ending, InputStream content) {
+      writeToFile(STD_DIR_TEMP, "dump", ending, content);
+   }
+
+
+   public static void writeDump(String ending, Reader content) {
+      writeToFile(STD_DIR_TEMP, "dump", ending, content);
+   }
+
+
    public static void writeDump(String filename, String ending, String content) {
-      writeDump(filename, ending, strToBytes(content));
+      writeToFile(STD_DIR_TEMP, filename, ending, content);
    }
 
 
@@ -258,9 +383,45 @@ public class FabianUtil {
    }
 
 
+   public static void writeDump(String filename, String ending, InputStream content) {
+      writeToFile(STD_DIR_TEMP, filename, ending, content);
+   }
+
+
+   public static void writeDump(String filename, String ending, Reader content) {
+      writeToFile(STD_DIR_TEMP, filename, ending, content);
+   }
+
+
+   public static void writeToFile(String path, String filename, String ending, String content) {
+      writeToFile(path, filename, ending, new StringReader(content));
+   }
+
+
    public static void writeToFile(String path, String filename, String ending, byte[] content) {
-      try {
+      writeToFile(path, filename, ending, new InputStreamReader(new ByteArrayInputStream(content)));
+   }
+
+
+   public static void writeToFile(String path, String filename, String ending, InputStream content) {
+      writeToFile(path, filename, ending, new InputStreamReader(content));
+   }
+
+
+   public static void writeToFile(String path, String filename, String ending, Reader content) {
+      Path toFile = Paths.get(path + filename + "." + ending);
+      LOG.fine("Schreibe in Datei {}", toFile);
+      try (content) {
+         BufferedWriter out = Files.newBufferedWriter(toFile);
+         content.transferTo(out);
+         /* varianten: mit streams:
+         Files.copy(content, Paths.get(path + filename + "." + ending), StandardCopyOption.REPLACE_EXISTING);
+         oder selber pipen, wie beim Reader/ writer:
+         OutputStream out = Files.newOutputStream(Paths.get(path + filename + "." + ending));
+         content.transferTo(out);
+         oder mit byte-array:
          Files.write(Paths.get(path + filename + "." + ending), content);
+         */
       } catch (IOException e) {
          throw new RuntimeException(e);
       }