Quali sono le cause e quali sono le differenze tra NoClassDefFoundError e ClassNotFoundException?

Qual è la differenza tra NoClassDefFoundErrore ClassNotFoundException?

Cosa li fa lanciare? Come possono essere risolti?

Incontro spesso questi oggetti gettabili quando modifico il codice esistente per includere nuovi file jar. Li ho colpiti sia sul lato client che sul lato server per un'app java distribuita tramite webstart.

Possibili ragioni per cui mi sono imbattuto:

1. pacchetti non inclusi build.xmlper il lato client del codice
2. percorso di classe runtime mancante per i nuovi vasetti che stiamo utilizzando
3. la versione è in conflitto con il vaso precedente

Quando li incontro oggi, adotto un approccio trail-and-error per far funzionare le cose. Ho bisogno di più chiarezza e comprensione.

La differenza dalle specifiche dell'API Java è la seguente.

Per ClassNotFoundException:

Generato quando un'applicazione tenta di caricare in una classe tramite il nome stringa utilizzando:

• Il forNamemetodo in classe Class.
• Il findSystemClassmetodo in classe ClassLoader.
• Il loadClassmetodo in classe ClassLoader.

ma non è stata trovata alcuna definizione per la classe con il nome specificato.

Per NoClassDefFoundError:

Viene generato se la Java Virtual Machine o ClassLoaderun'istanza tenta di caricare la definizione di una classe (come parte di una normale chiamata di metodo o come parte della creazione di una nuova istanza utilizzando la nuova espressione) e non è stata trovata alcuna definizione della classe.

La definizione della classe cercata esisteva al momento della compilazione della classe attualmente in esecuzione, ma non è più possibile trovare la definizione.

Quindi, sembra che si NoClassDefFoundErrorverifichi quando l'origine è stata compilata correttamente, ma in fase di esecuzione i classfile richiesti non sono stati trovati. Questo può essere qualcosa che può accadere nella distribuzione o produzione di file JAR, in cui non classsono stati inclusi tutti i file richiesti .

Per quanto riguarda ClassNotFoundException, sembra che potrebbe derivare dal tentativo di effettuare chiamate riflessive alle classi in fase di esecuzione, ma le classi che il programma sta tentando di chiamare non esiste.

La differenza tra i due è che uno è un Errore l'altro è un Exception. With NoClassDefFoundErroris Errore nasce dalla Java Virtual Machine che ha problemi a trovare una classe che si aspettava di trovare. Un programma che dovrebbe funzionare in fase di compilazione non può essere eseguito a causa di classfile non trovati o non è lo stesso prodotto o incontrato durante la compilazione. Questo è un errore piuttosto critico, poiché il programma non può essere avviato da JVM.

D'altra parte, ClassNotFoundExceptionè un Exception, quindi è un po 'previsto, ed è qualcosa che è recuperabile. L'uso di reflection is può essere soggetto a errori (poiché ci sono alcune aspettative che le cose potrebbero non andare come previsto. Non esiste un controllo in fase di compilazione per vedere che esistono tutte le classi richieste, quindi eventuali problemi nel trovare le classi desiderate verranno visualizzati in fase di esecuzione .

Una ClassNotFoundException viene generata quando la classe segnalata non viene trovata da ClassLoader. Ciò significa in genere che la classe non è presente in CLASSPATH. Potrebbe anche significare che la classe in questione sta tentando di essere caricata da un'altra classe che è stata caricata in un programma di caricamento classi principale e quindi la classe dal programma di caricamento classi figlio non è visibile. Questo è talvolta il caso quando si lavora in ambienti più complessi come un App Server (WebSphere è famoso per tali problemi con il classloader).

Spesso le persone tendono a confondere java.lang.NoClassDefFoundErrorcon java.lang.ClassNotFoundExceptionperò c'è una distinzione importante. Ad esempio un'eccezione (un errore in realtà java.lang.NoClassDefFoundErrorè una sottoclasse di java.lang.Error) come

java.lang.NoClassDefFoundError:
org/apache/activemq/ActiveMQConnectionFactory

non significa che la classe ActiveMQConnectionFactory non sia in CLASSPATH. Infatti è piuttosto il contrario. Significa che la classe ActiveMQConnectionFactory è stata trovata da ClassLoader, tuttavia durante il tentativo di caricare la classe, si è verificato un errore durante la lettura della definizione della classe. Questo in genere accade quando la classe in questione ha blocchi statici o membri che usano una Classe non trovata da ClassLoader. Quindi, per trovare il colpevole, visualizzare l'origine della classe in questione (ActiveMQConnectionFactory in questo caso) e cercare il codice utilizzando blocchi statici o membri statici. Se non hai accesso al sorgente, decompilalo semplicemente usando JAD.

Nell'esaminare il codice, supponi di trovare una riga di codice come di seguito, assicurati che la classe SomeClass sia presente nel tuo CLASSPATH.

private static SomeClass foo = new SomeClass();

Suggerimento: per scoprire a quale vaso appartiene una classe, è possibile utilizzare il sito Web jarFinder. Ciò consente di specificare un nome di classe utilizzando i caratteri jolly e cerca la classe nel suo database di vasetti. jarhoo ti permette di fare la stessa cosa ma non è più gratuito da usare.

Se desideri individuare il jar a cui appartiene una classe in un percorso locale, puoi utilizzare un'utilità come jarscan ( http://www.inetfeedback.com/jarscan/ ). Devi solo specificare la classe che desideri individuare e il percorso della directory principale in cui desideri che inizi a cercare la classe in barattoli e file zip.

NoClassDefFoundErrorè fondamentalmente un errore di collegamento. Si verifica quando si tenta di creare un'istanza di un oggetto (staticamente con "nuovo") e non viene trovato durante la compilazione.

ClassNotFoundExceptionè più generale ed è un'eccezione di runtime quando si tenta di utilizzare una classe che non esiste. Ad esempio, hai un parametro in una funzione che accetta un'interfaccia e qualcuno passa in una classe che implementa tale interfaccia ma non hai accesso alla classe. Copre anche il caso del caricamento dinamico della classe, come l'utilizzo di loadClass()o Class.forName().

Un NoClassDefFoundError (NCDFE) si verifica quando il codice esegue "new Y ()" e non riesce a trovare la classe Y.

È possibile che Y non sia presente nel programma di caricamento della classe come suggerito dagli altri commenti, ma potrebbe essere che la classe Y non sia firmata o abbia una firma non valida o che Y sia caricato da un programma di caricamento classi diverso non visibile al codice , o anche che Y dipende da Z che non può essere caricato per nessuno dei motivi di cui sopra.

Se ciò accade, JVM ricorderà il risultato del caricamento di X (NCDFE) e lancerà semplicemente un nuovo NCDFE ogni volta che chiederai Y senza dirti perché:

classe A {
  classe statica b {}
  public static void main (String args []) {
    System.out.println ("Primo tentativo nuovo b ():");
    provare {new b (); } catch (Throwable t) {t.printStackTrace ();}
    System.out.println ("\ nSecondo tentativo nuovo b ():");
    provare {new b (); } catch (Throwable t) {t.printStackTrace ();}
  }
}

salvalo come a.java da qualche parte

Il codice tenta semplicemente di creare un'istanza di una nuova classe "b" due volte, a parte questo, non ha alcun bug e non fa nulla.

Compila il codice con javac a.java, quindi esegui un invocando java -cp . a: dovrebbe solo stampare due righe di testo e dovrebbe funzionare correttamente senza errori.

Quindi eliminare il file "a $ b.class" (o riempirlo con immondizia o copiare a.class su di esso) per simulare la classe mancante o danneggiata. Ecco cosa succede:

Primo tentativo nuovo b ():
java.lang.NoClassDefFoundError: a $ b
    a a.main (a.java:5)
Causato da: java.lang.ClassNotFoundException: a $ b
    su java.net.URLClassLoader $ 1.run (URLClassLoader.java:200)
    at java.security.AccessController.doPrivileged (metodo nativo)
    su java.net.URLClassLoader.findClass (URLClassLoader.java:188)
    at java.lang.ClassLoader.loadClass (ClassLoader.java:307)
    at sun.misc.Launcher $ AppClassLoader.loadClass (Launcher.java:301)
    at java.lang.ClassLoader.loadClass (ClassLoader.java:252)
    at java.lang.ClassLoader.loadClassInternal (ClassLoader.java:320)
    ... 1 altro

Secondo tentativo nuovo b ():
java.lang.NoClassDefFoundError: a $ b
    a a.main (a.java:7)

La prima chiamata ha come risultato ClassNotFoundException (generata dal programma di caricamento classi quando non riesce a trovare la classe), che deve essere racchiusa in un NoClassDefFoundError non selezionato, poiché il codice in questione ( new b()) dovrebbe funzionare.

Naturalmente anche il secondo tentativo fallirà, ma come puoi vedere l'eccezione racchiusa non è più, perché ClassLoader sembra ricordare caricatori di classi falliti. Vedi solo l'NCDFE senza assolutamente indizi su cosa sia realmente successo.

Quindi, se vedi mai un NCDFE senza causa principale, devi vedere se riesci a risalire alla prima volta in cui la classe è stata caricata per trovare la causa dell'errore.

Da http://www.javaroots.com/2013/02/classnotfoundexception-vs.html :

ClassNotFoundException: si verifica quando il programma di caricamento classi non è riuscito a trovare la classe richiesta nel percorso classe. Quindi, in sostanza, dovresti controllare il tuo percorso di classe e aggiungere la classe nel percorso di classe.

NoClassDefFoundError: è più difficile eseguire il debug e trovare il motivo. Viene generato quando al momento della compilazione sono presenti le classi richieste, ma in fase di esecuzione le classi vengono modificate o rimosse o l'inizializzazione statica della classe genera eccezioni. Significa che la classe che viene caricata è presente nel percorso di classe, ma una delle classi richieste da questa classe viene rimossa o non può essere caricata dal compilatore. Quindi dovresti vedere le classi che dipendono da questa classe.

Esempio :

public class Test1
{
}


public class Test 
{
   public static void main(String[] args)
   {
        Test1 = new Test1();    
   }

}

Ora dopo aver compilato entrambe le classi, se si elimina il file Test1.class ed si esegue la classe Test, verrà generata

Exception in thread "main" java.lang.NoClassDefFoundError: Test
    at Test1.main(Test1.java:5)
Caused by: java.lang.ClassNotFoundException: Test
    at java.net.URLClassLoader$1.run(Unknown Source)
    at java.net.URLClassLoader$1.run(Unknown Source)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(Unknown Source)
    at java.lang.ClassLoader.loadClass(Unknown Source)
    at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
    at java.lang.ClassLoader.loadClass(Unknown Source)
    ... 1 more

ClassNotFoundException: generato quando un'applicazione tenta di caricare una classe attraverso il suo nome, ma non è stata trovata alcuna definizione per la classe con il nome specificato.

NoClassDefFoundError: generato se la Java Virtual Machine tenta di caricare la definizione di una classe e non è stata trovata alcuna definizione della classe.

Qual è la ragione per ottenere ciascuno di essi e qualsiasi processo di riflessione su come affrontare tali errori?

Sono strettamente correlati. A ClassNotFoundExceptionviene generato quando Java cerca una determinata classe in base al nome e non riesce a caricarla correttamente. A NoClassDefFoundErrorviene lanciato quando Java è andato alla ricerca di una classe collegata a un codice esistente, ma non è stata trovata per un motivo o per l'altro (ad esempio, percorso di classe errato, versione errata di Java, versione errata di una libreria) ed è completamente fatale poiché indica che qualcosa è andato storto.

Se hai uno sfondo C, un CNFE è come un errore dlopen()/ dlsym()e un NCDFE è un problema con il linker; nel secondo caso, i file di classe interessati non avrebbero mai dovuto essere effettivamente compilati nella configurazione che si sta tentando di usarli.

Esempio 1:

class A{
 void met(){
   Class.forName("com.example.Class1");
 }
}

Se com/example/Class1non esiste in nessuno dei percorsi di classe, allora genera ClassNotFoundException.

Esempio n. 2:

Class B{
  void met(){
   com.example.Class2 c = new com.example.Class2();
 }
}

Se com/example/Class2esisteva durante la compilazione di B, ma non trovato durante l'esecuzione, viene generato NoClassDefFoundError.

Entrambe sono eccezioni di runtime.

ClassNotFoundException viene generata quando si tenta di caricare la classe facendo riferimento a essa tramite una stringa. Ad esempio, il parametro in Class.forName () è una stringa e questo aumenta il potenziale di nomi binari non validi che vengono passati al classloader.

ClassNotFoundException viene generata quando viene rilevato un nome binario potenzialmente non valido; ad esempio, se il nome della classe ha il carattere '/', si è tenuti a ottenere ClassNotFoundException. Viene inoltre generato quando la classe a cui viene fatto riferimento direttamente non è disponibile nel percorso di classe.

D'altra parte, viene generato NoClassDefFoundError

• quando la rappresentazione fisica effettiva della classe - il file .class non è disponibile,
• oppure la classe è già stata caricata in un classloader diverso (di solito un classloader genitore avrebbe caricato la classe e quindi la classe non può essere caricata di nuovo),
• o se è stata trovata una definizione di classe incompatibile: il nome nel file di classe non corrisponde al nome richiesto,
• o (soprattutto) se non è possibile individuare e caricare una classe dipendente. In questo caso, la classe con riferimento diretto potrebbe essere stata individuata e caricata, ma la classe dipendente non è disponibile o non può essere caricata. Questo è uno scenario in cui la classe a cui si fa riferimento diretto può essere caricata tramite Class.forName o metodi equivalenti. Ciò indica un errore nel collegamento.

In breve, un NoClassDefFoundError viene solitamente generato su nuove istruzioni (o invocazioni di metodi) che caricano una classe precedentemente assente (al contrario del caricamento basato su stringhe di classi per ClassNotFoundException), quando il classloader non è in grado di trovare o caricare la definizione della classe ( S).

Alla fine, spetta all'implementazione ClassLoader generare un'istanza di ClassNotFoundException quando non è in grado di caricare una classe. La maggior parte delle implementazioni del classloader personalizzato esegue questa operazione poiché estende URLClassLoader. Di solito i classloader non generano esplicitamente un NoClassDefFoundError su nessuna delle implementazioni del metodo: questa eccezione viene generalmente generata dalla JVM nel compilatore HotSpot e non dallo stesso classloader.

Differenza tra ClassNotFoundException e NoClassDefFoundError

Con i nomi stessi possiamo facilmente identificarne uno Exceptione l'altro proviene da Error.

Eccezione: si verificano eccezioni durante l'esecuzione del programma. Un programmatore può gestire queste eccezioni provando il blocco catch. Abbiamo due tipi di eccezioni. Eccezione controllata che viene generata al momento della compilazione. Eccezioni di runtime che vengono generate in fase di esecuzione, queste eccezioni si verificano in genere a causa di una programmazione errata.

Errore: queste non sono affatto eccezioni, è oltre lo scopo del programmatore. Questi errori vengono generalmente generati da JVM.

fonte dell'immagine

Differenza:

ClassNotFoundException:

• Il programma di caricamento classi non riesce a verificare un codice byte di classe menzionato nella fase di collegamento del sottosistema di caricamento classe che otteniamo ClassNotFoundException.
• ClassNotFoundExceptionè un'eccezione controllata derivata direttamente dalla java.lang.Exceptionclasse e devi fornire una gestione esplicita per essa
• ClassNotFoundExceptionviene visualizzato quando è coinvolto un caricamento esplicito della classe fornendo il nome della classe in fase di esecuzione utilizzando ClassLoader.loadClass (), Class.forName () e ClassLoader.findSystemClass ().

NoClassDefFoundError:

• Il programma di caricamento classe non riesce a risolvere i riferimenti di una classe nella fase Collegamento del sottosistema di caricamento classe che otteniamo NoClassDefFoundError.
• NoClassDefFoundErrorè un errore derivato dalla LinkageErrorclasse, che viene utilizzato per indicare casi di errore, in cui una classe ha una dipendenza da qualche altra classe e quella classe è stata modificata in modo incompatibile dopo la compilazione.
• NoClassDefFoundErrorè il risultato del caricamento implicito della classe a causa di una chiamata del metodo da quella classe o di qualsiasi accesso variabile.

Somiglianze:

• Entrambi NoClassDefFoundErrore ClassNotFoundExceptionsono correlati all'indisponibilità di una classe in fase di esecuzione.
• Entrambi ClassNotFoundExceptione NoClassDefFoundErrorsono correlati al percorso di classe Java.

Date le azioni del sottosistema del caricatore di classi:

Questo articolo mi ha aiutato molto a capire la differenza: http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html

Se si verifica un errore durante il caricamento della classe, è necessario lanciare un'istanza di una sottoclasse di LinkageError in un punto del programma che (direttamente o indirettamente) utilizza la classe o l'interfaccia da caricare.

Se la Java Virtual Machine tenta mai di caricare una classe C durante la verifica (§5.4.1) o la risoluzione (§5.4.3) (ma non l'inizializzazione (§5.5)) e il caricatore di classi utilizzato per avviare il caricamento di C genera un'istanza di ClassNotFoundException , quindi Java Virtual Machine deve generare un'istanza di NoClassDefFoundError la cui causa è l'istanza di ClassNotFoundException .

Quindi una ClassNotFoundException è una causa principale di NoClassDefFoundError .
E un NoClassDefFoundError è un caso speciale di errore di caricamento del tipo, che si verifica nella fase di collegamento .

Aggiungi un possibile motivo in pratica:

• ClassNotFoundException: come diceva cletus, si utilizza l'interfaccia mentre la classe di interfaccia ereditata non si trova nel percorso di classe. Ad esempio, Service Provider Pattern (o Service Locator ) tenta di individuare una classe inesistente
• NoClassDefFoundError: la classe data viene trovata mentre la dipendenza della classe data non viene trovata

In pratica, l' errore può essere lanciato in silenzio , ad esempio, si invia un'attività timer e nell'attività timer genera Errore , mentre nella maggior parte dei casi il programma rileva solo Eccezione . Quindi il loop principale del timer viene terminato senza alcuna informazione. Un errore simile a NoClassDefFoundError è ExceptionInInitializerError , quando l'inizializzatore statico o l'inizializzatore di una variabile statica generano un'eccezione.

ClassNotFoundException è un'eccezione verificata che si verifica quando diciamo a JVM di caricare una classe con il suo nome stringa usando i metodi Class.forName () o ClassLoader.findSystemClass () o ClassLoader.loadClass () e la classe menzionata non si trova nel classpath.

Il più delle volte, questa eccezione si verifica quando si tenta di eseguire un'applicazione senza aggiornare il percorso di classe con i file JAR richiesti. Ad esempio, potresti aver visto questa eccezione quando esegui il codice JDBC per connetterti al tuo database ieMySQL ma il tuo percorso di classe non ha JAR per esso.

L' errore NoClassDefFoundError si verifica quando JVM tenta di caricare una particolare classe che fa parte dell'esecuzione del codice (come parte di una normale chiamata di metodo o come parte della creazione di un'istanza utilizzando la nuova parola chiave) e quella classe non è presente nel percorso di classe ma era presente al momento della compilazione perché per eseguire il programma è necessario compilarlo e se si sta tentando di utilizzare una classe che non è presente, il compilatore genererà errori di compilazione.

Di seguito è la breve descrizione

Puoi leggere Tutto su ClassNotFoundException Vs NoClassDefFoundError per maggiori dettagli.

Ricordo a me stesso quanto segue quando devo aggiornare

ClassNotFoundException

Gerarchia di classe

ClassNotFoundException extends ReflectiveOperationException extends Exception extends Throwable

Durante il debug

1. Jar richiesto, la classe non è presente nel percorso di classe.
2. Verificare che tutti i barattoli richiesti siano nel percorso di classe di jvm.

NoClassDefFoundError

Gerarchia di classe

NoClassDefFoundError extends LinkageError  extends Error extends Throwable

Durante il debug

1. Problema con il caricamento dinamico di una classe, che è stata compilata correttamente
2. Problema con blocchi statici, costruttori, metodi init () di classe dipendente e l'errore effettivo è racchiuso da più livelli [specialmente quando si utilizza la molla, ibernare l'eccezione effettiva è racchiusa e si otterrà NoClassDefError]
3. Quando affronti "ClassNotFoundException" sotto un blocco statico di classe dipendente
4. Problema con le versioni di classe. Questo accade quando hai due versioni v1, v2 della stessa classe in diversi jar / pacchetti, che è stata compilata correttamente usando v1 e v2 viene caricata in fase di esecuzione che non ha i metodi / le variabili rilevanti e vedrai questa eccezione. [Una volta ho risolto questo problema rimuovendo il duplicato della classe relativa a log4j sotto più vasetti che apparivano nel percorso di classe]

ClassNotFoundException e NoClassDefFoundError si verificano quando una determinata classe non viene trovata in fase di esecuzione. Tuttavia, si verificano in scenari diversi.

ClassNotFoundException è un'eccezione che si verifica quando si tenta di caricare una classe in fase di esecuzione utilizzando i metodi Class.forName () o loadClass () e le classi menzionate non si trovano nel percorso di classe.

    public class MainClass
    {
        public static void main(String[] args)
        {
            try
            {
                Class.forName("oracle.jdbc.driver.OracleDriver");
            }catch (ClassNotFoundException e)
            {
                e.printStackTrace();
            }
        }
    }



    java.lang.ClassNotFoundException: oracle.jdbc.driver.OracleDriver
    at java.net.URLClassLoader.findClass(Unknown Source)
    at java.lang.ClassLoader.loadClass(Unknown Source)
    at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
    at java.lang.ClassLoader.loadClass(Unknown Source)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Unknown Source)
    at pack1.MainClass.main(MainClass.java:17)

NoClassDefFoundError è un errore che si verifica quando una determinata classe è presente in fase di compilazione, ma mancava in fase di esecuzione.

    class A
    {
      // some code
    }
    public class B
    {
        public static void main(String[] args)
        {
            A a = new A();
        }
    }

Quando compili il programma precedente, verranno generati due file .class. Uno è A.class e un altro è B.class. Se rimuovi il file A.class ed esegui il file B.class, Java Runtime System genererà NoClassDefFoundError come di seguito:

    Exception in thread "main" java.lang.NoClassDefFoundError: A
    at MainClass.main(MainClass.java:10)
    Caused by: java.lang.ClassNotFoundException: A
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)