(快速参考)

5 命令行

版本 6.2.0

5 命令行

与先前版本相比，Grails 新命令行界面 (CLI) 经历了重大变化，主要集中在代码生成方面。一个显著的变化是删除了使用 Gradle Tooling API 调用 Gradle 来执行与构建相关的任务的 API。这种责任的转移与框架的演变及其与 Gradle 构建系统的集成相一致。

访问 Grails CLI

只需在终端或命令提示符中输入以下命令，即可快速轻松地访问 Grails CLI（命令行界面）

grails

此命令允许开发人员快速启动 Grails CLI 并开始使用该框架，使其成为那些希望启动 Grails 项目的人的简单入口点。

新的 Grails CLI！是启动新 Grails 项目的首选方法。此命令行界面提供了用于创建项目的各种选项，使您能够选择首选的构建工具、测试框架、GORM 实现等。此外，CLI 还提供用于生成控制器和域类等基本组件的命令。

Grails Forge 网站

您还可以通过访问 Grails Forge 网站来启动 Grails 应用程序，而无需安装 Grails CLI。这个基于 Web 的平台允许您方便地启动 Grails 项目，绕过 CLI 的安装。

了解新的 Grails 命令行界面 (CLI)

成功安装 Grails CLI 后，可以使用“grails”命令激活它。例如

grails create-app myapp

Grails 框架 CLI 项目可以通过“grails-cli.yml”文件的存在来识别，如果项目是使用 CLI 创建的，则该文件会自动生成在项目的根目录下。此文件包含有关项目配置文件、默认包和其他变量的信息。

以下是默认 Grails Web 应用程序的“grails-cli.yml”配置示例

applicationType: web
defaultPackage: com.example
testFramework: spock
sourceLanguage: groovy
buildTool: gradle
gormImpl: gorm-hibernate5
servletImpl: spring-boot-starter-tomcat
features:
  - app-name
  - asset-pipeline-grails
  - base
  - geb
  - gorm-hibernate5
  - gradle
  - grails-application
  - grails-console
  - grails-dependencies
  - grails-gorm-testing-support
  - grails-gradle-plugin
  - grails-gsp
  - grails-url-mappings
  - grails-web
  - grails-web-testing-support
  - h2
  - logback
  - micronaut-inject-groovy
  - readme
  - scaffolding
  - spock
  - spring-boot-autoconfigure
  - spring-boot-starter
  - spring-boot-starter-tomcat
  - yaml

此“grails-cli.yml”配置设置 Grails Web 应用程序各个方面的默认值，包括应用程序类型、默认包、测试框架、源语言、构建工具、GORM 实现、Servlet 实现和已启用功能的列表。

Grails 默认包配置

项目的默认包是根据项目的名称确定的。例如，运行以下命令

grails create-app myapp

将默认包设置为“myapp”。

如果您希望在创建应用程序时指定自己的默认包，可以通过在应用程序名称前加上包名来实现，如下所示

grails create-app com.example.myapp

在这种情况下，“com.example”将成为项目的默认包。

Gradle 构建工具

Grails 现在使用 Gradle 构建系统进行项目管理。项目的构建配置在“build.gradle”文件中指定，您可以在其中定义项目的关键方面，例如其版本、所需的依赖项以及应该从中获取这些依赖项的存储库。以下是实现此目的的示例

plugins {
    id 'org.grails.grails-web' version 'x.y.z' // Grails plugin
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.grails:grails-core'
    // Add more dependencies as needed...
}

grails {
    pathingJar = true
}

使用 Gradle 构建工具

要与 Grails 项目进行交互并执行与构建和运行相关的各种任务，您应该使用 Gradle 命令。以下是一些示例

构建 Grails 应用程序

gradle build

运行 Grails 应用程序

gradle bootRun

列出可用的 Gradle 任务

gradle tasks

通过调用这些 Gradle 命令，您可以有效地管理 Grails 应用程序的生命周期。

重要的是要记住，Grails 利用 Gradle 的强大功能来简化项目管理，包括构建自动化和依赖项解析。这种方法允许您对 Grails 项目进行更大的灵活性和控制。

5.1 交互模式

当您执行不带任何参数的“grails”命令时，Grails 命令行界面 (CLI) 将进入交互模式。在此模式下，它的功能类似于 shell，允许您运行多个 CLI 命令，而无需重新初始化 CLI 运行时。当使用代码生成命令（例如“create-controller”）、创建多个项目或探索各种 CLI 功能时，此模式特别有用。

交互模式的优点之一是提供 Tab 补全功能。您只需按 TAB 键即可查看给定命令或标志的可能选项。以下是交互模式下可用选项的示例

grails>
--help                --verbose             -V                    -v                    create-app            create-domain-class   create-restapi        create-webapp
--stacktrace          --version             -h                    -x                    create-controller     create-plugin         create-web-plugin

帮助和信息

您可以使用与特定命令关联的 help 标志访问 Grails 命令的一般用法信息。

grails> create-app -h
Usage: grails create-app [-hivVx] [--list-features] [-g=GORM Implementation] [--jdk=<javaVersion>]
                         [-s=Servlet Implementation] [-t=TEST] [-f=FEATURE[,FEATURE...]]... [NAME]
Creates an application
      [NAME]            The name of the application to create.
  -f, --features=FEATURE[,FEATURE...]
                        The features to use. Possible values: h2, scaffolding, gorm-hibernate5,
                          spring-boot-starter-jetty, springloaded, spring-boot-starter-tomcat,
                          micronaut-http-client, cache-ehcache, hibernate-validator, postgres,
                          mysql, cache, database-migration, grails-gsp, hamcrest, gorm-mongodb,
                          assertj, mockito, spring-boot-starter-undertow, micronaut-inject-groovy,
                          github-workflow-java-ci, jrebel, testcontainers, sqlserver,
                          grails-console, views-markup, asset-pipeline-grails, views-json,
                          gorm-neo4j, asciidoctor, embedded-mongodb, grails-web-console,
                          logbackGroovy, mongo-sync, shade, geb, properties
  -g, --gorm=GORM Implementation
                        Which GORM Implementation to configure. Possible values: hibernate,
                          mongodb, neo4j.
  -h, --help            Show this help message and exit.
  -i, --inplace         Create a service using the current directory
      --jdk, --java-version=<javaVersion>
                        The JDK version the project should target
      --list-features   Output the available features and their descriptions
  -s, --servlet=Servlet Implementation
                        Which Servlet Implementation to configure. Possible values: none, tomcat,
                          jetty, undertow.
  -t, --test=TEST       Which test framework to use. Possible values: junit, spock.
  -v, --verbose         Create verbose output.
  -V, --version         Print version information and exit.
  -x, --stacktrace      Show full stack trace when exceptions occur.

您还可以通过对任何创建命令使用 --list-features 标志来获取可用功能的列表。

grails> create-app --list-features
Available Features
(+) denotes the feature is included by default
  Name                                Description
  ----------------------------------  ---------------
  CI/CD
  github-workflow-java-ci [PREVIEW]   Adds a Github Actions Workflow to Build and Test Grails Application

  Cache
  cache                               The Grails Cache plugin provides powerful and easy to use caching functionality to Grails applications and plugins.
  cache-ehcache                       The Grails Cache Ehcache plugin extends the Cache plugin and uses Ehcache as the storage provider for cached content.

  Client
  micronaut-http-client               Adds support for the Micronaut HTTP client

  Configuration
  properties                          Creates a properties configuration file

  Database
  database-migration                  Adds support for Liquibase database migrations. The Database Migration plugin helps you manage database changes while developing Grails applications.
  embedded-mongodb                    Executes an embedded mongo database for integration or functional testing
  gorm-hibernate5 (+)                 Adds support for Hibernate5 using GORM
  gorm-mongodb                        Configures GORM for MongoDB for Groovy applications
  gorm-neo4j                          Configures GORM for Neo4j for Groovy applications
  h2 (+)                              Adds the H2 driver and default config
  mongo-sync                          Adds support for the MongoDB Synchronous Driver
  mysql                               Adds the MySQL driver and default config
  postgres                            Adds the PostgresSQL driver and default config
  sqlserver                           Adds the SQL Server driver and default config
  testcontainers                      Use Testcontainers to run a database or other software in a Docker container for tests

  Development Tools
  assertj                             AssertJ fluent assertions framework
  hamcrest                            Hamcrest matchers for JUnit
  jrebel                              Adds support for class reloading with JRebel (requires separate JRebel installation)
  springloaded                        Adds support for class reloading with Spring Loaded

  Documentation
  asciidoctor                         Adds support for creating Asciidoctor documentation

  Logging
  logbackGroovy                       Gives you the ability to use groovy to configure logback instead of XML.

  Management
  grails-web-console                  A web-based Groovy console for interactive runtime application management and debugging

  Other
  geb (+)                             This plugins configure Geb for Grails framework to write automation tests.
  grails-console (+)                  Starts the Grails console, which is an extended version of the regular Groovy console.
  micronaut-inject-groovy (+)         micronaut-inject-groovy
  scaffolding (+)                     The Grails® framework Scaffolding plugin replicates much of the functionality from Grails 2, but uses the fields plugin instead.

  Packaging
  shade                               Adds the ability to build a Fat/Shaded JAR

  Server
  spring-boot-starter-jetty           spring-boot-starter-jetty
  spring-boot-starter-tomcat (+)      spring-boot-starter-tomcat
  spring-boot-starter-undertow        spring-boot-starter-undertow

  Validation
  hibernate-validator                 Adds support for the Hibernate Validator
  mockito                             Mockito test mocking framework for JUnit

  View Rendering
  asset-pipeline-grails (+)           The Asset-Pipeline is a plugin used for managing and processing static assets in JVM applications primarily via Gradle (however not mandatory). Read more at https://github.com/bertramdev/asset-pipeline
  grails-gsp (+)                      grails-gsp
  views-json                          JSON views are written in Groovy, end with the file extension gson and reside in the grails-app/views directory. They provide a DSL for producing output in the JSON format.
  views-markup                        Markup views are written in Groovy, end with the file extension gml and reside in the grails-app/views directory. They provide a DSL for producing output in the XML.

5.2 创建自定义命令

在 Grails 中，自定义命令是您可以添加到 Grails 应用程序中并通过命令行界面 (CLI) 执行的功能。这些命令不是核心 Grails 框架的一部分，而是您可以创建的扩展，用于执行特定于应用程序需求的特定任务或操作。自定义命令是一种强大的方式，可以通过命令行自动执行各种任务、与应用程序交互以及执行管理功能。当您运行自定义命令时，它们会导致 Grails 环境启动，使您可以完全访问应用程序上下文和运行时，从而允许您根据需要在自定义命令中使用应用程序的资源、服务和配置。

您可能希望为 Grails 应用程序编写自定义命令，原因如下：

自动执行任务：自定义命令允许您通过将逻辑封装在可按需执行的命令中来自动执行例行任务，例如数据迁移、数据库更新或批处理。
管理操作：您可以将自定义命令用于管理任务，例如用户管理、系统维护和配置管理，从而更轻松地在不同环境中管理应用程序。
集成：自定义命令可用于将 Grails 应用程序与其他系统或服务集成。例如，您可以创建一个命令来与外部 API 同步数据。
自定义工作流：如果您的应用程序具有唯一的工作流或流程，则自定义命令提供了一种从命令行执行这些工作流的方法。

在 Grails 中，您可以通过实现 GrailsApplicationCommand 特征来创建自定义命令。默认情况下，此特征要求您的命令实现 handle() 方法，如下所示

boolean handle()

以这种方式定义的命令仍然可以通过名为“executionContext”的变量访问执行上下文。

以下是使用 GrailsApplicationCommand 特征创建自定义命令的分步指南，其中包含示例以及如何运行这些命令。

在 Grails 中，您可以通过实现“GrailsApplicationCommand”特征来创建自定义命令。自定义命令允许您向 Grails 应用程序添加可以通过命令行界面 (CLI) 执行的功能。以下是使用“GrailsApplicationCommand”特征创建自定义命令的分步指南，其中包含示例以及如何运行这些命令。

步骤 1：创建自定义命令

要创建自定义命令，您需要创建一个实现“GrailsApplicationCommand”特征的 Groovy 类。此特征提供了用于命令执行的方法。让我们创建一个简单的示例命令来向用户问好

// grails-app/commands/com/example/GreetCommand.groovy
package com.example

import grails.cli.GrailsApplicationCommand

class GreetCommand implements GrailsApplicationCommand {

    String getName() {
        return "greet"
    }

    String getDescription() {
        return "Greet the user"
    }

    boolean handle() {
        println("Hello, user!")
        return true // Return true to indicate successful execution
    }
}

在此示例中，我们创建了一个“GreetCommand”类，该类实现了“GrailsApplicationCommand”特征。它提供了一个“getName()”方法来定义命令名称，一个“getDescription()”方法用于简要描述，以及一个“run()”方法来指定在运行命令时要执行的代码。

步骤 2：构建 Grails 应用程序

在使用 runCommand 任务之前，请确保您已使用以下命令构建了 Grails 应用程序

./gradlew assemble

此命令将编译您的应用程序，并使其准备好运行自定义命令。

步骤 3：运行自定义命令

要运行自定义命令，请使用 Gradle 的 runCommand 任务。打开终端，并导航到 Grails 应用程序的根目录。然后，使用以下 Gradle 命令运行自定义命令

./gradlew runCommand -Pargs="greet"

在上面的命令中，将“greet”替换为您的自定义命令的名称。这将执行 GreetCommand，您将看到输出。

以下是运行 greet 命令时的预期最终输出

Hello, user!

附加功能：命令参数和选项

Grails 还支持自定义命令的命令行参数和选项。您可以通过实现“GrailsApplicationCommand”接口在命令类中定义这些参数和选项。以下是一个命令示例，该命令将名称作为参数，并使用可选的“--loud”选项使问候语更响亮

// grails-app/commands/com/example/GreetCommand.groovy
package com.example

import grails.cli.GrailsApplicationCommand

class GreetCommand implements GrailsApplicationCommand {

    String getName() {
        return "greet"
    }

    String getDescription() {
        return "Greet the user with options"
    }

    boolean handle() {
        def args = commandLine.args
        String name = args.size() > 0 ? args[0] : "user"
        boolean loud = args.contains("--loud")

        if (loud) {
            println("HELLO, $name! (LOUD)")
        } else {
            println("Hello, $name!")
        }

        return true
    }
}

现在，您可以使用参数和选项运行“greet”命令

# Greet the user with the default message
./gradlew runCommand -Pargs="greet"

# Greet a specific user
./gradlew runCommand -Pargs="greet Alice"

# Greet loudly
./gradlew runCommand -Pargs="greet --loud"

# Greet a specific user loudly
./gradlew runCommand -Pargs="greet Alice --loud"

这允许您为 Grails 应用程序创建更多功能和交互式自定义命令。

总之，使用“GrailsApplicationCommand”特征在 Grails 中创建自定义命令是一种强大的方式，可以扩展应用程序的功能，使其超出 Web 界面的范围。您可以定义命令的名称、描述和逻辑，然后从命令行执行它，并根据需要选择性地传递参数和选项。

在 Grails 自定义命令中使用“executionContext”

在 Grails 中，executionContext 是一个运行时上下文对象，它提供有关 Grails 应用程序当前执行环境的有价值信息。它包括应用程序环境（例如，开发、生产、测试）等详细信息，并允许开发人员在自定义命令中访问此上下文。

Grails 中的自定义命令可以使用 executionContext 根据当前运行时环境做出明智的决策并执行特定任务。例如，开发人员可以在自定义命令中编写条件逻辑，这些逻辑在生产、开发或测试环境中的执行方式不同。这种灵活性使自定义命令能够根据其运行上下文进行调整和表现出不同的行为，使其成为管理和扩展 Grails 应用程序的通用工具。

假设您有一个管理客户数据的 Grails 应用程序，并且您想创建一个自定义命令来执行数据备份。在这种情况下，您可能希望备份过程的行为根据您是在开发、登台还是生产环境中运行它而有所不同。

以下是如何创建一个使用 executionContext 来确定备份行为的自定义命令的示例

// grails-app/commands/com/example/BackupCommand.groovy
package com.example

import grails.cli.GrailsApplicationCommand

class BackupCommand implements GrailsApplicationCommand {

    String getName() {
        return "backup"
    }

    String getDescription() {
        return "Backup customer data"
    }

    boolean handle() {
        // Access the executionContext to determine the environment
        def environment = executionContext.environment

        if (environment == "production") {
            // Perform a full backup in the production environment
            println("Performing a full backup of customer data (Production)")
            // Add production-specific backup logic here
        } else {
            // Perform a partial backup in other environments
            println("Performing a partial backup of customer data (Non-production)")
            // Add non-production backup logic here
        }

        return true // Return true to indicate successful execution
    }
}

在此示例中

名为 BackupCommand 的自定义命令用于备份客户数据。
它会检查 executionContext 以确定当前环境。
如果环境是“生产环境”，它将使用特定于生产环境的逻辑执行完整备份。
在所有其他环境中，它将使用非生产环境逻辑执行部分备份。

当您使用 ./gradlew runCommand -Pargs="backup" 运行此自定义命令时，它会根据您是在生产环境还是非生产环境中调整其行为，从而演示如何在实际场景中使用 executionContext 做出特定于环境的决策。

如何从 Grails 插件创建自定义命令

您不仅可以在 Grails 应用程序中创建自定义命令，还可以从 Grails 插件创建自定义命令。以下是操作方法

创建 Grails 插件：如果您还没有 Grails 插件，则可以使用 Grails 的插件生成命令创建一个。例如
```
grails create-plugin my-plugin
```
定义命令：在您的 Grails 插件中，通过创建一个实现 GrailsApplicationCommand 特性或接口的 Groovy 类来定义自定义命令，并提供必要的方法，如 getName()、getDescription() 和 handle()。

构建和打包插件：要发布插件，您应该使用 Gradle maven-publish 插件。更新插件的 build.gradle 文件以包含以下配置

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {
            url "file://path/to/your/local/repo" // Adjust the path accordingly
        }
    }
}

然后，您可以将插件发布到本地存储库

./gradlew publishToMavenLocal

添加插件作为依赖项：您应该在 Grails 应用程序的 build.gradle 文件中添加插件作为依赖项，而不是使用 grails install-plugin 命令。包括以下依赖项
```
dependencies {
    // ...
    implementation 'com.example:my-plugin:1.0.0' // Replace with your plugin's group and version
    // ...
}
```
确保将“com.example:my-plugin:1.0.0”替换为插件的相应组和版本
运行自定义命令：现在，您可以使用 Gradle runCommand 任务从 Grails 应用程序的根目录运行自定义命令，如前所述
```
./gradlew runCommand -Pargs="your-command-name"
```
将 "your-command-name" 替换为您在插件中定义的自定义命令的名称。

通过执行这些步骤，您可以从 Grails 插件创建和运行自定义命令，根据需要扩展 Grails 应用程序的功能。这种方法允许您模块化自定义功能，并在必要时在多个 Grails 项目之间共享它。

5.3 创建 Grails 项目

创建项目是 CLI 的主要用途。创建新项目的主要命令是 create-app，它创建一个通过 HTTP 进行通信的标准 Grails Web 应用程序。对于其他类型的应用程序，请参阅下面的文档。

命令描述选项示例

create-app / create-webapp

创建一个 Grails Web 应用程序

-jdk, --java-version
-s, --servlet
-g, --gorm
-t, --test
-f, --features
-i, --inplace

grails create-app \
    --servlet=tomcat \
    --jdk=11 \
    --gorm=hibernate \
    --test=spock \
    --features=github-workflow-java-ci \
    com.example.demo`

create-restapi

创建一个 Grails REST API 应用程序

-jdk, --java-version
-s, --servlet
-g, --gorm
-t, --test
-f, --features
-i, --inplace

grails create-restapi \
    --servlet=tomcat \
    --jdk=11 \
    --gorm=hibernate \
    --test=spock \
    --features=github-workflow-java-ci \
    com.example.demo`

create-plugin

创建一个 Grails 插件应用程序

-jdk, --java-version
-s, --servlet
-g, --gorm
-t, --test
-f, --features
-i, --inplace

grails create-plugin \
    --servlet=tomcat \
    --jdk=11 \
    --gorm=hibernate \
    --test=spock \
    --features=github-workflow-java-ci \
    com.example.demo`

create-web-plugin

创建一个 Grails Web 插件应用程序

-jdk, --java-version
-s, --servlet
-g, --gorm
-t, --test
-f, --features
-i, --inplace

grails create-web-plugin \
    --servlet=tomcat \
    --jdk=11 \
    --gorm=hibernate \
    --test=spock \
    --features=github-workflow-java-ci \
    com.example.demo`

| 标志 | 描述 | 示例

`create-` 命令标志

“create-*”命令用于生成基本的 Grails 项目，允许包含可选标志以选择其他功能、自定义 GORM 设置、嵌入式 servlet、测试框架和 Java 版本。

标志描述示例

-jdk, --java-version

项目应面向的 JDK 版本

--java-version 11

-s, --servlet

要配置的 Servlet 实现。可能的值：none、tomcat、jetty、undertow。

--servlet=tomcat

-g, --gorm

要配置的 GORM 实现。可能的值：hibernate、mongodb、neo4j。

--gorm hibernate

-t, --test

要使用的测试框架。可能的值：junit、spock。

--test spock

-f, --features

要使用的功能。可能的值：h2、gorm-hibernate5、spring-boot-starter-jetty、springloaded、micronaut-http-client、cache-ehcache、hibernate-validator、postgres、mysql、cache、database-migration、grails-gsp、hamcrest、gorm-mongodb、assertj、mockito、spring-boot-starter-undertow、micronaut-inject-groovy、github-workflow-java-ci、jrebel、testcontainers、sqlserver、grails-console、views-markup、views-json、gorm-neo4j、asciidoctor、embedded-mongodb、grails-web-console、logbackGroovy、mongo-sync、shade、properties

--features github-workflow-java-ci,micronaut-http-client

-i, --inplace

使用当前目录创建项目

--inplace

<< 4配置

6对象关系映射 (GORM) >>

5 命令行

目录

5 命令行

访问 Grails CLI

Grails Forge 网站

了解新的 Grails 命令行界面 (CLI)

Grails 默认包配置

Gradle 构建工具

使用 Gradle 构建工具

5.1 交互模式

帮助和信息

5.2 创建自定义命令

5.3 创建 Grails 项目

`create-` 命令标志

命令行

约束

控制器

数据库映射

依赖版本

域类

插件

服务

Servlet API

5 命令行

目录

5 命令行

访问 Grails CLI

Grails Forge 网站

了解新的 Grails 命令行界面 (CLI)

Grails 默认包配置

Gradle 构建工具

使用 Gradle 构建工具

5.1 交互模式

帮助和信息

5.2 创建自定义命令

5.3 创建 Grails 项目

create- 命令标志

命令行

约束

控制器

数据库映射

依赖版本

域类

插件

服务

Servlet API

`create-` 命令标志