spring-boot-starter-webflux dependency issue with gradle build

I tried to use the Springframework WebClient (I use IntelliJ with gradle), and in the “dependencies” section of the build.gradle, I added

“compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-webflux’, version: versions.spring_boot”

However, when I do gradle build, it failed in the lintGradle task with the following errors:

This project contains lint violations. A complete listing of the violations follows.
Because some were serious, the overall build status has been changed to FAILED
error     unused-dependency                  one or more classes in jakarta.annotation:jakarta.annotation-api:1.3.5 are required by your code directly (no auto-fix available)
error     transitive-duplicate-dependency-classjakarta.annotation:jakarta.annotation-api:1.3.5 in configuration ‘:compile’ has 15 classes duplicated by javax.annotation:javax.annotation-api:1.3.2 (use --info for detailed class list) (no auto-fix available)
error     transitive-duplicate-dependency-classjakarta.annotation:jakarta.annotation-api:1.3.5 in configuration ‘:runtime’ has 15 classes duplicated by javax.annotation:javax.annotation-api:1.3.2 (use --info for detailed class list) (no auto-fix available)
error     transitive-duplicate-dependency-classjakarta.annotation:jakarta.annotation-api:1.3.5 in configuration ‘:testCompile’ has 15 classes duplicated by javax.annotation:javax.annotation-api:1.3.2 (use --info for detailed class list) (no auto-fix available)
error     transitive-duplicate-dependency-classjakarta.annotation:jakarta.annotation-api:1.3.5 in configuration ‘:implementation’ has 15 classes duplicated by javax.annotation:javax.annotation-api:1.3.2 (use --info for detailed class list) (no auto-fix available)
error     transitive-duplicate-dependency-classjakarta.annotation:jakarta.annotation-api:1.3.5 in configuration ‘:integrationTestCompile’ has 15 classes duplicated by javax.annotation:javax.annotation-api:1.3.2 (use --info for detailed class list) (no auto-fix available)
error     undeclared-dependency              one or more classes in jakarta.annotation:jakarta.annotation-api:1.3.5 are required by your code directly
error     unused-dependency                  this dependency should be removed since its artifact is empty (no auto-fix available)
build.gradle:122
compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-webflux’, version: versions.spring_boot

Not sure if I need to add something else to the gradle build setting environment? Or if the webflux dependency conflicts with other dependencies?

There is a parent folder Par and child folder Child, they both have their build.gradle respectively. The build task in the Child folder passed but failed in the Par folder with the errors above. The use of WebClient is in the child folder and the dependency is added to the build.gradle file of the Child foler.

The build.gradle file for Par folder:

plugins {
    id 'org.springframework.boot' version '2.2.6.RELEASE'
    id 'nerv-java-war-module-plugin' version '10.9.0'
    id 'nerv-tab-checkstyle-plugin' version '4.5.0'
    id 'hackathon-teamcity-auto-increment' version '3.1.0'
    id 'microservice-incremental-deploy-plugin' version '1.2.0'
    id 'protobuf-java-consumer-plugin' version '4.2.0'
    id 'nebula.lint' version '16.0.2'
    id 'application'
    id 'eclipse-wtp'
}

subprojects {
    apply plugin: 'nerv-java-war-module-plugin'
    apply plugin: 'nerv-tab-checkstyle-plugin'
    apply plugin: 'hackathon-teamcity-auto-increment'
}

incrementalDeploy.packageNames += 'Par'

// Notice about Spring Dependency Management: It doesn't work in this project due to a
// nebula.lint bug: https://github.com/nebula-plugins/gradle-lint-plugin/issues/227

gradleLint {
    criticalRules += 'all-dependency'
    excludedRules += ['overridden-dependency-version']// Ignore for dependency lock
    /*gradle daemon locks the Child.jar file which prevents from
     cleaning the build
     cause: linting rules 'undeclared-dependency','unused-dependency'
     Workaround: run gw --stop and then clean */
    alwaysRun = false
    build.finalizedBy lintGradle
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

// Integration tests related setup for sources
sourceSets {
    integrationTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integrationTest/java')
        }
        resources.srcDir file('src/integrationTest/resources')
    }

}


// When running locally, configure Log4J via system property
application {
    mainClassName = 'Par.ParApplication'
    applicationDefaultJvmArgs = ["-Dlog4j.defaultInitOverride=false",
                                 "-Dlogging.config=${buildDir}/config/log4j2.xml"]
}

// When running locally, we need some config files that would normally live in
// resources.  However, resources get included in the published WAR file, which
// we need to avoid.  We copy these to the build dir so that the same config files
// can be used by both this service, and the accompanying contractTest.
task copyConfig(type: Copy) {
    from("${buildscript.sourceFile.parent}/config/")
    into("${buildDir}/config")
}
bootRun.dependsOn(copyConfig)

ext.versions = [
        //  These definitions are shared with the contractTest application,
        //  so version numbers can be updated in one place.

        config_decrypt: '^3.0',
        grpc_helpers_java: '^19.0',

        //  Fixed versions for third-party packages
        grpc: '1.32.1',
        guava: '29.0-jre',
        javax_annotation: '1.3.2',
        junit: '4.12',
        log4j: '2.13.1',
        protobuf_java: '3.12.0',
        servlet_api: '4.0.1',
        slf4j: '1.7.30',
        spring: '5.2.9.RELEASE',
        spring_boot: '2.2.10.RELEASE'
]


configurations {
        gradleLint.ignore {
        // These exclusions are useful for application projects to make sure they aren't getting any log4j v1 dependencies transitively
        all*.exclude group: 'log4j', module: 'log4j'
        all*.exclude group: 'org.slf4j', module: 'slf4j-log4j12'
        // ignore logging libraries
        all*.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
        }

    // Favor org.slf4j:jcl-over-slf4j
    all*.exclude group: 'org.springframework', module: 'spring-jcl'

    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly

}

dependencies {
    compile project(':Child')
    compile nerv('grpc-helpers-java', versions.grpc_helpers_java)
    compile group: 'com.google.guava', name: 'guava', version: versions.guava
    compile group: 'com.google.protobuf', name: 'protobuf-java', version: versions.protobuf_java
    compile group: 'io.grpc', name: 'grpc-api', version: versions.grpc
    compile group: 'io.grpc', name: 'grpc-protobuf', version: versions.grpc
    compile group: 'io.grpc', name: 'grpc-stub', version: versions.grpc
    compile group: 'javax.annotation', name: 'javax.annotation-api', version: versions.javax_annotation
    compile group: 'org.springframework', name: 'spring-beans', version: versions.spring
    compile group: 'org.springframework', name: 'spring-context', version: versions.spring
    gradleLint.ignore {
        // Avoid unused-dependency error on spring-web. It is detected as a service provider which gradleLint thinks
        // should be a runtime dependency. There are compile time dependencies on spring-web so use an ignore block.
        compile group: 'org.springframework', name: 'spring-web', version: versions.spring
        compile group: 'org.springframework.boot', name: 'spring-boot', version: versions.spring_boot
        compile group: 'org.springframework.boot', name: 'spring-boot-autoconfigure', version: versions.spring_boot
        compile group: 'org.springframework', name: 'spring-core', version: versions.spring
    }

    gradleLint.ignore { // See https://github.com/nebula-plugins/gradle-lint-plugin/issues/126
        // Add javax.servlet-api for compiling but the implementations will be provided at runtime by the container
        compileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: versions.servlet_api
    }

    runtime group: 'org.apache.logging.log4j', name: 'log4j-api', version: versions.log4j
    runtime group: 'org.apache.logging.log4j', name: 'log4j-core', version: versions.log4j
    runtime group: 'org.apache.logging.log4j', name: 'log4j-slf4j-impl', version: versions.log4j // For SLF4J 1.7.x releases or older.

    // to consume encrypted configuration generated by tsm/tab-core-crypto, include this runtime dependency
    // and set features.SecureSecretStorage = true anywhere in your application properties
    runtime nerv('tab-microservice-config-decrypt-spring', versions.config_decrypt)
    testCompile ( group: 'junit', name: 'junit', version: versions.junit )

    gradleLint.ignore { // See https://github.com/nebula-plugins/gradle-lint-plugin/issues/126
        // Add javax.servlet-api for compiling but the implementations will be provided at runtime by the container
        testCompile group: 'org.springframework.boot', name: 'spring-boot-test', version: versions.spring_boot
        testCompile group: 'org.springframework', name: 'spring-test', version: versions.spring
    }
    constraints {
        implementation("com.netflix.nebula:gradle-scm-plugin:4.1.0"){
            because("Breaking changes for Gradle 7 compatibility")
        }
    }
    //  Bring in logging modules.  Code should be written to the slf4j API.
    //  At runtime, this is resolved to log4j for this service.
    //  PLEASE Remember to include these dependencies in all WAR files.  Failure to include this will lead
    //  to very difficult to diagnose problems with logging not working correctly.
    compile group: 'org.slf4j', name: 'slf4j-api', version: versions.slf4j
    runtime group: 'org.slf4j', name: 'jcl-over-slf4j', version: versions.slf4j // slf4j implementation for commons-logging
    runtime group: 'org.slf4j', name: 'slf4j-log4j12', version: versions.slf4j // Send slf4j calls to log4j
    // Applications projects only: Spring Boot add the compatible Log4J implementation (omit for libraries)
    // All 3 are necessary! Logging still may work without all 3 because you're getting some of these transitively, but that shouldn't be relied on.
    runtimeOnly group: 'org.apache.logging.log4j', name: 'log4j-api', version: versions.log4j
    runtimeOnly group: 'org.apache.logging.log4j', name: 'log4j-core', version: versions.log4j
    runtimeOnly group: 'org.apache.logging.log4j', name: 'log4j-slf4j-impl', version: versions.log4j // For SLF4J 1.7.x releases or older.

    integrationTestCompile nerv('grpc-helpers-java',versions.grpc_helpers_java)
    // to consume encrypted configuration generated by tsm/tab-core-crypto, include this runtime dependency
    // and set features.SecureSecretStorage = true anywhere in your application properties
    integrationTestCompile group: 'junit', name: 'junit', version: versions.junit
    //  Bring in logging modules.  Code should be written to the slf4j API.
    //  Runtime configuration resolves this to a specific output implementation.
    //  The jcl-over-slf4j module directs java common logging to slf4j
    //  slf4j is then directed to log4j for the service and consumer, like we expect in Production.
    integrationTestCompile group: 'org.springframework', name: 'spring-test', version: versions.spring
    integrationTestCompile group: 'org.springframework.boot', name: 'spring-boot-test', version: versions.spring_boot
}


def testSystemProperties = [
        "spring.config.location":  "${project.projectDir}/build/resources/integrationTest/application-integration-test.properties",
        "logging.config": "${project.projectDir}/build/resources/integrationTest/log4j2.xml"
]

task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    outputs.upToDateWhen { false }
}

eclipse {
    classpath {
        defaultOutputDir = file('build-eclipse/classes')
    }
}

distZip.enabled = false
distTar.enabled = false

bootRun.systemProperties = application.properties

The build.gradle file for Child folder:

version '0.1.0'
sourceCompatibility = 1.8
targetCompatibility = 1.8

ext.versions = [
        spring: '5.2.9.RELEASE',
        spring_boot: '2.2.10.RELEASE',
        slf4j: '1.7.30',
        grpc_helpers_java: '^19.0'
]

dependencies {
    compile nerv('grpc-helpers-java', versions.grpc_helpers_java)
    compile group: 'org.springframework', name: 'spring-core', version: versions.spring
    compile group: 'org.springframework', name: 'spring-beans', version: versions.spring
    compile group: 'org.springframework', name: 'spring-context', version: versions.spring
    compile group: 'org.springframework', name: 'spring-web', version: versions.spring
    compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version:'2.10.5'
    compile group: 'com.fasterxml.jackson.core',name:'jackson-core', version:'2.10.5'
    compile group: 'com.fasterxml.jackson.core', name:'jackson-databind', version:'2.10.5'
    compile group: 'org.slf4j', name: 'slf4j-api', version: versions.slf4j
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-webflux', version: versions.spring_boot
    runtime group: 'org.slf4j', name: 'slf4j-log4j12', version: versions.slf4j

    gradleLint.ignore {
        // Avoid unused-dependency error on spring-web. It is detected as a service provider which gradleLint thinks
        // should be a runtime dependency. There are compile time dependencies on spring-web so use an ignore block.
        compile group: 'org.springframework', name: 'spring-web', version: versions.spring
        //compile group: 'org.springframework.boot', name: 'spring-boot-starter-webflux', version: versions.spring_boot
    }
}

Thank you