Implementación de Interfaz Repository en EmployeeRepository

Clase 11 de 22 • Curso de Java SE: SQL y Bases de Datos

Resumen

En el paquete repository, creamos la clase EmployeeRepository que implementa la interfaz Repository. En esta clase, implementamos todos los métodos definidos en la interfaz y comenzamos a codificar cada uno de ellos.

Comenzamos con los métodos findAll() y getById(), que corresponden a las operaciones de lectura en el CRUD. Aprendimos a extraer un método utilizando la opción “Refactor” > “Extract Method” en nuestro IDE. Esta técnica nos permitió reutilizar código y evitar repetir la lógica de asignación de valores a través de los métodos set de la clase Employee. En su lugar, creamos el método createEmployee, que nos ayuda a encapsular esa lógica y mejorar la legibilidad y mantenibilidad del código.

Ana Fernanda Gutierrez Villanueva

teacher•

Comenzamos con los métodos findAll() y getById(), que corresponden a las operaciones de lectura en el CRUD. Aprendimos a extraer un método utilizando la opción "Refactor" > "Extract Method" en nuestro IDE. Esta técnica nos permitió reutilizar código y evitar repetir la lógica de asignación de valores a través de los métodos set de la clase Employee. En su lugar, creamos el método createEmployee, que nos ayuda a encapsular esa lógica y mejorar la legibilidad y mantenibilidad del código.

Edwin David Montiel

student•

Muy buena explicación, gracias por la clase Profe Ana

Moni Guerra

student•

Muy bien por la explicación. Por favor compartir un artículo sobre lo que son las interfaces. Gracias Profe Ana.

Nicolas Botello Mendoza

student•

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

teacher•

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

teacher•

¿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.

Paul Flores

student•

Aquí dejo mi código para una estatica más agradable

    @Override
    public String toString() {
        return
                "\n-------------------------------------"+
                "\nEmployee" +
                "\nid: " + id +
                "\nfirst_name: " + first_name +
                "\npa_surname: " + pa_surname +
                "\nma_surname: " + ma_surname +
                "\nemail: " + email +
                "\nsalary: " + salary +
                "\n-------------------------------------"
        ;
    }

Moni Guerra

student•

Gracias profe. Me ha costado un poco entender la lógica del patrón, por esto he visto el video varias veces. Pero éxito en mi ejercicio. Yo utilizo una tabla diferente.

Omar Darío Salcedo Solarte

student•

yo lo hice de este modo:

@Overridepublic String toString() {    return "=== DETALLES DEL EMPLEADO ===" +            "\nID: " + Id +            "\nNombre Completo: " + PrimerNombre + " " + (SegundoNombre != null ? SegundoNombre + " " : "") + PrimerApellido + " " + SegundoApellido +            "\n------------------------------" +            "\nPrimer Nombre: " + PrimerNombre +            "\nSegundo Nombre: " + (SegundoNombre != null ? SegundoNombre : "N/A") +            "\nPrimer Apellido: " + PrimerApellido +            "\nSegundo Apellido: " + (SegundoApellido != null ? SegundoApellido : "N/A") +            "\nEmail: " + Email +            "\nSalario: $" + Salario +            "\n==============================";}

La salida estuvo asi:

Xavier Armando Larios Alvarenga

student•

El método toString() en Java es un método de la clase Object que se utiliza para obtener una representación en forma de cadena de un objeto. Este método se puede sobrescribir en tus propias clases para devolver una cadena que contenga información significativa sobre el objeto, como sus atributos y valores. Al sobrescribir toString(), puedes facilitar la depuración y la visualización del contenido de un objeto en una forma legible.

En el contexto de las clases y objetos que has aprendido, es útil para mejorar la presentación de datos.

Xavier Armando Larios Alvarenga

student•

En la clase EmployeeRepository, es importante crear el método getConnection() para gestionar la conexión a la base de datos de manera adecuada y encapsulada. Aunque getInstance() puede ser estático y proporciona una instancia de conexión, tener un método separado para obtener la conexión permite un control más específico sobre el manejo de recursos y excepciones. Esto también facilita la posibilidad de reutilizar la lógica de conexión en diferentes métodos sin repetir código, lo que puede llevar a un mejor diseño y mantenimiento del código.

Jesús Patricio Pereira Matus

student•

dato curioso, no es necesario crear una variable para guardar el empleado y asignarsela al add porque de por si el metodo createEmployee devuelve el employee gracias al return

Francisco Lopez Campos

student•

Asi estilice el metodo toString()

Vicente Eduardo Gonzalez

student•

Para qué se conecta a la base de datos dos veces? en el método main declara un try-with-resources donde usa la clase utilitaria de DatabaseConnection para obtener una conexion, y dentro del try usa metodos de la clase EmployeeRepository la cual a su vez también se conecta con su propio método privado getConnection();

William Fernando Tovar Arevalo

student•

Necesito ayuda, resulta que cuando voy a crear un objeto tipo employee, me pide los 6 parámetros del constructor y en la clase a la profesora no se los pide :(

Employee e = new Employee();

Gabriel Omar Gramajo

student•

seguramente es porque no creaste un constructor vacío en la clase Employee

Jaiver Martinez

student•

Muy buena clase, sin embargo creo que faltó profundizar un poco porqué Repository es Interface, además lo de la notación <T>; Si en los recursos pueden poner algo que trate sobre esto, sería ideal

Alejandro Calderón

student•

Una interfaz es como una clase al funcionar como una "plantila". Verlo asi se me hizo mas sencillo. Eso de la <T> es que el respositorio puede ser se tipo (o clase) de cualquier entidad del programa, sea Employee, Administrator o Manager. Para todas esas entidades voy a requeir una misma estructura de metodos, reflejados en la interfaz Repository. Espero te sea util amigo.

Ramon Antonio Campos Valencia

student•

package org.example.platzi.repository;

import org.example.platzi.model.Employee;
import org.example.platzi.util.DatabaseConnection;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class EmployeeRepository implements Repository <Employee>{

    private Connection getConnection() throws SQLException {
        return DatabaseConnection.getInstance();
    }

    @Override
    public List<Employee> findAll() throws SQLException{
        List<Employee> employees = new ArrayList<>();
        try(Statement myStand = getConnection().createStatement();
           ResultSet myRes = myStand.executeQuery("SELECT * FROM employees")){

            while(myRes.next()){
                Employee e = createEmployee(myRes);
                employees.add(e);
            }
        } catch (SQLException e) {
            throw new SQLException(e);
        }
        return employees;
    }



    @Override
    public Employee getById(Integer id) throws SQLException {
        Employee employee = null;
        try(PreparedStatement myStant = getConnection().prepareStatement("SELECT  * FROM employees WHERE  id = ?")){
            myStant.setInt(1,id);
            try(ResultSet myRes = myStant.executeQuery()) {
                if (myRes.next()){
                    employee = createEmployee(myRes);
                }
            }
            return employee;
        }
    }

    @Override
    public void save(Employee employee) {

    }

    @Override
    public void delete(Integer I) {

    }

    private Employee createEmployee(ResultSet myRes) throws SQLException {
        Employee e = new Employee();
        e.setId(myRes.getInt("id"));
        e.setFirst_name(myRes.getString("first_name"));
        e.setPa_surname(myRes.getString("pa_surname"));
        e.setMa_surname(myRes.getString("ma_surname"));
        e.setEmail(myRes.getString("email"));
        e.setSalary(myRes.getFloat("salary"));
    return e;
    }
}

```package org.example.platzi.repository;
import org.example.platzi.model.Employee;
import org.example.platzi.util.DatabaseConnection;
import java.sql.\*;
import java.util.ArrayList;
import java.util.List;
public class EmployeeRepository implements Repository \<Employee>{

&#x20;   private Connection getConnection() throws SQLException {
&#x20;       return DatabaseConnection.*getInstance*();
&#x20;   }

&#x20;   @Override
&#x20;   public List\<Employee> findAll() throws SQLException{
&#x20;       List\<Employee> employees = new ArrayList<>();
&#x20;       try(Statement myStand = getConnection().createStatement();
&#x20;          ResultSet myRes = myStand.executeQuery("SELECT \* FROM employees")){

&#x20;           while(myRes.next()){
&#x20;               Employee e = createEmployee(myRes);
&#x20;               employees.add(e);
&#x20;           }
&#x20;       } catch (SQLException e) {
&#x20;           throw new SQLException(e);
&#x20;       }
&#x20;       return employees;
&#x20;   }



&#x20;   @Override
&#x20;   public Employee getById(Integer id) throws SQLException {
&#x20;       Employee employee = null;
&#x20;       try(PreparedStatement myStant = getConnection().prepareStatement("SELECT  \* FROM employees WHERE  id = ?")){
&#x20;           myStant.setInt(1,id);
&#x20;           try(ResultSet myRes = myStant.executeQuery()) {
&#x20;               if (myRes.next()){
&#x20;                   employee = createEmployee(myRes);
&#x20;               }
&#x20;           }
&#x20;           return employee;
&#x20;       }
&#x20;   }

&#x20;   @Override
&#x20;   public void save(Employee employee) {

&#x20;   }

&#x20;   @Override
&#x20;   public void delete(Integer I) {

&#x20;   }

&#x20;   private Employee createEmployee(ResultSet myRes) throws SQLException {
&#x20;       Employee e = new Employee();
&#x20;       e.setId(myRes.getInt("id"));
&#x20;       e.setFirst\_name(myRes.getString("first\_name"));
&#x20;       e.setPa\_surname(myRes.getString("pa\_surname"));
&#x20;       e.setMa\_surname(myRes.getString("ma\_surname"));
&#x20;       e.setEmail(myRes.getString("email"));
&#x20;       e.setSalary(myRes.getFloat("salary"));
&#x20;   return e;
&#x20;   }
}

Juan Marcelo Panasiti

student•

Excelente clase, rescato mucho las explicaciones y los tips a la hora de trabajar con el IDE

Juan Marcelo Panasiti

student•

El método main me quedó directamente así: public static void main(String[] args) throws SQLException { Repository<Employee> repo = new EmployeeRepository(); repo.findAll().forEach(System.``out``::println); }

Sin necesidad del bloque try with resources (aparte resource que tenia no hacia falta)

Juan Marcelo Panasiti

student•

Buena explicación, nomás recomendaría no utilizar variables nombradas con una sola letra, incluso aunque se utilice solo dentro de un método, mejor llamarle "employee" en vez de "e"

Alvaro Poma

student•

Mi main:

public static void main(String[] args) { try (Connection myConn = DatabaseConnection.``getInstance``()){ Repository<Employee> empRepo = new EmployeeRepository(); System.``out``.println("Find All Employees"); empRepo.findAll().forEach(System.``out``::println); System.``out``.println("Find one Employee by ID"); System.``out``.println(empRepo.findById(1)); }catch (SQLException e){ e.printStackTrace(); System.``out``.println("Error to connect to database!"); } }

Jose Carrillo Zenteno

student•

public String toString() {

return "PERSONA{" +

"\t IdPersona=" + IdPersona +

",\t NombrePersona='" + NombrePersona + '\'' +

'}';

}

Joahan Carlo Nuñez Soto

student•

Aquí esta mi aporte :

public String toString() {

return "Employee{" +

"\n id : " + id +

"\n firts_name : " + firts_name +

"\n pa_surname : " + pa_surname +

"\n ma_surname : " + ma_surname +

"\n email : " + email +

"\n salary : " + salary + '}';

}

Daniel Camacho

student•

Tambien es bueno definir el mapeo de registros a objetos, en un archivo aparte como utilidad, para no hacer la implementacion por cada metodo