Managing Static Resources in Spring Boot
Introduction to CSS in Our Spring Boot Application
Welcome to the second lesson of our course on building an image generation web application with Spring Boot! In our previous lesson, we created the HTML structure for our application, setting up the tabs, form elements, and containers that will make up our user interface. While the structure is in place, our application currently lacks visual appeal and usability.
In this lesson, we'll focus on styling our application using CSS (Cascading Style Sheets). CSS is a styling language that allows us to control the appearance of HTML elements, including colors, fonts, spacing, and layout. By adding CSS to our application, we'll transform the basic HTML structure into an attractive, user-friendly interface.
Remember that in a Spring Boot application, static files like CSS are stored in a folder located at src/main/resources/static. We've already linked our CSS file in the HTML as follows:
This tells Spring Boot to look for a file named style.css in the static/css folder. Now, let's create this file and add our styles to it.
Setting Up the Page Layout
Let's start by styling the basic page layout, including the body element and the main container. This will set the foundation for our application's appearance.
In this code, we're styling the body element to use a modern sans-serif font stack, with Segoe UI as the primary font. We've set a light gray background color (#f0f0f0) and removed the default margin. We've also added padding to the top and bottom of the page.
The display: flex, flex-direction: column, justify-content: center, and align-items: center properties work together to center our content both horizontally and vertically on the page. The min-height: 100vh ensures that the body takes up at least the full height of the viewport, which helps with the centering.
For the .container class, we've set a white background, added padding for spacing, and used border-radius to round the corners. The box-shadow property adds a subtle shadow effect, giving the container a slight elevation above the background. We've set the width to 100% but limited the maximum width to 600px, which will make our application responsive while preventing it from becoming too wide on large screens.
With these styles in place, our application already looks much better. The content is centered on the page, and the white container stands out against the light gray background.
Designing the Tab Navigation System
Next, let's style the tab navigation system that allows users to switch between the Generate Image and View History tabs.
For the .tabs container, we're using flexbox (display: flex) with justify-content: center to center the tab buttons horizontally. We've added a margin-bottom to separate the tabs from the content below.
The .tab-button class styles the individual tab buttons. We've added padding to make the buttons larger and more clickable, and margins to separate them from each other. The background color is a deep blue (#0056b3), and the text color is white for good contrast. We've removed the default border, rounded the corners with border-radius, and set the cursor to pointer to indicate that the buttons are clickable.
The transition: background-color 0.3s property creates a smooth transition effect when the background color changes, which happens when a user hovers over a button. The .tab-button:hover selector targets buttons when the user hovers over them, changing the background color to a lighter blue (#007bff).
Finally, the .tab-content class styles the containers for the tab content. We've set display: block to make them visible (though in our HTML, the history tab content has an inline style of display: none to hide it initially). We've also added a margin-top to separate the content from the tabs.
With these styles, our tab navigation system now looks like a proper set of tabs, with clear visual feedback when users interact with them.
Enhancing Form Elements
Now, let's style the form elements in our Generate Image tab, including the input fields, select dropdowns, and the generate button.
For both input and select elements, we've set the width to 100% to make them span the full width of their container. We've added padding to make them larger and more user-friendly, and margins to separate them from each other. The border-radius property rounds the corners, and we've set a light gray border color (#d1d1d1). We've also increased the font-size slightly for better readability.
For the button elements, we've also set the width to 100% and added padding. The background color is a bright blue (#007bff), and the text color is white. Like with the tab buttons, we've removed the default border, rounded the corners, set the cursor to pointer, and added a transition effect for the background color. We've also increased the font-size for better readability.
The button:hover selector changes the background color to a deeper blue (#0056b3) when the user hovers over a button, providing visual feedback.
With these styles, our form elements now look more polished and user-friendly. The input fields and select dropdowns are clearly defined, and the button stands out as a call to action.
Styling the Image Display Areas
Finally, let's style the areas where images will be displayed, both in the Generate Image tab and the View History tab.
For both the #image-container and #history-container elements, we've added a margin-top to separate them from the elements above.
For the img elements that will be displayed in these containers, we've set the max-width to 100% to ensure that they don't overflow their containers. We've rounded the corners with border-radius and added a subtle shadow effect with box-shadow to give the images a slight elevation.
With these styles, our image display areas are now ready to showcase the generated images in an attractive way.
Summary and Next Steps
In this lesson, we've transformed our basic HTML structure into an attractive, user-friendly interface using CSS. We've styled the page layout, tab navigation system, form elements, and image display areas, creating a cohesive and visually appealing design.
Here's a summary of what we've accomplished:
- We've set up a centered, responsive layout with a clean white container on a light gray background.
- We've styled the tab navigation system to provide clear visual feedback when users interact with it.
- We've enhanced the form elements to make them more user-friendly and visually appealing.
- We've prepared the image display areas to showcase the generated images in an attractive way.
Our application now looks much better, but it still doesn't do anything when users interact with it. In the next lesson, we'll implement the JavaScript functionality to handle user interactions, such as switching between tabs, submitting image generation requests to the Spring Boot backend, and viewing the image history. That backend will use the Gemini API to generate images, so the JavaScript we write will be the bridge between the interface you see here and the AI model running on the server.
The CSS we've added serves as the visual layer of our application, complementing the structural layer (HTML) that we created in the previous lesson. In the upcoming lessons, we'll add the behavioral layer (JavaScript) to make our application fully functional.
In the practice exercises that follow, you'll have the opportunity to modify the CSS styles and experiment with different visual designs. You'll also get to see how the CSS interacts with the HTML and JavaScript to create a complete web application. This hands-on experience will help reinforce the concepts we've covered in this lesson and prepare you for the more advanced topics in the upcoming lessons.
