JDBC
Arquitectura de la API JDBC
¿Qué es Java Database Connection (JDBC)?
Métodos y componentes de JDBC
Conectando Java con bases de datos
Leer y crear datos con JDBC
Actualizar y eliminar datos con JDBC
CRUD
Clases y estructura del proyecto con IntelliJ y Maven
Optimización de recursos
Patrón DAO y Repository
Implementando el Patrón Repository
Leer Datos desde Java
Insertar Datos en Java
Eliminar Datos en Java
Visualizando bases de datos con Java Swing
Transacciones
¿Qué es una transacción?
Implementando transacciones con JDBC
Conexiones Pool
¿Qué es una conexión pool?
Implementando conexiones pool
JPA y ORM
¿Qué es JPA y ORM?
Instalación y configuración de Hibernate
Implementando JPA con Hibernete
Próximos pasos
Reto: crea un clon de Netflix con Java
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Clases y estructura del proyecto con IntelliJ y Maven
7/22Recursos
Una vez que se haya creado el proyecto Maven, agrega el conector JDBC de MySQL:
Manualmente:
- Abre el archivo “pom.xml” en el proyecto Maven.
- Busca el enlace al conector JDBC de MySQL en el repositorio Maven. Puedes utilizar el siguiente enlace: https://mvnrepository.com/artifact/com.mysql/mysql-connector-j ****En este repositorio, se encuentran alojados una gran cantidad de artefactos, como librerías, frameworks y plugins de Maven, que pueden ser utilizados en proyectos de desarrollo de software Java.
- Copia la dependencia XML del conector JDBC de MySQL desde el enlace.
- Pega la dependencia dentro del bloque de dependencias en el archivo “pom.xml”.
- Guarda el archivo “pom.xml”.
Después de seguir estos pasos, tu proyecto Maven estará configurado con el conector JDBC de MySQL y podrás utilizarlo en tu aplicación para interactuar con una base de datos MySQL.
Desde el IDE:
IntelliJ IDEA proporciona una forma más sencilla de agregar dependencias utilizando el atajo de teclado “Alt + Insert” en proyectos de Maven.
- Abre tu proyecto en IntelliJ IDEA.
- Navega hasta el archivo
pom.xmlen la estructura del proyecto. - Haz clic con el botón derecho del ratón en el archivo
pom.xmly selecciona “Open ‘pom.xml’” en el menú contextual. - En el editor de
pom.xml, coloca el cursor en el lugar donde deseas agregar la dependencia. Por lo general, se coloca dentro del elemento<dependencies>. - Luego, presiona el atajo de teclado “Alt + Insert” (o “Ctrl + Enter” en macOS).
- En el menú emergente, selecciona “Dependency” o “Add Dependency” según la versión de IntelliJ IDEA que estés utilizando.
- Aparecerá un cuadro de diálogo llamado “Add Dependency”. En este cuadro de diálogo, puedes buscar la dependencia que deseas agregar escribiendo su nombre en el campo de búsqueda.
- A medida que escribas, IntelliJ IDEA buscará en el repositorio Maven y mostrará una lista de coincidencias. Selecciona la dependencia adecuada de la lista.
- Una vez que hayas seleccionado la dependencia, haz clic en el botón “OK” para agregarla al archivo
pom.xml.
IntelliJ IDEA descargará automáticamente la dependencia y actualizará el archivo pom.xml con la nueva entrada de dependencia. Además, podrás ver el progreso de la descarga en la barra de estado de IntelliJ IDEA.
Aportes 18
Preguntas 2
Ordenar por:
En mi caso al cargar la dependencia de mySQL en intellij me daba el siguiente error:
`Dependency 'mysql:mysql-connector-java:8.0.33' not found`
y se solucionó recargando el proyecto haciendo en el `pom.xml`:
***click derecho> Maven > Reload Project***
## **Maven:**
Apache Maven es una herramienta de gestión y construcción de proyectos en Java que simplifica el proceso de construcción, gestión de dependencias y distribución de software. Maven utiliza un modelo de proyecto basado en convenciones y proporciona un conjunto de prácticas estándar para estructurar proyectos Java. Su objetivo principal es facilitar la gestión del ciclo de vida del desarrollo de software, desde la compilación hasta la distribución.
Maven automatiza tareas como la compilación, la gestión de dependencias, la ejecución de pruebas, la creación de archivos JAR/WAR, y más. Utiliza un sistema de plugins para realizar estas tareas, lo que permite una configuración sencilla y coherente.
## **Archivo** `pom.xml`**:**
El archivo `pom.xml` (Project Object Model) es un archivo de configuración fundamental en Maven. Contiene información esencial sobre el proyecto, sus dependencias, plugins y configuraciones.
Algunos elementos clave en un archivo `pom.xml` incluyen:
1. `<groupId>`, `<artifactId>`, y `<version>`: Definen la identidad del proyecto (grupo, nombre y versión respectivamente).
2. `<dependencies>`: Lista las dependencias del proyecto, especificando el grupo, nombre y versión de las bibliotecas utilizadas.
3. `<build>`: Contiene configuraciones para la construcción del proyecto, incluyendo plugins, directorios de salida, y otras configuraciones relacionadas con la compilación.
4. `<plugins>`: Define los plugins de Maven utilizados para tareas específicas, como la compilación, la ejecución de pruebas, y la generación de informes.
El archivo `pom.xml` actúa como el descriptor del proyecto y proporciona a Maven las instrucciones necesarias para gestionar el ciclo de vida del proyecto. Además, facilita la colaboración y la reproducción del entorno de desarrollo al incluir información detallada sobre las dependencias y configuraciones del proyecto.
Connection myConn = null; // NUestro objeto de conexion
Statement myStamt = null; // Objeto Statement
ResultSet myRes = null; // Para procesar nuestros resultados
try {
// 1. Conexion a nuesta base de datos, pasando 3 arhumentos
myConn = DriverManager.*getConnection*("jdbc:mysql://localhost:3306/bdproyecto","root","");
// 2 . crear una declaracion obejto
myStamt = myConn.createStatement();
//3. Ejecutar la consulta Sql
myRes = myStamt.executeQuery("Select \* from usuario");
while (myRes.next()){
System.*out*.println(myRes.getString("nombres"));
}
}catch (Exception e){
e.printStackTrace();
System.*out*.println("Algo salio mal ");
}
hora entonces se carga poor dependencias !
<dependencies>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>
En las primeras clases escribí sobre este punto, que bueno que lo usaron, quizás pudieron haber iniciado asi, es la forma correcta de crear un proyecto Java y manejar las dependencias.
```js
Hola no entiendo porque me sale error, podrían ayudarme por favor
```
Cuando lo hago automatico me carga el conector 5.1.46 y en el repositorio de Maven esta el 8.3.0, sin embargo con ninguno me funcionaba. Busque la opcion de reindexar Maven en el IDE. Cerre todo el proyecto y volvi a abrir.
Buenas tardes, si me pueden apoyar con la consulta:
Una consulta a la profesora cuando presiona ALT + INSERT le sale bastante resultados, en mi caso solo el proyecto. En la sección de "repositories" hay un icono de maven
Le di click derecho "Reindex repository" se tardo como 20 minutos en temrinar pero igual cuando presiono ALT + INSERT no me muestra como la profesora. Por favor si me pueden responder. Gracias
Listo el proyecto CRUD. Con el Alt+Insert fue mucho mas fácil agregar la dependencia en el pom.xml.
esta forma es más facil para evitar en buscar el conector para mi mysql 5.1.42
creo que seria mejor refactorizarlos en métodos, aunque pues el punto de primeros videos es explicar como funciona JDBC. sim embargo aqui les dejo una forma de como se harian unos simples metodos para reutilizar.
```java
public void update(int userid, String name, String email, String password) {
String query = "UPDATE user SET name = ?, email = ?, password = ? WHERE id = ?";
try {
PreparedStatement prepareStatement = this.connection.prepareStatement(query);
prepareStatement.setString(1, name);
prepareStatement.setString(2, email);
prepareStatement.setString(3, password);
prepareStatement.setInt(4, userid);
int rowsUpdated = prepareStatement.executeUpdate();
if (rowsUpdated > 0) {
System.out.println("An existing user was updated successfully!");
}
} catch (Exception e) {
System.out.println("Something went wrong");
}
}
public void delete(int userId) {
String query = "DELETE FROM user where id=?";
try {
PreparedStatement preparedStatement = this.connection.prepareStatement(query);
preparedStatement.setInt(1, userId);
boolean rowsDeleted = preparedStatement.execute();
if (rowsDeleted) {
System.out.println("A user was deleted successfully!");
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
```
creo que seria mejor refactorizarlos en métodos, aunque pues el punto de primeros videos es explicar como funciona JDBC.
sim embargo aqui les dejo una forma de como se harian unos simples metodos para reutilizar.
`public void update(int userid, String name, String email, String password) {`
` String query = "UPDATE user SET name = ?, email = ?, password = ? WHERE id = ?";`
` try {`
` PreparedStatement prepareStatement = this.connection.prepareStatement(query);`
` prepareStatement.setString(1, name);`
` prepareStatement.setString(2, email);`
` prepareStatement.setString(3, password);`
` prepareStatement.setInt(4, userid);`
` int rowsUpdated = prepareStatement.executeUpdate();`
` if (rowsUpdated > 0) {`
` System.out.println("An existing user was updated successfully!");`
` }`
` } catch (Exception e) {`
` System.out.println("Something went wrong");`
` }`
` }`
` public void delete(int userId) {`
` String query = "DELETE FROM user where id=?";`
` try {`
` PreparedStatement preparedStatement = this.connection.prepareStatement(query);`
` preparedStatement.setInt(1, userId);`
` boolean rowsDeleted = preparedStatement.execute();`
` if (rowsDeleted) {`
` System.out.println("A user was deleted successfully!");`
` }`
` } catch (Exception e) {`
` System.out.println(e.getMessage());`
` }`
` }`
Hola buen dia. Alguien que por favor me pueda apoyar. Al dia de hoy el IDE no se muestra tal cual lo tiene la profesora. De todas maneras al crear el proyecto Maven, el pom se genera vacio. Qué debo hacer en este caso para agregar la dependencia del conecctor mysql?? Help me....!!!!
\
\<dependency>
\<groupId>com.mysql\</groupId>
\<artifactId>mysql-connector-j\</artifactId>
\<version>8.0.33\</version>
\</dependency>
``
`<dependency>`
` <groupId>com.mysql</groupId>`
` <artifactId>mysql-connector-j</artifactId>`
` <version>8.0.33</version>`
`</dependency>`
Para los usuarios de Mac el atajo de generar dependencias es Command+N
Podrian ayudarme con esto -> OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended me descargue de otro proveedor y me sale eso
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?