Conectar Java con MySQL usando

JDBC
4 febrero, 2010 por Herman Barrantes Dejar una respuesta »

Para conectar Java con cualquier base de datos lo primero es conseguir el Driver adecuado,

unDriver es una clase que sirve como interfaz entre nuestra aplicación y la base de datos.
Es lógico que Java (JDK) no cuenta con todos los Drivers para poderse conectar con todos los
motores de base de datos existentes en el mercado, por lo que en algunos casos es necesario
descargarlos de internet, en el caso de MySQL se puede descargar
desde:http://dev.mysql.com/downloads/connector/j/5.1.html
Si se esta usando NetBeans como IDE de trabajo no es necesario bajar este Driver ya que el
mismo NetBeans lo trae incorporado. En el caso de Eclipse es necesario bajar el Driver,
descomprimir el ZIP y añadirlo al proyecto, para esto damos con el botón derecho del ratón
sobre el proyecto, para sacar el menú y elegimos “properties”->”java build path”-
>”Libraries”->”Add external JARs…” y seleccionamos nuestro JAR (el que viene dentro del
ZIP que descargamos con el nombre de mysql-connector-java-x.x.x-bin.jar).
Para NetBeans en el árbol de nuestro proyecto damos con el botón derecho del ratón
sobre“Bibliotecas” para sacar el menú y elegimos “Agregar biblioteca…”

Les aparecera una venta como esta:

Seleccionamos “Driver MySQL JDBC” y los agregamos, en el árbol de proyecto se tiene que
ver el Driver que acabamos de añadir

Ya con el Driver instalado vamos ha hacer un ejemplo en el conectaremos nuestra

aplicación Javacon una base de datos MySQL, haremos una consulta sobre una tabla y
cerraremos la conexión.
Para este ejemplo crearemos una base de datos la cual llamaremos “javamysql” con una
única tabla llamada “persona”, corre el siguiente Script en MySQL
1 -- MySQL Administrator dump 1.4
2 --
3 -- ------------------------------------------------------
4 -- Server version   5.1.37-1ubuntu5

5  
6 /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
7 /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;

8 /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;

9 /*!40101 SET NAMES utf8 */;

10  
11 /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;

12 /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS,
FOREIGN_KEY_CHECKS=0 */;
13 /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE,
SQL_MODE='NO_AUTO_VALUE_ON_ZERO'*/;
14  
15 --
16 -- Create schema javamysql
17 --
18  
19 CREATE DATABASE IF NOT EXISTS javamysql;

20 USE javamysql;

21 CREATE TABLE  `javamysql`.`persona` (

22   `id` int(11) NOT NULL AUTO_INCREMENT,

23   `nombre` varchar(20) NOT NULL,

24   `sexo` char(1) NOT NULL DEFAULT 'M',

25   PRIMARY KEY (`id`)

26 ) ENGINE=MyISAM AUTO_INCREMENT=8 DEFAULT CHARSET=latin1;
27 INSERT INTO `javamysql`.`persona` VALUES  (1,'Herman','M'),

28  (2,'Ana','F'),
29  (3,'Carlos','M'),
30  (4,'Marta','F'),

31  (5,'José','M'),
32  (6,'Allan','M'),
33  (7,'Sonia','F');
34  
35 /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;

36 /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;

37 /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;

38 /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
39 /*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;

40 /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
41 /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
Bajar código fuente:
MySQL
Ahora, crearemos un proyecto de Java, en la clase Main copia el siguiente código fuente:
1 package javamysql;

2  
3 import java.sql.*;
4 //import java.util.logging.Level;
5 //import java.util.logging.Logger;
6  
7 /**
8  *
9  * @author herman barrantes
10  */

11 public class Main {

12  
13     //variables

14     private static Connection conexion;
15     private static String bd="javamysql";

16     private static String user="test";

17     private static String password="123";

18     private static String host="localhost";
19     private static String server="jdbc:mysql://"+host+"/"+bd;

20  
21     /**
22      * @param args the command line arguments
23      */

24     public static void main(String[] args) {
25         //conectar
26         try {

27             Class.forName("com.mysql.jdbc.Driver");
            conexion =
28
DriverManager.getConnection(server,user,password);
29  
            System.out.println("Conexión a base de datos
30
"+server+" ... OK");
31  
32         } catch (ClassNotFoundException ex) {
            System.out.println("Error cargando el Driver MySQL
33
JDBC ... FAIL");
            //Logger.getLogger(Main.class.getName()).log(Level.SEVER
34
E, null, ex);
35         } catch (SQLException ex) {
            System.out.println("Imposible realizar conexion con
36
"+server+" ... FAIL");
            //Logger.getLogger(Main.class.getName()).log(Level.SEVER
37
E, null, ex);
38         }

39  
40         //realizar consulta
41         try {
42             // Preparamos la consulta
43             Statement s = conexion.createStatement();
44             ResultSet rs = s.executeQuery ("select * from persona");
45  
            // Recorremos el resultado, mientras haya registros para
46
leer, y escribimos el resultado en pantalla.
47             while (rs.next())

48             {

49                 System.out.println(

50                         "ID: " +rs.getInt (1) +

51                         "tNombre: " + rs.getString (2)+

52                         "tSexo: " + rs.getString("sexo")

53                         );
54             }

55         } catch (SQLException ex) {
            System.out.println("Imposible realizar consulta ...
56
FAIL");
            //Logger.getLogger(Main.class.getName()).log(Level.SEVER
57
E, null, ex);
58         }

59  
60         //desconectar
61         try {
62             conexion.close();
63             System.out.println("Cerrar conexion con "+server+" ...
 OK");
64         } catch (SQLException ex) {
            System.out.println("Imposible cerrar conexion ...
65
FAIL");
            //Logger.getLogger(Main.class.getName()).log(Level.SEVER
66
E, null, ex);
67         }
68  
69     }
70  
71 }
Bajar código fuente:
Java
Al ejecutar el programa deberíamos de obtener como resultado algo como:
Conexión a base de datos jdbc:mysql://localhost/javamysql ... OK

ID: 1 Nombre: Herman Sexo: M

ID: 2 Nombre: Ana Sexo: F

ID: 3 Nombre: Carlos Sexo: M

ID: 4 Nombre: Marta Sexo: F

ID: 5 Nombre: José Sexo: M

ID: 6 Nombre: Allan Sexo: M

ID: 7 Nombre: Sonia Sexo: F

Cerrar conexion con jdbc:mysql://localhost/javamysql ... OK

Como pueden ver al principio del código fuente se hace import java.sql.*;, esto es para
importar las clases necesarias para trabajar bases de datos (todas en general no solo MySQL).
A partir de la línea 13 de este ejemplo podemos encontrar las variables para la conexión a la
base de datos, la mayoría de estas es obvio que función cumplen por lo que no lo voy a
explicar a profundidad, solo voy a mencionar que la variable host tiene como
valor “localhost” ya que el servidor de base de datos esta en el localhost de mi PC, este valor
puede ser cambiado por la IP o Nombre del equipo si el servidor se encuentra en otro equipo
en la red.
A partir de la línea 25 de este ejemplo podemos encontrar el método para conectarse a la base
de datos, Class.forName nos sirve para asegurarnos que el Driver se inicializa y se registra,
luego solo pediremos una conexion a la clase DriverManager mediante su
método getConnection. El método getConection puede recibir varios parámetros pero esos 3
son sufientes para nuestro ejemplo.
A partir de la línea 40 se usa la clase Statement de java para enviar
consultas. Statement tiene 2 metodos interesantes: executeUpdate y executeQuery. El
primero nos permitirá enviar consultas que modifiquen la base de datos (insert, update, delete,
etc) y el segundo nos permitirá hacer consultas que nos retornen valores (select, views, etc),
esos valores son guardados en un tipo de variable ResultSet que luego nos servirá para
recorrer los resultados.
El ResultSet contiene dentro los registros leidos de la base de datos. Inicialmente, tal cual nos
lo devuelve el Statement.executeQuery(), tiene internamente un “puntero” apuntando justo
delante del primer registro. El método next() del ResultSet hace que dicho puntero avance al
siguiente registro, en este caso, al primero. Si lo consigue, el método next() devuelve true. Si
no lo consigue (no hay siguiente registro que leer), devuelve false, por tanto la mejor forma de
recorrerlo es mediante un while.
Una vez que el “puntero” está apuntando a un registro, los
métodos getInt(), getString(),getDate(), etc nos van devolviendo los valores de los campos de
dicho registro. Podemos pasar a estos métodos un índice (que comienza en 1) para indicar qué
columna de la tabla de base de datos deseamos. También podemos usar un String con el
nombre de la columna (tal cual está en la tabla de base de datos).
Es responsabilidad nuestra saber qué tipo de dato hay en cada columna, aunque si nos
equivocamos y RecordSet es capaz de hacer la conversión, la hará por nosotros. Por ejemplo,
en cualquiera de los campos anteriores podemos pedir un getString() y nos devolveran los
números como String y la fecha como String.
También podemos usar getObject(), y el RecordSet nos devolverá el Object más adecuado
para el tipo de campo que pedimos.
Finalmente, de la línea 60 en adelante encontramos como se cierra la conexión mediante el
método close() de nuestra variable conexion, es importante siempre cerrar la conexión ya
que si no se hace y se crean continuamente conexiones podría ocurrir en alguna momento
alguna de 2 cosas: o sobrecargar la memoria con conexiones inútiles o agotarse el “pool” de
conexiones que crea el Driver.
Conectando MySQL con JAVA
en eclipse y Windows 7
Por ea2013eetac

Explicaremos de forma muy breve unos pasos de cómo integrar la base de datos MySQL con
JAVA en Eclipse y Windows7.

1-      Descargamos XAMPP http://www.apachefriends.org/es/xampp.htmlpara Windows e

instalamos los módulos que queramos. 

2-      Descargamos el conector de MySQL con Java en la siguiente dirección:

http://dev.mysql.com/downloads/mirror.php?id=409560 (Nos fijamos en la línea No
thanks, just start my download!)

 3-      Abrimos Eclipse y en el proyecto que queramos conectar hacemos click derecho à
Build Path à Configure build path.. y nos aparecerá la siguiente pantalla:
 

Para Importar el conector mysql-connector-java-5.1.22-bin.jar  clickamos en Add External

JARs y buscamos el archivo.

Para probar el buen funcionamiento podemos hacerlo con el siguiente código:

(Recordar cambiar el usuario y contraseña de MySQL por el vuestro)

import java.sql.*;

public class Principal {

 

        public static void main(String[] args)

    {

               Connection connect = null;

               Statement statement = null;

               ResultSet resultSet = null;

              

               try {

                       // This will load the MySQL driver

              

                       Class.forName(“com.mysql.jdbc.Driver”);

                      

                              // Setup the connection with the DB

                       connect = DriverManager.getConnection(“jdbc:mysql://localhost/”, “root”,

“”);

                       

                       // Statements allow to issue SQL queries to the database

                       statement = connect.createStatement();

                      

                     //creamos la base de datos e introducimos algunos datos

                                              statement.execute(“create database ejemplo;”);

                       statement.execute(“use ejemplo”);

                       statement.execute(“create table clientes (id INT not null, nombre VARCHAR
(10), primary key (id));”);

                       statement.execute(“insert into clientes values (3, ‘Juan’);”);

                       statement.execute(“insert into clientes values (4, ‘Maria’);”);

                       statement.execute(“insert into clientes values (5, ‘Pedro’);”);

              

                       // Result set get the result of the SQL query

                       resultSet = statement.executeQuery(“select * from clientes”);

                      

                       //Ahora procesamos el resultado

                       System.out.println(“Contenido de la base de datos”);

                       while (resultSet.next())

              {  

                               String nombre = resultSet.getString(“nombre”);

                               int id = resultSet.getInt(“id”);

                              

                               System.out.println(“Nombre: ” + nombre + ” Identificador: ” + id);

                              

                       }

                       statement.close();

                       connect.close();

                      

               } catch (Exception e)

               {

                       System.out.println (“Error base de datos”);

               }

        }
 }
 Conectar desde Java (eclipse) a BD mysql
1. Primero tendremos instalar el mysql server
(http://dev.mysql.com/doc/refman/5.0/es/installing.html)

2. Creamos la base de datos y las tablas según nuestras necesidades, para esto
necesitamos conocimientos de mysql y diseño de BD.

3. El driver con la base de datos

Necesitamos para conectarnos con una base de datos es unDriver (o Connector) con

ella. Ese Driver es la clase que, de alguna forma, sabe cómo hablar con la base de
datos. Desgraciadamente (y hasta cierto punto es lógico), java no viene con todos los
Drivers de todas las posibles bases de datos del mercado. Debemos ir a internet y
obtener el Driver, normalmente en la página de nuestra base de datos

Para el caso de MySQL, podemos descargarlo

dehttp://dev.mysql.com/downloads/connector/j/5.0.html. Nos bajamos el mysql-
connector-java-5.0.5.zip, lo desempaquetamos en algún sitio y nos quedamos con
el mysql-connector-java-5.0.5-bin.jar que viene dentro. En ese jar está la clase
Driver que nos interesa.

Tendremos que poner ese jar accesible en nuestro proyecto.

 Guardarlo en la carpeta <DIRECTORIO_DE_JAVA>/jre/lib/ext. Si has hecho una

instalación por defecto en Windows, estará enC:\Archivos de
Programa\Java\jdk1.5.0_05\jre\lib\ext. Esta es la carpeta en la que java nos deja
poner jar adicionales para que se encuentren por defecto. Es buena idea ponerlo aquí si
vamos a hacer muchos programas con base de datos. Si solo vamos a hacer uno, es mejor
no ponerlo aquí. Si decidimos usar esta carpeta, también debemos tener la precaución de ir
retirando jars de versiones antiguas cuando pongamos las nuevas, o tendremos problemas.

4. A partir de ahí desde nuestra clase Java o Servlet

Creamos clase para driver y creamos conexión consultamos mediante recordset y

realizamos acciones

Class.forName(“com.mysql.jdbc.Driver”);
Connection conexion =
DriverManager.getConnection(“jdbc:mysql://localhost/practicas”
,“root”, “root”);

Statement st = conexion.createStatement();

/**** Si es Ok: avisamos ****/

System.out.println( “Si he llegado hasta aquí es que se ha

producido la conexión”);

System.out.println( “Si no se hubiera producido, se habría

disparado SQLException”);

ResultSet rs = st.executeQuery(“select * from

estudiantes” );

while (rs.next())

//Recorremos recordset realizando acciones

}
CONECTANDO UNA APLICACIÓN JAVA
CON UNA BASE DE DATOS MYSQL
2012/08/01 · by josemmsimo · in Database, Software

(In English / En Inglés:  http://josemmsimo.wordpress.com/2012/08/03/connecting-a-

java-application-with-a-mysql-database/)

Todo programador que se precie ha de saber manejarse mínimamente con las bases de datos.
Este es, en mi caso, uno de los aspectos más “bonitos” de la programación, ya que es donde
manejas lo que en el fondo es más importante: la información. La forma de representarla es
infinita, y la forma de acceder y administrar dicha información también lo es. No voy a explicar
demasiados detalles al respecto, pero en bases de datos grandes (con millones de registros), es
sumamente importante que la base de datos esté bien diseñada.

Para la realización de esta pequeña práctica me baso en lo que yo ya tengo instalado en el

sistema:

-          WAMP (Windows + Apache + MySQL + PHP), aunque sería XAMP si estuviese en
entorno GNU/Linux u otro en otros sistemas… En fin, es MySQL lo que nos interesa.

-          Eclipse para escribir el programa en Java.

-          JDK y otros elementos básicos de Java.

En primer lugar, especifico como quiero que sea mi base de datos. Su nombre será “agenda”, y
contendrá una sola tabla a la que llamaré “personal”. La tabla que creará tendrá: identificador,
nombre, apellidos, teléfono y e-mail (más fácil e intuitiva imposible). Antes de crear dicha tabla,
se comprobará si existe la misma para eliminarla y así evitar problemillas. En las pruebas
también se crean un total de 4 registros, y a continuación se muestran por pantalla.

Centrándonos en la parte de Java, para hacer uso de la base de datos tendremos que importar el
paquete “java.sql”.

Si nunca hemos realizado una conexión desde Java a la base de datos, es probable que no
tengamos el driver instalado. Este driver nos permite la conexión, y puede ser descargado desde
aquí:http://dev.mysql.com/downloads/connector/j/  Tendremos 3 opciones para utilizarlo:

-          Poniéndolo en $JAVA_HOME/lib/ext/ y así será accesible por defecto para siempre. Esta
opción no es aconsejable, puesto que este jar estará disponible para todas las aplicaciones que
corramos en el ordenador, lo necesiten o no. Si no somos cuidadosos, podemos tener conflictos
entre distintas versiones o con otros jar que pongamos que ahí.

-          Poniéndolo en el CLASSPATH.

-          Añadiéndolo a nuestro proyecto del IDE que usemos (por ejemplo eclipse).

No explicaré esto porque hay muchas páginas que indican como hacerlo, aunque si tenéis alguna
duda podéis consultarla por aquí y os responderé.

Respecto al código fuente, es bastante intuitivo. La versión larga, en la que se dividen los pasos
en pequeños métodos para hacer más comprobaciones, puede resultar algo pesada. Si preferís
algo más “light”, tenéis una segunda versión más “ligera” algo más abajo.

Versión “pesada”:

1 import java.sql.*;

2  

3 public class conectarMostrar {

    private static Connection conexion = null;

4
    private static String bd = "agenda"; // Nombre de BD.
5
    private static String user = "root"; // Usuario de BD.
6
    private static String password = ""; // Password de BD.
7
    // Driver para MySQL en este caso.
8
    private static String driver = "com.mysql.jdbc.Driver";
9
    // Ruta del servidor.
10     private static String server = "jdbc:mysql://localhost/" + bd;

11  

12     public static void main(String[] args) throws SQLException {

13  

14         System.out.println("INICIO DE EJECUCIÓN.");

15         conectar();

16         Statement st = conexion();
17  

18         // Se elimina la tabla "personal" en caso de existir.

19         String cadena = "DROP TABLE IF EXISTS personal;";

        consultaActualiza(st, cadena);
20
 
21
        // Se crea la tabla "personal"
22
        cadena = "CREATE TABLE personal (`Identificador` int(11) NOT NULL AUTO_INCR
23 DEFAULT NULL, `Email` varchar(60) DEFAULT NULL, PRIMARY KEY (`Identificador`))";

24         consultaActualiza(st, cadena);

25  

26         // Se crean datos de prueba para utilizarlos en la tabla "personal"

        cadena = "INSERT INTO personal (`Identificador`, `Nombre`, `Apellidos`, `Te
27
(2, 'María', 'Gómez Muñoz', '911876876', 'maria@gomezoliver.com'), (3, 'Juan', 'Sán
'950999888', 'ana@murciarodriguez.com');";
28
        consultaActualiza(st, cadena);
29
 
30
        // Se sacan los datos de la tabla personal
31
        cadena = "SELECT * FROM personal;";
32
        ResultSet rs = consultaQuery(st, cadena);
33
        if (rs != null) {
34
            System.out.println("El listado de persona es el siguiente:");
35
 
36             while (rs.next()) {

37                 System.out.println("  ID: " + rs.getObject("Identificador"));

38                 System.out.println("  Nombre completo: "

39                         + rs.getObject("Nombre") + " "

40                         + rs.getObject("Apellidos"));

41  
                System.out.println("  Contacto: " + rs.getObject("Telefono")
42
                        + " " + rs.getObject("Email"));
43
44  

45                 System.out.println("- ");

46             }
            cerrar(rs);
47
        }
48
        cerrar(st);
49
        System.out.println("FIN DE EJECUCIÓN.");
50
    }
51
 
52
    /**
53      * Método neecesario para conectarse al Driver y poder usar MySQL.

54      */

55     public static void conectar() {

56         try {

57             Class.forName(driver);
            conexion = DriverManager.getConnection(server, user, password);
58
        } catch (Exception e) {
59
            System.out.println("Error: Imposible realizar la conexion a BD.");
60
            e.printStackTrace();
61
        }
62
    }
63
 
64     /**

65      * Método para establecer la conexión con la base de datos.

66      *

67      * @return
     */
68
    private static Statement conexion() {
69
        Statement st = null;
70
        try {
71             st = conexion.createStatement();

72         } catch (SQLException e) {

            System.out.println("Error: Conexión incorrecta.");
73
            e.printStackTrace();
74
        }
75
        return st;
76
    }
77
 
78
    /**
79      * Método para realizar consultas del tipo: SELECT * FROM tabla WHERE..."

80      *

81      * @param st

82      * @param cadena La consulta en concreto

83      * @return
     */
84
    private static ResultSet consultaQuery(Statement st, String cadena) {
85
        ResultSet rs = null;
86
        try {
87
            rs = st.executeQuery(cadena);
88
        } catch (SQLException e) {
89             System.out.println("Error con: " + cadena);

90             System.out.println("SQLException: " + e.getMessage());

91             e.printStackTrace();

92         }

93         return rs;
    }
94
 
95
    /**
96
     * Método para realizar consultas de actualización, creación o eliminación.
97
     *
98      * @param st

99      * @param cadena La consulta en concreto

     * @return
10
0      */

10     private static int consultaActualiza(Statement st, String cadena) {

1
        int rs = -1;
10         try {
2
            rs = st.executeUpdate(cadena);
10
        } catch (SQLException e) {
3
            System.out.println("Error con: " + cadena);
10
4             System.out.println("SQLException: " + e.getMessage());

10             e.printStackTrace();
5         }

10         return rs;
6
    }
10
7  
    /**
10
8      * Método para cerrar la consula

10      *
9
     * @param rs
11      */
0
    private static void cerrar(ResultSet rs) {
11
        if (rs != null) {
1
            try {
11
2                 rs.close();

11             } catch (Exception e) {

3                 System.out.print("Error: No es posible cerrar la consulta.");

11             }
4
        }
11
    }
5  

11     /**
6      * Método para cerrar la conexión.

11      *
7
     * @param st
11
     */
8
    private static void cerrar(java.sql.Statement st) {
11
9         if (st != null) {

12             try {
0                 st.close();

12             } catch (Exception e) {

1
                System.out.print("Error: No es posible cerrar la conexión.");
12
            }
2
        }
12
3     }

12 }
4

12
5

12
6

12
7

12
8

12
9

13
0

13
1

13
2

13
3

13
4

13
5

13
6

13
7

13
8

13
9

14
0

14
1

14
2

14
3

14
4

14
5

14
6

14
7

14
8

14
9

15
0

Versión “corta”, en la que he puesto dos catch para tener un mínimo de control ante fallos:

1 import java.sql.*;

2  

3 public class conectarMostrar2 {

    public static void main(String[] args) throws SQLException {
4
        System.out.println("INICIO DE EJECUCIÓN.");
5
        try {
6
            Class.forName("com.mysql.jdbc.Driver");
7
            Connection conexion = DriverManager.getConnection("jdbc:mysql://localhos
8
            Statement st = conexion.createStatement();
9             st.executeUpdate("DROP TABLE IF EXISTS personal;");

1             st.executeUpdate("CREATE TABLE personal (`Identificador` int(11) NOT NUL

0 varchar(9) DEFAULT NULL, `Email` varchar(60) DEFAULT NULL, PRIMARY KEY (`Identificad

1             st.executeUpdate("INSERT INTO personal (`Identificador`, `Nombre`, `Apel

1 'jose@martinezlopez.com'), (2, 'María', 'Gómez Muñoz', '911876876', 'maria@gomezoliv
'Ana', 'Murcia Rodríguez', '950999888', 'ana@murciarodriguez.com');");
1
            ResultSet rs = st.executeQuery("SELECT * FROM personal;");
2
 
1
3             if (rs != null) {

1                 System.out.println("El listado de persona es el siguiente:");

4
 
1                 while (rs.next()) {
5
                    System.out.println("  ID: " + rs.getObject("Identificador"));
1
6                     System.out.println("  Nombre completo: " + rs.getObject("Nombre"
                    System.out.println("  Contacto: " + rs.getObject("Telefono") + "
1
7                     System.out.println("- ");

1                 }
8
1                 rs.close();
9             }

2             st.close();
0
 
2
1         }
        catch(SQLException s)
2
2         {

2             System.out.println("Error: SQL.");
3             System.out.println("SQLException: " + s.getMessage());

2         }
4
        catch(Exception s)
2
        {
5
            System.out.println("Error: Varios.");
2
6             System.out.println("SQLException: " + s.getMessage());

2         }
7         System.out.println("FIN DE EJECUCIÓN.");

2     }
8
}
2
9

3
0

3
1

3
2

3
3

3
4

3
5
3
6

3
7

3
8

3
9

4
0

4
1