Index
- Setup
- Create a simple application
- Create an application with root project
- Adding internal dependencies
- Publishing on maven repository
- Using "external" projects
- Using Spring boot
- Adding Junit and JaCoCo
- Profiles
Source code on github: https://github.com/kendarorg/Gradle101
003-Publishing on maven repository
First, just take the demo002 and copy as demo003
Publishin on local directory
To ease the development i choosed to use a local Maven repository to share the libraries. Again supposing our projects are in the C:\Documents directory, my new repo will be placed in C:\Documents\maven directory
This local repo will be used to overcame the need for the one level max nesting of gradle projects
The main build.gradle
In the main build.gradle i will add an external variable. This is a variable that will be seen by all build.gradle-s inside the project. This will contain a reference to the our maven directory. Please note that i assume that exists one "container" (kind of pom) project with only direct childrens! No nesting!
ext.repos = [
'LocalMaven' : "file://${projectDir}/../maven"
]
Then i have to tell all the subprojects to use this repository (as a source). I add this at the end of the main build.gradle. This means that all java-type subprojects will first search on the "LocalMaven" and then on the maven central.
All the subprojects will have access to the "repos" variable. The placement inside the main build.gradle is driven by the need to define a common directory for all subprojects. The internal variable will have the form of "repos.LocalMaven": notice the lack of commas!
The definition of the "jar source" repository can be placed in every java-type project, and can have the following form, the declaration order matters a lot! Here first is taken the local maven repository (just declared) and after the maven central repo.
repositories {
maven {
name = 'LocalMaven'
url = uri(repos.LocalMaven)
}
mavenCentral()
}
The idea is to put all the repository informations in one single place to avoid littering the groovy code. We introduce some new constructs.
- supbrojects: apply the content to all the sub projects. This can be seen as an iterator
- afterEvaluate(func(project)): tells groovy to apply the function to the subproject only after all the subproject variables have been evaluated. This is needed to access the project specific variables like group, version, projectDir
- allprojects: apply the content to all the projects (is not needed here)
- plugins.withType: filter only the projects with the given plugin installed. The plugin name here is its Java class. Not the maven artifact!
Inside the main build.gradle now can be added the declaration of the repos.
subprojects {
afterEvaluate { project ->
plugins.withType(JavaPlugin) {
repositories {
maven {
name = 'LocalMaven'
url = uri(repos.LocalMaven)
}
mavenCentral()
...
To demonstrate the previous statement you can add some line and see the differences (i always loved variable scoping...)
subprojects{
println project.name
println project.version
afterEvaluate { project ->
println project.name
println project.version
...
At last i have to tell the projects that publishes artifacts to use the local maven repo. Adding the following to the previously created "subprojects" section.
subprojects {
afterEvaluate { project ->
plugins.withType(JavaPlugin) {
...
}
plugins.withType(MavenPublishPlugin) {
publishing {
publications {
mavenJava(MavenPublication) {
from project.components.java
}
}
repositories {
maven {
name = 'LocalMaven'
url = uri(repos.LocalMaven)
}
...
Remember to close the curly braces!!!!
Publishing the services
To publish the services on our local repository it would be enough to add the mavne-publish plugin to the build.gradle, resulting in the following. This because we already handled the publishing behaviour in the root project!
plugins {
id 'java'
id 'java-library'
id 'maven-publish'
}
group 'org.kendar'
version '1.0.0-SNAPSHOT'
Now running "gradle build publish" the new directory C:\Documents\maven have been created containing the poms, md5 and jars for the services!
But this simple "publish" task... will not last long
Publishing on global repository
Setup a simple maven repository
We can now download a ready copy of Artifactory to simulate a real repo, from Artifactory Portable extract in the same dir previously used for Gradle and Java, then run partifactory.bat.
An UI will then open and the first things to do are
- Change login and password from the standard admin/password (i usually change this for demo purposes in !Passw0rd with a Zero instead of the "O" letter)
- Create a Maven repository
Integrate the main build.gradle
First must be added the variables containing the addresses of the remote repositories
ext.repos = [
...
'RemoteMavenRelease' : "http://localhost:8081/artifactory/libs-release",
'RemoteMavenSnapshot' : "http://localhost:8081/artifactory/libs-snapshot"
]
Now i will add the dependency on the "Remote Repo" to download files and to upload them. Here i have to add the credentials for my local artifactory repository. Of course you can work with any kind of repository following this approach.
subprojects {
afterEvaluate { project ->
plugins.withType(JavaPlugin) {
repositories {
...
maven {
name = 'RemoteMaven'
if (project.version.endsWith('-SNAPSHOT')) {
url = uri(repos.RemoteMavenSnapshot)
} else {
url = uri(repos.RemoteMavenRelease)
}
credentials {
username 'admin'
password '!Passw0rd'
}
}
...
mavenCentral()
}
}
plugins.withType(MavenPublishPlugin) {
publishing {
...
repositories {
...
maven {
name = 'RemoteMaven'
if (project.version.endsWith('-SNAPSHOT')) {
url = uri(repos.RemoteMavenSnapshot)
} else {
url = uri(repos.RemoteMavenRelease)
}
credentials {
username 'admin'
password '!Passw0rd'
}
...
A new task will then appear if we call gradle tasks: publishMavenJavaPublicationToRemoteMavenRepository (pretty long but this will be solved afterwards)
This when called will publish our data on the remote repo choosing the right path for snapshots and releases