Grails is a popular web application framework built on top of the Java Virtual Machine (JVM). It provides a simplified and efficient way to develop web applications using the Groovy programming language. One of the key features of Grails is its seamless integration with databases, making it easier for developers to work with data in their applications.
In this article, we will explore how to access two databases in Grails. This can be a useful feature for applications that need to store data in multiple databases, or for applications that need to integrate data from different sources.
To start, let's create a simple Grails application. We will call it "TwoDBApp" and use the Grails command line tool to generate the project structure. Open your terminal or command prompt and navigate to the directory where you want to create the project. Then, type the following command:
```
grails create-app TwoDBApp
```
This will create a new Grails project with the name "TwoDBApp". Next, we need to add our two databases to the project. Grails supports a variety of databases, including MySQL, PostgreSQL, and MongoDB. For this article, we will use MySQL and PostgreSQL as our two databases.
To add MySQL support to our project, we need to modify the "build.gradle" file in the project's root directory. We will add the MySQL dependency under the "dependencies" section:
```
dependencies {
...
runtime 'mysql:mysql-connector-java:8.0.26'
}
```
Next, we need to configure the database connection in the "application.yml" file located in the "grails-app/conf" directory. In the "dataSource" section, we will add the following properties:
```
dataSource:
pooled: true
jmxExport: true
driverClassName: "com.mysql.cj.jdbc.Driver"
dialect: org.hibernate.dialect.MySQL8Dialect
username: <YOUR_DATABASE_USERNAME>
password: <YOUR_DATABASE_PASSWORD>
url: "jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC"
```
Replace the <YOUR_DATABASE_USERNAME> and <YOUR_DATABASE_PASSWORD> placeholders with your own database credentials. We also need to create a new database called "db1" in MySQL.
Similarly, to add PostgreSQL support, we need to add the PostgreSQL dependency to the "build.gradle" file:
```
dependencies {
...
runtime 'org.postgresql:postgresql:42.2.24'
}
```
Then, in the "dataSource" section of the "application.yml" file, we will add the following properties:
```
dataSource:
pooled: true
jmxExport: true
driverClassName: "org.postgresql.Driver"
dialect: org.hibernate.dialect.PostgreSQL10Dialect
username: <YOUR_DATABASE_USERNAME>
password: <YOUR_DATABASE_PASSWORD>
url: "jdbc:postgresql://localhost:5432/db2"
```
Again, replace the placeholders with your own database credentials. We also need to create a new database called "db2" in PostgreSQL.
Now, we have our two databases set up and configured in our Grails project. The next step is to create domain classes for each database. In Grails, domain classes serve as the mapping between the application and the database tables.
Let's create a "Book" domain class for the "db1" database. In the Grails command line tool, type the following command:
```
grails create-domain-class Book
```
This will create a new domain class in the "grails-app/domain" directory. Open the "Book.groovy" file and add the following code:
```groovy
package twodbapp
class Book {
String title
String author
String genre
static constraints = {
title blank: false
author blank: false
genre blank: false
}
}
```
Similarly, create a "User" domain class for the "db2" database:
```
grails create-domain-class User
```
In the "User.groovy" file, add the following code:
```groovy
package twodbapp
class User {
String firstName
String lastName
String email
static constraints = {
firstName blank: false
lastName blank: false
email blank: false, email: true
}
}
```
We have now defined our domain classes for each database. The next step is to create controllers and views to interact with the data. We will create a "BookController" and a "UserController" using the Grails command line tool:
