Patrón Repository con JDBC en Java

Contenido del curso

No sé dónde empezar

JDBC

CRUD

Transacciones

Conexiones Pool

JPA y ORM

Próximos pasos

22
Clon de Netflix con JDBC o JPA
02:29 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0020:24

Patrón Repository con JDBC en Java

Curso de Java SE: SQL y Bases de Datos

Clase 11 de 22

Clase 11 / 22

Recursos

Implementar el patrón Repository en Java te permite separar la lógica de acceso a datos del resto de tu aplicación. Aquí construyes una interfaz genérica con métodos CRUD y la aterrizas en una clase concreta llamada EmployeeRepository, usando JDBC para conectarte a la base de datos y recorrer resultados.

¿Qué métodos debe tener una interfaz Repository genérica?

La interfaz Repository se define con un tipo genérico T para que pueda reutilizarse con cualquier entidad. Esto evita repetir código cuando agregas nuevas tablas a tu proyecto.

Los métodos base que vas a declarar son cuatro y cubren las operaciones esenciales de lectura y escritura:

List<T> findAll() para leer todos los registros.
T getById(Integer id) para leer un registro específico.
void save(T entity) que internamente decide entre insert o update.
void delete(Integer id) para eliminar por identificador.

¿Por qué usar genéricos en una interfaz Repository? Porque te permite reutilizar la misma estructura para distintas entidades como Employee, Product o Customer sin reescribir las firmas de los métodos.

¿Cómo implementar findAll con JDBC y try with resources?

En EmployeeRepository cambias el genérico T por Employee al implementar la interfaz. Lo primero es declarar una conexión privada usando el patrón Singleton de tu clase DatabaseConnection:

java private Connection getConnection = DatabaseConnection.getInstance();

Dentro de findAll() usas un bloque try with resources para que el Statement y el ResultSet se cierren automáticamente. La consulta es un simple SELECT * FROM employees ejecutado con executeQuery().

¿Cómo recorrer un ResultSet y mapearlo a objetos?

Mientras myRes.next() devuelva verdadero, creas una nueva instancia de Employee y le asignas cada campo según su tipo de dato:

setId con myRes.getInt("id").
setFirstName y setSurname con getString.
setEmail con getString.
setSalary con getFloat.

Cada empleado creado se agrega a una lista declarada al inicio del método: List<Employee> employees = new ArrayList<>(). Al final, retornas esa lista.

¿Cómo refactorizar código repetido con Extract Method?

Como el mapeo de un ResultSet a un Employee se va a repetir en getById y otros métodos, conviene extraerlo. En IntelliJ seleccionas el bloque, clic derecho, Refactor y luego Extract Method. Le asignas el nombre createEmployee.

El método extraído queda así:

java private Employee createEmployee(ResultSet myRes) throws SQLException { Employee e = new Employee(); e.setId(myRes.getInt("id")); e.setFirstName(myRes.getString("firstName")); e.setSurname(myRes.getString("surname")); e.setEmail(myRes.getString("email")); e.setSalary(myRes.getFloat("salary")); return e; }

Ahora dentro del while solo necesitas llamar employees.add(createEmployee(myRes)) y tu código queda mucho más legible.

¿Qué hace Extract Method en IntelliJ? Toma un fragmento de código repetido y lo convierte en un método independiente con parámetros y retorno, mejorando la mantenibilidad sin cambiar el comportamiento.

¿Cómo implementar getById con PreparedStatement?

Para buscar un registro único usas un PreparedStatement en lugar de Statement, porque necesitas pasar parámetros de forma segura y evitar inyección SQL.

La consulta queda como SELECT * FROM employees WHERE id = ? y antes de ejecutar haces myStmt.setInt(1, id) para vincular el parámetro. Luego ejecutas executeQuery() dentro de otro try with resources anidado para el ResultSet.

Si myRes.next() devuelve verdadero, llamas a createEmployee(myRes) y asignas el resultado a la variable employee que retornarás. Si no encuentra nada, devuelve null porque la variable se inicializa en ese valor.

¿Cómo probar el repositorio desde el método main?

En tu clase Main, dentro del try que maneja la conexión, instancias el repositorio y recorres los resultados con un forEach:

java Repository<Employee> repository = new EmployeeRepository(); repository.findAll().forEach(System.out::println);

Un detalle importante que puede fallar: si al extraer createEmployee se te olvidó volver a agregar employees.add(e) dentro del bucle, la lista regresa vacía aunque la consulta funcione. Revisa siempre que el método original siga agregando el objeto a la colección.

Otro punto fácil de pasar por alto es el nombre de la tabla. En MySQL las tablas suelen ser sensibles a mayúsculas según el sistema operativo, así que verifica que employees esté escrito tal cual existe en tu base de datos.

¿Cómo mejorar la salida al imprimir empleados?

La representación por defecto de un objeto en Java muestra la clase y un hash. Para que el System.out.println muestre información legible, sobrescribe el método toString() en la clase Employee devolviendo una cadena con los campos formateados como prefieras. Comparte tu versión en los comentarios.

¿Cómo dejarías tú el toString de Employee para que la consola se vea más estilizada?

Nicolas Botello Mendoza

Hace 3 años

Buenas, tengo 2 preguntas que me gustaría aclarar,

La primera esta relacionada el siguiente código

1 Repository<Employee> repository = new EmployeeRepository();         
2 repository.findAll().forEach(System.out::println);

Me funciona perfecto, pero mi pregunta esta relacionado a la primera línea (1), ya que no entiendo porque sirve, según tengo entendido las interfaces no se pueden instanciar y según yo en esa línea si se esta instanciando y no genera un error. Así que me gustaría saber porque es que funciona ese línea de código

La segunda pregunta tiene que ver en que se diferencia entre hacerlo como este arriba o como lo hice abajo en el siguiente codigo, lo unico que cambia es que en vez de instanciar la interfaz, lo hago con la clase EmployeeRepository:

1 EmployeeRepository e  = new EmployeeRepository();
2 e.findAll().forEach(System.out::println);

Como tal mi pregunta seria: ya que generar el mismo resultado, es cual forma es mejor de aplicarlo ? y porque ?

Ana Fernanda Gutierrez Villanueva

Profesor

Hace 3 años

En la línea 1 estas instanciando una clase que implementa esa interfaz, que en este caso es EmployeeRepository.

Usar la interfaz (Repository<Employee> repository = new EmployeeRepository();): Es útil cuando quieres desacoplar el código que usa la interfaz de la implementación concreta. Esto te va facilitar el cambio de la implementación sin afectar el código que utiliza la interfaz. 😊

**Usar la clase concreta (EmployeeRepository e = new EmployeeRepository();): ** Puede ser apropiado cuando no anticipas cambiar la implementación y prefieres una sintaxis más directa. Esto puede ser más conveniente en situaciones simples o cuando la implementación concreta es parte del contexto.

Ana Fernanda Gutierrez Villanueva

Profesor

Hace 2 años

¿Por qué funciona la línea de código que usa la interfaz?

Repository<Employee> repository = new EmployeeRepository();
repository.findAll().forEach(System.out::println);

En esta línea de código, no estás instanciando una interfaz. Lo que estás haciendo es crear una instancia de EmployeeRepository, que es una clase concreta que implementa la interfaz Repository<Employee>.

La línea:

Repository<Employee> repository = new EmployeeRepository();

significa que repository es una variable de tipo Repository<Employee>, pero la instancia real que se le asigna es de tipo EmployeeRepository. Esto es perfectamente válido en Java debido al polimorfismo, donde una variable de tipo interfaz puede referenciar a cualquier objeto de una clase que implemente esa interfaz.

Esto permite que:

Desacoplamiento: Tu código no está firmemente acoplado a la implementación específica (EmployeeRepository), sino a la abstracción (Repository<Employee>). Esto facilita cambiar la implementación en el futuro sin afectar el resto del código.
Flexibilidad: Puedes pasar diferentes implementaciones de la interfaz Repository sin necesidad de cambiar el código que utiliza repository.

++¿Cuál es la diferencia y cuál es mejor?++ Ambas opciones generan el mismo resultado, pero hay diferencias importantes en cuanto a diseño y flexibilidad del código.

Usando la interfaz:

Como se mencionó antes, el uso de la interfaz (Repository<Employee>) permite desacoplar el código de la implementación específica. Esto hace que tu código sea más flexible y fácil de mantener.
Es más fácil sustituir la implementación de la interfaz con una nueva implementación sin necesidad de cambiar el código que usa la interfaz.

Usando la clase concreta:

El código está más acoplado a la implementación específica (EmployeeRepository). Esto puede dificultar cambios futuros en la implementación.
Cambiar a una implementación diferente de Repository<Employee> requerirá cambios en todas partes donde se utiliza EmployeeRepository directamente.

Aunque ambas opciones funcionan, usar la interfaz proporciona mayor flexibilidad y desacoplamiento, lo cual es preferido en el diseño de software.

Comentarios (27)27 comentarios

Edwin David Diaz Parra

Moni Guerra

Paul Flores

Marlon Jose Cardenas Castellanos

Hace 3 meses

ANDRES ALFONSO MIRA MEJIA

Hace 10 meses

Jaiver Martinez

Alejandro Calderón

Omar Darío Salcedo Solarte

Hace un año

Xavier Armando Larios Alvarenga

Jesús Patricio Pereira Matus

Francisco Lopez Campos

Vicente Eduardo Gonzalez

William Fernando Tovar Arevalo

Gabriel Omar Gramajo

Ramon Antonio Campos Valencia

Juan Marcelo Panasiti

Alvaro Poma

Jose Carrillo Zenteno

JDBC

Arquitectura y Funcionamiento de la API JDBC

Qué es JDBC y cómo conecta Java a bases de datos

Componentes y métodos clave de JDBC

Conexión a MySQL con JDBC en Java

Consultas SQL en Java con JDBC

Update y Delete en Java con JDBC

CRUD

Creación de Proyectos Java con Maven y Gestión de Dependencias

Try-with-resources para cerrar conexiones JDBC

Patrón DAO vs Repository en Java

Patrón Repository con Singleton en Java

Patrón Repository con JDBC en Java

Insertar datos en MySQL con PreparedStatement

Método delete en JDBC con PreparedStatement

Interfaz gráfica de CRUD con Java Swing

Transacciones

Transacciones en bases de datos y principios ACID

Transacciones en Java con commit y rollback

Conexiones Pool

Pool de conexiones a bases de datos

Implementación de Pool de Conexiones en Java con Apache Commons

JPA y ORM

Fundamentos de JPA y sus Anotaciones Principales

Configuración de JPA con Hibernate en Maven

Operaciones CRUD con JPA en Java

Próximos pasos

Clon de Netflix con JDBC o JPA

Patrón Repository con JDBC en Java

Progreso del curso

JDBC

CRUD

Transacciones

Conexiones Pool

JPA y ORM

Próximos pasos

Recursos

Recursos