Spring/spring-boot
Spring/spring-boot
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-boot.git synced 2024-07-15 01:07:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '2.7.x'

Browse Source
This commit is contained in:
Andy Wilkinson 2022-02-18 19:02:54 +00:00
commit 8209980ca0
6 changed files with 97 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
buildSrc/src/main/java/org/springframework/boot/build/GeneratePropertiesResource.java
View File

@ -1,81 +0,0 @@
/*
* Copyright 2012-2022 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.
*/
package org.springframework.boot.build;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import org.gradle.api.DefaultTask;
import org.gradle.api.Task;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;
/**
* {@link Task} to generate properties and write them to disk as a properties file.
*
* @author Scott Frederick
*/
public class GeneratePropertiesResource extends DefaultTask {
private final Property<String> propertiesFileName;
private final DirectoryProperty destinationDirectory;
private final Map<String, String> properties = new HashMap<>();
public GeneratePropertiesResource() {
ObjectFactory objects = getProject().getObjects();
this.propertiesFileName = objects.property(String.class);
this.destinationDirectory = objects.directoryProperty();
}
@OutputDirectory
public DirectoryProperty getDestinationDirectory() {
return this.destinationDirectory;
}
@Input
public Property<String> getPropertiesFileName() {
return this.propertiesFileName;
}
public void property(String name, String value) {
this.properties.put(name, value);
}
@Input
public Map<String, String> getProperties() {
return this.properties;
}
@TaskAction
void generatePropertiesFile() throws IOException {
File outputFile = this.destinationDirectory.file(this.propertiesFileName).get().getAsFile();
try (PrintWriter writer = new PrintWriter(new FileWriter(outputFile))) {
this.properties.forEach((key, value) -> writer.printf("%s=%s\n", key, value));
}
}
}

49
buildSrc/src/main/java/org/springframework/boot/build/JavaConventions.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012-2022 the original author or authors.
* Copyright 2012-2021 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.
@ -105,8 +105,6 @@ class JavaConventions {
private static final String SOURCE_AND_TARGET_COMPATIBILITY = "17";
private static final String SPRING_BOOT_PROPERTIES_FILE = "spring-boot.properties";
void apply(Project project) {
project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
project.getPlugins().apply(TestFailuresPlugin.class);
@ -115,7 +113,6 @@ class JavaConventions {
configureJavadocConventions(project);
configureTestConventions(project);
configureJarManifestConventions(project);
configureMetaInfResourcesConventions(project);
configureDependencyManagement(project);
configureToolchain(project);
configureProhibitedDependencyChecks(project);
@ -123,37 +120,29 @@ class JavaConventions {
}
private void configureJarManifestConventions(Project project) {
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
Set<String> sourceJarTaskNames = sourceSets.stream().map(SourceSet::getSourcesJarTaskName)
.collect(Collectors.toSet());
Set<String> javadocJarTaskNames = sourceSets.stream().map(SourceSet::getJavadocJarTaskName)
.collect(Collectors.toSet());
project.getTasks().withType(Jar.class,
(jar) -> project.afterEvaluate((evaluated) -> jar.manifest((manifest) -> {
Map<String, Object> attributes = new TreeMap<>();
attributes.put("Automatic-Module-Name", project.getName().replace("-", "."));
attributes.put("Build-Jdk-Spec", SOURCE_AND_TARGET_COMPATIBILITY);
attributes.put("Built-By", "Spring");
attributes.put("Implementation-Title",
determineImplementationTitle(project, sourceJarTaskNames, javadocJarTaskNames, jar));
attributes.put("Implementation-Version", project.getVersion());
manifest.attributes(attributes);
})));
}
private void configureMetaInfResourcesConventions(Project project) {
ExtractResources extractLegalResources = project.getTasks().create("extractLegalResources",
ExtractResources.class);
extractLegalResources.getDestinationDirectory().set(project.getLayout().getBuildDirectory().dir("legal"));
extractLegalResources.setResourcesNames(Arrays.asList("LICENSE.txt", "NOTICE.txt"));
extractLegalResources.property("version", project.getVersion().toString());
GeneratePropertiesResource generateInfo = project.getTasks().create("generateSpringBootInfo",
GeneratePropertiesResource.class);
generateInfo.getDestinationDirectory().set(project.getLayout().getBuildDirectory().dir("info"));
generateInfo.getPropertiesFileName().set(SPRING_BOOT_PROPERTIES_FILE);
generateInfo.property("version", project.getVersion().toString());
project.getTasks().withType(Jar.class, (jar) -> project.afterEvaluate(
(evaluated) -> jar.metaInf((metaInf) -> metaInf.from(extractLegalResources, generateInfo))));
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
Set<String> sourceJarTaskNames = sourceSets.stream().map(SourceSet::getSourcesJarTaskName)
.collect(Collectors.toSet());
Set<String> javadocJarTaskNames = sourceSets.stream().map(SourceSet::getJavadocJarTaskName)
.collect(Collectors.toSet());
project.getTasks().withType(Jar.class, (jar) -> project.afterEvaluate((evaluated) -> {
jar.metaInf((metaInf) -> metaInf.from(extractLegalResources));
jar.manifest((manifest) -> {
Map<String, Object> attributes = new TreeMap<>();
attributes.put("Automatic-Module-Name", project.getName().replace("-", "."));
attributes.put("Build-Jdk-Spec", SOURCE_AND_TARGET_COMPATIBILITY);
attributes.put("Built-By", "Spring");
attributes.put("Implementation-Title",
determineImplementationTitle(project, sourceJarTaskNames, javadocJarTaskNames, jar));
attributes.put("Implementation-Version", project.getVersion());
manifest.attributes(attributes);
});
}));
}
private String determineImplementationTitle(Project project, Set<String> sourceJarTaskNames,

10
buildSrc/src/test/java/org/springframework/boot/build/ConventionsPluginTests.java
View File

@ -83,7 +83,6 @@ class ConventionsPluginTests {
try (JarFile jar = new JarFile(file)) {
assertThatLicenseIsPresent(jar);
assertThatNoticeIsPresent(jar);
assertThatSpringBootPropertiesIsPresent(jar);
Attributes mainAttributes = jar.getManifest().getMainAttributes();
assertThat(mainAttributes.getValue("Implementation-Title"))
.isEqualTo("Test project for manifest customization");
@ -113,7 +112,6 @@ class ConventionsPluginTests {
try (JarFile jar = new JarFile(file)) {
assertThatLicenseIsPresent(jar);
assertThatNoticeIsPresent(jar);
assertThatSpringBootPropertiesIsPresent(jar);
Attributes mainAttributes = jar.getManifest().getMainAttributes();
assertThat(mainAttributes.getValue("Implementation-Title"))
.isEqualTo("Source for " + this.projectDir.getName());
@ -143,7 +141,6 @@ class ConventionsPluginTests {
try (JarFile jar = new JarFile(file)) {
assertThatLicenseIsPresent(jar);
assertThatNoticeIsPresent(jar);
assertThatSpringBootPropertiesIsPresent(jar);
Attributes mainAttributes = jar.getManifest().getMainAttributes();
assertThat(mainAttributes.getValue("Implementation-Title"))
.isEqualTo("Javadoc for " + this.projectDir.getName());
@ -168,13 +165,6 @@ class ConventionsPluginTests {
assertThat(noticeContent).doesNotContain("${");
}
private void assertThatSpringBootPropertiesIsPresent(JarFile jar) throws IOException {
JarEntry properties = jar.getJarEntry("META-INF/spring-boot.properties");
assertThat(properties).isNotNull();
String content = FileCopyUtils.copyToString(new InputStreamReader(jar.getInputStream(properties)));
assertThat(content).contains("version=");
}
@Test
void testRetryIsConfiguredWithThreeRetriesOnCI() throws IOException {
try (PrintWriter out = new PrintWriter(new FileWriter(this.buildFile))) {

19
spring-boot-project/spring-boot/build.gradle
View File

@ -153,7 +153,26 @@ task extractTomcatConfigProperties(type: Sync) {
}
}
def syncJavaTemplates = tasks.register("syncJavaTemplates", Sync) {
from("src/main/javaTemplates")
into("build/generated-sources/main")
def properties = ["springBootVersion": project.version]
expand(properties)
inputs.properties(properties)
}
plugins.withType(EclipsePlugin) {
eclipse {
synchronizationTasks syncJavaTemplates
}
}
sourceSets {
main {
java {
srcDirs syncJavaTemplates
}
}
test {
output.dir(tomcatConfigProperties, builtBy: "extractTomcatConfigProperties")
}

28
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/SpringBootVersion.java → spring-boot-project/spring-boot/src/main/javaTemplates/org/springframework/boot/SpringBootVersion.java
View File

@ -16,18 +16,9 @@
package org.springframework.boot;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* Exposes the Spring Boot version.
*
* The version information is read from a file that is stored in the Spring Boot library.
* If the version information cannot be read from the file, consider using a
* reflection-based check instead (for example, checking for the presence of a specific
* Spring Boot method that you intend to call).
*
* @author Drummond Dawson
* @author Hendrig Sellik
* @author Andy Wilkinson
@ -40,24 +31,11 @@ public final class SpringBootVersion {
}
/**
* Return the full version string of the present Spring Boot codebase, or {@code null}
* if it cannot be determined.
* @return the version of Spring Boot or {@code null}
* Return the full version string of the present Spring Boot codebase.
* @return the version of Spring Boot
*/
public static String getVersion() {
InputStream input = SpringBootVersion.class.getClassLoader()
.getResourceAsStream("META-INF/spring-boot.properties");
if (input != null) {
try {
Properties properties = new Properties();
properties.load(input);
return properties.getProperty("version");
}
catch (IOException ex) {
// fall through
}
}
return null;
return "${springBootVersion}";
}
}

56
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/SpringBootVersionTests.java Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright 2012-2022 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.
*/
package org.springframework.boot;
import java.io.File;
import java.io.IOException;
import org.junit.jupiter.api.Test;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link SpringBootVersion}.
*
* @author Andy Wilkinson
*/
public class SpringBootVersionTests {
@Test
void getVersionShouldReturnVersionMatchingGradleProperties() throws IOException {
String expectedVersion = PropertiesLoaderUtils.loadProperties(new FileSystemResource(findGradleProperties()))
.getProperty("version");
assertThat(SpringBootVersion.getVersion()).isEqualTo(expectedVersion);
}
private File findGradleProperties() {
File current = new File(".").getAbsoluteFile();
while (current != null) {
File gradleProperties = new File(current, "gradle.properties");
System.out.println(gradleProperties);
if (gradleProperties.isFile()) {
return gradleProperties;
}
current = current.getParentFile();
}
throw new IllegalStateException("Could not find gradle.properties");
}
}