Groovy - Constructores

Durante el proceso de desarrollo de software, a veces los desarrolladores dedican mucho tiempo a crear estructuras de datos, clases de dominio, XML, diseños de GUI, flujos de salida, etc., y a veces el código utilizado para crear estos requisitos específicos da como resultado la repetición del mismo fragmento de código en muchos lugares. Aquí es donde entran en juego los constructores de Groovy. Groovy tiene constructores que se pueden usar para crear estructuras y objetos estándar. Estos constructores ahorran tiempo ya que el desarrollador no necesita escribir su propio código para crear estos constructores. En la primera parte de este capítulo veremos los diferentes constructores disponibles en groovy.

Constructor de columpios

En groovy también se pueden crear interfaces gráficas de usuario utilizando los constructores de columpios disponibles en groovy. La clase principal para desarrollar componentes de swing es la clase SwingBuilder. Esta clase tiene muchos métodos para crear componentes gráficos como:

JFrame - Esto es para crear el elemento marco.
JTextField - Se utiliza para crear el componente de campo de texto.

Veamos un ejemplo simple de cómo crear una aplicación Swing usando la clase SwingBuilder. En el siguiente ejemplo, puede ver los siguientes puntos:

Necesita importar las clases groovy.swing.SwingBuilder y javax.swing. *.
Todos los componentes que se muestran en la aplicación Swing son parte de la clase SwingBuilder.
Para el marco en sí, puede especificar la ubicación inicial y el tamaño del marco. También puede especificar el título del marco.
Debe establecer la propiedad Visibility en true para que se muestre el marco.

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)

El resultado del programa anterior se muestra a continuación. La siguiente salida muestra un JFrame junto con un JLabel con un texto de Hello World.

Veamos nuestro siguiente ejemplo para crear una pantalla de entrada con cuadros de texto. En el siguiente ejemplo, queremos crear un formulario que tenga cuadros de texto para el nombre del estudiante, la materia y el nombre de la escuela. En el siguiente ejemplo, puede ver los siguientes puntos clave:

Estamos definiendo un diseño para nuestros controles en la pantalla. En este caso estamos usando el diseño de cuadrícula.
Estamos usando una propiedad de alineación para nuestras etiquetas.
Estamos usando el método textField para mostrar cuadros de texto en la pantalla.

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 salida del programa anterior se da a continuación:

Controladores de eventos

Ahora veamos los controladores de eventos. Los controladores de eventos se utilizan para que el botón realice algún tipo de procesamiento cuando se presiona un botón. Cada llamada de pseudometodo de botón incluye el parámetro actionPerformed. Esto representa un bloque de código presentado como un cierre.

Veamos nuestro siguiente ejemplo para crear una pantalla con 2 botones. Cuando se presiona cualquiera de los botones, se envía el mensaje correspondiente a la pantalla de la consola. En el siguiente ejemplo, puede ver los siguientes puntos clave:

Para cada botón definido, usamos el método actionPerformed y definimos un cierre para enviar alguna salida a la consola cuando se hace clic en el botón.

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)

El resultado del programa anterior se muestra a continuación. Cuando hace clic en cualquiera de los botones, el mensaje requerido se envía a la pantalla de registro de la consola.

Otra variación del ejemplo anterior es definir métodos que pueden actuar como controladores. En el siguiente ejemplo, definimos 2 controladores de DisplayA y 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)

El resultado del programa anterior seguirá siendo el mismo que el del ejemplo anterior.

Constructor DOM

El constructor DOM se puede utilizar para analizar HTML, XHTML y XML y convertirlo en un árbol DOM W3C.

El siguiente ejemplo muestra cómo se puede utilizar el constructor DOM.

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

El JsonBuilder se utiliza para crear objetos de tipo json.

El siguiente ejemplo muestra cómo se puede utilizar el constructor Json.

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());

El resultado del programa anterior se muestra a continuación. La salida clearlt muestra que Jsonbuilder pudo construir el objeto json a partir de un conjunto estructurado de nodos.

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

El jsonbuilder también puede tomar una lista y convertirla en un objeto json. El siguiente ejemplo muestra cómo se puede lograr esto.

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

El resultado del programa anterior se muestra a continuación.

[1,2,3]

El jsonBuilder también se puede utilizar para clases. El siguiente ejemplo muestra cómo los objetos de una clase pueden convertirse en entradas para el constructor 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)

El resultado del programa anterior se muestra a continuación.

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

NodeBuilder

NodeBuilder se utiliza para crear árboles anidados de objetos Node para manejar datos arbitrarios. A continuación se muestra un ejemplo del uso de un Nodebuilder.

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 es un constructor para generar una estructura de directorio de archivos a partir de una especificación. A continuación se muestra un ejemplo de cómo se puede utilizar FileTreeBuilder.

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

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

A partir de la ejecución del código anterior, se creará un archivo llamado sample.txt en la carpeta main / submain / Tutorial. Y el archivo sample.txt tendrá el texto "Hola mundo".

↰ Previous page Next page ↱