O que causa e quais são as diferenças entre NoClassDefFoundError e ClassNotFoundException?

Qual é a diferença entre NoClassDefFoundErrore ClassNotFoundException?

O que faz com que eles sejam jogados? Como eles podem ser resolvidos?

Costumo encontrar esses lançáveis ​​ao modificar o código existente para incluir novos arquivos jar. Eu os atingi no lado do cliente e no servidor para um aplicativo java distribuído através do webstart.

Possíveis razões que me deparei:

1. pacotes não incluídos no build.xmllado do cliente do código
2. caminho de classe de tempo de execução ausente para os novos frascos que estamos usando
3. versão entra em conflito com o jar anterior

Quando os encontro hoje, adotei uma abordagem de rastreamento e erro para fazer as coisas funcionarem. Eu preciso de mais clareza e compreensão.

A diferença das especificações da API Java é a seguinte.

Para ClassNotFoundException:

Lançado quando um aplicativo tenta carregar uma classe através do nome da sequência usando:

• O forNamemétodo na aula Class.
• O findSystemClassmétodo na aula ClassLoader.
• O loadClassmétodo na aula ClassLoader.

mas nenhuma definição para a classe com o nome especificado foi encontrada.

Para NoClassDefFoundError:

Lançada se a Java Virtual Machine ou uma ClassLoaderinstância tenta carregar na definição de uma classe (como parte de uma chamada de método normal ou como parte da criação de uma nova instância usando a nova expressão) e nenhuma definição da classe foi encontrada.

A definição de classe pesquisada existia quando a classe em execução no momento foi compilada, mas a definição não pode mais ser encontrada.

Portanto, parece que isso NoClassDefFoundErrorocorre quando a fonte foi compilada com êxito, mas em tempo de execução, os classarquivos necessários não foram encontrados. Isso pode ser algo que pode acontecer na distribuição ou produção de arquivos JAR, onde nem todos os classarquivos necessários foram incluídos.

Quanto a ClassNotFoundException, parece que isso pode resultar da tentativa de fazer chamadas reflexivas para as classes em tempo de execução, mas as classes que o programa está tentando chamar não existem.

A diferença entre os dois é que um é um Errore o outro é um Exception. With NoClassDefFoundErroré um Errore surge da Java Virtual Machine com problemas para encontrar uma classe que esperava encontrar. Um programa que se espera que funcione em tempo de compilação não pode ser executado devido à classfalta de arquivos encontrados ou não é o mesmo que foi produzido ou encontrado em tempo de compilação. Este é um erro bastante crítico, pois o programa não pode ser iniciado pela JVM.

Por outro lado, o ClassNotFoundExceptioné um Exception, então é algo esperado e é algo que é recuperável. O uso da reflexão pode estar sujeito a erros (pois há algumas expectativas de que as coisas não saem conforme o esperado. Não há verificação em tempo de compilação para verificar se todas as classes necessárias existem, portanto, quaisquer problemas em encontrar as classes desejadas aparecerão em tempo de execução .

Uma ClassNotFoundException é lançada quando a classe relatada não é encontrada pelo ClassLoader. Isso normalmente significa que a classe está ausente no CLASSPATH. Também pode significar que a classe em questão está tentando ser carregada de outra classe que foi carregada em um carregador de classes pai e, portanto, a classe do carregador de classes filho não está visível. Às vezes, esse é o caso ao trabalhar em ambientes mais complexos, como um App Server (o WebSphere é famoso por esses problemas no carregador de classes).

Muitas vezes as pessoas tendem a confundir java.lang.NoClassDefFoundErrorcom java.lang.ClassNotFoundExceptionno entanto há uma distinção importante. Por exemplo, uma exceção (um erro realmente desde que java.lang.NoClassDefFoundErroré uma subclasse de java.lang.Error) como

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

não significa que a classe ActiveMQConnectionFactory não esteja na CLASSPATH. De fato, é exatamente o contrário. Isso significa que a classe ActiveMQConnectionFactory foi encontrada pelo ClassLoader; no entanto, ao tentar carregar a classe, ocorreu um erro ao ler a definição da classe. Isso normalmente acontece quando a classe em questão possui blocos ou membros estáticos que usam uma classe que não é encontrada pelo ClassLoader. Portanto, para encontrar o culpado, visualize a fonte da classe em questão (ActiveMQConnectionFactory neste caso) e procure o código usando blocos ou membros estáticos. Se você não tiver acesso à fonte, simplesmente descompile-a usando o JAD.

Ao examinar o código, digamos que você encontre uma linha de código como a seguir, verifique se a classe SomeClass está no seu CLASSPATH.

private static SomeClass foo = new SomeClass();

Dica: Para descobrir a qual jar pertence uma classe, você pode usar o site jarFinder. Isso permite que você especifique um nome de classe usando curingas e ele procura a classe em seu banco de dados de jars. O jarhoo permite que você faça a mesma coisa, mas não é mais gratuito.

Se você deseja localizar o jar a que uma classe pertence em um caminho local, você pode usar um utilitário como o jarscan ( http://www.inetfeedback.com/jarscan/ ). Você acabou de especificar a classe que deseja localizar e o caminho do diretório raiz onde deseja iniciar a pesquisa da classe em jars e arquivos zip.

NoClassDefFoundErroré um erro de ligação basicamente. Ocorre quando você tenta instanciar um objeto (estaticamente com "novo") e não é encontrado quando estava durante a compilação.

ClassNotFoundExceptioné mais geral e é uma exceção de tempo de execução quando você tenta usar uma classe que não existe. Por exemplo, você tem um parâmetro em uma função que aceita uma interface e alguém passa em uma classe que implementa essa interface, mas você não tem acesso à classe. Também abrange casos de carregamento de classe dinâmica, como usar loadClass()or Class.forName().

Um NoClassDefFoundError (NCDFE) acontece quando seu código executa "novo Y ()" e não consegue encontrar a classe Y.

Pode ser que Y esteja ausente do seu carregador de classes, como os outros comentários sugerem, mas pode ser que a classe Y não esteja assinada ou tenha uma assinatura inválida, ou que Y esteja carregado por um carregador de classe diferente, não visível para o seu código , ou mesmo que Y dependa de Z, que não pôde ser carregado por qualquer um dos motivos acima.

Se isso acontecer, a JVM lembrará o resultado do carregamento do X (NCDFE) e lançará um novo NCDFE toda vez que você solicitar Y sem informar o motivo:

classe A {
  classe estática b {}
  public static void main (String args []) {
    System.out.println ("Primeira tentativa nova b ():");
    tente {novo b (); } catch (Throwable t) {t.printStackTrace ();}
    System.out.println ("\ nSegunda tentativa nova b ():");
    tente {novo b (); } catch (Throwable t) {t.printStackTrace ();}
  }
}

salve isso como a.java em algum lugar

O código simplesmente tenta instanciar uma nova classe "b" duas vezes, além disso, não possui bugs e não faz nada.

Compile o código com javac a.java, Em seguida, execute a invocando java -cp . a- ele deve apenas imprimir duas linhas de texto e deve funcionar bem sem erros.

Em seguida, exclua o arquivo "a $ b.class" (ou preencha-o com lixo ou copie a.class sobre ele) para simular a classe ausente ou corrompida. Aqui está o que acontece:

Primeira tentativa nova b ():
java.lang.NoClassDefFoundError: a $ b
    em a.main (a.java:5)
Causado por: java.lang.ClassNotFoundException: a $ b
    em java.net.URLClassLoader $ 1.run (URLClassLoader.java:200)
    em java.security.AccessController.doPrivileged (método nativo)
    em java.net.URLClassLoader.findClass (URLClassLoader.java:188)
    em java.lang.ClassLoader.loadClass (ClassLoader.java:307)
    em sun.misc.Launcher $ AppClassLoader.loadClass (Launcher.java:301)
    em java.lang.ClassLoader.loadClass (ClassLoader.java:252)
    em java.lang.ClassLoader.loadClassInternal (ClassLoader.java:320)
    ... mais 1

Segunda tentativa nova b ():
java.lang.NoClassDefFoundError: a $ b
    em a.main (a.java:7)

A primeira chamada resulta em uma ClassNotFoundException (lançada pelo carregador de classes quando não consegue encontrar a classe), que deve ser agrupada em um NoClassDefFoundError desmarcado, pois o código em questão ( new b()) deve funcionar.

Obviamente, a segunda tentativa também falhará, mas como você pode ver, a exceção agrupada não existe mais, porque o ClassLoader parece lembrar os carregadores de classes com falha. Você vê apenas o NCDFE com absolutamente nenhuma pista do que realmente aconteceu.

Portanto, se você vir um NCDFE sem causa raiz, precisará verificar se consegue rastrear desde a primeira vez em que a classe foi carregada para encontrar a causa do erro.

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

ClassNotFoundException: ocorre quando o carregador de classes não conseguiu encontrar a classe necessária no caminho da classe. Portanto, basicamente você deve verificar o caminho da classe e adicionar a classe no caminho da classe.

NoClassDefFoundError: isso é mais difícil de depurar e encontre o motivo. Isso é acionado quando, em tempo de compilação, as classes necessárias estão presentes, mas, em tempo de execução, as classes são alteradas ou removidas ou as inicializações estáticas da classe lançam exceções. Isso significa que a classe que está sendo carregada está presente no caminho de classe, mas uma das classes exigidas por essa classe é removida ou falha ao carregar pelo compilador. Então você deve ver as classes que são dependentes dessa classe.

Exemplo :

public class Test1
{
}


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

}

Agora, depois de compilar as duas classes, se você excluir o arquivo Test1.class e executar a classe Test, ele lançará

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: lançado quando um aplicativo tenta carregar uma classe por meio de seu nome, mas nenhuma definição para a classe com o nome especificado foi encontrada.

NoClassDefFoundError: lançado se a Java Virtual Machine tentar carregar na definição de uma classe e nenhuma definição da classe puder ser encontrada.

Qual é o motivo para obter cada um deles e qualquer processo de reflexão sobre como lidar com esses erros?

Eles estão intimamente relacionados. A ClassNotFoundExceptioné acionada quando o Java procura uma classe específica por nome e não pode carregá-la com êxito. A NoClassDefFoundErroré lançada quando o Java procura uma classe que esteja vinculada a algum código existente, mas não a encontrou por um motivo ou outro (por exemplo, caminho de classe errado, versão incorreta do Java, versão incorreta de uma biblioteca) e é completamente fatal pois indica que algo deu errado.

Se você possui um background C, um CNFE é como uma falha no dlopen()/ dlsym()e um NCDFE é um problema com o vinculador; no segundo caso, os arquivos de classe em questão nunca deveriam ter sido realmente compilados na configuração que você está tentando usá-los.

Exemplo 1:

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

Se com/example/Class1não existir em nenhum dos caminhos de classe, será lançado ClassNotFoundException.

Exemplo 2:

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

Se com/example/Class2existia durante a compilação de B, mas não foi encontrado durante a execução, é lançado NoClassDefFoundError.

Ambos são exceções de tempo de execução.

ClassNotFoundException é lançado quando há uma tentativa de carregar a classe fazendo referência a ela por meio de uma String. Por exemplo, o parâmetro em Class.forName () é uma String e isso aumenta o potencial de nomes binários inválidos sendo passados ​​para o carregador de classes.

A ClassNotFoundException é lançada quando um nome binário potencialmente inválido é encontrado; por exemplo, se o nome da classe tiver o caractere '/', você receberá uma ClassNotFoundException. Também é lançada quando a classe referenciada diretamente não está disponível no caminho de classe.

Por outro lado, NoClassDefFoundError é lançado

• quando a representação física real da classe - o arquivo .class estiver indisponível,
• ou a classe já foi carregada em um carregador de classe diferente (geralmente um carregador de classe pai teria carregado a classe e, portanto, a classe não pode ser carregada novamente),
• ou se uma definição de classe incompatível foi encontrada - o nome no arquivo de classe não corresponde ao nome solicitado,
• ou (o mais importante) se uma classe dependente não puder ser localizada e carregada. Nesse caso, a classe diretamente referenciada pode ter sido localizada e carregada, mas a classe dependente não está disponível ou não pode ser carregada. Este é um cenário em que a classe diretamente referenciada pode ser carregada por meio de um Class.forName ou métodos equivalentes. Isso indica uma falha no vínculo.

Em resumo, um NoClassDefFoundError geralmente é lançado em instruções new () ou invocações de métodos que carregam uma classe anteriormente ausente (em oposição ao carregamento de classes baseado em string para ClassNotFoundException), quando o carregador de classe não consegue encontrar ou carregar a definição de classe ( s)

Eventualmente, cabe à implementação do ClassLoader lançar uma instância de ClassNotFoundException quando não é possível carregar uma classe. A maioria das implementações personalizadas do carregador de classes realiza isso porque elas estendem o URLClassLoader. Geralmente, os carregadores de classes não lançam explicitamente um NoClassDefFoundError em nenhuma das implementações de métodos - essa exceção geralmente é lançada da JVM no compilador HotSpot e não pelo próprio carregador de classes.

Diferença entre ClassNotFoundException Vs NoClassDefFoundError

Com os nomes em si, podemos facilmente identificar um Exceptione outro é de Error.

Exceção: Exceções ocorrem durante a execução do programa. Um programador pode lidar com essas exceções tentando o bloco catch. Temos dois tipos de exceções. Exceção marcada que lança em tempo de compilação. Exceções de tempo de execução lançadas em tempo de execução, essas exceções geralmente ocorrem devido a uma programação incorreta.

Erro: Estas não são exceções, está além do escopo do programador. Esses erros geralmente são gerados pela JVM.

fonte da imagem

Diferença:

ClassNotFoundException:

• O carregador de classes falha ao verificar um código de byte de classe mencionado na fase Link do subsistema de carregamento de classe que obtemos ClassNotFoundException.
• ClassNotFoundExceptioné uma exceção verificada derivada diretamente da java.lang.Exceptionclasse e você precisa fornecer tratamento explícito para ela
• ClassNotFoundExceptionsurge quando há um carregamento explícito da classe, fornecendo o nome da classe em tempo de execução usando ClassLoader.loadClass (), Class.forName () e ClassLoader.findSystemClass ().

NoClassDefFoundError:

• O carregador de classes falha ao resolver as referências de uma classe na fase Link do subsistema de carregamento de classes que obtemos NoClassDefFoundError.
• NoClassDefFoundErroré um erro derivado da LinkageErrorclasse, usado para indicar casos de erro, nos quais uma classe depende de alguma outra classe e essa classe foi alterada incompativelmente após a compilação.
• NoClassDefFoundErroré o resultado do carregamento implícito da classe devido a uma chamada de método dessa classe ou a qualquer acesso variável.

Semelhanças:

• Ambos NoClassDefFoundErrore ClassNotFoundExceptionestão relacionados à indisponibilidade de uma classe em tempo de execução.
• Ambos ClassNotFoundExceptione NoClassDefFoundErrorestão relacionados ao caminho de classe Java.

Dadas as ações básicas do carregador de classes:

Este é um artigo que me ajudou muito a entender a diferença: http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-5.html

Se ocorrer um erro durante o carregamento da classe, uma instância de uma subclasse de LinkageError deverá ser lançada em um ponto no programa que (direta ou indiretamente) use a classe ou a interface que está sendo carregada.

Se a Java Virtual Machine tentar carregar uma classe C durante a verificação (§5.4.1) ou a resolução (§5.4.3) (mas não a inicialização (§5.5)), e o carregador de classe usado para iniciar o carregamento de C lança uma instância de ClassNotFoundException , a Java Virtual Machine deve lançar uma instância de NoClassDefFoundError cuja causa é a instância de ClassNotFoundException .

Portanto, um ClassNotFoundException é uma causa raiz de NoClassDefFoundError .
E um NoClassDefFoundError é um caso especial de erro de carregamento de tipo, que ocorre na etapa Vinculação .

Adicione um possível motivo na prática:

• ClassNotFoundException: como disse o cletus, você usa a interface enquanto a classe herdada da interface não está no caminho de classe. Por exemplo, o padrão do provedor de serviços (ou localizador de serviços ) tenta localizar alguma classe não existente
• NoClassDefFoundError: determinada classe é encontrada enquanto a dependência de determinada classe não é encontrada

Na prática, o erro pode ser gerado silenciosamente , por exemplo, você envia uma tarefa de timer e na tarefa de timer lança Error , enquanto na maioria dos casos, seu programa apenas captura Exception . Em seguida, o loop principal do timer termina sem nenhuma informação. Um erro semelhante ao NoClassDefFoundError é ExceptionInInitializerError , quando o inicializador estático ou o inicializador de uma variável estática lança uma exceção.

ClassNotFoundException é uma exceção verificada que ocorre quando dizemos à JVM para carregar uma classe por seu nome de string usando os métodos Class.forName () ou ClassLoader.findSystemClass () ou ClassLoader.loadClass () e a classe mencionada não é encontrada no caminho de classe.

Na maioria das vezes, essa exceção ocorre quando você tenta executar um aplicativo sem atualizar o caminho de classe com os arquivos JAR necessários. Por exemplo, você pode ter visto essa exceção ao executar o código JDBC para conectar-se ao seu banco de dados, ieMySQL, mas seu caminho de classe não possui JAR para ele.

O erro NoClassDefFoundError ocorre quando a JVM tenta carregar uma classe específica que faz parte da execução do seu código (como parte de uma chamada de método normal ou como parte da criação de uma instância usando a nova palavra-chave) e essa classe não está presente no seu caminho de classe, mas estava presente no momento da compilação porque, para executar seu programa, você precisa compilá-lo e, se estiver tentando usar uma classe que não esteja presente, o compilador gerará um erro de compilação.

Abaixo está a breve descrição

Você pode ler Tudo sobre ClassNotFoundException Vs NoClassDefFoundError para obter mais detalhes.

Lembro-me o seguinte repetidamente quando preciso atualizar

ClassNotFoundException

Hierarquia de Classes

ClassNotFoundException extends ReflectiveOperationException extends Exception extends Throwable

Durante a depuração

1. Jar obrigatório, a classe está ausente no caminho de classe.
2. Verifique se todos os jars necessários estão no caminho de classe da jvm.

NoClassDefFoundError

Hierarquia de Classes

NoClassDefFoundError extends LinkageError  extends Error extends Throwable

Durante a depuração

1. Problema ao carregar uma classe dinamicamente, que foi compilada corretamente
2. Problema com blocos estáticos, construtores, métodos init () da classe dependente e o erro real é quebrado por várias camadas [especialmente quando você usa spring, hiberna a exceção real é quebrada e você obtém NoClassDefError]
3. Quando você enfrenta "ClassNotFoundException" em um bloco estático da classe dependente
4. Problema com versões da classe. Isso acontece quando você tem duas versões v1, v2 da mesma classe em jar / packages diferentes, que foram compiladas com sucesso usando v1 e v2 são carregadas no tempo de execução que não possui os métodos / vars relevantes e você verá essa exceção. [Certa vez, resolvi esse problema removendo a duplicata da classe relacionada ao log4j em vários jars que apareciam no caminho de classe]

ClassNotFoundException e NoClassDefFoundError ocorrem quando uma classe específica não é encontrada no tempo de execução. No entanto, elas ocorrem em diferentes cenários.

ClassNotFoundException é uma exceção que ocorre quando você tenta carregar uma classe em tempo de execução usando os métodos Class.forName () ou loadClass () e as classes mencionadas não são encontradas no caminho de 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 é um erro que ocorre quando uma classe específica está presente no tempo de compilação, mas estava ausente no tempo de execução.

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

Quando você compila o programa acima, dois arquivos .class serão gerados. Um é A.class e outro é B.class. Se você remover o arquivo A.class e executar o arquivo B.class, o Java Runtime System exibirá NoClassDefFoundError como abaixo:

    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)