Page Controller

About 3 min

Intent

The Page Controller pattern is intended to handle requests for a specific page or action within a web application, processing input, and determining the appropriate view for rendering the response.

Explanation

Real-world example

Imagine a large department store with multiple specialized counters: Customer Service, Returns, Electronics, and Clothing. Each counter has a dedicated staff member who handles specific tasks for that department.
In this analogy, the department store is the web application, and each specialized counter represents a Page Controller. The Customer Service counter (Page Controller) handles customer inquiries, the Returns counter processes returns and exchanges, the Electronics counter assists with electronic goods, and the Clothing counter manages clothing-related requests. Each counter operates independently, addressing the specific needs of their respective department, just as each Page Controller handles requests for a specific page or action within the web application.

In plain words

The Page Controller pattern handles requests for specific pages or actions within a web application, processing input, executing business logic, and determining the appropriate view for rendering the response.

Programmatic Example

The Page Controller design pattern is a pattern used in web development where each page of a website is associated with a class or function known as a controller. The controller handles the HTTP requests for that page and determines which model and view to use. This pattern is commonly used in MVC (Model-View-Controller) architectures.

In the provided code, we have an example of the Page Controller pattern implemented using Spring Boot in Java. Let's break it down:

SignupController: This is a Page Controller for the signup page. It handles HTTP GET and POST requests at the "/signup" path. The GET request returns the signup page, and the POST request processes the signup form and redirects to the user page.

@Controller
@Component
public class SignupController {
  SignupView view = new SignupView();

  @GetMapping("/signup")
  public String getSignup() {
    return view.display();
  }

  @PostMapping("/signup")
  public String create(SignupModel form, RedirectAttributes redirectAttributes) {
    redirectAttributes.addAttribute("name", form.getName());
    redirectAttributes.addAttribute("email", form.getEmail());
    redirectAttributes.addFlashAttribute("userInfo", form);
    return view.redirect(form);
  }
}

UserController: This is another Page Controller, this time for the user page. It handles HTTP GET requests at the "/user" path, returning the user page.

@Slf4j
@Controller
public class UserController {
  UserView view = new UserView();

  @GetMapping("/user")
  public String getUserPath(SignupModel form, Model model) {
    model.addAttribute("name", form.getName());
    model.addAttribute("email", form.getEmail());
    return view.display(form);
  }
}

SignupModel and UserModel: These are the data models used by the controllers. They hold the data to be displayed on the page.

@Component
@Getter
@Setter
public class SignupModel {
  private String name;
  private String email;
  private String password;
}

@Getter
@Setter
public class UserModel {
  private String name;
  private String email;
}

SignupView and UserView: These are the views used by the controllers. They determine how the data is presented to the user.

@Slf4j
public class SignupView {
  public String display() {
    return "/signup";
  }

  public String redirect(SignupModel form) {
    return "redirect:/user";
  }
}

@Slf4j
public class UserView {
  public String display(SignupModel user) {
    return "/user";
  }
}

In this example, the controllers (SignupController and UserController) are the Page Controllers. They handle the HTTP requests for their respective pages and determine which model and view to use. The models (SignupModel and UserModel) hold the data for the page, and the views (SignupView and UserView) determine how that data is presented. This separation of concerns makes the code easier to manage and maintain.

Class diagram

Applicability

When developing a web application where each page or action needs specific processing.
When aiming to separate the request handling logic from the view rendering logic.
In scenarios where a clear separation of concerns between different layers (controller, view) is required.

Known Uses

Spring MVC (Java)
Apache Struts
JSF (JavaServer Faces)

Consequences

Benefits:

Separation of Concernsopen in new window: Clearly separates the controller logic from the view, making the application easier to manage and maintain.
Reusability: Common logic can be reused across multiple controllers, reducing code duplication.
Testability: Controllers can be tested independently of the view, improving unit test coverage.

Trade-offs:

Complexity: Can add complexity to the application structure, requiring careful organization and documentation.
Overhead: May introduce performance overhead due to additional layers of abstraction and processing.

Front Controlleropen in new window: Often used in conjunction with Page Controller to handle common pre-processing logic such as authentication and logging.
View Helper: Works alongside Page Controller to assist in preparing the view, often handling formatting and other presentation logic.
Model-View-Controller (MVC)open in new window: Page Controller is a fundamental part of the MVC architecture, acting as the Controller.