Spring boot multi project with gradle generates the same jar - spring

Question

I'm new to gradle and I'm having trouble generating multiple jars with spring boot.
I generate two different builds, but when I run build A or build B, both are A
My project has the following structure:
root
├── facade
├─── rest-api
└─── web-api
├── dependencies
├─── services
├─── entities
└─── ...
├── settings.gradle
└── build.gradle
My intention is to have a mono repo of micro services. The micro services I will generate are the web api and rest api modules of the facade directory. These modules have dependencies of the module called dependencies as its name indicates.
As I described before, when I run the web api module, it's like I'm running rest api, even asking for its dependencies.
My settings.gradle:
rootProject.name = "root"
include ":root:facade:rest-api"
include ":root:facade:web-api"
include ":root:dependencies:entities"
include ":root:dependencies:services"
...
And my build.gradle
buildscript {
ext.kotlin_version = '1.3.61'
ext.spring_boot_version = '2.2.2.RELEASE'
ext.jjwt_version = '0.10.6'
ext.klockVersion = "1.7.3"
ext.queryDslVersion = '4.1.4'
repositories {
jcenter()
mavenCentral()
}
dependencies {
classpath "org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_version"
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"
classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
}
}
group 'org.com'
version '0.1.0'
def javaProjects() {
return subprojects.findAll { new File(it.projectDir, "src").exists() }
}
subprojects {
repositories {
jcenter()
mavenCentral()
}
configure(javaProjects()) {
apply plugin: "java"
apply plugin: "java-library"
apply plugin: "org.jetbrains.kotlin.jvm"
apply plugin: 'kotlin'
apply plugin: "kotlin-spring"
apply plugin: "kotlin-jpa"
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
compileKotlin {
kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
kotlinOptions.jvmTarget = "1.8"
}
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
implementation "io.jsonwebtoken:jjwt-api:$jjwt_version"
implementation "io.jsonwebtoken:jjwt-impl:$jjwt_version"
implementation "io.jsonwebtoken:jjwt-jackson:$jjwt_version"
implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
implementation "com.soywiz.korlibs.klock:klock-jvm:1.7.3"
implementation "org.jetbrains.kotlin:kotlin-reflect"
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'org.springframework.boot:spring-boot-starter-data-rest'
implementation "org.springframework.boot:spring-boot-starter-web"
implementation("org.springframework.boot:spring-boot-starter-security")
implementation "org.postgresql:postgresql:42.1.3"
implementation 'com.fasterxml.jackson.module:jackson-module-kotlin'
implementation "khttp:khttp:1.0.0"
testImplementation('org.springframework.boot:spring-boot-starter-test') {
exclude module: 'junit'
exclude module: 'mockito-core'
}
testImplementation('org.junit.jupiter:junit-jupiter:5.5.2')
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
testImplementation('com.ninja-squad:springmockk:2.0.0')
}
allOpen {
annotation("javax.persistence.Entity")
annotation("javax.persistence.MappedSuperclass")
annotation("javax.persistence.Embeddable")
}
}
}
project(":root:dependencies:services") {
bootJar {
enabled = false
}
jar {
enabled = true
}
}
project(":root:dependencies:entities") {
bootJar {
enabled = false
}
jar {
enabled = true
}
}
...
I feel that I must have something wrong with the build.gradle, but I don't understand what.
I also have omitted the build.gradle files of the modules rest api and web api since I only have the dependencies and I have not considered it relevant.
I had previously worked with maven and followed this architecture. I don't know if gradle is the right thing to do, so I'm open to any advice you can give me.
Thank you for your attention.

Answer 1

As I mentioned in the comments, the correct way to include subprojects is to replace the path to the subproject with : i.e. if the subproject is in (from the root project) sub/project1, then the correct way to include it is:
include ':sub:project1'
Now as for your other question in the comments regarding:
Main class name has not been configured and it could not be resolved
You can simply do:
mainClassName = 'full.cannonical.name.of.MainClass'
If all the projects have a main class, then you need to do this in each project's build.gradle