Groovy - Costruttori
Durante il processo di sviluppo del software, a volte gli sviluppatori trascorrono molto tempo nella creazione di strutture dati, classi di dominio, XML, layout GUI, flussi di output ecc. Ea volte il codice utilizzato per creare questi requisiti specifici si traduce nella ripetizione dello stesso frammento di codice in molti posti. È qui che entrano in gioco i costruttori di Groovy. Groovy dispone di builder che possono essere utilizzati per creare oggetti e strutture standard. Questi builder risparmiano tempo poiché lo sviluppatore non ha bisogno di scrivere il proprio codice per creare questi builder. Nel corso di questo capitolo vedremo i diversi builder disponibili in groovy.
Costruttore di oscillazioni
In groovy si possono anche creare interfacce utente grafiche utilizzando i costruttori di swing disponibili in groovy. La classe principale per lo sviluppo di componenti swing è la classe SwingBuilder. Questa classe ha molti metodi per creare componenti grafici come:
JFrame - Serve per creare l'elemento del telaio.
JTextField - Viene utilizzato per creare il componente textfield.
Diamo un'occhiata a un semplice esempio di come creare un'applicazione Swing utilizzando la classe SwingBuilder. Nell'esempio seguente, puoi vedere i seguenti punti:
È necessario importare le classi groovy.swing.SwingBuilder e javax.swing. *.
Tutti i componenti visualizzati nell'applicazione Swing fanno parte della classe SwingBuilder.
Per il frame stesso, è possibile specificare la posizione iniziale e le dimensioni del frame. È inoltre possibile specificare il titolo del frame.
È necessario impostare la proprietà Visibility su true per visualizzare il frame.
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)
L'output del programma di cui sopra è fornito di seguito. Il seguente output mostra un JFrame insieme a un JLabel con un testo di Hello World.
Diamo un'occhiata al nostro prossimo esempio per creare una schermata di input con caselle di testo. Nell'esempio seguente, vogliamo creare un modulo che abbia caselle di testo per il nome dello studente, l'argomento e il nome della scuola. Nell'esempio seguente, puoi vedere i seguenti punti chiave:
- Stiamo definendo un layout per i nostri controlli sullo schermo. In questo caso stiamo usando il layout a griglia.
- Stiamo usando una proprietà di allineamento per le nostre etichette.
- Stiamo usando il metodo textField per visualizzare le caselle di testo sullo schermo.
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)
L'output del programma di cui sopra è dato di seguito:
Gestori di eventi
Ora esaminiamo i gestori di eventi. I gestori di eventi vengono utilizzati affinché il pulsante esegua una sorta di elaborazione quando viene premuto un pulsante. Ogni chiamata allo pseudometodo del pulsante include il parametro actionPerformed. Questo rappresenta un blocco di codice presentato come chiusura.
Diamo un'occhiata al nostro prossimo esempio per la creazione di una schermata con 2 pulsanti. Quando uno dei pulsanti viene premuto, viene inviato un messaggio corrispondente allo schermo della console. Nell'esempio seguente, puoi vedere i seguenti punti chiave:
Per ogni pulsante definito, utilizziamo il metodo actionPerformed e definiamo una chiusura per inviare un output alla console quando si fa clic sul pulsante.
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)
L'output del programma di cui sopra è fornito di seguito. Quando si fa clic su uno dei pulsanti, il messaggio richiesto viene inviato alla schermata del registro della console.
Un'altra variazione dell'esempio precedente consiste nel definire metodi che possono agire come gestori. Nell'esempio seguente stiamo definendo 2 gestori di DisplayA e 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)
L'output del programma precedente rimarrebbe lo stesso dell'esempio precedente.
DOM Builder
Il generatore DOM può essere utilizzato per analizzare HTML, XHTML e XML e convertirlo in un albero DOM W3C.
Il seguente esempio mostra come utilizzare il generatore 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
JsonBuilder viene utilizzato per creare oggetti di tipo json.
L'esempio seguente mostra come utilizzare il builder 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());
L'output del programma di cui sopra è fornito di seguito. L'output clearlt mostra che Jsonbuilder è stato in grado di creare l'oggetto json da un insieme strutturato di nodi.
{"students":{"student":{"studentname":"Joe","studentid":"1","Marks":{"Subject1":10,
"S ubject2":20,"Subject3":30}}}}
Il jsonbuilder può anche prendere in un elenco e convertirlo in un oggetto json. L'esempio seguente mostra come eseguire questa operazione.
def builder = new groovy.json.JsonBuilder()
def lst = builder([1, 2, 3])
println(builder.toString());
L'output del programma di cui sopra è fornito di seguito.
[1,2,3]
Il jsonBuilder può essere utilizzato anche per le classi. L'esempio seguente mostra come gli oggetti di una classe possono diventare input per il generatore di 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)
L'output del programma di cui sopra è fornito di seguito.
[{"name":"Joe"},{"name":"Mark"},{"name":"John"}]
NodeBuilder
NodeBuilder viene utilizzato per creare alberi nidificati di oggetti Node per la gestione di dati arbitrari. Di seguito è mostrato un esempio di utilizzo di 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 è un builder per generare una struttura di directory di file da una specifica. Di seguito è riportato un esempio di come può essere utilizzato FileTreeBuilder.
tmpDir = File.createTempDir()
def fileTreeBuilder = new FileTreeBuilder(tmpDir)
fileTreeBuilder.dir('main') {
dir('submain') {
dir('Tutorial') {
file('Sample.txt', 'println "Hello World"')
}
}
}
Dall'esecuzione del codice sopra verrà creato un file chiamato sample.txt nella cartella main / submain / Tutorial. E il file sample.txt avrà il testo di "Hello World".