maven编译后如何运行

三维地图看世界

于 2024-06-29 02:05:11 发布

阅读量50

点赞数

文章标签： maven python linux 服务器前端

在使用 Maven 编译 Java 项目后，可以通过几种不同的方式运行生成的应用程序。以下是一些常用的方法：

1. 使用 `exec:java` 插件运行

Maven 提供了 exec-maven-plugin 插件，可以直接运行编译后的 Java 类。

首先，在 pom.xml 中添加 exec-maven-plugin 配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.0.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>java</goal>
                    </goals>
                    <configuration>
                        <mainClass>com.example.App</mainClass>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

然后，运行以下命令：

该命令会编译项目并运行 com.example.App 类中的 main 方法。

2. 手动运行编译后的类

如果你不使用 exec-maven-plugin 插件，也可以手动运行编译后的类。

2.1 编译项目

首先，编译项目：

2.2 找到输出目录

Maven 默认将编译后的类文件放在 target/classes 目录中。

2.3 运行 Java 类

使用 java 命令运行主类，并指定类路径为 target/classes：

3. 打包并运行 JAR 文件

Maven 可以将项目打包成 JAR 文件，然后运行该 JAR 文件。

3.1 打包项目

使用 mvn package 命令打包项目：

该命令会在 target 目录下生成一个 JAR 文件，例如 myproject-1.0-SNAPSHOT.jar。

3.2 运行 JAR 文件

假设你的 pom.xml 中包含以下 mainClass 配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.example.App</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

然后，可以使用以下命令运行 JAR 文件：

总结

根据你的具体需求和项目配置，选择适合的方法来运行 Maven 编译后的 Java 项目。如果你频繁运行项目，推荐使用 exec-maven-plugin 插件来简化命令。对于生产环境或分发应用程序，打包成 JAR 文件并运行是更常见的做法。

编译后运行 Maven 项目通常涉及以下步骤：

确保项目已编译并打包：首先，确保你已经使用 mvn package 命令将项目打包成 .jar 或 .war 文件。
运行 .jar 文件：如果你的项目打包成了 .jar 文件，可以使用以下命令运行它：
java -jar target/your-project-name.jar
1.
请将 your-project-name.jar 替换为实际的 .jar 文件名。

运行 .war 文件：如果你的项目打包成了 .war 文件，你需要将其部署到一个支持 Java 的 Web 服务器（如 Apache Tomcat）。将 .war 文件复制到 Tomcat 的 webapps 目录下，然后启动 Tomcat 服务器。
运行 Spring Boot 项目：如果你使用的是 Spring Boot 项目，可以直接使用 Maven 插件运行项目：
mvn spring-boot:run
1.
运行测试：如果你想运行测试，可以使用以下命令：
mvn test
1.

和玲生命等价的东西，根本不存在

mvn exec:java -Dexec.mainClass=com.example.App 是一个 Maven 命令，用于运行指定的 Java 类。让我们分解一下这个命令的各个部分：

mvn:

这是 Maven 命令的入口点。每当你运行 Maven 命令时，都需要以 mvn 开头。

exec:java:

这是 Maven Exec 插件的一个目标（goal）。exec 是插件的简称，java 是这个插件的一个具体目标。这个目标允许你运行一个 Java 程序。

-Dexec.mainClass=com.example.App:

-D 表示传递一个系统属性。
exec.mainClass 是 Maven Exec 插件的一个配置参数，用于指定要运行的 Java 类的全限定名（fully qualified name），也就是包含包名的完整类名。
com.example.App 是你要运行的 Java 类的全限定名。在这个例子中，App 类位于 com.example 包下。

详细解释

Maven Exec 插件:

Maven Exec 插件用于执行系统和 Java 程序。它提供了两个主要目标：exec:exec 和 exec:java。
exec:java 目标专门用于运行 Java 程序。它会在项目的 classpath 中查找你指定的类，并运行它。

-Dexec.mainClass 参数:

这个参数告诉 Maven Exec 插件你想要运行哪个 Java 类。
例如，在你的 Maven 项目中，你可能有一个名为 App 的 Java 类，它包含 public static void main(String[] args) 方法。这个方法是 Java 程序的入口点。
当你运行 mvn exec:java -Dexec.mainClass=com.example.App 时，Maven 会找到 App 类并执行它的 main 方法。

示例

假设你有一个简单的 Java 类 App：

package com.example;

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

当你在项目根目录运行 mvn exec:java -Dexec.mainClass=com.example.App 时，Maven 会编译项目并运行 App 类的 main 方法，输出：

配置 `exec-maven-plugin` 插件

为了避免每次都在命令行中指定 -Dexec.mainClass 参数，你可以在 pom.xml 中配置 exec-maven-plugin 插件：

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
                <mainClass>com.example.App</mainClass>
            </configuration>
        </plugin>
    </plugins>
</build>

这样，你可以直接运行 mvn exec:java 而无需指定 -Dexec.mainClass 参数。

运行 mvn exec:java -Dexec.mainClass=com.example.App 时，Maven 会输出大量的信息，包括构建生命周期的各个阶段、依赖解析、编译信息等。这些输出是为了提供详细的构建过程日志，帮助开发者调试和了解构建过程中的各个步骤。具体来说，Maven 的输出通常包括以下几部分：

Maven 构建生命周期信息：

初始化阶段的信息。
解析和下载依赖的信息。
编译阶段的信息。
测试阶段的信息（如果有）。
打包阶段的信息（如果有）。
运行阶段的信息（如果有）。

插件信息：

Maven 使用的插件及其配置的信息。
具体插件执行的任务及其详细信息。

日志输出：

默认情况下，Maven 会输出 INFO 级别的日志，包括所有的构建步骤和插件执行的详细信息。

为了减少输出内容，使其仅显示结果，可以采取以下几种方法：

1. 使用 `-q` 参数（quiet 模式）

-q 参数将 Maven 的输出减少到最低限度，只显示基本的错误信息和构建结果：

2. 配置 `exec-maven-plugin` 的日志级别

你可以在 pom.xml 中配置 exec-maven-plugin，并指定其日志级别：

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
                <mainClass>com.example.App</mainClass>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>java</goal>
                    </goals>
                    <configuration>
                        <logLevel>ERROR</logLevel>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

3. 使用 `-D` 参数设置日志级别

你还可以通过命令行参数设置 Maven 的日志级别：

4. 仅输出 Java 程序的结果

如果你只关心 Java 程序的输出结果，可以重定向 Maven 的输出到一个临时文件，并只显示 Java 程序的输出：

mvn exec:java -Dexec.mainClass=com.example.App > temp.log 2>&1
cat temp.log | grep -A 100 'Starting App'

以上方法可以帮助你减少 Maven 的输出，使其更关注于 Java 程序的运行结果。如果有任何问题或需要进一步的帮助，请随时告诉我！

mkdir 跨中间目录直接生成多个层级目录

当你不使用 Maven 或其他构建工具时，你可以手动管理你的 Java 项目。下面是一些基本的步骤和示例，来帮助你编写和管理一个简单的 Java 项目。

步骤

创建项目结构
首先，创建一个合适的项目结构。通常，一个简单的 Java 项目包含以下结构：

myproject
├── src
│   └── com
│       └── example
│           └── App.java
└── lib

src 目录用于存放你的 Java 源代码。
lib 目录可以用来存放项目所需的外部库（JAR 文件）。

编写 Java 代码
在 src/com/example 目录下创建 App.java 文件，并编写你的 Java 代码。例如：

package com.example;

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

编译 Java 代码
打开命令行（或终端），导航到项目的根目录，并使用 javac 命令编译你的 Java 源文件。假设你的 App.java 文件在 src/com/example 目录下：

编译完成后，将生成 App.class 文件。

运行 Java 程序
使用 java 命令来运行编译后的 Java 类。确保你在命令行中位于项目根目录下：

-cp 参数用于指定类路径。在这里，我们将 src 目录作为类路径，确保 Java 能够找到 com.example.App 类。

注意事项

依赖管理：

如果你的项目需要依赖外部的 JAR 文件，你可以将这些 JAR 文件放在 lib 目录下，并在编译和运行时使用 -cp 参数指定类路径。

项目扩展性：

对于复杂的项目，手动管理依赖和编译过程可能变得复杂和不可维护。在这种情况下，考虑使用构建工具（如 Maven 或 Gradle）可以提高项目的扩展性和管理性。

编译和运行环境：

确保你的开发环境配置正确，包括 JDK 的安装和环境变量的设置。

通过这些步骤，你可以在不使用 Maven 的情况下编写和管理一个简单的 Java 项目。

原创作者: save 转载于: https://blog.51cto.com/save/11291277

三维地图看世界

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
maven编译后如何运行

在使用 Maven 编译 Java 项目后，可以通过几种不同的方式运行生成的应用程序。以下是一些常用的方法：1. 使用 exec:java 插件运行Maven 提供了 exec-maven-plugin 插件，可以直接运行编译后的 Java 类。首先，在 pom.xml 中添加 exec-maven-plugin 配置：登...
复制链接

扫一扫