Die Umgebung ist dieselbe wie in dem Artikel, den ich zuvor geschrieben habe. Vorbereiten der Ausführungsumgebung von Tomcat in der IntelliJ Community
Um es grob zusammenzufassen, sieht es wie folgt aus.
| Art | Software |
|---|---|
| Sprache | Java SE 8 |
| Server-API | JavaEE |
| Log API | Log4j2 |
| IDE | IntelliJ Community |
| Werkzeug erstellen | Gradle |
| Container | Tomcat |
Wenn es sich um ein JavaEE-Projekt handelt, wurde es möglicherweise bereits erstellt. Erstellen Sie jedoch ein Verzeichnis wie folgt.
Erstellen Sie außerdem die Verzeichnisse "classes" und "lib" in WEB-INF.
Fügen Sie den Abhängigkeiten von build.gradle Folgendes hinzu.
dependencies {
//Log4j verfügbar machen
compile group: 'org.apache.logging.log4j', name: 'log4j-api', version: '2.11.1'
compile group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.11.1'
compile group: 'org.apache.logging.log4j', name: 'log4j-web', version: '2.11.1'
}
Wenn Sie ein Protokoll schreiben, ist es schwierig, den vorbereitenden Code jedes Mal zu schreiben. Erstellen Sie daher eine Wrap-Klasse wie folgt. Für den Code habe ich auf den unten stehenden Link verwiesen. Spring MVC kleiner Durchmesser, kleiner Umweg, Protokollierung kleiner Durchmesser
import org.apache.logging.log4j.LogManager;
import java.io.File;
/**
*Führen Sie den Protokollierungsprozess durch
*/
public class Log4j {
private static Log4j logger = null;
private Log4j() {
}
public static synchronized Log4j getInstance() {
if (logger == null) {
logger = new Log4j();
}
return logger;
}
private String getMessage(final String msg) {
String thisClassName = this.getClass().getName();
//Klassennamen abrufen
String SuperClassName = Logger.class.getName();
Thread t = Thread.currentThread();
StackTraceElement[] stackTraceElements = t.getStackTrace();
int pos = 0;
for (StackTraceElement stackTraceElement : stackTraceElements) {
String steClassName = stackTraceElement.getClassName();
if (thisClassName.equals(steClassName) || SuperClassName.equals(steClassName)){
break;
}
pos++;
}
pos += 2;
StackTraceElement m = stackTraceElements[pos];
return m.getClassName() + ":" + m.getMethodName() + "() \n" + msg;
}
private String getErrorMessage(final Exception e) {
StringBuilder sb = new StringBuilder();
StackTraceElement[] st = e.getStackTrace();
if (st != null && st.length > 0) {
sb.append("Class:")
.append(e.getClass().getName())
.append("¥n")
.append("Detail:")
.append(e.getMessage())
.append("¥n");
for (StackTraceElement s : st) {
sb.append(s.toString())
.append("¥n");
}
}
return sb.toString();
}
public void debug(final String msg) {
LogManager.getLogger(this.getClass()).debug(getMessage(msg));
}
public void info(final String msg) {
LogManager.getLogger(this.getClass()).info(getMessage(msg));
}
public void info(final Object obj, final String msg) {
LogManager.getLogger(obj.getClass()).info(msg);
}
public void warn(final String msg) {
LogManager.getLogger(this.getClass()).warn(getMessage(msg));
}
public void error(final Exception e) {
LogManager.getLogger(e.getClass()).error(getErrorMessage(e));
}
public void trace(final String msg) {
LogManager.getLogger(this.getClass()).trace(getMessage(msg));
}
public void fatal(final String msg) {
LogManager.getLogger(this.getClass()).fatal(getMessage(msg));
}
}
Rufen Sie in EndPoint Folgendes auf und verwenden Sie es wie folgt.
Log4j logger = Log4j.getInstance();
logger.info("Schreiben Sie hier den Protokollinhalt");
Die folgenden Protokollebenen werden in log4j vorbereitet, und die Wrap-Methode wird entsprechend definiert.
fatal > error > warn > info > debug > trace
Die log4j2-Konfigurationsdatei wird in einer XML-Datei mit dem Namen "log4j2.xml" beschrieben. In Tomcat können Sie es auch automatisch laden, indem Sie es in den Ordner webapp-> WEB-INF-> classes legen. Hier ist ein Beispiel für das Ausfüllen von log4j2.xml.
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="off">
<Properties>
<Property name="loglayout">[%d{yyyy-MM-dd HH:mm:ss.SSS}], %-5p, %t, %c, %m%n</Property>
</Properties>
<Appenders>
<!--
fileName:Dateiname zur Ausgabe des Protokolls
filePattern:Muster der Dateien, die komprimiert werden sollen, wenn Protokolle gesammelt werden
-->
<RollingFile name="rolling" fileName="./log/webapp.log" filePattern="./log/webapp-%d{yyyy-MM-dd}-%i.zip">
<PatternLayout pattern="${loglayout}"/>
<Policies>
<OnStartupTriggeringPolicy/>
<SizeBasedTriggeringPolicy size="20 MB"/>
<TimeBasedTriggeringPolicy/>
</Policies>
<DefaultRolloverStrategy max="10"/>
</RollingFile>
<Console name="console" target="SYSTEM_OUT">
<PatternLayout pattern="${ptn}" />
</Console>
</Appenders>
<Loggers>
<!--
name:Paketname für die Protokollausgabe
level:Protokollausgangspegel
additivity:Gibt an, ob das obere Protokoll ausgegeben werden soll
-->
<Logger name="Logger" level="info" additivity="true">
<AppenderRef ref="rolling"/>
</Logger>
</Loggers>
</Configuration>
Weitere Informationen finden Sie unter den folgenden Links.
Im Gradle-Projekt befindet sich der relative Pfad direkt unter dem Projekt, also das Dateiverzeichnis
. -> log
In Tomcat ist das Stammverzeichnis des relativen Pfads jedoch der Tomcat-Installationsordner
.-> webapps->
Fügen Sie build.gradle den folgenden Code hinzu.
//laufen, bevor die Kriegsaufgabe ausgeführt wird
war.doFirst {
//Kinderdatei abrufen
java.io.File[] flist = (new java.io.File("./src/main/webapp/WEB-INF/classes")).listFiles();
for(i in flist) {
//Beurteilung des Dateinamens
switch (i.getName()) {
case "log4j2.xml":
//umbenennen
i.renameTo(new java.io.File("./src/main/webapp/WEB-INF/classes/log4j2_test.xml"));
break;
case "log4j2_exe.xml":
i.renameTo(new java.io.File("./src/main/webapp/WEB-INF/classes/log4j2.xml"));
break;
}
}
}
//Nach Ausführung der Kriegsaufgabe ausführen
war.doLast {
java.io.File[] flist = (new java.io.File("./src/main/webapp/WEB-INF/classes")).listFiles();
for(i in flist) {
switch (i.getName()) {
case "log4j2_test.xml":
i.renameTo(new java.io.File("./src/main/webapp/WEB-INF/classes/log4j2.xml"));
break;
case "log4j2.xml":
i.renameTo(new java.io.File("./src/main/webapp/WEB-INF/classes/log4j2_exe.xml"));
break;
}
}
}
Beim Erstellen einer Datei für jede Ausführung von Kriegsaufgaben erkennt git diese nicht als Verwaltungsdatei -> Einstellungen sollten in einer XML vorgenommen werden
Recommended Posts