<module>templateview</module>

title: "Template View Pattern in Java: Streamlining Dynamic Webpage Rendering"

shortTitle: Template View

description: "Learn about the Template View design pattern in Java, which simplifies webpage rendering by separating static and dynamic content. Ideal for developers building reusable and maintainable UI components."

category: Behavioral

language: en

tag:

- Abstraction

- Code simplification

- Decoupling

- Extensibility

- Gang of Four

- Inheritance

- Polymorphism

- Reusability

Separate the structure and static parts of a webpage (or view) from its dynamic content. Template View ensures a consistent layout while allowing flexibility for different types of views.

Our example involves rendering different types of views (`HomePageView` and `ContactPageView`) with a common structure consisting of a header, dynamic content, and a footer.

The `TemplateView` class defines the skeleton for rendering a view. Subclasses provide implementations for rendering dynamic content.

public abstract class TemplateView {

public final void render() {

printHeader();

renderDynamicContent();

printFooter();

}

protected void printHeader() {

LOGGER.info("Rendering header...");

}

protected abstract void renderDynamicContent();

protected void printFooter() {

LOGGER.info("Rendering footer...");

}

}

public class HomePageView extends TemplateView {

@Override

protected void renderDynamicContent() {

LOGGER.info("Welcome to the Home Page!");

}

}

public class ContactPageView extends TemplateView {

@Override

protected void renderDynamicContent() {

LOGGER.info("Contact us at: contact@example.com");

}

}

The `App` class demonstrates rendering different views using the Template View pattern.

public class App {

public static void main(String[] args) {

TemplateView homePage = new HomePageView();

LOGGER.info("Rendering HomePage:");

homePage.render();

TemplateView contactPage = new ContactPageView();

LOGGER.info("\nRendering ContactPage:");

contactPage.render();

}

}

```lessRendering HomePage:

- When you want to enforce a consistent structure for rendering views while allowing flexibility in dynamic content.

- When you need to separate the static layout (header, footer) from the dynamic parts of a view (main content).

- To enhance code reusability and reduce duplication in rendering logic.

**Benefits:**

- Code Reusability: Centralizes shared layout logic in the base class.

- Maintainability: Reduces duplication, making updates easier.

- Flexibility: Allows subclasses to customize dynamic content.

**Trade-offs:**

- Increased Number of Classes: Requires creating separate classes for each type of view.

- Design Overhead: Might be overkill for simple applications with few views.

- [Template Method](https://java-design-patterns.com/patterns/template-method/): A similar pattern focusing on defining a skeleton algorithm, allowing subclasses to implement specific steps.

- [Strategy Pattern](https://java-design-patterns.com/patterns/strategy/): Offers flexibility in choosing dynamic behaviors at runtime instead of hardcoding them in subclasses.

- [Decorator Pattern](https://java-design-patterns.com/patterns/decorator/): Can complement Template View for dynamically adding responsibilities to views.

- Web frameworks like Spring MVC and Django use this concept to render views consistently.

- CMS platforms like WordPress follow this pattern for theme templates, separating layout from content.

- [Effective Java](https://amzn.to/4cGk2Jz)

- [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)

- [Refactoring to Patterns](https://amzn.to/3VOO4F5)

- [Template Method Pattern](https://refactoring.guru/design-patterns/template-method)

- [Basics of Django: Model-View-Template (MVT) Architecture](https://angelogentileiii.medium.com/basics-of-django-model-view-template-mvt-architecture-8585aecffbf6)

package com.iluwater.templateview {

class App {

+ App()

+ main(args : String[]) {static}

}

abstract class TemplateView {

- LOGGER : Logger {static}

+ TemplateView()

+ render() : void {final}

# printHeader() : void

# renderDynamicContent() : void {abstract}

# printFooter() : void

}

class HomePageView {

- LOGGER : Logger {static}

+ HomePageView()

+ renderDynamicContent() : void

}

class ContactPageView {

- LOGGER : Logger {static}

+ ContactPageView()

+ renderDynamicContent() : void

}

}

App --> TemplateView

TemplateView <|-- HomePageView

TemplateView <|-- ContactPageView

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<parent>

<groupId>com.iluwatar</groupId>

<artifactId>java-design-patterns</artifactId>

<version>1.26.0-SNAPSHOT</version>

</parent>

<artifactId>templateview</artifactId>

<dependencies>

<dependency>

<groupId>org.junit.jupiter</groupId>

<artifactId>junit-jupiter-engine</artifactId>

<scope>test</scope>

</dependency>

<dependency>

<groupId>org.mockito</groupId>

<artifactId>mockito-inline</artifactId>

<scope>test</scope>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-assembly-plugin</artifactId>

<executions>

<execution>

<configuration>

<archive>

<manifest>

<mainClass>com.iluwatar.templateview.App</mainClass>

</manifest>

</archive>

</configuration>

</execution>

</executions>

</plugin>

</plugins>

</build>

</project>

package com.iluwatar.templateview;

import lombok.extern.slf4j.Slf4j;

public class App {

/**

public static void main(String[] args) {

// Create and render the HomePageView

TemplateView homePage = new HomePageView();

LOGGER.info("Rendering HomePage:");

homePage.render();

// Create and render the ContactPageView

TemplateView contactPage = new ContactPageView();

LOGGER.info("\nRendering ContactPage:");

contactPage.render();

}

}

package com.iluwatar.templateview;

import lombok.extern.slf4j.Slf4j;

public class ContactPageView extends TemplateView {

/**

@Override

protected void renderDynamicContent() {

LOGGER.info("Contact us at: contact@example.com");

}

}

package com.iluwatar.templateview;

import lombok.extern.slf4j.Slf4j;

public class HomePageView extends TemplateView {

/**

@Override

protected void renderDynamicContent() {

LOGGER.info("Welcome to the Home Page!");

}

}