Question

I’m trying to set up a project using Maven and am a bit stuck with how to include some third party dependencies that need to be included unpacked in the resultant war file.

My project contains some custom ColdFusion code and includes Java dependencies, including ColdFusion packaged as a war file. I then am attempting to include some 3rd party ColdFusion code, which I’ve installed in my maven repository packaged as a jar, but I actually want to deploy it unpacked in the resultant war file. It’s this unpacking of the 3rd party libraries that I’m stuck with. I’d really like this to be done BEFORE the war is build, so that I can use war:exploded during the development.

Currently my pom.xml looks something like this:

    <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/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.mycompany.app</groupId>
      <artifactId>my-webapp</artifactId>
      <packaging>war</packaging>
      <version>1.0-SNAPSHOT</version>
      <name>my-webapp Maven Webapp</name>
      <url>http://maven.apache.org</url>
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>

        <!-- This is the war overlay -->
        <dependency>
            <groupId>com.adobe.coldfusion</groupId>
            <artifactId>coldfusion</artifactId>
            <version>9.0.1</version>
            <type>war</type>
            <scope>runtime</scope>
            <optional>false</optional>
        </dependency>  

        <!-- This is the 3rd party ColdFusion dependency -->    
        <dependency>
            <groupId>org.corfield</groupId>
            <artifactId>fw1</artifactId>
            <version>1.2RC2A</version>
            <scope>provided</scope>
        </dependency>

     </dependencies>
     <build>
        <finalName>my-webapp</finalName>
     </build>
  </project>

I’ve kind of got it doing what I want by modifying the build section as follows:

<build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>unpack</id>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <artifactItem>
                                <groupId>org.corfield</groupId>
                                <artifactId>fw1</artifactId>
                                <version>1.2RC2A</version>
                                <type>jar</type>
                                <overWrite>true</overWrite>
                                <outputDirectory>${project.build.directory}/${project.artifactId}</outputDirectory>
                                <includes>**/*.cfc</includes>
                            </artifactItem>
                           </artifactItems>
                        <includes>**/*.cfc</includes>
                        <outputDirectory>${project.build.directory}/${project.artifactId}</outputDirectory>
                        <overWriteReleases>false</overWriteReleases>

                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

The problem with this is that the package:unpack happens after the war is built, so the unpacked dependecies are not in the resulting war file.

I have also tried a few things with the assembly plugin and I came fairly close also by using something like this:

<assembly>
    <id>${project.artifactId}</id>
    <formats>
        <format>war</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
        <dependencySet>
            <includes>
                <include>org.corfield:fw1</include>
            </includes>
            <unpack>true</unpack>
            <outputDirectory>/</outputDirectory>
        </dependencySet>
        <dependencySet>
            <excludes>
                <exclude>org.corfield:fw1</exclude>
            </excludes>
            <unpack>false</unpack>
            <outputDirectory>/WEB-INF/lib</outputDirectory>
        </dependencySet>
    </dependencySets>
    <fileSets>
        <fileSet>
            <directory>src/main/webapp</directory>
            <outputDirectory>/</outputDirectory>
        </fileSet>
    </fileSets>
</assembly>

However that created a second war file named something like my-webapp-1.0-SNAPSHOT-my-webapp.war as well as the my-webapp-1.0-SNAPSHOT.war. The my-webapp-1.0-SNAPSHOT-my-webapp.war also included my-webapp-1.0-SNAPSHOT.war

At the end of the day I want my resultant war to look like:

org
 |-- corfield
    |-- framework.cfc
WEB-INF
 |-- lib
 |-- web.xml
index.cfm

(in reality there’s a lot more to it than that, but that’s enough to illustrate the point hopefully)

I think I’m pretty close but I’m just missing something I need. I’d be extremely grateful for any assistance.

Answer 1

For the maven-dependency-plugin approach, bind the unpack goal on the prepare-package phase (Maven 2.1+) instead of package.

References

• Lifecycle Reference