Groovy - Bauherren
Während des Softwareentwicklungsprozesses verbringen Entwickler manchmal viel Zeit mit dem Erstellen von Datenstrukturen, Domänenklassen, XML, GUI-Layouts, Ausgabestreams usw. Und manchmal führt der Code, der zum Erstellen dieser spezifischen Anforderungen verwendet wird, zur Wiederholung desselben Snippets von Code an vielen Stellen. Hier kommen Groovy Builder ins Spiel. Groovy verfügt über Builder, mit denen Standardobjekte und -strukturen erstellt werden können. Diese Builder sparen Zeit, da Entwickler keinen eigenen Code schreiben müssen, um diese Builder zu erstellen. In diesem Kapitel werden wir uns die verschiedenen Builder ansehen, die in groovy verfügbar sind.
Swing Builder
In Groovy kann man auch grafische Benutzeroberflächen mit den in Groovy verfügbaren Swing Buildern erstellen. Die Hauptklasse für die Entwicklung von Swing-Komponenten ist die SwingBuilder-Klasse. Diese Klasse verfügt über viele Methoden zum Erstellen grafischer Komponenten wie -
JFrame - Hiermit erstellen Sie das Rahmenelement.
JTextField - Dies wird zum Erstellen der Textfeldkomponente verwendet.
Schauen wir uns ein einfaches Beispiel zum Erstellen einer Swing-Anwendung mit der SwingBuilder-Klasse an. Im folgenden Beispiel sehen Sie die folgenden Punkte:
Sie müssen die Klassen groovy.swing.SwingBuilder und javax.swing. * Importieren.
Alle in der Swing-Anwendung angezeigten Komponenten sind Teil der SwingBuilder-Klasse.
Für den Rahmen selbst können Sie die anfängliche Position und Größe des Rahmens angeben. Sie können auch den Titel des Rahmens angeben.
Sie müssen die Visibility-Eigenschaft auf true setzen, damit der Frame angezeigt wird.
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)Die Ausgabe des obigen Programms ist unten angegeben. Die folgende Ausgabe zeigt einen JFrame zusammen mit einem JLabel mit einem Text von Hello World.
Schauen wir uns unser nächstes Beispiel zum Erstellen eines Eingabebildschirms mit Textfeldern an. Im folgenden Beispiel möchten wir ein Formular erstellen, das Textfelder für Schülernamen, Fach und Schulnamen enthält. Im folgenden Beispiel sehen Sie die folgenden wichtigen Punkte:
- Wir definieren ein Layout für unsere Steuerelemente auf dem Bildschirm. In diesem Fall verwenden wir das Rasterlayout.
- Wir verwenden eine Ausrichtungseigenschaft für unsere Beschriftungen.
- Wir verwenden die textField-Methode zum Anzeigen von Textfeldern auf dem Bildschirm.
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)Die Ausgabe des obigen Programms ist unten angegeben -
Ereignishandler
Schauen wir uns nun die Event-Handler an. Ereignishandler werden für Schaltflächen verwendet, um eine Art Verarbeitung durchzuführen, wenn eine Schaltfläche gedrückt wird. Jeder Pseudomethodenaufruf für Schaltflächen enthält den Parameter actionPerformed. Dies stellt einen Codeblock dar, der als Abschluss dargestellt wird.
Schauen wir uns unser nächstes Beispiel zum Erstellen eines Bildschirms mit 2 Schaltflächen an. Wenn eine der Tasten gedrückt wird, wird eine entsprechende Nachricht an den Konsolenbildschirm gesendet. Im folgenden Beispiel sehen Sie die folgenden wichtigen Punkte:
Für jede definierte Schaltfläche verwenden wir die actionPerformed-Methode und definieren einen Abschluss, um beim Klicken auf die Schaltfläche eine Ausgabe an die Konsole zu senden.
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)Die Ausgabe des obigen Programms ist unten angegeben. Wenn Sie auf eine der beiden Schaltflächen klicken, wird die erforderliche Nachricht an den Konsolenprotokollbildschirm gesendet.
Eine andere Variante des obigen Beispiels besteht darin, Methoden zu definieren, die als Handler fungieren können. Im folgenden Beispiel definieren wir zwei Handler von DisplayA und 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)Die Ausgabe des obigen Programms würde dieselbe bleiben wie im vorherigen Beispiel.
DOM Builder
Der DOM-Builder kann zum Parsen von HTML, XHTML und XML und zum Konvertieren in einen W3C-DOM-Baum verwendet werden.
Das folgende Beispiel zeigt, wie der DOM-Builder verwendet werden kann.
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
Der JsonBuilder wird zum Erstellen von Objekten vom Typ json verwendet.
Das folgende Beispiel zeigt, wie der Builder Json verwendet werden kann.
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());Die Ausgabe des obigen Programms ist unten angegeben. Die Ausgabe clearlt zeigt, dass der Jsonbuilder das json-Objekt aus einer strukturierten Gruppe von Knoten erstellen konnte.
{"students":{"student":{"studentname":"Joe","studentid":"1","Marks":{"Subject1":10,
"S ubject2":20,"Subject3":30}}}}Der jsonbuilder kann auch eine Liste aufnehmen und in ein json-Objekt konvertieren. Das folgende Beispiel zeigt, wie dies erreicht werden kann.
def builder = new groovy.json.JsonBuilder()
def lst = builder([1, 2, 3])
println(builder.toString());Die Ausgabe des obigen Programms ist unten angegeben.
[1,2,3]Der jsonBuilder kann auch für Klassen verwendet werden. Das folgende Beispiel zeigt, wie Objekte einer Klasse zu Eingaben in den json-Builder werden können.
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)Die Ausgabe des obigen Programms ist unten angegeben.
[{"name":"Joe"},{"name":"Mark"},{"name":"John"}]NodeBuilder
NodeBuilder wird zum Erstellen verschachtelter Bäume von Node-Objekten für die Verarbeitung beliebiger Daten verwendet. Ein Beispiel für die Verwendung eines Nodebuilders ist unten dargestellt.
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 ist ein Builder zum Generieren einer Dateiverzeichnisstruktur aus einer Spezifikation. Im Folgenden finden Sie ein Beispiel für die Verwendung des FileTreeBuilder.
tmpDir = File.createTempDir()
def fileTreeBuilder = new FileTreeBuilder(tmpDir)
fileTreeBuilder.dir('main') {
dir('submain') {
dir('Tutorial') {
file('Sample.txt', 'println "Hello World"')
}
}
}Aus der Ausführung des obigen Codes wird eine Datei mit dem Namen sample.txt im Ordner main / submain / Tutorial erstellt. Und die Datei sample.txt enthält den Text „Hello World“.