[Java Groovy Grails Cloud] Grails 2.0 : un Ruby on Rails à base de Java (Groovy)

La version 2.0 de Grails est désormais disponible depuis quelques semaines.
Il s'agit qu'une évolution de la version 1.3 et non d'une version majeure, ça aurait pu être Grails 1.4. Mais apparemment, le nombre de modifications a inspiré les concepteurs à passer vers la version 2.0 :

• Groovy 1.8,
• Spring 3.1,
• Hibernate 3.6 
• Servlet 3.0
• La migration vers le framework JS, JQuery en remplacment de Prototype
• La possibilité de réaliser de la génération de code (dynamqiue ou statci) dite scaffolding Html 5,
• La migration vers une API de test unitaires à base de groovy  Spock,
• L'ajout du mode XA pour les transaction entre deux bases de données
• le reverse engineering d'une base existante seront désormais possibles,

En plus des dizaines de plugins (WS, …), de la compatibilité avec le PaaS de Google GAE (Google appengine,  Cloud computing), Grails 2.0 fait une ouverture vers le mode noSQL avec le support de la base de données MongoDB 

Grails, groovy & Google Appengine (3G): créer et déployer votre première application dans le cloud en 10 commandes

Introduction

Après 3,5 mois de test de la version java de Googgle Appengine, j’arrive à la conclusion suivante : dans la version actuelle (Googgle Appengine SDK installé : la version 1.2.2), il est utopique de penser à migrer sans efforts des applications javaEE actuelles. La migration reste possible, n’est pas triviale.
L’approche PaaS proposé par Google, dans son offre Googgle Appengine, ne privilégie pas la réutilisation des applications existantes pour trois raisons (contrairement à l'approche - à tester- de Spring sur son CloudFoundary).


- Une limitation des API java disponible et du ClassLoader (ce lien pour les classes du JRE et ce lien will-it-play-in-app-engine ?)

• - Une limitation des actions possibles (pas de gestion de thread, pas d’écriture dans des fichiers, …)
• - Un changement dans l’utilisation des bases de schémas possibles de bases de données
• Il est préférable que la première application déployée soit réécrite spécialement pour le Googgle Appengine. Cela permet de comprendre le modèle de programmation et le modèle de facturation, les performances … avant même de penser à la connecter aux autres applications Google.

Pour une première exploration, je conseille d”adopter une approche RAD en utilisant l’un sur des frameworks “nouvelle approche du monde Java EE basé sur le concept de “Convention Over Configuration”.

Graisl & Groovy

Depuis sa version 1.1.1, Grails, est devenu le framework le plus prometteur de cette mouvance. Grails encapsule un condensé de Best practices, des meilleurs framewors (Spring, …) open source, des plugins spécifiques …
Ce tutorial vous permet de saisir la faciliter de création et déploiement d’une application

Créer et déployer votre première application dans le cloud en10 commandes

Alors si vous souhaiter vous lancer dans le cloud en quelques minutes : adopter l’approche 3 G : Grails, groovy & Google Appengine.

Les prérequis

1. Java JDK installé (de préférence la dernière version )
2. Grails installé : la version Grails 1.1.1
3. Goggle Appenigne SDK installé : la version 1.2.2
4. Avoir un compte Googgle Appenigne

Les étapes simplement (commades …)

1. grails create-app my_First_3G_app
2. cd my_First_3G_app
3. grails uninstall-plugin hibernate
4. grails install-plugin gorm-jpa
5. grails install-plugin app-engine
6. grails create-domain-class com.oxia.att.test.Message (ajouter un attribute message et faire le mapping JPA avec les annotations )
7. grails generate-all com.oxia.att.test.Message (ajouter le code Groovy et GSP pour personaliser les écrans selon vos besoins)
8. add to grails-app\conf\Config.groovy - google.appengine.application=" app3g "
9. grails set-version 1
10. grails app-engine deploy

Pour visualiser le résultat, allez au http://app3g.appspot.com
Exemple de cette approche : http://np-grails.appspot.com/twitting/list

Pour tester localement l’application :

• grails app-engine
• go to http://localhost:8080 and test the app locally

Les étapes avec explications

Les étapes de 1 à 5 permettent de créer la structure de l’application

Ce qu’il faut retenir :

Ce qu’il faut retenir, Google appengine n’est pas compatible Hibernate, et que grâce au plugin Gorm-JPA de Grails, l’utilisation des annotations JPA est possible.
Les étapes 8 à 10 : concernent le déploiement
Les étapes 6 et 7 concernent l’application Grails et le code métier, affichage …
L’application doit répondre, bien sûre, à vos besoins métiers, et correspondre à la charte graphique de votre entreprise.
Tous ses aspects peuvent être réalisés avec Grails / Groovy en respectant les limitations de Google app engine.
Espèrerons que la même application soit compatible avec l'offre de Spring sur son CloudFoundary.
Signalons, en fin, que la principale limitation qui va rencontrer votre projet : la définition de votre schéma de persistance (pour ne pas dire schéma SQL) compatible avec BigTable (ce n’est pas du SQL bien qu’on y accède en JPA ou JDO, dison GQL)
Mais ceci est un autre sujet
autres entrés sur le même sujet

Cloud Computing : Créer votre première application avec GoogleApp Engine et java

Quel crédit donner aux résultats affichés par le DashBoard de GoogleApp Engine (GAE) ?

Groovy,Grails & Web service: Consommer simplement un web service

Question : comment consommer simplement un web service

Réponse : avec groovy, très simplement en 3 lignes de code

Nous allons utiliser le webservice crée à l’occasion du billet suivant : Grails, Groovy, xFire & SoapUI : créer un web service et le tester en 22 lignes de codes, 7 commandes et 5 minutes

Les étapes sont simples

Etape 1 : installer Groovy

Voir ce lien :

Etape 2 (optionnel): créer un projet Groovy avec Eclipse ou avec STS (Springsource Tool Suite, la version free et conseillée pour ce type de projet)

Télécharger à partir du lien suivant: http://www.springsource.com/products/springsource-tool-suite-download

Etape 3 : ajouter la librairie nécessaire "groovyws-xxxx-0.5.0.jar »

Télécharger à partir de ce lien http://dist.codehaus.org/gmod/groovyws-minimal-0.5.0.jar

Etape 4 : créer le code pour consommer le web service (le WSDL est définie ici)

1:  def proxy = new WSClient("http://localhost:8080/webservice-xfire/services/role?wsdl", this.class.classLoader)
2:  proxy.initialize()  
3:  def result = proxy.getRoles()
4:  // utilization de la réponse
5:  assert result.getClass().name=="com.oxia.att.grails.ArrayOfRole"
6:  def role=result.role[0]
7:  assert role.name.getClass().name=='javax.xml.bind.JAXBElement'
8:  println 'NS   ' +role.name.getName()
9:  println 'Valeur ' +role.name.getValue()

( l’a classe Role possède une propriété ‘name’)

Explication :

dans ce usage; Groovy se base sur CXF (avec la version SOAP version: 1.1 pour le moment et présente ces deux classes org.apache.cxf.endpoint.dynamic.DynamicClientFactory et groovyx.net.ws.AbstractCXFWSClient getBindingOperationInfo)

en se basant sur le WSDL il va créer dynamiquement les classes nécessaires

com.oxia.att.grails.ArrayOfRole,

com.oxia.att.grails.GetRoles,

com.oxia.att.grails.GetRolesResponse,

com.oxia.att.grails.ObjectFactory,

com.oxia.att.grails.Role,

com.oxia.att.grails.ServiceMethod,

com.oxia.att.grails.ServiceMethodResponse

Les résultats sont retournés dans un objet crée à la volé (com.oxia.att.grails.ArrayOfRole) et sont de type javax.xml.bind.JAXBElement.

Qui contient le nameSpace : {http://grails.att.oxia.com}name

Et la valeur : admin

Pour ceux qui pensent que la manipulation des résultats n’est pas évidente, il est temps de se rappeler que Groovy vous permet de créer vos propre méthodes de manipulations dynamiquement.

Ça permet de simplifier la manipulation des objets …javax.xml.bind.JAXBElement

C'est ici que se manifeste la puissance de Groovy en tant que langage dynamqiue avec sa capacité à manipuler les Closures ..

Mais ceci est autre sujet …

Lien utile:

Consuming a web service with Groovy Web Service

Groovy Web Service

Groovy Web Service installation

autres sujets : Groovy & Grails

Tomcat, Spring, Grails, Groovy : dans le giron de Vmware

Groovy & Grails : L’instabilité en vue du coté JRuby, une opportunité de plus pour Groovy & Grails

Groovy et Grails dans le giron de SpringSource : Un bel avenir pour les langage dynamique

Tomcat, Spring, Grails, Groovy : dans le giron de Vmware

10 août 2009 : Un jour d’été pas comme les autres, une montée fulgurante d’une société, crée il y a 5 ans sur la base du consulting autour d’un framework Ioc, pour devenir la référence d’une communauté java toujours en quête d’évolution.

Aujourd’hui 10 août 2009 Vmware le leader incontesté de la vritualisation a annoncé l’acquisition de springSource le leader incontesté de la voie alternative de la communauté Java, du Server Side et java Software

Rappelons les grandes dates pour Spring :

novembre 2002: Rod Johnson publie son réquisitoire contre la voie officielle de J2EE : “J2EE Design and Development”

février 2003: Lancement d’un IOC en open source ‘Spring le Framework’
Juillet 2004: Lancement de SpringSource ‘Spring l’entrerpise’

janvier 2008: Acquisition par SpringSource de Covalent Technologies ( Apache java Software Foundation projects, Tomcat, Axis …)

novembre 2008: Acquisition par SpringSource de G2One : Groovy and Grails.

mai 2009: Acquisition par SpringSource der Hyperic (monitoring de système).

Le but ultime de ce mariage, reste à mon avis, la préparation de prochaine bataille de l’IT: celle du cloud computing ( Qu’il s’agisse de Cloud privé ou public).

Rappelons que les offres cloud de Microsoft et de Google menacent directement le modèle &économique de VMware : Les deux Big Brothers offrent des infrastructures vitalisées par essence. Les offres cloud de Microsoft et de Google parlent en plus directement aux développeurs : .Net C# ou Java, conserver vos habitudes, programmez simplement et déployer facilement. Chère développeur Azure ou Google Appengine : des Vmware ou des Framework (Spring compris…) il n’y guère besoin, le cloud est là pour simplifier votre travaille. ….

Il s’agit donc, d’un autre mariage de raison, entre deux leaders préparant leurs avenirs :

Vmware est focalisée sur la simplification et l’automatisation des infrastructures pour les applications et Spring est focalisée sur la simplification et l’automatisation du développement des applications.

Pour le monde java, c’est une bonne nouvelle si ça aboutit à une vraie simplification des modèles de développement, déploiement et monitoring.

Restons vigilant sur l’ouverture du code de Tomcat, Spring, Grails et Groovy …

d’autre part, VMware, doit batailler pour s’imposer dans le monde des clouds privées ou va t’elle fusionner avec Amazon ?

Mais ceci est une autre histoire

news : http://blog.springsource.com/2009/08/10/springsource-chapter-two/

http://www.marketwatch.com/story/vmware-to-acquire-privately-held-springsource-2009-08-10

http://www.infoq.com/news/2009/08/vmware-springsource

http://www.marketwire.com/press-release/Vmware-Inc-NYSE-VMW-1028298.html

Grails, Groovy, xFire & SoapUI : créer un web service et le tester en 22 lignes de codes, 7 commandes et 5 minutes

Préambule : Avant de commencer, s’agissant de publier des services, je rappelle que je reste adepte du concept Contrat-first. Mais, ce tutoriel est destiné à montrer la puissance de l’approche Grails. Il doit être affiné pour suivre l’approche contract-first. Qu'il s'agisse d'une solution java développée 'from scratch' ou basée sur du 'java software' payé en $$ ou sur du .net basée sur Biztalk : l'essentiel c'est que le contrat soit défini dès le début

Question : comment créer un web service en exposant la liste à partir d’une base de données

Contexte : confronté, sur un nouveau projet, à une demande du client qui souhaite rapidement : apprendre à consommer des web services, dans un projet classique JSF/Spring/Hibernate . L’idée est d’utiliser Spring webservice template, mais, Il a fallu fournir des web services rapidement, pour les consommer

Réponse : le simple c’est d’utiliser Grails (yes it's a java software from Spring cretors, based on Groovy : a dynamique java software from the Spring source ...)

Des webservices en moins de 5 minutes, 6 commandes et 22 lignes de codes …

En prime : les écrans de gestion de l’entité cible dans la base de donnée

Etape 1: installer Grails

http://www.objis.com/formation-java/tutoriel-grails-installation.html

Etape 2 : créer une application

(Commande 1)>grails create-app webservice-xfire

(Commande 2)>cd webservice-xfire

(Commande 3)>grails create-domain-class com.oxia.att.grails.Role

Ajouter ce code (en somme du Plain old Groovy objects, dit POGO)

1:  package com.oxia.att.grails
2:  class Role {
3:       String name
4:       static constraints = {
5:            name(blank: false, size: 1..20)
6:       }
7:       public String toString() {
8:            return name
9:       }
10:  }

(commande 4)>grails create-controller com.oxia.att.grails.Role

Etape 2 : installer le plugin xFire

http://www.grails.org/plugin/xfire

(commande 5)> grails install-plugin xfire

Etape 3 : générer les bases du service en relation avec le POGO Role

(commande 6)> grails create-service com.oxia.att.grails.Role

Etape 4 : ajouter un peu de code Groovy pour exposer le métier

1:  class RoleService {
2:        static expose=['xfire']
3:     def serviceMethod(Role dc) {
4:          return true
5:     }
6:     Role[] getRoles(){ Role.list() as Role[] }
7:  }

Etape 5 : lancer

(commande 7)> grails run-app
http://localhost:8080/webservice-xfire/services/role?wsdl
Avant de tester le web service : ajouter au moins 1 Role (le fameux admin…) ( les écrans d’administration ont été générés aussi)

Etape 6 : tester avec SoapUI

Créer un projet avec SOAP UT à partir du WSDL

SOAPUI va créer ce projet

Lancer le teste

Le résultat n’est pas « orienté » Contrat-first

Mais … avec du XPATH on pourra se débrouiller !

Avouons qu’il faut travailler encore le CONTRAT

Etape 7: statistique

Code utile : 22 lignes de codes (les tests unitaires sont aussi utiles mains non comptabilisées dans ce cas)

 +----------------------+-------+-------+
| Name         | Files | LOC |
+----------------------+-------+-------+
| Controllers     |   1 |   4 |
| Domain Classes    |   1 |  10 |
| Services       |   1 |   8 |
| Unit Tests      |   3 |  36 |
+----------------------+-------+-------+
| Totals        |   6 |  58 |

( sans formatage de texte )

Etape 8 : consommer le service

Utiliser Spring Web service template

Mais, ceci est un autre sujet

--------------------------------------------------

autres sujets Grails

-- Groovy & Grails : L’instabilité en vue du coté JRuby, une opportunité de plus pour Groovy & Grails

-- Groovy et Grails dans le giron de SpringSource : Un bel avenir pour les langage dynamique
--------------------------------------------------

autres sujets à venir

- le concept Java 3G : Grails, Groovy et Google appengine

- les plugins Grails

Cloud Computing : Google App Engine à la conquête des développeurs java

On l'attendait pour le milieu de l'année, mais Google vient de la lancer officiellement au début du second trimestre 2009 : La « déclinaison » java de sa plate-forme Google App Engine est désormais là.

C'était logique : il fallait réagir rapidement : pour faire barrage à Microsoft Azure.

La manouvre est habile : supporter Java 6 et offrir un plugin Eclipse, permet à Google d'élargir la base de développeurs cible.

Google vise ainsi à faciliter la réutilisation de code source et à introduire les langages dynamique de type Groovy…

Et pour mon premier test, je suis « tombé sous le charme » : il m'a fallu moins d'une demi-heure (moins de 30 minutes pour déployer une ancienne application (simple) basée sur Struts sur le cloud de Google)

Aucune modification n'a été nécessaire !

... et l'application "est dans les nuages".

la courbe d'apprentissage est "rapide".

Certes : il n'y a avait pas de transaction, de base de données, de Spring, de Hibernate …

Voir le résultat en bas ou allez : http://kbdsoft.appspot.com/

Un dashBoard permet de suivre l'activité de l'application :

Mais,

Attention : l'accès gratuit est limité aux 10 000 premiers inscrits.

et on attend un plagin Grails spécialement conçue pour la création d'application Grails pour google appengine

mais ceci est un autre sujet (à suivre) ...

à suivre "le tabeau de Bord : donne t il des données vérifiables"