A Comprehensive Guide to Setting Up Apache Maven

By I Wayan Saryada in Maven, Tools 0 Comment

In this guide, you’ll learn everything you need to know about Apache Maven—from what it is to how to configure it across different operating systems.

What is Apache Maven?

In simple terms, Maven is a powerful build and project management tool primarily used by Java developers. Compared to older build systems like Apache Ant, Maven provides a standardized way to manage builds, dependencies, and project lifecycles.

Key Features of Maven:

  • Simplifies the build process.
  • Ensures consistency with a uniform build system.
  • Manages project dependencies through a central or local repository.
  • Provides quality project information.
  • Follows development best practices.
  • Allows for smooth migration to new features.

Now, let’s dive into how to install and configure Maven on your system.

Step 1: Downloading Apache Maven

  1. Visit the official Apache Maven Download page.
  2. Download the binary archive matching your operating system:
    • .zip for Windows
    • .tar.gz for Linux/macOS
  3. Extract the archived files to a directory of your choice:
    • On Windows, you might extract to: C:\Apache\apache-maven-<version>
    • On Linux/macOS, extract it to: /opt/apache-maven-<version>

Step 2: Configuring Environment Variables

After downloading Maven, the next step is to configure your environment so that Maven can be accessed from your terminal or command prompt.

On Windows:

  1. Open System Properties:
    • Right-click on “This PC” → select Properties → click Advanced System Settings → select Environment Variables.
  2. Add the following system variables:
    • M2_HOME: Set this to the Maven installation directory (e.g., C:\Apache\apache-maven-<version>).
    • JAVA_HOME: Set this to your JDK installation directory (e.g., C:\Program Files\Java\jdk-<version>).
  3. Add M2_HOME\bin to your PATH variable:
    • Locate and edit the PATH variable in the Environment Variables list.
    • Append: ;%M2_HOME%\bin

On Linux/macOS:

  1. Open your shell profile configuration file. This depends on the shell you’re using:
    • For bash: ~/.bashrc or ~/.bash_profile
    • For zsh (default on macOS): ~/.zshrc
  2. Add the following lines to configure Maven and Java: 
    export M2_HOME=/opt/apache-maven-<version>
export PATH=$M2_HOME/bin:$PATH
export JAVA_HOME=/path/to/your/jdk

    Example:

    export M2_HOME=/opt/apache-maven-3.9.5
export PATH=$M2_HOME/bin:$PATH
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
  3. Reload the configuration: 
    source ~/.bashrc    # For bash users
source ~/.zshrc     # For zsh users

Step 3: Verifying the Installation

Now that Maven is installed and configured, it’s time to check if it works correctly.

  1. Open a terminal or command prompt.
  2. Run the following command: 
    mvn -version
  3. You should see output similar to this: 
    Apache Maven 3.x.x (...)
Maven home: <Maven installation path>
Java version: <your JDK version>, vendor: Oracle Corporation
Java home: <JDK path>

Additional Installation Options

Using a Package Manager (Optional):

If you’re on Linux or macOS, you may install Maven using a package manager. Note that these methods may not always install the latest version.

  1. Linux (Ubuntu/Debian): 
    sudo apt update
sudo apt install maven
  2. Linux (CentOS/RHEL): 
    sudo yum install maven
  3. macOS:
    Install Maven via Homebrew:

    brew install maven

Verifying Java:

Maven requires a JDK (Java Development Kit) to work. Verify that Java is installed by running:

java -version

If it’s not installed:

  • On Linux, install OpenJDK: 
    sudo apt install openjdk-17-jdk   # For Ubuntu/Debian
sudo yum install java-17-openjdk  # For CentOS/RHEL
  • On macOS, install OpenJDK via Homebrew: 
    brew install openjdk

Step 4: Running Maven

You’re now ready to use Maven! Here are a few common commands:

  1. Check Maven Version: 
    mvn -version
  2. Create a New Maven Project: 
    mvn archetype:generate
  3. Build a Maven Project: 
    mvn clean install

Final Thoughts

Congratulations! You’ve successfully installed and configured Apache Maven. With Maven set up on your system, you can now manage your Java projects with ease. Maven simplifies build processes, ensures consistent project management, and makes dependency management seamless. Feel free to explore its many features and extend your knowledge by diving into Maven’s powerful tools, plugins, and architecture.

Have fun coding! 🚀

How to Install and Set Up Java 17 on Your System

By I Wayan Saryada in Basic, Java 17 0 Comment

To install and set up Java 17 on your system, follow the steps below. The process may vary slightly depending on your operating system.

On Windows

  1. Download Java 17
  2. Install Java 17
    • Run the .msi installer file and follow the setup instructions.
    • Install Java in the default directory or specify a custom directory (e.g., C:\Program Files\Java\jdk-17).
  3. Set Environment Variables
    • Open the Start menu, search for “Environment Variables,” and click on “Edit the system environment variables.”
    • In the System Properties window, click on the “Environment Variables” button.
    • Under “System Variables,” find the Path variable and click Edit.
    • Add the path to the bin directory of your Java installation (e.g., C:\Program Files\Java\jdk-17\bin).
    • Click OK on all windows to save your changes.
    • Optionally, set a JAVA_HOME variable:
      • Click New under “System Variables.”
      • Name the variable JAVA_HOME and set its value to the path of your Java installation (e.g., C:\Program Files\Java\jdk-17).
  4. Verify Installation
    • Open a Command Prompt and run: 
    java -version
    • If installed properly, it will display the Java 17 version.

On macOS

  1. Download Java 17
    • Visit the Oracle JDK or OpenJDK website, and download the .dmg installer for macOS.
  2. Install Java 17
    • Open the .dmg file and follow the installation instructions.
    • Java will be installed, usually in /Library/Java/JavaVirtualMachines/.
  3. Set Environment Variables (Optional)
    • Open a terminal and edit the ~/.zshrc (for zsh users) or ~/.bash_profile (for bash users) file using a text editor.
    • Add the following lines to set the JAVA_HOME variable:
    export JAVA_HOME=$(/usr/libexec/java_home -v 17)
export PATH=$JAVA_HOME/bin:$PATH
    • Save and close the file, then reload the shell configuration:
    source ~/.zshrc
    • Note: The /usr/libexec/java_home command automatically detects installed Java versions.
  4. Verify Installation
    • Run the following in Terminal:
    java -version
    • It should show the Java 17 version.

On Linux

  1. Install OpenJDK 17
    • Use your package manager to install OpenJDK 17:
      • For Debian/Ubuntu-based systems:
      sudo apt update
sudo apt install openjdk-17-jdk
      • For Red Hat/CentOS/Fedora-based systems:
      sudo dnf install java-17-openjdk-devel
  2. Set Default Java Version
    • If multiple Java versions are installed, you can set Java 17 as the default:
    sudo update-alternatives --config java
    • Select the path for Java 17 from the list.
  3. Set Environment Variables
    • Edit the ~/.bashrc or ~/.zshrc file and add:
    export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
export PATH=$JAVA_HOME/bin:$PATH
    • Save the file and reload it:
    source ~/.bashrc
  4. Verify Installation
    • Run the following command:
    java -version
    • It should display details about Java 17.

Optional: Verify Java Compiler

To ensure the javac compiler is working:

javac -version

That’s it! Now Java 17 is installed and ready to use.

How to Set Up Java 10 and Compile Your First Program

By I Wayan Saryada in Basic, Java 10 0 Comment

To set up Java 10 and compile your first program, follow these steps. Additionally, you’ll learn about Java 10’s var keyword feature once your setup is complete.

Steps to Set Up Java 10

  1. Download Java 10 JDK:
  2. Install Java 10:
    • Follow the installation wizard to install the JDK.
    • Don’t forget to note the installation path (e.g., C:\Program Files\Java\jdk-10).
  3. Set up the Environment Variables:
    • Add the JDK bin directory to the PATH variable:
      1. Go to System Properties → Advanced → Environment Variables.
      2. Under System Variables, find the Path variable and add the JDK’s bin directory (e.g., C:\Program Files\Java\jdk-10\bin).
    • Verify the setup:
      • Open the command prompt or terminal and type:
        text
        java -version
        You should see the version as Java 10.
  4. Install an IDE or Use a Text Editor:
    • Download and install an IDE like IntelliJ IDEA, Eclipse, or Visual Studio Code (or use a simple text editor).

Compile and Run Your First Java Program

  1. Write the Java Program:
    Create a file named HelloWorld.java with the following content:

    public class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello, World! Welcome to Java 10!");
   }
}
  2. Compile Your Program:
    From the command prompt, navigate to the directory containing HelloWorld.java, and run:

    javac HelloWorld.java

    This will create a compiled HelloWorld.class file.

  3. Run Your Program:
    Execute the compiled program using:

    java HelloWorld

    You should see the output:

    Hello, World! Welcome to Java 10!

Using the var Keyword in Java 10

To explore Java 10’s var keyword for local variable type inference, you can enhance your program. Update the HelloWorld class as follows:

package org.kodejava.basic;

import java.util.List;

public class HelloWorld {
   public static void main(String[] args) {
      var message = "Hello, Java 10!";
      var numbers = List.of(1, 2, 3);

      System.out.println(message);
      for (var number : numbers) {
         System.out.println("Number: " + number); // Using 'var' in loop
      }
   }
}
  • Save the changes as HelloWorld.java.
  • Recompile and run using the steps above.

You’ll see the output:

Hello, Java 10!
Number: 1
Number: 2
Number: 3

The var keyword simplifies variable declarations without compromising type safety, ensuring better code readability and brevity.

Conclusion

You’ve successfully set up Java 10, compiled, and executed your first program. Additionally, you explored how to use Java 10’s var keyword for type inference. Keep experimenting with these features to leverage Java 10’s capabilities!

Introduction to Apache Maven

By I Wayan Saryada in Maven, Tools 0 Comment

In this post you will learn about Apache Maven. What is Maven? In simple words, Maven is a tool that we can use to build and manage a Java based project. Compare to the older type of build tool such as Ant, which is also an Apache project, Maven gives developers a standard way to build projects, a clear definition of the projects consisted of, an easy way to publish project information and an easy management of the project libraries dependency.

In Maven, the project libraries (Jars) will be maintained in the Maven repository and can be shared among projects. We don’t need to include the Jars in the project’s source code, as what we usually do when using tool like Ant. And here are the main objectives of the Apache Maven project:

  • Making the build process easy.
  • Providing a uniform build system.
  • Providing quality project information.
  • Providing guidelines for best practices development.
  • Allowing transparent migration to a new features.

After you know a little about Maven, let’s continue to the next step, installing the Apache Maven.

Step 1. Downloading Apache Maven

  • Go to Apache Maven and from the Get Maven section on the left sidebar click Download link.
  • Download the appropriate installer for your platform. For example, I am downloading the .zip file. The latest version when this post is written is Maven 3.1.0 (apache-maven-3.1.0-bin.zip).
  • Extract the downloaded zip file. For example, I am extracting it into D:\Toolbox\apache-maven-3.1.0 directory.

Step 2. Configuring Environment Variables

  • After extracting Maven distribution you have to define M2_HOME environment variable. The value of this variable is the path to your Maven installation.
  • You can create environment variable using the following steps:
    • Right click on My Computer.
    • Select Properties menu.
    • Select Advanced system settings.
    • In the System Properties window select the Advanced tab and click the Environment Variables button.
    • Add the variable in the System variables section.
    • Click OK to proceed.
  • Add the %M2_HOME%\bin; into your PATH environment variable so that you can execute Maven command from any path inside your command prompt. This PATH variable can also be updated in the System variables section.

  • Open your command prompt and type echo %M2_HOME%. Pressing Enter and you should see the value of the variable printed on the console. For example:
D:\>echo %M2_HOME%
D:\Toolbox\apache-maven-3.1.0
  • To check if Maven also in your Path variable you can execute echo %PATH% in your command prompt. You should see the path to Maven binary in the Path variable.
D:\>echo %PATH%
D:\Toolbox\apache-maven-3.1.0\bin;C:\Program Files (x86)\Java\jdk1.7.0_13\bin;

Step 3. Running Maven

  • Now you have Maven installed and configured. Let’s run Maven for the first time.
  • To run Maven we use the mvn command.
  • For example to check the version of the Maven we run mvn -version
  • You will see the following output, more or less, it depends on the JDK version you have in your machine.
D:\>mvn -version
Apache Maven 3.1.0 (893ca28a1da9d5f51ac03827af98bb730128f9f2; 2013-06-28 10:15:32+0800)
Maven home: D:\Toolbox\apache-maven-3.1.0
Java version: 1.7.0_13, vendor: Oracle Corporation
Java home: C:Program Files (x86)\Java\jdk1.7.0_13\jre
Default locale: en_US, platform encoding: Cp1252
OS name: "windows 7", version: "6.1", arch: "x86", family: "windows"

Congratulations! You’ve installed Apache Maven successfully on your development machine. On the next post I will show you how to create a new project using Maven.

How do I get file separator symbol?

By I Wayan Saryada in Core API, Lang Package 0 Comment

Creating a program to be run on more than one platform such as Windows and Linux our program need to understand the difference between both platform. The simplest thing for instance is the file separator. Windows use "\" (backslash) while Linux use "/" (forward slash).

To avoid manual checking for the operating system we can get the file separator symbol from the system property using the file.separator key.

package org.kodejava.lang;

public class FileSeparatorExample {
    public static void main(String[] args) {
        // file.separator system property return the correct file 
        // separator for each different platform (Windows = \), 
        // (Linux = /)
        String dataFolder = System.getProperty("user.dir") +
                System.getProperty("file.separator") + "data";

        System.out.println("Data Folder = " + dataFolder);
    }
}