Spring From the Trenches:Zurückgeben von Git-Commit-Informationen als JSON
Es gibt Situationen, in denen wir die genaue Version unserer Webanwendung kennen müssen, die auf einem Remote-Server bereitgestellt wird. Ein Kunde möchte beispielsweise wissen, ob wir bereits eine Fehlerkorrektur auf dem Server X bereitgestellt haben.
Wir können natürlich versuchen, diese Frage mit der "traditionellen" Methode zu beantworten. Das Problem ist folgendes:
- Niemand kann sich erinnern, wer den Server X aktualisiert hat oder wann er aktualisiert wurde.
- Die Person, die es aktualisiert hat, kann sich nicht erinnern, welches der letzte Commit war, der in den Build aufgenommen wurde.
Mit anderen Worten, wir sind am Arsch. Wir können versuchen zu testen, ob der Fehler noch auf dem Server X vorhanden ist, aber das hilft uns nicht wirklich, da unsere Fehlerbehebung möglicherweise nicht funktioniert.
Dieser Blogbeitrag beschreibt, wie wir dieses Problem lösen können. Beginnen wir damit, den Build-Time-Status unseres Git-Repositorys zu extrahieren.
Extrahieren des Build-Time-Status unseres Git-Repositorys
Wir können den Build-Time-Status unseres Git-Repositorys mithilfe des Maven Git Commit Id-Plugins extrahieren. Lassen Sie uns herausfinden, wie wir das Maven Git Commit Id-Plugin konfigurieren und die extrahierten Informationen zu einer Eigenschaftendatei hinzufügen können.
Zuerst , müssen wir den Speicherort unseres Ressourcenverzeichnisses konfigurieren und sicherstellen, dass die in unseren Eigenschaftendateien gefundenen Eigenschaftsplatzhalter durch die tatsächlichen Eigenschaftswerte ersetzt werden. Wir können dies tun, indem wir das folgende XML zum Build hinzufügen Abschnitt unserer pom.xml Datei:
<resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> <includes> <include>**/*.properties</include> </includes> </resource> </resources>Zweite , müssen wir das Maven Git Commit Id-Plugin konfigurieren. Wir können dies tun, indem wir diesen Schritten folgen:
- Fügen Sie das Maven Git Commit Id-Plugin zu unserem Build hinzu.
- Stellen Sie sicher, dass die Überarbeitung Das Ziel des Maven Git Commit Id-Plugins wird beim Initialisieren aufgerufen Phase des Standardlebenszyklus.
- Konfigurieren Sie den Speicherort der .git Verzeichnis.
Wir müssen das folgende XML zu den Plugins hinzufügen Abschnitt der pom.xml Datei:
<plugin>
<groupId>pl.project13.maven</groupId>
<artifactId>git-commit-id-plugin</artifactId>
<version>2.1.13</version>
<!--
Ensure that the revision goal is invoked during the initialize
phase.
-->
<executions>
<execution>
<goals>
<goal>revision</goal>
</goals>
</execution>
</executions>
<configuration>
<!--
Configure the location of the .git directory.
-->
<dotGitDirectory>${project.basedir}/../.git</dotGitDirectory>
</configuration>
</plugin>
Dritter , müssen wir die Eigenschaftendatei erstellen, die die Informationen enthält, die aus unserem Git-Repository extrahiert werden. Die application.properties Datei sieht wie folgt aus:
git.tags=${git.tags}
git.branch=${git.branch}
git.dirty=${git.dirty}
git.remote.origin.url=${git.remote.origin.url}
git.commit.id=${git.commit.id}
git.commit.id.abbrev=${git.commit.id.abbrev}
git.commit.id.describe=${git.commit.id.describe}
git.commit.id.describe-short=${git.commit.id.describe-short}
git.commit.user.name=${git.commit.user.name}
git.commit.user.email=${git.commit.user.email}
git.commit.message.full=${git.commit.message.full}
git.commit.message.short=${git.commit.message.short}
git.commit.time=${git.commit.time}
git.build.user.name=${git.build.user.name}
git.build.user.email=${git.build.user.email}
git.build.time=${git.build.time}
Wir haben jetzt das Maven Git Commit Id-Plugin konfiguriert. Wenn wir unser Projekt kompilieren, werden die Eigenschaftsplatzhalter aus application.properties gefunden Datei werden durch die tatsächlichen Eigenschaftswerte ersetzt, die aus unserem Git-Repository extrahiert werden.
Die application.properties Datei aus target/classes gefunden Verzeichnis sieht wie folgt aus:
git.tags= git.branch=master git.dirty=true [email protected]:pkainulainen/spring-from-the-trenches.git git.commit.id=1bdfe9cf22b550a3ebe170f60df165e5c26448f9 git.commit.id.abbrev=1bdfe9c git.commit.id.describe=1bdfe9c-dirty git.commit.id.describe-short=1bdfe9c-dirty git.commit.user.name=Petri Kainulainen [email protected] git.commit.message.full=Declare PropertySourcesPlaceholderConfigurer in a static @Bean method git.commit.message.short=Declare PropertySourcesPlaceholderConfigurer in a static @Bean method git.commit.time=16.04.2015 @ 23:35:23 EEST git.build.user.name=Petri Kainulainen [email protected] git.build.time=18.04.2015 @ 17:07:55 EEST
Lassen Sie uns weitermachen und herausfinden, wie wir die Git-Commit-Informationen in Eigenschaften-Beans einfügen können.
Einfügen der Git-Commit-Informationen in Eigenschaften-Beans
Wir müssen drei Eigenschaften-Bean-Klassen erstellen, die im Folgenden beschrieben werden:
- Die BuildProperties Klasse enthält Informationen über die Person, die den Build gestartet hat.
- Die CommitProperties Klasse enthält Informationen über den letzten Commit, der im Build enthalten ist.
- Die GitProperties Klasse enthält einige "gemeinsame" Eigenschaften wie branch , Tags und remoteOriginUrl . Es enthält auch Verweise auf BuildProperties und CommitProperties Objekte.
Zuerst , müssen wir die BuildProperties erstellen Klasse. Diese Klasse hat die Endzeit , Benutzer-E-Mail und Benutzername Felder. Die eigentlichen Feldwerte werden mithilfe der Konstruktorinjektion in diese Felder eingefügt. Der Quellcode der BuildProperties Klasse sieht wie folgt aus:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class BuildProperties {
private final String time;
private final String userEmail;
private final String userName;
@Autowired
public BuildProperties(@Value("${git.build.time}") String time,
@Value("${git.build.user.email}") String userEmail,
@Value("${git.build.user.name}") String userName) {
this.time = time;
this.userEmail = userEmail;
this.userName = userName;
}
//Getters are omitted for the sake of clarity
}
Zweite , müssen wir die CommitProperties erstellen Klasse. Diese Klasse hat die abschließende Beschreibung , describeShort , vollständige Nachricht , Kennung , idAbbrev , shortMessage , Zeit , Benutzer-E-Mail und Benutzername Felder. Die eigentlichen Eigenschaftswerte werden mithilfe der Konstruktorinjektion in diese Felder eingefügt. Der Quellcode der CommitProperties Klasse sieht wie folgt aus:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class CommitProperties {
private final String describe;
private final String describeShort;
private final String fullMessage;
private final String id;
private final String idAbbrev;
private final String shortMessage;
private final String time;
private final String userEmail;
private final String userName;
@Autowired
public CommitProperties(@Value("${git.commit.id.describe}") String describe,
@Value("${git.commit.id.describe-short}") String describeShort,
@Value("${git.commit.message.full}") String fullMessage,
@Value("${git.commit.id}") String id,
@Value("${git.commit.id.abbrev}") String idAbbrev,
@Value("${git.commit.message.short}") String shortMessage,
@Value("${git.commit.time}") String time,
@Value("${git.commit.user.email}") String userEmail,
@Value("${git.commit.user.name}") String userName) {
this.describe = describe;
this.describeShort = describeShort;
this.fullMessage = fullMessage;
this.id = id;
this.idAbbrev = idAbbrev;
this.shortMessage = shortMessage;
this.time = time;
this.userEmail = userEmail;
this.userName = userName;
}
//Getters are omitted for the sake of clarity
}
Dritter , müssen wir die GitProperties erstellen Klasse. Diese Klasse hat den letzten Zweig , erstellen , übernehmen , schmutzig , remoteOriginUrl und Tags Felder. Die eigentlichen Feldwerte (oder Objekte) werden mithilfe der Konstruktorinjektion in diese Felder eingefügt. Der Quellcode der GitProperties Klasse sieht wie folgt aus:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class GitProperties {
private String branch;
private final BuildProperties build;
private final CommitProperties commit;
private final boolean dirty;
private final String remoteOriginUrl;
private final String tags;
@Autowired
public GitProperties(@Value("${git.branch}") String branch,
BuildProperties build,
CommitProperties commit,
@Value("${git.dirty}") boolean dirty,
@Value("${git.remote.origin.url}") String remoteOriginUrl,
@Value("${git.tags}") String tags) {
this.branch = branch;
this.build = build;
this.commit = commit;
this.dirty = dirty;
this.remoteOriginUrl = remoteOriginUrl;
this.tags = tags;
}
//Getters are omitted for the sake of clarity
}
Fahren wir fort und schreiben die Git-Commit-Informationen in eine Protokolldatei.
Schreiben der Git-Commit-Informationen in eine Protokolldatei
Unser nächster Schritt besteht darin, die Git-Commit-Informationen in eine Protokolldatei zu schreiben. Lassen Sie uns herausfinden, wie wir das tun können.
Zuerst , müssen wir toString() hinzufügen Methoden zu BuildProperties , CommitProperties und GitProperties Klassen und implementieren Sie diese Methoden mithilfe von ToStringBuilder Klasse.
Der Quellcode der BuildProperties Klasse sieht wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class BuildProperties {
private final String time;
private final String userEmail;
private final String userName;
@Autowired
public BuildProperties(@Value("${git.build.time}") String time,
@Value("${git.build.user.email}") String userEmail,
@Value("${git.build.user.name}") String userName) {
this.time = time;
this.userEmail = userEmail;
this.userName = userName;
}
//Getters are omitted for the sake of clarity
@Override
public String toString() {
return new ToStringBuilder(this)
.append("time", this.time)
.append("userEmail", this.userEmail)
.append("userName", this.userName)
.toString();
}
}
Der Quellcode der CommitProperties Klasse sieht wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class CommitProperties {
private final String describe;
private final String describeShort;
private final String fullMessage;
private final String id;
private final String idAbbrev;
private final String shortMessage;
private final String time;
private final String userEmail;
private final String userName;
@Autowired
public CommitProperties(@Value("${git.commit.id.describe}") String describe,
@Value("${git.commit.id.describe-short}") String describeShort,
@Value("${git.commit.message.full}") String fullMessage,
@Value("${git.commit.id}") String id,
@Value("${git.commit.id.abbrev}") String idAbbrev,
@Value("${git.commit.message.short}") String shortMessage,
@Value("${git.commit.time}") String time,
@Value("${git.commit.user.email}") String userEmail,
@Value("${git.commit.user.name}") String userName) {
this.describe = describe;
this.describeShort = describeShort;
this.fullMessage = fullMessage;
this.id = id;
this.idAbbrev = idAbbrev;
this.shortMessage = shortMessage;
this.time = time;
this.userEmail = userEmail;
this.userName = userName;
}
//Getters are omitted for the sake of clarity
@Override
public String toString() {
return new ToStringBuilder(this)
.append("describe", this.describe)
.append("describeShort", this.describeShort)
.append("fullMessage", this.fullMessage)
.append("id", this.id)
.append("idAbbrev", this.idAbbrev)
.append("shortMessage", this.shortMessage)
.append("time", this.time)
.append("userEmail", this.userEmail)
.append("userName", this.userName)
.toString();
}
}
Der Quellcode der GitProperties Klasse sieht wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class GitProperties {
private String branch;
private final BuildProperties build;
private final CommitProperties commit;
private final boolean dirty;
private final String remoteOriginUrl;
private final String tags;
@Autowired
public GitProperties(@Value("${git.branch}") String branch,
BuildProperties build,
CommitProperties commit,
@Value("${git.dirty}") boolean dirty,
@Value("${git.remote.origin.url}") String remoteOriginUrl,
@Value("${git.tags}") String tags) {
this.branch = branch;
this.build = build;
this.commit = commit;
this.dirty = dirty;
this.remoteOriginUrl = remoteOriginUrl;
this.tags = tags;
}
//Getters are omitted for the sake of clarity
@Override
public String toString() {
return new ToStringBuilder(this)
.append("branch", this.branch)
.append("build", this.build)
.append("commit", this.commit)
.append("dirty", this.dirty)
.append("remoteOriginUrl", this.remoteOriginUrl)
.append("tags", this.tags)
.toString();
}
}
Zweite , müssen wir die Git-Commit-Informationen in eine Protokolldatei schreiben, wenn unsere Anwendung gestartet wird. Wir können dies tun, indem wir diesen Schritten folgen:
- Fügen Sie einen statischen finalen Logger hinzu Feld zu den GitProperties Klasse und erstellen Sie einen neuen Logger -Objekt mithilfe der LoggerFactory Klasse.
- Fügen Sie ein writeGitCommitInformationToLog() hinzu -Methode zu den GitProperties Klasse und kommentieren Sie sie mit @PostConstruct Anmerkung. Dadurch wird sichergestellt, dass der Spring-Container diese Methode aufruft, nachdem er die Abhängigkeiten des erstellten Bean-Objekts in ihn eingefügt hat.
- Implementieren Sie writeGitCommitInformationToLog() -Methode, indem die Git-Commit-Informationen in eine Protokolldatei geschrieben werden.
Nachdem wir diese Änderungen vorgenommen haben, wird der Quellcode der GitProperties Klasse sieht wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public class GitProperties {
private static final Logger LOGGER = LoggerFactory.getLogger(GitProperties.class);
private String branch;
private final BuildProperties build;
private final CommitProperties commit;
private final boolean dirty;
private final String remoteOriginUrl;
private final String tags;
@Autowired
public GitProperties(@Value("${git.branch}") String branch,
BuildProperties build,
CommitProperties commit,
@Value("${git.dirty}") boolean dirty,
@Value("${git.remote.origin.url}") String remoteOriginUrl,
@Value("${git.tags}") String tags) {
this.branch = branch;
this.build = build;
this.commit = commit;
this.dirty = dirty;
this.remoteOriginUrl = remoteOriginUrl;
this.tags = tags;
}
//Getters are omitted for the sake of clarity
@Override
public String toString() {
return new ToStringBuilder(this)
.append("branch", this.branch)
.append("build", this.build)
.append("commit", this.commit)
.append("dirty", this.dirty)
.append("remoteOriginUrl", this.remoteOriginUrl)
.append("tags", this.tags)
.toString();
}
@PostConstruct
public void writeGitCommitInformationToLog() {
LOGGER.info("Application was built by using the Git commit: {}", this);
}
}
Wenn wir unsere Webanwendung starten, sollten wir die folgenden Informationen aus ihrer Protokolldatei finden:
INFO - GitProperties - Application was built by using the Git commit: net.petrikainulainen.spring.trenches.config.GitProperties@47044f7d[ branch=master, build=net.petrikainulainen.spring.trenches.config.BuildProperties@7b14c61[ time=19.04.2015 @ 00:47:37 EEST, [email protected], userName=Petri Kainulainen ], commit=net.petrikainulainen.spring.trenches.config.CommitProperties@8fcc534[ describe=1bdfe9c-dirty, describeShort=1bdfe9c-dirty, fullMessage=Declare PropertySourcesPlaceholderConfigurer in a static @Bean method, id=1bdfe9cf22b550a3ebe170f60df165e5c26448f9, idAbbrev=1bdfe9c, shortMessage=Declare PropertySourcesPlaceholderConfigurer in a static @Bean method, time=16.04.2015 @ 23:35:23 EEST, [email protected], userName=Petri Kainulainen ], dirty=true, [email protected]:pkainulainen/spring-from-the-trenches.git, tags= ]
Lassen Sie uns herausfinden, wie wir die Git-Commit-Informationen als JSON zurückgeben können.
Git-Commit-Informationen als JSON zurückgeben
Zuvor haben wir eine Controller-Klasse erstellt, die die Laufzeitkonfiguration einer Webanwendung als JSON zurückgibt. Ändern wir diese Klasse so, dass sie die Git-Commit-Informationen als JSON zurückgibt. Wir können dies tun, indem wir diesen Schritten folgen:- Fügen Sie endgültige GitProperties hinzu -Feld an den PropertiesController Klasse.
- Injizieren Sie die GitProperties -Bean in das erstellte Controller-Bean mithilfe der Konstruktorinjektion.
- Erstellen Sie eine Controller-Methode, die GET-Anforderungen verarbeitet, die an die URL „/version“ gesendet werden, und implementieren Sie sie, indem Sie die GitProperties zurückgeben Objekt.
Der Quellcode des PropertiesController sieht wie folgt aus:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
final class PropertiesController {
private final ApplicationProperties applicationProperties;
private final GitProperties gitProperties;
@Autowired
PropertiesController(ApplicationProperties applicationProperties,
GitProperties gitProperties) {
this.applicationProperties = applicationProperties;
this.gitProperties = gitProperties;
}
@RequestMapping(value = "/config", method = RequestMethod.GET)
ApplicationProperties getAppConfiguration() {
return applicationProperties;
}
@RequestMapping(value = "/version", method = RequestMethod.GET)
GitProperties getVersion() {
return gitProperties;
}
}
Wenn wir eine GET-Anfrage an die URL „/version“ senden, gibt unsere Controller-Methode den folgenden JSON-Code zurück:
{
"branch":"master",
"build":{
"time":"19.04.2015 @ 00:47:37 EEST",
"userEmail":"[email protected]",
"userName":"Petri Kainulainen"
},
"commit":{
"describe":"1bdfe9c-dirty",
"describeShort":"1bdfe9c-dirty",
"fullMessage":"Declare PropertySourcesPlaceholderConfigurer in a static @Bean method",
"id":"1bdfe9cf22b550a3ebe170f60df165e5c26448f9",
"idAbbrev":"1bdfe9c",
"shortMessage":"Declare PropertySourcesPlaceholderConfigurer in a static @Bean method",
"time":"16.04.2015 @ 23:35:23 EEST",
"userEmail":"[email protected]",
"userName":"Petri Kainulainen"
},
"dirty":true,
"remoteOriginUrl":"[email protected]:pkainulainen/spring-from-the-trenches.git",
"tags":""
}
Wir sollten nicht jedem erlauben, auf die Git-Commit-Informationen unserer Anwendung zuzugreifen. Wenn dies eine reale Anwendung wäre, sollten wir sicherstellen, dass nur Administratoren auf diese Informationen zugreifen können. Fahren wir fort und fassen zusammen, was wir aus diesem Blogbeitrag gelernt haben.
Zusammenfassung
Dieser Blogbeitrag hat uns drei Dinge gelehrt:
- Wir können den Build-Time-Status aus einem Git-Repository extrahieren, indem wir das Maven Git Commit Id-Plugin verwenden.
- Wir können die Git-Commit-Informationen in eine Protokolldatei schreiben, indem wir toString() überschreiben Methoden der Eigenschaften-Bean-Klassen und Schreiben der Eigenschaftswerte dieser Beans in eine Protokolldatei, nachdem die Eigenschaftswerte in sie eingefügt wurden.
- Wir können die Git-Commit-Informationen als JSON zurückgeben, indem wir eine Controller-Methode erstellen, die das „Root“-Properties-Bean-Objekt zurückgibt (GitProperties ).
P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github herunterladen.
