“Gradle es construcción automatizada evolucionada. Gradle puede automatizar la construcción, pruebas, publicación, despliegue y muchos más paquetes de software u otros tipos de proyectos tales que generen sitios estáticos, generar documentación o realmente cualquier otra cosa.

Gradle combina el poder y la flexibilidad de Ant con el administrador de dependencias y convenciones de Maven en una manera más efectiva para construir. Definido por un DSL Groovy y empaquetado con innovación, Gradle provee una forma declarativa para describir todo tipo de builds a través de defaults sensnibles. Gradle está rapidamente llegando a ser el sistema de construcción elegido por muchos proyectos open source.”

Además comentamos cosas como Maven, Ant y GAnt, pero sobre todo compartimos nuestras experiencias con el uso de Gradle.

Hablamos un poco de Selenium y PhantomJS para pruebas funcionales en casos en los que externamos la fase de pruebas.

Algunos libros de referencia de Gradle:

http://www.gradle.org/books

En fin, hablamos de varias cosas, esperamos que les sirva tanto como a nosotros.

Suscríbete al feed en http://podcast.springhispano.org/grails.xml

O bien descargalo en directo desde:

http://s3.amazonaws.com/media.grails.org.mx/podcast/temporada02/02×04.mp3

Muchas gracias por escucharnos !!!!

Hace poco tuve la oportunidad de impartir un curso de Grails, en donde vimos como uno de los últimos temas la integración con algunos beans de Spring que no vienen en el Application Context. Y uno de los asistentes tuvo una buena duda al respecto de integrar algunos beans adicionales, realmente la pregunta fue:

Buen día JJ

Primero que nada agradecer el obsequio del curso, el cual por cierto me pareció excelente. En segundo lugar me gustaría hacerte una consulta, en el caso de no desear utilizar Hibernate para la persistencia y en cambio utilizar JDBCTemplate de Spring me quedó claro que es posible sin ningún problema, pero en el ejemplo que nos mostraste la inyección del jdbcTemplate se realizó directo en el Controller, mi pregunta es si se puede estructurar de una manera diferente, es decir, crear un paquete diferente en el que se encuentren las clases de Acceso a Datos (DAO’s) y ahi inyectar el jdbcTemplate y realizar la persistencia. Si es así en que parte de la estructura del proyecto se crearía dicho paquete, en grails-app al nivel del paquete de services??? o en la carpeta de src/groovy??? así mismo quisiera saber si la inyección de la clase DAO en el service se realiza de la misma forma que se inyecta un Servicie en el Controller???

Muchas gracias por tu ayuda de antemano.

Saludos

OVP

Si bien, pude escribir un correo contestando exclusivamente, decidí hacerlo públic a través de un Hangout y aquí les dejo la grabación, dura alrededor de 20 minutos y puede que les sirva.

Saludos

Escúchalo en directo en SoundCloud:

En esta ocasión los hosts Tomas Lin, Domingo Suárez y José Juan Reyes nos pusimos a platicar acerca de micro frameworks en Groovy. Intercambiando las experiencias que hemos tenido en su uso y experimentación, además de algunos comentarios enriquecedores acerca de herramientas relacionadas.

Los micro-frameworks:

Dropwizard - http://dropwizard.codahale.com/manual/

Ratpack - https://github.com/ratpack/ratpack

Gaelyk - http://gaelyk.appspot.com/

Caelyf - http://caelyf.cloudfoundry.com/

Vert.x - http://vertx.io/

Vert.x Go - https://github.com/sebastienblanc/vertxgo

La pasamos muy bien platicando  y planeando nuestra siguiente entrega del podcast.

Suscríbete al feed en http://podcast.springhispano.org/grails.xml

O bien descargalo en directo desde:

http://s3.amazonaws.com/media.grails.org.mx/podcast/temporada02/02×03.mp3

Muchas gracias por escucharnos !!!!

Nos da gusto entregarles la última grabación del podcast, en donde tenemos un nuevo Host: Tomás Lín desde Londres.

La charla se ha vuelto más interesante, pues en esta ocasión estuvimos hablando principalmente de :

• Las nuevas características de Grails 2
• El roadmap hacia grails 3
• El diseño de Single Page Interface con Grails y algunos frameworks Javascript

Además, nos ayudamos de algunas ligas que complementan la charla:

• http://sebastien-arbogast.com/2013/02/14/top-5-reasons-why-you-should-consider-groovy-and-grails-for-your-enterprise-software-architecture-right-now/
• http://grails.io/post/40093552028/road-to-grails-2-3-improved-dependency-resolution
• http://ofps.oreilly.com/titles/9781449323936/chapter_upgrading.html

Los vídeos comentados:

• http://skillsmatter.com/podcast/groovy-grails/grails-for-hipsters
• http://www.youtube.com/watch?v=K-Y2pZOU1yQ
• http://www.objectpartners.com/2013/01/24/presentation-grails-rest-with-client-side-javascript/
• http://www.youtube.com/watch?v=coKtdouoOBA

Mucho contenido muy interesante resumido en esta charla.

De antemano agradecemos la participación de Tomás y como lo comentamos, nos gustaría tenerlo más seguido como nuestro Host.

Suscríbete al feed en http://podcast.springhispano.org/grails.xml

O bien descargalo en directo desde:

http://s3.amazonaws.com/media.grails.org.mx/podcast/temporada02/02×02.mp3

Que disfruten del podcast,  tanto o más como nosotros al grabarlo…

La referencia a alguno de los temas que platicamos la pueden encontrar en :

• http://groovy.codehaus.org/Groovy+2.0+release+notes
• http://groovy.codehaus.org/Groovy+2.1+release+notes

Suscríbete al feed en http://podcast.springhispano.org/grails.xml

O bien descargalo en directo desde:

http://s3.amazonaws.com/media.grails.org.mx/podcast/temporada02/02×01.mp3

Que lo disfruten como nosotros

Es por esto que queremos anunciarles el podcast de la temporada 2, el episodio número 0, en donde hablamos un poco de la historia del podcast, y de las tecnologías, de su evolución y de algunos eventos a los que hemos asistido o bien hemos seguido a través de twitter.

Las ligas de los sitios aquí:

• Grails eXchange – Agenda y videos en cada una de los detalles
• http://skillsmatter.com/event/groovy-grails/groovy-grails-exchange-2012
• TechMesh 2012
• http://techmeshconf.com/
• SpringIO 2012
• http://grails.org.mx/2012/03/08/resumen-del-springio-2012/
• Greach
• http://greach.es/

Suscríbete al feed en http://podcast.springhispano.org/grails.xml

O bien descargalo en directo desde:

http://s3.amazonaws.com/media.grails.org.mx/podcast/temporada02/02×00.mp3

Que lo disfruten como nosotros

Por ejemplo supongamos que tenemos la siguiente estructura de clases de dominio:

class Autor {
  String nombre
  String apellidoPaterno

  static hasMany = [libros : Libro]

  static constraints = {}
}

class Libro {
  String nombre
  String editorial

  static belongsTo = [autor : Autor]

  static constraints = {}
}

Ahora añadimos un par de datos, por ejemplo :

Stephen King, Doubleday The Shinning
Paolini Christopher, Alfred A. Knopf Eragon

Una vez realizada esta acción procedemos a añadir el plugin de searchable y le añadimos a nuestros dominios lo siguiente para que el plugin haga su trabajo :

class Autor {
  static searchable = true
 // Más Código
}

class Libro {
  static searchable = true
 // Más Código
}

Ahora levantamos la aplicación y accedemos a la siguiente URL

http://localhost:8080/EL-NOMBRE-DE-TU-APP/searchable

Una vez en ese link buscamos alguna palabra y todo lo relacionado a ello nos aparecerá ahí.

Hasta este momento todo va “viento en popa” pero de momento nos damos cuenta que al Autor le hace falta la nacionalidad y procedemos a añadirla:

class Autor {
  // Código
  String nacionalidad
  //Más código
}

Procedemos a reinicar la app para que tome los cambios y esperamos a que la aplicación levante…
Después de unos momentos de correr la app de nuevo nos aparece un mensaje de error

ERROR org.hibernate.util.JDBCExceptionReporter:234  Unknown column 'this_.nacionalidad' in 'field list'
ERROR org.compass.gps.device.hibernate.indexer.ScrollableHibernateIndexEntitiesIndexer:213  {hibernate}: Failed to index the database

Hasta este punto la BD tiene razón ya que no hemos realizado un dbm-update de los cambios realizados en BD así que procedemos a realizarlo. Para esto primero generamos la diferencia y después el update

dbm-gorm-diff anadiendo-columna-nacionalidad.groovy --add

Pero para nuestra mala suerte sigue saliendo el mismo error de que no conoce la columna “nacionalidad”.

Bueno el problema de este error surge de que primero se ejecuta el “indexado” del plugin de searchable antes de ejecutar el dbm-update o el dbm-gorm-diff
Para corregir este pequeño problema tenemos de dos :

1.- Añadir el dbCreate en el dataSource para que ejecute el update (cosa que no es recomendable ya que de ello se encarga el plugin de database migration)

2.- Habilitar el indexado de datos bajo demanda (Elegiremos esta opción)

Bueno para ello primero debemos añadir la siguiente configuración en nuestro Config.groovy para deshabilitar el indexado al inicio

searchable {
  bulkIndexOnStartup = false
}

Hasta este punto ya podemos ejecutar la aplicación y hacer lo que veniamos haciendo vamos a realizar el gorm-diff que nos resultó fallido en un paso anterior pero primero realizamos un grails clean

dbm-gorm-diff anadiendo-columna-nacionalidad.groovy --add

Como veremos ya se puede ejecutar y si lanzamos el dbm-update o levantamos la aplicación veremos el campo nacionalidad en el scaffold del Autor.

Ahora por no dejar vamos a eliminar la carpeta searchable-index que se encuentra en ~/.grails/projects/NOMBRE-DE-TU-APP/ para comprobar que en realidad esté haciendo lo que debería hacer. Una vez que reinicio la app vamos al apartado de searchable y buscamos por alguno de los datos que tengamos en nuestra BD.

Al realizar esto veremos que no nos regresa nada, se preguntarán ¿porque si ya funcionaba? Esto se debe a que el indexado que antes se ejecutaba al inicio ya ahora no se ejecuta y hay que lanzarlo manualmente y para realizar esto hacemos uso del Bootstrap para ello le inyectamos el servicio de searchable y ejecutamos el método index de la siguiente manera:

class BootStrap {
  def searchableService

  def init = { servletContext ->
    searchableService.index()
  }

  def destroy = {}
}

Bueno si han seguido hasta este punto los Post escritos en este lugar se deben de acordar del viejo amigo Bootstrap y que es lo que hace, sino les recomiendo que les den una leida a la mayor parte de ellos .

Una vez hecho esto si regresamos al apartado de búsqueda y realizamos alguna veremos resultados en nuestra app.

De esta manera hacemos la integración de dos plugins bastante interesantes y que nos pueden ayudar en nuestras aplicaciones. Espero este post les evite algunos dolores de cabeza.

Felices fiestas y nos veremos en otro post.
Saludos

Supongamos que al iniciar nuestra aplicación queremos que cargue a un determinado grupo de usuarios de prueba para usarlos con Spring Security o que queremos cargar un catálogo de categoría de libros ( ) Para realizar eso ubicamos en el archivo el closure de init y ahí procedemos a hacer lo siguiente :

class BootStrap {
    def init = { servletContext
        new Categoria( categoria : "Programación" ).save()
        new Categoria( categoria : "Historia" ).save()
    }
    def destroy = {
    }
}

Incluso en esta parte podemos hacer uso de los environments por ejemplo si queremos que unos usuarios se carguen al inicio de la aplicación pero sólo para el ambiente de desarrollo podemos hacer lo siguiente :

class BootStrap {
    def init = { servletContext
        switch(Environment.current){
        case Environment.DEVELOPMENT :
            new Usuario( username : "usuario", password : "12345678" ).save()
            new Usuario( username : "usuario2", password : "12345678" ).save()
        break
        case Environment.TEST :
        break
        case Environment.PRODUCTION :
        break
        }
    }
    def destroy = {
    }
}

Bueno con esto terminaremos esto nos vemos en el siguiente post.

En este post veremos un caso un poco más complejo, esto es, que pasa cuando ya tengo datos en la base y quiero realizar un cambio que borre una columna pero pasar esa información a otra columna en otra tabla, i.e. Tenemos la tabla Autor y la tabla Libro, la primera está compuesta de la siguiente manera:

class Autor {
    String nombre
    String apellidoPaterno
    static hasMany = [libros : Libro]
}

Y la tabla Libro :

class Libro{
    String titulo
    Integer numeroDePaginas
    static belongsTo = [autor : Autor]
}

Y como de momento esto nos sirve le generamos su changelog

    dbm-generate-gorm-changelog changelog.groovy

Que nos genera lo siguiente :

databaseChangeLog = {
    changeSet(author: "sohjiro (generated)", id: "1352952268429-1") {
           createTable(tableName: "autor") {
                column(autoIncrement: "true", name: "id", type: "bigint") {
                constraints(nullable: "false", primaryKey: "true", primaryKeyName: "autorPK")
            }
            column(name: "version", type: "bigint") {
                constraints(nullable: "false")
            }
            column(name: "apellido_paterno", type: "varchar(255)") {
                constraints(nullable: "false")
            }
            column(name: "nombre", type: "varchar(255)") {
                constraints(nullable: "false")
            }
        }
    }
    changeSet(author: "sohjiro (generated)", id: "1352952268429-2") {
        createTable(tableName: "libro") {
           column(autoIncrement: "true", name: "id", type: "bigint") {
                constraints(nullable: "false", primaryKey: "true", primaryKeyName: "libroPK")
            }
            column(name: "version", type: "bigint") {
                constraints(nullable: "false")
            }
            column(name: "autor_id", type: "bigint") {
                constraints(nullable: "false")
            }
            column(name: "numero_de_paginas", type: "integer") {
                constraints(nullable: "false")
            }
            column(name: "titulo", type: "varchar(255)") {
                constraints(nullable: "false")
            }
        }
    }
    changeSet(author: "sohjiro (generated)", id: "1352952268429-3") {
        addForeignKeyConstraint(baseColumnNames: "autor_id", baseTableName: "libro", constraintName: "FK62323827AD9965E", deferrable: "false", initiallyDeferred: "false", referencedColumnNames: "id", referencedTableName: "autor", referencesUniqueColumn: "false")
    }
    changeSet(author: "sohjiro (generated)", id: "1352952268429-4") {
        createIndex(indexName: "FK62323827AD9965E", tableName: "libro") {
            column(name: "autor_id")
        }
    }
}

Por cierto si ven el código generado primero crea el foreignKey y después el índice eso lo deben cambiar para que primero haga el createIndex ya que causará un error en la ejecución. Recuerden eliminar el dbCreate = “create-update” y hacer que el script se ejecute al iniciar la aplicación. Si trabajan con MySQL verifiquen sus tablassean del tipo InnoDB ya que de lo contrario causará un error al crear los ForeignKeys si es así o los eliminan del script o cambian el engine a InnoDB

Regresando al tema una vez que tenemos esto e insertamos datos y conforme  avanzamos en el desarrollo nos damos cuenta de que necesitamos separar las tablas porque requieren de una relación muchos a muchos es decir que la relación entre el Autor y el Libro se guarde en una tercera tabla llamada autor_libros. Para realizar esto necesitamos cambiar la relación en las clases de modo que quede de la siguiente manera

class Autor {
    String nombre
    String apellidoPaterno
    static hasMany = [libros : Libro]
}

Y la clase Libro

class Libro{
    String titulo
    Integer numeroDePaginas
    static belongsTo = Autor
    static hasMany = [autores : Autor]
}

Esto creará una tabla intermedia llamada autor_libros que contendrá las llaves primarias de ambas tablas ejecutamos la sentencia que nos dará la comparación entre el GORM y la BD de la siguiente manera

    dbm-gorm-diff cambiando-relacion-autor-libro.groovy

Y nos dará el siguiente resultado

databaseChangeLog = {
    changeSet(author: "sohjiro (generated)", id: "1352954334486-1") {
        createTable(tableName: "autor_libros") {
            column(name: "autor_id", type: "bigint") {
                constraints(nullable: "false")
            }
            column(name: "libro_id", type: "bigint") {
                constraints(nullable: "false")
            }
        }
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-2") {
        addPrimaryKey(columnNames: "autor_id, libro_id", tableName: "autor_libros")
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-3") {
        dropForeignKeyConstraint(baseTableName: "libro", baseTableSchemaName: "bookReviews", constraintName: "FK62323827AD9965E")
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-4") {
        addForeignKeyConstraint(baseColumnNames: "autor_id", baseTableName: "autor_libros", constraintName: "FK93C0044D7AD9965E", deferrable: "false", initiallyDeferred: "false", referencedColumnNames: "id", referencedTableName: "autor", referencesUniqueColumn: "false")
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-5") {
        addForeignKeyConstraint(baseColumnNames: "libro_id", baseTableName: "autor_libros", constraintName: "FK93C0044D58C2B5FE", deferrable: "false", initiallyDeferred: "false", referencedColumnNames: "id", referencedTableName: "libro", referencesUniqueColumn: "false")
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-6") {
        createIndex(indexName: "FK93C0044D58C2B5FE", tableName: "autor_libros") {
            column(name: "libro_id")
        }
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-7") {
        createIndex(indexName: "FK93C0044D7AD9965E", tableName: "autor_libros") {
            column(name: "autor_id")
        }
    }
    changeSet(author: "sohjiro (generated)", id: "1352954334486-8") {
        dropColumn(columnName: "autor_id", tableName: "libro")
        }
    }

Leyendo el script nos damos cuenta de que entre las líneas se encuentra un DROP que hace referencia a la tabla libro en específico a la columna autor_id , esto quiere decir que al ejecutar el script la columna autor_id será eliminada junto con todos los registros ahí guardados… ESPERA un momento esto no es lo que quería ahora ¿como hago para que los datos que tenía ahí no sean eliminados y las relaciones se mantengan?

No se olviden de cambiar los create index antes de hacer el addForeingKey y en este caso después del addPrimaryKey de la tabla autor_libros y de paso el dropForeingKey antes del dropColumn

Bueno una forma es hacerla manualmente ( jajajajajaja ) en este caso tal vez se pueda hacer pero ¿y que pasa cuando hay más cambios así? ¿Todos los tenemos que hacer manualmente? Pues no, este plugin nos permite ejecutar consultas de todo tipo para hacer la migración un poco menos dolorosa.

Para realizar estos cambios ubicamos en el changelog el lugar en donde se crea la tabla intermedia y escribimos un sql tal como se muestra a continuación

changeSet(author: "sohjiro (generated)", id: "1352954334486-1") {
    createTable(tableName: "autor_libros") {
        column(name: "autor_id", type: "bigint") {
            constraints(nullable: "false")
        }
        column(name: "libro_id", type: "bigint") {
            constraints(nullable: "false")
        }
    }
    sql("insert into autor_libros (libro_id, autor_id) select id, autor_id from libro")
}

Ahora sólo queda agregarlo al changelog principal hay dos formas que lo escribamos nosotros al final del archivo changlog.groovy de la siguiente manera o que al ejecutar el dbm-gorm-diff después del nombre del archivo pongamos –add

    include file: 'cambiando-relacion-autor-libro.groovy'

Ahora solamente levantamos la aplicación o sino la quieres levantar ejecuta lo siguiente desde la consola de grails

    dbm-update

Y de esta manera todo lo que tengamos en esa tabla pasará a ser ejecutado, lo que tenga que ser eliminado será eliminado pero no sin antes hacer los movimientos pertinentes.

Espero les sirva este pequeño POST y cualquier duda o comentario acerca del mismo será bien recibida.

Hasta la próxima

Algunas de ellas las he rescatado de mi timeline de twitter y otras las he visto examinando un poco la documentación y el código fuente.

A veces sólo deseamos habilitar el sql generado por hibernate en ciertas partes de la aplicación y lo que hacemos es activar el atributo logSql desde DataSource.groovy o donde quiera que se tenga configurado. Pues bueno, podemos hacerlo de forma programática en controllers, servicios y/o taglibs con ayuda del sessionFactory.

def sessionFactory // Inyección de dependencias
//....
def method(){
  //...
  sessionFactory.settings.sqlStatementLogger.logToStdout = true
  //...
}

En otras ocasiones he necesitado acceder al sessionFactory desde la grails console, y ahí no hay como tal una inyección de dependencias, y si ponemos sólo la definición como en el fragemtno pasado obtendremos NPE.

Sin embargo, dentro de la consola contamos con la variable ‘ctx’, una referencia al Application Context de la aplicación. Por lo tanto, podemos hacer lo siguiente:

// En la grails console
def sessionFactory = ctx.sessionFactory
//Haz lo que quieras con el sessionFactory

Más cosas con los internals de grails en otros post.