S01L03 - HelloWorld Java program with Maven

html

Creating a Maven Project in IntelliJ IDEA: A Comprehensive Guide
Table of Contents

Introduction
Setting Up Your Maven Project

Launching IntelliJ IDEA and Starting a New Project
Configuring Project Details


Understanding pom.xml

Setting Compiler Source and Target
Defining Packaging Type


Creating and Managing Packages

Adding Sample Code


Building and Running Your Application

Running the Application in IntelliJ IDEA
Generating the JAR File Using Maven


Common Issues and Troubleshooting
Conclusion


Introduction
Welcome to this comprehensive guide on creating a Maven project in IntelliJ IDEA. If you're a beginner or a developer with basic knowledge looking to streamline your Java project management, Maven is an essential tool in your toolkit. This guide will walk you through the process of setting up a Maven project, configuring essential settings, writing sample code, and building your application into a JAR file.
Why Use Maven?
Maven simplifies project build automation, dependency management, and project structure standards. It enhances productivity by providing a uniform build system and reduces the complexities involved in managing large projects.
Pros and Cons of Using Maven


Pros
Cons


Simplifies dependency management
Steeper learning curve for beginners


Standardizes project structure
Can be verbose with configuration


Facilitates integration with IDEs
Debugging Maven issues can be challenging


Enhances build automation
May introduce overhead for small projects


When to Use Maven
Maven is ideal for medium to large-scale Java projects that require standardized build processes and efficient dependency management. It's particularly beneficial when collaborating in teams, ensuring consistency across development environments.

Setting Up Your Maven Project
Launching IntelliJ IDEA and Starting a New Project

Open IntelliJ IDEA: Launch the IntelliJ IDEA application on your computer.
Create a New Project: Click on the "New Project" option from the welcome screen or navigate to File > New > Project.

    

    

    Figure 1: Starting a New Project in IntelliJ IDEA.
  

Configuring Project Details

Select Maven: In the "New Project" window, choose Maven as your project type.

    

    

    Figure 2: Selecting Maven as the Project Type.
  
Project Name and Location:

Name: Enter Hello World.
Location: Use the default Idea Project location or specify a preferred directory.


JDK Version: Select JDK 17, the Long-Term Support (LTS) version, ensuring compatibility and stability.
Maven Archetype: Skip selecting a Maven archetype for simplicity.
Group ID and Artifact ID:

Group ID: Enter org.studyeasy.
Artifact ID: Enter hello-world (ensure no whitespace).


Finalize Creation: Click Create to generate the Maven project structure.


Understanding pom.xml
The pom.xml file is the heart of your Maven project, managing project configuration, dependencies, and build settings.
Setting Compiler Source and Target


		
		
			
			
Java
			
			<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>
    <groupId>org.studyeasy</groupId>
    <artifactId>hello-world</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
</project>
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						<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>
    <groupId>org.studyeasy</groupId>
    <artifactId>hello-world</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
</project>
					
				
			
		


Figure 3: Sample pom.xml Configuration.
Explanation:

maven.compiler.source and maven.compiler.target: Both set to 17, aligning with the selected JDK version.
packaging: Defined as jar to specify the output artifact type.

Defining Packaging Type
Setting the packaging type to jar ensures that the build process generates a JAR file, a common format for Java applications.

Creating and Managing Packages
Adding Sample Code
Upon project creation, IntelliJ IDEA generates the necessary directories and a sample Java file.

Default Package: Navigate to the src/main/java directory to find the main.java file.
Creating a New Package (if necessary):

Right-click on src/main/java.
Select New > Package.
Name it org.studyeasy.


Sample Code: Here's a simple Java program to display a welcome message.



		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello and welcome.");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello and welcome.");
    }
}
					
				
			
		


Figure 4: Sample Java Code with Comments.
Explanation:

Package Declaration: org.studyeasy ensures organized code structure.
Main Class: Contains the main method, the entry point of the application.
Print Statement: Outputs "Hello and welcome." to the console.


Building and Running Your Application
Running the Application in IntelliJ IDEA

Run the Program:

Click the Run button in the toolbar.
Alternatively, right-click on the Main class and select Run 'Main.main()'.


    

    Figure 5: Running the Application.
  
Output:


		
		
			
			
Java
			
			Hello and welcome.
			
				
					
				
					1
				
						Hello and welcome.
					
				
			
		


This confirms that the application is running successfully.


Generating the JAR File Using Maven

Edit Configuration:

Navigate to Run > Edit Configurations.
Click the + icon to add a new configuration.
Select Maven.


Define Maven Goals:

Command Line: Enter clean package.

clean: Removes the target directory to ensure a fresh build.
package: Compiles the code and packages it into a JAR file as defined in pom.xml.



      

      Figure 6: Configuring Maven Goals.
    

Run Maven Build: Click Apply and then Run. Maven will execute the defined goals, generating the JAR file in the target directory.
Handling Warnings:

You might encounter warnings related to the manifest file. These are common and can be addressed in subsequent tutorials.




Common Issues and Troubleshooting
Manifest File Error
After generating the JAR file, attempting to run it may result in a manifest file error. This occurs because the JAR lacks the necessary metadata to execute the main method.
Solution:

Define the mainClass in the pom.xml to specify the entry point.



		
		
			
			
Java
			
			<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>org.studyeasy.Main</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>org.studyeasy.Main</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>
					
				
			
		


Explanation:

maven-jar-plugin: Specifies the JAR plugin configuration.
mainClass: Points to the Main class containing the main method.


Rebuild the Project: Run clean package again to generate the updated JAR with the correct manifest.

Alternative Approach:

Use Maven's Shade Plugin or other assembly plugins for more complex packaging needs.


Conclusion
Creating a Maven project in IntelliJ IDEA is a streamlined process that enhances your Java development workflow. By following this guide, you've learned how to set up a Maven project, configure essential settings, write sample code, and build your application into a runnable JAR file. Maven's standardized structure and dependency management capabilities make it an invaluable tool for both beginners and seasoned developers.
Key Takeaways

Maven Integration: Seamlessly integrates with IntelliJ IDEA, simplifying project setup.
pom.xml Configuration: Centralizes project settings, dependencies, and build instructions.
Efficient Build Process: Commands like clean package automate builds and packaging.
Troubleshooting: Understanding common issues like manifest file errors is crucial for smooth development.

Embrace Maven to elevate your Java projects, ensuring consistency, scalability, and efficiency in your development endeavors.
Pros	Cons
Simplifies dependency management	Steeper learning curve for beginners
Standardizes project structure	Can be verbose with configuration
Facilitates integration with IDEs	Debugging Maven issues can be challenging
Enhances build automation	May introduce overhead for small projects