Release 0.1.8

microsphere-java-core/src/main/java/io/microsphere/classloading/ManifestArtifactResourceResolver.java

@@ -207,7 +207,9 @@ Artifact resolveArtifactMetaInfoInManifest(Manifest manifest, URL resourceURL) {
         }
         String version = resolveVersion(mainAttributes);
         Artifact artifact = create(artifactId, version, resourceURL);
-        logger.trace("The artifactId was resolved from the resource URL['{}']: {}", artifactId, artifact);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The artifactId was resolved from the resource URL['{}']: {}", artifactId, artifact);
+        }
         return artifact;
     }
 

microsphere-java-core/src/main/java/io/microsphere/classloading/StreamArtifactResourceResolver.java

@@ -113,7 +113,9 @@ public final Artifact resolve(URL resourceURL) {
         Artifact artifact = null;
         try {
             if (archiveFile == null) {
-                logger.trace("The resourceURL['{}'] can't be resolved to be an archive file", resourceURL);
+                if (logger.isTraceEnabled()) {
+                    logger.trace("The resourceURL['{}'] can't be resolved to be an archive file", resourceURL);
+                }
                 artifactMetadataData = readArtifactMetadataDataFromResource(resourceURL, classLoader);
             } else {
                 artifactMetadataData = readArtifactMetadataDataFromArchiveFile(archiveFile);
@@ -149,7 +151,9 @@ protected InputStream readArtifactMetadataDataFromFile(File archiveFile) throws
         JarFile jarFile = new JarFile(archiveFile);
         JarEntry jarEntry = findArtifactMetadataEntry(jarFile);
         if (jarEntry == null) {
-            logger.trace("The artifact metadata entry can't be resolved from the JarFile[path: '{}']", archiveFile);
+            if (logger.isTraceEnabled()) {
+                logger.trace("The artifact metadata entry can't be resolved from the JarFile[path: '{}']", archiveFile);
+            }
             return null;
         }
         return jarFile.getInputStream(jarEntry);
@@ -159,7 +163,9 @@ protected InputStream readArtifactMetadataDataFromFile(File archiveFile) throws
     protected InputStream readArtifactMetadataDataFromDirectory(File directory) throws IOException {
         File artifactMetadataFile = findArtifactMetadata(directory);
         if (artifactMetadataFile == null) {
-            logger.trace("The artifact metadata file can't be found in the directory[path: '{}']", directory);
+            if (logger.isTraceEnabled()) {
+                logger.trace("The artifact metadata file can't be found in the directory[path: '{}']", directory);
+            }
             return null;
         }
         return new FileInputStream(artifactMetadataFile);

microsphere-java-core/src/main/java/io/microsphere/collection/ListUtils.java

@@ -668,6 +668,10 @@ public static <T> void forEach(List<T> values, Consumer<T> consumer) {
         forEach(values, (i, e) -> consumer.accept(e));
     }
 
+    public static <T> boolean addIfAbsent(List<T> values, T newValue) {
+        return values.contains(newValue) ? false : values.add(newValue);
+    }
+
     private ListUtils() {
     }
 }

microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java

@@ -135,7 +135,9 @@ public static boolean shutdown(ExecutorService executorService) {
         if (!executorService.isShutdown()) {
             executorService.shutdown();
         }
-        logger.trace("The ExecutorService({}) has been shutdown", executorService);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The ExecutorService({}) has been shutdown", executorService);
+        }
         return true;
     }
 

microsphere-java-core/src/main/java/io/microsphere/io/IOUtils.java

@@ -367,7 +367,9 @@ public static int copy(InputStream in, OutputStream out) throws IOException {
             byteCount += bytesRead;
         }
         out.flush();
-        logger.trace("Copied {} bytes[buffer size : {}] from InputStream[{}] to OutputStream[{}]", byteCount, BUFFER_SIZE, in, out);
+        if (logger.isTraceEnabled()) {
+            logger.trace("Copied {} bytes[buffer size : {}] from InputStream[{}] to OutputStream[{}]", byteCount, BUFFER_SIZE, in, out);
+        }
         return byteCount;
     }
 

microsphere-java-core/src/main/java/io/microsphere/io/StandardFileWatchService.java

@@ -245,7 +245,9 @@ private void dispatchFileChangedEvent(Path filePath, WatchEvent.Kind watchEventK
         Kind kind = toKind(watchEventKind);
         FileChangedEvent fileChangedEvent = new FileChangedEvent(file, kind);
         eventDispatcher.dispatch(fileChangedEvent);
-        logger.trace("The {} was dispatched", fileChangedEvent);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The {} was dispatched", fileChangedEvent);
+        }
     }
 
     private void registerDirectoriesToWatchService(WatchService watchService) throws Exception {
@@ -254,8 +256,10 @@ private void registerDirectoriesToWatchService(WatchService watchService) throws
             FileChangedMetadata metadata = entry.getValue();
             WatchEvent.Kind[] kinds = metadata.watchEventKinds;
             directoryPath.register(watchService, kinds);
-            logger.trace("The directory[path : '{}' , event kinds : {}] registers the WatchService : {}",
-                    directoryPath, arrayToString(kinds), watchService);
+            if (logger.isTraceEnabled()) {
+                logger.trace("The directory[path : '{}' , event kinds : {}] registers the WatchService : {}",
+                        directoryPath, arrayToString(kinds), watchService);
+            }
         }
     }
 

microsphere-java-core/src/main/java/io/microsphere/io/scanner/SimpleFileScanner.java

@@ -100,7 +100,7 @@ public Set<File> scan(File rootDirectory, boolean recursive, IOFileFilter ioFile
                     filesSet.add(subFile);
                 }
                 if (recursive && subFile.isDirectory()) {
-                    filesSet.addAll(this.scan(subFile, recursive, ioFileFilter));
+                    filesSet.addAll(scan(subFile, recursive, ioFileFilter));
                 }
             }
         }

microsphere-java-core/src/main/java/io/microsphere/net/StandardURLStreamHandlerFactory.java

@@ -86,7 +86,9 @@ URLStreamHandler createURLStreamHandler(Field defaultFactoryField, String protoc
 
     URLStreamHandler createURLStreamHandlerFromDefaultFactory(Field defaultFactoryField, String protocol) {
         if (defaultFactoryField == null) {
-            logger.trace("The 'defaultFactory' field can't be found in the class URL.");
+            if (logger.isTraceEnabled()) {
+                logger.trace("The 'defaultFactory' field can't be found in the class URL.");
+            }
             return null;
         }
         URLStreamHandlerFactory factory = getStaticFieldValue(defaultFactoryField);

microsphere-java-core/src/main/java/io/microsphere/net/URLUtils.java

@@ -1184,7 +1184,9 @@ public static String resolveProtocol(String url) {
         }
         for (int i = 0; i <= indexOfColon; i++) {
             if (isWhitespace(url.charAt(i))) {
-                logger.trace("The protocol content should not contain the whitespace[url : '{}' , index : {}]", url, i);
+                if (logger.isTraceEnabled()) {
+                    logger.trace("The protocol content should not contain the whitespace[url : '{}' , index : {}]", url, i);
+                }
                 return null;
             }
         }

microsphere-java-core/src/main/java/io/microsphere/process/ClassicProcessIdResolver.java

@@ -82,7 +82,9 @@ public boolean supports() {
     @Override
     public Long current() {
         Long processId = valueOf(processIdValue);
-        logger.trace("The PID was resolved from the method 'java.lang.management.RuntimeMXBean#getName()' = {} : {}", runtimeName, processId);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The PID was resolved from the method 'java.lang.management.RuntimeMXBean#getName()' = {} : {}", runtimeName, processId);
+        }
         return processId;
     }
 

microsphere-java-core/src/main/java/io/microsphere/process/ModernProcessIdResolver.java

@@ -64,7 +64,9 @@ public boolean supports() {
     public Long current() {
         Object processHandle = invokeStaticMethod(PROCESS_HANDLE_CLASS, "current");
         Long pid = invokeMethod(processHandle, PROCESS_HANDLE_CLASS, "pid");
-        logger.trace("The PID was resolved from the method 'java.lang.ProcessHandle#pid()' : {}", pid);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The PID was resolved from the method 'java.lang.ProcessHandle#pid()' : {}", pid);
+        }
         return pid;
     }
 

microsphere-java-core/src/main/java/io/microsphere/process/ProcessExecutor.java

@@ -175,7 +175,9 @@ public void execute(OutputStream outputStream, long timeout, TimeUnit timeUnit)
                 }
             } finally {
                 processManager.removeUnfinishedProcess(process, options);
-                logger.trace("The command['{}'] is executed with exit value : {}", commandLine, exitValue);
+                if (logger.isTraceEnabled()) {
+                    logger.trace("The command['{}'] is executed with exit value : {}", commandLine, exitValue);
+                }
             }
             return targetOutputStream.toByteArray();
         });

microsphere-java-core/src/main/java/io/microsphere/process/VirtualMachineProcessIdResolver.java

@@ -90,7 +90,9 @@ public Long current() {
         RuntimeMXBean runtimeMXBean = getRuntimeMXBean();
         Object jvm = getFieldValue(runtimeMXBean, JVM_FIELD);
         Integer processId = invokeMethod(jvm, GET_PROCESS_ID_METHOD_NAME);
-        logger.trace("The PID was resolved from the native method 'sun.management.VMManagementImpl#getProcessId()' : {}", processId);
+        if (logger.isTraceEnabled()) {
+            logger.trace("The PID was resolved from the native method 'sun.management.VMManagementImpl#getProcessId()' : {}", processId);
+        }
         return valueOf(processId.longValue());
     }
 

microsphere-java-core/src/main/java/io/microsphere/reflect/FieldUtils.java

@@ -115,7 +115,9 @@ public static Field findField(Class<?> klass, String fieldName) {
             // ignore, try the super class
             field = findField(klass.getSuperclass(), fieldName);
         }
-        logger.trace("To find the field[name :'{}'] from the class : '{}'", fieldName, klass);
+        if (logger.isTraceEnabled()) {
+            logger.trace("To find the field[name :'{}'] from the class : '{}'", fieldName, klass);
+        }
         return field;
     }
 
@@ -507,8 +509,6 @@ public static <V> V getFieldValue(Object instance, String fieldName, Class<V> fi
      * @param instance The object instance from which to retrieve the field value
      * @param field    The {@link Field} object representing the field to retrieve
      * @return The value of the field if found and accessible; otherwise, {@code null}
-     * @throws IllegalStateException    if this Field object is enforcing Java language access control and the underlying
-     *                                  field is inaccessible
      * @throws IllegalArgumentException if the specified object is not an instance of the class or interface declaring
      *                                  the underlying field (or a subclass or implementor thereof)
      */
@@ -523,10 +523,9 @@ public static <V> V getFieldValue(Object instance, Field field) throws IllegalSt
         try {
             accessible = trySetAccessible(field);
             fieldValue = (V) field.get(instance);
-        } catch (IllegalAccessException e) {
-            handleIllegalAccessException(e, instance, field, accessible);
-        } catch (IllegalArgumentException e) {
-            handleIllegalArgumentException(e, instance, field);
+        } catch (IllegalAccessException | IllegalArgumentException e) {
+            handleFieldException(e, instance, field);
+            throw new IllegalArgumentException(e);
         }
 
         return fieldValue;
@@ -610,7 +609,6 @@ public static <V> V setFieldValue(Object instance, String fieldName, V value) th
      * @param field    The {@link Field} object representing the field to modify
      * @param value    The new value to assign to the field
      * @return The previous value of the field before modification, or {@code null} if the field was not found or inaccessible
-     * @throws IllegalStateException    If this Field object is enforcing Java language access control and the underlying field is inaccessible
      * @throws IllegalArgumentException If the specified object is not an instance of the class or interface declaring the underlying field
      */
     @Nullable
@@ -620,17 +618,15 @@ public static <V> V setFieldValue(Object instance, Field field, V value) throws
         }
 
         V previousValue = null;
-        boolean accessible = false;
         try {
-            accessible = trySetAccessible(field);
+            trySetAccessible(field);
             previousValue = (V) field.get(instance);
             if (!Objects.equals(previousValue, value)) {
                 field.set(instance, value);
             }
-        } catch (IllegalAccessException e) {
-            handleIllegalAccessException(e, instance, field, accessible);
-        } catch (IllegalArgumentException e) {
-            handleIllegalArgumentException(e, instance, field);
+        } catch (IllegalAccessException | IllegalArgumentException e) {
+            handleFieldException(e, instance, field);
+            throw new IllegalArgumentException(e);
         }
 
         return previousValue;
@@ -679,18 +675,11 @@ public static void assertFieldMatchType(Object instance, String fieldName, Class
         }
     }
 
-    static void handleIllegalAccessException(IllegalAccessException e, Object instance, Field field, boolean accessible) {
-        String errorMessage = format("The instance [object : {} , class : {} ] can't access the field[name : '{}' , type : {} , accessible : {}]",
-                instance, getTypeName(instance.getClass()), field.getName(), getTypeName(field.getType()), accessible);
-        logger.trace(errorMessage);
-        throw new IllegalStateException(errorMessage, e);
-    }
-
-    static void handleIllegalArgumentException(IllegalArgumentException e, Object instance, Field field) {
-        String errorMessage = format("The instance[object : {} , class : {}] can't match the field[name : '{}' , type : {}]",
-                instance, getTypeName(instance.getClass()), field.getName(), getTypeName(field.getType()));
-        logger.trace(errorMessage);
-        throw new IllegalArgumentException(errorMessage, e);
+    static void handleFieldException(Exception e, Object instance, Field field) {
+        if (logger.isTraceEnabled()) {
+            logger.trace("The instance[object : {} , class : {}] can't match the field[name : '{}' , type : {}]",
+                    instance, getTypeName(instance.getClass()), field.getName(), getTypeName(field.getType()), e);
+        }
     }
 
     private FieldUtils() {