Meilleures pratiques à suivre lors du développement de l'application Grails

Question

Lors du développement d'un Graal de l'application, ce que vous considérez être les "meilleures pratiques" et pourquoi? Je ne suis pas intéressé par un débat sur les meilleures pratiques, mais un ou plusieurs états sauvegardés avec une justification et/ou une description du moment où la meilleure pratique s'applique et quand il ne fonctionne pas. Je ne crois pas qu'il y est un meilleur moyen de développer le Graal des applications, mais qu'il y a un certain nombre de lignes directrices qui permettront aux plus maintenable des applications avec moins de bugs qui rôdent dans les.

Mon expérience du Graal, c'est qu'il offre beaucoup de fonctionnalités qu'il y a une tentation de les utiliser tous dans une seule application, ce qui entraîne dans certains des pires code spaghetti que j'ai vu depuis que j'ai débogué un programme Fortran avec les instructions GOTO dans et hors d'une partie de la boucle.

Nous savons tous comment le Graal crée un lieu pour les classes de domaine, des services, des vues, contrôleurs, etc. Ce genre de fonctions appartiennent à ces endroits? Quelles sont les règles de base vous aider à faire la bonne chose? Quelles sont Graal odeurs de code?

Answer 1

1. Comprendre le Graal des conventions. Graal est la convention à moteur; et les conventions sont comment Graal peut faire beaucoup de sa magie pour vous. Les points de vue devraient seulement être vues. Les contrôleurs doivent juste être des contrôleurs. Les Services et les objets de Modèle doit contenir toute la logique de votre application. Cela signifie que lorsque vous cliquez sur un lien, ou invoquer un point de terminaison, vous appelez un Contrôleur. Le contrôleur d'invoquer un service (ce qui pourrait à son tour faire appel à d'autres services) et d'en donner une description concise de réponse. Le service sera de retour modèle des objets ou des données au contrôleur, qui va simplement rendre une réponse appropriée. Services transactionnels, donc tout ce qui touche à la base de données devrait aller dans un service.

2. Test. Test. Test un peu plus. Les tests est la meilleure façon de vous assurer que vous pouvez ajouter des fonctionnalités sans casser de nouvelles fonctionnalités, c'est à dire que votre projet est plus facile à maintenir.

3. L'Injection De Dépendance. Vous avez besoin de mettre vos composants dans le graal-app/dossier. Services aller dans le dossier des services. Les contrôleurs aller dans le dossier controllers. Si vous avez une Chose le modèle objet, et vous avez besoin d'un contrôleur et de service, puis votre contrôleur et le service devrait être nommé ThingController et ThingService. Pour obtenir le ThingService dans votre ThingController, mis def thingService dans votre contrôleur, et le graal sera autowire pour vous. Si vous ne suivez pas les conventions de nommage et les règles pour l'endroit où placer les différentes composantes, l'permettra à l'autowiring peut échouer.

4. Comprendre les technologies sous-jacentes, à savoir Spring et Hibernate. Vous allez rencontrer des problèmes de modélisation votre domaine d'objets et de les amener à travailler ensemble. Graal est vraiment une productivité élevée, mais si vous ne comprenez pas comment Hibernate œuvres, vous allez à se perdre facilement lorsque vous essayez d'obtenir votre persistance à se comporter de la façon dont vous le souhaitez.

5. Groovy est pas Java. Beaucoup de Java connaissances permettront de bien vous servir. Mais Groovy est un langage dynamique et Graal a son propre ensemble de problèmes qui découlent de Groovy. Vous obtiendrez d'exécution questions autour de taper dans Graal que vous éviter en grande partie avec Java. Test permet de avec ce.

Ces choses semblent évidentes, mais de nombreuses questions se posent autour de ces questions.

Answer 2

1. Évitez la tentation de mettre beaucoup de logique dans la couche web. Pour les vues, s'efforcer de les rendre aussi simple que possible. Mettre autant de passe-partout dans vos mises en page. Éviter conditionnel la logique comme la peste. Divisé le contenu partagé dans des modèles et des g:render d'eux. Construire votre propre bibliothèque de tags pour le commun des éléments de l'INTERFACE.

2. De même, gardez vos contrôleurs aussi simple que possible. Inexpérimentés, les développeurs semblent avoir l'habitude de jeter le tout dans le contrôleur, car il semble plus évident. Quelques conseils: les requêtes et la récupération de l'objet de la logique peut aller dans des objets du domaine. Si vous voyez withTransaction() et besoin transactionnelle comportement, c'est un bon candidat pour un service. Si vous avez des complexes de liaison de données, le diviser en un objet de commande.

3. Pour les objets du domaine, de prendre avantage de la possibilité de remplacer les setters et getters pour faire de propriétés plus facile de travailler avec. Création de courts-requêtes nommées et le chaînage est une excellente façon de décomposer la requête complexe de la logique. Tout ce qui s'applique à un seul objet de ce type avec peu de dépendances devrait aller dans le domaine objet de la classe. Garder la logique spécifique à l'objet, si. De plus logique métier complexe qui traite avec des groupes d'objets appartient dans les services.

4. En cas de doute, il peut aller dans un service. Les Services devraient être apatrides. Si vous trouvez que vous avez besoin de stocker l'état, vous avez probablement besoin d'un nouveau domaine d'objet.

Answer 3

Ce que je peux penser...

1. Tester autant que vous le pouvez avec des tests unitaires, pas de tests d'intégration. Les tests unitaires sont des moyens plus rapides à exécuter/déboguer et d'appliquer de couplage faible mieux. Utiliser mockDomain(), mockLogging() etc.
2. Utiliser grails console pour tester et explorer votre code dans la nature. Intégrer une console Groovy dans votre INTERFACE utilisateur web - c'est un outil précieux pour examiner l'intérieur d'une application en cours d'exécution.
3. Utilisez les objets de domaine à domaine du modèle logique. Le déplacement de domaine logique de Services est une gueule de bois des inconvénients couches de persistance.
4. Garder les Contrôleurs de mémoire. Si la logique peut être exprimé dans des termes d'une classe spécifique, déplacer la logique ou de créer une nouvelle classe. Tester ensuite.
5. Des calques distincts. Garder la logique de domaine de classes du domaine. Garder la logique de présentation dans les contrôleurs/points de vue.
6. transactional Service n'est pas la seule façon de faire une transaction. Invoquant DomainClass.withTransaction{ ...a couple of lines here... } de Contrôleur est très bien, tant qu'ils obéissent à #4.
7. Tendre à la perfection, contrairement à Java, il est réalisable :D Faire connaître la technologie. Utilisez les Constructeurs, les plugins adéquats, les Commandes, la métaprogrammation, que ce soit, afin de rendre votre code plus court, plus lisible, groovier.

Answer 4

1. Développer ré-utilisable parties de votre application comme le Graal des plugins. Ces plugins peuvent être testées individuellement et à retirer de la complexité de votre application principale(s). Envisager de publier les plugins dans le public référentiel de plug-in si vous pensez que d'autres puissent en bénéficier.

2. Utilisez la libération (précédemment connu en tant que maven-éditeur) plugin de déployer en interne des plugins à votre référentiel.

3. Familiarisez-vous avec les ressources plugin pour la manipulation des ressources statiques. Ce plugin va être une partie de Graal 1.4 et sera utilisé par de nombreux plugins.

4. N'ayez pas peur de regarder dans le code source de la troisième partie de plugins que vous utilisez ou le Graal lui-même d'ailleurs (ce qui m'a sauvé tant de fois!). Graal et les plus populaires des plugins d'accueil de leur code source sur GitHub, il est très pratique pour parcourir le code, la fourche des projets et contribuer patchs.