Introduction to the Web Interface

Welcome to the first lesson of our course on building an image generation web application with Spring Boot! In this course, you'll learn how to create a user-friendly web interface for an AI-powered image generation service. By the end of this course, you'll have built a complete web application that allows users to generate images based on text prompts and view their generation history.

In this first lesson, we'll focus on creating the HTML structure for our application. This structure will serve as the foundation for our user interface, providing the elements with which users will interact to generate images and view their history.

Our application will have two main sections:

  1. A "Generate Image" tab where users can enter prompts and customize their image generation.
  2. A "View History" tab where users can see their previously generated images.

Before we dive into the code, let's understand how Spring Boot handles HTML templates. In a Spring Boot application, HTML files are typically stored in the src/main/resources/static directory. We'll also include our CSS and JavaScript files from this directory.

Now, let's start building our HTML interface!

App File Structure

Before we start building the HTML for our image generation interface, let's take a moment to understand how our Spring Boot application is organized. A clear file structure helps us stay organized as our project grows in complexity.

Here's the structure we'll be working with:

Folder Responsibilities
  • controllers/: Defines Spring MVC controllers and handles incoming HTTP requests.
  • services/: Contains the logic for formatting prompts and generating images using AI.
  • models/: Deals with image storage and the loading of prompt templates.
  • static/: Supports the front-end UI with HTML, CSS, and JavaScript.

With this structure in mind, you'll find it easier to understand where each part of the code lives as we build out the HTML and connect it to our Spring Boot backend.

Creating the Basic HTML Document Structure

Every HTML document starts with a basic structure that includes the document type declaration, the HTML root element, and the head and body sections. Let's create this structure for our image generator application.

To link static resources like CSS files, we use a standard HTML <link> tag with an absolute path (starting with /) so that Spring Boot serves them correctly.

Here's the basic HTML structure:

Let's break down what each part of this code does:

  • <!DOCTYPE html> tells the browser that this is an HTML5 document.
  • <html lang="en"> is the root element of the HTML document, with en specifying English as the language.
  • The <head> section contains metadata about the document:
Building the Tab Navigation System

Our application will have two main tabs: one for generating images and another for viewing the history of generated images. Let's create the tab navigation system that will allow users to switch between these views.

In this code, we've added:

  • A <div> with the class tabs that contains two buttons, one for each tab.
  • Each button has an onclick attribute that calls a JavaScript function named openTab with the ID of the tab to open.
  • Two <div> elements with the class tab-content and IDs generate and history. These will contain the content for each tab.
  • The history tab content has style="display:none;" to hide it initially, showing only the generate tab when the page loads.
Designing the Image Generation Form

The "Generate Image" tab will contain a form where users can enter a prompt for the image they want to generate and select an aspect ratio. Let's create this form:

Let's examine the elements in our form:

  • A container <div> to hold all the form elements.
  • An <h1> heading that displays the title of our application.
  • An <input> field where users can enter their image description (prompt).
  • A dropdown <select> menu for choosing the aspect ratio of the generated image, with options for square (1:1), widescreen (16:9), classic (4:3), and portrait (3:4) formats.
  • A button that, when clicked, will call a JavaScript function named generateImage() to process the form and generate the image.
Setting Up the History View

The "View History" tab will allow users to see their previously generated images. Let's create the content for this tab:

The history view includes:

  • A container <div> to hold all the elements.
  • An <h1> heading that displays "Image History".
  • A button with the ID history-button that, when clicked, will call a JavaScript function named fetchHistory() to load the user's previously generated images.
  • A loading message with the ID history-loading-message that is initially hidden and will be shown while images are loading.
  • An empty <div> with the ID history-container where the images will be displayed.

The fetchHistory() function will be defined in our JavaScript file. It will fetch the user's image history from our backend API and display the images in the history-container div.

Connecting Everything Together

Now that we have created all the necessary HTML elements, let's connect everything together by adding the <script> tag at the end of our body section.

To reference our JavaScript file, we use a standard <script> tag with an absolute path:

Here's the complete HTML code for our image generator application:

Summary

In this lesson, we've created the HTML structure for our image generator application using Spring Boot. We've set up a tab navigation system, designed a form for generating images, and created a view for displaying the image history. We've also linked our CSS and JavaScript files using absolute paths, which is the recommended way to reference static resources in a Spring Boot application.

Right now, our application doesn't look very appealing because we haven't added any styling yet. Additionally, the buttons do not perform any actions because we haven't implemented the JavaScript functions. In the next lesson, we'll add CSS to style our application and make it visually appealing. After that, we'll implement the JavaScript functions to handle user interactions and communicate with our backend API.

The HTML structure we've created serves as the foundation for our application. It defines the elements with which users will interact and provides the structure that our CSS and JavaScript will build upon. By understanding this structure, you'll be better prepared to implement the styling and functionality in the upcoming lessons.

In the practice exercises that follow, you'll have the opportunity to modify this HTML structure and experiment with different elements to better understand how they work together. You'll also see how the HTML structure interacts with and to create a complete web application.

Next
Sign up
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal