index-1-1.jpg
  • Aurora Solutions

GORM Feature of Grails

This article will explain Grails Object Relational Mapping feature and Grails relationship mapping such as one-to-one, one-to-many, many –to-many.


Grails is known as domain driven language that means we can build application using bottom to top approach which is more nearer to object oriented programming. GORM uses internal Hibernate to map the domain class with table which gives life to Domain modeling. If we combined everything just only based on domain we could build the whole web application. Scaffolding can bring domain design directly to visible state to users.


But keep in mind Grails is an agile development framework. That means we build application quickly, deploy and run in one shot and make changes at any layer without impacting other parts such UI, domain modeling, service classes etc.


Create Domain Class


Grails domain classes are the most important of the application.This is like the root of application which lets us visualize the whole application. We can use it as entity object for mapping to database.

 

package firstapp.domain.com.User class User { long userId String userName String password } We don't need to worry about setter and getter methods as Grails dynamically generates them. By default, all the fields in a domain class are persisted to the database. The User class contains two fields’ username and password which will map to table User with column name username and password. GORM provides following dynamic methods to access database without exploring the PL/SQL directly

 

User.save() //saves the data to the User table in the database.

User.delete() //deletes the data from the User table.

User.list() //returns a list of Users.

User.get() //returns a single User .


Relationship


Grails gives flexibility to make various combination of mapping such as one-to-one, one-to-many, many-to-many.

It uses belongsTo for unidirectional and hasMany and direct reference for bidirectional. hasMany also uses for many relationship. In subsequent topic we will discuss in detail uses of these properties.


One-to-one relationships


One-to-one relationships could be unidirectional or bidirectional with single valued reference. For example User has single address and each address belongs to only one user. Following figure illustrates that a one-to-one relationship between user and his address.


Figure Assigning one-to-one on entities


For defining relationship between user and address first we will create domain class as follows


We will start creating


In below example belongsTo field inform GORM that Book has a relationship to Author and eligible for cascade, so if any Author deleted, the matching Book will also be deleted. We can define One-to-one relationship unidirectional or bidirectional by defining belongsTo on Address object and adding Address reference on User (owner) object.

 

package com.onetoone.domain class Book { Long id String bookName String bookDesc static belongsTo=Author //Book belong to Author } One-to-many Relationship One-to-many relationship occurs when one object has a multivalued relationship with another object. For example one-to-many relationship exists between employee and department. Below figure depicts that a department can have many employees, but that each individual employee can work for only one department Figure : Assigning one-to-many on entities


Grails introduces hasMany and belongsTo properties to establish one-to-many relationship. For e.g. hasMany need to define on Department domain and belongsTo need to define on Employee domain class as follows: package com.onetomany.domain

 

class Department {

long id

String departmentName

static hasMany=[employees:Employee]

}

package com.onetomany.domain

class Employee {

long id

String employeeName

String emailId

String phone

static belongsTo=Department

}


Many-to-many relationship


If two objects are in a many-to-many relationship, they will both have a hasMany

clause pointing to the other object.

Lets do Modeling a Post that can have many Tags

 

class Post { String content Date dateCreated static constraints = { content(blank: false) } static mapping = { sort dateCreated:"desc" } static hasMany = [ tags : Tag ] } This will model post with many tags.

 

class Tag {

String name

static constraints = {

name(blank: false)

}

static hasMany = [ posts : Post ]

static belongsTo = [ Post ]

}


We can see the hasMany relationship that is linking back to the Post

object.

Conclusion


Domain is the heart of Grail based development which map domain as entity to database table without configuration or annotation .

0 views0 comments

Recent Posts

See All

Grails & reCAPTCHA

What is reCAPTCHA? reCAPTCHA is a powerful service to detect against spam & abuse and can very easily help your distinguish between an actual site visitor or a bot. reCAPTCHA is a free service provide

Grails: Validating Domain Object

In this series of articles I am going to talk about the validations or constraints that can be added to Grails domain objects so that any junk data should not get stored to the database and hence our

Domain Relationships in Grails

In this article I am going to talk about how associations between domain objects are used in Grails. Grails is known as domain driven language that means we can build application using bottom to top a