Welcome to the first lesson of our Building an Image Generation Service With Java course! In this course, you will learn how to build a complete web application that transforms text descriptions into stunning images using Google's Gemini API.

Before we dive into web frameworks or API integration, we need to establish a solid foundation for our image generation system. At the heart of any AI image generation service is the prompt — the text instructions that guide the AI to create the image you want.

Prompt engineering is the art and science of crafting effective instructions for AI models. When working with image generation models like gemini-3.1-flash-image, the quality and structure of your prompts directly impact the quality of the images you receive. A well-crafted prompt provides clear direction, specific details, and appropriate context to help the AI understand exactly what you are looking for.

In our application, we will be creating event banners for a fictional company named Eventify Co. Rather than crafting a new prompt each time a user requests an image, we will create a template system that:

1. Maintains consistent structure and quality across all prompts
2. Allows users to customize only the specific event details
3. Handles the formatting and presentation of the prompt automatically

This approach ensures our application produces high-quality, consistent results while still allowing for customization. Let's begin by understanding what makes an effective prompt template.

A well-structured prompt template for image generation typically contains several key components that work together to guide the AI. Let's examine the structure of our template:

# ROLE
Lead graphic designer

# THEME 
{user_input}

# TASK
Your task is to create a visually stunning, high-quality event banner that prominently features the event name and tagline. Avoid adding any other text. Ensure the text is well-integrated with the design, enhancing readability 
and aesthetic appeal. 

# ASPECT RATIO
Create the image using a {aspectRatio} aspect ratio.

# DESIGN REQUIREMENTS
- Color Palette: Muted gold, deep navy blue, charcoal black, ivory white.
- Style: Sophisticated pastel shades and metallic accents conveying exclusivity and elegance.
- Typography: 
  - Headings: Serif fonts for event names.
  - Descriptions: Sleek sans-serif fonts for taglines and additional information.
- Composition: Visual clarity and balance with generous spacing and harmonious layout.

# OUTPUT REQUIREMENTS
The banner must be suitable for:
- Social media
- Websites
- Print

Ensure high resolution and impeccable visual quality. Maintain brand consistency and deliver a polished, impactful design ready for promotional use.

Let's break down each section:

ROLE: This establishes the persona that the AI should adopt. By positioning the AI as a lead graphic designer, we are setting expectations for high-quality, professional output.

THEME: This is where we will insert the user's input — the specific event details they want to feature in the banner. Notice the {user_input} placeholder, which we will programmatically replace with actual content.

TASK: This section clearly defines what we want the AI to create — an event banner with specific characteristics. It provides direction on how text should be integrated into the design.

ASPECT RATIO: This section specifies the dimensions of the generated image. We use the {aspectRatio} placeholder to allow dynamic control over the image shape (e.g., 16:9 or 1:1).

DESIGN REQUIREMENTS: Here, we provide specific design guidelines, including color palette, style, typography, and composition. These details help ensure consistency across all generated images and align with the brand identity of our fictional company.

OUTPUT REQUIREMENTS: This final section specifies the practical requirements for the image, ensuring it will be suitable for various use cases.

By structuring our prompt this way, we provide comprehensive guidance to the AI while still allowing for customization through the user input and aspect ratio. This balance is key to creating a flexible yet consistent image generation system.

Now that we understand the structure of our prompt template, let's create the actual file that will store it. In our Java application, it is common to organize resources such as templates in the src/main/resources directory.

First, let's set up our project directory structure:

src/
└── main/
    ├── java/
    │   └── com/
    │       └── codesignal/
    │           ├── Main.java
    │           └── models/
    │               └── PromptManager.java
    └── resources/
        └── image_prompt_template.txt

• The resources directory will store our template and potentially other data files.
• The java directory will contain our Java classes, organized by package.
• PromptManager.java will be our class for managing prompt templates.

Now, let's create the image_prompt_template.txt file in the src/main/resources directory with the content we discussed in the previous section. You can use any text editor to create this file and save it using the exact structure we reviewed earlier.

Make sure the file is saved with UTF-8 encoding to handle any special characters properly. The placeholders {user_input} and {aspectRatio} are crucial — these are what allow our code to dynamically insert the user's specific event details and aspect ratio into the template.

When creating this file, be careful to maintain the formatting exactly as shown. The spacing, line breaks, and section headers all contribute to how the AI model will interpret the prompt.

If you are working in a team environment, consider adding comments to the top of the file explaining its purpose and how it should be modified. This helps maintain consistency if multiple people need to update the template in the future.

With our template file in place, we now need a way to load it and format it with user input. For this, we will create a PromptManager class that handles these operations. This class will be responsible for:

1. Loading the template from the file
2. Inserting user input into the template
3. Inserting aspect ratio into the template
4. Handling any errors that might occur during these operations

Let's create the PromptManager.java file in the com.codesignal.models package:

package com.codesignal.models;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class PromptManager {
    /**
     * Loads the base prompt from a file in the resources directory.
     * If the file cannot be loaded, returns a simplified fallback template.
     */
    public static String loadBasePrompt(String filePath) {        
        try {
            return Files.readString(Paths.get(filePath));
        } catch (IOException e) {
            System.out.println("Error loading prompt template: " + e.getMessage());
            return "# ROLE\nLead graphic designer\n\n" +
                   "# THEME\n{user_input}\n\n" +
                   "# TASK\nPlease generate a beautiful banner.\n\n" +
                   "# ASPECT RATIO\nCreate the image using a {aspectRatio} aspect ratio.\n";
        }
    }

    /**
     * Loads the default prompt template from the resources directory.
     */
    public static String loadBasePrompt() {
        return loadBasePrompt("src/main/resources/image_prompt_template.txt");
    }

    /**
     * Formats the prompt by inserting the user input and aspect ratio into the template.
     */
    public static String formatPrompt(String userInput, String aspectRatio) {
        String basePrompt = loadBasePrompt();
        return basePrompt.replace("{user_input}", userInput)
                         .replace("{aspectRatio}", aspectRatio);
    }

    public static String formatPrompt(String userInput) {
        return formatPrompt(userInput, "16:9");
    }
}

Let's examine this code in detail:

public static String loadBasePrompt(String filePath) {        
    try {
        return Files.readString(Paths.get(filePath));
    } catch (IOException e) {
        System.out.println("Error loading prompt template: " + e.getMessage());
        return "# ROLE\nLead graphic designer\n\n" +
               "# THEME\n{user_input}\n\n" +
               "# TASK\nPlease generate a beautiful banner.\n\n" +
               "# ASPECT RATIO\nCreate the image using a {aspectRatio} aspect ratio.\n";
    }
}

The loadBasePrompt method:

• Takes a filePath parameter pointing to our template file in the resources directory.
• Attempts to open and read the file using Java's Files.readString().
• Returns the contents as a String if successful.
• If an error occurs (e.g., the file does not exist), it prints the error and returns a simplified fallback template.

Notice the error handling in loadBasePrompt. This is important because it ensures our application will not crash if the template file is missing or corrupted. Instead, it will fall back to a simplified template that can still produce reasonable results.

We also define a no-argument overload that loads the default template path:

public static String loadBasePrompt() {
    return loadBasePrompt("src/main/resources/image_prompt_template.txt");
}

public static String formatPrompt(String userInput, String aspectRatio) {
    String basePrompt = loadBasePrompt();
    return basePrompt.replace("{user_input}", userInput)
                     .replace("{aspectRatio}", aspectRatio);
}

public static String formatPrompt(String userInput) {
    return formatPrompt(userInput, "16:9");
}

The formatPrompt method:

• Takes a userInput parameter containing the event details.
• Takes an aspectRatio parameter containing the desired image shape.
• Calls loadBasePrompt() to get the template.
• Uses Java's String.replace method to replace the {user_input} and {aspectRatio} placeholders with the actual values.
• Returns the fully formatted prompt.

This approach ensures the user's input is correctly inserted into the template while the rest of the template remains unchanged, providing consistent guidance to the AI model.

Now that we have our template file and PromptManager class, let's create a simple Java program to test that everything works correctly. We'll create a Main.java file in the com.codesignal package:

package com.codesignal;

import com.codesignal.models.PromptManager;

public class Main {
    public static void main(String[] args) {
        String userInput = "Luxury Tech Conference 2025: Innovating the Future - April 10th, New York City";
        String aspectRatio = "16:9";
        String formattedPrompt = PromptManager.formatPrompt(userInput, aspectRatio);

        System.out.println("Generated Prompt:");
        System.out.println(formattedPrompt);
    }
}

This program:

1. Imports our PromptManager class.
2. Defines a sample user input for a fictional tech conference.
3. Defines a sample aspect ratio.
4. Calls the formatPrompt method to insert both values into our template.
5. Prints the resulting formatted prompt.

When you run this program, you should see output similar to the following:

Generated Prompt:
# ROLE
Lead graphic designer

# THEME 
Luxury Tech Conference 2025: Innovating the Future - April 10th, New York City

# TASK
Your task is to create a visually stunning, high-quality event banner that prominently features the event name and tagline. Avoid adding any other text. Ensure the text is well-integrated with the design, enhancing readability 
and aesthetic appeal. 

# ASPECT RATIO
Create the image using a 16:9 aspect ratio.

# DESIGN REQUIREMENTS
- Color Palette: Muted gold, deep navy blue, charcoal black, ivory white.
- Style: Sophisticated pastel shades and metallic accents conveying exclusivity and elegance.
- Typography: 
  - Headings: Serif fonts for event names.
  - Descriptions: Sleek sans-serif fonts for taglines and additional information.
- Composition: Visual clarity and balance with generous spacing and harmonious layout.

# OUTPUT REQUIREMENTS
The banner must be suitable for:
- Social media
- Websites
- Print

Ensure high resolution and impeccable visual quality. Maintain brand consistency and deliver a polished, impactful design ready for promotional use.

As you can see, our user input has been successfully inserted into the THEME section of the template, and the {aspectRatio} placeholder has been replaced with the specified value. The rest of the template remains unchanged, providing consistent guidance to the AI model.

If you would like to see the error handling in action, try temporarily renaming or moving the template file before running the program. You should observe an error message and see the fallback template being used instead.

This kind of experiment will help reinforce your understanding and confirm that the prompt management system handles missing files gracefully — ensuring we can still load a default template, insert user input, and generate a well-structured prompt for the AI image generation model.

In this lesson, we built the foundation for our image generation service by designing a reusable and resilient prompt template system. You now have the tools to load a template, insert dynamic content, and gracefully handle errors.

In the practice session, you will get hands-on experience modifying templates, trying different inputs, and reinforcing the techniques covered here.

Next, we will continue building our service by creating an ImageManager class to manage the storage and retrieval of generated images.

Great job completing the first lesson! You have taken an important step toward building a complete image generation service with Java.