1.Kafka源码-导入源码

最新推荐文章于 2022-06-22 09:09:34 发布

Jasoncbk

最新推荐文章于 2022-06-22 09:09:34 发布

阅读量1.5k

点赞数 1

分类专栏： kafka

本文链接：https://blog.csdn.net/Jasoncbk/article/details/105235113

版权

kafka 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

导入源码

1 版本
2 安装
3 导入工作

1 版本

idea : 2019.3.4
scala : 2.11.8
gradle : 3.0
jdk : 1.8.0_241
kafka : 0.10.1.0

2 安装

gradle安装方法跟maven类似,验证gradle -v
安装并没有太多要求,正常即可
注意
安装完gradle需要去C:\Users\xxx\.gradle目录下创建init.gradle文件
内容为

allprojects{
  repositories {
    def REPOSITORY_URL = 'http://maven.aliyun.com/nexus/content/groups/public/'
      all { ArtifactRepository repo ->
        if(repo instanceof MavenArtifactRepository){
          def url = repo.url.toString()
          if (url.startsWith('https://repo1.maven.org/maven2') || url.startsWith('https://jcenter.bintray.com/')) {
            project.logger.lifecycle "Repository ${repo.url} replaced by $REPOSITORY_URL."
            remove repo
          }
       }
    }
    maven {
      url REPOSITORY_URL
    }
  }
}

3 导入工作

1.首先进入到kafka源码目录
在这里插入图片描述
最后有SUCCESSFUL字样,显示成功即可
如果遇到一些,gradle idea的错误百度即可,解决方案多为增加一些配置

打开idea
使用open打开项目,选中build.gradle打开项目
设置idea中的gradle
修改build.gradle
这里附加上我自己的build.gradle

// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//import org.ajoberstar.grgit.Grgit

buildscript {
 repositories {
//    mavenCentral()
   maven{
     //配置阿里云
     url 'http://maven.aliyun.com/nexus/content/groups/public/'
   }
   jcenter()
 }
 apply from: file('gradle/buildscript.gradle'), to: buildscript

 dependencies {
   // For Apache Rat plugin to ignore non-Git files
   classpath "org.ajoberstar:grgit:1.5.0"
   classpath 'com.github.ben-manes:gradle-versions-plugin:0.12.0'
   classpath 'org.scoverage:gradle-scoverage:2.5.0'
 }
}

allprojects {
 apply plugin: 'idea'
 apply plugin: 'eclipse'
 apply plugin: "jacoco"

 repositories {
//    mavenCentral()
   //配置阿里云
   maven{ url 'http://maven.aliyun.com/nexus/content/groups/public/'}
 }

 apply plugin: 'com.github.ben-manes.versions'

 dependencyUpdates {
   revision="release"
   resolutionStrategy = {
     componentSelection { rules ->
       rules.all { ComponentSelection selection ->
         boolean rejected = ['snap', 'alpha', 'beta', 'rc', 'cr', 'm'].any { qualifier ->
           selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
         }
         if (rejected) {
           selection.reject('Release candidate')
         }
       }
     }
   }
 }

 if (JavaVersion.current().isJava8Compatible()) {
   tasks.withType(Javadoc) {
     // disable the crazy super-strict doclint tool in Java 8
     // noinspection SpellCheckingInspection
     options.addStringOption('Xdoclint:none', '-quiet')
   }
 }

}

ext {
 gradleVersion = "3.0"
 buildVersionFileName = "kafka-version.properties"

 maxPermSizeArgs = []
 if (!JavaVersion.current().isJava8Compatible())
   maxPermSizeArgs = ['-XX:MaxPermSize=512m']

 userMaxForks = project.hasProperty('maxParallelForks') ? maxParallelForks.toInteger() : null

 skipSigning = project.hasProperty('skipSigning') && skipSigning.toBoolean()
 shouldSign = !skipSigning && !version.endsWith("SNAPSHOT") && project.gradle.startParameter.taskNames.any { it.contains("upload") }

 mavenUrl = project.hasProperty('mavenUrl') ? project.mavenUrl : ''
 mavenUsername = project.hasProperty('mavenUsername') ? project.mavenUsername : ''
 mavenPassword = project.hasProperty('mavenPassword') ? project.mavenPassword : ''

 userShowStandardStreams = project.hasProperty("showStandardStreams") ? showStandardStreams : null

 userTestLoggingEvents = project.hasProperty("testLoggingEvents") ? Arrays.asList(testLoggingEvents.split(",")) : null

 generatedDocsDir = new File("${project.rootDir}/docs/generated")
}

apply from: "$rootDir/gradle/dependencies.gradle"
apply from: file('wrapper.gradle')

if (new File('.git').exists()) {
 apply from: file('gradle/rat.gradle')
 rat {
   // Exclude everything under the directory that git should be ignoring via .gitignore or that isn't checked in. These
   // restrict us only to files that are checked in or are staged.
   def repo = Grgit.open(project.file('.'))
   excludes = new ArrayList<String>(repo.clean(ignore: false, directories: true, dryRun: true))
   // And some of the files that we have checked in should also be excluded from this check
   excludes.addAll([
       '**/.git/**',
       '**/build/**',
       'CONTRIBUTING.md',
       'gradlew',
       'gradlew.bat',
       '**/README.md'
   ])
 }
}

subprojects {
 apply plugin: 'java'
 apply plugin: 'maven'
 apply plugin: 'signing'
 apply plugin: 'checkstyle'

 sourceCompatibility = 1.7

 compileJava {
   options.encoding = 'UTF-8'
   // Add unchecked once we drop support for Java 7 as @SuppressWarnings("unchecked") is too buggy in Java 7
   options.compilerArgs << "-Xlint:deprecation"
 }

 uploadArchives {
   repositories {
     signing {
         required { shouldSign }
         sign configurations.archives

         // To test locally, replace mavenUrl in ~/.gradle/gradle.properties to file://localhost/tmp/myRepo/
         mavenDeployer {
             beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
             repository(url: "${mavenUrl}") {
                 authentication(userName: "${mavenUsername}", password: "${mavenPassword}")
             }
             afterEvaluate {
                 pom.artifactId = "${archivesBaseName}"
                 pom.project {
                     name 'Apache Kafka'
                     packaging 'jar'
                     url 'http://kafka.apache.org'
                     licenses {
                         license {
                             name 'The Apache Software License, Version 2.0'
                             url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                             distribution 'repo'
                         }
                     }
                 }
             }
         }
     }
   }
 }

 test {
   maxParallelForks = userMaxForks ?: Runtime.runtime.availableProcessors()

   minHeapSize = "256m"
   maxHeapSize = "2048m"
   jvmArgs = maxPermSizeArgs

   testLogging {
     events = userTestLoggingEvents ?: ["passed", "skipped", "failed"]
     showStandardStreams = userShowStandardStreams ?: false
     exceptionFormat = 'full'
   }

 }

 jar {
   from '../LICENSE'
   from '../NOTICE'
 }

 task srcJar(type: Jar) {
   classifier = 'sources'
   from '../LICENSE'
   from '../NOTICE'
   from sourceSets.main.allSource
 }

 task javadocJar(type: Jar, dependsOn: javadoc) {
   classifier 'javadoc'
   from '../LICENSE'
   from '../NOTICE'
   from javadoc.destinationDir
 }

 task docsJar(dependsOn: javadocJar)

 javadoc {
   options.charSet = 'UTF-8'
   options.docEncoding = 'UTF-8'
   options.encoding = 'UTF-8'
 }

 task systemTestLibs(dependsOn: jar)

 artifacts {
   archives srcJar
   archives javadocJar
 }

 if(!sourceSets.test.allSource.isEmpty()) {
   task testJar(type: Jar) {
     classifier = 'test'
     from '../LICENSE'
     from '../NOTICE'
     from sourceSets.test.output
   }

   task testSrcJar(type: Jar, dependsOn: testJar) {
     classifier = 'test-sources'
     from '../LICENSE'
     from '../NOTICE'
     from sourceSets.test.allSource
   }

   artifacts {
     archives testJar
     archives testSrcJar
   }
 }

 plugins.withType(ScalaPlugin) {
   task scaladocJar(type:Jar) {
     classifier = 'scaladoc'
     from '../LICENSE'
     from '../NOTICE'
     from scaladoc.destinationDir
   }

   //documentation task should also trigger building scala doc jar
   docsJar.dependsOn scaladocJar

   artifacts {
     archives scaladocJar
   }
 }

 tasks.withType(ScalaCompile) {
   scalaCompileOptions.additionalParameters = [
     "-deprecation",
     "-unchecked",
     "-encoding", "utf8",
     "-target:jvm-${sourceCompatibility}".toString(),
     "-Xlog-reflective-calls",
     "-feature",
     "-language:postfixOps",
     "-language:implicitConversions",
     "-language:existentials"
   ]

   configure(scalaCompileOptions.forkOptions) {
     memoryMaximumSize = '1g'
     jvmArgs = ['-Xss2m'] + maxPermSizeArgs
   }
 }

 checkstyle {
   configFile = new File(rootDir, "checkstyle/checkstyle.xml")
   configProperties = [importControlFile: "$rootDir/checkstyle/import-control.xml"]
 }
 test.dependsOn('checkstyleMain', 'checkstyleTest')

 // Ignore core since its a scala project
 if (it.path != ':core') {
   // NOTE: Gradles Jacoco plugin does not support "offline instrumentation" this means that classes mocked by PowerMock
   // may report 0 coverage, since the source was modified after initial instrumentation.
   // See https://github.com/jacoco/jacoco/issues/51
   jacocoTestReport {
     dependsOn tasks.test
     sourceSets sourceSets.main
     reports {
       html.enabled = true
       xml.enabled = true
       csv.enabled = false
     }
   }
 }
}

// Aggregates all jacoco results into the root project directory
task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
 def javaProjects = subprojects.findAll { it.path != ':core' }

 description = 'Generates an aggregate report from all subprojects'
 dependsOn(javaProjects.test)

 additionalSourceDirs = files(javaProjects.sourceSets.main.allSource.srcDirs)
 sourceDirectories = files(javaProjects.sourceSets.main.allSource.srcDirs)
 classDirectories =  files(javaProjects.sourceSets.main.output)
 executionData = files(javaProjects.jacocoTestReport.executionData)

 reports {
   html.enabled = true
   xml.enabled = true
 }

 // workaround to ignore projects that don't have any tests at all
 onlyIf = { true }
 doFirst {
   executionData = files(executionData.findAll { it.exists() })
 }
}

task reportCoverage(dependsOn: ['jacocoRootReport', 'core:reportScoverage'])

for ( sv in ['2_10', '2_11'] ) {
 String svInDot = sv.replaceAll( "_", ".")

 tasks.create(name: "jar_core_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['core:jar']
 }

 tasks.create(name: "test_core_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['core:test']
 }

 tasks.create(name: "srcJar_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['core:srcJar']
 }

 tasks.create(name: "docsJar_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['core:docsJar']
 }

 tasks.create(name: "install_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['install']
 }

 tasks.create(name: "releaseTarGz_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['releaseTarGz']
 }

 tasks.create(name: "uploadCoreArchives_${sv}", type: GradleBuild) {
   startParameter = project.getGradle().getStartParameter().newInstance()
   startParameter.projectProperties += [scalaVersion: "${svInDot}"]
   tasks = ['core:uploadArchives']
 }
}

def connectPkgs = ['connect:api', 'connect:runtime', 'connect:json', 'connect:file']
def pkgs = ['clients', 'examples', 'log4j-appender', 'tools', 'streams', 'streams:examples'] + connectPkgs

tasks.create(name: "jarConnect", dependsOn: connectPkgs.collect { it + ":jar" }) {}
tasks.create(name: "jarAll", dependsOn: ['jar_core_2_10', 'jar_core_2_11'] + pkgs.collect { it + ":jar" }) { }

tasks.create(name: "srcJarAll", dependsOn: ['srcJar_2_10', 'srcJar_2_11'] + pkgs.collect { it + ":srcJar" }) { }

tasks.create(name: "docsJarAll", dependsOn: ['docsJar_2_10', 'docsJar_2_11'] + pkgs.collect { it + ":docsJar" }) { }

tasks.create(name: "testConnect", dependsOn: connectPkgs.collect { it + ":test" }) {}
tasks.create(name: "testAll", dependsOn: ['test_core_2_10', 'test_core_2_11'] + pkgs.collect { it + ":test" }) { }

tasks.create(name: "installAll", dependsOn: ['install_2_10', 'install_2_11'] + pkgs.collect { it + ":install" }) { }

tasks.create(name: "releaseTarGzAll", dependsOn: ['releaseTarGz_2_10', 'releaseTarGz_2_11']) { }

tasks.create(name: "uploadArchivesAll", dependsOn: ['uploadCoreArchives_2_10', 'uploadCoreArchives_2_11'] + pkgs.collect { it + ":uploadArchives" }) { }

project(':core') {
 println "Building project 'core' with Scala version ${versions.scala}"

 apply plugin: 'scala'
 apply plugin: "org.scoverage"
 archivesBaseName = "kafka_${versions.baseScala}"

 dependencies {
   compile project(':clients')
   compile libs.joptSimple
   compile libs.metrics
   compile libs.scala
   compile libs.slf4jlog4j
   compile libs.zkclient
   compile libs.zookeeper
   // These modules were broken out of core scala in 2.10. We can remove special handling when 2.10 support is dropped.
   if (versions.baseScala != '2.10') {
     compile libs.scalaParserCombinators
   }

   testCompile project(':clients').sourceSets.test.output
   testCompile libs.bcpkix
   testCompile libs.easymock
   testCompile(libs.apacheda) {
     exclude group: 'xml-apis', module: 'xml-apis'
   }
   testCompile libs.apachedsCoreApi
   testCompile libs.apachedsInterceptorKerberos
   testCompile libs.apachedsProtocolShared
   testCompile libs.apachedsProtocolKerberos
   testCompile libs.apachedsProtocolLdap
   testCompile libs.apachedsLdifPartition
   testCompile libs.apachedsMavibotPartition
   testCompile libs.apachedsJdbmPartition
   testCompile libs.junit
   testCompile libs.scalaTest

   scoverage libs.scoveragePlugin
   scoverage libs.scoverageRuntime
 }

 jacocoTestReport.enabled = false
 scoverage {
   reportDir = file("${rootProject.buildDir}/scoverage")
   highlighting = false
 }
 checkScoverage {
   minimumRate = 0.0
 }
 checkScoverage.shouldRunAfter('test')

 configurations {
   // manually excludes some unnecessary dependencies
   compile.exclude module: 'javax'
   compile.exclude module: 'jline'
   compile.exclude module: 'jms'
   compile.exclude module: 'jmxri'
   compile.exclude module: 'jmxtools'
   compile.exclude module: 'mail'
   compile.exclude module: 'netty'
   // To prevent a UniqueResourceException due the same resource existing in both
   // org.apache.directory.api/api-all and org.apache.directory.api/api-ldap-schema-data
   testCompile.exclude module: 'api-ldap-schema-data'
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
   }
   into "$buildDir/dependant-libs-${versions.scala}"
   duplicatesStrategy 'exclude'
 }

 task genProtocolErrorDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.common.protocol.Errors'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "protocol_errors.html").newOutputStream()
 }

 task genProtocolApiKeyDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.common.protocol.ApiKeys'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "protocol_api_keys.html").newOutputStream()
 }

 task genProtocolMessageDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.common.protocol.Protocol'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "protocol_messages.html").newOutputStream()
 }

 task genProducerConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.clients.producer.ProducerConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "producer_config.html").newOutputStream()
 }

 task genConsumerConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.clients.consumer.ConsumerConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "consumer_config.html").newOutputStream()
 }

 task genKafkaConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'kafka.server.KafkaConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "kafka_config.html").newOutputStream()
 }

 task genTopicConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'kafka.log.LogConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "topic_config.html").newOutputStream()
 }

 task siteDocsTar(dependsOn: ['genProtocolErrorDocs', 'genProtocolApiKeyDocs', 'genProtocolMessageDocs',
                              'genProducerConfigDocs', 'genConsumerConfigDocs', 'genKafkaConfigDocs',
                              'genTopicConfigDocs', ':connect:runtime:genConnectConfigDocs', 
                              ':streams:genStreamsConfigDocs'], type: Tar) {
   classifier = 'site-docs'
   compression = Compression.GZIP
   from project.file("../docs")
   into 'site-docs'
   duplicatesStrategy 'exclude'
 }

 tasks.create(name: "releaseTarGz", dependsOn: configurations.archives.artifacts, type: Tar) {
   into "kafka_${versions.baseScala}-${version}"
   compression = Compression.GZIP
   from(project.file("../bin")) { into "bin/" }
   from(project.file("../config")) { into "config/" }
   from '../LICENSE'
   from '../NOTICE'
   from(configurations.runtime) { into("libs/") }
   from(configurations.archives.artifacts.files) { into("libs/") }
   from(project.siteDocsTar) { into("site-docs/") }
   from(project(':tools').jar) { into("libs/") }
   from(project(':tools').configurations.runtime) { into("libs/") }
   from(project(':connect:api').jar) { into("libs/") }
   from(project(':connect:api').configurations.runtime) { into("libs/") }
   from(project(':connect:runtime').jar) { into("libs/") }
   from(project(':connect:runtime').configurations.runtime) { into("libs/") }
   from(project(':connect:json').jar) { into("libs/") }
   from(project(':connect:json').configurations.runtime) { into("libs/") }
   from(project(':connect:file').jar) { into("libs/") }
   from(project(':connect:file').configurations.runtime) { into("libs/") }
   from(project(':streams').jar) { into("libs/") }
   from(project(':streams').configurations.runtime) { into("libs/") }
   from(project(':streams:examples').jar) { into("libs/") }
   from(project(':streams:examples').configurations.runtime) { into("libs/") }
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn('copyDependantLibs')
 }

 jar.manifest {
   attributes(
     'Version': "${version}"
   )
 }

 tasks.create(name: "copyDependantTestLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('*.jar')
   }
   into "$buildDir/dependant-testlibs"
   duplicatesStrategy 'exclude'
 }

 systemTestLibs.dependsOn('jar', 'testJar', 'copyDependantTestLibs')

 checkstyle {
   configProperties = [importControlFile: "$rootDir/checkstyle/import-control-core.xml"]
 }
}

project(':examples') {
 archivesBaseName = "kafka-examples"

 dependencies {
   compile project(':core')
 }

 javadoc {
   enabled = false
 }

 checkstyle {
   configProperties = [importControlFile: "$rootDir/checkstyle/import-control-core.xml"]
 }
}

project(':clients') {
 archivesBaseName = "kafka-clients"

 dependencies {
   compile libs.lz4
   compile libs.snappy
   compile libs.slf4jApi

   testCompile libs.bcpkix
   testCompile libs.junit
   testCompile libs.easymock
   testCompile libs.powermock
   testCompile libs.powermockEasymock

   testRuntime libs.slf4jlog4j
 }

 task determineCommitId {
   ext.commitId = "unknown"
   def takeFromHash = 16
   if (file("../.git/HEAD").exists()) {
     def headRef = file("../.git/HEAD").text
     if (headRef.contains('ref: ')) {
       headRef = headRef.replaceAll('ref: ', '').trim()
       if (file("../.git/$headRef").exists()) {
       commitId = file("../.git/$headRef").text.trim().take(takeFromHash)
       }
     } else {
       commitId = headRef.trim().take(takeFromHash)
     }
   }
   commitId
 }

 task createVersionFile(dependsOn: determineCommitId) {
   ext.receiptFile = file("$buildDir/kafka/$buildVersionFileName")
   outputs.file receiptFile
   outputs.upToDateWhen { false }
   doLast {
     def data = [
       commitId: determineCommitId.commitId,
       version: version,
     ]

     receiptFile.parentFile.mkdirs()
     def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
     receiptFile.setText(content, "ISO-8859-1")
   }
 }

 jar {
   dependsOn createVersionFile
   from("$buildDir") {
       include "kafka/$buildVersionFileName"
   }
 }

 clean.doFirst {
   delete "$buildDir/kafka/"
 }

 javadoc {
   include "**/org/apache/kafka/clients/consumer/*"
   include "**/org/apache/kafka/clients/producer/*"
   include "**/org/apache/kafka/common/*"
   include "**/org/apache/kafka/common/errors/*"
   include "**/org/apache/kafka/common/serialization/*"
   include "**/org/apache/kafka/common/config/*"
 }
}

project(':tools') {
 archivesBaseName = "kafka-tools"

 dependencies {
   compile project(':clients')
   compile project(':log4j-appender')
   compile libs.argparse4j
   compile libs.jacksonDatabind
   compile libs.slf4jlog4j

   testCompile project(':clients')
   testCompile libs.junit
 }

 javadoc {
   enabled = false
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
   }
   into "$buildDir/dependant-libs-${versions.scala}"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn 'copyDependantLibs'
 }
}

project(':streams') {
 archivesBaseName = "kafka-streams"

 dependencies {
   compile project(':clients')
   compile project(':connect:json')  // this dependency should be removed after we unify data API
   compile libs.slf4jApi
   compile libs.rocksDBJni
   // this dependency should be removed after KIP-4
   compile (libs.zkclient) {
     // users should be able to choose the logging implementation (and slf4j bridge)
     exclude module: 'slf4j-log4j12'
     exclude module: 'log4j'
     exclude module: 'jline'
     exclude module: 'netty'
   }

   // zkclient has a hard log4j dependency, we set it here as well to avoid copying an older
   // version to the binary package; the following two dependencies should be removed after KIP-4
   // (along with the zkclient dependency)
   compile libs.log4j
   compile libs.jacksonDatabind

   testCompile project(':clients').sourceSets.test.output
   testCompile project(':core')
   testCompile project(':core').sourceSets.test.output
   testCompile libs.junit

   testRuntime libs.slf4jlog4j
 }

 javadoc {
   include "**/org/apache/kafka/streams/**"
   exclude "**/internals/**"
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
   }
   into "$buildDir/dependant-libs-${versions.scala}"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn 'copyDependantLibs'
 }

 systemTestLibs {
   dependsOn testJar
 }

 task genStreamsConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.streams.StreamsConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "streams_config.html").newOutputStream()
 }
}

project(':streams:examples') {
 archivesBaseName = "kafka-streams-examples"

 dependencies {
   compile project(':streams')
   compile project(':connect:json')  // this dependency should be removed after we unify data API
   compile libs.slf4jlog4j           // this dependency should be removed after KIP-4
 }

 javadoc {
   enabled = false
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.runtime) {
     exclude('kafka-streams*')
   }
   into "$buildDir/dependant-libs-${versions.scala}"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn 'copyDependantLibs'
 }
}

project(':log4j-appender') {
 archivesBaseName = "kafka-log4j-appender"

 dependencies {
   compile project(':clients')
   compile libs.slf4jlog4j

   testCompile project(':clients').sourceSets.test.output
   testCompile libs.junit
 }

 javadoc {
   enabled = false
 }

}

project(':connect:api') {
 archivesBaseName = "connect-api"

 dependencies {
   compile project(':clients')
   compile libs.slf4jApi

   testCompile libs.junit

   testRuntime libs.slf4jlog4j
 }

 javadoc {
   include "**/org/apache/kafka/connect/**" // needed for the `javadocAll` task
   options.links "http://docs.oracle.com/javase/7/docs/api/"
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
     exclude('connect-*')
   }
   into "$buildDir/dependant-libs"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn copyDependantLibs
 }
}

project(':connect:json') {
 archivesBaseName = "connect-json"

 dependencies {
   compile project(':connect:api')
   compile libs.jacksonDatabind
   compile libs.slf4jApi

   testCompile libs.easymock
   testCompile libs.junit
   testCompile libs.powermock
   testCompile libs.powermockEasymock

   testRuntime libs.slf4jlog4j
 }

 javadoc {
   enabled = false
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
     exclude('connect-*')
   }
   into "$buildDir/dependant-libs"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn copyDependantLibs
 }
}

project(':connect:runtime') {
 archivesBaseName = "connect-runtime"

 dependencies {
   compile project(':connect:api')
   compile project(':clients')
   compile project(':tools')
   compile libs.slf4jApi

   compile libs.jacksonJaxrsJsonProvider
   compile libs.jerseyContainerServlet
   compile libs.jettyServer
   compile libs.jettyServlet
   compile libs.jettyServlets
   compile(libs.reflections) {
     // Exclude because of LGPL license
     exclude group: 'com.google.code.findbugs', module: 'annotations'
   }

   testCompile project(':clients').sourceSets.test.output
   testCompile libs.easymock
   testCompile libs.junit
   testCompile libs.powermock
   testCompile libs.powermockEasymock
   testCompile project(":connect:json")

   testRuntime libs.slf4jlog4j
 }

 javadoc {
   enabled = false
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
     exclude('connect-*')
   }
   into "$buildDir/dependant-libs"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn copyDependantLibs
 }

 task genConnectConfigDocs(type: JavaExec) {
   classpath = sourceSets.main.runtimeClasspath
   main = 'org.apache.kafka.connect.runtime.distributed.DistributedConfig'
   if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
   standardOutput = new File(generatedDocsDir, "connect_config.html").newOutputStream()
 }
}

project(':connect:file') {
 archivesBaseName = "connect-file"

 dependencies {
   compile project(':connect:api')
   compile libs.slf4jApi

   testCompile libs.easymock
   testCompile libs.junit
   testCompile libs.powermock
   testCompile libs.powermockEasymock

   testRuntime libs.slf4jlog4j
 }

 javadoc {
   enabled = false
 }

 tasks.create(name: "copyDependantLibs", type: Copy) {
   from (configurations.testRuntime) {
     include('slf4j-log4j12*')
   }
   from (configurations.runtime) {
     exclude('kafka-clients*')
     exclude('connect-*')
   }
   into "$buildDir/dependant-libs"
   duplicatesStrategy 'exclude'
 }

 jar {
   dependsOn copyDependantLibs
 }
}

task aggregatedJavadoc(type: Javadoc) {
 def projectsWithJavadoc = subprojects.findAll { it.javadoc.enabled }
 source = projectsWithJavadoc.collect { it.sourceSets.main.allJava }
 classpath = files(projectsWithJavadoc.collect { it.sourceSets.main.compileClasspath })
 includes = projectsWithJavadoc.collectMany { it.javadoc.getIncludes() }
 excludes = projectsWithJavadoc.collectMany { it.javadoc.getExcludes() }
 options.links "http://docs.oracle.com/javase/7/docs/api/"
}

4.创建buildscript.gradle
内容为

repositories {
    repositories {
        // For license plugin.
        maven {
            //url 'http://dl.bintray.com/content/netflixoss/external-gradle-plugins/'  //原有注释
            //新增
            url 'http://maven.aliyun.com/nexus/content/groups/public/'
        }
    }
}

这个时间会比较漫长
5. Build
在这里插入图片描述
6. 导入完成

Jasoncbk

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
5
评论
1.Kafka源码-导入源码

导入源码1 版本2 安装3 导入工作1 版本idea : 2019.3.4scala : 2.11.8gradle : 3.0jdk : 1.8.0_241kafka : 0.10.1.02 安装安装方法跟maven类似,验证gradle -v安装并没有太多要求,正常即可注意安装完gradle需要去C:\Users\xxx\.gradle目录下创建init.gradle文件...
复制链接

扫一扫