web-dev-qa-db-fra.com

Erreur Spring / Java: élément de l'espace de noms 'annotation-config' ... sur JDK 1.5 et versions supérieures

J'ai Spring/Java App qui est compilé avec niveau de conformité du compilateur 1.5.

J'ai une nouvelle configuration Linux où j'ai téléchargé Apache Tomcat 8.0.8.

J'ai téléchargé JDK 8u5.

Je fixe le chemin dans bash comme suit:

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

Rapports de version Java:

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)

Et définissez dans setnenv.sh (pour Tomcat):

JDK_HOME=/home/userid/jdk1.8.0_05

Lorsque je déploie mon fichier WAR, l'erreur ci-dessous apparaît. Je pense que Tomcat ne semble pas utiliser le Java que j'ai installé. J'ai suivi les instructions d'installation. PS: J'ai aussi essayé le JRE au lieu du JDK et le même problème.

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
javaspringillegalstateexception
66
user3665944

La classe qui lève l'exception utilise ce code pour vérifier Java version:

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;
        }
    }

Ainsi, lors de la première publication de Spring 2.5, le code ne supposait pas qu'il serait exécuté dans une version Java version ultérieure à 1.7. Pour Java 8 et au-delà, le code ci-dessus assumera la version 1.4 par défaut, raison pour laquelle la partie annotations se plaindra.

Je pense que vous devez soit mettre à niveau votre version Spring, soit utiliser Java 7. Spring 2.5 a été supprimé depuis un certain temps déjà, en tout cas.

134
Andrei Stefan

J'ai le même problème. L’ancienne application Spring Spring MVC/Spring Faces sous Spring 2.5.5 ne s’exécute pas sur Java 8.

J'ai passé quelques jours à essayer de trouver une solution car nous devons exécuter Java 8.

La première idée était: mettre à jour le paquet Spring complet jusqu'au 4.1.6. J'ai utilisé Maven. Le problème de cette méthode est qu’il faut ensuite retravailler presque tout le projet. C’est parce que, par exemple, au printemps 4, l’implémentation de JSF a été supprimée et que certaines balises spéciales ont été complètement supprimées, comme <sf:..>. Et il y avait quelques problèmes majeurs et mineurs avec la configuration, les adaptateurs, les gestionnaires, les mappages, etc.

La deuxième approche consistait à remplacer partiellement les JAR Spring.Un par un. Encore une fois pas de succès. Impossible de remplacer un pot sans toucher les dépendances.

Je crois qu'après quelques semaines ou mois de difficultés, je peux réussir dans les deux approches. Mais pas autant de temps. Et j'ai abandonné. Ma solution est:

J'ai trouvé le fichier source JdkVersion.Java du paquet org.springframework.core. http://www.Java2s.com/Code/Jar/o/Downloadorgspringframeworkcoresources300releasejar.htm . J'ai créé le package org.springframework.core dans mon projet avec une seule classe JdkVersion. Après cela fait simple changement du code pour vérifier Java 8. Smth comme ça:

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;
    }

Même ce changement de code n'est pas vraiment nécessaire, mais juste pour le plaisir. C'est parce que cette source est issue du paquet Spring 3.0.0 où les gars de Spring avaient déjà changé le Java. Les versions supérieures à 7 sont pas considéré comme vieux Java.

Maintenant, l'application démarre correctement. Il appelle la classe JdkVersion de mon projet au lieu de jar.

Fonctionne jusqu'à présent! Merci à tous pour ce fil qui a donné cette idée.

Merci

16
Dmitry

Je dois prendre en charge Spring 2.5.5 sur Java 8, alors j’ai utilisé l’approche de cette réponse pour fournir un remplacement immédiat pour JdkVersion.class avec le moins d’effets secondaires possibles (personne d’autre n’a publié un cours complet et je ne voulais pas détourner l’autre réponse). Il n’est pas nécessaire de vérifier Java 8, il suffit simplement de choisir par défaut Java 7, qui est la version la plus élevée dont la classe se souciait:

Extrayez le fichier jar:

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

Vérifiez la version de printemps dans META-INF/MANIFEST.MF (vous devriez voir quelque chose comme version=2.5.5). Recherchez le version appropriée de JdkVersion.Java et utilisez-le comme point de départ (l'exemple ci-dessous concerne Spring 2.5.5 et vous ne souhaitez modifier aucune des signatures de méthode de la version que vous utilisez).

Vérifiez les versions majeure et mineure du JdkVersion.class fichier:

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

Nous voyons que la classe était initialement compilée comme cible 48.0 ( recherche , nous trouvons que 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:
...

Créer org/springframework/core/JdkVersion.Java avec le contenu suivant:

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;
    }
}

Puis compilez la nouvelle classe en tant que Java 1.4:

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

Vous pouvez vérifier la version majeure.minor comme ci-dessus si nécessaire.

Créez le fichier JAR modifié (sans écraser le manifeste d'origine):

jar Mcf ../spring-modified.jar *

Copiez le fichier JAR modifié si nécessaire (sous la forme spring.jar ou selon le cas).

13
vallismortis
<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>

OR

  1. Faites un clic droit sur la propriété du projet.
  2. Allez à/cliquez sur "Chemin de construction Java".
  3. Sélectionnez l'onglet Bibliothèques et double-cliquez sur "JRE System Libry".
  4. Dans cette fenêtre, sélectionnez le JDK 1.7 (si vous n'avez pas le JDK 1.7, commencez par l'installer, puis sélectionnez-le dans "Environnement d'exécution").

Property

11
MAFAIZ

j'ai eu le même problème, mais j'ai une solution:

dans votre fichier de projet pom.xml, remplacez:

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

pour:

<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>

et dire au revoir à vos problèmes !!

Ces deux dépendances sont le remplacement de la première dépendance dans la plupart des cas.

4
Juan David Grisales Garzon

Migrez votre version de printemps de 2.5 à> = 3.2.3.

Pour la migration de printemps, vous devez effectuer les modifications suivantes:

1) Dans votre pom.xml, supprimez la dépendance pour le printemps 2.5.6 et ajoutez une dépendance pour la nouvelle version du printemps.

2) Mettez à jour 'xsi: schemaLocation' dans la balise beans du fichier applicationcontet.xml de votre projet.

par exemple, update http://www.springframework.org/schema/beans/spring-beans-2.5.xsd à http://www.springframework.org/schema/beans/spring -beans-3.2.xsd pour la version printemps 3.2.3.

3) Nettoyez, construisez et redéployez votre projet.

3
Amandeep Singh Bhatia

Je suis un autre utilisateur malheureux d’un très vieux projet (développé en 2008!) Qui utilise toujours Spring 2.5. Et comme ce n’est pas non plus un projet Maven, la mise à niveau vers les versions ultérieures de Spring prenait beaucoup de temps, les dépendances échouant et donnant des erreurs de construction. J'ai rétrogradé Tomcat JRE à 1,7 et cela a bien fonctionné.

Just documenter comment faire cela dans Eclipse au cas où quelqu'un aurait besoin d'aide:

  1. Si vous ne possédez pas déjà Java 7, téléchargez JDK 7 et installez-le quelque part comme C:\Program Files\Java\jdk1.7.0_71

  2. Ensuite, allez sur Eclipse et double-cliquez sur Servers > Tomcat vX.Y server

  3. Cliquer sur Runtime Environment, puis Installed JREs

  4. Alors Add> Standard VM et cliquez sur Next. Vous voyez une fenêtre comme celle-ci:

    Adding a new JRE

  5. Cliquer sur Directory... et naviguez jusqu'au dossier où vous avez installé le JDK (c'est-à-dire C:\Program Files\Java\jdk1.7.0_71. JDK va bien, pas besoin de JRE). Cliquez sur Finish.

  6. Assurez-vous ensuite de sélectionner le JRE pour Java 7 et vous êtes tous ensemble).

3
arun

Je faisais face au même problème. Mais après avoir essayé très dur, j'ai découvert que c'était à cause de l'utilisation de Java 1.8. Je l'ai changé en 1.6 et cela a fonctionné.

2
vikash singh

J'ai créé une version entièrement automatique de cette réponse . S'il vous plaît lire ce poste en premier pour les subtilités qu'il adresse.

  • créer un fichier de construction ant avec le contenu situé sous les puces
  • copie spring.jar à côté de la build.xml fichier
  • lancer la cible du correctif
  • vous avez terminé, le fichier est corrigé

build.xml contenu du fichier:

<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>
2
Erik Lievaart

Même si cette réponse a été parfaitement satisfaite, dans certains cas, il n'est pas souhaité ni possible de mettre à niveau la version Java ou la version Spring).

Dans notre cas, nous devons utiliser JDK 8 pour pouvoir communiquer avec Sonar (de Jenkins) et nous ne souhaitons pas modifier la version de printemps, car nous ne disposons pas de la capacité de test pour tester cette mise à niveau.

Notre solution consistait simplement à remplacer la version Java lors de la construction, en utilisant

-Djava.version=1.6.45
2
Dennis van Beek

J'ai ajouté le support Java 1.8 et Java 1.9 à Spring 2.5. Veuillez remplacer le fichier dans votre bibliothèque tomacat. JdkVersion.class - modifié

télécharger spring.jar

1
Konstantin Kimlaev