Spring / Java-Fehler: Namespace-Element 'annotation-config'… unter JDK 1.5 und höher

70

Ich habe Spring / Java App, die mit Compiler Compliance Level 1.5 kompiliert wurde .

Ich habe ein neues Linux-Setup, in dem ich Apache Tomcat 8.0.8 heruntergeladen habe .

Ich habe JDK 8u5 heruntergeladen .

Ich habe den Pfad in bash wie folgt festgelegt:

PATH=$PATH:$HOME/jdk1.8.0_05/bin
export PATH

Java-Versionsberichte:

java version "1.8.0_05"
Java(TM) SE Runtime Environment (build 1.8.0_05-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)

Und in setnenv.sh (für Tomcat) eingestellt:

JDK_HOME=/home/userid/jdk1.8.0_05

Wenn ich meine WAR-Datei bereitstelle, wird der folgende Fehler angezeigt. Ich denke, Tomcat scheint das von mir installierte Java nicht zu verwenden. Ich habe die Setup-Anweisungen befolgt. PS: Ich habe auch JRE anstelle von JDK und das gleiche Problem ausprobiert.

22-May-2014 11:34:54.070 INFO [http-nio-8080-exec-4] org.apache.catalina.core.ApplicationContext.log Initializing Spring root WebApplicationContext
22-May-2014 11:34:54.512 SEVERE [http-nio-8080-exec-4] org.apache.catalina.core.StandardContext.listenerStart Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener
 org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsing XML document from file [/home/userid/apache-tomcat-8.0.8/webapps/myApplication-QA/WEB-INF/classes/config/spring/securityContext.xml]; nested exception is **java.lang.IllegalStateException: Context namespace element 'annotation-config' and its parser class [org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser] are only available on JDK 1.5 and higher**
    at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:420)
    at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:342)
    at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:310)
    at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:143)
    at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:178)
    at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:149)
    at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:124)
    at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:92)
    at org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory(AbstractRefreshableApplicationContext.java:123)
    at org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory(AbstractApplicationContext.java:423)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:353)
    at org.springframework.web.context.ContextLoader.createWebApplicationContext(ContextLoader.java:255)
    at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:199)
    at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:45)
    at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4750)
    at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5170)
    at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)
    at org.apache.catalina.manager.ManagerServlet.start(ManagerServlet.java:1270)
    at org.apache.catalina.manager.HTMLManagerServlet.start(HTMLManagerServlet.java:673)
    at org.apache.catalina.manager.HTMLManagerServlet.doPost(HTMLManagerServlet.java:221)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:644)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:725)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:301)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
    at org.apache.catalina.filters.CsrfPreventionFilter.doFilter(CsrfPreventionFilter.java:213)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:239)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
    at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:239)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
    at org.apache.catalina.filters.SetCharacterEncodingFilter.doFilter(SetCharacterEncodingFilter.java:108)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:239)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
    at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:219)
    at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:106)
    at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:615)
    at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:136)
    at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:78)
    at org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:610)
    at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:88)
    at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:526)
    at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1033)
    at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:652)
    at org.apache.coyote.http11.Http11NioProtocol$Http11ConnectionHandler.process(Http11NioProtocol.java:222)
    at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1566)
    at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.run(NioEndpoint.java:1523)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
    at java.lang.Thread.run(Unknown Source)
Caused by: java.lang.IllegalStateException: Context namespace element 'annotation-config' and its parser class [org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser] are only available on JDK 1.5 and higher
    at org.springframework.context.config.ContextNamespaceHandler$1.parse(ContextNamespaceHandler.java:65)
    at org.springframework.beans.factory.xml.NamespaceHandlerSupport.parse(NamespaceHandlerSupport.java:69)
    at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1253)
    at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1243)
    at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:135)
    at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:92)
    at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(XmlBeanDefinitionReader.java:507)
    at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:398)
    ... 49 more

22-May-2014 11:34:54.518 INFO [http-nio-8080-exec-4] org.apache.catalina.core.ApplicationContext.log Closing Spring root WebApplicationContext
java  spring  illegalstateexception 
— user3665944
quelle
1
Versuchen Sie in setenv.sh: JAVA_HOME = / home / userid / jdk1.8.0_05
— Andrei Stefan
1
Danke Stefan, das habe ich versucht und trotzdem kein Glück. Übrigens: Beim Tomcat-Start komme ich unten. bash startup.sh Verwenden von CATALINA_BASE: /home/userid/apache-tomcat-8.0.8 Verwenden von CATALINA_HOME: /home/userid/apache-tomcat-8.0.8 Verwenden von CATALINA_TMPDIR: /home/userid/apache-tomcat-8.0.8/ temp Verwenden von JRE_HOME: /home/userid/jdk1.8.0_05 Verwenden von CLASSPATH: /home/userid/apache-tomcat-8.0.8/bin/bootstrap.jar:/home/userid/apache-tomcat-8.0.8/bin/ tomcat-juli.jar Verwenden von CATALINA_PID: /home/userid/apache-tomcat-8.0.8/tomcat.pid Tomcat wurde gestartet.
— user3665944
Sie verwenden Spring 2.5?
— Andrei Stefan
Ja, das ist eine alte App.
— user3665944
1
@AndreiStefan ersetze jdk1.8 ... durch ein jdk 5, 6 oder 7. Danke, dass du mich in die richtige Richtung gelenkt hast. Ich bin auf dieses Problem gestoßen, weil zwei Apps auf demselben Computer ausgeführt wurden - eine, die Java 8 erfordert, und eine alte, die vom Frühjahr 2.5 abhängt
— 11.

Antworten:

142

Die Klasse, die die Ausnahme auslöst, verwendet diesen Code, um nach der Java-Version zu suchen:

static {
        javaVersion = System.getProperty("java.version");
        // version String should look like "1.4.2_10"
        if (javaVersion.indexOf("1.7.") != -1) {
            majorJavaVersion = JAVA_17;
        }
        else if (javaVersion.indexOf("1.6.") != -1) {
            majorJavaVersion = JAVA_16;
        }
        else if (javaVersion.indexOf("1.5.") != -1) {
            majorJavaVersion = JAVA_15;
        }
        else {
            // else leave 1.4 as default (it's either 1.4 or unknown)
            majorJavaVersion = JAVA_14;
        }
    }

Als Spring 2.5 zum ersten Mal veröffentlicht wurde, ging der Code nicht davon aus, dass es in einer Java-Version ausgeführt wird, die später als 1.7 ist. Für Java 8 und höher wird für den obigen Code die Standardversion 1.4 angenommen. Aus diesem Grund wird sich der Anmerkungsteil beschweren.

Ich denke, Sie müssen entweder Ihre Spring-Version aktualisieren oder Java 7 verwenden. Spring 2.5 ist sowieso schon seit einiger Zeit EOLed .

— Andrei Stefan
quelle
3
Stefan, das war es. Ich habe JRE 1.7 heruntergeladen und alles ist gut. Danke für deine Hilfe. Robert
— user3665944
1
Es scheint, als ob die Unterstützung für Java 8 in Spring> = 3.2.3 hinzugefügt wurde. Siehe die Codeänderung in JdkVersion.class.
— djule5
1
Puh, diese Lösung war einfacher als ich befürchtet hatte. Vielen Dank!
— Pieter De Bie
Das hat mir viele Kopfschmerzen erspart, danke!
— Richard H
19

Ich habe das ähnliche Problem. Die alte Spring MVC / Spring Faces-Anwendung unter Spring 2.5.5 läuft nicht unter Java 8.

Ich habe einige Tage damit verbracht, nach einer Lösung zu suchen, da wir Java 8 ausführen müssen.

Die erste Idee war: das komplette Spring-Paket auf 4.1.6 zu aktualisieren. Ich habe Maven benutzt. Problem dieser Methode ist, dass danach fast das gesamte Projekt überarbeitet werden muss. Dies liegt daran, dass beispielsweise in Spring 4 die JSF-Implementierung entfernt wurde und einige spezielle Taglibs vollständig entfernt wurden, wie z <sf:..>. Und es gab einige größere und kleinere Probleme mit Konfiguration, Adaptern, Handlern, Zuordnungen ...

Der zweite Ansatz bestand darin, Spring JARs teilweise zu ersetzen. Wieder kein Erfolg. Es ist unmöglich, ein Glas zu ersetzen, ohne Abhängigkeiten zu berühren.

Ich glaube, dass ich nach einigen Wochen oder Monaten des Kampfes mit beiden Ansätzen Erfolg haben kann. Aber hab nicht so viel Zeit. Und ich habe aufgegeben. Meine Lösung ist:

Ich habe die Quelldatei JdkVersion.java aus dem Paket org.springframework.core gefunden. http://www.java2s.com/Code/Jar/o/Downloadorgspringframeworkcoresources300releasejar.htm . Ich habe in meinem Projekt das Paket org.springframework.core mit nur einer Klasse JdkVersion erstellt. Danach wurde der Code einfach geändert, um die Java 8-Version zu überprüfen. So etwas:

public static final int JAVA_18 = 5;

...

        javaVersion = System.getProperty("java.version");
    // version String should look like "1.4.2_10"
    if (javaVersion.contains("1.8.")) {
        majorJavaVersion = JAVA_18;         
        System.out.println("JAVA_VERSION: "+javaVersion);

    } else if (javaVersion.contains("1.7.")) {
        majorJavaVersion = JAVA_17;
    }

Selbst diese Codeänderung ist nicht wirklich notwendig, nur zum Spaß. Dies liegt daran, dass diese Quelle aus dem Spring 3.0.0-Paket stammt, in dem Spring-Leute bereits die Java-Versionsprüfung geändert haben. Versionen höher als 7 gelten nicht als altes Java.

Jetzt startet die Anwendung ordnungsgemäß. Es ruft die JdkVersion-Klasse aus meinem Projekt anstelle von jar auf.

Funktioniert soweit! Vielen Dank für alles aus diesem Thread, der diese Idee gegeben hat.

Vielen Dank

— Dmitry
quelle
1
Ich habe diesen Ansatz an mein Projekt angepasst, das mehrere Module / Teilprojekte enthält. Also habe ich in meinem Serververzeichnis nach der Datei spring-xxx-version.jar gesucht (ich habe Tomcat verwendet). Ich habe der Datei spring-xxx-version.jar eine JdkVersion.class hinzugefügt (die wie oben beschrieben nach Java 8 sucht) und den Server neu gestartet. das hat mein Problem behoben.
— Pushya
1
Das ist auch gut so, Sie haben gerade originale Frühlingsgläser geflickt. Auf jeden Fall ist diese Version des Frühlings außer Betrieb.
— Dmitry
15

Ich muss Spring 2.5.5 unter Java 8 unterstützen, daher habe ich den Ansatz aus dieser Antwort verwendet , um einen zukunftssicheren Drop-In-Ersatz für JdkVersion.classso wenig Nebenwirkungen wie möglich bereitzustellen (niemand anderes hat eine vollständige Klasse veröffentlicht, und ich habe es nicht getan Ich möchte die andere Antwort nicht entführen. Es ist nicht erforderlich, nach Java 8 zu suchen. Standardmäßig wird Java 7 verwendet. Dies ist die höchste Version, die der Klasse am Herzen liegt:

Extrahieren Sie die JAR-Datei:

mkdir spring
cd spring
jar xvf ../spring.jar

Überprüfen Sie die Spring-Version in META-INF/MANIFEST.MF(Sie sollten so etwas sehen version=2.5.5). Suchen Sie nach der entsprechenden Version von JdkVersion.javaund verwenden Sie diese als Ausgangspunkt (das folgende Beispiel bezieht sich auf Spring 2.5.5 und Sie möchten keine Methodensignaturen von der Version ändern, mit der Sie arbeiten).

Überprüfen Sie die Haupt- und Nebenversion der JdkVersion.classDatei:

javap -verbose org/springframework/core/JdkVersion.class

Wir sehen , dass die Klasse ursprünglich als Ziel kompiliert wurde 48,0 ( suchen , um diese nach oben , so finden wir , dass ist Java 1.4):

Classfile /tmp/spring/org/springframework/core/JdkVersion.class
  Last modified Jun 23, 2008; size 1286 bytes
  MD5 checksum 98e6ea08ce9186c50cc71d14465fc3dd
  Compiled from "JdkVersion.java"
public abstract class org.springframework.core.JdkVersion
  minor version: 0
  major version: 48
  flags: ACC_PUBLIC, ACC_SUPER, ACC_ABSTRACT
Constant pool:
...

Erstellen Sie org/springframework/core/JdkVersion.javamit folgendem Inhalt:

package org.springframework.core;

public abstract class JdkVersion
{
    public static final int JAVA_13 = 0;
    public static final int JAVA_14 = 1;
    public static final int JAVA_15 = 2;
    public static final int JAVA_16 = 3;
    public static final int JAVA_17 = 4;

    private static final String javaVersion;
    private static final int majorJavaVersion;

    static
    {
        javaVersion = System.getProperty("java.version");

        if (javaVersion.indexOf("1.7.") != -1)
        {
            majorJavaVersion = JAVA_17;
        } else if (javaVersion.indexOf("1.6.") != -1) {
            majorJavaVersion = JAVA_16;
        } else if (javaVersion.indexOf("1.5.") != -1) {
            majorJavaVersion = JAVA_15;
        } else if (javaVersion.indexOf("1.4.") != -1) { // new
            majorJavaVersion = JAVA_14;                 // new
        } else {
            majorJavaVersion = JAVA_17;                 // changed from JAVA_14
        }
    }

    public static String getJavaVersion()
    {
        return javaVersion;
    }

    public static int getMajorJavaVersion()
    {
        return majorJavaVersion;
    }

    public static boolean isAtLeastJava14()
    {
        return true;
    }

    public static boolean isAtLeastJava15()
    {
        return getMajorJavaVersion() >= JAVA_15;
    }

    public static boolean isAtLeastJava16()
    {
        return getMajorJavaVersion() >= JAVA_16;
    }
}

Kompilieren Sie dann die neue Klasse als Java 1.4:

javac -source 1.4 org/springframework/core/JdkVersion.java

Sie können die major.minor-Version bei Bedarf wie oben beschrieben erneut überprüfen.

Erstellen Sie die geänderte JAR-Datei (ohne das ursprüngliche Manifest zu überschreiben):

jar Mcf ../spring-modified.jar *

Kopieren Sie die geänderte JAR-Datei nach Bedarf ( spring.jarnach Bedarf).

— vallismortis
quelle
@ SunilShevante Kein Problem, ich bin froh, dass dir das geholfen hat!
— Vallismortis
10 
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>

TO =>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.1.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.1.4.RELEASE</version>
</dependency>

ODER

  1. Klicken Sie mit der rechten Maustaste auf die Projekteigenschaft.
  2. Gehen Sie zu / Klicken Sie auf "Java Build Path".
  3. Wählen Sie die Registerkarte Bibliotheken und doppelklicken Sie auf "JRE System Libry".
  4. Wählen Sie in diesem Popup das JDK 1.7 aus (Wenn Sie JDK 1.7 nicht haben, installieren Sie es zuerst und wählen Sie es dann unter "Ausführungsumgebung" aus).

Eigentum

— MAFAIZ
quelle
5

Ich hatte das gleiche Problem, aber ich habe eine Lösung:

in Ihrer Projektdatei pom.xml ersetzen:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
</dependency>

zum:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.1.4.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.1.4.RELEASE</version>
</dependency>

und verabschieden Sie sich von Ihren Problemen!

Diese beiden Abhängigkeiten sind größtenteils der Ersatz für die erste Abhängigkeit.

— Juan David Grisales Garzon
quelle
3

Ich bin zufällig ein weiterer unglücklicher Benutzer eines sehr alten Projekts (entwickelt im Jahr 2008!), Das immer noch Spring 2.5 verwendet. Und es ist auch kein Maven-Projekt, daher dauerte das Upgrade auf spätere Versionen von Spring lange, da Abhängigkeiten fehlschlugen und Buildfehler auftraten. Ich habe Tomcat JRE auf 1.7 herabgestuft und es hat gut funktioniert.

Nur dokumentieren, wie das in Eclipse gemacht wird, falls jemand Hilfe benötigt:

  1. Wenn Sie Java 7 noch nicht haben, laden Sie JDK 7 herunter und installieren Sie es wie folgt C:\Program Files\Java\jdk1.7.0_71

  2. Gehen Sie dann zu Eclipse und doppelklicken Sie auf Servers > Tomcat vX.Y server

  3. Klicken Sie Runtime Environmentdann aufInstalled JREs

  4. Dann Add> Standard VMund klicken Next. Sie sehen ein Fenster wie dieses:

    Hinzufügen einer neuen JRE

  5. Klicken Sie auf Directory...und navigieren Sie zu dem Ordner, in dem Sie das JDK installiert haben (dh C:\Program Files\Java\jdk1.7.0_71JDK ist in Ordnung, JRE ist nicht erforderlich). Klicken Sie auf Finish.

  6. Stellen Sie dann sicher, dass Sie die JRE für Java 7 auswählen, und schon sind Sie fertig.

— arun
quelle
3

Migrieren Sie Ihre Spring-Version von 2.5 auf> = 3.2.3.

Für die Frühjahrsmigration müssen Sie folgende Änderungen vornehmen:

1) Entfernen Sie in Ihrer pom.xml die Abhängigkeit für Spring 2.5.6 und fügen Sie die Abhängigkeit für Spring New Version hinzu.

2) Aktualisieren Sie 'xsi: schemaLocation' im Beans-Tag der Datei applicationcontet.xml Ihres Projekts.

Aktualisieren Sie beispielsweise http://www.springframework.org/schema/beans/spring-beans-2.5.xsd auf http://www.springframework.org/schema/beans/spring-beans-3.2.xsd für das Frühjahr 3.2.3 Ausführung.

3) Bereinigen, erstellen und implementieren Sie Ihr Projekt erneut.

— Amandeep Singh Bhatia
quelle
2

Ich stand vor dem gleichen Problem. Nachdem ich mich sehr bemüht hatte, stellte ich fest, dass dies auf die Verwendung von Java 1.8 zurückzuführen ist. Ich habe es auf 1.6 geändert und es hat funktioniert.

— Vikash Singh
quelle
2

Obwohl diese Antwort perfekt beantwortet wurde, ist es in einigen Fällen nicht erwünscht oder möglich, die Java-Version oder die Spring-Version zu aktualisieren.

In unserem Fall müssen wir JDK 8 verwenden, um mit Sonar (von Jenkins) kommunizieren zu können, und wir möchten die Spring-Version nicht ändern, da wir nicht über die Testkapazität verfügen, um dieses Upgrade zu testen.

Unsere Lösung bestand darin, die Java-Version beim Erstellen einfach zu überschreiben

-Djava.version=1.6.45
— Dennis van Beek
quelle
2

Ich habe eine vollautomatische Version dieser Antwort erstellt . Bitte lesen Sie diesen Beitrag zuerst für die Feinheiten, die er anspricht.

  • Erstellen Sie eine Ant-Build-Datei mit dem Inhalt unter den Aufzählungszeichen
  • Kopie spring.jarneben der build.xmlDatei
  • Führen Sie das Patch-Ziel aus
  • Wenn Sie fertig sind, wird die Datei gepatcht

build.xml Dateiinhalt:

<project name="spring-patch" default="patch">
    <target name="patch">
        <mkdir dir="src/org/springframework/core"/>
        <get dest="src/org/springframework/core/JdkVersion.java"
                src="http://grepcode.com/file_/repo1.maven.org/maven2/org.springframework/spring/2.5.5/org/springframework/core/JdkVersion.java/?v=source&amp;disposition=attachment" />
        <replace dir="src" value="majorJavaVersion = JAVA_17">
          <replacetoken>majorJavaVersion = JAVA_14</replacetoken>
        </replace>
        <javac srcdir="src" />
        <zip destfile="spring.jar" update="true">
            <fileset dir="src" includes="**/*.class" />
        </zip>
        <delete dir="src" />
    </target>
</project>
— Erik Lievaart
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.