import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static boolean isCamelComponentArtifact(Dependency dependency) {
    try {
        // is it a JAR file
        File file = dependency.getArtifact().getUnderlyingResourceObject();
        if (file != null && file.getName().toLowerCase().endsWith(".jar")) {
            URL url = new URL("file:" + file.getAbsolutePath());
            URLClassLoader child = new URLClassLoader(new URL[]{url});

            // custom component
            InputStream is = child.getResourceAsStream("META-INF/services/org/apache/camel/component.properties");
            if (is != null) {
                IOHelpers.close(is);
                return true;
            }
        }
    } catch (Throwable e) {
        // ignore
    }

    return false;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static boolean hasDependency(Project project, String groupId, String artifactId, String version) {
    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getEffectiveDependencies();
    for (Dependency d : dependencies) {
        boolean match = d.getCoordinate().getGroupId().equals(groupId);
        if (match && artifactId != null) {
            match = d.getCoordinate().getArtifactId().equals(artifactId);
        }
        if (match && version != null) {
            match = d.getCoordinate().getVersion().equals(version);
        }
        if (match) {
            return match;
        }
    }
    return false;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static boolean hasManagedDependency(Project project, String groupId, String artifactId, String version) {
    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getManagedDependencies();
    for (Dependency d : dependencies) {
        boolean match = d.getCoordinate().getGroupId().equals(groupId);
        if (match && artifactId != null) {
            match = d.getCoordinate().getArtifactId().equals(artifactId);
        }
        if (match && version != null) {
            match = d.getCoordinate().getVersion().equals(version);
        }
        if (match) {
            return match;
        }
    }
    return false;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static Result ensureCamelArtifactIdAdded(Project project, CamelComponentDetails details, DependencyInstaller dependencyInstaller) {
    String groupId = details.getGroupId();
    String artifactId = details.getArtifactId();
    Dependency core = CamelProjectHelper.findCamelCoreDependency(project);
    if (core == null) {
        return Results.fail("The project does not include camel-core");
    }

    // we want to use same version as camel-core if its a camel component
    // otherwise use the version from the dto
    String version;
    if ("org.apache.camel".equals(groupId)) {
        version = core.getCoordinate().getVersion();
    } else {
        version = details.getVersion();
    }
    DependencyBuilder component = DependencyBuilder.create().setGroupId(groupId)
            .setArtifactId(artifactId).setVersion(version);

    // install the component
    dependencyInstaller.install(project, component);
    return null;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static Properties loadComponentProperties(Dependency dependency) {
    Properties answer = new Properties();

    try {
        // is it a JAR file
        File file = dependency.getArtifact().getUnderlyingResourceObject();
        if (file != null && file.getName().toLowerCase().endsWith(".jar")) {
            URL url = new URL("file:" + file.getAbsolutePath());
            URLClassLoader child = new URLClassLoader(new URL[]{url});

            InputStream is = child.getResourceAsStream("META-INF/services/org/apache/camel/component.properties");
            if (is != null) {
                answer.load(is);
            }
        }
    } catch (Throwable e) {
        // ignore
    }

    return answer;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static String extractComponentJavaType(Dependency dependency, String scheme) {
    try {
        // is it a JAR file
        File file = dependency.getArtifact().getUnderlyingResourceObject();
        if (file != null && file.getName().toLowerCase().endsWith(".jar")) {
            URL url = new URL("file:" + file.getAbsolutePath());
            URLClassLoader child = new URLClassLoader(new URL[]{url});

            InputStream is = child.getResourceAsStream("META-INF/services/org/apache/camel/component/" + scheme);
            if (is != null) {
                Properties props = new Properties();
                props.load(is);
                return (String) props.get("class");
            }
        }
    } catch (Throwable e) {
        // ignore
    }

    return null;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public Iterable<DataFormatDto> getValueChoices() {
    if (core == null) {
        return null;
    }

    List<String> names = camelCatalog.findDataFormatNames();

    // filter out existing dataformats we already have
    Set<Dependency> artifacts = findCamelArtifacts(project);
    for (Dependency dep : artifacts) {
        Set<String> languages = dataFormatsFromArtifact(camelCatalog, dep.getCoordinate().getArtifactId());
        names.removeAll(languages);
    }

    List<DataFormatDto> answer = new ArrayList<>();
    for (String name : names) {
        DataFormatDto dto = createDataFormatDto(camelCatalog, name);
        answer.add(dto);
    }

    return answer;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public Iterable<String> getValueNames(String label) {
    // need to find camel-core so we known the camel version
    Dependency core = CamelProjectHelper.findCamelCoreDependency(project);
    if (core == null) {
        return null;
    }

    List<String> names = getComponentNames();

    if (label != null && !"<all>".equals(label)) {
        names = filterByLabel(names, label);
    }

    if (consumerOnly) {
        names = filterByConsumerOnly(names);
    }
    if (producerOnly) {
        names = filterByProducerOnly(names);
    }
    if (mustHaveOptions) {
        names = filterByMustHaveOptions(names);
    }

    return names;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public Iterable<LanguageDto> getValueChoices() {
    if (core == null) {
        return null;
    }

    List<String> names = camelCatalog.findLanguageNames();

    // filter out existing languages we already have
    Set<Dependency> artifacts = findCamelArtifacts(project);
    for (Dependency dep : artifacts) {
        Set<String> languages = languagesFromArtifact(camelCatalog, dep.getCoordinate().getArtifactId());
        names.removeAll(languages);
    }

    List<LanguageDto> answer = new ArrayList<>();
    for (String name : names) {
        LanguageDto dto = createLanguageDto(camelCatalog, name);
        answer.add(dto);
    }

    return answer;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public Set<String> getLanguageNamesFromClasspath() {
    if (core == null) {
        return null;
    }

    Set<String> names = new TreeSet<>();

    // only include existing languages we already have on classpath
    Set<Dependency> artifacts = findCamelArtifacts(project);
    for (Dependency dep : artifacts) {
        Set<String> languages = languagesFromArtifact(camelCatalog, dep.getCoordinate().getArtifactId());
        names.addAll(languages);
    }

    return names;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public void checkDependency(DependencyFacet dependencies, String groupId, String artifactId, String version, String
    scope) {
    Optional<Dependency> dep = dependencies.getDependencies().stream().filter((dependency) ->
        dependency.getCoordinate().getArtifactId().equals(artifactId))
        .findFirst();
    assertThat(dep.isPresent()).isTrue();
    assertThat(dep.get().getCoordinate().getGroupId()).isEqualTo(groupId);
    if (version == null) {
        assertThat(dep.get().getCoordinate().getVersion()).isNull();
    } else {
        assertThat(dep.get().getCoordinate().getVersion()).isEqualTo(version);
    }
    if (scope != null) {
        assertThat(dep.get().getScopeType()).isEqualTo(scope);
    }
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static DependencyBuilder addDependency(Project project, Dependency dependency) {
   final DependencyFacet dependencyFacet = project.getFacet(DependencyFacet.class);
   final DependencyBuilder builder = dependency instanceof DependencyBuilder
         ? (DependencyBuilder) dependency : DependencyBuilder.create(dependency);

   dependencyFacet.addDirectDependency(builder);

   return builder;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
@Override
public Result execute(UIExecutionContext context) throws Exception {
    UIContext uiContext = context.getUIContext();
    Project project = (Project) uiContext.getAttributeMap().get(Project.class);
    Archetype chosenArchetype = archetype.getValue();
    String coordinate = chosenArchetype.getGroupId() + ":" + chosenArchetype.getArtifactId() + ":"
            + chosenArchetype.getVersion();
    DependencyQueryBuilder depQuery = DependencyQueryBuilder.create(coordinate);
    String repository = chosenArchetype.getRepository();
    if (!Strings.isNullOrEmpty(repository)) {
        if (repository.endsWith(".xml")) {
            int lastRepositoryPath = repository.lastIndexOf('/');
            if (lastRepositoryPath > -1)
                repository = repository.substring(0, lastRepositoryPath);
        }
        if (!repository.isEmpty()) {
            depQuery.setRepositories(new DependencyRepository("archetype", repository));
        }
    }
    Dependency resolvedArtifact = dependencyResolver.resolveArtifact(depQuery);
    FileResource<?> artifact = resolvedArtifact.getArtifact();
    MetadataFacet metadataFacet = project.getFacet(MetadataFacet.class);
    File fileRoot = project.getRoot().reify(DirectoryResource.class).getUnderlyingResourceObject();
    ArchetypeHelper archetypeHelper = new ArchetypeHelper(artifact.getResourceInputStream(), fileRoot,
            metadataFacet.getProjectGroupName(), metadataFacet.getProjectName(), metadataFacet.getProjectVersion());
    JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
    archetypeHelper.setPackageName(facet.getBasePackage());
    archetypeHelper.execute();
    return Results.success();
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static Dependency findCamelArtifactDependency(Project project, String artifactId) {
    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getEffectiveDependencies();
    for (Dependency d : dependencies) {
        if ("org.apache.camel".equals(d.getCoordinate().getGroupId()) && artifactId.equals(d.getCoordinate().getArtifactId())) {
            return d;
        }
    }
    return null;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static Set<Dependency> findCamelArtifacts(Project project) {
    Set<Dependency> answer = new LinkedHashSet<Dependency>();

    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getEffectiveDependencies();
    for (Dependency d : dependencies) {
        if ("org.apache.camel".equals(d.getCoordinate().getGroupId())) {
            answer.add(d);
        }
    }
    return answer;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
public static Set<Dependency> findCustomCamelArtifacts(Project project) {
    Set<Dependency> answer = new LinkedHashSet<Dependency>();

    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getEffectiveDependencies();
    for (Dependency d : dependencies) {
        if (isCamelComponentArtifact(d)) {
            answer.add(d);
        }
    }
    return answer;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
/**
 * Returns true if the dependency was added or false if its already there
 */
public static boolean ensureMavenDependencyAdded(Project project, DependencyInstaller dependencyInstaller, String groupId, String artifactId, String scope) {
    List<Dependency> dependencies = project.getFacet(DependencyFacet.class).getEffectiveDependencies();
    for (Dependency d : dependencies) {
        if (groupId.equals(d.getCoordinate().getGroupId()) && artifactId.equals(d.getCoordinate().getArtifactId())) {
            getLOG().debug("Project already includes:  " + groupId + ":" + artifactId + " for version: " + d.getCoordinate().getVersion());
            return false;
        }
    }

    DependencyBuilder component = DependencyBuilder.create().
            setGroupId(groupId).
            setArtifactId(artifactId);

    if (scope != null) {
        component.setScopeType(scope);
    }

    String version = MavenHelpers.getVersion(groupId, artifactId);
    if (Strings.isNotBlank(version)) {
        component = component.setVersion(version);
        getLOG().debug("Adding pom.xml dependency:  " + groupId + ":" + artifactId + " version: " + version + " scope: " + scope);
    } else {
        getLOG().debug("No version could be found for:  " + groupId + ":" + artifactId);
    }
    dependencyInstaller.install(project, component);
    return true;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
/**
 * Returns true if the pom has the given dependency
 */
public static boolean hasDependency(Model pom, String groupId, String artifactId) {
    if (pom != null) {
        List<org.apache.maven.model.Dependency> dependencies = pom.getDependencies();
        return hasDependency(dependencies, groupId, artifactId);
    }
    return false;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
@Override
public ArchetypeCatalog getArchetypeCatalog() {
    if (cachedArchetypes == null) {
        String version = VersionHelper.fabric8ArchetypesVersion();

        Coordinate coordinate = CoordinateBuilder.create()
                .setGroupId("io.fabric8.archetypes")
                .setArtifactId("archetypes-catalog")
                .setVersion(version)
                .setPackaging("jar");

        // load the archetype-catalog.xml from inside the JAR
        Dependency dependency = resolver.get().resolveArtifact(DependencyQueryBuilder.create(coordinate));
        if (dependency != null) {
            try {
                String name = dependency.getArtifact().getFullyQualifiedName();
                URL url = new URL("file", null, name);
                URLClassLoader loader = new URLClassLoader(new URL[]{url});
                InputStream is = loader.getResourceAsStream("archetype-catalog.xml");
                if (is != null) {
                    cachedArchetypes = new ArchetypeCatalogXpp3Reader().read(is);
                }
            } catch (Exception e) {
                LOG.log(Level.WARNING, "Error while retrieving archetypes due " + e.getMessage(), e);
            }
        }
    }
    return cachedArchetypes;
}
 

import org.jboss.forge.addon.dependencies.Dependency; //导入依赖的package包/类
protected Set<String> discoverCustomCamelComponentsOnClasspathAndAddToCatalog(CamelCatalog camelCatalog, Project project) {
    Set<String> answer = new LinkedHashSet<>();

    // find the dependency again because forge don't associate artifact on the returned dependency when installed
    MavenDependencyFacet facet = project.getFacet(MavenDependencyFacet.class);
    List<Dependency> list = facet.getEffectiveDependencies();

    for (Dependency dep : list) {
        Properties properties = loadComponentProperties(dep);
        if (properties != null) {
            String components = (String) properties.get("components");
            if (components != null) {
                String[] part = components.split("\\s");
                for (String scheme : part) {
                    if (!camelCatalog.findComponentNames().contains(scheme)) {
                        // find the class name
                        String javaType = extractComponentJavaType(dep, scheme);
                        if (javaType != null) {
                            String json = loadComponentJSonSchema(dep, scheme);
                            if (json != null) {
                                camelCatalog.addComponent(scheme, javaType, json);
                                answer.add(scheme);
                            }
                        }
                    }
                }
            }
        }
    }

    return answer;
}