java - ignoreunknown - @jsonignoreproperties example

¿Es posible ignorar una excepción?

Question

En Java, es posible hacer que un método que tiene una declaración de throws no se compruebe.

Por ejemplo:

public class TestClass {
    public static void throwAnException() throws Exception {
        throw new Exception();
    }
    public static void makeNullPointer() {
        Object o = null;
        o.equals(0);//NullPointerException
    }
    public static void exceptionTest() {
        makeNullPointer(); //The compiler allows me not to check this
        throwAnException(); //I''m forced to handle the exception, but I don''t want to
    }
}

Answer 1

Como sé, es imposible en el caso. Sólo la excepción sin marcar, el compilador puede saltar para comprobar. como RuntimeException.

Answer 2

En Java hay dos tipos de Excepciones , Excepciones marcadas y Excepciones no marcadas.

• Exception es una excepción marcada, debe ser capturada o lanzada.
• NullPointerException es una RuntimeException (el compilador no obliga a que se declaren en los lanzamientos), puede ignorarlo, pero aún puede ocurrir en el Runtime , y su aplicación se bloqueará.

De la documentación de Exception :

La excepción de clase y las subclases que no son también subclases de RuntimeException son excepciones comprobadas. Las excepciones marcadas deben declararse en una cláusula de lanzamientos del método o del constructor si pueden ser lanzadas por la ejecución del método o constructor y propagarse fuera del límite del método o del constructor.

De la documentación de RuntimeException :

RuntimeException es la superclase de las excepciones que se pueden lanzar durante el funcionamiento normal de la máquina virtual de Java.

RuntimeException y sus subclases son excepciones sin marcar. Las excepciones no verificadas no necesitan declararse en una cláusula de lanzamientos del método o del constructor si pueden ser lanzadas por la ejecución del método o constructor y propagarse fuera del límite del método o del constructor.

Answer 3

Hay 3 cosas que puedes hacer:

• Lanzar una RuntimeException (o algo que extienda una RuntimeException , como NullPointerException , IllegalArgumentException , ...), no tiene que detectarlas porque son excepciones sin marcar.

• Capture la excepción y no haga nada (no recomendado):

  public static void exceptionTest() {
      makeNullPointer(); //The compiler allows me not to check this
      try {
          throwAnException(); //I''m forced to handle the exception, but I don''t want to
      } catch (Exception e) {
          // Do nothing
      }
  }

• Cambie la declaración exceptionTest () para decir que lanza una Exception , y deje que el método que la llama capture la Exception y haga lo que sea apropiado:

  public static void exceptionTest() throws Exception {
      makeNullPointer(); //The compiler allows me not to check this
      throwAnException(); //I''m no more forced to handle the exception
  }

Answer 4

Lanzar una excepción RuntimeException o una excepción que se deriva de RuntimeException . Entonces el compilador no te obligará a atraparlo.

Answer 5

Las otras respuestas son correctas, en el sentido de que te dicen correctamente lo que debes hacer, pero en realidad es posible lanzar una excepción comprobada no declarada. Hay algunas maneras en que esto se puede hacer; el más simple es:

public void methodThatSecretlyThrowsAnException() {
    Thread.currentThread().stop(new Exception());
}

o si su objetivo es envolver un método existente que declare su excepción

public void methodThatSecretlyThrowsAnException() {
    try {
        methodThatAdmitsItThrowsAnException();
    } catch(final Exception e) {
        Thread.currentThread().stop(e);
    }
}

(No hace falta decir que nunca debes hacer esto).

Answer 6

No es recomendable evitar una excepción con un bloque catch vacío, aunque esté completamente seguro de que no fallará bajo ninguna circunstancia. A veces, no somos conscientes del factor humano.

Si está seguro de que es muy poco probable que ocurra una excepción (si no es imposible), debe crear su propia excepción y envolver la excepción inesperada en ella.

Por ejemplo:

private class UnlikelyException extends RuntimeException {
    public UnlikelyException (Exception e){
        super (e);
    }
}

Luego envuelva su código con un bloque try-catch y lance su excepción, que no tiene que capturar

try {
    // Your code
} catch  (Exception e) {
    throw new UnlikelyException(e);
}

Answer 7

No, genera un error de compilación. Al ser una excepción marcada, debe atraparla o propagarla declarando que su método podría lanzarla. Revisa this y esto .

Answer 8

Puede utilizar una laguna en el compilador de Java. Agregue el siguiente código:

public RuntimeException hideThrow(Throwable e) {
    if (e == null)
        throw new NullPointerException("e");
    this.<RuntimeException>hideThrow0(e);
    return null;
}

@SuppressWarnings("unchecked")
private <GenericThrowable extends Throwable> void hideThrow0(Throwable e) throws GenericThrowable {
    throw (GenericThrowable) e;
}

Puede capturar la excepción y luego invocar a hideThrow con la excepción para lanzarla sin que el compilador se dé cuenta. Esto funciona debido a la eliminación de tipo. En tiempo de compilación, GenericThrowable representa RuntimeException porque eso es lo que estamos pasando. En el tiempo de ejecución, GenericThrowable representa GenericThrowable porque ese es el tipo básico en la especificación de parámetro de tipo.

Answer 9

Puedes intentar y no hacer nada al respecto:

public static void exceptionTest() {
    makeNullPointer(); //The compiler allows me not to check this
    try {
        throwAnException(); //I''m forced to handle the exception, but I don''t want to
    } catch (Exception e) { /* do nothing */ }
}

Tenga en cuenta que en la vida real esto es extremadamente desaconsejable . Eso puede ocultar un error y mantenerte buscando perros durante toda una semana, mientras que el problema era realmente un gato (ch). _{^{(Vamos, ponga al menos un System.err.println() allí. El registro es la mejor práctica aquí, como sugiere @BaileyS).}}

Las excepciones no verificadas en Java extienden la clase RuntimeException . Lanzarlos no exigirá una catch de sus clientes:

// notice there''s no "throws RuntimeException" at the signature of this method
public static void someMethodThatThrowsRuntimeException() /* no need for throws here */ {
    throw new RuntimeException();
}

Las clases que extienden RuntimeException no requerirán una declaración de throws también.

Y una palabra de Oracle al respecto:

Esta es la línea de fondo: si se puede esperar que un cliente se recupere de una excepción, conviértalo en una excepción comprobada. Si un cliente no puede hacer nada para recuperarse de la excepción, conviértalo en una excepción sin marcar.

Answer 10

Solo captura una excepción y no hagas nada con ella, déjala como está y captura la excepción genérica en caso de que no conozcas la excepción específica

try{
//Your logic goes here
}
catch(Exception e)//Exception is generic
{
//do nothing
}