Try-catch-finally / Try-with-resources

Estuve leyendo un dato importante que para poder usar el try catch wit resourses la clase debe implementar la interfaz AutoCloseable sino no va a funcionar.

Mal estoy en esos momentos donde nose que es lo que estoy haciendo, entre mas avanzo menos sentido me encuentro 😕

¿ es eso normal ?

ref: https://docs.oracle.com/javase/tutorial/essential/exceptions/QandE/answers.html

Cuando quieres convertir una cadena a un número.

public static void main(String[] args) {
	String cadena = "Hola";
	int numero;

	try {
		numero = Integer.parseInt(cadena);
	} catch(NumberFormatException e) {
		System.out.println("No es un número es una cadena");
	}
}

public static void main(String[] args) {
	String fileName = "C:/test.txt";

	try {
		ReadFile file = new ReadFile(fileName);
		String[] arrayLines = file.OpenFile();
	} catch(Exception e) {
		System.out.println(e.getMessage());
	}
}

y si se crean clases genéricas de manejo de errores es decir que en vez de ser manejado el error directamente en código envié el error a una clase superior ejemplo

public class FacturadorException extends Exception{
    
    private int codigo;
    private String mensaje;
    private Object datos;

    public FacturadorException(EMensajes mensaje){
        this.codigo = mensaje.getCodigo();
        this.mensaje = mensaje.getDescripcion();
    }
    
    public FacturadorException(EMensajes mensaje,Object datos){
        this.codigo = mensaje.getCodigo();
        this.mensaje = mensaje.getDescripcion();
        this.datos = datos;
    }
    
    /**
     * @return the codigo
     */
    public int getCodigo() {
        return codigo;
    }

    /**
     * @param codigo the codigo to set
     */
    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    /**
     * @return the mensaje
     */
    public String getMensaje() {
        return mensaje;
    }

    /**
     * @param mensaje the mensaje to set
     */
    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    /**
     * @return the datos
     */
    public Object getDatos() {
        return datos;
    }

    /**
     * @param datos the datos to set
     */
    public void setDatos(Object datos) {
        this.datos = datos;
    }
    
    
    
}

y otra clases enum

public enum EMensajes {

    INSERTO(1, "Se insertó correctamente"),
    MODIFICO(1, "Se modificó correctamente"),
    ELIMINO(1, "Se eliminó correctamente"),
    CONSULTO(1, "Se ha consultado correctamente"),
    ERROR_INSERTO(-1, "Error al insertar el registro"),
    ERROR_MODIFICO(-1, "Error al modificar el registro"),
    ERROR_ELIMINO(-1, "Error al eliminar el registro"),
    ERROR_CONSULTO(-1, "Error al consultar el registro"),
    ERROR_REGISTRO_EXISTE(-1, "El registro ya existe"),
    ERROR_CONEXION_BD(-2, "No hay conexión con la base de datos");

    private int codigo;
    private String descripcion;

    private EMensajes(int codigo, String descripcion) {
        this.codigo = codigo;
        this.descripcion = descripcion;
    }

    /**
     * @return the codigo
     */
    public int getCodigo() {
        return codigo;
    }

    /**
     * @param codigo the codigo to set
     */
    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    /**
     * @return the descripcion
     */
    public String getDescripcion() {
        return descripcion;
    }

    /**
     * @param descripcion the descripcion to set
     */
    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

}

clase que genera la excepción

public final class BdConexion {
    
    public static Connection conectar() throws FacturadorException {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection cnn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/facturador_db",
                    "root",
                    "1234"
            );
            cnn.setAutoCommit(false);
            return cnn;
        } catch (ClassNotFoundException | SQLException ex) {
            throw new FacturadorException(EMensajes.ERROR_CONEXION_BD);
        }        
    ```
esto seria una buena practica para majar los errores ?

Try-with-resources

Cuando un método es susceptible a un error, se usa el try - catch o incluso para cualquier linea de código es buena practica que siempre esté dentro de un try - catch, estos errores o exceptions se verán reflejados en el cliente, por ende se deben imprimir o entregar como información HTTP, y para esto hay una asignación ‘throw exception’ que se debe insertar en los métodos que sean llamados por otras clases o por la clase principal que ejecuta, así siendo apto el método para lanzar las errores y la clase que ejecuta pueda capturarlos.

Acá les comparto un pequeño proyecto que busca un archivo (nombre completo con extensión) en una ruta dada del sistema operativo, y escribe las rutas donde lo encontró en un archivo de nombre paths.txt
String fileSearch: nombre completo del archivo a buscar.
String pathSearch: ruta absoluta en la que queremos buscar el archivo.

En este proyecto hice uso del bloque de control Try-Catch con parámetros:

package entryPoint;

import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

public class Main {

    public static void main(String[] args) {
        String fileSearch = args[0];
        String pathSearch = args[1];
        String finalFile = "paths.txt";
        try (PrintWriter writer = new PrintWriter(finalFile, StandardCharsets.UTF_8)) {
            Files.walkFileTree(Paths.get(pathSearch),
                new SimpleFileVisitor<>() {
                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                        if (file.endsWith(fileSearch))
                            writer.println(file);
                        return FileVisitResult.CONTINUE;
                    }

                    @Override
                    public FileVisitResult visitFileFailed(Path file, IOException e) {
                        if (file.endsWith(fileSearch))
                            writer.println(file);
                        return FileVisitResult.SKIP_SUBTREE;
                    }

                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                        if (dir.endsWith(fileSearch))
                            writer.println(dir);
                        return FileVisitResult.CONTINUE;
                    }
                });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

https://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf

Encontré un caso especial de uso detry catch with resources dentro de un método, se obvia la declaracion del catch en lugar de ello se lo coloca en la declaracion del metodo

 throws IOException```

static String readFirstLineFromFile(String path) throws IOException {
try (BufferedReader br =
new BufferedReader(new FileReader(path))) {
return br.readLine();
}
}```

Muy interesante lo que se va añadiendo en las versiones de java.

Podráne encontrar mucha más información aquí. Por cierto, les recomiendo los post y tutoriales de baeldung.

public class MyClass {
public static void main(String[] args) {
try {
int[] myNumbers = {1, 2, 3};
System.out.println(myNumbers[10]);
} catch (Exception e) {
System.out.println(“Something went wrong.”);
}
}
}

The throw keyword
The throw statement allows you to create a custom error.

The throw statement is used together with an exception type. There are many exception types available in Java: ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc:

Hola, solo como observación try-cath-with-resources esta disponible desde JAVA 7, no desde la versión 9.

En la web se encuentra demasiada información de JAVA; sabe alguien donde encuentro ejercicios básicos y avanzados para la practica de todos estos temas tan interesantes que hemos visto hasta este momento y los que me faltan ver. Gracias Compañeros

La sentencia finally realiza una ejecución incondicional ya que, incluso si el try o el catch tuvieran un return que se alcanzara a ejecutar, el contenido de finally se ejecutaría de todas formas.

++Las ocasiones en las que no se ejecutaría serían:
++

1. Se llama a System.exit() (System.exit(0)).
2. En caso de que Java Virtual Machine (JVM) tenga un fallo primero(crashes)

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        try (BufferedReader r1 = reader) {
            //System.exit(0); //No imprime ningún System.out.println

            System.out.println("en el try");
            return;
        } catch(Exception ex) {
            System.out.println("en el catch");
        } finally {
            System.out.println("en el finally");
        }

Solo les comento que he usado Try-with-resources con la versión 8 de java y funciona sin problema.

un caso de uso podria ser cuando queremos actualizar los datos de una grafica cada determinado tiempo, para eso utilizo Threads. ejemplo:

package util;

public class Hilo implements Runnable{

    private Graph graph;
    
    public Hilo(Graph graph) {
        this.graph = graph;
    }
    
    @Override
    public void run() {
        
        while(true) {

            try {
                graph.updateGraph();
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

try en ingles significa intentar su función es intentar capturar los errores para pasarlo al bloque catch para devolver un excepcion entre estos excepción existen varios tipos donde se escoge el error a captar según sea el caso

Buen día comunidad, deseando lo mejor para ustedes.
Encontre en github un ejemplo interesante.
Les dejo el enlace https://github.com/liubo-tech/redis-distribute-lock
y link util https://redis.io/topics/distlock
Ejemplo del try-with-resources:

@SpringBootApplication
public class Application {
    private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class, args);
        RedisTemplate redisTemplate = applicationContext.getBean("redisTemplate",RedisTemplate.class);

        try (RedisLock lock = new RedisLock(redisTemplate,"test_key","test_val",60)){
            //obtener el bloqueo
            if (lock.getLock()){
                //Simular ejecucion de negocios
                Thread.sleep(5*1000);
                LOGGER.info("Obtener la cerradura，se tarda 5 segundos para realizar operaciones");
            }
        }catch (Exception e){
            LOGGER.error(e.getMessage(),e);
        }
    }
}

El código anterior muestra como se realiza un bloqueo distribuido, en este caso el try-with-resources se utiliza para liberar el bloqueo.

En este caso tambien nosotros podremos lanzar nuestra propia exception en el proceso con el throw y creando la exception

Ejemplo

</*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package exception;

/**
 *
 * @author wilso
 */
public class Numerico extends RuntimeException {
    
    

}
>

Para comentar recordemos que tambien podremos manejar excepciones propias

Definicion

El lenguaje Java proporciona las clases que manejan casi cualquier tipo de excepción. Sin embargo, podemos imaginar situaciones en la que producen excepciones que no están dentro del lenguaje Java. Siguiendo el ejemplo de la página anterior estudiaremos una situación en la que el usuario introduce un valor fuera de un determinado intervalo, el programa lanza un excepción, que vamos a llamar ExcepcionIntervalo.

Fuente tomada de

Yo use try/catch en mi metodo para recibir la respuesta del usuario en los menus, y ahora lo modifique a try with resource:

public static int getResponse(int min, int max) {
		Scanner sc = new Scanner(System.in);
        int resp;
        try (sc)
        {
            resp = sc.nextInt();
            if (resp < min || resp > max) {
            	System.out.println("Please enter a valid response between " + min + " and " + max);
            	resp = getResponse(min, max);
            }
        }
        catch (Exception e)
        {
            System.out.println("Please enter a number...\n");
            resp = getResponse(min,max);
        }
        return resp;
	}

Si me quedo muy claro la diferencia, ojalá que mas adelante podamos provocar estos tipos de excepciones para podersaber como resolverlos en la práctica 😄

Un ejemplo de código que lee una línea de un fichero

public static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

Este ejemplo lo encontre en internet pero les comparto por q me parece muy bueno. vemos como el try puede cerrar multiples objetos.

try (Connection connection = getConnection();
Prepared pStatement = connection.prepareStatement(sql);
ResultSet resultSet = pStatement.executeQuery()) {
while (resultSet.next()) {
// gestionar resultset
}
} catch (SQLException e) {
throw newException;
}

Un ejemplo muy ilustrativo

response.setHeader("Content-Disposition", "attachment;filename=" + archivoNOMBRE);
try (InputStream is = new FileInputStream(RUTAARCHIVO); OutputStream os = response.getOutputStream()) {
  byte[] bytes = newbyte[4096];
  int leidos;
       while ((leidos = is.read(bytes)) != -1) {
            os.write(bytes, 0, leidos);
      }
}

“Cerraduras de Recursos”? eso esta bien dicho? xD

public static void main(String arg[]){
int [] array = new int[20];
try {
	array[-3] = 24;	
}
catch (ArrayIndexOutOfBoundsException E ) {
	System.out.println(" Error de índice en un array");
 }

Cuando no existe el dato en un ArrayList

public class ArrayIndexOutOfBound {

	public static void main(String[] args) {

		ArrayList<Integer> Reto = new ArrayList();
		Reto.add(1);
		Reto.add(2);
		Reto.add(3);
		Reto.add(4);
		Reto.add(5);
		Reto.add(6);
		Reto.add(7);
		try {
			Reto.get(11);
		} catch (ArrayIndexOutOfBoundsException e) {
		}
	}

}

Cuando divides algo entre 0

	public static void main(String[] args) {
		
		int a = 20;
		int b = 0;
		try {
			a = a / b;
		} catch (ArithmeticException e) {
			e.printStackTrace();
		}
}

Cuando intentas parsear un String a Int

	public static void main(String[] args) {
		
		int a = 20;
		int b = 0;
		String c = "Hola";
		try {
			a = Integer.parseInt(c);
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
}

Podemos tener mas de una excepcion en nuestros bloque de try catch. En lugar de manejarlas como:

try {
    ...     
} catch (IOException e) {
    someCode();
} catch (SQLException e) {
    someCode();
} 

Podemos manejarlas en un solo bloque de catch:

try { 
  ...
} catch (IOException | SQLException ex) { 
  ...
}

Este es un ejemplo donde utilizando un objeto Throwable se genera una excepción de manera intencional:

package com.moisescode.prueba;

public class Main {

	public static void main(String[] args) throws Exception {
		try {
            throw new NullPointerException("Sentencia de excepción");
            //Cualquier otra linea de codigo que agreguemos no será ejecutada
        } catch( NullPointerException e ) {
            System.out.println( "Se capturó la excepción" );
            throw e;
            }
        }
	}

Entiendo que esto nos puedes ser útil para hacer pruebas dentro de nuestro programa.

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int num1, num2;
		try {
			num1=0;
			num2=10/num1;
			System.out.println("La división es: "+ num2);
		}catch (ArithmeticException e) {
			// TODO: handle exception
			System.out.println("no puede dividir un número para cero");
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("Error ocurrido al dividir los valores");
		}
		
	}
}

En Java 9, como ejemplo el acceso a una base de datos asegurando el código on un try catch sin el finally:

public void loadDataFromDB() throws SQLException {
    Connection dbCon = DriverManager.getConnection("url", "user", "password");
    try (dbCon; ResultSet rs = dbCon.createStatement().executeQuery("select * from emp")) {
        while (rs.next()) {
            System.out.println("In loadDataFromDB() =====>>>>>>>>>>>> " + rs.getString(1));
        }
    } catch (SQLException e) {
        System.out.println("Exception occurs while reading the data from DB ->" + e.getMessage());
    }
}```

Otro ejemplo tomado de la documentación de Java 9:

public static void viewTable(Connection con) throws SQLException {

String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";

try (Statement stmt = con.createStatement()) {
    ResultSet rs = stmt.executeQuery(query);

    while (rs.next()) {
        String coffeeName = rs.getString("COF_NAME");
        int supplierID = rs.getInt("SUP_ID");
        float price = rs.getFloat("PRICE");
        int sales = rs.getInt("SALES");
        int total = rs.getInt("TOTAL");

        System.out.println(coffeeName + ", " + supplierID + ", " + 
                           price + ", " + sales + ", " + total);
    }
} catch (SQLException e) {
    JDBCTutorialUtilities.printSQLException(e);
}

}```

    public Connection abrirConexionPG() {
         Connection conPosgress=null;
         DataSource odsPosgrest=null;
        try {
            Context ctx = new InitialContext();
            odsPosgrest = (DataSource) ctx.lookup("NombreMiDataSource");
            conPosgress = odsPosgrest.getConnection();
         
        } catch (SQLException | NamingException ex) {
            Logger.getLogger(ConfigDB.class.getName()).log(Level.SEVERE, null, ex);
        }

           return conPosgress;
    }```

les comparto este pdf esta muy bueno si quieren profundizar algo

Todo muy claro Anahí. Excelente docente.

try (Scanner scanner = new Scanner(new File("test.txt"))) {
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException fnfe) {
    fnfe.printStackTrace();
}```

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	
	try(br){
		String texto = br.readLine();
	}catch(IOException e) {
		e.getMessage();
	}```

Tambien se puede personalizar la excepciones, herendando la clase excepcion, a continuacion un link en donde se muestra un ejemplo
https://sites.google.com/site/pilasexcepcionesjava/

finally super interesante

public class MyClass {
  public static void main(String[ ] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    }
  }
}```

Mi ejemplo para seleccionar un imagen en android

 switch (requestCode) {
            case SELECT_FILE:
                if (resultCode == Activity.RESULT_OK) {
                    selectedImage = imageReturnedIntent.getData();
                    String selectedPath = selectedImage.getPath();
                    if (requestCode == SELECT_FILE) {

                        if (selectedPath != null) {
                            InputStream imageStream = null;
                            try {
                                imageStream = getActivity().getContentResolver().openInputStream(
                                        selectedImage);
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();
                            }

                            // Transformamos la URI de la imagen a inputStream y este a un Bitmap
                            Bitmap bmp = BitmapFactory.decodeStream(imageStream);

                            // Ponemos nuestro bitmap en un ImageView que tengamos en la vista

                            imagenPrducto.setImageBitmap(bmp);

                        }
                    }
                }
                break;
        }****```

El recurso usado en el try-with-resources se cerrara automáticamente, y no es necesario definir una varible en el try sino directamente pasarle una ya instanciada

///Antes
try {
connection = dataSource.getConnection();
ps = connection.prepareStatement(SQL_UPDATE_POST_META);
ps.setString(1, metaValue);
ps.executeUpdate();

    } catch (Exception e) {
        //
    } finally {
        if (ps != null) {
            ps.close();
        }
        if (connection != null) {
            connection.close();
        }
    }

//Try catch with resources
try (Connection connection = dataSource.getConnection();
PreparedStatement ps = connection.prepareStatement(SQL_UPDATE_POST_META)) {
ps.setString(1, metaValue);
ps.setInt(2, postId);
ps.setString(3, GlobalUtils.META_KEY);

        ps.executeUpdate()

    } catch (Exception e) {
        //...
    }

Bueno de todos los cursos que vi utilizaron bastante esto, pero este es el primer curso que explican claramente el por que y para que. Genial.

I have a example about this:

try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    }

When we can use Finally:
The finally statement lets you execute code, after try…catch, regardless of the result:

Try Catch Finally

Gracias por la explicación 😃

😃

try(BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))){
writer.write(str); // do something with the file we’ve opened
}
catch(IOException e){
// handle the exception
}

Muy bien, con el uso de estas herramientas podremos capturar los errores para saber que esta fallando en nuestro proyecto. Acá comparto un ejemplo de try catch:

class Test{
 public static void main(String args[]){
  int numero;
  String cadena="  1";
  try{
    numero = Integer.parseInt(cadena);
  }
  catch(NumberFormatException ex){
    System.out.println("No es un número, es una cadena de texto.");
  }
 }
}

try (PrintStream stream = new PrintStream(“hello.txt”)) {
stream.println(“Hello world!”);
} catch (FileNotFoundException ex) {
System.err.println(“Cannot open the file”);
} finally {
System.err.println(“All done”);
}

Ele ejemplo de necesidad de try/catch que más veo en mi trabajo es para consumir APIs de terceros…
Casi siempre están caidos los servicios y/o hacen modificaciones que no documentan ni avisan y esto provoca instabilidades en la interpretación de la respuesta que no podemos permitir que afecten la ejecución de la app… Pero no me queda del todo claro si es esto una buena práctica 😄