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. Pourtant, il n'a pas les moyens nécessaires pour faire le travail rapidement, en particulier pour des choses comme les applications Web. Afin d'éviter les frustrations liées à ces types de problèmes, les développeurs optent souvent pour des 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.

Développeurs Web Java: rencontrez Grails et découvrez ce que vous avez manqué. Tweet

Heureusement, pour les développeurs Java souhaitant créer des applications Web, est une meilleure façon, 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 intéresse en tant que développeurs Java et pourrait aussi inciter quelqu'un d'autre à essayer.

L'histoire

Dans une startup pour laquelle j'ai travaillé, nous avons eu exactement ce problème. Nous avions une application Spring qui devenait difficile à travailler. Avec sa 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 principale. Nous étions également ouverts à la modification ou au remplacement de la pile technologique existante. Grails semblait être un choix viable car il fonctionne dans la JVM et repose sur des technologies que nous connaissions déjà. Il utilise le langage de programmation Groovy mais vous permet en même temps de le mélanger avec Java. Nous avons donc franchi 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 un effort également minimal. La seule chose dont vous devez faire attention est de nommer et de placer correctement les éléments. Contrairement à Java, il n'y a pratiquement pas de code standard qui doit être là simplement parce qu'il le faut. Ceci est partiellement rendu possible grâce à l'utilisation de Spring et Hibernate qui sont deux des piliers de Grails, ainsi que du 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é. Également Cartographie relationnelle des objets Grails (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 (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 manière 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 l'état de notre 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.

Dans la classe Bootstrap, nous pouvons également utiliser des conditions «if» pour vérifier le type d'environnement (développement, test, production, etc.) et modifier les données en conséquence.

Manipulation des données

L'une des choses qui a immédiatement attiré notre attention avec Grails a été 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 à plusieurs reprises. 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 chercheur dynamique pour cela? C'est une manière d'interroger des 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 dénomination.

qu'est-ce que l'interface utilisateur dans les jeux

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

La ligne au-dessus de la ligne récupérera tous les objets User dont le nom de famille commence par «Doe» ou dont l'âge est supérieur à 30. 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 celles dont la propriété «failedLogins» est supérieure à 10? Et si nous voulions les trier par leur date de création? Et si nous voulions concaténer 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 dans 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'argument nommé est une fonctionnalité que beaucoup d'entre nous voulaient avoir en Java. C’est bien de définir les constructeurs autorisés par une classe donnée, mais dans de nombreux cas, vous voulez juste définir quelques propriétés et obtenir l’instance. Groovy ajoute un constructeur spécial pour chaque entité qui prend essentiellement l'élégance d'une carte comme 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 d'avoir à utiliser tout le code standard 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 des méthodes Java traditionnelles pour la manipulation de base, sauf si vous le souhaitez vraiment.

Nous avons besoin de plus de puissance!

Bien sûr, il n’existe pas de cadre qui puisse 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 le BuildConfig classe qui est présente dans chaque projet Grails (la convention de code frappe à nouveau!).

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é.

C'est similaire à l'utilisation des dépendances Maven (que vous pouvez également référencer dans la même classe de configuration), mais les plugins sont généralement des blocs plus volumineux qui contiennent toutes les fonctionnalités.

Cela étant dit, laissez-moi vous parler d'un cas que nous avons dû traiter. Nous devions implémenter une recherche couvrant plusieurs entités de données. Grails a un plugin Elasticsearch qui est facile à utiliser. Comme mentionné précédemment, nous n'avons besoin de référencer le plugin que dans le fichier de configuration et nous sommes prêts à partir. Si nous voulons rechercher des entités d'une certaine classe, nous devons simplement ajouter une propriété statique «interrogeable» à cette classe. Et si nous le voulons, nous pouvons même limiter les propriétés qui pourront ê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’index 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 excellents, mais parfois nous n'avons pas besoin d'un plugin complet, nous voulons juste quelque chose de plus. Vous souvenez-vous de la dernière fois que vous vouliez avoir une méthode supplémentaire sur une classe Java existante, mais vous ne vouliez pas (ou ne pouviez pas) les étendre / les remplacer? Dans Groovy, vous pouvez ajouter des méthodes et des propriétés à des classes existantes, ou même uniquement à certaines instances de celles-ci. Par exemple, vous pouvez ajouter un formatting méthode à la java.util.Date classe, ce qui est génial lorsque vous souhaitez formater les dates de manière cohérente et que vous ne voulez simplement pas écrire des classes util 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 par 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.

Utilisation de «moins» pour supprimer tous les éléments d’une collection présents dans une autre collection.

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

Méthodes supplémentaires de manipulation java.util.Date objets qui s'avèrent utiles tant de fois, comme ajouter / soustraire des jours à des dates ou obtenir / définir un certain champ de la date sans le convertir en Calendar ou en utilisant 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 être descriptif avec la manipulation de la date, vous pouvez simplement utiliser le Groovy ajouté TimeCategory classe:

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

Un marteau et un clou

node.js est utilisé pour créer des programmes côté serveur.

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.

Et le 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 sous le capot, ce qui peut souvent être une bonne chose, mais parfois le résultat ne sera pas celui que vous attendiez. Les bogues se produiront simplement parce que vous n'utilisez pas de saisie (oui, les types sont facultatifs dans Groovy) et que vous ne faites pas assez attention. Et peut-être que vous ne remarquerez pas d'erreur avant qu'il ne soit trop tard. De plus, il est très tentant d’écrire des pages simples pour impressionner vos collègues. Et toi. Mais ces lignes de code puissantes peuvent ne pas être aussi explicites pour vos collègues. Ou même pour 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 infrastructure actuelle l'exige. Surtout avec le nombre croissant de startups ces jours-ci, il est important de se concentrer sur les tâches qui comptent vraiment et d'être aussi efficace que possible. Le temps est en effet de l'argent et le temps de mise sur le marché est critique. Vous devez être capable d'agir rapidement et de mettre en œuvre la solution avant que le temps ne s'écoule et que votre concurrence ne vous batte.

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

En relation: Pourquoi vous devez déjà mettre à niveau vers Java 8