DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports Events Over 2 million developers have joined DZone. Join Today! Thanks for visiting DZone today,
Edit Profile Manage Email Subscriptions Moderation Admin Console How to Post to DZone Article Submission Guidelines
View Profile
Sign Out
Refcards
Trend Reports
Events
Zones
Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Partner Zones AWS Cloud
by AWS Developer Relations
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Partner Zones
AWS Cloud
by AWS Developer Relations
11 Monitoring and Observability Tools for 2023
Learn more
  1. DZone
  2. Testing, Deployment, and Maintenance
  3. Deployment
  4. Using Jenkins Local Maven Repository as An Internal Private Maven Repository

Using Jenkins Local Maven Repository as An Internal Private Maven Repository

An alternative option to using commercial repository management software is to use a Jenkins instance of Maven instead.

Upul Kamburawala user avatar by
Upul Kamburawala
·
May. 17, 19 · Tutorial
Like (1)
Save
Tweet
Share
39.25K Views

Join the DZone community and get the full member experience.

Join For Free

Organizational software projects use their own private (organizational-wide) Maven repositories. This approach allows them to store their own or other non-publically available artifacts in these repositories. Additionally, it has the advantage of using this repository as a proxy for the Maven central repository.

It is a recommended practice to use repository management software for this purpose. More details on this topic can be found here.

As an alternative to those repository management products, using an AWS S3 bucket as a Maven repository has become a common practice, at least with organizations that use AWS cloud. This article provides details of setting up such a repository.

There are occasions where developers simply need to store and share their JAR files among the projects of their organization. Developers use local private Maven repositories on their development environments in order to achieve this purpose. But the issue is, how do the projects get access to those artifacts in the project’s test or production build environments?

The good news is, if you are using Jenkins, we can use Jenkin’s Maven repository as local internal Maven repository in our Jenkins build environment.

Jenkins is a very popular and widely use continuous integration tool. Jenkins uses Maven internally as a build tool. You can see the Maven repository location inside the Jenkins administrator interface.

Got to the Jenkins homepage and click on “Manage Jenkins” on the left-hand side menu. Then click “Configure System.” Under the “Maven Project Configuration,” you can see the Maven repository directory location as shown in this image:

Image title


The purpose of this article is to show the necessary steps involved in using an internal Maven repository with requirements as explained above. Steps shown here will use both popular built streams Gradle and Maven.

Suppose your development team needed to develop and maintain a utility software program and use it as a library in other software projects.

Once you are happy with the implementation and testing of this program, then you may need to make it available to your other projects. So you will need to upload it to your local Maven repository.

Here is a Gradle build script which has necessary steps to package artifacts of the program together as a jar file and to upload it to local Maven repository.

Note: This script will bundle all dependencies as well, since the intention is to use this as a software library in other projects.

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'maven-publish'

sourceCompatibility = 1.5
version = '1.0'
def title = 'test-publish'

jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart',
                   'Implementation-Version': version
    }
}

repositories {
    mavenCentral()
}
dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    compile group: 'org.slf4j', name:'slf4j-api', version: '1.7.12'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

//create a single Jar with all dependencies
task createJar(type: Jar) {

println 'Going to create the jar..'
manifest {
        attributes 'Implementation-Title': 'Test Package',  
        'Implementation-Version': version,
        'Main-Class':'com.myorg.TestPackaging'
    }
    baseName = title
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
     with jar
}

publishing {
publications {
            maven(MavenPublication) {
                groupId 'com.myorg.testpublish'
                artifactId 'test-publish'
                version version
                artifact "$buildDir"+'/libs/'+"${title}"+'-'+"$version"+'.jar'
            }
        }
}

//publich to local maven repo
publishToMavenLocal.dependsOn clean, test, createJar


Now, on the command prmompt, go to the folder where your “build.gradle” file is available and execute the following command:

 gradle publishToMavenLocal

Once the above build is successful, you can see “test-publish-1.0.0.jar” is available in your local Maven repository.

If your favourite build tool is Maven, then here is the Maven build script to package and upload the project’s artifacts to local Maven repository.

<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.myorg.testpublish</groupId>
  <artifactId>test-publish</artifactId>
  <packaging>jar</packaging>
  <version>1.0.0</version>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<manifest>
<mainClass>com.myorg.TestPackaging</mainClass>
</manifest>
</archive>
<!--Following is needed to bundle dependency jars. -->
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<appendAssemblyId>false</appendAssemblyId>
</configuration>
<executions>
          <execution>
            <id>make-assembly</id> <!-- this is used for inheritance merges -->
            <phase>package</phase> <!-- bind to the packaging phase -->
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
</plugin>
</plugins>
</build>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8</version>
      <scope>test</scope>
    </dependency>
    <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.26</version>
</dependency>
<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20180813</version>
</dependency>
  </dependencies>
</project>


Now, on the command prompt, go to the folder where your pom.xml is available and execute the following command:

 mvn clean install 

Note: When the install  command is executed, the package  command will also be executed, so there is no need to give package  command here. More information about the Maven life cycle is availble here.

As you can see, using one of above scripts (depending on our build stream), we can upload our library jar file to our local Maven repository.

We can now create a Jenkins build job and use any of the above scripts, in order to upload our jar file to Jenkins local Maven repository.

Following are the steps to create a Jenkins build job.

Creating a Jenkins Build Job

Go to the Jenkins dashboard and click on "Manage Jenkins" and then select "Manage Plugins." Select the plugins your project may need on Available tab. If you grabbing your source code from Git, you may need to install “Git plugin," “GitHub plugin” and “GitHub API Plugin." Click on Download now and install after restart button. Restart Jenkins.

Go to the Jenkins dashboard again and click on New Item. Select Freestyle project check box and provide a suitable name for the Item name. Then click OK.

Then go to the configuration page and configure Source Code Management and provide a path to the source code of the library projects created.

Source Code Management sections of Jenkins configuration


Then go to the Build section and select Gradle as the build tool. Provide the task name as in our Gradle built script as shown at the previous steps.

Note: If you are going to use Maven as your build tool, you need to select Maven here.

Build sections of Jenkins configuration


Now save the configuration and build the projects. With that step, your jar file is available in Jenkins Local Maven repository.

Now other projects (in the same Jenkins build environment) which need to use this jar file as a dependency, can access it from their corresponding build files.

This  is a section of a Gradle build script which shows how to use our new library as a dependency:

......
dependencies {
compile (
......
'com.myorg.testpublish:test-publish:1.0.0 '
......
)
}
......


This is a section of a Maven pom.xml which shows how to use our new library as a dependency:

......
<dependency>
      <groupId>com.myorg.testpublish </groupId>
      <artifactId>test-publish </artifactId>
      <version>1.0.0 </version>
 </dependency>
......


Summary

As explained in the above steps, we can use the Jenkins local Maven repository as an internal private Maven repository in our build environments. This becomes handy when you want to share some project artifacts among other projects within your organization but still do not want to use repository management software like Nexus or Apache Archiva.

Apache Maven Repository (version control) Jenkins (software) Continuous Integration/Deployment

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • Using GPT-3 in Our Applications
  • Little's Law and Lots of Kubernetes
  • Cloud Performance Engineering
  • How To Best Use Java Records as DTOs in Spring Boot 3

Comments

Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends: