Pourquoi les développeurs Java devraient-ils donner une chance à Grails ?

Java possède un écosystème qui a mûri au fil des années de développement, ce qui en fait l'une des plates-formes les plus fiables du marché. Pourtant, il manque les moyens nécessaires pour faire le travail rapidement, en particulier pour des choses comme les applications Web. Pour tenter d'éviter les frustrations liées à ces types de problèmes, les développeurs optent souvent à la place pour les langages d'implémentation et leurs frameworks Web modernes, tels que Ruby avec Ruby on Rails, Python avec Django, etc. Contrairement à Java, ceux-ci fournissent un chemin beaucoup plus simple pour créer une application Web.

Heureusement, pour les développeurs Java souhaitant créer des applications Web, il existe un meilleur moyen, et cela implique Grails. Dans cet article, nous verrons comment Grails avec Groovy est une alternative viable dans le domaine JVM. Nous examinerons quelques exemples où Grails nous attire en tant que développeurs Java et pourrait inciter quelqu'un d'autre à essayer également.

L'histoire

Dans une startup pour laquelle je travaillais, nous avions exactement ce problème. Nous avions une application Spring qui devenait pénible à travailler. Avec une croissance de plus en plus grande, nous avons rapidement constaté que la refactorisation et l'ajout de fonctionnalités nous prenaient beaucoup plus de temps que prévu. En combinant cela avec d'autres motivations, nous avons décidé de réécrire notre application de base. Nous étions également ouverts à la modification ou au remplacement de la pile technologique existante. Grails semblait être un choix viable car il s'exécute dans la JVM et repose sur des technologies que nous connaissions déjà. Il utilise le langage de programmation Groovy mais permet en même temps de le mixer avec Java. Alors on a sauté le pas.

Pleine vitesse

Une chose dans laquelle Grails excelle vraiment est de faciliter le démarrage d'un nouveau projet. C'est aussi simple que d'exécuter une commande qui crée la structure du projet avec tous les dossiers nécessaires pour les classes que vous ajouterez plus tard. L'ajout de classes de modèles, de contrôleurs, de services et de pages Web nécessite également un minimum d'efforts. La seule chose dont vous devez vous occuper est de nommer et de placer les choses correctement. Contrairement à Java, il n'y a pratiquement pas de code passe-partout qui doit être là simplement parce qu'il doit l'être. Ceci est en partie rendu possible en utilisant Spring et Hibernate qui sont deux des piliers de Grails, ainsi que le concept de codage par convention. Pour exécuter le projet, Grails est fourni avec Apache Tomcat en tant que serveur de développement. Tout ce que nous avons à faire est d'exécuter le projet dans notre IDE et le serveur sera lancé avec notre code déployé. De plus, le Grails' Object Relational Mapping (GORM) avec Hibernate se chargera de créer la base de données pour nous. Pour utiliser une base de données existante, nous devons configurer les propriétés de connexion JDBC ou simplement la laisser par défaut pour utiliser une instance en mémoire. Une fois que le serveur avec Grails est en cours d'exécution (cela prend un peu plus qu'une application Spring MVC), nous pouvons modifier le code et la fonctionnalité de déploiement à chaud gardera notre session de débogage équipée de la dernière version. Les seules classes qui ne peuvent pas être rechargées de cette façon sont les classes d'entité.

Le remplissage de la base de données peut être effectué à l'aide de scripts SQL, mais cela peut devenir fastidieux. Tous les projets Grails contiennent une classe Bootstrap qui sera exécutée lors de l'exécution de notre application. Dans cette classe, nous pouvons stocker ou modifier des données et ainsi initialiser notre état d'application. Cela s'est avéré très utile pour nous, nous avons donc tout de suite quelques cas de test en version de développement.

Manipulation des données

L'une des choses qui a immédiatement attiré notre attention avec Grails était la facilité de travail avec les données. La lecture de la base de données est une tâche qui doit être répétée encore et encore. Et souvent, c'est simple. Comme récupérer une ou plusieurs entités qui répondent à certains critères, puis les agréger. Pourquoi ne pas utiliser un finder dynamique pour cela ? C'est une façon d'interroger les données où les méthodes sont créées dynamiquement au moment de l'exécution. Tout ce que vous avez à faire est de suivre une convention de nommage.

 def users = User.findAllByLastNameLikeOrAgeGreaterThan('Doe%', 30)

La ligne au-dessus de la ligne récupérera tous les objets Utilisateur dont le nom de famille commence par "Doe" ou dont l'âge est supérieur à 30 ans. Oui, ce n'est pas un cas très sophistiqué, mais vous comprenez l'essentiel.

Et si nous voulions filtrer cette liste en plus pour ceux dont la propriété "failedLogins" est supérieure à 10 ? Et si on voulait les trier par date de création ? Et si on voulait obtenir la concaténation de leurs prénoms ou trouver l'âge maximum des utilisateurs renvoyés ?

 users = users.findAll() { it.failedLogins > 10 } users = users.sort { it.dateCreated } def firstNamesString = users.firstName.join(', ') def maximumAge = users.age.max()

Les exemples ci-dessus peuvent sembler simples, mais ils montrent à quel point Grails peut être puissant pour interroger, filtrer et manipuler des données. Dans Java 8, vous pouvez obtenir des résultats similaires pour certains de ces cas, mais cela nécessitera toujours plus de code que Grails.

Parfois, je veux créer différemment

Un constructeur dynamique ou un constructeur d'arguments nommés est une fonctionnalité que beaucoup d'entre nous souhaitaient avoir en Java. C'est bien de définir quels constructeurs une certaine classe autorise, mais dans de nombreux cas, vous voulez simplement définir certaines propriétés et obtenir l'instance sacrée. Groovy ajoute un constructeur spécial pour chaque entité qui prend essentiellement l'élégance d'une carte en entrée et définit les propriétés avec les entrées de la carte.

 def Person = new Person(name: 'Batman', age: 57)

Cette approche conduit à un code beaucoup plus expressif et évite le besoin de tout le code passe-partout du constructeur.

Et BTW, voici quelques exemples de la génialité et de l'élégance des cartes de Groovy :

 def emptyMap = [:] def map = [bread:3, milk:5, butter:2] map['bread'] = 4 map.milk = 6

Ceci est un autre exemple de la façon dont le code peut être court et simple, mais puissant. Il montre comment l'initialisation en ligne peut être utilisée et comment les valeurs de carte peuvent être manipulées d'une manière similaire aux propriétés d'objet. Pas besoin d'appeler les méthodes Java traditionnelles pour une manipulation de base, à moins que vous ne le vouliez vraiment.

Nous avons besoin de plus de puissance !

Bien sûr, il n'y a pas de cadre qui peut tout faire, mais lorsque nous comblons les lacunes, nous devrions voir ce qui pourrait déjà être disponible avant d'essayer de mettre en œuvre notre propre solution. Pour étendre notre arsenal de fonctionnalités basées sur Grails, nous pouvons utiliser Grails Plugins. L'installation d'un plugin se fait simplement en ajoutant une autre ligne dans la classe BuildConfig qui est présente dans chaque projet Grails (la convention de code a encore frappé !).

 compile ':spring-security-core:2.0-RC4'

La ligne ci-dessus ajoute le noyau de sécurité Spring à notre application et il n'y a pratiquement plus de configuration nécessaire pour intégrer cette fonctionnalité.

Ceci étant dit, permettez-moi de vous parler d'un cas que nous avons eu à traiter. Nous devions implémenter une recherche couvrant plusieurs entités de données. Grails a un plugin Elasticsearch qui est un jeu d'enfant à utiliser. Comme mentionné précédemment, il nous suffit de référencer le plugin dans le fichier de configuration et nous sommes prêts à partir. Si nous voulons rechercher des entités d'une certaine classe, il nous suffit d'ajouter une propriété statique "recherchable" à cette classe. Et si nous le voulons, nous pouvons même limiter les propriétés qui seront autorisées à être recherchées.

 class User { static searchable = { only = name } String name Double salary }

C'est si peu de code, mais sous le capot, Grails et le plugin Elasticsearch indexeront automatiquement tous les utilisateurs par nom et nous permettront de rechercher par nom. L'appel de recherche proprement dit est également très concis :

 User.search("${params.query}")

Si nous ne le voulons pas, nous n'aurons jamais à toucher à l'indice de Lucene. Tout se fera automatiquement pour nous. Le plugin a même une API pour afficher les résultats de la recherche - il peut mettre en évidence la correspondance trouvée dans le texte recherché. Ceci n'est qu'un exemple de la façon dont un plugin peut fournir un énorme ensemble de fonctionnalités qui peuvent nous rendre beaucoup plus efficaces en nous évitant d'avoir à l'implémenter nous-mêmes.

Nous avons encore besoin de plus de puissance

Les plugins sont super, mais parfois nous n'avons pas besoin d'un plugin complet, nous voulons juste quelque chose en plus. Vous souvenez-vous de la dernière fois où vous avez voulu avoir une méthode supplémentaire sur une classe Java existante mais vous ne vouliez pas (ou ne pouviez pas) les étendre/remplacer ? Dans Groovy, vous pouvez ajouter des méthodes et des propriétés à des classes existantes, ou même à certaines instances de celles-ci. Par exemple, vous pouvez ajouter une méthode de formatting à la classe java.util.Date , ce qui est génial lorsque vous souhaitez formater les dates de manière cohérente et que vous ne voulez tout simplement pas écrire des classes utilitaires statiques ou définir divers filtres.

 Date.metaClass.formatDate = { delegate.format("dd.MM.yyyy") }

Que faire si vous souhaitez trier une liste d'utilisateurs par une valeur calculée et que vous n'en avez besoin que dans un cas (c'est-à-dire que l'ajout d'une nouvelle méthode dans la classe User serait polluant) ? Vous pouvez ajouter une propriété sur chacune de ces instances, puis simplement trier ou filtrer la collection en fonction de cette propriété :

 user.metaClass.computedProp = 312 * 32 * 3

Les auteurs de Groovy ont déjà ajouté de nombreuses améliorations à certaines des classes Java de base, nous n'avons donc pas à le faire. Voici quelques exemples.

Utiliser "moins" pour supprimer tous les éléments d'une collection qui sont présents dans une autre collection.

 assert [1, 2, 3, 4, 4, 5] - [2, 4] == [1, 3, 5]

Méthodes supplémentaires pour manipuler les objets java.util.Date qui sont très utiles, comme ajouter/soustraire des jours de dates ou obtenir/définir un certain champ de la date sans le convertir en Calendar ou utiliser des bibliothèques supplémentaires.

 def yesterdayAllMyTroublesSeemedSoFarAway = new Date() - 1 def myAwesomeAnniversaryYear = myAwesomeDate[Calendar.YEAR] + 1 myAwesomeDate.set(year: myAwesomeAnniversaryYear, second: 0)

Lorsque vous voulez vraiment devenir descriptif avec la manipulation de la date, vous pouvez simplement utiliser la classe TimeCategory ajoutée par Groovy :

 use (TimeCategory) { println 1.minute.from.now println 10.hours.ago def someDate = new Date() println someDate - 3.months }

Un marteau et un clou

Ensuite, il y a les IDE. GGTS et IntelliJ IDEA basés sur Eclipse sont configurés pour travailler avec Grails. Ils comprennent la structure du projet (et vous aideront à naviguer dans les dossiers et les ressources) et disposent de raccourcis pour les commandes que vous utiliserez le plus souvent (par exemple, ajouter un contrôleur, ajouter une page, exécuter un projet, etc.). Avec Grails, vous exécuterez des commandes (pour exécuter un projet ou configurer une nouvelle fonctionnalité de plugin) et vous aurez besoin de différentes configurations, qui sont également couvertes par les IDE. La complétion de code fonctionne bien dans les pages de modèles Web Grails où vous référencerez souvent des contrôleurs et des actions. Il existe également d'autres IDE qui peuvent être utilisés avec Grails tels que Netbeans, TextMate, Emacs et autres.

Qu'en est-il du côté obscur ?

Comme pour tout dans la vie, il y a aussi des mises en garde avec Grails. Il y a beaucoup de magie qui se fait sous le capot, ce qui peut souvent être une bonne chose, mais parfois le résultat ne sera pas celui que vous attendiez. Des bogues se produiront simplement parce que vous n'utilisez pas la saisie (oui, les types sont facultatifs dans Groovy) et que vous n'êtes pas assez prudent. Et peut-être que vous ne remarquerez pas une erreur jusqu'à ce qu'il soit trop tard. De plus, il est très tentant d'écrire des phrases simples pour impressionner vos collègues. Et toi. Mais ces puissantes lignes de code peuvent ne pas être aussi explicites pour vos collègues. Ou même à vous-même dans quelques mois. C'est pourquoi je pense que Grails exige plus de discipline de programmation que certains des frameworks plus traditionnels.

Le temps, c'est de l'argent

Le codage ne devrait pas prendre plus de temps simplement parce que votre cadre actuel l'exige. Surtout avec le nombre croissant de startups de nos jours, il est important de se concentrer sur les tâches qui comptent vraiment et d'être aussi efficace que possible. Le temps, c'est de l'argent et le temps de mise sur le marché est critique. Vous devez être en mesure d'agir rapidement et de mettre en œuvre la solution avant que le temps ne soit écoulé et que vos concurrents ne vous battent.

Mes amis travaillant avec Ruby on Rails ou Python/Django me disent depuis longtemps à quel point ces technologies sont cool. Et c'était vraiment idiot de penser combien de temps il m'a fallu en Java pour écrire du code qui stocke quelque chose dans une base de données et l'affiche dans une page Web. Grails peut en effet être une réponse utile. Ce n'est pas que vous ne pourriez pas faire cela avec Java pur, Spring MVC et Hibernate. Vous pourriez. Votre application pourrait même s'exécuter un peu plus vite. Mais vous ferez le travail plus rapidement avec Grails.