Erreur Spring / Java: élément namespace 'annotation-config' ... à partir de JDK 1.5

j'ai le même problème. L'application Old Spring MVC/Spring Faces sous spring 2.5.5 ne fonctionne pas sur Java 8.

j'ai passé quelques jours à essayer de trouver une solution parce que nous avons besoin D'exécuter Java 8.

première idée: mettre à niveau le paquet complet de ressorts jusqu'à 4.1.6. J'ai utilisé Maven. Problème de cette méthode qu'après cela il faut retravailler presque tout le projet. C'est parce que, par exemple, au printemps 4 ont été supprimés mise en œuvre JSF et quelques taglibs spéciaux où complètement enlevé, comme <sf:..> . Et il y avait des problèmes majeurs et mineurs avec la configuration, les adaptateurs, les manipulateurs, les mappages....

la deuxième approche consistait à remplacer partiellement les pots à ressort.Un par un. De nouveau sans succès. Impossible de remplacer n'importe quel pot sans toucher aux dépendances.

je crois qu'après quelques semaines ou des mois de lutte je peux obtenir le succès sur les deux approches. Mais n'ont pas beaucoup de temps. Et j'ai donné jusqu'. Ma solution est:

j'ai trouvé le fichier source JdkVersion.java à partir de org.springframework.package de base. http://www.java2s.com/Code/Jar/o/Downloadorgspringframeworkcoresources300releasejar.htm . J'ai créé org.springframework.paquet de base dans mon projet avec une seule classe JdkVersion. Après cela fait simple modification du code pour vérifier la version Java 8. Qch 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, seulement pour le plaisir.C'est parce que cette source vient du paquet Spring 3.0.0 où les gars de Spring ont déjà modifié la vérification de version Java. Les Versions supérieures à 7 ne sont pas considérées comme de l'ancien java.

maintenant application démarre correctement. Il appelle la classe JdkVersion de mon projet au lieu de jar.

fonctionne jusqu'à présent! Merci pour toutes de ce fil qui a donné cette idée.

Merci

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

ou

1. clic droit sur la propriété du projet.
2. allez à/ cliquez sur"Java Build Path".
3. sélectionnez l'onglet Bibliothèques et double-cliquez sur "JRE System Libry"
4. sélectionnez le JDK 1.7 (si vous n'avez pas JDK 1.7 ,installez-le d'abord, puis sélectionnez-le dans "environnement D'exécution")

j'ai besoin de support pour Spring 2.5.5 sur Java 8, donc j'ai utilisé l'approche de cette réponse pour fournir un drop-in à l'épreuve du futur pour remplacer JdkVersion.class avec le moins d'effets secondaires possibles (personne n'a posté une classe complète, et je ne voulais pas détourner l'autre réponse). Il n'est pas nécessaire de vérifier pour Java 8, simplement par défaut à Java 7, qui est la version la plus élevée dont la classe se souciait:

extraire le fichier jar:

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

Vérifiez la version du ressort dans META-INF/MANIFEST.MF (vous devriez voir quelque chose comme version=2.5.5 ). Consultez la version appropriée de JdkVersion.java et utilisez-la comme point de départ (l'exemple ci-dessous est pour le printemps 2.5.5 et vous ne voulez pas changer les signatures de méthode de la version avec laquelle vous travaillez).

vérifier les versions majeure et mineure du fichier JdkVersion.class :

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

nous voyons que la classe a été compilée à l'origine comme cible 48.0 ( en cherchant , nous trouvons que C'est 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 compiler la nouvelle classe comme Java 1.4:

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

vous pouvez vérifier le major.version mineure à nouveau comme ci-dessus si nécessaire.

Créer de la modification de fichier jar (sans écraser l'original du manifeste):

jar Mcf ../spring-modified.jar *

copier le fichier jar modifié si nécessaire (en tant que spring.jar ou selon le cas).

il se trouve que je suis un autre utilisateur malheureux d'un très vieux projet (développé en 2008!) qui utilise encore le ressort 2.5. Et ce n'est pas un projet Maven non plus, donc la mise à niveau vers des versions plus tardives de Spring a pris beaucoup de temps avec des dépendances défaillantes et donnant des erreurs de construction. J'ai rétrogradé tomcat JRE à 1,7 et ça a bien marché.

je documente juste comment faire ça dans eclipse au cas où quelqu'un a besoin d'aide:

1. Si vous n'avez pas encore Java 7, téléchargez JDK 7 et installez-le quelque part comme C:\Program Files\Java\jdk1.7.0_71

2. puis allez à eclipse et double-cliquez sur Servers > Tomcat vX.Y server

3. cliquez sur Runtime Environment , puis Installed JREs

4. puis Add > Standard VM et cliquez sur Next . Vous voyez une fenêtre comme ceci:

   

5. cliquez sur Directory... et accédez au dossier dans lequel vous avez installé le JDK (i.e. C:\Program Files\Java\jdk1.7.0_71 . JDK va bien, non need for JRE). Cliquez sur Finish .

6. ensuite, assurez-vous de sélectionner le JRE pour Java 7 et vous êtes prêt.

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

pour la migration de printemps, vous devez faire les changements suivants -

1) dans votre pom.xml supprimer la dépendance pour le printemps 2.5.6 et ajouter la dépendance pour le printemps nouvelle version.

2) la mise à Jour "xsi:schemaLocation' dans les fèves de balise de applicationcontet.fichier xml de votre projet.

E. g mise à jour 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 3.2.3 du printemps.

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

je faisais face à la même question. Mais, après avoir essayé très dur, j'ai découvert que c'est à cause de l'utilisation de Java 1.8. Je l'ai changé à 1,6 et ça a marché.

bien que cette réponse ait été parfaitement répondue, dans certains cas, il n'est pas souhaitable ou possible de mettre à jour la version Java ou la version printemps.

dans notre cas, nous devons utiliser JDK 8 pour pouvoir communiquer avec Sonar (de Jenkins) et nous ne voulons pas changer la version de printemps, parce que nous n'avons pas la capacité de test pour tester cette mise à jour.

notre solution était de simplement remplacer la version Java tout en construisant ,en utilisant

-Djava.version=1.6.45

j'ai créé une version entièrement automatique de cette réponse . Veuillez lire que le premier post pour les subtilités qu'il adresse.

• créer un fichier ant avec le contenu ci-dessous les balles
• copie spring.jar à côté de build.xml fichier
• exécuter le patch cible
• vous avez terminé, le fichier est patché

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>

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

dans votre dossier de projet pom.remplacer:

<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 dites au revoir à vos problèmes!!

ces deux dépendances remplacent en grande partie la première dépendance.

j'ai ajouté le support java1.8 et java1.9 au printemps 2.5. S'il vous plaît remplacer fichier dans votre lib tomacat. JdkVersion.changement de classe

télécharger le printemps.jar