Grails框架参考文档：快速敏捷的Web应用开发

下载需积分: 9 | PDF格式 | 1.03MB | 更新于2025-01-05 | 79 浏览量 | 举报

"Grails参考文档1.1.x版本是一个详细阐述Grails框架的官方文档，由Graeme Rocher、Peter Ledbrook和Marc Palmer撰写。该文档覆盖了Grails的各个方面，包括入门、配置、应用开发、测试和部署等关键知识点。" 在深入探讨Grails框架之前，首先理解其核心理念是至关重要的。Grails是一种基于Groovy语言的敏捷、工业级且快速的Web应用开发框架。它倡导“约定优于配置”的原则，这使得开发过程更加简洁高效。文档的“Getting Started”部分介绍了如何下载和安装Grails，以及如何从Grails 1.0.x升级到1.1.x版本。创建Grails应用是入门的第一步，文档详细说明了如何进行。从创建一个简单的“Hello World”示例开始，开发者可以快速了解Grails的工作原理。同时，文档还指导用户如何在集成开发环境(IDE)中设置Grails，以便更高效地编写代码。 Grails的“Convention over Configuration”理念意味着框架提供了默认的配置和结构，使得开发者不必处理大量琐碎的配置工作，从而能够更快地专注于业务逻辑。文档中展示了如何运行和测试应用，包括启动应用、执行单元测试和功能测试等。部署应用是开发周期的一部分，文档介绍了如何将Grails应用部署到不同的Java EE容器，列出了框架支持的容器类型。此外，Grails还允许开发者创建和管理各种构建工件，如控制器、服务、视图等，这些都在“Creating Artefacts”章节中有详细讲解。在配置方面，文档涵盖了基本配置选项，如内置命令行选项和日志设置。此外，还讨论了如何针对不同环境（如开发、测试和生产）进行配置。特别是数据源配置，文档不仅讲解了数据源和环境的关系，还涉及了JNDI数据源的使用，以及如何自动配置数据库连接。这份“Grails Reference Documentation 1.1.x”是学习和使用Grails框架的宝贵资源，它详尽地阐述了从开始到部署的整个流程，为开发者提供了一个全面的理解和实践Grails的指南。无论是初学者还是经验丰富的开发者，都能从中受益匪浅。

}

This also works for the built-in appender "stdout", which logs to the console:

log4j = {

appenders {

console name:'stdout', layout:pattern(conversionPattern: '%c{2} %m%n')

}

Full stacktraces

When exceptions occur, there can be an awful lot of noise in the stacktrace from Java and Groovy internals. Grails filters

these typically irrelevant details and restricts traces to non-core Grails/Groovy class packages.

When this happens, the full trace is always written to the StackTrace logger. This logs to a file called stacktrace.log -

but you can change this in your Config.groovy to do anything you like. For example if you prefer full stack traces to go to

standard out you can add this line:

error stdout:"StackTrace"

You can completely disable stacktrace filtering by setting the grails.full.stacktrace VM property to true:

grails -Dgrails.full.stacktrace=true run-app

Logging by Convention

All application artefacts have a dynamically added log property. This includes domain classes, controllers, tag libraries and so

on. Below is an example of its usage:

def foo = "bar"

log.debug "The value of foo is $foo"

Logs are named using the convention grails.app.<artefactType>.ClassName. Below is an example of how to

configure logs for different Grails artefacts:

log4j = {

// Set level for all application artefacts

info "grails.app"

// Set for a specific controller

debug "grails.app.controller.YourController"

// Set for a specific domain class

debug "grails.app.domain.Book"

// Set for all taglibs

info "grails.app.tagLib"

}

The artefacts names are dictated by convention, some of the common ones are listed below:

◦ bootstrap - For bootstrap classes

◦ dataSource - For data sources

◦ tagLib - For tag libraries

◦ service - For service classes

◦ controller - For controllers

The Grails Framework - Reference-Documentation 1.1

Within your code, such as in a Gant script or a bootstrap class you can detect the environment using the Environment class:

import grails.util.Environment

...

switch(Environment.current) {

case Environment.DEVELOPMENT:

configureForDevelopment()

break

case Environment.PRODUCTION:

configureForProduction()

break

}

3.3 The DataSource

Since Grails is built on Java technology to set-up a data source requires some knowledge of JDBC (the technology that

doesn't stand for Java Database Connectivity).

Essentially, if you are using another database other than HSQLDB you need to have a JDBC driver. For example for MySQL

you would need Connector/J

Drivers typically come in the form of a JAR archive. Drop the JAR into your projects lib directory.

Once you have the JAR in place you need to get familiar Grails' DataSource descriptor file located at grails-app/conf/

DataSource.groovy. This file contains the dataSource definition which includes the following settings:

◦ driverClassName - The class name of the JDBC driver

◦ username - The username used to establish a JDBC connection

◦ password - The password used to establish a JDBC connection

◦ url - The JDBC URL of the database

◦ dbCreate - Whether to auto-generate the database from the domain model or not

◦ pooled - Whether to use a pool of connections (defaults to true)

◦ logSql - Enable SQL logging

◦ dialect - A String or Class that represents the Hibernate dialect used to communicate with the database. See the

org.hibernate.dialect package for available dialects.

A typical configuration for MySQL may be something like:

dataSource {

pooled = true

dbCreate = "update"

url = "jdbc:mysql://localhost/yourDB"

driverClassName = "com.mysql.jdbc.Driver"

username = "yourUser"

password = "yourPassword"

}

When configuring the DataSource do not include the type or the def keyword before any of the

configuration settings as Groovy will treat these as local variable definitions and they will not be

processed. For example the following is invalid:

dataSource {

boolean pooled = true // type declaration results in local variable

…

}

3.3.1 DataSources and Environments

The previous example configuration assumes you want the same config for all environments: production, test, development

etc.

The Grails Framework - Reference-Documentation 1.1

Grails' DataSource definition is "environment aware", however, so you can do:

dataSource {

// common settings here

}

environments {

production {

dataSource {

url = "jdbc:mysql://liveip.com/liveDb"

}

3.3.2 JNDI DataSources

Since many Java EE containers typically supply DataSource instances via the Java Naming and Directory Interface (JNDI).

Sometimes you are required to look-up a DataSource via JNDI.

Grails supports the definition of JNDI data sources as follows:

dataSource {

jndiName = "java:comp/env/myDataSource"

}

The format on the JNDI name may vary from container to container, but the way you define the DataSource remains the

same.

3.3.3 Automatic Database Migration

The dbCreate property of the DataSource definition is important as it dictates what Grails should do at runtime with

regards to automatically generating the database tables from GORM classes. The options are:

◦ create-drop - Drop and re-create the database when Grails is run

◦ create - Create the database if it doesn't exist, but don't modify it if it does. Deletes existing data.

◦ update - Create the database if it doesn't exist, and modify it if it does exist

Both create-drop and create will destroy all existing data hence use with caution!

In development mode dbCreate is by default set to "create-drop":

dataSource {

dbCreate = "create-drop" // one of 'create', 'create-drop','update'

}

What this does is automatically drop and re-create the database tables on each restart of the application. Obviously this may

not be what you want in production.

Although Grails does not currently support Rails-style Migrations out of the box, there are currently

three plugins that provide similar capabilities to Grails: Autobase (http://wiki.github.com/

RobertFischer/autobase), The LiquiBase plugin and the DbMigrate plugin both of which are available

via the grails list-plugins command

3.4 Externalized Configuration

The default configuration file Config.groovy in grails-app/conf is fine in the majority of cases, but there may be

circumstances where you want to maintain the configuration in a file outside the main application structure. For example if

you are deploying to a WAR some administrators prefer the configuration of the application to be externalized to avoid having

to re-package the WAR due to a change of configuration.

3. Configuration

In order to support deployment scenarios such as these the configuration can be externalized. To do so you need to point

Grails at the locations of the configuration files Grails should be using by adding a grails.config.locations setting in

Config.groovy:

grails.config.locations = [ "classpath:${appName}-config.properties",

"classpath:${appName}-config.groovy",

"file:${userHome}/.grails/${appName}-config.properties",

"file:${userHome}/.grails/${appName}-config.groovy"]

In the above example we're loading configuration files (both Java properties files and ConfigSlurper configurations) from

different places on the classpath and files located in USER_HOME.

Ultimately all configuration files get merged into the config property of the GrailsApplication object and are hence

obtainable from there.

Grails also supports the concept of property place holders and property override configurers as

defined in Spring For more information on these see the section on Grails and Spring

3.5 Versioning

Versioning Basics

Grails has built in support for application versioning. When you first create an application with the create-app command the

version of the application is set to 0.1. The version is stored in the application meta data file called

application.properties in the root of the project.

To change the version of your application you can run the set-version command:

grails set-version 0.2

The version is used in various commands including the war command which will append the application version to the end of

the created WAR file.

Detecting Versions at Runtime

You can detect the application version using Grails' support for application metadata using the GrailsApplication class. For

example within controllers there is an implicit grailsApplication variable that can be used:

def version = grailsApplication.metadata['app.version']

If it is the version of Grails you need you can use:

def grailsVersion = grailsApplication.metadata['app.grails.version']

or the GrailsUtil class:

import grails.util.*

def grailsVersion = GrailsUtil.grailsVersion

The Grails Framework - Reference-Documentation 1.1

剩余175页未读，继续阅读

F4arsenal

粉丝: 0
资源: 1

Grails框架参考文档：快速敏捷的Web应用开发

groovy-grails-tool-suite-3.6.4.RELEASE-e4.4.2-win32-x86_64.part2

grails-fck-editor-0.3.zip_grails_grails-fck-editor

wsdl2java源码-grails-cxf-grails-3:grails-cxf-grails-3

grails-docs-1.0-RC1.pdf

grails-bin-1.1

The Grails Framework - Reference Documentation

grails-datastore-simple-1.1.5.RELEASE.zip

grails-datastore-core-1.0.7.RELEASE.zip

groovy-grails-tool-suite-3.6.4.RELEASE-e4.4.2-win32-x86_64.part1

Grails-开源框架---使用指南.pdf与Groovy入门经典(中文).pdf（2合一）

最新资源