La persistencia de datos se puede realizar en un archivo de texto o en una base de datos. En este tema se desarrollará el uso de una base de datos desde una aplicación en Java.
Para poder conectar una aplicación Java con una base de datos se requiere un puente de comunicación entre ambos elementos. Este puente de comunicación en Java se conoce como JDBC.
Un Java DataBase Connectivity (JDBC) permite comunicar una aplicación en Java (ya sea standalone, GUI, Servlet o JSP) con una base de datos (Postgres, MySQL, SQL Lite, entre otras). Para ello, sólo es necesario seleccionar el conector adecuado, el cual depende de la base de datos a la que se quiera conectar.
Java Database Connectivity (JDBC) es una interfaz de acceso a bases de datos estándar SQL que proporciona un acceso uniforme a una gran variedad de bases de datos relacionales; también proporciona una base común para la construcción de herramientas y utilidades de alto nivel.
JDBC es un API para la ejecución de sentencias SQL. Consiste en un conjunto de clases e interfaces escritas en el lenguaje de programación Java; además, permite realizar las siguientes tres tareas.
Base de datos (MySQL)
Para lograr conectar una aplicación Java con una base de datos se debe seleccionar el JDBC adecuado para dicha base de datos. En esta UAPA se utilizará la base de datos MySQL, por lo tanto, se debe instalar MySQL Server.
1. Descargar MySQL Server
El primer paso para instalar MySQL Server es descargar el servidor de la siguiente página web:
(s. a.) (s. f.). MySQL [imagen]. Tomada de https://dev.mysql.com/downloads/mysql/
En la página hay que seleccionar el sistema operativo sobre el cual se vaya a instalar el servidor. Existen versiones de 32 y 64 bits. Para esta UAPA se debe descargar la versión comprimida en formato zip.
2. Descomprimir MySQL Server.
El siguiente paso es descomprimir el archivo en el sistema de archivos local en la ubicación deseada.
Descompresión de MySQL Server en una carpeta llamada mysql en la raíz del sistema Windows (C:\) [imagen].
3. Inicialización del servidor MySQL
Se debe ejecutar una consola de comandos del sistema con permisos de administrador. Hay que ubicarse en la ruta donde quedó descomprimido el servidor e ingresar a la carpeta bin. Una vez ubicados en la carpeta bin del servidor, se ejecuta la siguiente instrucción:
mysqld.exe --initialize --console
La instrucción anterior inicializa el servidor y crea el directorio data que contiene las bases de datos del servidor. La instrucción --console permite mostrar los pasos que va siguiendo internamente el instalador; es importante activarla porque al final muestra la contraseña asignada al usuario de la base. Al finalizar la instalación se debe ver una salida similar a la siguiente:
Al inicializar el directorio data y las bases de datos del servidor, se crea una contraseña temporal para el usuario root, la cual se puede ver en el último renglón de la imagen anterior.
Nota: Debes guardar esa contraseña porque es la contraseña de acceso a la BD.
4. Inicialización del servicio MySQL
El siguiente paso es iniciar el servicio de la BD, es decir, para que la base de datos pueda atender peticiones se debe iniciar un servicio en un puerto de la computadora. Por defecto, el puerto por el que se levanta el servicio de MySQL es el 3306. Para levantar el servicio se utiliza el siguiente comando:
mysqld.exe --console
Datos primitivos de variables en Java. [Tabla] Basada en http://ayudaparaprogramacion.blogspot.com/2013/10/programacion-en-java-tipos-pvimitivos.html
El servicio va a estar corriendo mientras la terminal esté abierta, por lo tanto, esta ventana de comandos se debe dejar abierta para que el servicio esté disponible.
5. Conexión al servidor
Ahora que el servidor ya está ejecutándose es posible conectarse al servidor a través de un cliente. Para ello hay que abrir otra terminal y ejecutar el cliente de mysql, es decir:
mysql -u root -p
El comando anterior ejecuta el cliente de mysql. Por defecto se conecta al localhost (a la computadora local), que es donde se está ejecutando nuestro servidor. La bandera -u permite asignar el nombre de usuario con el cual se va a realizar la conexión, root en este caso. La bandera -p habilita la introducción de la contraseña. Al ejecutar el comando se va a solicitar la contraseña que guardamos del punto 3.
Los ejemplos que utilicen JDBC se van a estar trabajando con el usuario root y la contraseña admin. Para cambiar la contraseña al usuario root se puede utilizar alguno de los siguientes comandos:
SET PASSWORD FOR 'root'@'localhost' = PASSWORD(‘admin’);
ALTER USER 'root'@'localhost' identified by 'admin';
6. Creación de una base de datos en MySQL
Para crear una base de datos hay que conectarse al servidor MySQL con el usuario root. Una vez establecida la conexión, se puede crear una base de datos con el siguiente comando:
CREATE DATABASE “nombre_BD”;
Una vez ejecutado el comando, se puede verificar que la BD fue creada correctamente utilizando el comando:
SHOW DATABASES;
Para poder ejecutar comandos en una base de datos se debe seleccionar la BD, para ello se utiliza el comando:
USE “nombre_BD”;
Una vez situados en la BD donde se va a trabajar, se pueden crear las tablas que se necesiten. Para crear una tabla, se utiliza el siguiente comando:
CREATE TABLE “Nombre_Tabla”(var1 tipo_var, var2 tipo_var, …);
Ejemplo
Se desea crear la tabla alumno dentro de la base de datos prueba. La tabla alumno estará conformada por los atributos id, nombre, apellido paterno, apellido materno y promedio.
Nota: Las palabras reservadas de MySQL pueden escribirse tanto en mayúsculas como minúsculas, en el ejemplo que se muestra en la imagen se han empleado sólo minúsculas.
Existen cuatro operaciones que representan la forma fundamental en la que se manipula la información en una base de datos:
Creación
Lectura
Actualización
Destrucción / eliminación
A este conjunto de operaciones se le conoce como CRUD por sus siglas en inglés (Create, Read, Update, Delete) y son implementadas dentro del lenguaje de manipulación de datos (DML), el cual se considera como un subconjunto de comandos SQL.
En la siguiente tabla se muestran las operaciones CRUD junto a su comando DML correspondiente:
Operación CRUD |
Comando DML |
Función |
Creat |
Insert |
Crea o agrega datos a la base de datos. |
Read |
Select |
Lee datos de la base de datos. |
Update |
Update |
Modifica datos existentes dentro de la base de datos |
Delete |
Delete |
Elimina datos existentes en la base de datos. |
INSERT
La sentencia INSERT agrega datos a una tabla dentro de una base de datos. La estructura de la sentencia INSERT es la siguiente
Ver
INSERT INTO nombre_tabla [(columna1, columna2, …)]
VALUES (valor1, valor2, …);
A continuación, se muestran dos formas de insertar datos a una tabla:
Forma 1
Forma 2
Se insertan los datos asumiendo implícitamente que se llenarán todos los campos de la tabla y que se ingresarán los datos en el mismo orden que se definieron en la creación de la tabla.
Se indica, después del nombre de la tabla qué campos se llenarán y en qué orden.
SELECT
La sentencia SELECT permite obtener información de una tabla en una base de datos. Se pueden obtener todos los datos contenidos en una tabla o se pueden seleccionar sólo algunos campos o bien se pueden obtener algunos campos o registros completos que cumplan con una condición específica.
La sentencia SELECT tiene la siguiente sintaxis:
Ver
SELECT columna1, columna2, …
columnaN
FROM “NOMBRE_TABLA”
WHERE condición;
Si se desea revisar el contenido de todas las columnas de la tabla, se utiliza el operador “*”. Si se desea obtener todos los registros contenidos en la tabla, se omite la cláusula WHERE. Si se desea obtener los registros que cumplan una condición específica, se utiliza la cláusula WHERE.
Ejemplo
Selección de todas las columnas de la tabla PRUEBA1.
Ejemplo
Selección de las columnas nombre y apellido paterno de la tabla alumno.
Ejemplo
Selección de todas las columnas de la tabla alumno donde la columna apellido paterno sea igual a ‘Gómez’.
Ejemplo
Selección de las columnas nombre y apellido paterno de la tabla alumno donde el promedio sea mayor a 8.
UPDATE
La sentencia UPDATE se utiliza para modificar registros ya existentes en una tabla de una base de datos, puede modificarse más de un campo perteneciente a un registro en una sola ejecución de la sentencia. También es posible cambiar un campo o campos específicos para todos los registros de la tabla.
La estructura de la sentencia UPDATE es la siguiente:
Ver
UPDATE nombre_tabla
SET columna1 = valor1, columna2 = valor2, …
WHERE condición;
Ejemplo
Ejemplo
Actualizar de la tabla alumno, poner el id_alumno con el valor de 2, donde el apellido paterno sea ‘Gómez’.
Actualizar la tabla alumno, poner el promedio igual a 8.5 y el apellido paterno igual a ‘Domínguez’, donde el id_alumno sea igual a 2.
DELETE
La sentencia DELETE permite eliminar registros ya existentes en una tabla de una base de datos. Se puede eliminar uno o varios registros a la vez.
La estructura para el comando DELETE es la siguiente:
Ver
DELETE
FROM nombre_tabla
WHERE condición;
Ejemplo
Eliminar de la tabla Alumno el registro cuyo id_alumno sea igual a 1
Existen diferentes drivers JDBC dependiendo del gestor de base de datos al que se desee conectar. Generalmente, el driver tiene la siguiente sintaxis:
gestorBD-connector-java-versión.jar
Donde gestorBD se refiere al gestor al que se quiere conectar (DB2, Sybase, Oracle, SQLServer, PostgresSQL o mySQL).
Para poder ocupar el driver JDBC en una aplicación se deben realizar las siguientes acciones:
1. En el sistema operativo se debe agregar a la variable de entorno CLASSPATH la ruta donde se instaló el driver.
2. En el programa Java donde se va a utilizar se debe invocar el driver JDBC en el método estático forName de la clase Class, de la siguiente manera: Class.forName(“clase_del_driver”)
Nota: En la última versión del driver para MySQL esto ya no es necesario.
Ejemplo
Para crear una instancia del driver para Sybase se utilizaría la siguiente sentencia:
Class.forName(“com.sybase.jdbc2.jdbc.SybDriver”);
Para crear una instancia del driver para Oracle se utilizaría la siguiente sentencia:
Class.forName(“oracle.jdbc.driver.OracleDriver”);
Para poder establecer la comunicación desde la aplicación Java hacia la base de datos utilizando el driver JDBC se deben realizar los siguientes pasos:
1. Crear una instancia del JDBC driver.
Class.forName(“paquete.driver.nombreDriver”);
Ejemplo: Class.forName(“org.postgresql.Driver”);
2. Especificar la dirección y el puerto de la base de datos, junto con el driver a utilizar.
String url = “jdbc:subprotocolo:dbms”
Ejemplo: String url= "jdbc:postgresql://127.0.0.1:5432/”
3. Establecer la conexión a la base a través de la clase DriverManager.
Connection conn = DriverManager.getConnection(url, usuario, contraseña);
4. Crear un objeto Statement de la conexión establecida. El objeto Statement es el que permite ejecutar sentencia SQL en la BD.
Statement stmt = con.createStatement();
5. Realizar la consulta SQL y ejecutarla usando el objeto Statement creado. Las operaciones de insert, delete y update se realizan a través del comando executeUpdate y regresan un número entero (el cual indica el número de renglones afectados en la operación). La operación de select se realiza a través del comando executeQuery y regresa un ResultSet, que es una tabla de datos (como una matriz).
ResultSet rs = stmt.executeQuery(“Consulta_Select_SQL”);
int num = stmt.executeUpdate(“Consulta_Insert_SQL”);
6. Recibir los resultados en el objeto ResultSet (executeQuery) o el resultado entero (executeUpdate). Un objeto ResultSet se puede recorrer de la siguiente manera:
while(rs.next()) {
System.out.println(“Columna 1: “ + rs.getString(1));
System.out.println(“Columna 2: “ + rs.getString(2));
}
JDBC permite comunicarse con la base de datos utilizando sentencias SQL. Sin embargo, JDBC no pone ninguna restricción sobre los tipos de sentencias que pueden enviarse, por lo que permite el uso de sentencias específicas de la base de datos o incluso sentencias no SQL.
Por ello, es necesario asegurarse de que las sentencias SQL enviadas son soportadas por la base de datos a la que se intenta acceder, así como soportar las consecuencias si no es así (manejo de excepciones).
Instrucciones
Para poder ejecutar los siguientes códigos de Java hay que tener configurada la base de datos, además de ciertos servicios arriba. Para ello sigue los siguientes pasos:
1. Debes tener el servicio de MySQL iniciado, como se indica en el punto 4 Inicialización del servicio MySQL del tema Base de datos (MySQL) de esta UAPA.
2. Debes conectarte al servicio de BD con el cliente mysql, como se indica en el punto 5 Conexión al servidor del tema Base de datos (MySQL) de esta UAPA.
3. Ejecuta las siguientes sentencias SQL dentro del cliente mysql:
Ejemplo
CREATE DATABASE cursosJava;
use cursosJava;
create table usuarios(
id INT,
usr VARCHAR(100),
passwd VARCHAR(100)
);
insert into usuarios values('1010', 'usuario1', 'usuario1');
insert into usuarios values('1011', 'usuario2', 'usuario2');
insert into usuarios values('1100', 'usuario3', 'usuario3');
insert into usuarios values('1101', 'usuario4', 'usuario4');
insert into usuarios values('1110', 'usuario5', 'usuario5');
DELIMITER $$
CREATE PROCEDURE usuario( in usr_id int, in usr_name varchar(10), in usr_pass varchar(10))
BEGIN
insert into usuarios values('1111', 'usuario6', 'usuario6');
insert into usuarios values('0001', 'usuario7', 'usuario7');
insert into usuarios values('0010', 'usuario8', 'usuario8');
update usuarios set usr = usr_name, passwd = usr_pass where id = usr_id;
select * from usuarios;
END$$
DELIMITER ;
4. Descarga el conector JDBC para MySQL (que se encuentra en la plataforma) y ubícalo en la misma carpeta donde pongas los archivos .java.
5. Transcribe cada uno de los siguientes ejemplos en un archivo .java.
Ejemplo
package uapajdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.DriverManager;
public class Conexion {
public static void main (String [] args){
try {
// puente JDBC -> MySQL
/*Class.forName("com.mysql.jdbc.Driver");*/
// ConexiOn a la base de datos
Connection con = DriverManager.getConnection("jdbc:mysql://
localhost:3306?serverTimezone=UTC","root","admin");
System.out.println("Conexión con la BD establecida");
}catch (SQLException e){
System.out.println("Error al realizar la conexión con mysql");
}catch (Exception e){
System.out.println("Error:\n" + e.getMessage());
e.printStackTrace();
}
}
}
Para compilar el programa ejecuta la siguiente instrucción en la ubicación donde está el archivo Conexion.java:
javac -d . Conexion.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo Conexion.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.Conexion (En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.Conexion
Si todo salió correctamente, debes ver en la terminal la siguiente oración:
Conexión con la BD establecida
El objeto de tipo Statement se utiliza para crear peticiones SQL estáticas y regresar el resultado que éstas producen. Por lo general, el objeto Statement se utiliza para la ejecución de sentencias SELECT, y en ese caso, se invoca al método executeQuery(), el cual regresa un objeto ResultSet que contiene los registros resultantes de la consulta:
Statement stm = con.createStatement();
ResultSet res =stm.executeQuery(“select * from emp”);
Un objeto tipo Statement también se utiliza para realizar sentencias INSERT, UPDATE y DELETE y, en ese caso, se utiliza el método executeUpdate() y lleva como argumento la cadena de caracteres (String) con la sentencia SQL:
String consulta = “insert into emp values(‘123’,‘Juan’)”
Statement stm = con.createStatement();
int res = stm.executeUpdate(consulta);
Ejemplo
package uapajdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class SeleccionarBD {
public static void main (String [] args){
try {
/* En lugar de usar Class.forName("com.mysql.jdbc.Driver");
La conexión a la BD se puede hacer de la siguiente manera: */
Connection con = DriverManager.getConnection("jdbc:mysql://
localhost:3306?serverTimezone=UTC","root","admin");
System.out.println("ConexiOn con la BD establecida");
// Se crea una instancia del tipo declaraciOn
Statement stmt = con.createStatement();
stmt.executeQuery("use cursosJava");//Se indica qué base de datos de usará
ResultSet rs = stmt.executeQuery("SELECT * FROM usuarios;");
System.out.println("ID\tUsuario\tContra");
while(rs.next()) {
System.out.println(rs.getInt("id") + "\t" + rs.getString("usr") + "\t" + rs.getString("passwd"));
}
}catch (SQLException e){
System.out.println("Error al realizar la conexiOn con mysql");
}catch (Exception e){
System.out.println("Error:\n" + e.getMessage());
e.printStackTrace();
}
}
}
Para compilar el programa ejecuta la siguiente instrucción en la ubicación donde está el archivo SeleccionarBD.java:
javac -d . SeleccionarBD.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo SeleccionarBD.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.SeleccionarBD
(En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.SeleccionarBD
Si todo salió correctamente, debes ver los usuarios que tengan la base de datos:
Ejemplo
package uapajdbc;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
public class MetaDatos {
public static void main (String [] args){
try {
Connection con = DriverManager.getConnection("jdbc:mysql://
localhost:3306?serverTimezone=UTC","root","admin");
System.out.println("Conexión con la BD establecida");
Statement stmt = con.createStatement();
stmt.executeQuery("use cursosJava");//Se indica qué base de datos de usará
ResultSet rs = stmt.executeQuery("SELECT * FROM usuarios;");
ResultSetMetaData rsmd = rs.getMetaData();
int cols = rsmd.getColumnCount();
for (int cont = 1 ; cont <= cols ; cont++) {
System.out.println(rsmd.getColumnName(cont) + "\t");
}
}catch (SQLException e){
System.out.println("Error al realizar la conexión con mysql: "+e.getMessage());
}catch (Exception e){
System.out.println("Error:\n" + e.getMessage());
e.printStackTrace();
}
}
}
Para compilar el programa ejecuta la siguiente instrucción en la ubicación donde está el archivo public class MetaDatos.java:
javac -d . MetaDatos.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo MetaDatos.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.MetaDatos
(En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.MetaDatos
Si todo salió correctamente, debes ver los campos que tiene la tabla usuarios:
Ejemplo
package uapajdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.SQLException;
public class InsertarBD {
public static void main (String [] args){
try {
Connection con = DriverManager.getConnection("jdbc:mysql://
localhost:3306?serverTimezone=UTC","root","admin");
System.out.println("ConexiOn con la BD establecida");
// Se crea una instancia del tipo declaración
Statement stmt = con.createStatement();
//Se indica qué base de datos de usará
stmt.executeQuery("use cursosJava");
int res = stmt.executeUpdate("INSERT INTO usuarios VALUES('"+ 0 +" ','" + args[0] + "','"+ args[1] + "')");
if (res == 1){
System.out.println("Registro insertado");
} else {
System.out.println("Registro no insertado");
}
}catch (SQLException e){
System.out.println("Error al realizar la inserciOn en mysql");
while (e != null){
System.out.println("SQLState: " + e.getSQLState());
System.out.println("Mensaje: " + e.getMessage());
System.out.println("COdigo: " + e.getErrorCode());
e.getNextException();
System.out.println(" -------------------------------------- ");
}
}catch (Exception e){
System.out.println("Error:\n" + e.getMessage());
e.printStackTrace();
}
}
}
Para compilar el programa, ejecuta la siguiente instrucción en la ubicación donde está el archivo public class InsertarBD.java:
javac -d . InsertarBD.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo InsertarBD.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.InsertarBD usuario contraseña
(En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.InsertarBD usuario contraseña
Si todo salió correctamente, debes ver la siguiente salida:
¡Vuelve a ejecutar el programa SeleccionarBD.java para ver que el registro ya fue insertado!
¿Te diste cuenta de que el usuario y la contraseña se pasaron como parámetro al ejecutar el programa? Son las cadenas que se encuentran después del nombre de la clase uapajdbc.InsertarBD.
El objeto de tipo PreparedStatement se utiliza para ejecutar sentencias SQL precompiladas. PreparedStatement se utiliza para la ejecución de sentencias Insert, Delete y Update ya que éstas requieren condicionantes, por lo que se crea la cadena (String) con la sentencia SQL desde la instanciación del objeto.
Para ejecutar una instrucción con el objeto PreparedStatement se siguen los siguientes pasos:
Se crea el objeto con el query (petición).
String peticion = “update emp set nom_emp=? where cve_emp=?” PreparedStatement pstmt = con.prepareStatement(peticion);
Se envían los parámetros al objeto.
pstmt.setString(1,“Juan”);
pstmt.setInt(2,123);
Se ejecuta la sentencia.
int res = pstmt.executeUpdate();
Ejemplo
Para compilar el programa, ejecuta la siguiente instrucción en la ubicación donde está el archivo public class PreparedSBD.java:
javac -d . PreparedSBD.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo PreparedSBD.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.PreparedSBD
(En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.PreparedSBD
Si todo salió correctamente, debes ver una salida similar a la siguiente:
Es decir, se muestran los usuarios de la BD y después se muestra el menú actualizar o borrar. Elije la opción que desees y observa cómo el programa actualiza o elimina el registro que le indiques desde teclado.
CallableStatement se utiliza para ejecutar procedimientos almacenados (stored procedures) SQL.
La API de JDBC provee una sintaxis para que todos los procedimientos almacenados sean llamados de la misma manera en los diferentes sistemas manejadores de bases de datos.
Ejemplo
Nota: En las sentencias SQL que ejecutaste al iniciar los programas ya se encuentra el procedimiento almacenado.
Para compilar el programa, ejecuta la siguiente instrucción en la ubicación donde está el archivo public class PreparedSBD.java:
javac -d . CallableSBD.java
Para ejecutar el programa debes hacerlo en la misma ubicación donde está el archivo CallableSBD.java (recuerda que en esa misma ubicación también debe estar el conector JDBC):
(En GNU/Linux) java -cp mysql-connector-java-8.0.16.jar:. uapajdbc.CallableSBD
(En Windows) java -cp mysql-connector-java-8.0.16.jar;. uapajdbc.CallableSBD
Si todo salió correctamente, debes ver una salida similar a la siguiente:
Conexión con la BD establecida
El procedimiento que esta por ejecutar creará 3 usuarios nuevos y actualizará los datos de un usuario existente. Proporcione los datos del usuario que desee actualizar:
Proporcione el id del usuario:
Proporciona el ID de usuario que deseas modificar y observa lo que pasa.
Las bases de datos permiten la persistencia de datos, lo que garantiza la integridad de la información. Para conectar un archivo Java con una base de datos se requiere de un conector entre ambos, el cual es conocido como JDBC. El JDBC no sólo permite establecer conexión con una base de datos, sino que también posibilita ejecutar sentencias SQL desde la aplicación Java en la base de datos.
A continuación, lee la descripción del caso de estudio (requerimientos) y posteriormente completa el código.
El conector JDBC permite establecer la conexión entre un programa en Java y una base de datos. A partir de esa conexión se pueden ejecutar sentencias SQL en la base de datos desde el programa en Java.
Fuentes de información
Pratik, P. (1996). Java Database Programming with JDBC. The Coriolis Group.
Cómo citar
Solano, J. A. (2020). JDBC (Java DataBase Connectivity). Unidades de Apoyo para el Aprendizaje. CUAIEED/Facultad de Ingeniería-UNAM. (Vínculo)
-->
