Error de Spring/Java: elemento de espacio de nombres ''annotation-config''... en JDK 1.5 y superior

illegalstateexception

Question

Tengo la aplicación Spring / Java que se compila con el nivel de cumplimiento del compilador 1.5 .

Tengo una nueva configuración de Linux donde descargué Apache Tomcat 8.0.8 .

Descargué JDK 8u5 .

Establecí el camino en bash de la siguiente manera:

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

Informes de versiones de 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)

Y establecido en setnenv.sh (para Tomcat):

JDK_HOME=/home/userid/jdk1.8.0_05

Cuando despliego mi archivo WAR, obtengo el siguiente error. Creo que Tomcat parece no usar el Java que instalé. He seguido las instrucciones de configuración. PD: También probé JRE en lugar de JDK y el mismo problema.

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

Answer 1

Aunque esta respuesta se ha respondido perfectamente, en algunos casos no es deseable o posible actualizar la versión de Java o la versión de Spring.

En nuestro caso, tenemos que usar JDK 8 para poder comunicarnos con Sonar (de Jenkins) y no queremos cambiar la versión de primavera, porque no tenemos la capacidad de prueba para probar esta actualización.

Nuestra solución fue simplemente anular la versión de Java mientras construimos, usando

-Djava.version=1.6.45

Answer 2

Creé una versión completamente automática de esta respuesta . Por favor, lea esa publicación primero por las sutilezas que aborda.

• crea un archivo de compilación de ant con el contenido debajo de las viñetas
• copie spring.jar junto al archivo build.xml
• ejecutar el objetivo de parche
• ya terminaste, el archivo está parcheado

contenido del archivo build.xml :

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

Estaba enfrentando el mismo problema. Pero, después de intentarlo mucho, descubrí que esto se debe al uso de Java 1.8. Lo cambié a 1.6 y funcionó.

Answer 4

He agregado soporte java1.8 y java1.9 a la primavera 2.5. Por favor reemplace el archivo en su tomacat lib. JdkVersion.class - cambiado

descargar spring.jar

Answer 5

La clase que lanza la excepción está usando este código para verificar la versión de Java:

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

Por lo tanto, cuando se lanzó por primera vez Spring 2.5, el código no asumió que se ejecutará en una versión de Java posterior a 1.7. Para Java 8 y versiones posteriores, el código anterior asumirá la versión 1.4 predeterminada. Debido a esto, la parte de anotaciones se quejará.

Creo que o bien necesitas actualizar tu versión de Spring o usar Java 7. Spring 2.5 ha estado en EOL durante bastante tiempo, de todos modos.

Answer 6

Migre su versión de primavera de 2.5 a> = 3.2.3.

Para la migración de Spring, debe hacer los siguientes cambios:

1) En su pom.xml, elimine la dependencia para la primavera 2.5.6 y agregue la dependencia para la nueva versión de primavera.

2) Actualice ''xsi: schemaLocation'' en la etiqueta beans del archivo applicationcontet.xml de su proyecto.

por ejemplo, actualizar http://www.springframework.org/schema/beans/spring-beans-2.5.xsd a http://www.springframework.org/schema/beans/spring-beans-3.2.xsd para la primavera 3.2.3 versión.

3) Limpia, construye y vuelve a implementar tu proyecto.

Answer 7

Necesito apoyar Spring 2.5.5 en Java 8, así que utilicé el enfoque de esta respuesta para proporcionar un reemplazo JdkVersion.class a prueba de futuro para JdkVersion.class con el JdkVersion.class número posible de efectos secundarios (nadie más publicó una clase completa, y no quería secuestrar la otra respuesta). No es necesario comprobar Java 8, simplemente por defecto a Java 7, que es la versión más alta que le importa a la clase:

Extraiga el archivo jar:

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

Verifique la versión de Spring en META-INF/MANIFEST.MF (debería ver algo como version=2.5.5 ). Busque la versión adecuada de JdkVersion.java y utilícela como punto de partida (el ejemplo siguiente es para Spring 2.5.5 y no desea cambiar ninguna firma de método de la versión con la que está trabajando).

Compruebe la versión principal y secundaria del archivo JdkVersion.class :

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

Vemos que la clase se compiló originalmente como destino 48.0 (al buscar esto , encontramos que es 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:
...

Crea org/springframework/core/JdkVersion.java con el siguiente contenido:

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

Luego compila la nueva clase como Java 1.4:

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

Puede verificar la versión major.minor nuevamente como arriba si es necesario.

Cree el archivo jar modificado (sin sobrescribir el manifiesto original):

jar Mcf ../spring-modified.jar *

Copie el archivo jar modificado donde sea necesario (como spring.jar o según corresponda).

Answer 8

Resulta que soy otro usuario desafortunado de un proyecto muy antiguo (¡desarrollado en 2008!) Que aún utiliza Spring 2.5. Y tampoco es un proyecto de Maven, por lo que la actualización a versiones posteriores de Spring tardó mucho tiempo con el fallo de las dependencias y los errores de compilación. Bajé de categoría a Tomcat JRE a 1.7 y funcionó bien.

Solo documentando cómo hacer eso en eclipse en caso de que alguien necesite ayuda:

1. Si aún no tiene Java 7, descargue JDK 7 e instálelo en algún lugar como C:/Program Files/Java/jdk1.7.0_71

2. Luego vaya a Eclipse y haga doble clic en Servers > Tomcat vX.Y server

3. Haga clic en Runtime Environment , luego Installed JREs

4. A continuación, Add > Standard VM y haga clic en Next . Usted ve una ventana como esta:

5. Haga clic en Directory... y busque la carpeta donde instaló el JDK (es decir, C:/Program Files/Java/jdk1.7.0_71 . JDK está bien, no es necesario JRE). Haga clic en Finish .

6. Luego, asegúrese de seleccionar JRE para Java 7 y ya está todo listo.

Answer 9

Tengo un problema similar. La aplicación Old Spring MVC / Spring Faces en la primavera 2.5.5 no se ejecuta en Java 8.

Pasé algunos días tratando de encontrar una solución porque necesitamos ejecutar Java 8.

La primera idea fue: actualizar el paquete completo de Spring hasta 4.1.6. Usé a Maven. Problema de este método que después de eso es necesario volver a trabajar casi todo el proyecto. Es porque, por ejemplo, en Spring 4 se eliminó la implementación de JSF y algunos taglibs especiales se eliminaron por completo, como <sf:..> . Y hubo algunos problemas mayores y menores con la configuración, los adaptadores, los manejadores, las asignaciones ...

El segundo enfoque fue reemplazar Spring JAR parcialmente. Uno por uno. Otra vez sin éxito. Imposible reemplazar cualquier jar sin tocar dependencias.

Creo que después de algunas semanas o montones de dificultades, puedo tener éxito en ambos enfoques. Pero no tengo tanto tiempo. Y me di por vencido. Mi solución es:

Encontré el archivo fuente JdkVersion.java del paquete org.springframework.core. http://www.java2s.com/Code/Jar/o/Downloadorgspringframeworkcoresources300releasejar.htm . Creé el paquete org.springframework.core en mi proyecto con solo una clase JdkVersion. Después de eso, se hizo un cambio simple del código para verificar la versión de Java 8. Así es:

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

Incluso este cambio de código no es realmente necesario, solo por diversión. Se debe a que esta fuente vino del paquete Spring 3.0.0 donde Spring Boys ya cambió la verificación de la versión de Java. Las versiones superiores a 7 no se consideran antiguas Java.

Ahora la aplicación comienza correctamente. Llama a la clase JdkVersion de mi proyecto en lugar de jar.

Funciona hasta ahora! Gracias a todos por este hilo que dio esta idea.

Gracias

Answer 10

Tuve el mismo problema, pero tengo una solución:

en su archivo de proyecto pom.xml replace:

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

para:

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

¡y adiós a tus problemas!

Estas dos dependencias son el reemplazo de la primera dependencia en la mayor parte.

Answer 11

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

O

1. Haga clic derecho en la propiedad del proyecto.
2. Vaya a / Haga clic en "Java Build Path".
3. Seleccione la pestaña Libraries y haga doble clic en "JRE System Libry"
4. En esa ventana emergente, seleccione JDK 1.7 (si no tiene JDK 1.7, primero instálelo, luego selecciónelo desde "Entorno de ejecución")