Key Points

1. Grails CRUD scaffolding and GORM is IBM i DFU on steroids - but more - any database, any Java runtime environment
2. Where it fits, Grails is the fastest way to build Web apps or microservices using the right templates
3. Grails generated apps provide a good starting point to understand how Web and REST microservices are built
4. Grails generates Spring Boot applications and REST services
5. Grails can build traditional MVC web apps or REST microservices using templates and generators
6. Grails can generate simple front-ends for REST microservices - Angular, React, Web
7. Grails profiles define which options an application or service will use
8. Grails uses Groovy - a Java superset and a dynamic JVM language
9. Grails v4x will use Groovy v3x when available in 2020
10. Groovy v3x will support latest Java versions ( Lamba expressions, modules etc )
11. I should look at running Grails REST service in Docker container similar to a Spring Boot REST service
12. Tracking Grails releases in Github ( milestones etc ) https://github.com/grails/grails-core/releases   

References

Key Concepts

Grails and Groovy resource links

Grails Training

grails v4x books - authors 4 days
http://docs.grails.org/latest/

https://www.djamware.com/post/5d385e00fd741853d22abf5c/building-crud-web-application-using-grails-4-and-mongodb-easily

grails mvc app using spring services - mode coding
https://www.baeldung.com/grails-mvc-application

https://www.google.com/search?client=firefox-b-1-d&q=grails+version+4+tutorials

Grails and Okta

https://developer.okta.com/blog/2018/04/19/okta-with-grails

Grails CRUD app with Okta

https://developer.okta.com/blog/2018/06/04/okta-with-grails-part2

Grails with Spring Security - default

https://www.slideshare.net/JesusPerezFranco/spring-security-5?from_action=save

Why use Grails & Groovy?

https://www.quora.com/Why-is-it-that-there-are-less-people-using-Groovy-and-Grails-for-web-development

I've used Spring + Hibernate for around 4 years. I've been using Grails for the last 2 years. Here's my take:

Grails is a high productivity framework, i.e. it has some features that make it easier to build typical web functionality. Some things are easier in grails:

* Building a Xml/Json REST API.
* Integrating with Spring Security
* Integrating with Less CSS or Coffeescript.
* Integrating with Quartz
* Creating scaffoldings for basic crud functionality

All these things are easier because of abstraction. Grails offers a simpler way by abstracting all these things which happen a lot in web apps.

However once you are using a higher level of abstraction, accessing the lower apis becomes slightly difficult. I don't say it is not possible. It is possible, and there is a lot of documentation on anything you want to do, but sometimes you end up wasting a lot of time debugging or researching for something that wouldn't have been so difficult in Spring/Java because of the Grails layer you must interact through.

The good news though, is that you write a lot less code, and that is definitely worth the difference, because code is read more than it is written.

Why don't more developers use Grails in 2023?

• not understanding it, not aware of it
• want to do more custom client js coding ( eg React / Redux etc vs GSP templates extended) which is justifiable for some front end apps
• don't know how to generate high performance Grails apps using GraalVM and compiled groovy
• don't know how to create custom Grails templates for different app & services profiles
• don't know how to generate apps from profiles for containers and Kubernetes in the cloud

Grails download & install

http://grails.org/download.html

Milestone releases are not available from the download site, email OCI directly.

You can find 4.1.0.M3 at

https://github.com/grails/grails-core/releases/tag/v4.1.0.M3.

Grails Application Forge

https://start.grails.org/

Manual Grails install

http://docs.grails.org/latest/guide/gettingStarted.html#downloadingAndInstalling

Set the GRAILS_HOME environment variable to the location where you extracted the zip

Grails beta versions 

Check for Grails versions released in Github here ( including milestones ) -  https://github.com/grails/grails-core/releases

For a given release / milestone - check the Github issues to see what's important that's still open - https://github.com/grails/grails-core/issues

https://github.com/grails/grails-core/releases/tag/v4.1.0.M1

http://docs.grails.org/4.1.0.M1/guide/introduction.html#whatsNew

install from Zip file

ensure GRAILS_HOME, GROOVY_HOME, JAVA_HOME are set

ensure any CLASSPATH and path updates are correct

to validate, run:

grails -version 

Grails docs on skwebteam

grails4-update-Slide_Deck_Introducing_Grails_4_Webinar.pdf

grails-181115-tutorial-guestbook-java-web-app-vogella.com-.pdf

gorm-basics-tutorial-relations-maps.pptx

grails-best-practices-web-profile-2016-MarProg_Grails_WP_Web.pdf

grails-web-mvc-tutorial-v4-mongodb-2019-vgood.pdf

grails-plugins.github.io-DB Reverse Engineering Plugin - Reference Documentation.pdf

Grails v4.0 Features

https://objectcomputing.com/products/grails/grails-roadmap

• Groovy 2.5
• GORM 7.0 (Hibernate 5.2 minimum, Java 8 baseline)
• Java 8 Baseline
• Java 11 Support
• Spring 5.1
• Spring Boot 2.1
• Micronaut Integration

Grails 5x Plans 

https://grails.org/blog/2021-01-22-grails-exciting-updates.html

A major highlight of this release is the update to Apache Groovy 3, which includes support for Java 15 and significant other improvements around static compilation. We have also upgraded to the latest stable releases of some third-party libraries, including:

• Apache Groovy 3, which offers several enhancements to the language, including GDK improvements, a new parrot parser – far more flexible than the previous versions – and a collection of other new features and capabilities.

• SpringBoot 2.4: This release adds a significant number of new features and improvements, such as improvements to the config file processing, a new startup actuator endpoint to help identify beans that are taking longer than expected to start, and an update to Spring Framework 5.3. For more information, check out SpringBoot 2.4 release notes.

• Gradle 6, which brings faster incremental Java and Groovy compilation, better version ordering, many bug fixes, and more. Refer to Gradle Release Notes for more information.

We will be focusing on improving the performance of the Grails application and user experience. In addition, we are planning a number of enhancements including:

• Making GSP more modular and independent of the Grails framework
• Transaction support in GORM for MongoDB
• Native support for web-sockets
• Continuously improving Grails documentation (especially around plugins, Micronaut configuration, HTTP Client, and other features)
• Better integration with Micronaut, such as declarative HTTP Client
• Better support for Kafka, including creating Kafka listeners through a plugin and more

Grails JAX-RS plugin documentation ( for Grails v3x )

http://budjb.github.io/grails-jaxrs/3.x/latest/guide/introduction.html

The jaxrs project is a set of Grails plugins that supports the development of RESTful web services based on the Java API for RESTful Web Services (JSR 311: JAX-RS).

It is targeted at developers who want to structure the web service layer of an application in a JSR 311 compatible way but still want to continue to use Grails' powerful features such as GORM, automated XML and JSON marshalling, Grails services, Grails filters and so on. This plugin is an alternative to Grails' built-in mechanism for implementing RESTful web services.

Features

• Makes the JSR 311 (JAX-RS) available to Grails applications for developing RESTful web services.
• New Grails artefact types, Resource and Provider, for JAX-RS classes.
• JAX-RS Resource classes under grails-app/resources are auto-detected and can be modified at runtime.
• JAX-RS Provider classes under grails-app/providers are auto-detected and can be modified at runtime.
• Extended Grails command line interface
• Create new resources and unit test templates via grails create-resource <resource name>.
• Generate ready-to-use resources from domain objects via grails generate-resources <domain class name>.
• Scaffolding
• Generate RESTful service interfaces for Grails domain objects.
• Content negotiation support for XML and JSON representations.
• Ability to use any Grails feature within JAX-RS resources and providers such as:
• GORM can be used for interacting with persistent domain objects.
• Grails filters for intercepting requests to JAX-RS resources. ( Deprecated )
• Grails services which can be auto-injected by name.
• Entity providers
• Domain object providers that convert between Grails domain objects and XML or JSON representations.
• Support classes for developing custom entity providers.
• Support for content negotiation based on the Accept request header.
• Easy integration testing of JAX-RS resources and providers.
• Plugin users may choose between Jersey and Restlet as JAX-RS implementations by means of configuration.
• jaxrs applications can be deployed to Google App Engine (GAE).

Tutorial Migrate React Node.js app to Grails backend

https://guides.grails.org/grails-vs-nodejs/guide/index.html

~ ./gradlew server:bootRun   //Windows users use "gradlew.bat"

//in a second terminal session
~ ./gradlew client:bootRun

GORM - Grails Object Relational Management

http://gorm.grails.org/6.1.x/hibernate/manual/#quickStartGuide

grails create-domain-class helloworld.Person

package helloworld

class Person {
}

class Person {
    String name
    Integer age
    Date lastVisit
}

grails console

import spock.lang.*
import grails.gorm.annotation.Entity
import grails.transaction.Rollback
import org.grails.orm.hibernate.HibernateDatastore
import org.springframework.transaction.PlatformTransactionManager

class ExampleSpec extends Specification {

    @Shared @AutoCleanup HibernateDatastore hibernateDatastore
    @Shared PlatformTransactionManager transactionManager

    void setupSpec() {
       hibernateDatastore = new HibernateDatastore(Person)
       transactionManager = hibernateDatastore.getTransactionManager()
    }

    @Rollback
    void "test execute GORM standalone in a unit test"() {
       // your logic here
    }
}

@Entity
class Person {
    ...
}

def p = new Person(name: "Fred", age: 40, lastVisit: new Date())
p.save()

def p = Person.get(1)
assert 1 == p.id

def p = Person.read(1)

def p = Person.load(1)

def p = Person.get(1)
p.name = "Bob"
p.save()

def p = Person.get(1)
p.delete()

GORM DB Reverse Engineering Plugin - no longer supported

https://grails-plugins.github.io/grails-db-reverse-engineer/grails3v4/index.html

Burt Beckwith

Grails DB reverse engineering plugin does not work after Grails 3.1 - 2017

https://groups.google.com/forum/#!topic/grails-dev-discuss/CNmd8BRuf28

DB Reverse Tutorial

https://grails-plugins.github.io/grails-db-reverse-engineer/grails3v4/index.html#tutorial

last version of  DB reverse engineering plugin

db-reverse-engineer-4.0.0-manual.pdf

early version of DB reverse engineering manual with books authors output classes

grails-db-reverse-engineering-plugin-v51-manual.pdf

Books and authors tables

create table author (   id bigint not  auto_increment  null,   version bigint not null,   name varchar(255) not null,  email varchar(255) null,  primary key (id)) ENGINE=InnoDB;

create table book (   id bigint not  auto_increment  null,   version bigint not null,   title varchar(255) not null,  type varchar(255), description varchar(2048),  sold bigint null,  primary key (id)) ENGINE=InnoDB;

create table author_books (   author_id bigint not null,   book_id bigint not null,   primary key (author_id, book_id)) ENGINE=InnoDB;

alter table author_books add index FKauthor_books_2_books (book_id), add constraint FKauthor_books_2_books foreign key (book_id) references book (id);

alter table author_books add index FKauthor_books_2_authors (author_id), add constraint FKauthor_books_2_authors foreign key (author_id) references author(id);

Books and authors output classes from DB plugin

class Author { 
String name
String email
String phone
static hasMany = [books: Book]
};


class Book { 
String title
String publisher
BigDecimal price
String description 
Integer quantitySold
static hasMany = [authors: Author]
static belongsTo = Author
};


class Author_Books { 
String name
String email
static hasMany = [books: Book]
};

Final version of Books and authors output classes

Example of DB Reverse Engineering Output

Yes GORM. The reverse engineering for Grails is a little simpler because all that is needed are Domain classes and the framework handles all the hibernate mappings. So for example a DB table called Application would only need a single Domain class instead of a Domain, DAO and XML Mapping file. Here is an example with one-to-many and many-to-one relationships

class Application {
BigDecimal gpa
Date submitDate
String appliedFlag
String acceptedFlag
String deniedFlag
String managerNetid
Date timeStamp
AcademicYear academicYear
Quarter quarter
Student student
Set<ApplicationFile> applicationFiles = []
Set<ApplicationQa> applicationQas = []
Set<ApplicationAccepted> applicationAccepteds = []
Set<ApplicationDenied> applicationDenieds = []
 
static hasMany = [applicationAccepteds: ApplicationAccepted,
                  applicationDenieds: ApplicationDenied,
                  applicationFiles: ApplicationFile,
                  applicationQas: ApplicationQa]
 
static belongsTo = [AcademicYear, Quarter, Student]
 
static mapping = {
version false
quarter column: "quarter_code"
student column: "sid"
applicationAccepteds cascade: "save-update, delete-orphan"
applicationDenieds cascade: "save-update, delete-orphan"
applicationQas cascade: "save-update"
}
 
static constraints = {
submitDate nullable: true
appliedFlag maxSize: 1
acceptedFlag maxSize: 1
deniedFlag maxSize: 1
managerNetid nullable: true, maxSize: 36
}
}

$ mn create-app my-kafka-app --features kafka

$ mn create-messaging-app my-kafka-app --features kafka

import io.micronaut.configuration.kafka.annotation.KafkaClient;
import io.micronaut.configuration.kafka.annotation.KafkaKey;
import io.micronaut.configuration.kafka.annotation.Topic;

@KafkaClient 
public interface ProductClient{

    @Topic("my-products") 
    void sendProduct(@KafkaKey String brand, String name); 

    void sendProduct(@Topic String topic, @KafkaKey String brand, String name); 
}

ProductClient client = applicationContext.getBean(ProductClient.class); client.sendProduct("Nike", "Blue Trainers");

go get -u github.com/jinzhu/gorm

package main

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
  gorm.Model
  Code string
  Price uint
}

func main() {
  db, err := gorm.Open("sqlite3", "test.db")
  if err != nil {
    panic("failed to connect database")
  }
  defer db.Close()

  // Migrate the schema
  db.AutoMigrate(&Product{})

  // Create
  db.Create(&Product{Code: "L1212", Price: 1000})

  // Read
  var product Product
  db.First(&product, 1) // find product with id 1
  db.First(&product, "code = ?", "L1212") // find product with code l1212

  // Update - update product's price to 2000
  db.Model(&product).Update("Price", 2000)

  // Delete - delete product
  db.Delete(&product)
}