Sale!

The Definitive Guide to Grails 1st Edition by Graeme Rocher ISBN 1590597583 9781590597583

Original price was: $50.00.Current price is: $35.00.

The Definitive Guide to Grails 1st Edition Graeme Rocher Digital Instant Download

Author(s): Graeme Rocher
ISBN(s): 9781590597583, 1590597583
Edition: 1
File Details: PDF, 9.03 MB
Year: 2006
Language: english
SKU: EB-1834192 Category: Tag:

The Definitive Guide to Grails 1st Edition by Graeme Rocher – Ebook PDF Instant Download/Delivery: 1590597583, 9781590597583
Full download The Definitive Guide to Grails 1st Edition after payment

Product details:

ISBN 10: 1590597583 
ISBN 13: 9781590597583
Author: Graeme Rocher

Grails is a full stack framework which aims to greatly simplify the task of building serious web applications for the JVM. The concepts within Grails, like interceptors, tag libs, and Groovy Server Pages (GSP), make those in the Java community feel right at home. Grails’ foundation is on solid open source technologies such as Spring, Hibernate, and SiteMesh, which gives it even more potential in the Java space: Spring provides powerful inversion of control and MVC, Hibernate brings a stable, mature object relational mapping technology with the ability to integrate with legacy systems, and SiteMesh handles flexible layout control and page decoration. Grails complements these with additional features that take advantage of the coding–by–convention paradigm such as dynamic tag libraries, Grails object relational mapping, Groovy Server Pages, and scaffolding. Graeme Rocher, Grails lead and founder, and Jeff Brown bring you completely up–to–date with their authoritative and fully comprehensive guide to the Grails 2 framework. You’ll get to know all the core features, services, and Grails extensions via plug–ins, and understand the roles that Groovy and Grails are playing in the changing Web.

The Definitive Guide to Grails 1st Table of contents:

Chapter 1: The Essence of Grails

  • Simplicity and Power

  • Grails, the Platform

  • Living in the Java Ecosystem

  • Installing and Configuring Grails

  • Creating Your First Application

    • Step 1: Creating the Application

    • Step 2: Creating a Controller

    • Step 3: Printing a Message

    • Step 4: Testing the Code

    • Step 5: Running the Tests

    • Step 6: Running the Application

  • Grails Interactive Mode

  • Summary

Chapter 2: Getting Started with Grails

  • What Is Scaffolding?

  • Creating a Domain

  • Introducing Dynamic Scaffolding

  • The Create Operation

  • The Read Operation

  • The Update Operation

  • The Delete Operation

  • Static Scaffolding

  • Generating a Controller

  • Generating the Views

  • Being Environmentally Friendly

  • Configuring Data Sources

    • The DataSource.groovy File

    • Configuring a MySQL Database

    • Configuring a JNDI Data Source

  • Supported Databases

  • Deploying the Application

    • Deployment with run-war

    • Deployment with a WAR file

  • Summary

Chapter 3: Understanding Domain Classes

  • Persisting Fields to the Database

  • Validating Domain Classes

  • Using Custom Validators

  • Understanding Transient Properties

  • Customizing Your Database Mapping

  • Building Relationships

  • Extending Classes with Inheritance

  • Embedding Objects

  • Testing Domain Classes

  • Summary

Chapter 4: Understanding Controllers

  • Defining Controllers

  • Setting the Default Action

  • Logging

    • Logging Exceptions

  • Accessing Request Attributes

  • Using Controller Scopes

  • Understanding Flash Scope

  • Accessing Request Parameters

  • Request Parameter Type Conversions

  • Rendering Text

  • Redirecting a Request

  • Creating a Model

  • Rendering a View

    • Finding the Default View

    • Selecting a Custom View

    • Rendering Templates

  • Performing Data Binding

  • Validating Incoming Data

    • The Errors API and Controllers

    • Data Binding to Multiple Domain Objects

    • Data Binding with the bindData Method

    • Data Binding and Associations

    • The Bindable Constraint

  • Working with Command Objects

    • Defining Command Objects

    • Using Command Objects

  • Imposing HTTP Method Restrictions

    • Implementing an Imperative Solution

    • Taking Advantage of a Declarative Syntax

  • Controller IO

    • Handling File Uploads

    • Working with Multipart Requests

    • Uploads and Data Binding

    • Reading the Request InputStream

    • Writing a Binary Response

  • Using Simple Interceptors

    • Before Advice

    • After Advice

  • Testing Controllers

  • Controllers in Action

    • Creating the gTunes Home Page

    • Adding the User Domain Class

    • Adding a Login Form

    • Implementing Registration

    • Testing the Registration Code

    • Allowing Users to Log In

    • Testing the Login Process

  • Summary

Chapter 5: Understanding Views

  • The Basics

  • Understanding the Model

  • Page Directives

  • Groovy Scriptlets

  • GSP As GStrings

  • Built-in Grails Tags

    • Setting Variables with Tags

    • Logical Tags

    • Iterative Tags

    • Filtering and Iteration

    • The collect Tag

    • The findAll Tag

  • Grails Dynamic Tags

  • Linking Tags

    • The Link Tag

    • The createLink and resource Tags

  • Creating Forms and Fields

    • The form Tag

    • The textField Tag

    • Check Boxes and Radio Buttons

    • Handling Lists of Values

    • Working with Dates

  • Simplifying Forms with the Fields Plug-in

  • Validation and Error Handling

    • The hasErrors Tag

    • The eachError Tag

  • Paginating Views

  • Rendering GSP Templates

  • Creating Custom Tags

    • Creating a Tag Library

    • Custom Tag Basics

    • Testing a Custom Tag

  • Summary

Chapter 6: Mapping URLs

  • Understanding the Default URL Mapping

  • Including Static Text in a URL Mapping

  • Removing the Controller and Action Names from the URL

  • Embedding Parameters in a Mapping

  • Specifying Additional Parameters

  • Mapping to a View

  • Applying Constraints to URL Mappings

  • Including Wildcards in a Mapping

  • Mapping to HTTP Request Methods

  • Mapping HTTP Response Codes

  • Taking Advantage of Reverse URL Mapping

  • Named URL Mappings

  • Defining Multiple URL Mappings Classes

  • Testing URL Mappings

  • Summary

Chapter 7: Internationalization

  • Localizing Messages

  • Defining User Messages

  • Retrieving Message Values

  • Using URL Mappings for Internationalization

  • Using Parameterized Messages

  • Using java.text.MessageFormat

  • Using the message Tag for Parameterized Messages

  • Using Parameterized Messages for Validation

  • Using messageSource

  • Summary

Chapter 8: Ajax

  • Writing Ajax Code

  • Ajax in Action

  • Changing Your Ajax Provider

  • Asynchronous Form Submission

  • Fun with Ajax Remote Linking

  • Adding Effects and Animation

  • Ajax-Enabled Form Fields

  • A Note on Ajax and Performance

  • Summary

Chapter 9: GORM

  • Persistence Basics

  • Reading Objects

  • Listing, Sorting, and Counting

  • Saving, Updating, and Deleting

  • Associations

  • Relationship Management Methods

  • Transitive Persistence

  • Querying

    • Dynamic Finders

    • Criteria Queries

    • Querying Associations with Criteria

    • Querying with Projections

    • Detached Criteria Queries

      • Creating Detached Criteria Queries

      • Executing Detached Criteria Queries

      • Lazy Evaluation of Detached Criteria

    • Batch Updates and Deletes with Detached Criteria

    • Where Queries

      • Where Query Basics

      • Understanding Where Query Operators

      • Querying Associations with Where Queries

    • Subqueries and Functions

    • Query by Example

    • HQL and SQL

  • Pagination

  • Configuring GORM

    • SQL Logging

    • Specifying a Custom Dialect

    • Other Hibernate Properties

  • The Semantics of GORM

  • The Hibernate Session

    • Session Management and Flushing

    • Obtaining the Session

    • Automatic Session Flushing

  • Transactions in GORM

  • Detached Objects

    • The Persistence Life Cycle

    • Reattaching Detached Objects

    • Merging Changes

  • Performance Tuning GORM

    • Eager vs. Lazy Associations

    • Batch Fetching

    • Caching

      • The Second-Level Cache

      • Query Caching

  • Inheritance Strategies

  • Locking Strategies

  • Events Auto Time Stamping

  • Summary

Chapter 10: Services

  • Understanding Service Basics

  • Services and Dependency Injection

  • Services in Action

  • Defining a Service

  • Configuring Service Bean Properties

  • Caching Service Methods

  • Using a Service

  • Managing Transactions

  • Scoping Services

  • Testing Services

  • Exposing Services

  • Summary

Chapter 11: Integration and Dependency Management

  • Grails and Configuration

    • Configuration Basics

    • Environment-Specific Configuration

    • Configuring Logging

    • Stack Trace Filtering

    • Externalized Configuration

  • Declaring Dependencies

  • Inheriting Dependencies

  • Declaring Repositories

  • Understanding the Grails Build System

  • Creating Gant Scripts

    • Command-Line Variables

    • Parsing Command-Line Arguments

    • Documenting Your Scripts

  • Reusing More of Grails

  • Bootstrapping Grails from the Command Line

  • Gant in Action

  • Automated Deployment to Tomcat

  • Exporting Data to XML

  • Continuous Integration with Hudson

  • Adding Support to Your Favorite IDE

  • Using The Groovy/Grails Tool Suite (GGTS)

    • Configuring Grails Installations

    • Importing a Grails Project

    • Running a Grails Application from GGTS

  • Using Spring Tool Suite (STS) and Eclipse

  • IntelliJ IDEA

  • NetBeans

  • Text Editors

  • Remote Debugging with an IDE

  • Integration with E-mail Servers

  • Deployment

    • Deploying with Grails

    • Deploying to a Container

  • Application Versioning and Metadata

  • Customizing the WAR

  • Populating the Database with BootStrap Classes

  • Summary

Chapter 12: Plug-ins

  • Plug-in Basics

  • Plug-in Discovery

  • Plug-in Installation

  • Local Plug-ins

  • Creating Plug-ins

    • Providing Plug-in Metadata

    • Supplying Application Artefacts

    • Plug-in Hooks

    • Plug-in Variables

    • Custom Artefact Types

    • Providing Spring Beans

    • Dynamic Spring Beans Using Conventions

    • Using Metaprogramming to Enhance Behavior

    • Plug-in Events and Application Reloading

    • Modifying the Generated WAR Descriptor

  • Packaging and Distributing a Grails Plug-in

  • Local Plug-in Repositories

  • Plug-ins in Action

    • Adding Behavior With Plug-ins

    • Specifying Plug-in Locations on the File System

    • Plug-ins for Application Modularity

    • Using the Resources Plug-in

    • Using the Database Migration Plug-in

People also search for The Definitive Guide to Grails 1st:

    
the definitive guide to guilt
    
the definitive guide to grails 2 pdf
    
the definitive guide
    
the definitive guide to futures trading pdf
    
the definitive guide to transportation

Tags: Graeme Rocher, Grails, Definitive Guide