Spring/Java error: namespace element 'annotation-config' … on JDK 1.5 and higher

Question

I have Spring/Java App that is compiled with Compiler compliance level 1.5.

I have a new Linux setup where I downloaded Apache Tomcat 8.0.8<

Answer 1

I need to support Spring 2.5.5 on Java 8, so I used the approach from this answer to provide a future-proof drop-in replacement for JdkVersion.class with as few side-effects as possible (nobody else posted a complete class, and I didn't want to hijack the other answer). There is no need to check for Java 8, simply default to Java 7, which is the highest version the class cared about:

Extract the jar file:

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

Check the Spring version in META-INF/MANIFEST.MF (you should see something like version=2.5.5). Look up the appropriate version of JdkVersion.java and use that as a starting point (the example below is for Spring 2.5.5 and you don't want to change any method signatures from the version you're working with).

Check the major and minor version of the JdkVersion.class file:

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

We see that the class was original compiled as target 48.0 (looking this up, we find that is 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:
...

Create org/springframework/core/JdkVersion.java with the following content:

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

Then compile the new class as Java 1.4:

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

You can check the major.minor version again as above if needed.

Create the modified jar file (without overwriting the original manifest):

jar Mcf ../spring-modified.jar *

Copy the modified jar file where needed (as spring.jar or as appropriate).

Answer 2

i had the same problem, but i have a solution:

in your project file pom.xml replace:

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

for:

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

and say good bye to your problems!!

This two dependecies are the replacement for the firts dependency in the most part.

Answer 3

Migrate your spring version from 2.5 to >=3.2.3.

For Spring migration you need to do following changes -

1) In your pom.xml remove dependency for spring 2.5.6 and add dependency for spring new version.

2) Update 'xsi:schemaLocation' in beans tag of applicationcontet.xml file of your project.

e.g update http://www.springframework.org/schema/beans/spring-beans-2.5.xsd to http://www.springframework.org/schema/beans/spring-beans-3.2.xsd for spring 3.2.3 version.

3) Clean,build and re-deploy your project.

Answer 4

I created a fully automatic version of this answer. Please read that post first for the subtleties he addresses.

• create an ant build file with the contents below the bullets
• copy spring.jar next to the build.xml file
• run the patch target
• you are done, the file is patched

build.xml file contents:

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

Answer 5

Even though this answer has been perfectly answered, in some cases it's not desired or possible to upgrade the Java version or the Spring version.

In our case, we have to use JDK 8 to be able to communicate with Sonar (from Jenkins) and we don't want to change the spring-version, because we don't have the test capacity to test this upgrade.

Our solution was to simply override the Java version while building, using

-Djava.version=1.6.45