Introducción a Grails 3 y GORM

Programación
Top de persistencia

Acabo de anunciar el nuevo curso Learn Spring , centrado en los fundamentos de Spring 5 y Spring Boot 2:

>> VER EL CURSO

1. Información general

Esta es una introducción rápida a Grails 3 y GORM.

Por supuesto, usaremos Groovy e, implícitamente, el marco también hace uso de Hibernate para ORM, Spring Framework para inyección de dependencia, SiteMash para diseño y temas, etc.

2. Configuración de la fuente de datos

Podemos comenzar sin tener que especificar ninguna configuración de fuente de datos explícita; por defecto, Grails usa la base de datos HSQLDB para los entornos de desarrollo y prueba.

Pero si desea cambiar estos valores predeterminados, puede definir su fuente de datos seleccionada en application.yml :

environments: development: dataSource: driverClassName : "com.mysql.jdbc.Driver" url : "jdbc:mysql://localhost:8080/test" dialect : org.hibernate.dialect.MySQL5InnoDBDialect

Del mismo modo, podemos crear varios entornos aquí, junto al desarrollo si es necesario.

3. Dominio

Grails es capaz de crear la estructura de la base de datos para nuestras clases de dominio, basándose en la propiedad dbCreate en la configuración de la base de datos.

Definamos una de estas clases de dominio aquí:

Class User { String userName String password String email String age static constraints = { userName blank: false, unique: true password size: 5..10, blank: false email email: true, blank: true } }

Tenga en cuenta cómo estamos especificando nuestras restricciones de validación directamente en el modelo , lo que mantiene las cosas bien, limpias y sin anotaciones.

Grails comprobará estas restricciones automáticamente cuando se persista la entidad y el marco arrojará las excepciones de validación adecuadas si se rompe alguna de estas restricciones.

También podemos especificar asignaciones GORM en la propiedad de asignación del modelo:

static mapping = { sort "userName" }

Ahora, si llamamos a User.list () , obtendremos los resultados ordenados por nombre de usuario .

Por supuesto, podríamos lograr el mismo resultado pasando el tipo a la API de lista:

User.list(sort: "userName")

4. Operaciones CRUD

Cuando miramos las operaciones de API, el andamiaje juega un papel muy interesante al principio; le permite generar una API CRUD básica para una clase de dominio, que incluye:

  • Las vistas necesarias
  • Acciones del controlador para las operaciones CRUD estándar
  • Dos tipos: dinámico y estático

Así es como funciona con andamios dinámicos:

class UserController { static scaffold = true }

Con solo escribir esta única línea, el marco generará 7 métodos en tiempo de ejecución: mostrar, editar, eliminar, crear, guardar y actualizar. Estos se publicarán como API para esa entidad de dominio en particular.

Ejemplo de andamio estático:

  • Para crear una vista con andamios, use: " Grails generate-views User "
  • Para crear el controlador y la vista con andamio, use: " Grails generate-controller User "
  • Para crear todo en un solo comando, use: " Grails generate-all User "

Estos comandos generarán automáticamente la plomería necesaria para ese objeto de dominio en particular.

Echemos ahora un vistazo rápido al uso de estas operaciones, por ejemplo, para nuestro objeto de dominio de usuario .

Para crear un nuevo registro de "usuario" :

def user = new User(username: "test", password: "test123", email: "[email protected]", age: 14) user.save()

Para buscar un solo registro :

def user = User.get(1)

Esta API de obtención recuperará el objeto de dominio en un modo editable. Para un modo de solo lectura, podemos usar la API de lectura :

def user = User.read(1)

Para actualizar el registro existente :

def user = User.get(1) user.userName = "testUpdate" user.age = 20 user.save()

Y una simple operación de eliminación para un registro existente:

def user = User.get(1) user.delete()

5. Consultas GORM

5.1. encontrar

Comencemos con la API de búsqueda :

def user = User.find("from User as u where u.username = 'test' ")

También podemos usar una sintaxis diferente para pasar el parámetro:

def user = User.find("from User as u where u.username?", ['test'])

También podemos usar un parámetro con nombre:

def user = User.find("from User as u where u.username=?", [username: 'test'])

5.2. findBy

Grails proporciona una función de búsqueda dinámica que utiliza propiedades de dominio para ejecutar una consulta en tiempo de ejecución y devolver el primer registro coincidente:

def user = User.findByUsername("test") user = User.findByUsernameAndAge("test", 20) user = User.findByUsernameLike("tes") user = User.findByUsernameAndAgeNotEquals("test", "100")

Puedes encontrar más expresiones aquí.

5.3. Criterios

También podemos recuperar datos utilizando algunos criterios flexibles:

def user = User.find { username == "test"} def user = User.createCriteria() def results = user.list { like ("userName", "te%") and { between("age", 10, 20) } order("userName", "desc") }

Una nota rápida aquí: cuando utilice una consulta de criterios, utilice "{}" en lugar de "()".

5.4. Ejecutar consulta / actualización

GORM también admite la sintaxis de consulta HQL, para operaciones de lectura:

def user = User.executeQuery( "select u.userName from User u where u.userName = ?", ['test'])

Además de las operaciones de escritura: 

def user = User.executeUpdate("delete User u where u.username =?", ['test'])

6. Conclusion

This has been a very quick intro to Grails and GORM – to be used as a guide to getting started with the framework.

Persistence bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE