Release 0.1.8

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

@@ -152,5 +152,4 @@ private void removeJdkClassPathURLs(Set<URL> classPathURLs) {
             }
         }
     }
-
-}
+}

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/DelegatingDeque.java

@@ -136,6 +136,10 @@ public Deque<E> getDelegate() {
      * @since Java 21
      */
     public Deque<E> reversed() {
+        return reversed(reversedMethodHandle);
+    }
+
+    protected Deque<E> reversed(MethodHandle reversedMethodHandle) {
         if (reversedMethodHandle == null) {
             return reversedDeque(getDelegate());
         }

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

@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.microsphere.collection;
+
+import io.microsphere.util.Utils;
+
+import java.util.Iterator;
+import java.util.Objects;
+
+/**
+ * The utilties class for {@link Iterator}
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @see Iterator
+ * @since 1.0.0
+ */
+public abstract class Iterators implements Utils {
+
+    /**
+     * Equals two {@link Iterator Iterators}
+     *
+     * @param one     {@link Iterator}
+     * @param another {@link Iterator}
+     * @return <code>true</code> if equals
+     */
+    public static boolean equals(Iterator<?> one, Iterator<?> another) {
+        if (one == another) {
+            return true;
+        }
+        if (one == null || another == null) {
+            return false;
+        }
+
+        while (one.hasNext() && another.hasNext()) {
+            if (!Objects.equals(one.next(), another.next())) {
+                return false;
+            }
+        }
+        return !one.hasNext() && !another.hasNext();
+    }
+
+    private Iterators() {
+    }
+
+}

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/collection/ReversedDeque.java

@@ -180,12 +180,7 @@ public boolean equals(Object o) {
 
         Iterator<E> iterator = iterator();
         Iterator<E> otherIterator = ((Iterable<E>) o).iterator();
-        while (iterator.hasNext() && otherIterator.hasNext()) {
-            if (!Objects.equals(iterator.next(), otherIterator.next())) {
-                return false;
-            }
-        }
-        return true;
+        return Iterators.equals(iterator, otherIterator);
     }
 
     @Override

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

@@ -16,6 +16,9 @@
  */
 package io.microsphere.concurrent;
 
+import io.microsphere.lang.DelegatingWrapper;
+import io.microsphere.lang.Wrapper;
+
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Spliterator;
@@ -47,57 +50,58 @@
  * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
  * @since 1.0.0
  */
-public class DelegatingBlockingQueue<E> implements BlockingQueue<E> {
+public class DelegatingBlockingQueue<E> implements BlockingQueue<E>, DelegatingWrapper {
 
     private final BlockingQueue<E> delegate;
 
     public DelegatingBlockingQueue(BlockingQueue<E> delegate) {
-        this.delegate = delegate;
+        BlockingQueue<E> unwrapper = Wrapper.tryUnwrap(delegate, BlockingQueue.class);
+        this.delegate = unwrapper == null ? delegate : unwrapper;
     }
 
     @Override
     public Iterator<E> iterator() {
-        return delegate.iterator();
+        return this.delegate.iterator();
     }
 
     @Override
     public Object[] toArray() {
-        return delegate.toArray();
+        return this.delegate.toArray();
     }
 
     @Override
     public <T> T[] toArray(T[] a) {
-        return delegate.toArray(a);
+        return this.delegate.toArray(a);
     }
 
     @Override
     public boolean containsAll(Collection<?> c) {
-        return delegate.containsAll(c);
+        return this.delegate.containsAll(c);
     }
 
     @Override
     public boolean addAll(Collection<? extends E> c) {
-        return delegate.addAll(c);
+        return this.delegate.addAll(c);
     }
 
     @Override
     public boolean removeAll(Collection<?> c) {
-        return delegate.removeAll(c);
+        return this.delegate.removeAll(c);
     }
 
     @Override
     public boolean removeIf(Predicate<? super E> filter) {
-        return delegate.removeIf(filter);
+        return this.delegate.removeIf(filter);
     }
 
     @Override
     public boolean retainAll(Collection<?> c) {
-        return delegate.retainAll(c);
+        return this.delegate.retainAll(c);
     }
 
     @Override
     public void clear() {
-        delegate.clear();
+        this.delegate.clear();
     }
 
     @Override
@@ -112,121 +116,126 @@ public boolean equals(Object o) {
             DelegatingBlockingQueue that = (DelegatingBlockingQueue) o;
             return this.delegate.equals(that.delegate);
         }
-        return delegate.equals(o);
+        return this.delegate.equals(o);
     }
 
     @Override
     public int hashCode() {
-        return delegate.hashCode();
+        return this.delegate.hashCode();
     }
 
     @Override
     public Spliterator<E> spliterator() {
-        return delegate.spliterator();
+        return this.delegate.spliterator();
     }
 
     @Override
     public Stream<E> stream() {
-        return delegate.stream();
+        return this.delegate.stream();
     }
 
     @Override
     public Stream<E> parallelStream() {
-        return delegate.parallelStream();
+        return this.delegate.parallelStream();
     }
 
     @Override
     public boolean add(E e) {
-        return delegate.add(e);
+        return this.delegate.add(e);
     }
 
     @Override
     public boolean offer(E e) {
-        return delegate.offer(e);
+        return this.delegate.offer(e);
     }
 
     @Override
     public void put(E e) throws InterruptedException {
-        delegate.put(e);
+        this.delegate.put(e);
     }
 
     @Override
     public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
-        return delegate.offer(e, timeout, unit);
+        return this.delegate.offer(e, timeout, unit);
     }
 
     @Override
     public E take() throws InterruptedException {
-        return delegate.take();
+        return this.delegate.take();
     }
 
     @Override
     public E poll(long timeout, TimeUnit unit) throws InterruptedException {
-        return delegate.poll(timeout, unit);
+        return this.delegate.poll(timeout, unit);
     }
 
     @Override
     public int remainingCapacity() {
-        return delegate.remainingCapacity();
+        return this.delegate.remainingCapacity();
     }
 
     @Override
     public boolean remove(Object o) {
-        return delegate.remove(o);
+        return this.delegate.remove(o);
     }
 
     @Override
     public boolean contains(Object o) {
-        return delegate.contains(o);
+        return this.delegate.contains(o);
     }
 
     @Override
     public int drainTo(Collection<? super E> c) {
-        return delegate.drainTo(c);
+        return this.delegate.drainTo(c);
     }
 
     @Override
     public int drainTo(Collection<? super E> c, int maxElements) {
-        return delegate.drainTo(c, maxElements);
+        return this.delegate.drainTo(c, maxElements);
     }
 
     @Override
     public E remove() {
-        return delegate.remove();
+        return this.delegate.remove();
     }
 
     @Override
     public E poll() {
-        return delegate.poll();
+        return this.delegate.poll();
     }
 
     @Override
     public E element() {
-        return delegate.element();
+        return this.delegate.element();
     }
 
     @Override
     public E peek() {
-        return delegate.peek();
+        return this.delegate.peek();
     }
 
     @Override
     public int size() {
-        return delegate.size();
+        return this.delegate.size();
     }
 
     @Override
     public boolean isEmpty() {
-        return delegate.isEmpty();
+        return this.delegate.isEmpty();
     }
 
     @Override
     public void forEach(Consumer<? super E> action) {
-        delegate.forEach(action);
+        this.delegate.forEach(action);
     }
 
     @Override
     public String toString() {
-        return delegate.toString();
+        return this.delegate.toString();
+    }
+
+    @Override
+    public Object getDelegate() {
+        return this.delegate;
     }
 }

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;
     }