Mantenimiento de una tabla en Oracle con Java y JSP – Anexo 04 – SQLException.

Capa BD
01. Crear una BD en Oracle.
02. Crear una Tabla con clave primaria.
03. Crear un secuenciador.
04. Implementar sentencias para mantenimiento de la tabla.
05. Crear un package en la BD.
06. Crear un SP con un cursor como parametro de salida.
07. Crear un SP para devolver nombres similares de un campo.

Applicacion Web
08. Crear Un proyecto Web en Java.

Capa modelo
09. Crear Una clase Entidad (una clase simple).
10. Obtener una Conexión hacia la BD.
11. Crear un Statement simple.
12. Crear un PreparedStatement con parametros.
13. Crear un CallableStatement con un cursor como parametro de salida.

Capa Controlador
14. Crear un Servlet Controlador.

Capa Vista
15. Crear una pagina JSP con un formulario.

Anexos
01. Cadena de conexión.
02. Interface connection.
03. Clase OracleDataSource.
04. SQLException.
05. try – catch.
06. RequestDispatcher.

SQLException

 

Que es :

 
La detección de errores y su manejo puede ser lo mas importante en cualquier aplicación robusta. Java tiene un elegante mecanismo para manejar errores que produce un código eficiente y organizado : el manejo de excepciones.
Este mecanismo usa objetos error y excepcion para manejar todo, desde una condicion end-of-file hasta un error de out-of-memory. Tambien provee un mecanismo que obliga a los usuarios de su codigo a incluir el manejo de excepciones.

java.lang.Object
   +-- java.lang.Throwable
           +---- java.lang.Error
           |        +-- a whole bunch of errors
           |
           +---- java.lang.Exception
                    +---- java.lang.RuntimeException
                    |        +-- various unchecked exceptions
                    +-- various checked exceptions

Como podemos ver, hay dos clases que derivan de Throwable. Exception y Error. Las clases que derivan de Error representan situaciones inusuales que no son causadas por errores del programa e indica cosas que no suceden normalmente durante la ejecución del programa, como la JVM ejecutando fuera de memoria. Generalmente, una aplicación no podrá recuperarse de un error, así que no requiere que la manejen. Si tu código no lo maneja, compilara sin problemas. Aunque a menudo son considerados como condiciones excepcionales, los errores no son técnicamente excepciones porque no derivan de la clase Exception.

En general, una excepción representa algo que no sucede como resultado de un error de programación, si no mas bien porque algún recurso no esta disponible o alguna otra condición requerida para su correcta ejecución no esta presente, que lo diferencia de un error porque este no tiene algo que lo relacione con el programa y mucho menos una condicion.
Los errores simplemente ocurren y uno no puede tener control sobre su aparicion. Las excepciones en cambio son eventos que han sido considerados y son previsibles, sino no podriamos identificarlos con un manejador adecuado.

Java proporciona muchas clases de excepciones, muchas de las cuales tienen nombres descriptivos. Hay dos maneras de obtener información de una excepción. La primera es desde el mismo tipo de la excepción. Es desde la información que podemos obtener del objeto de la excepción. La clase Throwable ofrece algunos métodos que son útiles a la hora de manejar excepciones. Uno de estos es printStackTrace(), que nos muestra una traza desde donde ocurrió la excepción.

Varias situaciones pueden generar una excepcion, incluyendo fallos de hardware, falta de recursos, y errores de programacion . Cuando un evento excepcional ocurre en Java, una excepción es “lanzada”. El código que es responsable de hacer algo con la excepción es el “manejador de excepción” y captura las excepciones que se “lanzan”.
El manejo de excepciones funciona mediante la transferencia de la ejecución de un programa a un manejador de excepciones apropiado. Por tanto nosotros necesitamos una manera de decirle a la JVM que código ejecutar cuando sucede una cierta excepción.

Al trabajar con JDBC, usaremos la clase SQLException. SQLException hereda de java.lang.Exception, y es la clase especializada en manejar los eventos originados por fallos cuando se usa para tareas relacionadas con las BDs, como conexiones, consultas, u otra operación relacionada con la BD.

Exception

 

Como se usa :

 

 


package ejemplo;

import java.sql.*;

public class SqlException {

    public static void main(String[] args) {
        //Declare Connection,Statement, and ResultSet variables
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        //Begin standard error handling
        try {
            //Registrar el driver
            String driver = "oracle.jdbc.driver.OracleDriver";
            Class.forName(driver).newInstance();

            System.out.println("Connecting to database...");
            String jdbcUrl = "jdbc:oracle:thin:@masterpc:1521:Quadro";
            conn = DriverManager.getConnection(jdbcUrl, "System", "12345");
            stmt = conn.createStatement();
            try {
                rs = stmt.executeQuery("Select * from no_table_exisits");
            } catch (SQLException seRs) {
                String exMsg = "Message from mySqlEx";
                String exSqlState = "Not set by me";
                SQLException mySqlEx = new SQLException(exMsg, exSqlState);
                seRs.setNextException(mySqlEx);
                throw seRs;
            }
        } catch (SQLException se) {
            int count = 1;
            //Loop through exception and retrieve messages
            while (se != null) {
                System.out.println("SQLException " + count);
                System.out.println("Code: " + se.getErrorCode());
                System.out.println("SqlState: " + se.getSQLState());
                System.out.println("Error Message: " + se.getMessage());
                //Load next SQLException
                se = se.getNextException();
                count++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }//end try

        finally {
            //block finally usado para cerrar recursos
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException se) {
                se.printStackTrace();
            }//fin finally try
    }//end main
}//end SqlException

 

Como funciona :

 
Se debe importar el paquete java.sql.*
En el ejemplo se hace una consulta a una clase no existente, lanzando un objeto SQLException que formara parte de la traza de informacion del error. Se usan tambien try y catch que se vera en el sgte tema.

 

Hay mas

Esta clase tiene ademas la sgte informacion :
Information : Explicacion
Error message : Una cadena que contiene un mensaje explicando el error.
Error code : codigo especifico del vendedor.
SQLState : identificador SQLState basado en la especificacion X/Open. Su DBS debe tener una lista de estos codigos de error standard en la industria.

Es importante entender que causa las excepciones y errores y de donde vienen. Vamos definir dos grandes categorías de excepciones y errores:

Excepciones JVM: Estas excepciones o errores que son exclusivas o mas, lógicamente, lanzadas por la JVM.
Excepciones programáticas: Estas excepciones son lanzadas explicitamente por la aplicación y/o la API de los programadores.

Excepciones programáticas:

Ahora vamos a ver como lanzar excepciones programaticamente, es decir, creado por una aplicación y o API de desarrollador.
Por ejemplo, muchas clases en la API de Java tienen métodos que toman argumentos String y convierte esos String a numericos primitivos.
En algún momento hace mucho tiempo, un programador escribio la clase java.lang.Integer y creo métodos como parseInt() y valueOf(). Este programador decidio que cuando el String no se pudiese convertir a un numero, el método lanzaria un NumberFormatException. El código implementado parcialmente puede ser algo como esto:

int parseInt (String s) throws NumberFormatException {
  boolean  parseSuccess = false;
  int result = 0;
  // do complicated parsing
  if (!parseSuccess)   // if the parsing failed
    throw new NumberFormatException();
  return result;
}

 

Ver tambien :

 
Java 2™ Programmer Exam Cram™ 2,By Bill Brogden, Marcus Green, Chapter 8 : Exceptions and Assertions.

Java Data Access—JDBC, JNDI, and JAXP, Todd M. Thomas, Appendix C: JDBC Error Handling.

http://javaes.wikispaces.com/, Capítulo 5 – Control de Flujo, Excepciones y Assertions.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s