Model-View-Controller (MVC) Pattern

// Model
class Student {
    private String name;
    private int grade;
    private List<View> views;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
        this.views = new ArrayList<>();
    }

    public void addView(View view) {
        views.add(view);
    }

    public String getName() { return name; }
    public int getGrade() { return grade; }

    public void setName(String name) {
        this.name = name;
        notifyViews();
    }

    public void setGrade(int grade) {
        this.grade = grade;
        notifyViews();
    }

    private void notifyViews() {
        for (View view : views) {
            view.update();
        }
    }
}

// View Interface
interface View {
    void update();
}

// Concrete View
class StudentView implements View {
    private Student student;

    public StudentView(Student student) {
        this.student = student;
    }

    @Override
    public void update() {
        System.out.println("Student Details: Name = " + student.getName() + ", Grade = " + student.getGrade());
    }
}

// Controller
class StudentController {
    private Student model;
    private View view;

    public StudentController(Student model, View view) {
        this.model = model;
        this.view = view;
        model.addView(view); // Register view with model
    }

    public void setStudentName(String name) {
        model.setName(name);
    }

    public void setStudentGrade(int grade) {
        model.setGrade(grade);
    }

    public void updateView() {
        view.update();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Create Model
        Student student = new Student("Amit", 85);

        // Create View
        StudentView view = new StudentView(student);

        // Create Controller
        StudentController controller = new StudentController(student, view);

        // Initial state
        System.out.println("Initial Student Details:");
        controller.updateView();

        // Update via Controller
        System.out.println("\nUpdating student name to Priya:");
        controller.setStudentName("Priya");

        System.out.println("\nUpdating student grade to 90:");
        controller.setStudentGrade(90);

        // Add another View (demonstrating multiple views)
        StudentView anotherView = new StudentView(student);
        student.addView(anotherView);
        System.out.println("\nUpdating grade with multiple views:");
        controller.setStudentGrade(95);
    }
}
/*
Initial Student Details:
Student Details: Name = Amit, Grade = 85

Updating student name to Priya:
Student Details: Name = Priya, Grade = 85

Updating student grade to 90:
Student Details: Name = Priya, Grade = 90

Updating grade with multiple views:
Student Details: Name = Priya, Grade = 95
Student Details: Name = Priya, Grade = 95
*/
Code language: PHP (php)

Use case and Implementation

User Profile Management Using MVC Pattern.

//MVCPatternDemo.java
// User.java
class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

// UserView.java
class UserView {
    public void printUserDetails(String userName, String userEmail) {
        System.out.println("User Details:");
        System.out.println("Name: " + userName);
        System.out.println("Email: " + userEmail);
        System.out.println("-------------------------");
    }
}

// UserController.java
class UserController {
    private User model;
    private UserView view;

    public UserController(User model, UserView view) {
        this.model = model;
        this.view = view;
    }

    public void setUserName(String name) {
        if (name != null && !name.trim().isEmpty()) {
            model.setName(name);
        } else {
            System.out.println("Invalid name. Name cannot be empty.");
        }
    }

    public String getUserName() {
        return model.getName();
    }

    public void setUserEmail(String email) {
        if (email != null && !email.trim().isEmpty()) {
            model.setEmail(email);
        } else {
            System.out.println("Invalid email. Email cannot be empty.");
        }
    }

    public String getUserEmail() {
        return model.getEmail();
    }

    public void updateView() {
        view.printUserDetails(model.getName(), model.getEmail());
    }
}

// MVCPatternDemo.java
public class MVCPatternDemo {
    public static void main(String[] args) {
        // Fetch user record from the database
        User model = retrieveUserFromDatabase();

        // Create a view to write user details on console
        UserView view = new UserView();

        // Create a controller
        UserController controller = new UserController(model, view);

        // Display initial user information
        System.out.println("Initial User Information:");
        controller.updateView();

        // Update user information
        controller.setUserName("LotusJavaPrince");
        controller.setUserEmail("lotusjavaprince@example.com");

        // Display updated user information
        System.out.println("Updated User Information:");
        controller.updateView();
    }

    private static User retrieveUserFromDatabase() {
        // Simulate fetching data from a database
        return new User("Mahesh", "lotusmahesh@example.com");
    }
}

/*
C:\>javac MVCPatternDemo.java

C:\>java MVCPatternDemo
Initial User Information:
User Details:
Name: Mahesh
Email: lotusmahesh@example.com
-------------------------
Updated User Information:
User Details:
Name: LotusJavaPrince
Email: lotusjavaprince@example.com
-------------------------
*/

Pros

• Separation of Concerns: Model (data/logic), View (UI), and Controller (input handling) are isolated, improving modularity.
• Reusability: The Model can be reused across different Views or applications.
• Scalability: Multiple Views can display the same Model (e.g., console and GUI Views).
• Maintainability: Changes to one component (e.g., UI) don’t affect others.
• Testability: Components can be tested independently (e.g., Model logic without UI).

Cons

• Complexity: Adds overhead for simple applications due to multiple components.
• Tight Coupling (in some cases): The Controller may become tightly coupled to the Model and View if not designed carefully.
• Learning Curve: Understanding MVC interactions can be challenging for beginners.
• Overhead for Small Apps: The pattern may be overkill for applications with minimal UI or logic.

When to Use

• When you need to separate data management, user interface, and input handling.
• When an application requires multiple views of the same data (e.g., web and mobile UIs).
• When you want to make the system modular, testable, and maintainable.
• When building applications with complex user interactions, such as web apps, desktop GUIs, or games.

Real-World Example

• Web Frameworks: In Spring MVC (Java), the Model holds data (e.g., database entities), the View renders HTML (e.g., Thymeleaf templates), and the Controller handles HTTP requests.
• Desktop Applications: In a Java Swing app, the Model manages data, the View is the GUI (e.g., JFrame), and the Controller handles events (e.g., button clicks).
• Mobile Apps: In Android, the Model manages data (e.g., Room database), the View is the UI (XML layouts), and the Controller is handled by Activities or ViewModels.
• Game Development: The Model manages game state (e.g., player stats), the View renders graphics, and the Controller processes user input (e.g., keyboard events).

The Model-View-Controller (MVC) Pattern is an architectural pattern that divides an application into three interconnected components—Model, View, and Controller—to promote separation of concerns, modularity, and maintainability.

• The Model handles the data and business logic.
• The View manages the UI and presentation.
• The Controller acts as an intermediary, processing input and updating the Model and View accordingly.