Modelo Vista Presentador MVP

 El patrón de diseño Modelo-Vista-Presentador (MVP) es una variante del patrón Modelo-Vista-Controlador (MVC), utilizado comúnmente en el desarrollo de aplicaciones de interfaz de usuario. En MVP, la lógica de presentación (Presentador) se separa de la lógica de la interfaz de usuario (Vista), y la comunicación entre ambas se realiza a través de interfaces. El Modelo representa los datos y la lógica de negocio de la aplicación.

Este modelo es similar al MVC que explicare a continuacion con sus caracteristicas y diferencias de cada uno.

El patrón de diseño Modelo-Vista-Controlador (MVC) es un enfoque arquitectónico utilizado en el desarrollo de software para separar las responsabilidades en una aplicación. Este patrón consta de tres componentes principales: el Modelo, la Vista y el Controlador. A continuación, se detallan las características y diferencias clave del MVC:

El patrón Modelo-Vista-Presentador (MVP) es una variante del patrón Modelo-Vista-Controlador (MVC) y se utiliza para estructurar aplicaciones de interfaz de usuario. Aquí están las características clave del patrón MVP:

Caracterizticas del MVP.

1. Separación de Responsabilidades:

Al igual que el MVC, el MVP busca la separación clara de las responsabilidades entre los componentes principales: Modelo, Vista y Presentador.

2. Modelo (Model):

Contiene la lógica de negocio y los datos de la aplicación, similar al modelo en MVC.

3. Vista (View):

Representa la interfaz de usuario y es responsable de mostrar la información al usuario.

4. Presentador (Presenter):

Actúa como intermediario entre el Modelo y la Vista.

Maneja las interacciones del usuario y actualiza el Modelo y la Vista según sea necesario.

En el MVP, el Presentador tiene un papel más activo en comparación con el Controlador en el MVC.

5. Dirección de la Comunicación:

La Vista observa al Presentador en lugar de al Modelo. La comunicación entre la Vista y el Modelo se realiza a través del Presentador.

6. Eventos:

El Presentador maneja los eventos generados por la Vista, como clics de botones o entradas de usuario.

Se busca minimizar la lógica en la Vista, moviéndola al Presentador para facilitar las pruebas unitarias.

7. Pruebas Unitarias:

Facilita las pruebas unitarias, ya que la lógica de presentación está concentrada en el Presentador, y la Vista y el Modelo se pueden simular fácilmente.

8. Acoplamiento:

Introduce una capa intermedia (Presentador) que reduce el acoplamiento entre la Vista y el Modelo.

El acoplamiento es más débil que en el MVC tradicional, lo que mejora la mantenibilidad y la flexibilidad.

9. Flexibilidad:

Permite cambiar la interfaz de usuario o la lógica de negocio sin afectar directamente a la otra parte.

10. Manejo de Actualizaciones:

El Presentador se encarga de actualizar la Vista en función de los cambios en el Modelo, manteniendo así una separación limpia.

11. Implementación de Interfaces:

La comunicación entre la Vista y el Presentador se realiza mediante interfaces, lo que facilita la sustitución de componentes y la implementación de pruebas de unidad.

12. Adaptabilidad:

Es adaptable a entornos con interfaces gráficas y facilita la implementación de patrones como MVP Passive View o MVP Supervising Controller según los requisitos.

En resumen, el MVP mantiene la separación de responsabilidades del MVC pero introduce una mayor participación del Presentador en la lógica de presentación y el manejo de eventos. Esta variante busca reducir el acoplamiento y mejorar la testabilidad y la mantenibilidad de las aplicaciones de interfaz de usuario.

Diferencias del MVC:

1. Dirección de la Comunicación:

Modelo-Vista-Controlador (MVC): La Vista observa al Modelo, y el Controlador actualiza el Modelo y la Vista.

Modelo-Vista-Presentador (MVP): La Vista observa al Presentador, y el Presentador actualiza tanto el Modelo como la Vista.

2. Manejo de Eventos:

MVC: El Controlador maneja los eventos del usuario y actualiza el Modelo y la Vista según sea necesario.

MVP: El Presentador maneja los eventos y actúa como intermediario entre la Vista y el Modelo.

3. Conexión entre Componentes:

MVC: La Vista y el Modelo pueden tener una conexión directa.

MVP: La Vista y el Modelo se comunican solo a través del Presentador.

4. Testeo:

MVC: Puede ser más desafiante de probar debido a la conexión directa entre la Vista y el Modelo.

MVP: Facilita las pruebas unitarias, ya que la Vista y el Modelo se comunican a través del Presentador.

5. Acoplamiento:

MVC: Puede tener un acoplamiento más fuerte entre la Vista y el Modelo.

MVP: Introduce una capa intermedia (Presentador) que reduce el acoplamiento entre la Vista y el Modelo.

En resumen, aunque comparten el principio de separación de responsabilidades, MVC y MVP presentan diferencias en la dirección de la comunicación, el manejo de eventos y la conexión entre componentes, lo que puede afectar la facilidad de prueba y el acoplamiento entre los elementos. La elección entre ellos dependerá de los requisitos y preferencias específicos del desarrollo de la aplicación.

Características del MVC:

1. Separación de Responsabilidades:

Modelo (Model): Se encarga de la lógica de la aplicación y la gestión de los datos.

Vista (View): Representa la interfaz de usuario y se encarga de mostrar la información al usuario.

Controlador (Controller): Gestiona las interacciones del usuario, actualiza el modelo y modifica la vista en consecuencia.

2. Reusabilidad:

Permite la reutilización de componentes. Cambios en la interfaz no deberían afectar la lógica de negocio y viceversa.

3. Facilita el Mantenimiento:

Los cambios en una capa (Modelo, Vista o Controlador) no deberían requerir cambios significativos en las otras capas.

4. Escalabilidad:

Permite una fácil expansión y mantenimiento a medida que la aplicación crece.

5. Testeabilidad:

Facilita las pruebas unitarias, ya que cada componente puede ser probado de forma independiente.

6. Flexibilidad:

Permite cambiar la interfaz de usuario o la lógica de negocio sin afectar la otra parte.

Voy a explicar cómo se implementaría el patrón MVP en el contexto de una simple calculadora. En este ejemplo, la calculadora tendrá funciones de suma, resta, multiplicación y división.

Modelo:

El modelo contendría la lógica de la calculadora y los datos necesarios para realizar las operaciones.

java

Copy code

public class CalculadoraModelo {

    public double sumar(double num1, double num2) {

        return num1 + num2;

    }

    public double restar(double num1, double num2) {

        return num1 - num2;

    }

    public double multiplicar(double num1, double num2) {

        return num1 * num2;

    }

    public double dividir(double num1, double num2) {

        if (num2 != 0) {

            return num1 / num2;

        } else {

            throw new ArithmeticException("No es posible dividir por cero");

        }

    }

}

Vista:

La vista se encarga de la interfaz de usuario y la presentación de datos. En este caso, podría ser una interfaz gráfica de usuario con botones para los números y operaciones, y un campo para mostrar el resultado.

java

Copy code

public interface CalculadoraVista {

    void mostrarResultado(double resultado);

    double getNumero1();

    double getNumero2();

    String getOperacion();

}

Presentador:

El presentador actúa como intermediario entre la vista y el modelo. Se encarga de manejar eventos del usuario desde la vista y coordinar la interacción con el modelo.

java

Copy code

public class CalculadoraPresentador {

    private CalculadoraModelo modelo;

    private CalculadoraVista vista;

    public CalculadoraPresentador(CalculadoraModelo modelo, CalculadoraVista vista) {

        this.modelo = modelo;

        this.vista = vista;

    }

    public void realizarOperacion() {

        double num1 = vista.getNumero1();

        double num2 = vista.getNumero2();

        String operacion = vista.getOperacion();

        double resultado = 0;

        switch (operacion) {

            case "Suma":

                resultado = modelo.sumar(num1, num2);

                break;

            case "Resta":

                resultado = modelo.restar(num1, num2);

                break;

            case "Multiplicacion":

                resultado = modelo.multiplicar(num1, num2);

                break;

            case "Division":

                try {

                    resultado = modelo.dividir(num1, num2);

                } catch (ArithmeticException e) {

                    vista.mostrarResultado(Double.NaN); // Mostrar un valor especial para indicar error

                    return;

                }

                break;

        }

        vista.mostrarResultado(resultado);

    }

}

En este ejemplo, el Presentador coordina la interacción entre la Vista y el Modelo. La vista notificará al presentador cuando el usuario haya ingresado números y seleccionado una operación, y el presentador realizará la operación correspondiente a través del modelo. Luego, el resultado se enviará de vuelta a la vista para su presentación.

Esta separación de responsabilidades facilita las pruebas unitarias, el mantenimiento y la escalabilidad del código.