Java Ant类代码示例

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
private static void addOtherClassPath(@NotNull final List<String> classpath) {
  classpath.add(PathUtil.getJarPathForClass(Ant.class));
  classpath.add(PathUtil.getJarPathForClass(GroovyObject.class));
  classpath.add(PathUtil.getJarPathForClass(Gson.class));
  classpath.add(PathUtil.getJarPathForClass(Logger.class));
  classpath.add(PathUtil.getJarPathForClass(Log4jLoggerFactory.class));
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
@Override
@NotNull
public List<String> getClassPath() {
    List<String> classpath = new ArrayList<>();
    classpath.add(PathUtil.getJarPathForClass(Ant.class));
    classpath.add(PathUtil.getJarPathForClass(GroovyObject.class));
    classpath.add(PathUtil.getJarPathForClass(Gson.class));
    classpath.add(PathUtil.getJarPathForClass(Logger.class));
    classpath.add(PathUtil.getJarPathForClass(Log4jLoggerFactory.class));
    return classpath;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
public boolean execute(Project project, long contentLength, InputStream content) throws Throwable {
	Ant ant = (Ant) project.createTask("ant");
	File baseDir = project.getBaseDir();
	if (dir != null)
		baseDir = new File(dir);
	ant.setDir(baseDir);
	ant.setInheritAll(inheritall);
	ant.setInheritRefs(interitrefs);

	if (target != null)
		ant.setTarget(target);

	if (antFile != null)
		ant.setAntfile(antFile);

	Enumeration e = properties.elements();
	PropertyContainer pc = null;
	Property p = null;
	while (e.hasMoreElements()) {
		pc = (PropertyContainer) e.nextElement();
		p = ant.createProperty();
		p.setName(pc.getName());
		p.setValue(pc.getValue());
	}

	e = references.elements();
	ReferenceContainer rc = null;
	Ant.Reference ref = null;
	while (e.hasMoreElements()) {
		rc = (ReferenceContainer) e.nextElement();
		ref = new Ant.Reference();
		ref.setRefId(rc.getRefId());
		ref.setToRefid(rc.getToRefId());
		ant.addReference(ref);
	}

	ant.execute();

	return false;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
public boolean execute(Project project, long contentLength, InputStream content) throws Throwable {
	CallTarget callTarget = (CallTarget) project.createTask("antcall");
	callTarget.setInheritAll(inheritall);
	callTarget.setInheritRefs(interitrefs);

	String toExecute = target;
	if (toExecute == null)
		toExecute = project.getDefaultTarget();
	callTarget.setTarget(toExecute);

	Enumeration e = properties.elements();
	PropertyContainer pc = null;
	Property p = null;
	while (e.hasMoreElements()) {
		pc = (PropertyContainer) e.nextElement();
		p = callTarget.createParam();
		p.setName(pc.getName());
		p.setValue(pc.getValue());
	}

	e = references.elements();
	ReferenceContainer rc = null;
	Ant.Reference ref = null;
	while (e.hasMoreElements()) {
		rc = (ReferenceContainer) e.nextElement();
		ref = new Ant.Reference();
		ref.setRefId(rc.getRefId());
		ref.setToRefid(rc.getToRefId());
		callTarget.addReference(ref);
	}

	callTarget.execute();

	return false;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
/**
 * Returns the resolved file
 * @param extension the extension
 * @param project the project
 * @return the file resolved
 * @throws BuildException if the file cannot be resolved
 */
@Override
public File resolve(final Extension extension,
                     final Project project) throws BuildException {
    validate();

    final Ant ant = new Ant();
    ant.setProject(project);
    ant.setInheritAll(false);
    ant.setAntfile(antfile.getName());

    try {
        final File dir =
            antfile.getParentFile().getCanonicalFile();
        ant.setDir(dir);
    } catch (final IOException ioe) {
        throw new BuildException(ioe.getMessage(), ioe);
    }

    if (null != target) {
        ant.setTarget(target);
    }

    ant.execute();

    return destfile;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
/**
 * Add the references explicitly defined as nested elements to the new project. Also copy over all references that
 * don't override existing references in the new project if inheritrefs has been requested.
 *
 * @param subproject a subproject
 * @throws BuildException if a reference does not have a refid.
 */
private void addReferences(Project subproject) throws BuildException {
    @SuppressWarnings("unchecked")
    Map<String, Object> thisReferences = (Map<String, Object>) getProject().getReferences().clone();
    Map<String, Object> newReferences = subproject.getReferences();
    for (Ant.Reference ref : references) {
        String refid = ref.getRefId();
        if (refid == null) {
            throw new BuildException("the refid attribute is required" + " for reference elements");
        }
        if (!thisReferences.containsKey(refid)) {
            log("Parent project doesn't contain any reference '" + refid + "'", Project.MSG_WARN);
            continue;
        }

        thisReferences.remove(refid);
        String toRefid = ref.getToRefid();
        if (toRefid == null) {
            toRefid = refid;
        }
        copyReference(subproject, refid, toRefid);
    }

    // Now add all references that are not defined in the
    // subproject, if inheritRefs is true
    if (inheritRefs) {
        for (String key : thisReferences.keySet()) {
            if (newReferences.containsKey(key)) {
                continue;
            }
            copyReference(subproject, key, key);
            subproject.inheritIDReferences(getProject());
        }
    }
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
public void execute() {
    validate("file", file).required();

    String path = file.getAbsolutePath();
    String hash = Require.class.getName() + ":" +
        path + ":" + target + ":" + key;

    synchronized (System.class) {
        if (System.getProperty(hash) != null) {
            return;
        }

        Ant ant = (Ant) getProject().createTask("ant");
        ant.setInheritAll(false);
        ant.setOwningTarget(getOwningTarget());
        ant.setTaskName(getTaskName());
        ant.init();
        if (target.length() > 0) {
            ant.setTarget(target);
        }
        ant.setAntfile(path);
        ant.setDir(file.getParentFile());
        ant.execute();

        System.setProperty(hash, "done");
    }
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
private void callTarget(final Module module, final String target)
{
    try {
        final Project project = getProject();
        final Ant antcall = (Ant) project.createTask("ant");
        antcall.init();
        antcall.setAntfile(project.getProperty(MagicNames.ANT_FILE));
        
        for (int i = 0, n = params.size(); i < n; ++i) {
            final ParamElement param = params.get(i);
            param.populate(antcall.createProperty());
        }
        
        if (moduleRefId != null) {
            final Method m = Ant.class.getDeclaredMethod("getNewProject");
            m.setAccessible(true);
            
            final Project newProject = (Project) m.invoke(antcall);
            newProject.addReference(moduleRefId, module);
        }
        for (int i = 0, n = references.size(); i < n; ++i) {
            antcall.addReference(references.get(i));
        }
        antcall.addPropertyset(propertySet);
        antcall.setInheritAll(inheritAll);
        antcall.setInheritRefs(inheritRefs);
        antcall.setTarget(target);
        
        antcall.perform();
    }
    catch (Exception ex) {
        throw buildExceptionForModule(ex, module);
    }
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
public void execute () throws BuildException {
    
    if (topdirs == null && topdir != null) {
        topdirs = new File[1];
        topdirs[0] = topdir; 
    }
    
    if (topdir == null && topdirs == null) {
        throw new BuildException("You must set at least one topdir attribute", getLocation());
    }
    
    if (resolvedependencies) resolveDependencies();
        
    for (int j = 0; j < topdirs.length; j++) {
        topdir = topdirs[j];            
        for (String module : modules) {
            Ant ant = (Ant) getProject().createTask("ant");
            ant.init ();                
            ant.setLocation(getLocation());
            File fl = new File(topdir.getAbsolutePath () + 
                File.separatorChar + module + File.separatorChar + "build.xml");                
            if (! fl.exists()) {                    
                continue;
            }
            ant.setDir(new File(topdir, module));
            ant.setTarget (targetname);
            try {
                log("Process '"+ module + "' location with '" + targetname + "' target", Project.MSG_INFO);
                ant.execute ();
            } catch (BuildException be) {
                if (failonerror) {
                    throw new BuildException(be.getMessage(), be, getLocation());
                } else {
                    log("Target \"" + targetname + "\" failed in module \"" + module + "\"", Project.MSG_WARN);
                    log(fl.getAbsolutePath());
                    log(be.getMessage());
                    String fname = fl.getAbsolutePath();
                    failedmodules.add(fname);
                }
            }
        }
    }
    if (failedmodules.size() > 0) {
        log("<cleanall> SOME MODULES FAILED TO BUILD, BUT THEIR BuildException WAS CAUGHT", Project.MSG_WARN);
        log("<cleanall> cleanfailedmodules=\"" + failedmodules.toString() + "\"", Project.MSG_WARN);
    }
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
private File computeClasspathModuleLocation(ModuleListParser modules, String cnb,
        Set<File> clusterPath, Set<String> excludedModules, boolean runtime) throws BuildException {
    ModuleListParser.Entry module = modules.findByCodeNameBase(cnb);
    if (module == null && cnb.contains("-")) {
        final String alternativeCnb = cnb.replace('-', '_');
        module = modules.findByCodeNameBase(alternativeCnb);
        if (module != null) {
            cnb = alternativeCnb;
        }
    }
    if (module == null) {
        throw new BuildException("No dependent module " + cnb, getLocation());
    }
    File jar = module.getJar();
    if (jar == null) return null;

    OK: if (module.getClusterName() != null && clusterPath != null) {
        File clusterF = jar.getParentFile();
        while (clusterF != null) {
            if (clusterPath.contains(clusterF)) {
                break OK;
            }
            clusterF = clusterF.getParentFile();
        }
        String msg = "The module " + cnb + " cannot be " + (runtime ? "run" : "compiled") +
                " against because it is part of the cluster " +
                jar.getParentFile().getParentFile() + " which is not part of cluster.path in your suite configuration.\n\n" +
                "Cluster.path is: " + clusterPath;
        throw new BuildException(msg, getLocation());
    }
    if (excludedModules != null && excludedModules.contains(cnb)) { // again #68716
        throw new BuildException("Module " + cnb + " excluded from the target platform", getLocation());
    }
    if (!jar.isFile()) {
        File srcdir = module.getSourceLocation();
        if (Project.toBoolean(getProject().getProperty(DO_NOT_RECURSE))) {
            log(jar + " missing for " + moduleProject + " but will not first try to build " + srcdir, Project.MSG_VERBOSE);
            return jar;
        }
        if (srcdir != null && srcdir.isDirectory()) {
            log(jar + " missing for " + moduleProject + "; will first try to build " + srcdir, Project.MSG_WARN);
            Ant ant = new Ant();
            ant.setProject(getProject());
            ant.setOwningTarget(getOwningTarget());
            ant.setLocation(getLocation());
            ant.setInheritAll(false);
            ant.setDir(srcdir);
            ant.execute();
        }
    }
    if (!jar.isFile()) {
        throw new BuildException("No such classpath entry: " + jar, getLocation());
    }
    return jar;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
private CallTarget createCallTarget() {
	CallTarget ct = (CallTarget) getProject().createTask("antcall");
	ct.setOwningTarget(getOwningTarget());
	ct.init();
	ct.setTarget(target);
	ct.setInheritAll(inheritAll);
	ct.setInheritRefs(inheritRefs);
	Enumeration e = params.elements();
	while (e.hasMoreElements()) {
		Property param = (Property) e.nextElement();
		Property toSet = ct.createParam();
		toSet.setName(param.getName());
		if (param.getValue() != null) {
			toSet.setValue(param.getValue());
		}
		if (param.getFile() != null) {
			toSet.setFile(param.getFile());
		}
		if (param.getResource() != null) {
			toSet.setResource(param.getResource());
		}
		if (param.getPrefix() != null) {
			toSet.setPrefix(param.getPrefix());
		}
		if (param.getRefid() != null) {
			toSet.setRefid(param.getRefid());
		}
		if (param.getEnvironment() != null) {
			toSet.setEnvironment(param.getEnvironment());
		}
		if (param.getClasspath() != null) {
			toSet.setClasspath(param.getClasspath());
		}
	}

	e = references.elements();
	while (e.hasMoreElements()) {
		ct.addReference((Ant.Reference) e.nextElement());
	}

	return ct;
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
public void progress(IvyEvent event) {
    File f = getBuildFile(event);
    if (f.exists()) {
        if (onlyOnce && isBuilt(f)) {
            Message.verbose("target build file already built, skipping: " + f);
        } else {
            Ant ant = new Ant();
            Project project = (Project) IvyContext
                    .peekInContextStack(IvyTask.ANT_PROJECT_CONTEXT_KEY);
            if (project == null) {
                project = new Project();
                project.init();
            }

            ant.setProject(project);
            ant.setTaskName("ant");

            ant.setAntfile(f.getAbsolutePath());
            ant.setInheritAll(false);
            String target = getTarget();
            if (target != null) {
                ant.setTarget(target);
            }
            for (Map.Entry<String, String> entry : event.getAttributes().entrySet()) {
                if (entry.getValue() != null) {
                    Property p = ant.createProperty();
                    p.setName(prefix == null ? entry.getKey() : prefix + entry.getKey());
                    p.setValue(entry.getValue());
                }
            }

            Message.verbose("triggering build: " + f + " target=" + target + " for " + event);
            try {
                ant.execute();
            } catch (BuildException e) {
                Message.verbose("Exception occurred while executing target " + target);
                throw e;
            }
            markBuilt(f);

            Message.debug("triggered build finished: " + f + " target=" + target + " for "
                    + event);
        }
    } else {
        Message.verbose("no build file found for dependency, skipping: " + f);
    }
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
/**
 * Corresponds to <code>&lt;antcall&gt;</code>'s nested
 * <code>&lt;reference&gt;</code> element.
 */
public void addReference(Ant.Reference r) {
	references.addElement(r);
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
/**
 * Corresponds to <code>&lt;ant&gt;</code>'s nested <code>&lt;reference&gt;</code> element.
 *
 * @param r the reference to pass on explicitly to the sub-build.
 */
public void addReference(Ant.Reference r) {
    references.add(r);
}
 

import org.apache.tools.ant.taskdefs.Ant; //导入依赖的package包/类
/**
 * <p>Adds a new {@link org.apache.tools.ant.taskdefs.Ant.Reference org.apache.tools.ant.taskdefs.Ant.Reference}
 * container that backs the nested element {@code <reference>} of this
 * {@code <callTargetForModules>} task. Multiple nested {@code <reference>} elements are
 * allowed.</p>
 * 
 * <p>This element defines a reference to be inherited by the Ant {@link Project projects}
 * created to process {@link Module modules}. If there is a reference with the ID requested
 * defined in the module-specific Ant project then it is overridden by this reference.
 * However, a reference with the ID requested defined within a target is not overridden.</p>
 * 
 * <p>Use the task attribute {@link #setInheritRefs(boolean) inheritRefs} set to {@code true}
 * to pass all references defined within the Ant project of this {@code <callTargetForModules>}
 * to the module-specific projects. Note that no references are overridden in this case except
 * those that are specified by the {@code <reference>} elements and
 * the {@link #setModuleRefId(String) moduleRefId} attribute.</p>
 * 
 * @param reference the {@code <reference>} element to be added. It must be not {@code null}.
 */
public void addReference(final Ant.Reference reference)
{
    references.add(reference);
}