remota - java ioexception error minecraft

¿Cuándo podría lanzarse un IOError?

Question

Nunca he visto un caso cuando se lanza un IOError . Lo único que dicen los documentos sobre IOError es esto:

Se lanza cuando se ha producido un error grave de E / S.

No hay subclases ni nada obvio.

¿Hay algún caso en el que IOError se lance en java? ¿Qué podría causarla?

(Esto no debe confundirse con la IOException : la IOException se presenta en una amplia gama de casos y se usa comúnmente; lo sé. Me estoy preguntando acerca del IOError menos común).

Answer 1

¿Hay algún caso en el que IOError se lance en java?

import java.io.IOError;

public class Test {

    public static void main(String[] args) {
        throw new IOError(new Exception());
    }

}

resultará en

Exception in thread "main" java.io.IOError: java.lang.Exception
    at test.Test.main(Test.java:13)
Caused by: java.lang.Exception
    ... 1 more
Java Result: 1

Creo que esperas un caso que es más probable que suceda.

Se IOError un IOError , por ejemplo, cuando se intenta leer desde una consola donde se ha cerrado la secuencia de entrada.

Puedes intentar ejecutar este fragmento

import java.io.*;

public class Test {

    public static void main(String[] s) {
        Console con = System.console();
        try {
            InputStreamReader reader = new InputStreamReader(System.in);
            reader.close();
            String st = con.readLine("%s", "Enter a line");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IOError error) {
            error.printStackTrace();
        }
    }
}

Eso resultaría en

java.io.IOError: java.io.IOException: Stream Closed
    at java.io.Console.readLine(Console.java:254)
    at Test.main(Test.java:10)
Caused by: java.io.IOException: Stream Closed
    at java.io.FileInputStream.readBytes(Native Method)
    at java.io.FileInputStream.read(FileInputStream.java:246)
    at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
    at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
    at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
    at java.io.Console$LineReader.read(Console.java:437)
    at java.io.Console.readline(Console.java:376)
    at java.io.Console.readLine(Console.java:250)
    ... 1 more

Answer 2

Aquí hay una explicación de Mark Reinhold de Oracle:

La nueva clase IOError se definió en combinación con la nueva clase java.io.Console. Se utiliza en situaciones en las que se produce un error de E / S irrecuperable y la respuesta más adecuada es terminar el programa en lugar de intentar manejar la excepción.

La clase IOError, junto con muchas otras mejoras, se documentará en la próxima revisión de mantenimiento del Mustang en el JCP.

http://cafe.elharo.com/blogroll/undocumented-changes-in-java-6-mustang-ioerror/

Answer 3

Solo para agregar a esto, la biblioteca de gestión de dominios RedHat JBoss Wildfly lanza explícitamente IOError para su interfaz ConsoleWrapper . La única implementación que he visto, hasta ahora de la interfaz es la clase JavaConsole .

Fuente:

/*
 * JBoss, Home of Professional Open Source.
 * Copyright 2012, Red Hat, Inc., and individual contributors
 * as indicated by the @author tags. See the copyright.txt file in the
 * distribution for a full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */

package org.jboss.as.domain.management.security.adduser;

import java.io.IOError;
import java.util.IllegalFormatException;

/**
 * Wrap the console commands
 *
 * @author <a href="mailto:[email protected]">Flemming Harms</a>
 */
public interface ConsoleWrapper<T> {

    /**
     * Writes a formatted string to this console''s output stream using
     * the specified format string and arguments.
     * see <a href="../util/Formatter.html#syntax">Format string syntax</a>
     * @param fmt
     * @param args
     */
    T format(String fmt, Object ...args) throws IllegalFormatException;

    /**
     * A convenience method to write a formatted string to this console''s
     * output stream using the specified format string and arguments.
     *
     * @param format
     * @param args
     * @throws IllegalStateException
     */
    void printf(String format, Object ... args) throws IllegalFormatException;

    /**
     * Provides a formatted prompt, then reads a single line of text from the
     * console.
     *
     * @param fmt
     * @param args
     * @return A string containing the line read from the console, not
     *          including any line-termination characters, or <tt>null</tt>
     *          if an end of stream has been reached.
     * @throws IOError
     */
    String readLine(String fmt, Object ... args) throws IOError;

    /**
     * Provides a formatted prompt, then reads a password or passphrase from
     * the console with echoing disabled.
     *
     * @param fmt
     * @param args
     * @return  A character array containing the password or passphrase read
     *          from the console.
     * @throws IOError
     */
    char[] readPassword(String fmt, Object ... args) throws IllegalFormatException, IOError;

    /**
     *  Return the console object
     *
     * @return Return the console object
     */
    T getConsole();
}

Answer 4

Una fuente oficial a buscar es la Base de datos de errores de Java, donde puede buscar errores relacionados con IOError utilizando la palabra clave de búsqueda. Esto puede mostrar algunos casos reales relacionados con este error.

Una incidencia que hace referencia directamente a este error (al menos eso es lo que he podido encontrar) fue en JDK-6347312 que se ocupa de Console.readLine() .

También hay pocos usos en el JDK. Lo más probable es que se use para señalar una IOException "crítica" que la persona que llama no debe manejar (como es el caso con otras excepciones de tiempo de ejecución).

Answer 5

Console , Path#toAbsolutePath y Path#toUri declaran que se Path#toUri esta excepción en particular. Por supuesto, eso es un hecho de documentación y no una declaración real; ya que Error es una excepción de tiempo de ejecución, declarar que se incluirá en la firma no tendría ningún significado.

Por lo que parece en el código, Console#readLine y Console#readPassword capturan una IOException que resulta de su operación normal, luego la propagan a un IOError .

Esencialmente, IOError representa una falla crítica del sistema de archivos subyacente, o el acceso a algún recurso que vincula a Java con el sistema de archivos. No se lanza con frecuencia , pero tiene el potencial de ser lanzado si algo serio sucede dentro del sistema de archivos.

Answer 6

IOError rara vez se utiliza. Creo que su mayor base de datos está en java.io.Console#readLine() y readPassword() , que de forma predeterminada no arroja IOExeption (sino que lo envuelve) para señalar problemas de E / S.

Supongo que la motivación para esto es que es tan poco frecuente que no quisieran declarar una excepción marcada. Puede suceder cuando los terminales tienen problemas, y esto es hoy en día donde ya no tiene líneas de serie, solo ocurre en condiciones severas del sistema, como quedarse sin memoria o controladores.

Answer 7

IOError es una excepción de tiempo de ejecución y se clasifica en la categoría de error, es una excepción no comprobada. Para mí, esto parece ocurrir cuando interactúa con el sistema utilizando las llamadas JNI / nativas de la JVM a las llamadas del sistema operativo subyacente. Esto podría ser obtener acceso a los dispositivos IO (almacenamiento, teclado, pantalla, red, etc.). Pero apenas he visto que se use en los documentos de la API de Java. La mayoría de las razones probablemente se deba a que los implementadores querían mantener la dependencia del sistema subyacente al mínimo.