Beheben Sie den Fehler Java.Lang.ClassNotFoundException: Org.Springframework.Web.Context.ContextLoaderListener in Java

1. Voraussetzungen
2. Fehlerdemonstration, Gründe und Lösungen

Heute lernen wir den Fehler org.springframework.web.context.ContextLoaderListener in Java kennen. Wie der Name schon sagt, geschieht dies zur Laufzeit.

Wir werden auch den Grund für diesen Fehler ermitteln, was zu verschiedenen möglichen Lösungen führt.

Voraussetzungen

Für dieses Tutorial verwenden wir die folgenden Tools und Technologien.

1. Apache Tomcat 9.0
2. Spring-MVC-Framework 3.1
3. Java8
4. Apache NetBeans 14 (Sie können NetBeans oder Eclipse verwenden)

Fehlerdemonstration, Gründe und Lösungen

Beispielcode (unser Projekt hat die folgende web.xml-Datei):

<?xml version="1.0" encoding="ISO-8859-1" ?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
                        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

	<display-name>Spring MVC Application</display-name>

    <servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
	</context-param>

	<listener>
       <listener-class>
           org.springframework.web.context.ContextLoaderListener
       </listener-class>
	</listener>

</web-app>

Beispielcode (unser Projekt hat folgende Abhängigkeiten in der pom.xml):

<dependency>
	<groupId>jstl</groupId>
	<artifactId>jstl</artifactId>
	<version>1.2</version>
	<type>jar</type>
	<scope>compile</scope>
</dependency>
<dependency>
	<groupId>taglibs</groupId>
	<artifactId>standard</artifactId>
	<version>1.1.2</version>
	<type>jar</type>
	<scope>compile</scope>
</dependency>
<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>servlet-api</artifactId>
	<version>3.0-alpha-1</version>
	<type>jar</type>
	<scope>compile</scope>
</dependency>

Das Projekt schlägt beim Start fehl und führt zu folgendem Fehler.

java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener

Um das Problem herauszufinden, das zu diesem Fehler führt, wollen wir verstehen, was der ContextLoaderListener ist und warum wir ihn verwenden.

Der ContextLoaderListener ist ein wichtiger Bestandteil des Spring-MVC-Frameworks. Wahrscheinlich ist es das Wichtigste nach DispatcherServlet selbst.

Es gehört zum Paket org.springframework.web.context. Wir verwenden es in Spring-Webanwendungen, um einen root-Kontext zu erstellen.

Außerdem ist es für das Laden von Beans verantwortlich, die von vielen DispatcherServlet geteilt werden. Im Allgemeinen verwenden wir zwei Anwendungskontexte, DispatcherServlet und ContextLoaderListener, während wir eine Spring MVC-basierte Web-App entwickeln.

Hier wird das DispatcherServlet verwendet, um webkomponentenspezifische Beans zu laden, zum Beispiel Controller, View, Handler-Mappings usw., während der ContextLoaderListener verwendet wird, um Data-Tier- und Middle-Tier-Beans zu laden, die das Back-End der Spring-Anwendung.

Denken Sie daran, dass der ContextLoaderListener genau wie der andere Servlet-Listener ist, der im Bereitstellungsdeskriptor (auch bekannt als web.xml) deklariert werden muss, um auf die Ereignisse zu hören. Die Implementierung von ServletContextListener lauscht nur auf das Herunterfahren und Hochfahren des Servers und erstellt/zerstört auch die von Spring verwalteten Beans.

Bemerkenswert ist, dass wir den ContextLoaderListener in einer Datei namens web.xml konfigurieren, während wir eine Spring-MVC-App erstellen. Wenn Sie Spring 3.1 und Spring 3.0 verwenden, dann können wir es ohne Deployment Descriptor konfigurieren, sondern nur Java-Konfigurationen.

An dieser Stelle kennen wir die Verwendung von ContextLoaderListener und haben uns bei Bedarf in der web.xml registriert. Warum erhalten wir nun den Fehler java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener?

Grund für das Erhalten des ContextLoaderListener-Fehlers

Wir erhalten diesen Fehler, weil wir das MVC-Framework Spring verwenden, um unsere Java-Web-App zu entwickeln, und den ContextLoaderListener als Listener in unserer Deployment-Beschreibung (Datei web.xml) konfigurieren, aber ein jar, das diese class nicht im CLASSPATH der Webapplikation aufgeführt.

Also, wie kann man das lösen? Siehe folgenden Abschnitt.

Mögliche Lösungen zur Behebung des ContextLoaderListener-Fehlers

Es gibt eine Reihe von Möglichkeiten, die wir verwenden können, um den Fehler java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener zu beheben, die Sie je nach Situation und Projektanforderungen verwenden können.

1. Die web.xml ist eine wichtige Datei bei der Arbeit mit dem Spring-MVC-Framework, da sie für das Laden unserer Spring-Konfigurationsdateien verantwortlich ist, beispielsweise dispatcher-servlet.xml und application-context.xml. Stellen Sie sicher, dass Sie darin den ContextLoadListener wie folgt registriert haben:

   <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
   </context-param>
   
   <listener>
      <listener-class>
   	   org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   

2. Wenn das Projekt die Spring-Framework-Version 3.0 verwendet, müssen wir spring-web.jar zum CLASSPATH hinzufügen. Durch das Hinzufügen in den CLASSPATH meinen wir, dass wir das in den Ordner WEB-INF/lib legen.

3. Wenn das Projekt die Spring-Framework-Version 2.0 oder niedriger verwendet, müssen wir die spring.jar-Datei in den WEB-INF/lib-Ordner legen, was bedeutet, dass wir diese Datei zu unserem hinzufügen CLASSPATH der App.

4. Wenn wir die Datei spring-web.jar oder spring.jar bereits hinzugefügt haben, basierend auf der von uns verwendeten Spring-Version.

   Dann tritt der Fehler höchstwahrscheinlich auf, weil CLASSPATH falsch konfiguriert wurde. Überprüfe das noch einmal und korrigiere es.

5. Wenn wir mit Maven arbeiten, müssen wir die folgende Maven-Abhängigkeit in unserer pom.xml hinzufügen. Das war in unserem Fall der Grund.

```xml
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-web</artifactId>
   <version>3.1.0.RELEASE</version>
   <type>jar</type>
   <scope>compile</scope>
</dependency>
```

Wir fügen diese Abhängigkeit hinzu, weil sie der Kern-`HTTP`-Integration dient, um sie mit anderen `HTTP`-Technologien und Web-Frameworks zu integrieren. Einige von uns haben vielleicht `spring-webmvc`, was auch in Ordnung ist.

Das `spring-webmvc` ist die Implementierung von `Spring` MVC; es kommt auf das `spring-web` an. Das Einschließen von `spring-webmvc` schließt also transitiv `spring-web` ein; wir müssen das nicht explizit hinzufügen.

Wir können das `spring-webmvc` wie folgt hinzufügen:

```xml
<dependency>
   <groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.1.0.RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
```

6. Wenn Sie Eclipse-freundlich sind und diesen Fehler erhalten, während Sie Eclipse und Tomcat verwenden. Dann müssen Sie einige einfache Schritte ausführen, um sicherzustellen, dass der CLASSPATH Maven-Abhängigkeiten enthält.

   Außerdem sind sie für den Klassenlader der Webanwendung von Tomcat sichtbar. Sie müssen nur die folgenden Schritte ausführen.

   1. Wählen Sie das Projekt aus. Klicken Sie mit der rechten Maustaste darauf und wählen Sie Eigenschaften.
   2. Wählen Sie auf der linken Seite des Fensters Deployment Assembly aus. Sie können auch hierher kommen, indem Sie das Projekt auswählen, mit der rechten Maustaste darauf klicken und Build Path > Configure Build Path auswählen.
   3. Wählen Sie dann Bereitstellungsmontage. Sie können jede Option verwenden, um hierher zu gelangen.
   4. Klicken Sie auf die Schaltfläche Hinzufügen. Es ist auf der rechten Seite des Fensters verfügbar.
   5. Sobald Sie auf die Schaltfläche Hinzufügen geklickt haben, sehen Sie ein neues Fenster. Wählen Sie dort Java Build Path Entries und klicken Sie auf Next.
   6. Wählen Sie im Menü Java Build Path Entries die Maven Dependencies und klicken Sie dann auf Finish.

Wir werden Maven-Abhängigkeiten sehen, die der Webbereitstellungs-Assembly-Definition hinzugefügt wurden, sobald alle Schritte erfolgreich durchgeführt wurden.