Spring 源码环境搭建 IDEA

IDEA编译Spring 源码

step1: 从github下载spring源码（5.0.x）

1）在搜索框中输入 spring 即可

2）选择分支5.0.x，然后下载zip到本地

step2: 安装 Gradle

解压刚刚下载的 zip 文件，查看spring-framework-5.0.x / gradle / wrapper 下的 gradle-wrapper.properties 文件。

我们可以看到 Gradle 的版本是4.4.1，然后我们从网上下载 gradle-4.4.1-bin.zip。下载完后解压到你的目录 ”xxx/ssss"，然后配置环境变量

GRADLE_HOME = “xxx/ssss”

GRADLE_USER_HOME = %GRADLE_HOME%.gradle

Path 变量中添加 %GRADLE_HOME%.gradle 和 %GRADLE_HOME%.gradle

STEP3: 导入 IDEA

1）设置 IDEA 的setting 中的 Gradle 目录为本地目录

2）点击 file / new / project from exists sources ，选择下载的源码，以gradle 的方式导入

3）修改docc.gradle 文件为：（为什么这么做，我也不知道）

/*
 * Copyright 2002-2019 the original author or authors.
 *
 *  Licensed 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
 *
 *       https://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.
 */

task api(type: Javadoc) {
	group = "Documentation"
	description = "Generates aggregated Javadoc API documentation."
	title = "${rootProject.description} ${version} API"

	dependsOn {
		subprojects.collect {
			it.tasks.getByName("jar")
		}
	}
	options.encoding = "UTF-8"
	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
	options.author = true
	options.header = rootProject.description
	options.use = true
	options.overview = "src/docs/api/overview.html"
	options.stylesheetFile = file("src/docs/api/stylesheet.css")
	options.splitIndex = true
	options.links(project.ext.javadocLinks)
	options.addStringOption('Xdoclint:none', '-quiet')

	source subprojects.collect { project ->
		project.sourceSets.main.allJava
	}

	maxMemory = "1024m"
	destinationDir = new File(buildDir, "api")

	doFirst {
		classpath = files(
				// ensure the javadoc process can resolve types compiled from .aj sources
				project(":spring-aspects").sourceSets.main.output
		)
		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
	}
}

/*dokka {
    dependsOn {
        tasks.getByName("api")
    }
    doFirst {
        classpath = subprojects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
        classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })

    }
    moduleName = "spring-framework"
    outputFormat = "html"
    outputDirectory = "$buildDir/docs/kdoc"

    sourceDirs = files(subprojects.collect { project ->
        def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
        kotlinDirs -= project.sourceSets.main.java.srcDirs
    })
    externalDocumentationLink {
        url = new URL("https://docs.spring.io/spring-framework/docs/$version/javadoc-api/")
        packageListUrl = new File(buildDir, "api/package-list").toURI().toURL()
    }
    externalDocumentationLink {
        url = new URL("https://projectreactor.io/docs/core/release/api/")
    }
    externalDocumentationLink {
        url = new URL("https://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/")
    }
}*/

/*asciidoctor {
    sources {
        include '*.adoc'
    }
    resources {
        from(sourceDir) {
            include 'images/*', 'stylesheets/*', 'tocbot-3.0.2/*'
        }
    }
    logDocuments = true
    backends = ["html5"]
    // only ouput PDF documentation for non-SNAPSHOT builds
    if(!project.getVersion().toString().contains("BUILD-SNAPSHOT")) {
        backends += "pdf"
    }
    options doctype: 'book', eruby: 'erubis'
    attributes  'icons': 'font',
            'idprefix': '',
            'idseparator': '-',
            docinfo: '',
            revnumber: project.version,
            sectanchors: '',
            sectnums: '',
            'source-highlighter': 'coderay@', // TODO switch to 'rouge' once supported by the html5 backend
            stylesdir: 'stylesheets/',
            stylesheet: 'main.css',
            'spring-version': project.version

}*/

task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'dokka']) {
	group = "Distribution"
	baseName = "spring-framework"
	classifier = "docs"
	description = "Builds -${classifier} archive containing api and reference " +
			"for deployment at https://docs.spring.io/spring-framework/docs."

	from("src/dist") {
		include "changelog.txt"
	}

	from (api) {
		into "javadoc-api"
	}

	from ("$asciidoctor.outputDir/html5") {
		into "spring-framework-reference"
	}

	from ("$asciidoctor.outputDir/pdf") {
		into "spring-framework-reference/pdf"
	}

	from (dokka) {
		into "kdoc-api"
	}
}

//task schemaZip(type: Zip) {
//    group = "Distribution"
//    baseName = "spring-framework"
//    classifier = "schema"
//    description = "Builds -${classifier} archive containing all " +
//            "XSDs for deployment at https://springframework.org/schema."
//    duplicatesStrategy 'exclude'
//    moduleProjects.each { subproject ->
//        def Properties schemas = new Properties();
//
//        subproject.sourceSets.main.resources.find {
//            (it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
//        }?.withInputStream { schemas.load(it) }
//
//        for (def key : schemas.keySet()) {
//            def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
//            assert shortName != key
//            File xsdFile = subproject.sourceSets.main.resources.find {
//                (it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\')))
//            }
//            assert xsdFile != null
//            into (shortName) {
//                from xsdFile.path
//            }
//        }
//    }
//}
task schemaZip(type: Zip) {
	group = "Distribution"
	baseName = "spring-framework"
	classifier = "schema"
	description = "Builds -${classifier} archive containing all " +
			"XSDs for deployment at https://springframework.org/schema."
	duplicatesStrategy 'exclude'
	moduleProjects.each { subproject ->
		def Properties schemas = new Properties();

		subproject.sourceSets.main.resources.find {
			//此处修改为\\
			it.path.endsWith("META-INF\\spring.schemas")
		}?.withInputStream { schemas.load(it) }

		for (def key : schemas.keySet()) {
			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
			assert shortName != key
			File xsdFile = subproject.sourceSets.main.resources.find {
				//此处将Linux路径符号替换为Windows路径符号
				it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\'))
			}
			assert xsdFile != null
			into (shortName) {
				from xsdFile.path
			}
		}
	}
}

task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
	group = "Distribution"
	baseName = "spring-framework"
	classifier = "dist"
	description = "Builds -${classifier} archive, containing all jars and docs, " +
			"suitable for community download page."

	ext.baseDir = "${baseName}-${project.version}";

	from("src/docs/dist") {
		include "readme.txt"
		include "license.txt"
		include "notice.txt"
		into "${baseDir}"
		expand(copyright: new Date().format("yyyy"), version: project.version)
	}

	from(zipTree(docsZip.archivePath)) {
		into "${baseDir}/docs"
	}

	from(zipTree(schemaZip.archivePath)) {
		into "${baseDir}/schema"
	}

	moduleProjects.each { subproject ->
		into ("${baseDir}/libs") {
			from subproject.jar
			if (subproject.tasks.findByPath("sourcesJar")) {
				from subproject.sourcesJar
			}
			if (subproject.tasks.findByPath("javadocJar")) {
				from subproject.javadocJar
			}
		}
	}
}

distZip.mustRunAfter subprojects.test

// Create a distribution that contains all dependencies (required and optional).
// Not published by default; only for use when building from source.
task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
	group = "Distribution"
	baseName = "spring-framework"
	classifier = "dist-with-deps"
	description = "Builds -${classifier} archive, containing everything " +
			"in the -${distZip.classifier} archive plus all runtime dependencies."

	from zipTree(distZip.archivePath)

	gradle.taskGraph.whenReady { taskGraph ->
		if (taskGraph.hasTask(":${zipTask.name}")) {
			def projectNames = rootProject.subprojects*.name
			def artifacts = new HashSet()
			subprojects.each { subproject ->
				(subproject.configurations.runtime.resolvedConfiguration.resolvedArtifacts +
						subproject.configurations.optional.resolvedConfiguration.resolvedArtifacts).each { artifact ->
					def dependency = artifact.moduleVersion.id
					if (!projectNames.contains(dependency.name)) {
						artifacts << artifact.file
					}
				}
			}

			zipTask.from(artifacts) {
				into "${distZip.baseDir}/deps"
			}
		}
	}
}

这个过程比较漫长，可以去做其他事情

4）预编译 spring-oxm 和 spring-core


编译成功后会提示 build success。

到此为止，源码也就编译完成，是不是很简单？