Is there are way to install maven dependencies before maven attempts to resolve them?

I have to unpack some dependencies from a remote location and install them locally.

I successfully get them (using the antrun plugin) and install them (using the install plugin)

However, if I define them as dependencies (<dependency>..</dependency>) maven first tries to resolve them, and only then, if succeeds, proceeds to the antrun and install.

I also tried the build-helper-plugin and its attach-artifact, but it d开发者_如何学编程oesn't do anything (it doesn't even add the artifacts to the final war file)

So, how to run my executions before maven attempts to resolve dependencies?

Interesting question! One attempt to (maybe) achiv this is to use a Multi Module Project setup.

Fetch and install your dependencies in the parent project and use them in the child module. I tested my assumption like this:

Parent pom.xml

<project
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>foo.bar</groupId>
    <artifactId>foo.bar.parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>foo.bar.child</module>
    </modules>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-antrun-plugin</artifactId>
                <version>1.6</version>
                <executions>
                    <execution>
                        <phase>validate</phase>
                        <configuration>
                            <target>
                                <echo
                                    message="Hello world!" />
                            </target>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

Module pom.xml

<project
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>foo.bar</groupId>
    <artifactId>foo.bar.child</artifactId>
    <version>1.0.0</version>

    <parent>
        <groupId>foo.bar</groupId>
        <artifactId>foo.bar.parent</artifactId>
        <version>1.0.0</version>
    </parent>

    <dependencies>
        <dependency>
            <artifactId>can.not</artifactId>
            <groupId>find.me</groupId>
            <version>0.0.0</version>
        </dependency>
    </dependencies>

</project>

I get the "Hello World" output from the parent pom build before the child module build fails (because of missing dependency). If you achiev to provide the dependency in the parent.pom's build the child module project should be buildable.

you should look at running Artifact Repository Manager such as Archiva, then you can just load them in there, and in your ~/.m2/settings.xml file add you Archiva server and don't have to worry about doing local installs manually, that is assuming the artifacts aren't already in a remote repository. If your "remote location" is a Maven repository, Archiva can proxy that transparently as well.

I ended up doing it in two phases:

• setup the antrun and install executions to run on clean
• when package is chosen, the build would fail if it hasn't been cleaned at least once

The solution introduces a bit of complexity though.

You can try the system scope in dependency and add systemPath:

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/myhackedjunit-4.0.jar</systemPath>
</dependency>

The system scope is similar to provided except that you have to provide the JAR which contains it explicitly. The artifact is always available and is not looked up in a repository.

The systemPath is used only if the the dependency scope is system. The path must be absolute. Since it is assumed that system scope dependencies are installed a prior, Maven will not check the repositories for the project, but instead checks to ensure that the file exists.