import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Install jackson 2 dependencies on project pom
 */
private void installDependencies() {
    // Get add-on configuration file
    Element configuration = XmlUtils.getConfiguration(getClass());
    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        getProjectOperations().addProperty(
                getProjectOperations().getFocusedModuleName(),
                new Property(property));
    }

    // Install dependencies
    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(
            getMetadataService(), getProjectOperations(), depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
private void installMavenPlugins(String moduleName) {
   	final Element configuration = XmlUtils.getConfiguration(getClass());

   	// Add properties
	  List<Element> properties = XmlUtils.findElements(
			"/configuration/properties/*", configuration);
	  for (Element property : properties) {
		  projectOperations.addProperty(moduleName, new Property(property));
	  }
   	
	  // Add Plugins
	  List<Element> elements = XmlUtils.findElements(
			"/configuration/plugins/plugin",
			configuration);
	  for (Element element : elements) {
		  Plugin plugin = new Plugin(element);
		  projectOperations.addBuildPlugin(
				moduleName, plugin);
	  }

}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
private void installMavenPlugins(String moduleName) {
   	final Element configuration = XmlUtils.getConfiguration(getClass());

   	// Add properties
	List<Element> properties = XmlUtils.findElements(
			"/configuration/properties/*", configuration);
	for (Element property : properties) {
		getProjectOperations().addProperty(moduleName, new Property(property));
	}
   	
	// Add Plugins
	List<Element> elements = XmlUtils.findElements(
			"/configuration/plugins/plugin",
			configuration);
	for (Element element : elements) {
		Plugin plugin = new Plugin(element);
		getProjectOperations().addBuildPlugin(
				moduleName, plugin);
	}

}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void addAddonDependency() {

    // Get configuration (repository and dependency) XML element
    Element conf = XmlUtils.getConfiguration(this.getClass());

    // Find repository elements and add them to the project
    for (Element repo : XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", conf)) {
        projectOperations.addRepository(projectOperations
                .getFocusedModuleName(), new Repository(repo));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", conf);
    for (Element property : properties) {
        projectOperations.addProperty(projectOperations
                .getFocusedModuleName(), new Property(property));
    }

    // Find dependency elements and update them into the project
    DependenciesVersionManager.manageDependencyVersion(metadataService,
            projectOperations, XmlUtils.findElements(
                    "/configuration/gvnix/dependencies/dependency", conf));
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Install properties defined in external XML file
 * 
 * @param configuration
 */
private void updatePomProperties(Element configuration) {
    List<Element> addonProperties = XmlUtils.findElements(
            "/configuration/gvnix/menu/properties/*", configuration);
    for (Element property : addonProperties) {
        getProjectOperations().addProperty(
                getProjectOperations().getFocusedModuleName(),
                new Property(property));
    }
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Update project pom: install repositories and dependencies
 */
private void setupProjectPom() {
    // Get add-on configuration file
    Element configuration = XmlUtils.getConfiguration(getClass());

    // Install the add-on repository needed
    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {
        getProjectOperations().addRepositories(
                getProjectOperations().getFocusedModuleName(),
                Collections.singleton(new Repository(repo)));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        getProjectOperations().addProperty(
                getProjectOperations().getFocusedModuleName(),
                new Property(property));
    }

    // Install dependencies
    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(
            getMetadataService(), getProjectOperations(), depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * 
 * This method updates dependencies and repositories with the added to
 * configuration.xml file
 * 
 * @param configuration
 * @param moduleName
 * @param projectOperations
 */
public static void updatePom(final Element configuration,
        ProjectOperations projectOperations, MetadataService metadataService) {

    // Install the add-on repository needed
    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {
        projectOperations.addRepositories(
                projectOperations.getFocusedModuleName(),
                Collections.singleton(new Repository(repo)));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        projectOperations.addProperty(projectOperations
                .getFocusedModuleName(), new Property(property));
    }

    // Install dependencies
    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(metadataService,
            projectOperations, depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
public Pom getInstance(final Element root, final String pomPath,
          final String moduleName) {
      Validate.notBlank(pomPath, "POM's canonical path is required");
      final String artifactId = XmlUtils.getTextContent(ARTIFACT_ID_XPATH,
              root);
      final String groupId = getGroupId(root);
      final String name = XmlUtils.getTextContent(NAME_XPATH, root);
      final String packaging = XmlUtils.getTextContent(PACKAGING_XPATH, root,
              DEFAULT_PACKAGING);
      String version = XmlUtils.getTextContent(VERSION_XPATH, root);
      final String sourceDirectory = XmlUtils.getTextContent(
              SOURCE_DIRECTORY_XPATH, root);
      final String testSourceDirectory = XmlUtils.getTextContent(
              TEST_SOURCE_DIRECTORY_XPATH, root);
      final List<Dependency> dependencies = parseElements(Dependency.class,
              DEPENDENCY_XPATH, root);
      final List<Filter> filters = parseElements(Filter.class, FILTER_XPATH,
              root);
      final List<Module> modules = getModules(root, pomPath, packaging);
      final List<Plugin> plugins = parseElements(Plugin.class, PLUGIN_XPATH,
              root);
      final List<Property> pomProperties = parseElements(Property.class,
              PROPERTY_XPATH, root);
      final List<Repository> pluginRepositories = parseElements(
              Repository.class, PLUGIN_REPOSITORY_XPATH, root);
      final List<Repository> repositories = parseElements(Repository.class,
              REPOSITORY_XPATH, root);
      final List<Resource> resources = parseElements(Resource.class,
              RESOURCE_XPATH, root);
final String projectParentVersion = XmlUtils.getTextContent("/project/parent/version", root);
      final Parent parent = getParent(pomPath, root);
if(version == null) {
	version = projectParentVersion;
}
      final Collection<Path> paths = getPaths(root, packaging);
      return new Pom(groupId, artifactId, version, packaging, dependencies,
              parent, modules, pomProperties, name, repositories,
              pluginRepositories, sourceDirectory, testSourceDirectory,
              filters, plugins, resources, pomPath, moduleName, paths);
  }
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Locates any properties which match the presented property, excluding the
 * value. This is useful for upgrade use cases, where it is necessary to
 * locate any properties with the name so that they can be removed.
 * 
 * @param property to locate (required; note the value is ignored in
 *            comparisons)
 * @return any matching properties (never returns null, but may return an
 *         empty {@link Set})
 */
public Set<Property> getPropertiesExcludingValue(final Property property) {
    Validate.notNull(property, "Property to locate is required");
    final Set<Property> result = new HashSet<Property>();
    for (final Property p : pomProperties) {
        if (property.getName().equals(p.getName())) {
            result.add(p);
        }
    }
    return result;
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Locates the first occurrence of a property for a given name and returns
 * it.
 * 
 * @param name the property name (required)
 * @return the property if found otherwise null
 */
public Property getProperty(final String name) {
    Validate.notBlank(name, "Property name to locate is required");
    for (final Property p : pomProperties) {
        if (name.equals(p.getName())) {
            return p;
        }
    }
    return null;
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
private void updatePomProperties(final Element configuration,
        final String moduleName) {
    final List<Element> databaseProperties = XmlUtils.findElements(
            "/configuration/spring-security/properties/*", configuration);
    for (final Element property : databaseProperties) {
        getProjectOperations().addProperty(moduleName, new Property(property));
    }
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * This method adds necessary dependencies to project pom.xml
 */
public void updatePomDependencies() {
    // Get add-on configuration file
    Element configuration = XmlUtils.getConfiguration(getClass());

    // Install the add-on repository needed
    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {
        getProjectOperations().addRepositories(
                getProjectOperations().getFocusedModuleName(),
                Collections.singleton(new Repository(repo)));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        getProjectOperations().addProperty(
                getProjectOperations().getFocusedModuleName(),
                new Property(property));
    }

    // Install dependencies
    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(
            getMetadataService(), getProjectOperations(), depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
public void addGvNIXAnnotationsDependecy() {

        // Install the add-on Google code repository and dependency needed to
        // get the annotations

        Element conf = XmlUtils.getConfiguration(this.getClass());

        // Install repositories
        List<Element> repos = XmlUtils.findElements(
                "/configuration/gvnix/repositories/repository", conf);
        for (Element repo : repos) {

            projectOperations.addRepository(projectOperations
                    .getFocusedModuleName(), new Repository(repo));
        }

        // Install properties
        List<Element> properties = XmlUtils.findElements(
                "/configuration/gvnix/properties/*", conf);
        for (Element property : properties) {
            projectOperations.addProperty(projectOperations
                    .getFocusedModuleName(), new Property(property));
        }

        // Install dependencies
        List<Element> depens = XmlUtils.findElements(
                "/configuration/gvnix/dependencies/dependency", conf);
        DependenciesVersionManager.manageDependencyVersion(metadataService,
                projectOperations, depens);
    }
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
public void setup() {
    // Get add-on configuration file
    Element configuration = XmlUtils.getConfiguration(getClass());

    // Install the add-on repository needed
    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {
        getProjectOperations().addRepositories(
                getProjectOperations().getFocusedModuleName(),
                Collections.singleton(new Repository(repo)));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        getProjectOperations().addProperty(
                getProjectOperations().getFocusedModuleName(),
                new Property(property));
    }

    // Install dependencies
    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(
            getMetadataService(), getProjectOperations(), depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
public void setupMavenDependency() {
    Element configuration = XmlUtils.getConfiguration(getClass());

    // Install the add-on Google code repository and dependency needed to
    // get the annotations

    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {
        projectOperations.addRepository(projectOperations
                .getFocusedModuleName(), new Repository(repo));
    }

    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);
    DependenciesVersionManager.manageDependencyVersion(metadataService,
            projectOperations, depens);

    depens = XmlUtils.findElements(
            "/configuration/dependencies/dependency", configuration);
    for (Element depen : depens) {
        projectOperations.addDependency(projectOperations
                .getFocusedModuleName(), new Dependency(depen));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        projectOperations.addProperty(projectOperations
                .getFocusedModuleName(), new Property(property));
    }
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
 * Add addon repository and dependency to get annotations.
 * 
 * @param configuration Configuration element
 */
private void addAnnotations(Element configuration) {

    // Install the add-on Google code repository and dependency needed to
    // get the annotations

    List<Element> repos = XmlUtils.findElements(
            "/configuration/gvnix/repositories/repository", configuration);
    for (Element repo : repos) {

        projectOperations.addRepository(projectOperations
                .getFocusedModuleName(), new Repository(repo));
    }

    // Install properties
    List<Element> properties = XmlUtils.findElements(
            "/configuration/gvnix/properties/*", configuration);
    for (Element property : properties) {
        projectOperations.addProperty(projectOperations
                .getFocusedModuleName(), new Property(property));
    }

    List<Element> depens = XmlUtils.findElements(
            "/configuration/gvnix/dependencies/dependency", configuration);

    DependenciesVersionManager.manageDependencyVersion(metadataService,
            projectOperations, depens);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
private void updateDependencies() {
    InputStream templateInputStream = FileUtils.getInputStream(getClass(),
            "dependencies.xml");
    Validate.notNull(templateInputStream,
            "Could not acquire dependencies.xml file");
    Document dependencyDoc;
    try {
        dependencyDoc = XmlUtils.getDocumentBuilder().parse(
                templateInputStream);
    }
    catch (Exception e) {
        throw new IllegalStateException(e);
    }

    Element dependenciesElement = (Element) dependencyDoc.getFirstChild();

    List<Dependency> dependencies = new ArrayList<Dependency>();
    List<Element> flexDependencies = XmlUtils.findElements(
            "/dependencies/springFlex/dependency", dependenciesElement);
    for (Element dependency : flexDependencies) {
        dependencies.add(new Dependency(dependency));
    }
    this.projectOperations.addDependencies(
            projectOperations.getFocusedModuleName(), dependencies);
    this.projectOperations.addProperty(projectOperations
            .getFocusedModuleName(), new Property("flex.version",
            "4.1.0.16248"));

    fixBrokenFlexDependency();

    this.projectOperations.updateProjectType(
            projectOperations.getFocusedModuleName(), ProjectType.WAR);
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
private void manageDependencies(final String moduleName){
   final Element configuration = XmlUtils.getConfiguration(getClass());

   final List<Dependency> dependencies = new ArrayList<Dependency>();
   final List<Element> springDependencies = XmlUtils.findElements(
           "/configuration/spring-data-elasticsearch/dependencies/dependency",
           configuration);
   for (final Element dependencyElement : springDependencies) {
       dependencies.add(new Dependency(dependencyElement));
   }

   final List<Repository> repositories = new ArrayList<Repository>();
   final List<Element> repositoryElements = XmlUtils.findElements(
           "/configuration/spring-data-elasticsearch/repositories/repository",
           configuration);
   for (final Element repositoryElement : repositoryElements) {
       repositories.add(new Repository(repositoryElement));
   }

   projectOperations.addRepositories(moduleName, repositories);
   projectOperations.addDependencies(moduleName, dependencies);
   
   // spring-data-elasticsearch-1.0.0-M1 and other needs spring-context-3.2.5 or other.
   // However Spring ROO 1.2.2 is just on spring-context-3.1.1. We need to upgrade this if
   // user has not already pick an up-to-date version of Spring ...
   final Pom pom = projectOperations.getPomFromModuleName(moduleName);
   final Document document = XmlUtils.readXml(fileManager.getInputStream(pom.getPath()));
   final Element root = document.getDocumentElement();
   final Element value = XmlUtils.findFirstElement("/project/properties/spring.version", root);
   // Use a lexicographic comparison in case of already set.
   if (value == null || value.getTextContent().compareTo("3.2.5.RELEASE") < 0){
      projectOperations.addProperty(moduleName, new Property("spring.version", "3.2.5.RELEASE"));
   }
}
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
/**
   * Constructor
   * 
   * @param groupId the Maven groupId, explicit or inherited (required)
   * @param artifactId the Maven artifactId (required)
   * @param version the version of the artifact being built (required)
   * @param packaging the Maven packaging (required)
   * @param dependencies (can be <code>null</code> for none)
   * @param parent the POM's parent declaration (can be <code>null</code> for
   *            none)
   * @param modules the modules defined by this POM (only applies when
   *            packaging is "pom"; can be <code>null</code> for none)
   * @param pomProperties any properties defined in the POM (can be
   *            <code>null</code> for none)
   * @param name the Maven name of the artifact being built (can be blank)
   * @param repositories any repositories defined in the POM (can be
   *            <code>null</code> for none)
   * @param pluginRepositories any plugin repositories defined in the POM (can
   *            be <code>null</code> for none)
   * @param sourceDirectory the directory relative to the POM that contains
   *            production code (can be blank for the Maven default)
   * @param testSourceDirectory the directory relative to the POM that
   *            contains test code (can be blank for the Maven default)
   * @param filters any filters defined in the POM (can be <code>null</code>
   *            for none)
   * @param buildPlugins any plugins defined in the POM (can be
   *            <code>null</code> for none)
   * @param resources any build resources defined in the POM (can be
   *            <code>null</code> for none)
   * @param path the canonical path of this POM (required)
   * @param moduleName the Maven name of this module (blank for the project's
   *            root or only POM)
   * @param paths the {@link Path}s required for this module, in addition to
   *            the root (can be <code>null</code>)
   */
  public Pom(final String groupId, final String artifactId,
          final String version, final String packaging,
          final Collection<? extends Dependency> dependencies,
          final Parent parent, final Collection<? extends Module> modules,
          final Collection<? extends Property> pomProperties,
          final String name,
          final Collection<? extends Repository> repositories,
          final Collection<? extends Repository> pluginRepositories,
          final String sourceDirectory, final String testSourceDirectory,
          final Collection<? extends Filter> filters,
          final Collection<? extends Plugin> buildPlugins,
          final Collection<? extends Resource> resources, final String path,
          final String moduleName, final Collection<Path> paths) {
      Validate.notBlank(packaging, "Invalid packaging '%s'", packaging);
      Validate.notBlank(path, "Invalid path '%s'", path);

      //gav = new GAV(groupId, artifactId, version);
      this.moduleName = StringUtils.stripToEmpty(moduleName);
      this.name = StringUtils.stripToEmpty(name);
      this.packaging = packaging;
      this.parent = parent;

if(version == null && parent.getVersion() != null) {
	gav = new GAV(groupId, artifactId, parent.getVersion());
}else {
	gav = new GAV(groupId, artifactId, version);
}

      this.path = path;
      this.sourceDirectory = StringUtils.defaultIfEmpty(sourceDirectory,
              Path.SRC_MAIN_JAVA.getDefaultLocation());
      this.testSourceDirectory = StringUtils.defaultIfEmpty(
              testSourceDirectory, Path.SRC_TEST_JAVA.getDefaultLocation());

      CollectionUtils.populate(this.buildPlugins, buildPlugins);
      CollectionUtils.populate(this.dependencies, dependencies);
      CollectionUtils.populate(this.filters, filters);
      CollectionUtils.populate(this.modules, modules);
      CollectionUtils.populate(this.pluginRepositories, pluginRepositories);
      CollectionUtils.populate(this.pomProperties, pomProperties);
      CollectionUtils.populate(this.repositories, repositories);
      CollectionUtils.populate(this.resources, resources);

      cachePhysicalPaths(paths);
  }
 

import org.springframework.roo.project.Property; //导入依赖的package包/类
public Set<Property> getPomProperties() {
    return pomProperties;
}