Groovy - Constructeurs

Au cours du processus de développement logiciel, les développeurs passent parfois beaucoup de temps à créer des structures de données, des classes de domaine, du XML, des dispositions d'interface graphique, des flux de sortie, etc. Et parfois le code utilisé pour créer ces exigences spécifiques entraîne la répétition du même extrait de code dans de nombreux endroits. C'est là que les constructeurs Groovy entrent en jeu. Groovy a des générateurs qui peuvent être utilisés pour créer des objets et des structures standard. Ces générateurs font gagner du temps car les développeurs n'ont pas besoin d'écrire leur propre code pour créer ces générateurs. Dans la suite de ce chapitre, nous examinerons les différents builders disponibles dans groovy.

Constructeur de balançoire

Dans groovy, on peut également créer des interfaces utilisateur graphiques en utilisant les swing builders disponibles dans groovy. La classe principale pour le développement de composants swing est la classe SwingBuilder. Cette classe a de nombreuses méthodes pour créer des composants graphiques tels que -

  • JFrame - C'est pour créer l'élément frame.

  • JTextField - Ceci est utilisé pour créer le composant textfield.

Regardons un exemple simple de création d'une application Swing à l'aide de la classe SwingBuilder. Dans l'exemple suivant, vous pouvez voir les points suivants -

  • Vous devez importer les classes groovy.swing.SwingBuilder et javax.swing. *.

  • Tous les composants affichés dans l'application Swing font partie de la classe SwingBuilder.

  • Pour le cadre lui-même, vous pouvez spécifier l'emplacement initial et la taille du cadre. Vous pouvez également spécifier le titre du cadre.

  • Vous devez définir la propriété Visibility sur true pour que le cadre soit affiché.

import groovy.swing.SwingBuilder 
import javax.swing.* 

// Create a builder 
def myapp = new SwingBuilder()

// Compose the builder 
def myframe = myapp.frame(title : 'Tutorials Point', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE {         
      label(text : 'Hello world')
   } 
	
// The following  statement is used for displaying the form 
frame.setVisible(true)

La sortie du programme ci-dessus est donnée ci-dessous. La sortie suivante montre un JFrame avec un JLabel avec un texte de Hello World.

Regardons notre prochain exemple pour créer un écran de saisie avec des zones de texte. Dans l'exemple suivant, nous voulons créer un formulaire contenant des zones de texte pour le nom de l'étudiant, le sujet et le nom de l'école. Dans l'exemple suivant, vous pouvez voir les points clés suivants -

  • Nous définissons une disposition pour nos contrôles à l'écran. Dans ce cas, nous utilisons la disposition en grille.
  • Nous utilisons une propriété d'alignement pour nos étiquettes.
  • Nous utilisons la méthode textField pour afficher les zones de texte à l'écran.
import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.*
 
// Create a builder 
def myapp = new SwingBuilder() 

// Compose the builder 
def myframe = myapp.frame(title : 'Tutorials Point', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) { 
      panel(layout: new GridLayout(3, 2, 5, 5)) { 
         label(text : 'Student Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10) 
			
         label(text : 'Subject Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10)
			
         label(text : 'School Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10) 
      } 
   } 
	
// The following  statement is used for displaying the form 
myframe.setVisible(true)

La sortie du programme ci-dessus est donnée ci-dessous -

Gestionnaires d'événements

Regardons maintenant les gestionnaires d'événements. Les gestionnaires d'événements sont utilisés pour le bouton pour effectuer une sorte de traitement lorsqu'un bouton est enfoncé. Chaque appel de pseudo-méthode de bouton inclut le paramètre actionPerformed. Cela représente un bloc de code présenté comme une fermeture.

Regardons notre prochain exemple pour créer un écran avec 2 boutons. Lorsque l'un des boutons est enfoncé, un message correspondant est envoyé à l'écran de la console. Dans l'exemple suivant, vous pouvez voir les points clés suivants -

  • Pour chaque bouton défini, nous utilisons la méthode actionPerformed et définissons une fermeture pour envoyer une sortie à la console lorsque le bouton est cliqué.

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
	
      button(text : 'Option A', actionPerformed : {
         println 'Option A chosen'
      })
		
      button(text : 'Option B', actionPerformed : {
         println 'Option B chosen'
      })
   }
}
  
def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : 'Which Option do you want', horizontalAlignment : 
      JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}
  
def myframe = myapp.frame(title : 'Tutorials Point', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE){
      mainPanel()
   }
	
myframe.setVisible(true)

La sortie du programme ci-dessus est donnée ci-dessous. Lorsque vous cliquez sur l'un des boutons, le message requis est envoyé à l'écran du journal de la console.

Une autre variante de l'exemple ci-dessus consiste à définir des méthodes qui peuvent jouer le rôle de gestionnaires. Dans l'exemple suivant, nous définissons 2 gestionnaires de DisplayA et DisplayB.

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def DisplayA = {
   println("Option A") 
} 

def DisplayB = {
   println("Option B")
}

def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
      button(text : 'Option A', actionPerformed : DisplayA) 
      button(text : 'Option B', actionPerformed : DisplayB)
   }
}  

def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : 'Which Option do you want', horizontalAlignment : JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}  

def myframe = myapp.frame(title : 'Tutorials Point', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) {
      mainPanel()
   } 
	
myframe.setVisible(true)

La sortie du programme ci-dessus resterait la même que celle de l'exemple précédent.

Générateur DOM

Le générateur DOM peut être utilisé pour analyser HTML, XHTML et XML et les convertir en une arborescence DOM W3C.

L'exemple suivant montre comment le générateur DOM peut être utilisé.

String records = '''
   <library>
	
      <Student>
         <StudentName division = 'A'>Joe</StudentName>
         <StudentID>1</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = 'B'>John</StudentName>
         <StudentID>2</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = 'C'>Mark</StudentName>
         <StudentID>3</StudentID>
      </Student>
		
   </library>'''
   
def rd = new StringReader(records) 
def doc = groovy.xml.DOMBuilder.parse(rd)

JsonBuilder

Le JsonBuilder est utilisé pour créer des objets de type json.

L'exemple suivant montre comment le générateur Json peut être utilisé.

def builder = new groovy.json.JsonBuilder() 

def root = builder.students {
   student {
      studentname 'Joe'
      studentid '1'
		
      Marks(
         Subject1: 10,
         Subject2: 20,
         Subject3:30,
      )
   } 
} 
println(builder.toString());

La sortie du programme ci-dessus est donnée ci-dessous. La sortie clearlt montre que le Jsonbuilder a pu construire l'objet json à partir d'un ensemble structuré de nœuds.

{"students":{"student":{"studentname":"Joe","studentid":"1","Marks":{"Subject1":10,
"S ubject2":20,"Subject3":30}}}}

Le jsonbuilder peut également prendre une liste et la convertir en objet json. L'exemple suivant montre comment cela peut être accompli.

def builder = new groovy.json.JsonBuilder() 
def lst = builder([1, 2, 3]) 
println(builder.toString());

La sortie du programme ci-dessus est donnée ci-dessous.

[1,2,3]

Le jsonBuilder peut également être utilisé pour les classes. L'exemple suivant montre comment les objets d'une classe peuvent devenir des entrées dans le générateur json.

def builder = new groovy.json.JsonBuilder() 

class Student {
   String name  
} 

def studentlist = [new Student (name: "Joe"), new Student (name: "Mark"), 
   new Student (name: "John")] 
	
builder studentlist, { Student student ->name student.name} 
println(builder)

La sortie du programme ci-dessus est donnée ci-dessous.

[{"name":"Joe"},{"name":"Mark"},{"name":"John"}]

NodeBuilder

NodeBuilder est utilisé pour créer des arborescences imbriquées d'objets Node pour gérer des données arbitraires. Un exemple d'utilisation d'un Nodebuilder est présenté ci-dessous.

def nodeBuilder = new NodeBuilder() 

def studentlist = nodeBuilder.userlist {
   user(id: '1', studentname: 'John', Subject: 'Chemistry')
   user(id: '2', studentname: 'Joe', Subject: 'Maths')
   user(id: '3', studentname: 'Mark', Subject: 'Physics') 
} 

println(studentlist)

FileTreeBuilder

FileTreeBuilder est un générateur pour générer une structure de répertoire de fichiers à partir d'une spécification. Voici un exemple de la façon dont FileTreeBuilder peut être utilisé.

tmpDir = File.createTempDir() 
def fileTreeBuilder = new FileTreeBuilder(tmpDir) 

fileTreeBuilder.dir('main') {
   dir('submain') {
      dir('Tutorial') {
        file('Sample.txt', 'println "Hello World"')
      }
   } 
}

A partir de l'exécution du code ci-dessus, un fichier appelé sample.txt sera créé dans le dossier main / submain / Tutorial. Et le fichier sample.txt contiendra le texte «Hello World».