Merge pull request #131 from mercyblitz/dev

Test coverage

Author: mercyblitz

microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyProcessingTest.java

@@ -17,7 +17,7 @@
 package io.microsphere.annotation.processor;
 
 import io.microsphere.annotation.ConfigurationProperty;
-import io.microsphere.classloading.ManifestArtifactResolver;
+import io.microsphere.classloading.ManifestArtifactResourceResolver;
 import org.junit.jupiter.api.Test;
 
 import javax.lang.model.element.AnnotationMirror;
@@ -42,12 +42,12 @@ public class ConfigurationPropertyProcessingTest extends AbstractAnnotationProce
 
     @Override
     protected void addCompiledClasses(Set<Class<?>> compiledClasses) {
-        compiledClasses.add(ManifestArtifactResolver.class);
+        compiledClasses.add(ManifestArtifactResourceResolver.class);
     }
 
     @Test
     public void test() {
-        TypeElement type = getTypeElement(ManifestArtifactResolver.class);
+        TypeElement type = getTypeElement(ManifestArtifactResourceResolver.class);
         List<VariableElement> fields = getDeclaredFields(type);
         assertNotNull(fields);
         for (VariableElement field : fields) {

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

@@ -0,0 +1,180 @@
+/*
+ * 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.classloading;
+
+import io.microsphere.annotation.Nullable;
+import io.microsphere.logging.Logger;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.List;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import static io.microsphere.collection.CollectionUtils.first;
+import static io.microsphere.collection.ListUtils.first;
+import static io.microsphere.io.FileUtils.resolveRelativePath;
+import static io.microsphere.io.IOUtils.close;
+import static io.microsphere.io.scanner.SimpleFileScanner.INSTANCE;
+import static io.microsphere.logging.LoggerFactory.getLogger;
+import static io.microsphere.net.URLUtils.resolveArchiveFile;
+import static io.microsphere.util.Assert.assertNotNull;
+import static io.microsphere.util.ClassLoaderUtils.getDefaultClassLoader;
+import static io.microsphere.util.jar.JarUtils.filter;
+
+/**
+ * Abstract {@link ArtifactResourceResolver} class
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @see ArtifactResourceResolver
+ * @since 1.0.0
+ */
+public abstract class AbstractArtifactResourceResolver implements ArtifactResourceResolver {
+
+    protected final Logger logger = getLogger(getClass());
+
+    protected final ClassLoader classLoader;
+
+    protected final int priority;
+
+    protected AbstractArtifactResourceResolver(int priority) {
+        this(getDefaultClassLoader(), priority);
+    }
+
+    protected AbstractArtifactResourceResolver(ClassLoader classLoader, int priority) {
+        assertNotNull(classLoader, () -> "The 'classLoader' must not be null");
+        this.classLoader = classLoader;
+        this.priority = priority;
+    }
+
+    @Override
+    public final Artifact resolve(URL resourceURL) {
+        if (resourceURL == null) {
+            return null;
+        }
+
+        File archiveFile = resolveArchiveFile(resourceURL);
+        InputStream artifactMetadataData = null;
+        Artifact artifact = null;
+        try {
+            if (archiveFile == null) {
+                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);
+            }
+            if (artifactMetadataData != null) {
+                artifact = resolve(resourceURL, artifactMetadataData, classLoader);
+            }
+        } catch (IOException e) {
+            if (logger.isErrorEnabled()) {
+                logger.error("The Artifact can't be resolved from the resource URL : {}", resourceURL, e);
+            }
+        } finally {
+            // close the InputStream
+            close(artifactMetadataData);
+        }
+        return artifact;
+    }
+
+    @Nullable
+    protected InputStream readArtifactMetadataDataFromResource(URL resourceURL, ClassLoader classLoader) throws IOException {
+        return null;
+    }
+
+    @Nullable
+    protected InputStream readArtifactMetadataDataFromArchiveFile(File archiveFile) throws IOException {
+        InputStream artifactMetadataData = null;
+        if (archiveFile.isFile()) {
+            artifactMetadataData = readArtifactMetadataDataFromFile(archiveFile);
+        } else if (archiveFile.isDirectory()) {
+            artifactMetadataData = readArtifactMetadataDataFromDirectory(archiveFile);
+        }
+        return artifactMetadataData;
+    }
+
+    @Nullable
+    protected InputStream readArtifactMetadataDataFromFile(File archiveFile) throws IOException {
+        JarFile jarFile = new JarFile(archiveFile);
+        JarEntry jarEntry = findArtifactMetadataEntry(jarFile);
+        if (jarEntry == null) {
+            if (logger.isTraceEnabled()) {
+                logger.trace("The artifact metadata entry can't be resolved from the JarFile[path: '{}']", archiveFile);
+            }
+            return null;
+        }
+        return jarFile.getInputStream(jarEntry);
+    }
+
+    @Nullable
+    protected InputStream readArtifactMetadataDataFromDirectory(File directory) throws IOException {
+        File artifactMetadataFile = findArtifactMetadata(directory);
+        if (artifactMetadataFile == null) {
+            if (logger.isTraceEnabled()) {
+                logger.trace("The artifact metadata file can't be found in the directory[path: '{}']", directory);
+            }
+            return null;
+        }
+        return new FileInputStream(artifactMetadataFile);
+    }
+
+    protected JarEntry findArtifactMetadataEntry(JarFile jarFile) throws IOException {
+        List<JarEntry> entries = filter(jarFile, this::isArtifactMetadataEntry);
+        return first(entries);
+    }
+
+    protected File findArtifactMetadata(File directory) throws IOException {
+        Set<File> files = INSTANCE.scan(directory, true, file -> isArtifactMetadataFile(directory, file));
+        return first(files);
+    }
+
+    protected boolean isArtifactMetadataEntry(JarEntry jarEntry) {
+        return isArtifactMetadata(jarEntry.getName());
+    }
+
+    protected boolean isArtifactMetadataFile(File directory, File file) {
+        String path = resolveRelativePath(directory, file);
+        return isArtifactMetadata(path);
+    }
+
+    protected boolean isArtifactMetadata(String relativePath) {
+        return false;
+    }
+
+    protected abstract Artifact resolve(URL resourceURL, InputStream artifactMetadataData, ClassLoader classLoader) throws IOException;
+
+    @Override
+    public final int getPriority() {
+        return priority;
+    }
+
+    @Override
+    public final String toString() {
+        final StringBuilder sb = new StringBuilder(getClass().getSimpleName());
+        sb.append('{');
+        sb.append("classLoader=").append(classLoader);
+        sb.append(", priority=").append(priority);
+        sb.append('}');
+        return sb.toString();
+    }
+}

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

@@ -8,6 +8,8 @@
 import java.util.Objects;
 import java.util.function.Function;
 
+import static java.util.Objects.hash;
+
 /**
  * Artifact entity
  *
@@ -111,7 +113,7 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-        return Objects.hash(artifactId, version, location);
+        return hash(artifactId, version, location);
     }
 
     @Override

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

@@ -2,16 +2,13 @@
 
 import io.microsphere.annotation.Nullable;
 import io.microsphere.logging.Logger;
-import io.microsphere.util.ClassUtils;
 
 import java.net.URL;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
-import java.util.StringJoiner;
-import java.util.stream.Collectors;
 
 import static io.microsphere.collection.CollectionUtils.isEmpty;
 import static io.microsphere.logging.LoggerFactory.getLogger;
@@ -37,19 +34,19 @@ public class ArtifactDetector {
 
     final ClassLoader classLoader;
 
-    private final List<ArtifactResolver> artifactResolvers;
+    private final List<ArtifactResourceResolver> artifactResourceResolvers;
 
     public ArtifactDetector() {
         this(null);
     }
 
     public ArtifactDetector(@Nullable ClassLoader classLoader) {
         ClassLoader actualClassLoader = classLoader == null ? getClassLoader(getClass()) : classLoader;
-        List<ArtifactResolver> artifactResolvers = loadServicesList(ArtifactResolver.class, actualClassLoader, true);
+        this.artifactResourceResolvers = loadServicesList(ArtifactResourceResolver.class, actualClassLoader, true);
         this.classLoader = actualClassLoader;
-        this.artifactResolvers = artifactResolvers;
         if (logger.isTraceEnabled()) {
-            logger.trace("ClassLoader[argument : {} , actual : {}] , ArtifactResolver List : {}", classLoader, actualClassLoader, getArtifactResolverClassNames(artifactResolvers));
+            logger.trace("ClassLoader[argument : {} , actual : {}] , ArtifactResolver List : {}",
+                    classLoader, actualClassLoader, this.artifactResourceResolvers);
         }
     }
 
@@ -68,13 +65,16 @@ protected List<Artifact> detect(Set<URL> classPathURLs) {
         }
 
         List<Artifact> artifactList = new LinkedList<>();
-        for (ArtifactResolver artifactResolver : artifactResolvers) {
-            Set<Artifact> artifactSet = artifactResolver.resolve(classPathURLs);
-            for (Artifact artifact : artifactSet) {
-                artifactList.add(artifact);
-                classPathURLs.remove(artifact.getLocation());
+        for (URL resourceURL : classPathURLs) {
+            for (ArtifactResourceResolver artifactResourceResolver : artifactResourceResolvers) {
+                Artifact artifact = artifactResourceResolver.resolve(resourceURL);
+                if (artifact != null) {
+                    artifactList.add(artifact);
+                    break;
+                }
             }
         }
+
         return unmodifiableList(artifactList);
     }
 
@@ -85,12 +85,8 @@ protected Set<URL> getClassPathURLs(boolean includedJdkLibraries) {
             removeJdkClassPathURLs(classPathURLs);
         }
         if (logger.isTraceEnabled()) {
-            StringJoiner stringJoiner = new StringJoiner(System.lineSeparator());
-            for (URL classPathURL : classPathURLs) {
-                stringJoiner.add(classPathURL.toString());
-            }
             logger.trace("ClassLoader[{}] covers the URLs[expected: {}, actual: {}], class-path : {}",
-                    classLoader, urls.size(), classPathURLs.size(), stringJoiner);
+                    classLoader, urls.size(), classPathURLs.size(), classPathURLs);
         }
         return classPathURLs;
     }
@@ -108,11 +104,4 @@ private void removeJdkClassPathURLs(Set<URL> classPathURLs) {
         }
     }
 
-    private List<String> getArtifactResolverClassNames(List<ArtifactResolver> artifactResolvers) {
-        return artifactResolvers.stream()
-                .map(Object::getClass)
-                .map(ClassUtils::getTypeName)
-                .collect(Collectors.toList());
-    }
-
 }