REPORT-93688 REPORT-94439 创建hsql连接超时

fine-hsqldb/src/main/java/com/fr/third/org/hsqldb/lib/FrameworkLogger.java

@@ -50,35 +50,35 @@ import java.lang.reflect.InvocationTargetException;
 
 /**
  * A logging framework wrapper that supports java.util.logging and log4j.
- * <P/>
+ * <p/>
  * Logger hierarchies are stored at the Class level.
  * Log4j will be used if the Log4j system (not necessarily config files) are
  * found in the runtime classpath.
  * Otherwise, java.util.logging will be used.
- * <P/>
+ * <p/>
  * This is pretty safe because for use cases where multiple hierarchies
  * are desired, classloader hierarchies will effectively isolate multiple
  * class-level Logger hierarchies.
- * <P/>
+ * <p/>
  * Sad as it is, the java.util.logging facility lacks the most basic
  * developer-side and configuration-side capabilities.
  * Besides having a non-scalable discovery system, the designers didn't
  * comprehend the need for a level between WARNING and SEVERE!
  * Since we don't want to require log4j in Classpath, we have to live
  * with these constraints.
- * <P/>
+ * <p/>
  * As with all the popular logging frameworks, if you want to capture a
  * stack trace, you must use the two-parameters logging methods.
  * I.e., you must also pass a String, or only toString() from your
  * throwable will be captured.
- * <P/>
+ * <p/>
  * Usage example:<CODE><PRE>
  * private static FrameworkLogger logger =
- *        FrameworkLogger.getLog(SqlTool.class);
+ * FrameworkLogger.getLog(SqlTool.class);
  * ...
- *   logger.finer("Doing something log-worthy");
+ * logger.finer("Doing something log-worthy");
  * </PRE> </CODE>
- *
+ * <p>
  * <p/>
  * The system level property <code>hsqldb.reconfig_logging=false</code> is
  * required to avoid configuration of java.util.logging. Otherwise
@@ -117,13 +117,13 @@ public class FrameworkLogger {
                 loggerInstances.keySet()).toString();
     }
 
-    static private Map     loggerInstances  = new HashMap();
+    static private Map loggerInstances = new HashMap();
-    static private Map     jdkToLog4jLevels = new HashMap();
+    static private Map jdkToLog4jLevels = new HashMap();
-    static private Method  log4jGetLogger;
+    static private Method log4jGetLogger;
-    static private Method  log4jLogMethod;
+    static private Method log4jLogMethod;
     static private boolean callerFqcnAvailable = false;
-    private Object        log4jLogger;
+    private Object log4jLogger;
-    private Logger        jdkLogger;
+    private Logger jdkLogger;
 
     // No need for more than one static, since we have only one console
     static private boolean noopMode;    // If true, then logging calls do nothing
@@ -131,7 +131,8 @@ public class FrameworkLogger {
     static {
         try {
             reconfigure();
-        } catch (SecurityException e) {}
+        } catch (SecurityException e) {
+        }
     }
 
     /**
@@ -148,10 +149,10 @@ public class FrameworkLogger {
      */
     public static synchronized void clearLoggers(String prefixToZap) {
 
-        Set                targetKeys = new HashSet();
+        Set targetKeys = new HashSet();
-        java.util.Iterator it         = loggerInstances.keySet().iterator();
+        java.util.Iterator it = loggerInstances.keySet().iterator();
-        String             k;
+        String k;
-        String             dottedPrefix = prefixToZap + '.';
+        String dottedPrefix = prefixToZap + '.';
 
         while (it.hasNext()) {
             k = (String) it.next();
@@ -169,32 +170,32 @@ public class FrameworkLogger {
             throws ClassNotFoundException, IllegalAccessException,
             NoSuchMethodException, InvocationTargetException {
         Method log4jToLevel = Class.forName(classString).getMethod(
-                "toLevel", new Class[]{ String.class });
+                "toLevel", new Class[]{String.class});
 
         jdkToLog4jLevels.put(Level.ALL,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "ALL" }));
+                        new Object[]{"ALL"}));
         jdkToLog4jLevels.put(Level.FINER,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "DEBUG" }));
+                        new Object[]{"DEBUG"}));
         jdkToLog4jLevels.put(Level.WARNING,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "ERROR" }));
+                        new Object[]{"ERROR"}));
         jdkToLog4jLevels.put(Level.SEVERE,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "FATAL" }));
+                        new Object[]{"FATAL"}));
         jdkToLog4jLevels.put(Level.INFO,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "INFO" }));
+                        new Object[]{"INFO"}));
         jdkToLog4jLevels.put(Level.OFF,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "OFF" }));
+                        new Object[]{"OFF"}));
         jdkToLog4jLevels.put(Level.FINEST,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "TRACE" }));
+                        new Object[]{"TRACE"}));
         jdkToLog4jLevels.put(Level.WARNING,
                 log4jToLevel.invoke(null,
-                        new Object[]{ "WARN" }));
+                        new Object[]{"WARN"}));
     }
 
     static void reconfigure() {
@@ -207,8 +208,8 @@ public class FrameworkLogger {
         loggerInstances.clear();
         jdkToLog4jLevels.clear();
 
-        log4jGetLogger   = null;
+        log4jGetLogger = null;
-        log4jLogMethod   = null;
+        log4jLogMethod = null;
         callerFqcnAvailable = false;
 
         // Precedence:
@@ -235,12 +236,12 @@ public class FrameworkLogger {
                 populateJdkToLog4jLevels("com.fr.third.apache.logging.log4j.Level");
 
                 log4jLogMethod = log4jLoggerClass.getMethod("log",
-                        new Class[] {
+                        new Class[]{
                                 Class.forName("com.fr.third.apache.logging.log4j.Level"),
                                 Object.class, Throwable.class
                         });
                 log4jGetLogger = log4jManagerClass.getMethod("getLogger",
-                        new Class[]{ String.class });
+                        new Class[]{String.class});
                 // This last object is what we toggle on to generate either
                 // Log4j or Jdk Logger objects (to wrap).
 
@@ -266,8 +267,8 @@ public class FrameworkLogger {
         // Reset
         log4jLoggerClass = null;
         log4jManagerClass = null;
-        log4jLogMethod   = null;
+        log4jLogMethod = null;
-        log4jGetLogger   = null;
+        log4jGetLogger = null;
         jdkToLog4jLevels.clear();
 
         try {
@@ -287,12 +288,12 @@ public class FrameworkLogger {
                 populateJdkToLog4jLevels("com.fr.third.apache.log4j.Level");
 
                 log4jLogMethod = log4jLoggerClass.getMethod("log",
-                        new Class[] {
+                        new Class[]{
                                 String.class, Class.forName("com.fr.third.apache.log4j.Priority"),
                                 Object.class, Throwable.class
                         });
                 log4jGetLogger = log4jManagerClass.getMethod("getLogger",
-                        new Class[]{ String.class });
+                        new Class[]{String.class});
                 // This last object is what we toggle on to generate either
                 // Log4j or Jdk Logger objects (to wrap).
                 callerFqcnAvailable = true;
@@ -319,8 +320,8 @@ public class FrameworkLogger {
         // Reset
         log4jLoggerClass = null;
         log4jManagerClass = null;
-        log4jLogMethod   = null;
+        log4jLogMethod = null;
-        log4jGetLogger   = null;
+        log4jGetLogger = null;
         callerFqcnAvailable = false;
         jdkToLog4jLevels.clear();
 
@@ -397,7 +398,7 @@ public class FrameworkLogger {
             } else {
                 try {
                     log4jLogger = log4jGetLogger.invoke(null,
-                            new Object[]{ s });
+                            new Object[]{s});
                 } catch (Exception e) {
                     throw new RuntimeException(
                             "Failed to instantiate Log4j Logger", e);
@@ -412,7 +413,7 @@ public class FrameworkLogger {
 
     /**
      * User's entry-point into this logging system.
-     * <P/>
+     * <p/>
      * You normally want to work with static (class-level) pointers to
      * logger instances, for performance efficiency.
      * See the class-level JavaDoc for a usage example.
@@ -465,9 +466,9 @@ public class FrameworkLogger {
      * Just like FrameworkLogger.log(Level, String),
      * but also logs a stack trace.
      *
-     * @param level java.util.logging.Level level to filter and log at
+     * @param level   java.util.logging.Level level to filter and log at
      * @param message Message to be logged
-     * @param t Throwable whose stack trace will be logged.
+     * @param t       Throwable whose stack trace will be logged.
      * @see #log(Level, String)
      * @see Logger#log(Level, String)
      * @see Level
@@ -492,8 +493,8 @@ public class FrameworkLogger {
 
         if (log4jLogger == null) {
             StackTraceElement[] elements = new Throwable().getStackTrace();
-            String            c          = "";
+            String c = "";
-            String            m          = "";
+            String m = "";
 
             if (elements.length > revertMethods) {
                 c = elements[revertMethods].getClassName();
@@ -508,10 +509,10 @@ public class FrameworkLogger {
         } else {
             try {
                 log4jLogMethod.invoke(log4jLogger, callerFqcnAvailable
-                        ? new Object[] {
+                        ? new Object[]{
                         skipClass.getName(), jdkToLog4jLevels.get(level),
                         message, t}
-                        : new Object[] {
+                        : new Object[]{
                         jdkToLog4jLevels.get(level), message, t}
                 );
             } catch (Exception e) {
@@ -539,10 +540,10 @@ public class FrameworkLogger {
         } else {
             try {
                 log4jLogMethod.invoke(log4jLogger, callerFqcnAvailable
-                        ? new Object[] {
+                        ? new Object[]{
                         FrameworkLogger.class.getName(),
                         jdkToLog4jLevels.get(level), message, null}
-                        : new Object[] {
+                        : new Object[]{
                         jdkToLog4jLevels.get(level), message, null}
                 );
 
@@ -557,7 +558,7 @@ public class FrameworkLogger {
     // Wrappers
 
     /**
-     * @param level java.util.logging.Level level to filter and log at
+     * @param level   java.util.logging.Level level to filter and log at
      * @param message Message to be logged
      * @see Logger#log(Level, String)
      * @see Level
@@ -679,7 +680,7 @@ public class FrameworkLogger {
 
     /**
      * Whether this JVM is configured with java.util.logging defaults.
-     *
+     * <p>
      * If the JRE-provided config file is not in the expected place, then
      * we return false.
      */
@@ -693,7 +694,7 @@ public class FrameworkLogger {
         }
 
         FileInputStream fis = null;
-        LogManager      lm  = LogManager.getLogManager();
+        LogManager lm = LogManager.getLogManager();
 
         try {
             fis = new FileInputStream(globalCfgFile);
@@ -703,14 +704,14 @@ public class FrameworkLogger {
             defaultProps.load(fis);
 
             Enumeration names = defaultProps.propertyNames();
-            int         i     = 0;
+            int i = 0;
-            String      name;
+            String name;
-            String      liveVal;
+            String liveVal;
 
             while (names.hasMoreElements()) {
                 i++;
 
-                name    = (String) names.nextElement();
+                name = (String) names.nextElement();
                 liveVal = lm.getProperty(name);
 
                 if (liveVal == null) {