Maven をシンプルに: Java プロジェクトを簡単に構築

Maven を使用してビルドを自動化するためのわかりやすいガイド

Maven は Java 開発者にとって不可欠なツールであり、プロジェクトのビルド、依存関係の管理、バージョン管理を簡素化します。 Java を初めて使用する場合でも、経験豊富な開発者であっても、Maven を理解することでワークフローを大幅に強化できます。この記事では、Maven の仕組み、その中心的な機能、そしてなぜ Maven が複雑な Java プロジェクトを管理するための頼りになるソリューションであるのかを探っていきます。反復的なタスクの自動化からプロジェクトの整理整頓まで、Maven は開発をよりスムーズかつ効率的にします。最後には、より速く、より信頼性の高いビルドを実現するために Maven をプロジェクトに統合する方法を明確に理解できるようになります。

Maven は依存関係を管理するだけではありません。それは開発プロセス全体を合理化することでもあります。シンプルかつ強力な構造に従っており、「pom.xml」ファイルを使用してプロジェクトの依存関係、ビルド構成、プラグインを定義します。このアプローチにより、さまざまな環境間でプロジェクトの一貫性が確保され、チームとの共同作業が容易になります。さらに、Maven のライフサイクル フェーズによりコンパイル、テスト、パッケージ化などのタスクが自動化されるため、コードの作成により集中できます。 Maven をマスターすると、ビルド効率が向上するだけでなく、Java アプリケーションの全体的な品質とスケーラビリティも向上します。 Maven の利点をさらに詳しく見てみましょう!

ビルドツール

ビルド ツールは、アプリケーションのビルド プロセスを自動化するために不可欠です。コードのコンパイル、依存関係のダウンロード、テストの実行、アプリケーションのパッケージ化を手動で行う代わりに、ビルド ツールがこれらのタスクを自動的に処理します。開発を合理化し、一貫性を確保します。

ビルドツールが通常行うことは次のとおりです:

• ソース コードをコンパイルします。
• 必要な依存関係をダウンロードします (Spring Boot、Hibernate、JUnit など)
• 単体テストを実行して、コードが期待どおりに動作することを確認します。
• アプリケーションを JAR (スタンドアロン アプリの場合) または WAR (Web アプリの場合) ファイルにパッケージ化します。

Java 用の人気のあるビルド ツールには次のものがあります

• アリ
• メイブン
• グラドル

「私は Java 開発者として、効率的なプロジェクト管理、ビルドの自動化、依存関係の処理のために Maven を活用し、開発と配信のプロセスを効率化しています。」

メイビン

Maven は、アプリケーション開発のビルド プロセスを自動化する、無料のオープンソース ビルド ツールです。これは Apache Organization によって提供されます。 Java プログラミング言語を使用して開発されるソフトウェアです。 Maven の助けを借りて、プロジェクト フォルダー構造を作成できます。プロジェクトを開発するときに、プロジェクトに必要なライブラリとフレームワークが非常に多く、手動で追加するのは困難です。 Java 開発者にとっては時間のかかる作業です。そのライブラリとフレームワークはプロジェクトの依存関係と呼ばれ、依存関係はそのようなものです (例: Spring-Boot、Hibernate、Kafaka、電子メールなど)。依存関係をダウンロードする代わりに、Maven ソフトウェアに依存関係をダウンロードするように指示できます。 Maven ソース コードをコンパイルし、API 機能をテストするためのテスト ケースを実行し、アプリケーションを jar(Java Archieve) / war(Web Archieve) としてパッケージ化します。

Maven を使い始めるには、インストール プロセスには、公式 Maven Web サイトからバイナリ パッケージをダウンロードし、MAVEN_HOME の環境変数を設定し、ターミナルまたはコマンド プロンプトで mvn -バージョン.

Windows への Maven のインストール

ステップ 1: Maven をダウンロードして開始する

公式 Web サイトから Maven をダウンロードします: Maven ダウンロード ページに移動します。最新バージョンの Maven のバイナリ zip アーカイブをダウンロードします。

ステップ 2: Maven を抽出する

ダウンロードしたら: ダウンロードした ZIP ファイルをフォルダーに解凍します。たとえば、C:Program FilesApachemaven または選択した別の場所を使用できます。

ステップ 3: 環境変数を設定する

Maven をコマンドラインから確実に利用できるようにするには、環境変数を設定する必要があります。 「この PC」を右クリックし、「プロパティ」を選択します

[システムの詳細設定] → [環境変数] をクリックします。

「システム環境変数」で「新規」をクリックし、以下を追加します。

変数名: MAVEN_HOME

変数値

C:\Program Files\Apache\maven

(または Maven を抽出したディレクトリ)。

次に、[システム環境変数] で Path 変数を見つけて選択し、[編集] をクリックします。

Add a new entry: %MAVEN_HOME%\bin.

ステップ 4: インストールの確認

To check if Maven is installed correctly, open a command prompt and run the following command:

mvn -version

Maven Terminology

Archetype

An Archetype is a template that helps you quickly create a Maven project with a predefined structure. It defines the directory layout and initial configuration files to simplify project setup.

groupId

The groupId identifies the organization or project to which a Maven artifact belongs. It follows a reverse domain name convention (e.g., com.example.project) and ensures that dependencies are uniquely identifiable across the system.

artifactId

The artifactId is the name of the project or library. It's used along with the groupId and version to uniquely identify a specific project artifact, such as a JAR, WAR, or other packages.

packaging

The packaging type defines the build output type for your Maven project. Common options include jar, war, or pom. It determines how Maven will package the code, usually as a JAR or WAR file.

version

The version specifies the release or iteration of a Maven project. It's crucial for managing different versions of a library or artifact, allowing you to reference a specific version when adding dependencies to other projects.

SNAPSHOT : Under development
RELEASE : Development completed

Creating a Stand-Alone Application Using Maven With CMD

Maven is an excellent tool for building and managing Java projects, especially when it comes to creating stand-alone applications. Let’s walk through the steps of setting up a basic stand-alone Java application using Maven.

mvn archetype:generate -DgroupId=com.example.app -DartifactId=standalone-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

• groupId: Uniquely identifies the project’s group.
• artifactId: The name of your application.
• archetypeArtifactId: Specifies the archetype for a simple Java project.

Once project created then verify project folder structure

standalone-app
│
├── src
│   ├── main
│   │   └── java               # Application source code (.java files)
│   │
│   ├── test
│   │   └── java               # Application Unit Test code (.java files)
│
└── pom.xml                    # Project Object Model (Maven configuration file)

src/main/java is containing the application source code.
src/test/java is containing the application test source code.
pom.xml file containing the maven configurations.

POM.XML

The pom.xml file, which stands for Project Object Model, is a crucial component of any Maven project. It is automatically generated when you create a Maven project and serves as the input file for Maven software. The pom.xml file defines the project’s metadata, including its name, version, and dependencies on various frameworks such as Spring, Hibernate, Kafka, and more. Instead of manually downloading these dependencies, you can specify them in the pom.xml file, and Maven will automatically fetch them for you. This makes managing project dependencies efficient and organized, allowing developers to focus on writing code without worrying about handling each library individually. Essentially, the pom.xml acts as a roadmap for Maven, guiding it on how to build and manage your Java project.

pom.xml

<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>com.example.app</groupId>
    <artifactId>standalone-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>  <!-- Java version -->
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- JUnit for unit testing -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Maven Compiler Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                </configuration>
            </plugin>

            <!-- Maven Shade Plugin for creating an executable JAR -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.example.app.App</mainClass>  <!-- Main class -->
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Maven Goals

Maven goals represent specific tasks that can be executed during the build lifecycle of a Maven project. Each goal corresponds to a distinct action, such as compiling code, running tests, packaging artifacts, or deploying to a repository.

By invoking these goals, developers can automate and streamline their build processes, ensuring that projects are built consistently and efficiently. Each goal can be run individually or as part of a larger lifecycle phase, providing flexibility in project management.

clean: Deletes the target directory, which contains compiled code and packaged artifacts, ensuring a fresh build.

compile: Compiles the source code of the project, producing class files from Java source files in the src/main/java directory.

test: Runs the unit tests defined in the src/test/java directory using a testing framework like JUnit.

package: Packages the compiled code into a distributable format, such as a JAR or WAR file, based on the project configuration in pom.xml.

install: Installs the packaged JAR/WAR file into the local Maven repository, making it available for other projects on the same machine.

deploy: Copies the packaged JAR/WAR file to a remote repository, making it available for other developers and projects.

site: Generates a site for the project, including documentation, reports, and project information, typically found in the target/site directory.

validate: Validates the project’s configuration and verifies that all required information is available before the build begins.

verify: Runs any checks to ensure the package is valid and meets quality standards, executing any verification tasks defined in the project.

archetype: Creates a new Maven project based on a specified archetype, setting up a project structure and initial files.

These goals can be executed from the command line, allowing developers to manage the build lifecycle effectively. You can run a specific goal using the following command format:

mvn [Goal]

Maven Repository

Maven repositories store project artifacts like libraries an dependencies. There are three main types of Maven repositories

Local Repository
Stores artifacts on your machine for quick access. it is a oyr system specific.

Remote Repository
Hosts artifacts on a server, accessible over the network. it is a organization specific.

Central Repository
Default public repository for widely used open-source libraries. it is accessed by everyone.

When you create a project and build it using Maven, it first checks your local repository (typically located at ~/.m2/repository) for any dependencies the project needs. If it finds the required dependencies in the local repository, Maven uses them directly, without downloading them again.

If the dependencies aren't available locally, Maven fetches them from a remote repository, such as Maven Central or another configured repository. Once downloaded, the dependencies are stored in the local repository for future use, so they don't need to be re-downloaded. This process helps optimize resource use and speeds up the build by preventing unnecessary downloads.

Maven build lifecycle

The Maven build lifecycle is a series of phases that automate the process of building and managing Java projects. It consists of three main lifecycles: default, clean, and site. The default lifecycle is the most commonly used, handling tasks like validating the project structure, compiling the code, running tests, packaging the output (e.g., into a JAR or WAR), and deploying the package to a remote repository. The clean lifecycle is responsible for cleaning up the project by deleting generated files from previous builds, while the site lifecycle is used to generate project documentation and reports. Each lifecycle consists of specific phases that are executed in sequence, ensuring that Maven handles everything from code compilation to deployment in a structured, automated way.

Conclusion

Maven has revolutionized how Java projects are built and managed, offering developers an efficient and automated approach to handling essential project tasks. Its core strength lies in dependency management, where Maven checks for required libraries in the local repository and fetches them from remote repositories like Maven Central if they're not available. This saves time and eliminates the need for manual dependency tracking, ensuring that projects always have the correct versions of required libraries.

The declarative nature of Maven, governed by the pom.xml file, standardizes the build process, making it easier to maintain consistency across different development environments. Whether it’s compiling code, running tests, or packaging the project for deployment, Maven's build lifecycle manages these steps seamlessly.

Additionally, Maven’s plugin system enhances its flexibility, enabling developers to integrate a wide array of tools and functionalities. Plugins for running tests, generating documentation, deploying artifacts, and more extend Maven’s utility far beyond a basic build tool.

By automating repetitive tasks and streamlining complex project setups, Maven allows developers to focus on writing code, improving productivity, and reducing potential errors. Its widespread adoption within the Java ecosystem makes it an indispensable tool for building modern, scalable, and maintainable Java applications.

以上がMaven をシンプルに: Java プロジェクトを簡単に構築の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。