This document provides a tutorial for connecting a Grails application to a MySQL database and performing basic CRUD operations. It describes creating databases in MySQL, generating a Grails application, configuring the data source properties to connect to MySQL, generating a domain class and controller with scaffolding, and verifying the application works by interacting with the database. The tutorial shows how to set up the development and production environments to use different databases.

1. Grails Tutorial
Connecting to MySql

2. Part 1
Creating database in MySql

3. • By default, Grails applications are configured to
use an in-memory HSQLDB database for
development and testing
• Now we will create application to store student
information in database.
• Create 2 new databases that will be used by our
application
• create database student_registration;
• create database student_registration_prod;

4. Part 2
Create Application in Grails

5. • After creating the database, the next thing to do is
to create a new application.
• grails create-app student-registraion
• After creating the application, the next step is to
setup the its dependencies. There are two ways of
setting up the application to use MySQL database,
However, I prefer this way since it is much easier.
•Inside the file BuildConfig.groovy file under grails-
app/conf, find and uncomment the line which says:
• //runtime 'mysql:mysql-connector-java:5.1.16'
• As of this writing, the latest versioin of the JDBC is
5.1.18, so update accordingly.

6. • You also need to uncomment maven repository if it is
commented (mavenCentral())
• Note : if application failed to start, then add mysql-
connector-java-5.1.18-bin.jar in lib directory
• Now we are ready to add database details. We need
to Update DataSource.groovy file under grails-
app/conf.
dataSource {
pooled = true
driverClassName = "com.mysql.jdbc.Driver"
dialect =
"org.hibernate.dialect.MySQL5InnoDBDialect"
}

7. • We need to change the driverClassName to point to
the proper class.
• Also, since we are using the InnoDB engine, we will be
setting the dialect
dialect =
"org.hibernate.dialect.MySQL5InnoDBDialect"
• Note : If application failed to start bcoz of database
credentials add the 2 entries after dialect
• username=“username”
• password=“password”

8. • Next step just shows you how to configure
environment variable for database
• Let us use the two databases we created a while ago.
• For development & test environment, let us use the
student_registration database. On the other hand, for
the production environment, let us use the
student_registration_prod database.

9. For Development & Test use same datasource
development {
dataSource {
dbCreate = "create-drop"
url =
"jdbc:mysql://localhost/student_registration?
useUnicode=yes&characterEncoding=UTF-8"
username = "root“
password = ""
}
}
• Note for dbCreate read next slide

10. For Production use same datasource
production {
dataSource {
dbCreate = “update"
url =
"jdbc:mysql://localhost/student_registration?
useUnicode=yes&characterEncoding=UTF-8"
username = "root“
password = ""
}
}

11. dbCreate
•dbCreate deserves a special mention, It determines
what happens to your database between server
restarts.
• For example, a value of create-drop means that the
database tables will be dropped and then recreated
when you start the server, so you lose any data that
was in there. This is fine for testing, but is definitely
not what you want in production

12. Part 3
Create Domain class,Controller &
Views

13. •The next step is to create a domain class that will be
persisted later in our database. Let’s create a sample
domain class.
• create-domain-class com.reg.Student
• Now update the Student.groovy file in domain dir
class Student {
String studentID
String firstName
String middleName
String lastName
Integer year
static constraints = { }
}

14. •The next step is to create a controller class
• create-controller com.reg.Student
• Update the file StudentController.groovy under
grails-app/controller/com.reg/.
• Inside the controller, we will define a scaffold which
will automatically create the CRUD (Create, Read,
Update, Delete) functionality for our domain class
class StudentController {
def scaffold = Student
def index() { }
}

15. •The next step is to generate a view for Student
• generate-views com.reg.Student
• There is no need to change in view (.gsp) pages. The
grails automatically creates all CRUD
(Create,Read,Update,Delete) functionality for you.
• You just need to care about the url mapping for all.
After running your application if your controller id
redirected to “index” then write “create” instead of
“index”.
• I don’t know where is url mapping configured in grails,
that’s why I use this to redirect the pages.

16. • Now its time to start your grails student-registration
application
• grails run-app
• If your application starts without any errors, use the
url printed on console to access your app.
• Now connect to your student_registration database in
mysql
• connect student_registration;
• Now you notice that new table student is created.
• desc student;

17. • Now access the url and check all CRUD
(Create,Read,Update,Delete) functionality is working or
not.
• http://localhost:8080/student-
registraion/student/create
• Check the database values after each create,update &
delete.

18. Thank you
• I am not expert in grails, but if you have any doubts in
tutorial please feel free to contact me on
ashishkirpan@gmail.com
• Sorry for grammar mistakes :)