Este post tiene como objetivo que sepas como se hacen las operacion CRUD:
- CREATE
- READ
- UPDATE
- DELETE
Utilizando JAVA y una base de datos MySQL, este es un post introductorio donde se indican los pasos a realizar para cada operacion, sin complejidad, es basico para que tengas la nocion de como se realiza y puedas ir descubriendo mas logica en diferentes contextos segun tu proyecto.
Empecemos...
Primero debes tener instalado MySQL y un SGBD como Workbench, si ya lo tienes, crearemos una base de datos sencilla con una tabla y a esta tabla le agregaremos un par de datos:
create database pruebas;
use pruebas;
create table personas (
id int unsigned not null auto_increment primary key,
nombres varchar(50) not null,
apellidos varchar(50) not null,
tinyint edad not null
);
insert into personas(nombres, apellidos, edad)
values ('Cristiano Ronaldo', 'Santos Aveiro', 41),
('Lionel Andres', 'Messi Cuccitini', 39);
select * from personas;
Una vez creada la base de datos, vamos a nuestro IDE favorito para proyectos JAVA, en este caso usare Intellij Idea.
Creamos un proyecto, yo lo llamare "curso-jdbc", una vez hecho agregaremos un package dentro de la carpeta "src", lo puedes nombrar como quieras, yo le puse como nombre "com.codefather.main":
Dentro del paquete "com.codefather.main" crearemos cuatro archivos, osea, cuatro clases con los siguientes nombres:
MySQL Conector/J
Una vez hecho esto, necesitamos el Conector MySQL, el cual hace la funcion de establecer la conexion con la base de datos MySQL, para ello, buscamos en google de la siguiente forma:
Y segun los resultados nos metemos al primer link y nos aparecera lo siguiente:
Luego nos mandara a esta pantalla, hacemos lo siguiente:
y empezara a descargarse el archivo, una vez descargado, nos vamos a la carpeta donde se descargó, y extraemos el archivo .zip:
Nos quedara una carpeta:
Al abrir esa carpeta encontraremos a nuestro conector mysql:
Te recomiendo que dejes en esa carpeta solamente el conector mysql, es decir, puedes eliminar lo demas.
Ahora nos vamos a nuestro proyecto en intellij Idea, y le damos en la siguiente opcion para agregar el conector y poder empezar con el codigo:
Luego seleccionamos lo siguiente:
Primero en dependencias, y luego en el icono "+"
Se desplegara un submenu:
Luego solo elegimos la carpeta donde tenemos nuestro conector:
y para terminar, damos clic en "apply" y leugo en "ok":
Componentes JDBC
Antes de ir al codigo debemos entender JDBC, que sus siglas significa (Java DataBase Connectivity), es una especificacion estandar de JAVA que permite a las aplicaciones conectarse e interactuar con bases de datos relacionales. Sirve como un puente universal para enviar consultas SQL, hacer operaciones CRUD (Create, Read, Update & Delete) desde cualquier base de datos.
Sus componentes son:
JDBC Driver: Es el componente de software provisto por el fabricante de base de datos (en este caso el que estamos utilizando "MySQL Connector/J") quien traduce las llamadas de JAVA al motor de datos.
JDBC Driver Management: Es quien gestiona y carga los controladores (Driver) especificos de cada base de datos.
JDBC Connection: Se encarga de establecer y mantener la conexion con la base de datos (URL, User, Password).
JDBC Statement: Se utiliza para ejecutar sentencias SQL sin parametros.
JDBC Prepared Statement: Se utiliza para ejecutar sentencias SQL con parametros, ofrece mayor seguridad contra inyecciones SQL.
JDBC Result Set: Objeto que almacena y permite iterar sobre filas devueltas por una consulta.
Hoy si vamos al codigo...
En cada clase conectaremos a la base de datos, validaremos que la conexion sea un exito, y realizaremos las operaciones.
READ
Empezaremos por la clase "ReadJDBC".
Primero, definiremos los objetos de JDBC, sus componentes para hacer la conexion a la base de datos y poder mandar la operacion SQL y tener como resultado e iterar la respuestas de esa operacion SQL:
public class ReadJDBC {
public static void main(String[] args) {
// ---------------------------------------------------------
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
// ---------------------------------------------------------
}
}
Segundo, en un bloque tryCatch haremos la conexion y la operacion SQL, empezando por establecer la conexion:
public class ReadJDBC {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
// ---------------------------------------------------------
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
} catch (Exception e) {
e.printStackTrace();
}
// ---------------------------------------------------------
}
}
DriverManager es quien gestiona y controla los driver para cada base de datos, se invoca al metodo getConnection() donde recibe como parametro la url del driver quien lo provee la documentacion del motor de la base de datos, es diferente para cada motor de bases de datos que existen, seguido del usuario y contraseña en caso de haberla definido al intalar el SGBD.
Tercero, validaremos que la conexion sea exitosa:
public class ReadJDBC {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
// ---------------------------------------------------------
if (conn != null) {
System.out.println("Conexion establecida!");
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
Con un condicional IF, validamos que la conexion sea diferente de null, osea, que haya abierta una sesion y se haya conectado satisfactoriamente.
Una vez conectado, empezaremos con la operacion:
public class ReadJDBC {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Conexion establecida!");
// ---------------------------------------------------------
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM personas");
while () {
System.out.println(rs.getInt(1) + rs.getString(2) + rs.getString(3) + rs.getInt(4));
}
// ---------------------------------------------------------
} else {
System.out.println("Error al conectarse!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Al objeto Statement (stmt) lo preparamos para enviarle consultas SQL con el metodo createStatement() instanciandolo desde el metodo Connection (conn).
Esto permite que al objeto Statement podamos invocar sus metodos principales, como el de executeQuery(), el cual nos devuelve el resultado de la operacion SQL, por ende, la operacion que estamos realizando nos devuelve todos los registros de la tabla 'personas', por eso lo almacenamos en el objeto ResultSet (rs) quien nos permite usar uno de sus metodos intanciondolo como .next(), este metodo nos permite iterar por cada registro que nos devuelve la operacion SQL, quien nos lleva a hacer uso del .get() que en su variantes estan:
.getInt().getString().getDouble().getDate().getTime()-
.getTimestamp()
Estos metodos nos permiten obtener el valor de los registros en nuestra tabla de la base de datos, segun el tipo de dato de cada registro invocaremos al metodo correspondiente.
Estos reciben un parametro, el cual es el indice segun el orden en como estan las columnas en la base de datos.
Por ultimo como buena practica debemos cerrar la sesion una vez finalizado la operacion:
public class ReadJDBC {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Conexion establecida!");
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM personas");
while () {
System.out.println(rs.getInt(1) + rs.getString(2) + rs.getString(3) + rs.getInt(4));
}
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
conn.close();
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
En resumen, se utilizo Statement mas no PreparedStatement, ya que es una consulta SQL sin parametros y se utilizo su metodo .executeQuery(), y se utilizo ResultSet porque en la consulta nos devolvia un resultado el cual podiamos iterar haciendo uso de su metodo .next().
En las siguientes operaciones, no usaremos el objeto ResultSet, pero si usaremos PreparedStatement ya que haremos consultas SQL que necesitaran parametros, y en vez de .executeQuery usaremos otro que nos ofrece el objeto PreparedStatement llamado .executeUpdate() ya que se ejecutara una consulta que a su vez actualizara la tabla de datos.
CREATE
Continuaremos con la clase "InsertJDBC":
Primero, definiremos los objetos para nuestra consulta:
public class InsertJDBC {
public static void main(String[] args) {
// ---------------------------------------------------------
Connection conn = null;
PreparedStatement pst = null;
// ---------------------------------------------------------
}
}
Segundo, en un bloque tryCatch haremos la conexion a nuestra base de datos:
public class InsertJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
// ---------------------------------------------------------
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
} catch (Exception e) {
System.out.println(e.printStackTrace());
}
// ---------------------------------------------------------
}
}
Tercero, validamos que la conexion se haya realizado con exito:
public class InsertJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
// ---------------------------------------------------------
if (conn != null) {
System.out.println("Se conecto a la base de datos!");
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
Si hay conexion pues continuamos con la operacion SQL:
public class InsertJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Se conecto a la base de datos!");
// ---------------------------------------------------------
pst = conn.prepareStatement("INSERT INTO personas(nombres, apellidos, edad) VALUES(?, ?, ?)");
pst.setString(1, "Neymar da Silva");
pst.setString(2, "Santos Junior");
pst.setInt(3, 34);
int rows = pst.executeUpdate();
if (rows > 0) {
System.out.println("Se registro correctamente!");
}
// ---------------------------------------------------------
} else {
System.out.println("Error al conectarse!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Invocamos a .prepareStatement() para poder hacer una consulta con parametros, y asi poder invocar a sus metodos, tales como set() que sus variantes son:
.getInt().getString().getDouble().getDate().getTime()-
.getTimestamp()
Son para asignar valores a los parametros de la consulta preparada SQL, se utilizan segun su tipo de dato y reciben como parametro el indice segun el orden de como se definio en la consulta, y el valor que lleva el parametro.
Para validar que se hizo efecta la ejecucion de la consulta, almacenamos en una variable de tipo entero llamada 'rows' invocando al metodo .executeUpdate() y con una condicional validamos si es mayor a cero (ya que nos devuelve 0 si fallo la consulta, o 1 si se completo con exito), mandamos a imprimir un mensaje que se registro correctamente.
Y por ultimo como buena practica cerramos la conexion:
public class InsertJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Se conecto a la base de datos!");
pst = conn.prepareStatement("INSERT INTO personas(nombres, apellidos, edad) VALUES(?, ?, ?)");
pst.setString(1, "Neymar da Silva");
pst.setString(2, "Santos Junior");
pst.setInt(3, 34);
int rows = pst.executeUpdate();
if (rows > 0) {
System.out.println("Se registro correctamente!");
}
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
conn.close();
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
UPDATE
Continuamos con la clase "UpdateJDBC":
Primero, definimos los objetos a utilizar:
public class UpdateJDBC {
public static void main(String[] args) {
// ---------------------------------------------------------
Connection conn = null;
PreparedStatement pst = null;
// ---------------------------------------------------------
}
}
Segundo, definimos un bloque tryCatch para hacer la conexion a la base de datos:
public class UpdateJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
// ---------------------------------------------------------
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
} catch (Exception e) {
e.printStackTrace();
}
// ---------------------------------------------------------
}
}
Tercero, validaremos que la conexion se haya realizado:
public class UpdateJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
// ---------------------------------------------------------
if (conn != null) {
System.out.println("Conexion establecida!");
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
Si la conexion se realizo, realizamos la operacion SQL:
public class UpdateJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Conexion establecida!");
// ---------------------------------------------------------
pst = conn.prepareStatement("UPDATE personas SET nombres = ?, apellidos = ? WHERE id = ?");
pst.setString(1, "Ronaldinho");
pst.setString(2, "Gaucho");
pst.setString(3, 3);
int rows = pst.executeUpdate();
if (rows > 0) {
System.out.println("Registro actualizado!");
}
// ---------------------------------------------------------
} else {
System.out.println("Error al conectarse!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Nuevamente, al objeto PreparedStatement invocamos al metodo (.prepareStatement()) para pasarle una consulta preparada con parametros. Siempre accediendo a sus metodos .set() segun el tipo de dato y el indice que corresponde.
Para validar que se hizo correctamente la operacion, guardamos en una variable de tipo entero y ejecutamos el metodo .executeUpdate(), con una condicional validamos que sea mayor a 0, si es asi, se realizo correctamente.
Como buena practica debemos cerrar la conexion:
public class UpdateJDBC {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Conexion establecida!");
pst = conn.prepareStatement("UPDATE personas SET nombres = ?, apellidos = ? WHERE id = ?");
pst.setString(1, "Ronaldinho");
pst.setString(2, "Gaucho");
pst.setString(3, 3);
int rows = pst.executeUpdate();
if (rows > 0) {
System.out.println("Registro actualizado!");
}
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
conn.close();
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
DELETE
Para finalizar, terminando con la clase "DeleteJDBC":
Primero, definimos los objetos que vamos a utilizar:
public class DeleteJDBC {
public class main(String[] args) {
// ---------------------------------------------------------
Connection conn = null;
PreparedSatement pst = null;
// ---------------------------------------------------------
}
}
Segundo, en un bloque tryCatch hacemos la conexion:
public class DeleteJDBC {
public class main(String[] args) {
Connection conn = null;
PreparedSatement pst = null;
// ---------------------------------------------------------
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
} catch (Exception e) {
e.printStackTrace();
}
// ---------------------------------------------------------
}
}
Tercero, validamos que la conexion se haya realizado:
public class DeleteJDBC {
public class main(String[] args) {
Connection conn = null;
PreparedSatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
// ---------------------------------------------------------
if (conn != null) {
System.out.println("Conexion exitosa"");
} else {
System.out.println("Error al conectarse!");
}
// ---------------------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
}
}
Si la conexion es exitosa, pues continuamos con la operacion SQL:
public class DeleteJDBC {
public class main(String[] args) {
Connection conn = null;
PreparedSatement pst = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebas", "root", "root");
if (conn != null) {
System.out.println("Conexion exitosa"");
// ---------------------------------------------------------
pst = conn.prepareStatement("DELETE FROM personas WHERE id = ?");
pst.setInt(1, 3);
int rows = pst.executeUpdate();
if (rows > 0) {
System.out.println("Se elimino el registro!");
}
// ---------------------------------------------------------
} else {
System.out.println("Error al conectarse!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Preparamos la consulta invocando al metodo .prepareStatement() para realizar la sentencia SQL y poder acceder a sus metodos .set(), en este ejemplo, solo usamos un metodo .setInt() ya que solo es un parametro el que necesitamos.
Para validar que se realizo con exito la operacion, almacenamos el resultado en una variable de tipo 'int' invocando al metodo .executeUpdate(), con una condicional validamos si es mayor a 0, y mostramos un mensaje de exito.
Conclusión
Siempre es necesario el objeto Connection para hacer la conexion invocando al DriverManager y a su metodo .getConnection() para hacer el puente al motor de la base de datos.
Lo que varia en el codigo son el objeto Statement y el objeto PreparedStatement, sus diferencias es que el segundo, es mas seguro para sentencias SQL con parametros y evitar inyecciones SQL, cada uno tienen sus metodos, como lo es el caso de Statement que para ejecutar una sentencias se hace directamente con el metodo .executeQuery(), a diferencia de PreparedStatement que utiliza los metodos .set() en diferentes tipos de datos segun lo requiera el parametro, y, para ejecutar la sentencia se utiliza .executeUpdate() para que realize la sentencia y a su vez actualize los cambios.
Y como cierre, nunca olvidar cerrar la conexion.
Top comments (0)