Groovy-概要

Groovyは、Javaプラットフォームに基づいたオブジェクト指向言語です。 Groovy 1.0は2007年1月2日にリリースされ、Groovy 2.4が現在のメジャーリリースです。 Groovyは、Apache License v 2.0を介して配布されます。

Groovyの機能

Groovyには次の機能があります-

静的タイピングと動的タイピングの両方をサポートします。
オペレーターのオーバーロードのサポート。
リストおよび連想配列のネイティブ構文。
正規表現のネイティブサポート。
XMLやHTMLなどのさまざまなマークアップ言語のネイティブサポート。
JavaとGroovyの構文は非常に似ているため、GroovyはJava開発者にとって簡単です。
既存のJavaライブラリを使用できます。
Groovyはjava.lang.Objectを拡張します。

Groovyの公式Webサイトはhttp://www.groovy-lang.org/です。

Groovy公式ウェブサイト

Groovy-環境

Groovy環境をセットアップするには、さまざまな方法があります。

バイナリのダウンロードとインストール-http://www.groovy-lang.org/downloadl[www.groovy-lang.org/downloadl]リンクにアクセスして、Windowsインストーラセクションを取得します。このオプションをクリックして、Groovyインストーラーのダウンロードを開始します。

Groovy環境のセットアップ

インストーラーを起動したら、以下の手順に従ってインストールを完了します。

ステップ1 *-言語インストーラーを選択します。

言語インストーラー

ステップ2 *-次の画面で[次へ]ボタンをクリックします。

Groovy 2.4.5セットアップ

ステップ3 *-[同意する]ボタンをクリックします。

ライセンス契約

ステップ4 *-デフォルトのコンポーネントを受け入れて、[次へ]ボタンをクリックします。

コンポーネントを選択

ステップ5 *-適切な宛先フォルダーを選択し、[次へ]ボタンをクリックします。

インストール場所

ステップ6 *-[インストール]ボタンをクリックして、インストールを開始します。

スタートメニューフォルダー

ステップ7 *-インストールが完了したら、[次へ]ボタンをクリックして構成を開始します。

インストール完了

ステップ8 *-デフォルトオプションを選択し、[次へ]ボタンをクリックします。

環境変数

ステップ9 *-デフォルトのファイルの関連付けを受け入れ、[次へ]ボタンをクリックします。

ファイルの関連付け

ステップ10 *-[完了]ボタンをクリックして、インストールを完了します。

完了ボタン

上記の手順に従うと、Groovyの本格的な統合開発環境を必要とせずに、Groovy言語のさまざまな側面をテストするのに役立つGroovyインストールの一部であるgroovyシェルを開始できます。これは、コマンドプロンプトからgroovyshコマンドを実行することで実行できます。

コマンドGroovyshの実行

Mavenまたはgradleビルドの一部としてgroovyバイナリを含める場合、次の行を追加できます。

Gradle

'org.codehaus.groovy:groovy:2.4.5'

メーベン

<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy</artifactId>
<version>2.4.5</version>

Groovy-基本構文

Groovyの基本的な構文を理解するために、まず簡単なHello Worldプログラムを見てみましょう。

初めてのHello Worldプログラムを作成する

最初のHello Worldプログラムの作成は、次のコード行を入力するだけで簡単です-

class Example {
   static void main(String[] args) {
     //Using a simple println statement to print output to the console
      println('Hello World');
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Hello World

Groovyのインポートステートメント

importステートメントを使用して、コードで使用できる他のライブラリの機能をインポートできます。これは、 import キーワードを使用して行われます。

次の例は、おそらくHTMLまたはXMLマークアップを作成するために最も使用されるクラスの1つであるMarkupBuilderクラスの単純なインポートを使用する方法を示しています。

import groovy.xml.MarkupBuilder
def xml = new MarkupBuilder()

デフォルトでは、Groovyのコードには次のライブラリが含まれているため、明示的にインポートする必要はありません。

import java.lang.*
import java.util.*
import java.io.*
import java.net.*

import groovy.lang.*
import groovy.util. *

import java.math.BigInteger
import java.math.BigDecimal

Groovyのトークン

トークンは、キーワード、識別子、定数、文字列リテラル、またはシンボルのいずれかです。

println(“Hello World”);

上記のコード行には2つのトークンがあり、最初のトークンはキーワードprintln、次のトークンは「Hello World」の文字列リテラルです。

Groovyのコメント

コメントは、コードを文書化するために使用されます。 Groovyのコメントは、単一行でも複数行でもかまいません。

単一行コメントは、行の任意の位置で//を使用して識別されます。以下に例を示します-

class Example {
   static void main(String[] args) {
     //Using a simple println statement to print output to the console
      println('Hello World');
   }
}

複数行コメントは、先頭が/* で識別され、*/が複数行コメントの終わりを識別します。

class Example {
   static void main(String[] args) {
     /*This program is the first program
      This program shows how to display hello world*/
      println('Hello World');
   }
}

セミコロン

Javaプログラミング言語とは異なり、すべてのステートメントの終了後にセミコロンを付けることは必須ではありません。オプションです。

class Example {
   static void main(String[] args) {
      def x = 5
      println('Hello World');
   }
}

上記のプログラムを実行する場合、mainメソッドの両方のステートメントはエラーを生成しません。

識別子

識別子は、変数、関数、またはその他のユーザー定義変数を定義するために使用されます。識別子は、文字、ドル、またはアンダースコアで始まります。数字で始めることはできません。有効な識別子の例を次に示します-

def employeename
def student1
def student_name

*def* は、Groovyで識別子を定義するために使用されるキーワードです。

Hello Worldプログラムで識別子を使用する方法のコード例を次に示します。

class Example {
   static void main(String[] args) {
     //One can see the use of a semi-colon after each statement
      def x = 5;
      println('Hello World');
   }
}

上記の例では、変数 x が識別子として使用されています。

キーワード

名前が示すキーワードは、Groovyプログラミング言語で予約されている特別な単語です。次の表は、Groovyで定義されているキーワードのリストです。

as	assert	break	case
catch	class	const	continue
def	default	do	else
enum	extends	false	Finally
for	goto	if	implements
import	in	instanceof	interface
new	pull	package	return
super	switch	this	throw
throws	trait	true	try
while

空白

空白は、Java、Groovyなどのプログラミング言語で使用される用語で、空白、タブ、改行文字、コメントを表します。空白は、ステートメントの一部を別の部分から分離し、コンパイラーがステートメント内のある要素を特定できるようにします。

たとえば、次のコード例では、キーワード def と変数xの間に空白があります。これは、 def が使用する必要があるキーワードであり、xが定義する必要がある変数名であることをコンパイラが認識するようにするためです。

def x = 5;

リテラル

リテラルは、固定値をGroovyで表すための表記法です。 groovy言語には、整数、浮動小数点数、文字、文字列の表記があります。 Groovyプログラミング言語のリテラルの例を次に示します-

12
1.45
‘a’
“aa”

Groovy-データ型

どのプログラミング言語でも、さまざまな変数を使用してさまざまな種類の情報を保存する必要があります。変数は、値を保存するために予約されたメモリの場所に他なりません。これは、変数を作成するときに、変数に関連付けられた値を保存するためにメモリ内にスペースを確保することを意味します。

文字列、文字、ワイド文字、整数、浮動小数点、ブールなどのさまざまなデータ型の情報を保存することができます。変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約メモリに保存できるものを決定します。

組み込みデータ型

Groovyは、さまざまな組み込みデータ型を提供します。以下はGroovyで定義されているデータ型のリストです-

byte -これはバイト値を表すために使用されます。例は2です。
short -これは短い番号を表すために使用されます。例は10です。
int -これは整数を表すために使用されます。例は1234です。
long -これは、長い数値を表すために使用されます。例は10000090です。
float -32ビット浮動小数点数を表すために使用されます。例は12.34です。
double -これは、64ビット浮動小数点数を表すために使用されます。64ビット浮動小数点数は、より長い10進数表現であることがあり、時々必要になることがあります。例は12.3456565です。
char -これは単一の文字リテラルを定義します。例は「a」です。
ブール-これはブール値を表し、trueまたはfalseのいずれかです。
String -これらは、文字のチェーンの*フォーム*で表されるテキストリテラルです。たとえば、「Hello World」。

バインドされた値

次の表は、数値リテラルと10進数リテラルの最大許容値を示しています。

byte	-128 to 127
short	-32,768 to 32,767
int	-2,147,483,648 to 2,147,483,647
long	-9,223,372,036,854,775,808 to +9,223,372,036,854,775,807
float	1.40129846432481707e-45 to 3.40282346638528860e+38
double	4.94065645841246544e-324d to 1.79769313486231570e+308d

クラス数値

型プリミティブ型に加えて、次のオブジェクト型（ラッパー型と呼ばれることもあります）が許可されています-

java.lang.Byte
java.lang.Short
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double

さらに、次のクラスは、任意精度の算術演算をサポートするために使用できます-

Name	Description	Example
java.math.BigInteger	Immutable arbitrary-precision signed integral numbers	30g
java.math.BigDecimal	Immutable arbitrary-precision signed decimal numbers	3.5g

次のコード例は、さまざまな組み込みデータ型を使用する方法を示しています-

class Example {
   static void main(String[] args) {
     //Example of a int datatype
      int x = 5;

     //Example of a long datatype
      long y = 100L;

     //Example of a floating point datatype
      float a = 10.56f;

     //Example of a double datatype
      double b = 10.5e40;

     //Example of a BigInteger datatype
      BigInteger bi = 30g;

     //Example of a BigDecimal datatype
      BigDecimal bd = 3.5g;

      println(x);
      println(y);
      println(a);
      println(b);
      println(bi);
      println(bd);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Groovy-変数

Groovyの変数は2つの方法で定義できます-データ型に*ネイティブ構文*を使用するか、次はdefキーワードを使用して*です。変数定義の場合、型名を明示的に指定するか、代わりに「def」を使用することが必須です。これは、Groovyパーサーに必要です。

前の章で説明したように、Groovyには次の基本的なタイプの変数があります-

byte -これはバイト値を表すために使用されます。例は2です。
short -これは短い番号を表すために使用されます。例は10です。
int -これは整数を表すために使用されます。例は1234です。
long -これは、長い数値を表すために使用されます。例は10000090です。
float -32ビット浮動小数点数を表すために使用されます。例は12.34です。
double -これは、64ビット浮動小数点数を表すために使用されます。64ビット浮動小数点数は、より長い10進数表現であることがあり、時々必要になることがあります。例は12.3456565です。
char -これは単一の文字リテラルを定義します。例は「a」です。
ブール-これはブール値を表し、trueまたはfalseのいずれかです。
String -これらは、文字のチェーンの*フォーム*で表されるテキストリテラルです。たとえば、「Hello World」。

Groovyでは、後続の章で説明する配列、構造、クラスなどの変数の追加タイプも使用できます。

可変宣言

変数宣言は、変数のストレージを作成する場所と量をコンパイラーに指示します。

以下は、変数宣言の例です-

class Example {
   static void main(String[] args) {
     //x is defined as a variable
      String x = "Hello";

     //The value of the variable is printed to the console
      println(x);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Hello

変数の命名

変数の名前は、文字、数字、およびアンダースコア文字で構成できます。文字またはアンダースコアで始まる必要があります。 GroovyはJavaと同様に大文字と小文字を区別するプログラミング言語であるため、大文字と小文字は区別されます。

class Example {
   static void main(String[] args) {
     //Defining a variable in lowercase
      int x = 5;

     //Defining a variable in uppercase
      int X = 6;

     //Defining a variable with the underscore in it's name
      def _Name = "Joe";

      println(x);
      println(X);
      println(_Name);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

5
6
Joe

*x* と *X* は大文字と小文字が区別されるため、2つの異なる変数であることがわかります。3番目のケースでは、_Nameがアンダースコアで始まることがわかります。

変数の印刷

println関数を使用して、変数の現在の値を印刷できます。次の例は、これを実現する方法を示しています。

class Example {
   static void main(String[] args) {
     //Initializing 2 variables
      int x = 5;
      int X = 6;

     //Printing the value of the variables to the console
      println("The value of x is " + x + "The value of X is " + X);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

The value of x is 5 The value of X is 6

Groovy-オペレーター

演算子は、特定の数学的または論理的な操作を実行するようコンパイラーに指示する記号です。

Groovyには次の種類の演算子があります-

算術演算子
関係演算子
論理演算子
ビットごとの演算子
割り当て演算子

算術演算子

Groovy言語は、すべての言語として通常の算術演算子をサポートしています。以下はGroovyで利用可能な算術演算子です-

link：/groovy/groovy_arithmetic_operators [例を表示]

Operator	Description	Example
PLUS	Addition of two operands	1 PLUS 2 will give 3
−	Subtracts second operand from the first	2 − 1 will give 1
*	Multiplication of both operands	2* 2 will give 4
/	Division of numerator by denominator	3/2 will give 1.5
%	Modulus Operator and remainder of after an integer/float division	3 % 2 will give 1
PLUSPLUS	Incremental operators used to increment the value of an operand by 1	int x = 5; x＆plus;＆plus xは6を与えます
—	Incremental operators used to decrement the value of an operand by 1	int x = 5; x--; xは4を与える

関係演算子

関係演算子は、オブジェクトの比較を許可します。以下はGroovyで利用可能な関係演算子です-

リンク：/groovy/groovy_relational_operators [例を表示]

Operator	Description	Example
==	Tests the equality between two objects	2 == 2 will give true
!=	Tests the difference between two objects	3 != 2 will give true
<	Checks to see if the left objects is less than the right operand.	2 < 3 will give true
⇐	Checks to see if the left objects is less than or equal to the right operand.	2 ⇐ 3 will give true
>	Checks to see if the left objects is greater than the right operand.	3 > 2 will give true
>=	Checks to see if the left objects is greater than or equal to the right operand.	3 >= 2 will give true

論理演算子

論理演算子は、ブール式を評価するために使用されます。以下はGroovyで利用可能な論理演算子です-

リンク：/groovy/groovy_logical_operators [例を表示]

Operator	Description	Example
&&	This is the logical “and” operator	true && true will give true

This is the logical “or” operator	true
true will give true	!	This is the logical “not” operator

ビット演算子

Groovyは4つのビット演算子を提供します。以下はGroovyで利用可能なビットごとの演算子です-

リンク：/groovy/groovy_bitwise_operators [例を表示]

Sr.No	Operator & Description
1	& これはビット単位の「and」演算子です
2	*
これはビット単位の「or」演算子です	3
^ これはビット単位の「xor」または排他的論理和演算子です	4

これらの演算子を示す真理値表を次に示します。

p	q	p & q	p	q
p ^ q	0	0	0	0
0	0	1	0	1
1	1	1	1	1
0	1	0	0	1

割り当て演算子

Groovy言語には、代入演算子も用意されています。以下はGroovyで利用可能な代入演算子です-

リンク：/groovy/groovy_assignment_operators [例を表示]

Operator	Description	Example
+=	This adds right operand to the left operand and assigns the result to left operand.	def A = 5 A+=3 出力は8になります
-=	This subtracts right operand from the left operand and assigns the result to left operand	def A = 5 A-=3 出力は2になります
*=	This multiplies right operand with the left operand and assigns the result to left operand	def A = 5 A*=3 出力は15になります
/=	This divides left operand with the right operand and assigns the result to left operand	def A = 6 A/=3 出力は2になります
%=	This takes modulus using two operands and assigns the result to left operand	def A = 5 A%=3 出力は2になります

範囲演算子

Groovyは範囲の概念をサポートし、..の助けを借りて範囲演算子の表記を提供します。表記法範囲演算子の簡単な例を以下に示します。

def range = 0..5

これは単純な整数の範囲を定義するもので、下限が0、上限が5のrangeというローカル変数に格納されます。

次のコードスニペットは、さまざまな演算子の使用方法を示しています。

class Example {
   static void main(String[] args) {
      def range = 5..10;
      println(range);
      println(range.get(2));
   }
}

上記のプログラムを実行すると、次の結果が得られます-

*println* ステートメントから、rangeステートメントで定義されている数値の範囲全体が表示されていることがわかります。

getステートメントは、パラメーターとしてインデックス値を受け取る定義済みの範囲からオブジェクトを取得するために使用されます。

[5, 6, 7, 8, 9, 10]
7

演算子の優先順位

次の表に、すべてのgroovy演算子を優先順位順に示します。

Sr.No	Operators & Names
1	++ — + - 事前インクリメント/デクリメント、単項プラス、単項マイナス
2	/% * 乗算、div、モジュロ
3	+ -* 加算、減算
4	== != <⇒ 等しい、等しくない、と比較
5	& バイナリ/ビット単位
6	^ バイナリ/ビットごとのxor
7	*
バイナリ/ビット単位または	8
&& 論理的	9
*
論理的または	10
= = =/= %= += -= <⇐ >>= >>>= &= ^=	=* さまざまな割り当て演算子

Groovy-ループ

これまでのところ、順次実行されるステートメントを見てきました。さらに、プログラムのロジックの制御フローを変更するステートメントがGroovyで提供されます。次に、これらは制御ステートメントのフローに分類され、詳細に説明します。

S.No.

Statements & Description

1

While Statement

whileステートメントは、最初に条件式（ブール値）を評価することによって実行され、結果がtrueの場合、whileループ内のステートメントが実行されます。

2

for Statement

forステートメントは、一連の値を反復処理するために使用されます。

3

for-in Statement

for-inステートメントは、一連の値を反復処理するために使用されます。

ループ制御ステートメント

S.No.

Statements & Description

1

Break Statement

breakステートメントは、ループ内の制御フローとswitchステートメントを変更するために使用されます。

2

Continue Statement

continueステートメントは、breakステートメントを補完します。その使用は、whileループとforループに制限されています。

Groovy-意思決定

意思決定構造では、プログラマーが、プログラムによって評価またはテストされる1つ以上の条件、および条件が true と決定された場合に実行されるステートメント、およびオプションで実行される他のステートメントを指定する必要があります。条件が false であると判断された場合。

Sr.No.	Statements & Description
1	if Statement このステートメントの一般的な動作は、最初にifステートメントで条件が評価されることです。条件が真の場合、ステートメントを実行します。
2	if/else Statement このステートメントの一般的な動作は、最初にifステートメントで条件が評価されることです。条件が真の場合、その後ステートメントを実行し、else条件の前に停止してループを終了します。条件が偽の場合、elseステートメントブロック内のステートメントを実行し、ループを終了します。
3	Nested If Statement 場合によっては、複数のifステートメントを相互に埋め込む必要があります。
4	Switch Statement ネストされたif-elseステートメントは非常に一般的で、頻繁に使用されるため、switchステートメントと呼ばれる簡単なステートメントが設計される場合があります。
5	Nested Switch Statement また、switchステートメントのネストされたセットを持つことも可能です。

Groovy-メソッド

Groovyにあるメソッドは、戻り値の型または def キーワードで定義されます。メソッドは、任意の数の引数を受け取ることができます。引数を定義するときに型を明示的に定義する必要はありません。 public、private、protectedなどの修飾子を追加できます。デフォルトでは、可視性修飾子が提供されていない場合、メソッドはパブリックです。

メソッドの最も単純なタイプは、以下に示すようにパラメータなしのものです-

def methodName() {
  //Method code
}

以下は簡単な方法の例です

class Example {
   static def DisplayName() {
      println("This is how methods work in groovy");
      println("This is an example of a simple method");
   }

   static void main(String[] args) {
      DisplayName();
   }
}

上記の例では、DisplayNameは、テキストをコンソールに出力するために使用される2つのprintlnステートメントで構成される単純なメソッドです。静的mainメソッドでは、DisplayNameメソッドを呼び出しています。上記の方法の出力は次のようになります-

This is how methods work in groovy
This is an example of a simple method

メソッドのパラメーター

メソッドは、その動作が1つ以上のパラメーターの値によって決定される場合、より一般的に役立ちます。メソッドパラメータを使用して、呼び出されたメソッドに値を転送できます。パラメーター名は互いに異なる必要があることに注意してください。

以下に示すようなパラメータを持つメソッドの最も単純なタイプ-

def methodName(parameter1, parameter2, parameter3) {
  //Method code goes here
}

以下は、パラメーターを使用した単純なメソッドの例です

class Example {
   static void sum(int a,int b) {
      int c = a+b;
      println(c);
   }

   static void main(String[] args) {
      sum(10,5);
   }
}

この例では、 a と b の2つのパラメーターを持つsumメソッドを作成しています。両方のパラメーターは int タイプです。次に、メインメソッドからsumメソッドを呼び出し、変数 a および b に値を渡します。

上記のメソッドの出力は値15になります。

デフォルトパラメータ

Groovyには、メソッド内のパラメーターのデフォルト値を指定する規定もあります。パラメータのメソッドに値が渡されない場合、デフォルトの値が使用されます。デフォルト以外のパラメータとデフォルトのパラメータの両方を使用する場合、デフォルトのパラメータはパラメータリストの最後に定義する必要があることに注意する必要があります。

以下は、パラメータを使用した簡単な方法の例です-

def someMethod(parameter1, parameter2 = 0, parameter3 = 0) {
  //Method code goes here
}

2つの数字の追加について前に見たのと同じ例を見てみましょう、1つのデフォルトと別の非デフォルトパラメータを持つメソッドを作成します-

class Example {
   static void sum(int a,int b = 5) {
      int c = a+b;
      println(c);
   }

   static void main(String[] args) {
      sum(6);
   }
}

この例では、 a と b の2つのパラメーターを持つsumメソッドを作成しています。両方のパラメーターはint型です。この例と前の例の違いは、この場合、 b のデフォルト値を5に指定していることです。したがって、メインメソッドからsumメソッドを呼び出すとき、6という1つの値を渡すだけのオプションがあり、これは sum メソッド内のパラメーター a に割り当てられます。

上記のメソッドの出力は値11になります。

class Example {
   static void sum(int a,int b = 5) {
      int c = a+b;
      println(c);
   }

   static void main(String[] args) {
      sum(6,6);
   }
}

2つの値を渡すことでsumメソッドを呼び出すこともできます。上記の例では、6つの2つの値を渡します。 2番目の値6は、実際にはパラメーター b に割り当てられているデフォルト値を置き換えます。

上記のメソッドの出力は値12になります。

メソッドの戻り値

メソッドは、呼び出し元プログラムに値を返すこともできます。これは、メソッドが何らかの計算を実行し、呼び出し元のメソッドに目的の値を返す現代のプログラミング言語で必要です。

以下は、戻り値を持つ単純なメソッドの例です。

class Example {
   static int sum(int a,int b = 5) {
      int c = a+b;
      return c;
   }

   static void main(String[] args) {
      println(sum(6));
   }
}

上記の例では、今回はint型であるメソッドsumの戻り値の型を指定していることに注意してください。このメソッドでは、returnステートメントを使用して、呼び出し側のメインプログラムに合計値を送信しています。メソッドの値がmainメソッドで使用できるようになったため、 println 関数を使用してコンソールに値を表示しています。

上記のメソッドの出力は値11になります。

インスタンスメソッド

メソッドは通常、Java言語と同様にGroovy内のクラス内に実装されます。クラスは、プロパティと動作を定義するさまざまなオブジェクトを作成するための設計図またはテンプレートにすぎません。クラスオブジェクトは、そのクラスによって定義されたプロパティと動作を示します。そのため、動作はクラス内にメソッドを作成することで定義されます。

クラスの詳細については、後の章で説明しますが、クラスのメソッド実装の例を次に示します。前の例では、メソッドを静的メソッドとして定義しました。つまり、クラスから直接これらのメソッドにアクセスできます。メソッドの次の例は、クラスのオブジェクトを作成することでメソッドにアクセスするインスタンスメソッドです。再び、後の章でクラスを見ることになりますが、今はメソッドの使用方法を示します。

以下は、メソッドの実装方法の例です。

class Example {
   int x;

   public int getX() {
      return x;
   }

   public void setX(int pX) {
      x = pX;
   }

   static void main(String[] args) {
      Example ex = new Example();
      ex.setX(100);
      println(ex.getX());
   }
}

上記の例では、今回はクラスメソッドに静的属性を指定していないことに注意してください。メイン関数では、実際にExampleクラスのインスタンスを作成してから、「ex」オブジェクトのメソッドを呼び出しています。

上記のメソッドの出力は値100です。

ローカルおよび外部パラメーター名

Groovyは、ローカルパラメータとグローバルパラメータを持つjavaのような機能を提供します。次の例では、 lx は* getX（）の関数内にのみスコープを持つローカルパラメータであり、 *x はExampleクラス全体内でアクセスできるグローバルプロパティです。 * getX（）関数の外部の変数 *lx にアクセスしようとすると、エラーが発生します。

class Example {
   static int x = 100;

   public static int getX() {
      int lx = 200;
      println(lx);
      return x;
   }

   static void main(String[] args) {
      println(getX());
   }
}

上記のプログラムを実行すると、次の結果が得られます。

200
100

プロパティのこのメソッド

Javaと同様に、groovyは this キーワードを使用してインスタンスメンバーにアクセスできます。次の例は、ステートメント this.x を使用するときに、インスタンスを参照し、それに応じて x の値を設定する方法を示しています。

class Example {
   int x = 100;

   public int getX() {
      this.x = 200;
      return x;
   }

   static void main(String[] args) {
      Example ex = new Example();
      println(ex.getX());
   }
}

上記のプログラムを実行すると、コンソールに200の結果が出力されます。

Groovy-ファイルI/O

Groovyは、I/Oを操作する際に多くのヘルパーメソッドを提供します。 Groovyは、ファイルに次の機能を提供するための簡単なクラスを提供します。

ファイルを読む
ファイルへの書き込み
ファイルツリーの走査
ファイルへのデータオブジェクトの読み取りと書き込み

これに加えて、ファイルI/O操作には、以下にリストされている通常のJavaクラスをいつでも使用できます。

java.io.File
java.io.InputStream
java.io.OutputStream
java.io.Reader
java.io.Writer

ファイルを読む

次の例では、Groovyのテキストファイルのすべての行を出力します。メソッド eachLine は、テキストファイルの各行が確実に読み取られるようにするために、GroovyのFileクラスに組み込まれています。

import java.io.File
class Example {
   static void main(String[] args) {
      new File("E:/Example.txt").eachLine {
         line -> println "line : $line";
      }
   }
}

Fileクラスは、ファイル名をパラメーターとして受け取る新しいオブジェクトをインスタンス化するために使用されます。次に、eachLineの関数を取得し、それをlineという変数に入れて、それに応じて出力します。

ファイルに次の行が含まれている場合、それらが印刷されます。

line : Example1
line : Example2

ファイルの内容を文字列全体として読み取る

ファイルの内容全体を文字列として取得する場合は、ファイルクラスのtextプロパティを使用できます。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      File file = new File("E:/Example.txt")
      println file.text
   }
}

ファイルに次の行が含まれている場合、それらが印刷されます。

line : Example1
line : Example2

ファイルへの書き込み

ファイルに書き込みたい場合は、writerクラスを使用してテキストをファイルに出力する必要があります。次の例は、これを行う方法を示しています。

import java.io.File
class Example {
   static void main(String[] args) {
      new File('E:/','Example.txt').withWriter('utf-8') {
         writer -> writer.writeLine 'Hello World'
      }
   }
}

ファイルExample.txtを開くと、「Hello World」という単語がファイルに出力されます。

ファイルのサイズを取得する

ファイルのサイズを取得する場合は、ファイルクラスのlengthプロパティを使用してファイルのサイズを取得できます。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      File file = new File("E:/Example.txt")
      println "The file ${file.absolutePath} has ${file.length()} bytes"
   }
}

上記のコードは、ファイルのサイズをバイト単位で示します。

ファイルがディレクトリかどうかのテスト

パスがファイルかディレクトリかを確認したい場合は、Fileクラスの isFile および isDirectory オプションを使用できます。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      def file = new File('E:/')
      println "File? ${file.isFile()}"
      println "Directory? ${file.isDirectory()}"
   }
}

上記のコードは、次の出力を示します-

File? false
Directory? True

ディレクトリを作成する

新しいディレクトリを作成する場合は、Fileクラスの mkdir 関数を使用できます。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      def file = new File('E:/Directory')
      file.mkdir()
   }
}

ディレクトリE：\ Directoryが存在しない場合は作成されます。

ファイルを削除する

ファイルを削除する場合は、Fileクラスの削除機能を使用できます。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      def file = new File('E:/Example.txt')
      file.delete()
   }
}

ファイルが存在する場合は削除されます。

ファイルをコピーする

Groovyは、あるファイルから別のファイルにコンテンツをコピーする機能も提供します。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      def src = new File("E:/Example.txt")
      def dst = new File("E:/Example1.txt")
      dst << src.text
   }
}

ファイルExample1.txtが作成され、ファイルExample.txtのすべての内容がこのファイルにコピーされます。

ディレクトリの内容を取得する

Groovyは、ドライブとドライブ内のファイルをリストする機能も提供します。

次の例は、Fileクラスの listRoots 関数を使用して、マシン上のドライブを表示する方法を示しています。

class Example {
   static void main(String[] args) {
      def rootFiles = new File("test").listRoots()
      rootFiles.each {
         file -> println file.absolutePath
      }
   }
}

マシンで使用可能なドライブに応じて、出力が異なる場合があります。標準的なマシンでは、出力は次のようになります-

C:\
D:\

次の例は、Fileクラスの eachFile 関数を使用して、特定のディレクトリ内のファイルを一覧表示する方法を示しています。

class Example {
   static void main(String[] args) {
      new File("E:/Temp").eachFile() {
         file->println file.getAbsolutePath()
      }
   }
}

出力には、ディレクトリE：\ Temp内のすべてのファイルが表示されます

ディレクトリとそのサブディレクトリ内のすべてのファイルを再帰的に表示する場合は、Fileクラスの eachFileRecurse 関数を使用します。次の例は、これを行う方法を示しています。

class Example {
   static void main(String[] args) {
      new File("E:/temp").eachFileRecurse() {
         file -> println file.getAbsolutePath()
      }
   }
}

出力には、ディレクトリE：\ Tempおよびそのサブディレクトリ（存在する場合）にあるすべてのファイルが表示されます。

Groovy-オプション

Groovyは「オプションで」型指定された言語であり、その区別は言語の基本を理解するときに重要です。「強く」型付けされた言語であるJavaと比較すると、コンパイラはすべての変数のすべての型を認識し、コンパイル時にコントラクトを理解し、尊重できます。これは、コンパイル時にメソッド呼び出しを決定できることを意味します。

Groovyでコードを記述する場合、開発者には型を提供するかどうかを柔軟に指定できます。これにより、実装がある程度簡単になり、適切に活用されると、堅牢で動的な方法でアプリケーションにサービスを提供できます。

Groovyでは、オプションの入力は「def」キーワードを介して行われます。以下は、 def メソッドの使用例です-

class Example {
   static void main(String[] args) {
     //Example of an Integer using def
      def a = 100;
      println(a);

     //Example of an float using def
      def b = 100.10;
      println(b);

     //Example of an Double using def
      def c = 100.101;
      println(c);

     //Example of an String using def
      def d = "HelloWorld";
      println(d);
   }
}

上記のプログラムから、これらのタイプの値が含まれていても、個々の変数をInteger、float、double、またはstringとして宣言していないことがわかります。

上記のプログラムを実行すると、次の結果が得られます-

100
100.10
100.101
HelloWorld

オプションのタイピングは開発中の強力なユーティリティになる可能性がありますが、コードが広大で複雑になりすぎる開発の後期段階で保守性の問題につながる可能性があります。

コードベースを維持できない混乱に陥ることなく、Groovyでオプションのタイピングを使用する方法を理解するには、アプリケーションで「アヒルタイピング」の哲学を採用することが最善です。

アヒルのタイピングを使用して上記のコードを書き直すと、次のようになります。変数名には、それらが表す型ではなく、コードをより理解しやすくする名前によく似た名前が付けられます。

class Example {
   static void main(String[] args) {
     //Example of an Integer using def
      def aint = 100;
      println(aint);

     //Example of an float using def
      def bfloat = 100.10;
      println(bfloat);

     //Example of an Double using def
      def cDouble = 100.101;
      println(cDouble);

     //Example of an String using def
      def dString = "HelloWorld";
      println(dString);
   }
}

Groovy-数字

Groovyでは、数値は実際にはオブジェクトとして表され、それらはすべて整数クラスのインスタンスです。オブジェクトに何かをさせるには、そのクラスで宣言されているメソッドの1つを呼び出す必要があります。

Groovyは整数と浮動小数点数をサポートしています。

整数は、分数を含まない値です。
浮動小数点数は、小数を含む小数値です。

Groovyの数値の例を以下に示します-

Integer x = 5;
Float y = 1.25;

ここで、 x は整数型で、 y は浮動小数点数です。

groovyの数字がオブジェクトとして定義される理由は、通常、数字に対して操作を実行するための要件があるためです。プリミティブ型を介してクラスを提供する概念は、ラッパークラスと呼ばれます。

デフォルトでは、次のラッパークラスがGroovyで提供されます。

ラッパークラス

ラッパークラスのオブジェクトには、それぞれのプリミティブデータ型が含まれているか、ラップされています。プリミティブデータ型をオブジェクトに変換するプロセスはボクシングと呼ばれ、これはコンパイラーによって処理されます。オブジェクトを変換して対応するプリミティブ型に戻すプロセスは、ボックス化解除と呼ばれます。

例

以下は、ボクシングとアンボクシングの例です-

class Example {
   static void main(String[] args) {
      Integer x = 5,y = 10,z = 0;

     //The the values of 5,10 and 0 are boxed into Integer types
     //The values of x and y are unboxed and the addition is performed
      z = x+y;
      println(z);
   }
}

上記のプログラムの出力は15になります。上記の例では、5、10、および0の値が最初に整数変数x、y、zにボックス化されます。そして、xとyの加算が実行されると、値は整数型からボックス化解除されます。

数値メソッド

Groovyの数値はクラスとして表されるため、使用可能なメソッドのリストは次のとおりです。

S.No.	Methods & Description
1	xxxValue() このメソッドはパラメーターとしてNumberを受け取り、呼び出されたメソッドに基づいてプリミティブ型を返します。
2	compareTo() compareToメソッドは、1つの数値を別の数値と比較するために使用します。これは、数値の値を比較する場合に便利です。
3	equals() メソッドは、メソッドを呼び出すNumberオブジェクトが引数として渡されるオブジェクトと等しいかどうかを判断します。
4	valueOf() valueOfメソッドは、渡された引数の値を保持する関連するNumberオブジェクトを返します。
5	toString() このメソッドは、Numberオブジェクトの値を表すStringオブジェクトを取得するために使用されます。
6	parseInt() このメソッドは、特定の文字列のプリミティブデータ型を取得するために使用されます。 parseXxx（）は静的メソッドであり、1つまたは2つの引数を持つことができます。
7	abs() このメソッドは、引数の絶対値を提供します。引数は、int、float、long、double、short、byteのいずれかです。
8	ceil() メソッドceilは、引数以上の最小の整数を提供します。
9	floor() メソッドfloorは、引数以下の最大整数を提供します。
10	rint() rintメソッドは、引数に値が最も近い整数を返します。
11	round() メソッドroundは、メソッドの戻り型で指定された最も近いlongまたはintを返します。
12	min() このメソッドは、2つの引数のうち小さい方を指定します。引数には、int、float、long、doubleを指定できます。
13	max() このメソッドは、2つの引数の最大値を提供します。引数には、int、float、long、doubleを指定できます。
14	exp() このメソッドは、自然対数の底eを引数のべき乗で返します。
15	log() このメソッドは、引数の自然対数を返します。
16	pow() このメソッドは、最初の引数の値を2番目の引数の累乗で返します。
17	sqrt() このメソッドは、引数の平方根を返します。
18	sin() このメソッドは、指定されたdouble値のサインを返します。
19	cos() メソッドは、指定されたdouble値の余弦を返します。
20	tan() メソッドは、指定されたdouble値のタンジェントを返します。
21	asin() このメソッドは、指定されたdouble値のアークサインを返します。
22	acos() このメソッドは、指定されたdouble値のアークコサインを返します。
23	atan() このメソッドは、指定されたdouble値のアークタンジェントを返します。
24	atan2() メソッドは、直交座標（x、y）を極座標（r、theta）に変換し、thetaを返します。
25	toDegrees() メソッドは、引数値を度に変換します。
26	radian() このメソッドは、引数値をラジアンに変換します。
27	random() このメソッドは、0.0〜1.0の乱数を生成するために使用されます。範囲は0.0 = <Math.random <1.0です。算術を使用すると、さまざまな範囲を実現できます。

Groovy-ストリング

文字列リテラルは、文字列テキストを引用符で囲むことにより、Groovyで構築されます。

Groovyは、文字列リテラルを表すさまざまな方法を提供します。 Groovyの文字列は、一重引用符（ ’）、二重引用符（「）、または三重引用符（「」」）で囲むことができます。さらに、三重引用符で囲まれたGroovy文字列は複数行にまたがることがあります。

以下はGroovyでの文字列の使用例です-

class Example {
   static void main(String[] args) {
      String a = 'Hello Single';
      String b = "Hello Double";
      String c = "'Hello Triple" + "Multiple lines'";

      println(a);
      println(b);
      println(c);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Hello Single
Hello Double
'Hello TripleMultiple lines'

文字列のインデックス付け

Groovyの文字列は、文字の順序付けられたシーケンスです。文字列内の個々の文字は、その位置によってアクセスできます。これはインデックス位置によって与えられます。

文字列インデックスは、ゼロから始まり、文字列の長さより1つ小さい値で終わります。 Groovyでは、負のインデックスを文字列の末尾からカウントバックすることもできます。

以下は、Groovyでの文字列インデックスの使用例です-

class Example {
   static void main(String[] args) {
      String sample = "Hello world";
      println(sample[4]);//Print the 5 character in the string

     //Print the 1st character in the string starting from the back
      println(sample[-1]);
      println(sample[1..2]);//Prints a string starting from Index 1 to 2
      println(sample[4..2]);//Prints a string starting from Index 4 back to 2

   }
}

上記のプログラムを実行すると、次の結果が得られます-

o
d
el
oll

基本的な文字列操作

まず、Groovyでの基本的な文字列操作を学びましょう。それらを以下に示します。

S.No.

String Operation & Description

1

Concatenation of two strings

文字列の連結は、単純な「+」演算子で実行できます。

2

String Repetition

文字列の繰り返しは、単純な「*」演算子で実行できます。

3

String Length

文字列のlength（）メソッドによって決定される文字列の長さ。

文字列メソッド

以下は、Stringクラスでサポートされているメソッドのリストです。

S.No.	Methods & Description
1	center() 左右にスペース文字が埋め込まれた受信者で構成される、長さnumberOfCharsの新しい文字列を返します。
2	compareToIgnoreCase() 大文字と小文字の違いを無視して、2つの文字列を辞書式に比較します。
3	concat() 指定された文字列をこの文字列の末尾に連結します。
4	eachMatch() 指定された文字列の部分文字列に一致する各正規表現グループ（次のセクションを参照）を処理します。
5	endsWith() この文字列が指定されたサフィックスで終わるかどうかをテストします。
6	equalsIgnoreCase() この文字列を別の文字列と比較し、大文字と小文字の区別を無視します。
7	getAt() インデックス位置で文字列値を返します
8	indexOf() 指定された部分文字列が最初に出現するこの文字列内のインデックスを返します。
9	matches() 文字列が指定された正規表現に一致するかどうかを出力します。
10	minus() 文字列の値部分を削除します。
11	next() このメソッドは、クラスStringの++演算子によって呼び出されます。指定された文字列の最後の文字をインクリメントします。
12	padLeft() 文字列の左側にスペースを追加して埋め込みます。
13	padRight() 文字列の右側にスペースを追加して埋め込みます。
14	plus() 文字列を追加します
15	previous() このメソッドは、CharSequenceの-演算子によって呼び出されます。
16	replaceAll() キャプチャされたグループのすべての出現を、そのテキストのクロージャの結果で置き換えます。
17	reverse() この文字列の逆である新しい文字列を作成します。
18	split() この文字列を、指定された正規表現の一致の周りで分割します。
19	subString() この文字列の部分文字列である新しい文字列を返します。
20	toUpperCase() この文字列のすべての文字を大文字に変換します。
21	toLowerCase() この文字列のすべての文字を小文字に変換します。

グルーヴィー-範囲

範囲は、値のシーケンスを指定するための略記です。範囲は、シーケンスの最初と最後の値で示され、範囲は包含的または排他的です。包括的範囲には最初から最後までのすべての値が含まれ、排他的範囲には最後以外のすべての値が含まれます。ここに範囲リテラルのいくつかの例があります-

1..10-包括的範囲の例
1 .. <10-排他的範囲の例
「a」..「x」–範囲は文字で構成することもできます
10..1 –範囲は降順でもかまいません
「x」..「a」–範囲は文字で構成され、降順でもかまいません。

以下は、範囲に使用できるさまざまな方法です。

Sr.No.	Methods & Description
1	contains() 範囲に特定の値が含まれているかどうかを確認します
2	get() このRangeの指定された位置にある要素を返します。
3	getFrom() この範囲の低い値を取得します。
4	getTo() この範囲の上限値を取得します。
5	isReverse() これは逆方向の範囲で、逆方向に反復します
6	size() この範囲内の要素の数を返します。
7	subList() 指定されたfromIndex（包括的）とtoIndex（排他的）の間のこのRangeの部分のビューを返します

Groovy-リスト

リストは、データ項目のコレクションを格納するために使用される構造です。 Groovyでは、リストはオブジェクト参照のシーケンスを保持します。リスト内のオブジェクト参照はシーケンス内の位置を占め、整数インデックスによって区別されます。リストリテラルは、カンマで区切られ、角括弧で囲まれた一連のオブジェクトとして表示されます。

リスト内のデータを処理するには、個々の要素にアクセスできる必要があります。 Groovyリストは、インデックス演算子[]を使用してインデックス付けされます。リストのインデックスはゼロから始まり、最初の要素を参照します。

以下はリストのいくつかの例です-

[11、12、13、14] –整数値のリスト
[「Angular」、「Groovy」、「Java」] –文字列のリスト
[1、2、[3、4]、5] –ネストされたリスト
[「Groovy」、21、2.11] –オブジェクト参照の異種リスト
[] –空のリスト

この章では、Groovyで使用可能なリストメソッドについて説明します。

Sr.No.	Methods & Description
1	add() このリストの最後に新しい値を追加します。
2	contains() このリストに指定された値が含まれる場合、trueを返します。
3	get() このリストの指定された位置にある要素を返します。
4	isEmpty() このリストに要素が含まれていない場合はtrueを返します
5	minus() コレクションで指定されていない元の要素で構成される新しいリストを作成します。
6	plus() 元の要素とコレクションで指定された要素で構成される新しいリストを作成します。
7	pop() このリストから最後のアイテムを削除します
8	remove() このリスト内の指定された位置にある要素を削除します。
9	reverse() 元のリストの要素と逆の新しいリストを作成します
10	size() このリスト内の要素の数を取得します。
11	sort() 元のリストのソートされたコピーを返します。

Groovy-マップ

Map（連想配列、辞書、テーブル、ハッシュとも呼ばれます）は、オブジェクト参照の順序付けられていないコレクションです。 Mapコレクションの要素は、キー値によってアクセスされます。マップで使用されるキーは、どのクラスのものでもかまいません。 Mapコレクションに挿入する場合、キーと値の2つの値が必要です。

以下は、マップのいくつかの例です-

[「TopicName」：「Lists」、「TopicName」：「Maps」] –キーとしてTopicNameを持ち、それぞれの値を持つキーと値のペアのコレクション。
[：] –空のマップ。

この章では、Groovyで使用可能なマップメソッドについて説明します。

Sr.No.	Methods & Description
1	containsKey() このマップにはこのキーが含まれていますか？
2	get() このマップでキーを検索し、対応する値を返します。キーのこのマップにエントリがない場合は、nullを返します。
3	keySet() このマップのキーのセットを取得します。
4	put() 指定された値をこのマップ内の指定されたキーに関連付けます。このマップに以前にこのキーのマッピングが含まれていた場合、古い値は指定された値に置き換えられます。
5	size() このマップ内のキーと値のマッピングの数を返します。
6	values() このマップに含まれる値のコレクションビューを返します。

Groovy-日付と時刻

Dateクラスは、特定の瞬間をミリ秒の精度で表します。以下に示すように、Dateクラスには2つのコンストラクターがあります。

日付（）

構文

public Date()

パラメータ-なし。

戻り値

Dateオブジェクトを割り当て、初期化して、オブジェクトが割り当てられた時間を表し、最も近いミリ秒で測定します。

例

以下は、このメソッドの使用例です-

class Example {
   static void main(String[] args) {
      Date date = new Date();

     //display time and date using toString()
      System.out.println(date.toString());
   }
}

上記のプログラムを実行すると、次の結果が得られます。次の出力は、現在の日付と時刻を提供します-

Thu Dec 10 21:31:15 GST 2015

日付（長いミリ秒）

構文

public Date(long millisec)

パラメーター

Millisec –標準ベース時間以降に指定するミリ秒単位の数。

戻り値- Date オブジェクトを割り当て、「エポック」として知られる標準のベースタイム、つまり1970年1月1日00:00:00 GMT以降の指定されたミリ秒数を表すようにオブジェクトを初期化します。

例

以下は、このメソッドの使用例です-

class Example {
   static void main(String[] args) {
      Date date = new Date(100);

     //display time and date using toString()
      System.out.println(date.toString());
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Thu Jan 01 04:00:00 GST 1970

以下は、Dateクラスの指定されたメソッドです。年、月、日付、時間、分、および秒の値を受け入れるか返すクラスDateのすべてのメソッドでは、次の表現が使用されます-

年yは、整数y-1900で表されます。
月は0〜11の整数で表されます。 0は1月、1は2月などです。したがって、11は12月です。
日付（月の日）は、通常の方法で1〜31の整数で表されます。
時間は、0〜23の整数で表されます。したがって、真夜中から午前1時までの時間です。は0時で、正午から午後1時までです。 12時です。
分は、通常の方法で0〜59の整数で表されます。
秒は、0〜61の整数で表されます。

Sr.No.	Methods & Description
1	after() この日付が指定された日付より後かどうかをテストします。
2	equals() 2つの日付が等しいかどうかを比較します。引数がnullではなく、このオブジェクトと同じ時点（ミリ秒単位）を表すDateオブジェクトである場合にのみ、結果はtrueです。
3	compareTo() 順序付けのために2つの日付を比較します。
4	toString() このDateオブジェクトを文字列に変換します
5	before() この日付が指定された日付より前かどうかをテストします。
6	getTime() このDateオブジェクトで表される1970年1月1日00:00:00 GMT以降のミリ秒数を返します。
7	setTime() このDateオブジェクトを設定して、1970年1月1日00:00:00 GMT以降のミリ秒の時点を表します。

Groovy-正規表現

正規表現は、テキスト内のサブストリングを見つけるために使用されるパターンです。 Groovyは、〜” regex”式を使用してネイティブに正規表現をサポートします。引用符で囲まれたテキストは、比較用の式を表します。

たとえば、次のように正規表現オブジェクトを作成できます-

def regex = ~'Groovy'

Groovy演算子=〜が if および while ステートメント（第8章を参照）で述語（ブールを返す式）として表示される場合、左側の文字列オペランドは右側の正規表現オペランドと照合されます。したがって、次のそれぞれは値trueを提供します。

正規表現を定義する場合、次の特殊文字を使用できます-

行の先頭と末尾を示すために使用される2つの特別な位置文字、キャレット（∧）とドル記号（$）があります。
正規表現には数量詞も含めることができます。プラス記号（+）は、式の前の要素に適用される1回以上を表します。アスタリスク（*）は、0個以上のオカレンスを表すために使用されます。疑問符（？）はゼロまたは1回を示します。
メタ文字\ {および}は、前の文字のインスタンスの特定の数と一致するために使用されます。
正規表現では、ピリオド記号（。）は任意の文字を表すことができます。これは、ワイルドカード文字として説明されます。
正規表現には文字クラスが含まれる場合があります。文字のセットは、[aeiou]のように、メタ文字[and]で囲まれた単純な文字列として指定できます。文字または数字の範囲には、[a–z]または[a–mA–M]のようにダッシュ区切り文字を使用できます。文字クラスの補数は、[∧a–z]のようにスクエアラケット内の先頭のキャレットで示され、指定された文字以外のすべての文字を表します。正規表現のいくつかの例を以下に示します

'Groovy' =~ 'Groovy'
'Groovy' =~ 'oo'
'Groovy' ==~ 'Groovy'
'Groovy' ==~ 'oo'
'Groovy' =~ '∧G'
‘Groovy' =~ 'G$'
‘Groovy' =~ 'Gro*vy' 'Groovy' =~ 'Gro{2}vy'

Groovy-例外処理

アプリケーションの通常のフローを維持できるように、ランタイムエラーを処理するには、プログラミング言語で例外処理が必要です。

例外は通常、アプリケーションの通常のフローを中断します。これが、アプリケーションで例外処理を使用する必要がある理由です。

例外は大きく次のカテゴリに分類されます-

Checked Exception -RuntimeExceptionとErrorを除くThrowableクラスを拡張するクラスは、チェック例外（IOException、SQLExceptionなど）として知られています。チェックされた例外はコンパイル時にチェックされます。

古典的なケースの1つはFileNotFoundExceptionです。 Eドライブのファイルから読み取る次のコードがアプリケーションにあったとします。

class Example {
   static void main(String[] args) {
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file);
   }
}

ファイル（file.txt）がEドライブにない場合、次の例外が発生します。

キャッチ：java.io.FileNotFoundException：E：\ file.txt（システムは指定されたファイルを見つけることができません）。

java.io.FileNotFoundException：E：\ file.txt（指定されたファイルが見つかりません）。

未チェックの例外-RuntimeExceptionを拡張するクラスは、未チェックの例外として知られています。たとえば、ArithmeticException、NullPointerException、ArrayIndexOutOfBoundsExceptionなどです。未チェックの例外はコンパイル時にチェックされず、実行時にチェックされます。

古典的なケースの1つは、ArrayIndexOutOfBoundsExceptionです。これは、配列の長さよりも大きい配列のインデックスにアクセスしようとしたときに発生します。以下は、この種の間違いの典型的な例です。

class Example {
   static void main(String[] args) {
      def arr = new int[3];
      arr[5] = 5;
   }
}

上記のコードが実行されると、次の例外が発生します。

キャッチ：java.lang.ArrayIndexOutOfBoundsException：5

java.lang.ArrayIndexOutOfBoundsException：5

エラー-エラーは回復不能です。 OutOfMemoryError、VirtualMachineError、AssertionErrorなど。

これらは、プログラムが回復できないエラーであり、プログラムをクラッシュさせます。

次の図は、Groovyの例外の階層がどのように編成されているかを示しています。すべてJavaで定義された階層に基づいています。

例外の階層

例外をキャッチする

メソッドは、 try キーワードと catch キーワードの組み合わせを使用して例外をキャッチします。 try/catchブロックは、例外を生成する可能性のあるコードの周りに配置されます。

try {
  //Protected code
} catch(ExceptionName e1) {
  //Catch block
}

例外を発生させる可能性のあるすべてのコードは、保護されたコードブロックに配置されます。

catchブロックでは、カスタムコードを記述して例外を処理し、アプリケーションが例外から回復できるようにすることができます。

配列のサイズよりも大きいインデックス値を持つ配列にアクセスするために上で見た同様のコードの例を見てみましょう。ただし、今回はコードをtry/catchブロックにラップします。

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(Exception ex) {
         println("Catching the exception");
      }

      println("Let's move on after the exception");
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Catching the exception
Let's move on after the exception

上記のコードから、tryブロックで障害のあるコードをラップします。 catchブロックでは、単に例外をキャッチし、例外が発生したというメッセージを出力しています。

複数のキャッチブロック

複数のタイプの例外を処理するために、複数のcatchブロックを使用できます。キャッチブロックごとに、発生した例外のタイプに応じて、それに応じて処理するコードを記述します。

上記のコードを変更して、特にArrayIndexOutOfBoundsExceptionをキャッチします。以下はコードスニペットです。

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      }

      println("Let's move on after the exception");
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Catching the Aray out of Bounds exception
Let's move on after the exception

上記のコードから、ArrayIndexOutOfBoundsException catchブロックが例外の基準を意味するため、最初にキャッチされることがわかります。

最後にブロック

*finally* ブロックは、tryブロックまたはcatchブロックの後に続きます。 例外の発生に関係なく、コードの最終ブロックは常に実行されます。

finallyブロックを使用すると、保護されたコードで何が起こっても、実行するクリーンアップタイプのステートメントを実行できます。このブロックの構文は次のとおりです。

try {
  //Protected code
} catch(ExceptionType1 e1) {
  //Catch block
} catch(ExceptionType2 e2) {
  //Catch block
} catch(ExceptionType3 e3) {
  //Catch block
} finally {
  //The finally block always executes.
}

上記のコードを変更して、最終的にコードのブロックを追加しましょう。以下はコードスニペットです。

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      } finally {
         println("The final block");
      }

      println("Let's move on after the exception");
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Catching the Array out of Bounds exception
The final block
Let's move on after the exception

以下はGroovyで利用可能な例外メソッドです-

public String getMessage（）

発生した例外に関する詳細メッセージを返します。このメッセージは、Throwableコンストラクターで初期化されます。

public Throwable getCause（）

Throwableオブジェクトで表される例外の原因を返します。

public String toString（）

getMessage（）の結果と連結されたクラスの名前を返します

public void printStackTrace（）

toString（）の結果とスタックトレースをエラー出力ストリームであるSystem.errに出力します。

public StackTraceElement [] getStackTrace（）

スタックトレースの各要素を含む配列を返します。インデックス0の要素は呼び出しスタックの一番上を表し、配列の最後の要素は呼び出しスタックの一番下のメソッドを表します。

public Throwable fillInStackTrace（）

このThrowableオブジェクトのスタックトレースを現在のスタックトレースで満たし、スタックトレース内の以前の情報に追加します。

例

以下は、上記のメソッドのいくつかを使用したコード例です-

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println(ex.toString());
         println(ex.getMessage());
         println(ex.getStackTrace());
      } catch(Exception ex) {
         println("Catching the exception");
      }finally {
         println("The final block");
      }

      println("Let's move on after the exception");
   }
}

上記のプログラムを実行すると、次の結果が得られます-

java.lang.ArrayIndexOutOfBoundsException: 5
5
[org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayPutAtMetaMethod$MyPojoMetaMet
hodSite.call(IntegerArrayPutAtMetaMethod.java:75),
org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:48) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:113) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:133) ,
Example.main(Sample:8), sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:93),
groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:325),
groovy.lang.MetaClassImpl.invokeStaticMethod(MetaClassImpl.java:1443),
org.codehaus.groovy.runtime.InvokerHelper.invokeMethod(InvokerHelper.java:893),
groovy.lang.GroovyShell.runScriptOrMainOrTestOrRunnable(GroovyShell.java:287),
groovy.lang.GroovyShell.run(GroovyShell.java:524),
groovy.lang.GroovyShell.run(GroovyShell.java:513),
groovy.ui.GroovyMain.processOnce(GroovyMain.java:652),
groovy.ui.GroovyMain.run(GroovyMain.java:384),
groovy.ui.GroovyMain.process(GroovyMain.java:370),
groovy.ui.GroovyMain.processArgs(GroovyMain.java:129),
groovy.ui.GroovyMain.main(GroovyMain.java:109),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:109),
org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:131),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)]

The final block
Let's move on after the exception

Groovy-オブジェクト指向

Groovyでは、他のオブジェクト指向言語と同様に、プログラミング言語のオブジェクト指向の性質を表すクラスとオブジェクトの概念があります。 Groovyクラスは、データとそのデータを操作するメソッドのコレクションです。一緒に、クラスのデータとメソッドを使用して、問題領域の現実世界のオブジェクトを表します。

Groovyのクラスは、そのクラスで定義されたオブジェクトの状態（データ）と動作を宣言します。したがって、Groovyクラスは、そのクラスのインスタンスフィールドとメソッドの両方を記述します。

以下は、Groovyのクラスの例です。クラスの名前は、 StudentID と StudentName の2つのフィールドがあるStudentです。メイン関数では、このクラスのオブジェクトを作成し、オブジェクトの StudentID および StudentName に値を割り当てています。

class Student {
   int StudentID;
   String StudentName;

   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe"
   }
}

getterおよびsetterメソッド

プログラミング言語では、常にprivateキーワードでインスタンスメンバーを非表示にし、代わりにgetterおよびsetterメソッドを提供して、それに応じてインスタンス変数の値を設定および取得します。次の例は、これを行う方法を示しています。

class Student {
   private int StudentID;
   private String StudentName;

   void setStudentID(int pID) {
      StudentID = pID;
   }

   void setStudentName(String pName) {
      StudentName = pName;
   }

   int getStudentID() {
      return this.StudentID;
   }

   String getStudentName() {
      return this.StudentName;
   }

   static void main(String[] args) {
      Student st = new Student();
      st.setStudentID(1);
      st.setStudentName("Joe");

      println(st.getStudentID());
      println(st.getStudentName());
   }
}

上記のプログラムを実行すると、次の結果が得られます-

1
Joe

上記のプログラムに関する以下のキーポイントに注意してください-

クラスでは、studentIDとstudentNameの両方がプライベートとしてマークされています。つまり、クラスの外部からアクセスすることはできません。
各インスタンスメンバーには、独自のgetterおよびsetterメソッドがあります。 getterメソッドは、インスタンス変数の値、たとえばメソッドint getStudentID（）を返し、setterメソッドはインスタンスIDの値を設定します。たとえば、メソッド-void setStudentName（String pName）

インスタンスメソッド

通常、クラス内で実際にクラスに対して何らかの機能を実行するメソッドを追加するのは自然なことです。生徒の例では、Marks1、Marks2、Marks3のインスタンスメンバーを追加して、3つの科目で生徒のマークを示します。次に、学生の合計点を計算する新しいインスタンスメソッドを追加します。コードは次のようになります。

次の例では、メソッドTotalは、いくつかのロジックが組み込まれた追加のインスタンスメソッドです。

class Student {
   int StudentID;
   String StudentName;

   int Marks1;
   int Marks2;
   int Marks3;

   int Total() {
      return Marks1+Marks2+Marks3;
   }

   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName="Joe";

      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 30;

      println(st.Total());
   }
}

上記のプログラムを実行すると、次の結果が得られます-

複数のオブジェクトを作成する

クラスの複数のオブジェクトを作成することもできます。以下は、これを実現する方法の例です。ここでは、3つのオブジェクト（st、st1、st2）を作成し、それに応じてインスタンスメンバーとインスタンスメソッドを呼び出しています。

class Student {
   int StudentID;
   String StudentName;

   int Marks1;
   int Marks2;
   int Marks3;

   int Total() {
      return Marks1+Marks2+Marks3;
   }

   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";

      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 30;

      println(st.Total());

      Student st1 = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";

      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 40;

      println(st.Total());

      Student st3 = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";

      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 50;

      println(st.Total());
   }
}

上記のプログラムを実行すると、次の結果が得られます-

60
70
80

継承

継承は、あるクラスが別のクラスのプロパティ（メソッドとフィールド）を取得するプロセスとして定義できます。継承を使用すると、情報は階層的な順序で管理可能になります。

他のプロパティを継承するクラスはサブクラス（派生クラス、子クラス）と呼ばれ、プロパティが継承されるクラスはスーパークラス（ベースクラス、親クラス）と呼ばれます。

拡張する

*extends* は、クラスのプロパティを継承するために使用されるキーワードです。 以下はextendsキーワードの構文です。 次の例では、次のことを行っています-

Personというクラスを作成します。このクラスには、nameという1つのインスタンスメンバーがあります。
Personクラスから拡張されるStudentというクラスを作成します。 Personクラスで定義されている名前インスタンスメンバーは、Studentクラスで継承されることに注意してください。
Studentクラスのコンストラクターでは、基本クラスのコンストラクターを呼び出しています。
Studentクラスでは、StudentIDとMarks1の2つのインスタンスメンバーを追加しています。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;

      st.Marks1 = 10;
      st.name = "Joe";

      println(st.name);
   }
}

class Person {
   public String name;
   public Person() {}
}

class Student extends Person {
   int StudentID
   int Marks1;

   public Student() {
      super();
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Joe

内部クラス

内部クラスは別のクラス内で定義されます。エンクロージングクラスは、通常どおり内部クラスを使用できます。一方、内部クラスは、プライベートクラスであっても、それを含むクラスのメンバーにアクセスできます。外側のクラス以外のクラスは、内部クラスにアクセスできません。

以下は、OuterおよびInnerクラスの例です。次の例では、次のことを行っています-

外部クラスとなるOuterというクラスを作成します。
Outerクラスでnameという名前の文字列を定義します。
Outerクラス内にInnerクラスまたはネストされたクラスを作成します。
内部クラスでは、Outerクラスで定義された名前インスタンスメンバーにアクセスできることに注意してください。

class Example {
   static void main(String[] args) {
      Outer outobj = new Outer();
      outobj.name = "Joe";
      outobj.callInnerMethod()
   }
}

class Outer {
   String name;

   def callInnerMethod() {
      new Inner().methodA()
   }

   class Inner {
      def methodA() {
         println(name);
      }
   }

}

上記のプログラムを実行すると、次の結果が得られます-

Joe

抽象クラス

抽象クラスは一般的な概念を表すため、インスタンス化することはできず、サブクラス化するために作成されます。それらのメンバーには、フィールド/プロパティと抽象メソッドまたは具象メソッドが含まれます。抽象メソッドには実装がなく、具体的なサブクラスによって実装する必要があります。抽象クラスは、抽象キーワードで宣言する必要があります。抽象メソッドも抽象キーワードで宣言する必要があります。

次の例では、Personクラスが抽象クラスになり、インスタンス化できないことに注意してください。また、抽象クラスにはDisplayMarksという抽象メソッドがあり、実装の詳細はありません。学生クラスでは、実装の詳細を追加することが必須です。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;

      st.Marks1 = 10;
      st.name="Joe";

      println(st.name);
      println(st.DisplayMarks());
   }
}

abstract class Person {
   public String name;
   public Person() { }
   abstract void DisplayMarks();
}

class Student extends Person {
   int StudentID
   int Marks1;

   public Student() {
      super();
   }

   void DisplayMarks() {
      println(Marks1);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Joe
10
null

インターフェース

インターフェイスは、クラスが準拠する必要があるコントラクトを定義します。インターフェイスは、実装が必要なメソッドのリストを定義するだけで、メソッドの実装は定義しません。インターフェイスは、interfaceキーワードを使用して宣言する必要があります。インターフェイスはメソッドシグネチャのみを定義します。インターフェイスのメソッドは常に public です。インターフェイスで保護されたメソッドまたはプライベートメソッドを使用するとエラーになります。

以下は、groovyのインターフェースの例です。次の例では、次のことを行っています-

Marksというインターフェイスを作成し、DisplayMarksというインターフェイスメソッドを作成します。
クラス定義では、implementsキーワードを使用してインターフェイスを実装しています。
インターフェイスを実装しているため、DisplayMarksメソッドの実装を提供する必要があります。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
      println(st.DisplayMarks());
   }
}

interface Marks {
   void DisplayMarks();
}

class Student implements Marks {
   int StudentID
   int Marks1;

   void DisplayMarks() {
      println(Marks1);
   }
}

上記のプログラムを実行すると、次の結果が得られます-

10
null

Groovy-ジェネリック

ジェネリックを使用すると、クラス、インターフェイス、およびメソッドを定義するときに、型（クラスおよびインターフェイス）をパラメーターにすることができます。メソッド宣言で使用されるより馴染みのある正式なパラメーターと同様に、型パラメーターは、異なる入力で同じコードを再利用する方法を提供します。違いは、仮パラメーターへの入力は値であるのに対して、型パラメーターへの入力は型であるということです。

コレクションのジェネリック

Listクラスなどのコレクションクラスは、そのタイプのコレクションのみがアプリケーションで受け入れられるように一般化できます。一般化されたArrayListの例を以下に示します。次のステートメントは、文字列型のリスト項目のみを受け入れるということです-

List<String> list = new ArrayList<String>();

次のコード例では、次のことを行っています-

文字列のみを保持する一般化されたArrayListコレクションを作成します。
リストに3つの文字列を追加します。
リスト内の各アイテムについて、文字列の値を出力します。

class Example {
   static void main(String[] args) {
     //Creating a generic List collection
      List<String> list = new ArrayList<String>();
      list.add("First String");
      list.add("Second String");
      list.add("Third String");

      for(String str : list) {
         println(str);
      }
   }
}

上記のプログラムの出力は次のようになります-

First String
Second String
Third String

一般化されたクラス

クラス全体を一般化することもできます。これにより、クラスは任意のタイプを受け入れ、それらのタイプに応じて適切に機能するようになります。これを達成する方法の例を見てみましょう。

次のプログラムでは、次の手順を実行しています-

ListTypeというクラスを作成しています。クラス定義の前に置かれた<T>キーワードに注意してください。これは、このクラスが任意の型を受け入れることができることをコンパイラに伝えます。したがって、このクラスのオブジェクトを宣言するとき、宣言中に型を指定できます。その型はプレースホルダー<T>で置き換えられます
ジェネリッククラスには、クラスで定義されたメンバー変数を操作するための単純なgetterおよびsetterメソッドがあります。
メインプログラムでは、ListTypeクラスのオブジェクトを宣言できますが、型は異なります。最初のタイプは整数型で、2番目のタイプは文字列型です。

class Example {
   static void main(String[] args) {
     //Creating a generic List collection
      ListType<String> lststr = new ListType<>();
      lststr.set("First String");
      println(lststr.get());

      ListType<Integer> lstint = new ListType<>();
      lstint.set(1);
      println(lstint.get());
   }
}

public class ListType<T> {
   private T localt;

   public T get() {
      return this.localt;
   }

   public void set(T plocal) {
      this.localt = plocal;
   }
}

上記のプログラムの出力は次のようになります-

First String
1

グルーヴィー-特性

特性は、許可する言語の構造的な構成です-

行動の構成。
インターフェイスのランタイム実装。
静的型チェック/コンパイルとの互換性

これらは、デフォルトの実装と状態の両方を保持するインターフェースと見なすことができます。特性は、traitキーワードを使用して定義されます。

特性の例を以下に示します-

trait Marks {
   void DisplayMarks() {
      println("Display Marks");
   }
}

次に、implementキーワードを使用して、インターフェイスと同様の方法で特性を実装できます。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
      println(st.DisplayMarks());
   }
}

trait Marks {
   void DisplayMarks() {
      println("Display Marks");
   }
}

class Student implements Marks {
   int StudentID
   int Marks1;
}

インターフェースの実装

特性はインターフェースを実装できます。その場合、インターフェースはimplementsキーワードを使用して宣言されます。

インターフェースを実装する特性の例を以下に示します。次の例では、次の重要な点に注意することができます。

インターフェイスTotalは、メソッドDisplayTotalで定義されます。
特性マークはTotalインターフェースを実装するため、DisplayTotalメソッドの実装を提供する必要があります。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;

      println(st.DisplayMarks());
      println(st.DisplayTotal());
   }
}

interface Total {
   void DisplayTotal()
}

trait Marks implements Total {
   void DisplayMarks() {
      println("Display Marks");
   }

   void DisplayTotal() {
      println("Display Total");
   }
}

class Student implements Marks {
   int StudentID
   int Marks1;
}

上記のプログラムの出力は次のようになります-

Display Marks
Display Total

プロパティ

特性はプロパティを定義できます。プロパティを持つ特性の例を以下に示します。

次の例では、整数型のMarks1はプロパティです。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;

      println(st.DisplayMarks());
      println(st.DisplayTotal());
   }

   interface Total {
      void DisplayTotal()
   }

   trait Marks implements Total {
      int Marks1;

      void DisplayMarks() {
         this.Marks1 = 10;
         println(this.Marks1);
      }

      void DisplayTotal() {
         println("Display Total");
      }
   }

   class Student implements Marks {
      int StudentID
   }
}

上記のプログラムの出力は次のようになります-

10
Display Total

行動の構成

特性を使用して、制御された方法で複数の継承を実装し、ダイヤモンドの問題を回避できます。次のコード例では、 Marks と Total の2つの特性を定義しています。 Studentクラスは両方の特性を実装します。学生クラスは両方の特性を拡張するため、 DisplayMarks と DisplayTotal の両方のメソッドにアクセスできます。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;

      println(st.DisplayMarks());
      println(st.DisplayTotal());
   }
}

trait Marks {
   void DisplayMarks() {
      println("Marks1");
   }
}

trait Total {
   void DisplayTotal() {
      println("Total");
   }
}

class Student implements Marks,Total {
   int StudentID
}

上記のプログラムの出力は次のようになります-

Total
Marks1

特性の拡張

特性は別の特性を拡張する場合があり、その場合は extends キーワードを使用する必要があります。次のコード例では、MarksトレイトでTotalトレイトを拡張しています。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      println(st.DisplayMarks());
   }
}

trait Marks {
   void DisplayMarks() {
      println("Marks1");
   }
}

trait Total extends Marks {
   void DisplayMarks() {
      println("Total");
   }
}

class Student implements Total {
   int StudentID
}

上記のプログラムの出力は次のようになります-

Total

Groovy-クロージャー

クロージャーは、コードの短い匿名ブロックです。通常は数行のコードにまたがります。メソッドは、コードのブロックをパラメーターとして受け取ることもできます。それらは本質的に匿名です。

以下は、単純なクロージャーの例とその外観です。

class Example {
   static void main(String[] args) {
      def clos = {println "Hello World"};
      clos.call();
   }
}

上記の例では、コード行-\ {println "Hello World"}はクロージャーとして知られています。この識別子によって参照されるコードブロックは、callステートメントで実行できます。

上記のプログラムを実行すると、次の結果が得られます-

Hello World

クロージャーの正式なパラメーター

クロージャーには、Groovyのメソッドと同じように、より便利にするための正式なパラメーターを含めることもできます。

class Example {
   static void main(String[] args) {
      def clos = {param->println "Hello ${param}"};
      clos.call("World");
   }
}

上記のコード例では、クロージャーがパラメーターを取得する$ \ {param}の使用に注意してください。 clos.callステートメントを介してクロージャーを呼び出す場合、クロージャーにパラメーターを渡すオプションがあります。

上記のプログラムを実行すると、次の結果が得られます-

Hello World

次の図は、前の例を繰り返して同じ結果を生成しますが、参照できる暗黙の単一パラメーターを使用できることを示しています。ここで「それ」はGroovyのキーワードです。

class Example {
   static void main(String[] args) {
      def clos = {println "Hello ${it}"};
      clos.call("World");
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Hello World

クロージャーと変数

より正式には、クロージャーは、クロージャーが定義されるときに変数を参照できます。以下は、これを実現する方法の例です。

class Example {
   static void main(String[] args) {
      def str1 = "Hello";
      def clos = {param -> println "${str1} ${param}"}
      clos.call("World");

     //We are now changing the value of the String str1 which is referenced in the closure
      str1 = "Welcome";
      clos.call("World");
   }
}

上記の例では、クロージャーにパラメーターを渡すことに加えて、str1という変数も定義しています。クロージャは、パラメータとともに変数も取ります。

上記のプログラムを実行すると、次の結果が得られます-

Hello World
Welcome World

メソッドでクロージャーを使用する

クロージャーはメソッドのパラメーターとしても使用できます。 Groovyでは、リストやコレクションなどのデータ型の多くの組み込みメソッドには、パラメーター型としてクロージャーがあります。

次の例は、クロージャーをパラメーターとしてメソッドに送信する方法を示しています。

class Example {
   def static Display(clo) {
     //This time the $param parameter gets replaced by the string "Inner"
      clo.call("Inner");
   }

   static void main(String[] args) {
      def str1 = "Hello";
      def clos = { param -> println "${str1} ${param}" }
      clos.call("World");

     //We are now changing the value of the String str1 which is referenced in the closure
      str1 = "Welcome";
      clos.call("World");

     //Passing our closure to a method
      Example.Display(clos);
   }
}

上記の例では、

引数としてクロージャーを受け取るDisplayという静的メソッドを定義しています。
次に、メインメソッドでクロージャーを定義し、パラメーターとしてDisplayメソッドに渡します。

上記のプログラムを実行すると、次の結果が得られます-

Hello World
Welcome World
Welcome Inner

コレクションと文字列のクロージャー

いくつかのList、Map、およびStringメソッドは、引数としてクロージャを受け入れます。これらのデータ型でクロージャーを使用する方法の例を見てみましょう。

リストでクロージャを使用する

次の例は、クロージャーをリストで使用する方法を示しています。次の例では、最初に値の単純なリストを定義しています。リストコレクションタイプは、。 each という関数を定義します。この関数は、パラメーターとしてクロージャーを取り、リストの各要素にクロージャーを適用します。

class Example {
   static void main(String[] args) {
      def lst = [11, 12, 13, 14];
      lst.each {println it}
   }
}

上記のプログラムを実行すると、次の結果が得られます-

マップでクロージャを使用する

次の例は、マップでクロージャーを使用する方法を示しています。次の例では、最初にキー値アイテムの単純なマップを定義しています。次に、マップコレクションタイプは.eachという関数を定義します。この関数は、パラメーターとしてクロージャーを受け取り、マップの各キーと値のペアにクロージャーを適用します。

class Example {
   static void main(String[] args) {
      def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"]
      mp.each {println it}
      mp.each {println "${it.key} maps to: ${it.value}"}
   }
}

上記のプログラムを実行すると、次の結果が得られます-

TopicName = Maps
TopicDescription = Methods in Maps
TopicName maps to: Maps
TopicDescription maps to: Methods in Maps

多くの場合、コレクションのメンバー全体を反復処理し、要素が何らかの基準を満たしている場合にのみ何らかのロジックを適用したい場合があります。これは、クロージャーの条件ステートメントで簡単に処理できます。

class Example {
   static void main(String[] args) {
      def lst = [1,2,3,4];
      lst.each {println it}
      println("The list will only display those numbers which are divisible by 2")
      lst.each{num -> if(num % 2 == 0) println num}
   }
}

上記の例は、リスト内の各項目が2で割り切れるかどうかを確認するために使用されるクロージャーで使用される条件付きif（num％2 == 0）式を示しています。

上記のプログラムを実行すると、次の結果が得られます-

1
2
3
4
The list will only display those numbers which are divisible by 2.
2
4

クロージャーで使用されるメソッド

クロージャー自体がいくつかのメソッドを提供します。

Sr.No.	Methods & Description
1	find() findメソッドは、コレクションにある基準に一致する最初の値を見つけます。
2	findAll() クローズ条件に一致する受信オブジェクト内のすべての値を検索します。
3	any() & every() メソッドanyは、ブール述語が少なくとも1つの要素に対して有効かどうかを確認するコレクションの各要素を反復処理します。
4	collect() メソッドcollectはコレクションを反復処理し、クロージャーをトランスフォーマーとして使用して各要素を新しい値に変換します。

Groovy-注釈

_注釈_は、プログラム自体の一部ではないプログラムに関するデータを提供するメタデータの形式です。注釈は、注釈を付けたコードの動作には直接影響しません。

注釈は主に次の理由で使用されます-

コンパイラの情報-エラーを検出したり、警告を抑制するために、コンパイラは注釈を使用できます。
コンパイル時および展開時の処理-ソフトウェアツールは、注釈情報を処理してコード、XMLファイルなどを生成できます。
実行時処理-実行時に検査できる注釈がいくつかあります。

Groovyでは、基本的な注釈は次のようになります-

@interface-アットマーク文字（@）は、後に続くものが注釈であることをコンパイラーに示します。

注釈は、ボディとオプションのデフォルト値のない*フォーム*のメソッドでメンバーを定義できます。

注釈は次のタイプに適用できます-

文字列タイプ

文字列の注釈の例を以下に示します-

@interface Simple {
   String str1() default "HelloWorld";
}

列挙型

enum DayOfWeek { mon, tue, wed, thu, fri, sat, sun }
@interface Scheduled {
   DayOfWeek dayOfWeek()
}

クラスタイプ

@interface Simple {}
@Simple
class User {
   String username
   int age
}

def user = new User(username: "Joe",age:1);
println(user.age);
println(user.username);

注釈メンバーの値

注釈を使用する場合、少なくともデフォルト値を持たないすべてのメンバーを設定する必要があります。例を以下に示します。アノテーションExampleを定義した後に使用する場合、値を割り当てる必要があります。

@interface Example {
   int status()
}

@Example(status = 1)

クロージャー注釈パラメーター

Groovyのアノテーションの優れた機能は、クロージャーをアノテーション値としても使用できることです。したがって、注釈はさまざまな式で使用できます。

以下に例を示します。アノテーションOnlyifは、クラス値に基づいて作成されます。次に、注釈は2つのメソッドに適用され、number変数の値に基づいて異なるメッセージを結果変数にポストします。

@interface OnlyIf {
   Class value()
}

@OnlyIf({ number<=6 })
void Version6() {
   result << 'Number greater than 6'
}

@OnlyIf({ number>=6 })
void Version7() {
   result << 'Number greater than 6'
}

メタ注釈

これは、Groovyのアノテーションの非常に便利な機能です。以下に示すように、メソッドに対して複数の注釈を付ける場合があります。これは、複数の注釈を持つために面倒になる場合があります。

@Procedure
@Master class
MyMasterProcedure {}

このような場合、複数の注釈をまとめたメタ注釈を定義し、メタ注釈をメソッドに適用できます。したがって、上記の例では、AnnotationCollectorを使用して注釈のコレクションを最初に定義できます。

import groovy.transform.AnnotationCollector

@Procedure
@Master
@AnnotationCollector

これが完了したら、次のメタアノテーターをメソッドに適用できます-

import groovy.transform.AnnotationCollector

@Procedure
@Master
@AnnotationCollector

@MasterProcedure
class MyMasterProcedure {}

Groovy-XML

XMLは、オペレーティングシステムや開発言語に関係なく、プログラマが他のアプリケーションで読み取れるアプリケーションを開発できる、移植可能なオープンソース言語です。これは、アプリケーション間でデータを交換するために使用される最も一般的な言語の1つです。

XMLとは何ですか？

拡張マークアップ言語XMLは、HTMLやSGMLによく似たマークアップ言語です。これは、World Wide Web Consortiumによって推奨されており、オープンスタンダードとして利用できます。 XMLは、SQLベースのバックボーンを必要とせずに、少量から中量のデータを追跡するのに非常に役立ちます。

GroovyでのXMLサポート

Groovy言語は、XML言語の豊富なサポートも提供します。使用される2つの最も基本的なXMLクラスは-

XML Markup Builder -Groovyは、さまざまなツリー構造のオブジェクト表現を作成するためにサブクラス化できるツリーベースのマークアップジェネレーターBuilderSupportをサポートしています。通常、これらのビルダーは、XMLマークアップ、HTMLマークアップを表すために使用されます。 Groovyのマークアップジェネレーターは、疑似メソッドの呼び出しをキャッチし、それらをツリー構造の要素またはノードに変換します。これらの擬似メソッドのパラメーターは、ノードの属性として扱われます。メソッド呼び出しの一部としてのクロージャーは、結果のツリーノードのネストされたサブコンテンツと見なされます。
XML Parser -Groovy XmlParserクラスは、XMLドキュメントをノードインスタンスのツリーに解析するための単純なモデルを採用しています。各ノードには、XML要素の名前、要素の属性、および任意の子ノードへの参照があります。このモデルは、ほとんどの単純なXML処理に十分です。

すべてのXMLコード例について、次の単純なXMLファイルmovies.xmlを使用して、XMLファイルを作成し、その後ファイルを読み取ります。

<collection shelf = "New Arrivals">

   <movie title = "Enemy Behind">
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>

   <movie title = "Transformers">
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>

   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <year>1986</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Vash the Stam pede!</description>
   </movie>

   <movie title = "Ishtar">
      <type>Comedy</type>
      <format>VHS</format>
      <year>1987</year>
      <rating>PG</rating>
      <stars>2</stars>
      <description>Viewable boredom </description>
   </movie>

</collection>

XMLマークアップビルダー

構文

public MarkupBuilder()

MarkupBuilderは、XMLドキュメント全体を構築するために使用されます。 XMLドキュメントは、最初にXMLドキュメントクラスのオブジェクトを作成することで作成されます。オブジェクトを作成したら、擬似メソッドを呼び出してXMLドキュメントのさまざまな要素を作成できます。

1つのブロック、つまり上記のXMLドキュメントから1つのムービー要素を作成する方法の例を見てみましょう-

import groovy.xml.MarkupBuilder

class Example {
   static void main(String[] args) {
      def mB = new MarkupBuilder()

     //Compose the builder
      mB.collection(shelf : 'New Arrivals') {
         movie(title : 'Enemy Behind')
         type('War, Thriller')
         format('DVD')
         year('2003')
         rating('PG')
         stars(10)
         description('Talk about a US-Japan war')
      }
   }
}

上記の例では、次のことに注意する必要があります-

* mB.collection（）*-これは、<collection> </collection>のヘッドXMLタグを作成するマークアップジェネレーターです。
* movie（title： 'Enemy Behind'）*-これらの擬似メソッドは、値を持つタグを作成するこのメソッドで子タグを作成します。 titleと呼ばれる値を指定することにより、これは実際に要素の属性を作成する必要があることを示します。
XMLドキュメントの残りの要素を作成するために、クロージャーが擬似メソッドに提供されます。
生成されたXMLが標準出力ストリームに発行されるように、クラスMarkupBuilderのデフォルトコンストラクターが初期化されます

上記のプログラムを実行すると、次の結果が得られます-

<collection shelf = 'New Arrivals'>
   <movie title = 'Enemy Behind'/>
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>
</collection>

XMLドキュメント全体を作成するには、次のことを行う必要があります。

要素のさまざまな値を保存するには、マップエントリを作成する必要があります。
マップの各要素に対して、各要素に値を割り当てています。

import groovy.xml.MarkupBuilder

class Example {
   static void main(String[] args) {
      def mp = [1 : ['Enemy Behind', 'War, Thriller','DVD','2003',
         'PG', '10','Talk about a US-Japan war'],
         2 : ['Transformers','Anime, Science Fiction','DVD','1989',
         'R', '8','A scientific fiction'],
         3 : ['Trigun','Anime, Action','DVD','1986',
         'PG', '10','Vash the Stam pede'],
         4 : ['Ishtar','Comedy','VHS','1987', 'PG',
         '2','Viewable boredom ']]

      def mB = new MarkupBuilder()

     //Compose the builder
      def MOVIEDB = mB.collection('shelf': 'New Arrivals') {
         mp.each {
            sd ->
            mB.movie('title': sd.value[0]) {
               type(sd.value[1])
               format(sd.value[2])
               year(sd.value[3])
               rating(sd.value[4])
               stars(sd.value[4])
               description(sd.value[5])
            }
         }
      }
   }
}

上記のプログラムを実行すると、次の結果が得られます-

<collection shelf = 'New Arrivals'>
   <movie title = 'Enemy Behind'>
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>PG</stars>
      <description>10</description>
   </movie>
   <movie title = 'Transformers'>
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>R</stars>
      <description>8</description>
   </movie>
   <movie title = 'Trigun'>
      <type>Anime, Action</type>
      <format>DVD</format>
      <year>1986</year>
      <rating>PG</rating>
      <stars>PG</stars>
      <description>10</description>
   </movie>
   <movie title = 'Ishtar'>
      <type>Comedy</type>
      <format>VHS</format>
      <year>1987</year>
      <rating>PG</rating>
      <stars>PG</stars>
      <description>2</description>
   </movie>
</collection>

XML解析

Groovy XmlParserクラスは、XMLドキュメントをノードインスタンスのツリーに解析するための単純なモデルを採用しています。各ノードには、XML要素の名前、要素の属性、および任意の子ノードへの参照があります。このモデルは、ほとんどの単純なXML処理に十分です。

構文

public XmlParser()
   throws ParserConfigurationException,
      SAXException

次のコードは、XMLパーサーを使用してXMLドキュメントを読み取る方法の例を示しています。

Movies.xmlという同じドキュメントがあり、XMLドキュメントを解析して適切な出力をユーザーに表示したいとします。次のコードは、XMLドキュメントのコンテンツ全体を走査し、ユーザーに適切な応答を表示する方法のスニペットです。

import groovy.xml.MarkupBuilder
import groovy.util.*

class Example {

   static void main(String[] args) {

      def parser = new XmlParser()
      def doc = parser.parse("D:\\Movies.xml");

      doc.movie.each{
         bk->
         print("Movie Name:")
         println "${bk['@title']}"

         print("Movie Type:")
         println "${bk.type[0].text()}"

         print("Movie Format:")
         println "${bk.format[0].text()}"

         print("Movie year:")
         println "${bk.year[0].text()}"

         print("Movie rating:")
         println "${bk.rating[0].text()}"

         print("Movie stars:")
         println "${bk.stars[0].text()}"

         print("Movie description:")
         println "${bk.description[0].text()}"
         println("*******************************")
      }
   }
}

上記のプログラムを実行すると、次の結果が得られます-

Movie Name:Enemy Behind
Movie Type:War, Thriller
Movie Format:DVD
Movie year:2003
Movie rating:PG
Movie stars:10
Movie description:Talk about a US-Japan war
*******************************
Movie Name:Transformers
Movie Type:Anime, Science Fiction
Movie Format:DVD
Movie year:1989
Movie rating:R
Movie stars:8
Movie description:A schientific fiction
*******************************
Movie Name:Trigun
Movie Type:Anime, Action
Movie Format:DVD
Movie year:1986
Movie rating:PG
Movie stars:10
Movie description:Vash the Stam pede!
*******************************
Movie Name:Ishtar
Movie Type:Comedy
Movie Format:VHS
Movie year:1987
Movie rating:PG
Movie stars:2
Movie description:Viewable boredom

上記のコードについて注意すべき重要なこと。

クラスXmlParserのオブジェクトは、XMLドキュメントの解析に使用できるように形成されています。
パーサーには、XMLファイルの場所が与えられます。
各ムービー要素について、クロージャーを使用して各子ノードを参照し、関連情報を表示しています。

movie要素自体については、@記号を使用して、movie要素に付加されたtitle属性を表示しています。

Groovy-JMX

JMXは、Java仮想環境と関係のあるすべてのアプリケーションを監視するために使用される事実上の標準です。 GroovyがJavaの上に直接置かれていることを考えると、GroovyはJavaを使用したJMXですでに行われた膨大な量の作業を活用できます。

JVMの監視

JVMの監視を実行するために、java.lang.managementで利用可能な標準クラスを使用できます。次のコード例は、これを行う方法を示しています。

import java.lang.management.*

def os = ManagementFactory.operatingSystemMXBean
println """OPERATING SYSTEM:
\tOS architecture = $os.arch
\tOS name = $os.name
\tOS version = $os.version
\tOS processors = $os.availableProcessors
"""

def rt = ManagementFactory.runtimeMXBean
println """RUNTIME:
   \tRuntime name = $rt.name
   \tRuntime spec name = $rt.specName
   \tRuntime vendor = $rt.specVendor
   \tRuntime spec version = $rt.specVersion
   \tRuntime management spec version = $rt.managementSpecVersion
   """

def mem = ManagementFactory.memoryMXBean
def heapUsage = mem.heapMemoryUsage
def nonHeapUsage = mem.nonHeapMemoryUsage

println """MEMORY:
   HEAP STORAGE:
      \tMemory committed = $heapUsage.committed
      \tMemory init = $heapUsage.init
      \tMemory max = $heapUsage.max
      \tMemory used = $heapUsage.used NON-HEAP STORAGE:
      \tNon-heap memory committed = $nonHeapUsage.committed
      \tNon-heap memory init = $nonHeapUsage.init
      \tNon-heap memory max = $nonHeapUsage.max
      \tNon-heap memory used = $nonHeapUsage.used
   """

println "GARBAGE COLLECTION:"
ManagementFactory.garbageCollectorMXBeans.each { gc ->
   println "\tname = $gc.name"
   println "\t\tcollection count = $gc.collectionCount"
   println "\t\tcollection time = $gc.collectionTime"
   String[] mpoolNames =   gc.memoryPoolNames

   mpoolNames.each {
      mpoolName -> println "\t\tmpool name = $mpoolName"
   }
}

コードが実行されると、コードが実行されるシステムによって出力が異なります。出力のサンプルを以下に示します。

OPERATING SYSTEM:
   OS architecture = x86
   OS name = Windows 7
   OS version = 6.1
   OS processors = 4

RUNTIME:
   Runtime name = 5144@Babuli-PC
   Runtime spec name = Java Virtual Machine Specification
   Runtime vendor = Oracle Corporation
   Runtime spec version = 1.7
   Runtime management spec version = 1.2

MEMORY:
   HEAP STORAGE:
      Memory committed = 16252928
      Memory init = 16777216
      Memory max = 259522560
      Memory used = 7355840

NON-HEAP STORAGE:
   Non-heap memory committed = 37715968
   Non-heap memory init = 35815424
   Non-heap memory max = 123731968
   Non-heap memory used = 18532232

GARBAGE COLLECTION:
   name = Copy
   collection count = 15
   collection time = 47
   mpool name = Eden Space
   mpool name = Survivor Space

   name = MarkSweepCompact
      collection count = 0
      collection time = 0

      mpool name = Eden Space
      mpool name = Survivor Space
      mpool name = Tenured Gen
      mpool name = Perm Gen
      mpool name = Perm Gen [shared-ro]
      mpool name = Perm Gen [shared-rw]

Tomcatの監視

Tomcatを監視するには、Tomcatの起動時に次のパラメータを設定する必要があります-

set JAVA_OPTS = -Dcom.sun.management.jmxremote
Dcom.sun.management.jmxremote.port = 9004\

-Dcom.sun.management.jmxremote.authenticate=false
Dcom.sun.management.jmxremote.ssl = false

次のコードは、JMXを使用して、実行中のTomcatで使用可能なMBeanを検出し、どのWebモジュールかを判断し、各Webモジュールの処理時間を抽出します。

import groovy.swing.SwingBuilder

import javax.management.ObjectName
import javax.management.remote.JMXConnectorFactory as JmxFactory
import javax.management.remote.JMXServiceURL as JmxUrl
import javax.swing.WindowConstants as WC

import org.jfree.chart.ChartFactory
import org.jfree.data.category.DefaultCategoryDataset as Dataset
import org.jfree.chart.plot.PlotOrientation as Orientation

def serverUrl = 'service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi'
def server = JmxFactory.connect(new JmxUrl(serverUrl)).MBeanServerConnection
def serverInfo = new GroovyMBean(server, 'Catalina:type = Server').serverInfo
println "Connected to: $serverInfo"

def query = new ObjectName('Catalina:*')
String[] allNames = server.queryNames(query, null)

def modules = allNames.findAll { name ->
   name.contains('j2eeType=WebModule')
}.collect{ new GroovyMBean(server, it) }

println "Found ${modules.size()} web modules. Processing ..."
def dataset = new Dataset()

modules.each { m ->
   println m.name()
   dataset.addValue m.processingTime, 0, m.path
}

Groovy-JSON

この章では、JSONオブジェクトの解析と生成にGroovy言語を使用する方法について説明します。

JSON関数

Sr.No

Function & Libraries

1

JsonSlurper

JsonSlurperは、JSONテキストまたはリーダーコンテンツをGroovyデータに解析するクラスです

マップ、リスト、および整数、倍精度、ブール、ストリングなどのプリミティブ型などの構造。

2

JsonOutput

このメソッドは、GroovyオブジェクトをJSON文字列にシリアル化する役割を果たします。

JsonSlurperを使用したデータの解析

JsonSlurperは、JSONテキストまたはリーダーコンテンツをGroovyデータ構造（マップ、リスト、Integer、Double、Boolean、Stringなどのプリミティブ型）に解析するクラスです。

構文

def slurper = new JsonSlurper()

JSON slurperは、テキストまたはリーダーコンテンツをリストおよびマップのデータ構造に解析します。

JsonSlurperクラスには、パーサー実装用のバリアントがいくつか付属しています。特定の文字列の解析に関しては、要件が異なる場合があります。 Webサーバーからの応答から返されたJSONを読み取る必要がある場合を考えてみましょう。そのような場合、パーサーのJsonParserLaxバリアントを使用すると有益です。このパーシーは、JSONテキスト内のコメントだけでなく、引用文字列なども許可します。この種のパーサーを指定するには、JsonSlurperのオブジェクトを定義するときにJsonParserType.LAXパーサータイプを使用する必要があります。

以下の例を見てみましょう。この例は、httpモジュールを使用してWebサーバーからJSONデータを取得するためのものです。このタイプのトラバーサルの場合、最適なオプションはパーサータイプをJsonParserLaxバリアントに設定することです。

http.request( GET, TEXT ) {
   headers.Accept = 'application/json'
   headers.'User-Agent' = USER_AGENT

   response.success = {
      res, rd ->
      def jsonText = rd.text

     //Setting the parser type to JsonParserLax
      def parser = new JsonSlurper().setType(JsonParserType.LAX)
      def jsonResp = parser.parseText(jsonText)
   }
}

同様に、次の追加のパーサータイプがGroovyで利用可能です-

JsonParserCharArrayパーサーは基本的にJSON文字列を受け取り、基礎となる文字配列で動作します。値の変換中に、文字のサブ配列（「チョッピング」として知られるメカニズム）をコピーし、個別に操作します。
JsonFastParserはJsonParserCharArrayの特別なバリアントであり、最速のパーサーです。 JsonFastParserは、インデックスオーバーレイパーサーとも呼ばれます。指定されたJSON文字列の解析中に、新しいchar配列またはStringインスタンスの作成を回避するために、可能な限りの努力が行われます。基になる元の文字配列のみへのポインタを保持します。さらに、オブジェクトの作成を可能な限り遅らせます。
JsonParserUsingCharacterSourceは、非常に大きなファイル用の特別なパーサーです。「文字ウィンドウ」と呼ばれる手法を使用して、一定のパフォーマンス特性を備えた大きなJSONファイル（この場合は2MBを超えるサイズのファイル）を解析します。

テキストの解析

JsonSlurperクラスを使用する方法の例を見てみましょう。

import groovy.json.JsonSlurper

class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def object = jsonSlurper.parseText('{ "name": "John", "ID" : "1"}')

      println(object.name);
      println(object.ID);
   }
}

上記の例では、私たちは-

最初にJsonSlurperクラスのインスタンスを作成します
次に、JsonSlurperクラスのparseText関数を使用して、JSONテキストを解析します。
オブジェクトを取得すると、キーを介してJSON文字列の値に実際にアクセスできることがわかります。

上記のプログラムの出力は以下のとおりです-

John
1

整数のリストの解析

JsonSlurperの解析方法の別の例を見てみましょう。次の例では、整数のリストを解析しています。次のコードから、それぞれのListメソッドを使用してクロージャーを渡すことができることに気付くでしょう。

import groovy.json.JsonSlurper
class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      Object lst = jsonSlurper.parseText('{ "List": [2, 3, 4, 5] }')
      lst.each { println it }
   }
}

上記のプログラムの出力は以下のとおりです-

List=[2, 3, 4, 5]

プリミティブデータ型の解析リスト

JSONパーサーは、文字列、数値、オブジェクト、true、false、nullのプリミティブデータ型もサポートしています。 JsonSlurperクラスは、これらのJSONタイプを対応するGroovyタイプに変換します。

次の例は、JsonSlurperを使用してJSON文字列を解析する方法を示しています。そしてここで、JsonSlurperが個々のアイテムをそれぞれのプリミティブ型に解析できることがわかります。

import groovy.json.JsonSlurper
class Example {

   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def obj = jsonSlurper.parseText ''' {"Integer": 12, "fraction": 12.55, "double": 12e13}'''

      println(obj.Integer);
      println(obj.fraction);
      println(obj.double);
   }
}

上記のプログラムの出力は以下のとおりです-

12
12.55
1.2E+14

JsonOutput

次に、Jsonで出力を印刷する方法について説明します。これは、JsonOutputメソッドによって実行できます。このメソッドは、GroovyオブジェクトをJSON文字列にシリアル化する役割を果たします。

構文

Static string JsonOutput.toJson(datatype obj)

パラメータ-パラメータは、数値、ブール値、文字、文字列、日付、マップ、クロージャなどのデータ型のオブジェクトにすることができます。

戻り値のタイプ-戻り値のタイプはJSON文字列です。

例

以下は、これを実現する方法の簡単な例です。

import groovy.json.JsonOutput
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([name: 'John', ID: 1])
      println(output);
   }
}

上記のプログラムの出力は以下のとおりです-

{"name":"John","ID":1}

JsonOutputは、プレーンで古いgroovyオブジェクトにも使用できます。次の例では、Student型のオブジェクトを実際にJsonOutputメソッドに渡していることがわかります。

import groovy.json.JsonOutput
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([ new Student(name: 'John',ID:1),
         new Student(name: 'Mark',ID:2)])
      println(output);
   }
}

class Student {
   String name
   int ID;
}

上記のプログラムの出力は以下のとおりです-

[{"name":"John","ID":1},{"name":"Mark","ID":2}]

Groovy-DSLS

Groovyでは、最上位ステートメントのメソッド呼び出しの引数の括弧を省略することができます。これは「コマンドチェーン」機能と呼ばれます。この拡張機能は、そのような括弧のないメソッド呼び出しを連鎖できるようにすることで機能し、引数を括弧で囲む必要も連鎖した呼び出しの間にドットも必要としません。

呼び出しが a b c d として実行される場合、これは実際には* a（b）.c（d）*と同等になります。

DSLまたはドメイン固有の言語は、Groovyで記述されたコードを単純化し、一般ユーザーが簡単に理解できるようにすることを目的としています。次の例は、ドメイン固有の言語を持つことの正確な意味を示しています。

def lst = [1,2,3,4]
print lst

上記のコードは、printlnステートメントを使用してコンソールに出力される数字のリストを示しています。ドメイン固有の言語では、コマンドは次のようになります-

Given the numbers 1,2,3,4

Display all the numbers

したがって、上記の例は、ドメイン固有言語のニーズを満たすためのプログラミング言語の変換を示しています。

GroovyでDSLを実装する方法の簡単な例を見てみましょう-

class EmailDsl {
   String toText
   String fromText
   String body

  /* *
  * This method accepts a closure which is essentially the DSL. Delegate the
 *closure methods to
  * the DSL class so the calls can be processed
   */

   def static make(closure) {
      EmailDsl emailDsl = new EmailDsl()
     //any method called in closure will be delegated to the EmailDsl class
      closure.delegate = emailDsl
      closure()
   }

  /* *
  * Store the parameter as a variable and use it later to output a memo
   */

   def to(String toText) {
      this.toText = toText
   }

   def from(String fromText) {
      this.fromText = fromText
   }

   def body(String bodyText) {
      this.body = bodyText
   }
}

EmailDsl.make {
   to "Nirav Assar"
   from "Barack Obama"
   body "How are things? We are doing well. Take care"
}

上記のプログラムを実行すると、次の結果が得られます-

How are things? We are doing well. Take care

以下は、上記のコードの実装について注意する必要があります-

クロージャを受け入れる静的メソッドが使用されます。これは、DSLを実装するための手間のかからない方法です。
電子メールの例では、EmailDslクラスにmakeメソッドがあります。インスタンスを作成し、クロージャー内のすべての呼び出しをインスタンスに委任します。これは、「to」セクションと「from」セクションが最終的にEmailDslクラス内でメソッドを実行するメカニズムです。
to（）メソッドが呼び出されると、後でフォーマットするためにテキストをインスタンスに保存します。
これで、エンドユーザーが理解しやすい簡単な言語でEmailDSLメソッドを呼び出すことができます。

Groovy-データベース

Groovyのgroovy-sqlモジュールは、現在のJavaのJDBCテクノロジーよりも高度な抽象化を提供します。 Groovy sql APIは、さまざまなデータベースをサポートしていますが、その一部を以下に示します。

HSQLDB
オラクル
SQLサーバー
MySQL *MongoDB

この例では、MySQL DBを例として使用します。 GroovyでMySQLを使用するために最初にすることは、mysqlサイトからMySQL jdbc jarファイルをダウンロードすることです。* MySQLのfor * matを以下に示します。

mysql-connector-java-5.1.38-bin

次に、上記のjarファイルをワークステーションのクラスパスに追加してください。

データベース接続

MySQLデータベースに接続する前に、次のことを確認してください-

データベースTESTDBを作成しました。
TESTDBにテーブルEMPLOYEEを作成しました。
このテーブルには、FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEフィールドがあります。
ユーザーID「testuser」とパスワード「test123」は、TESTDBにアクセスするように設定されています。
mysql jarファイルをダウンロードし、ファイルをクラスパスに追加したことを確認してください。
リンクを理解するためにMySQLチュートリアルを実行しました：/mysql/index [MySQL Basics]

次の例は、MySQLデータベース「TESTDB」との接続方法を示しています。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB',
         'testuser', 'test123', 'com.mysql.jdbc.Driver')

     //Executing the query SELECT VERSION which gets the version of the database
     //Also using the eachROW method to fetch the result from the database

      sql.eachRow('SELECT VERSION()'){ row ->
         println row[0]
      }

      sql.close()
   }
}

このスクリプトを実行している間、それは次の結果を生成しています-

5.7.10-log
The Sql.newInstance method is used to establish a connection to the database.

データベーステーブルの作成

データベースに接続した後の次のステップは、データベースにテーブルを作成することです。次の例は、Groovyを使用してデータベースにテーブルを作成する方法を示しています。 Sqlクラスのexecuteメソッドは、データベースに対してステートメントを実行するために使用されます。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test123', 'com.mysql.jdbc.Driver')

      def sqlstr = """CREATE TABLE EMPLOYEE (
         FIRST_NAME CHAR(20) NOT NULL,
         LAST_NAME CHAR(20),
         AGE INT,
         SEX CHAR(1),
         INCOME FLOAT )"""

      sql.execute(sqlstr);
      sql.close()
   }
}

挿入操作

データベーステーブルにレコードを作成する場合に必要です。

例

次の例は、従業員テーブルにレコードを挿入します。コードはtry catchブロックに配置されるため、レコードが正常に実行されると、トランザクションはデータベースにコミットされます。トランザクションが失敗すると、ロールバックが行われます。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test123', 'com.mysql.jdbc.Driver')

      sql.connection.autoCommit = false

      def sqlstr = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }

      sql.close()
   }
}

基準に基づいて特定の行のみを選択する場合を考えます。次のコードは、パラメータープレースホルダーを追加して値を検索する方法を示しています。上記の例は、次のコードに示すようにパラメーターを取り込むように記述することもできます。 $記号は、sqlステートメントの実行時に値に置き換えることができるパラメーターを定義するために使用されます。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test123', 'com.mysql.jdbc.Driver')

      sql.connection.autoCommit = false

      def firstname = "Mac"
      def lastname ="Mohan"
      def age = 20
      def sex = "M"
      def income = 2000

      def sqlstr = "INSERT INTO EMPLOYEE(FIRST_NAME,LAST_NAME, AGE, SEX,
         INCOME) VALUES " &plus; "(${firstname}, ${lastname}, ${age}, ${sex}, ${income} )"

      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      } catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }

      sql.close()
   }
}

読み取り操作

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。データベース接続が確立されると、このデータベースにクエリを実行する準備が整います。

読み取り操作は、sqlクラスのeachRowメソッドを使用して実行されます。

構文

eachRow(GString gstring, Closure closure)

結果セットの各行で指定されたClosureを呼び出して、指定されたSQLクエリを実行します。

パラメーター

Gstring -実行する必要があるsqlステートメント。
Closure -読み取り操作から取得した行を処理するためのクロージャーステートメント。結果セットの各行で指定されたClosureを呼び出して、指定されたSQLクエリを実行します。

次のコード例は、従業員テーブルからすべてのレコードを取得する方法を示しています。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test123', 'com.mysql.jdbc.Driver')

      sql.eachRow('select * from employee') {
         tp ->
         println([tp.FIRST_NAME,tp.LAST_NAME,tp.age,tp.sex,tp.INCOME])
      }

      sql.close()
   }
}

上記のプログラムからの出力は次のようになります-

[Mac, Mohan, 20, M, 2000.0]

更新操作

データベースでのUPDATE操作とは、データベースですでに使用可能な1つ以上のレコードを更新することです。次の手順は、SEXが「M」であるすべてのレコードを更新します。ここでは、すべての男性の年齢を1年増やします。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args){
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test@123', 'com.mysql.jdbc.Driver')

      sql.connection.autoCommit = false
      def sqlstr = "UPDATE EMPLOYEE SET AGE = AGE &plus; 1 WHERE SEX = 'M'"

      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }

      sql.close()
   }
}

削除操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。以下は、AGEが20を超えるEMPLOYEEからすべてのレコードを削除する手順です。

import java.sql.*;
import groovy.sql.Sql

class Example {
   static void main(String[] args) {
     //Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',
         'test@123', 'com.mysql.jdbc.Driver')

      sql.connection.autoCommit = false
      def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"

      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }

      sql.close()
   }
}

トランザクションの実行

トランザクションは、データの一貫性を保証するメカニズムです。トランザクションには、次の4つのプロパティがあります-

Atomicity -トランザクションが完了するか、まったく何も起こりません。
一貫性-トランザクションは一貫した状態で開始し、システムを一貫した状態のままにする必要があります。
分離-トランザクションの中間結果は、現在のトランザクションの外部では見えません。
耐久性-トランザクションがコミットされると、システム障害が発生した後でも効果は持続します。

トランザクションを実装する方法の簡単な例を次に示します。 DELETE操作の前のトピックで、この例をすでに見ました。

def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"

try {
   sql.execute(sqlstr);
   sql.commit()
   println("Successfully committed")
}catch(Exception ex) {
   sql.rollback()
   println("Transaction rollback")
}
sql.close()

コミット操作

コミット操作は、操作を続行し、データベースへのすべての変更を完了するようにデータベースに指示するものです。

上記の例では、これは次のステートメントによって達成されます-

sql.commit()

ロールバック操作

1つ以上の変更に満足せず、それらの変更を完全に元に戻したい場合は、ロールバックメソッドを使用します。上記の例では、これは次のステートメントによって達成されます-

sql.rollback()

データベースの切断

データベース接続を切断するには、closeメソッドを使用します。

sql.close()

Groovy-ビルダー

ソフトウェア開発のプロセス中、開発者はデータ構造、ドメインクラス、XML、GUIレイアウト、出力ストリームなどの作成に多くの時間を費やすことがあります。また、これらの特定の要件を作成するために使用されるコードは、多くの場所のコード。これが、Groovy Builderが登場する場所です。 Groovyには、標準のオブジェクトと構造を作成するために使用できるビルダーがあります。開発者がこれらのビルダーを作成するために独自のコードを記述する必要がないため、これらのビルダーは時間を節約します。この章では、Groovyで利用可能なさまざまなビルダーについて説明します。

スイングビルダー

groovyでは、groovyで利用可能なswing Builderを使用してグラフィカルユーザーインターフェイスを作成することもできます。 Swingコンポーネントを開発するためのメインクラスはSwingBuilderクラスです。このクラスには、次のようなグラフィカルコンポーネントを作成するための多くのメソッドがあります-

JFrame -これはフレーム要素を作成するためのものです。
JTextField -これは、テキストフィールドコンポーネントの作成に使用されます。

SwingBuilderクラスを使用してSwingアプリケーションを作成する方法の簡単な例を見てみましょう。次の例では、次の点を見ることができます-

groovy.swing.SwingBuilderクラスとjavax.swing。*クラスをインポートする必要があります。
Swingアプリケーションに表示されるすべてのコンポーネントは、SwingBuilderクラスの一部です。
フレーム自体については、フレームの初期位置とサイズを指定できます。フレームのタイトルを指定することもできます。
フレームを表示するには、Visibilityプロパティをtrueに設定する必要があります。

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)

上記のプログラムの出力を以下に示します。次の出力は、JFrameとHelloLabのテキストを含むJLabelを示しています。

JLabel With a Text

テキストボックスを使用して入力画面を作成する次の例を見てみましょう。次の例では、学生名、件名、学校名のテキストボックスがあるフォームを作成します。次の例では、次のキーポイントを見ることができます-

画面上のコントロールのレイアウトを定義しています。この場合、グリッドレイアウトを使用しています。
ラベルに位置合わせプロパティを使用しています。
画面にテキストボックスを表示するためにtextFieldメソッドを使用しています。

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)

上記のプログラムの出力は以下のとおりです-

表示フォーム

イベントハンドラ

それでは、イベントハンドラを見てみましょう。イベントハンドラーは、ボタンが押されたときに何らかの処理を実行するためにボタンに使用されます。各ボタン疑似メソッド呼び出しには、actionPerformedパラメーターが含まれます。これは、クロージャとして表示されるコードブロックを表します。

2つのボタンを持つ画面を作成するための次の例を見てみましょう。いずれかのボタンが押されると、対応するメッセージがコンソール画面に送信されます。次の例では、次のキーポイントを見ることができます-

定義されたボタンごとに、actionPerformedメソッドを使用し、クロージャーを定義して、ボタンがクリックされたときに出力をコンソールに送信します。

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)

上記のプログラムの出力を以下に示します。いずれかのボタンをクリックすると、必要なメッセージがコンソールログ画面に送信されます。

オプションボタン

上記の例の別のバリエーションは、ハンドラーとして機能できるメソッドを定義することです。次の例では、DisplayAとDisplayBの2つのハンドラーを定義しています。

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)

上記のプログラムの出力は、前の例と同じままです。

DOM Builder

DOMビルダーは、HTML、XHTML、およびXMLを解析し、W3C DOMツリーに変換するために使用できます。

次の例は、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は、json型オブジェクトの作成に使用されます。

次の例は、Json Builderの使用方法を示しています。

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

上記のプログラムの出力を以下に示します。出力clearltは、Jsonbuilderが構造化されたノードセットからjsonオブジェクトを構築できたことを示しています。

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

jsonbuilderはリストを取得して、jsonオブジェクトに変換することもできます。次の例は、これを実現する方法を示しています。

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

上記のプログラムの出力を以下に示します。

[1,2,3]

jsonBuilderはクラスにも使用できます。次の例は、クラスのオブジェクトが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)

上記のプログラムの出力を以下に示します。

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

NodeBuilder

NodeBuilderは、任意のデータを処理するNodeオブジェクトのネストされたツリーを作成するために使用されます。 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は、仕様からファイルディレクトリ構造を生成するためのビルダーです。 FileTreeBuilderの使用方法の例を次に示します。

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

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

上記のコードの実行により、sample.txtというファイルがフォルダーmain/submain/Tutorialに作成されます。また、sample.txtファイルには「Hello World」というテキストが含まれます。

Groovy-コマンドライン

groovyshとして知られるGroovyシェルは、groovy式の評価、クラスの定義、および単純なプログラムの実行に簡単に使用できます。コマンドラインシェルは、Groovyのインストール時にインストールされます。

以下はGroovyで利用可能なコマンドラインオプションです-

Command line parameter	Full Name	Details
-C	--color[=FLAG]	Enable or disable use of ANSI colors
-D	--define=NAME=VALUE	Define a system property
-T	--terminal=TYPE	Specify the terminal TYPE to use
-V	--version	Display the version
-classpath		Specify where to find the class files – must be the first argument
-cp	--classpath	Aliases for '-classpath'
-d	--debug	--debug Enable debug output
-e	--evaluate=arg	Evaluate option fist when starting interactive session
-h	--help	Display this help message
-q	--quiet	Suppress superfluous output
-v	--verbose	Enable verbose output

次のスナップショットは、Groovyシェルで実行される式の簡単な例を示しています。次の例では、groovyシェルで「Hello World」と出力しています。

Groovy Shell

クラスと関数

コマンドプロンプトでクラスを定義し、新しいオブジェクトを作成して、クラスのメソッドを呼び出すのは非常に簡単です。次の例は、これを実装する方法を示しています。次の例では、単純なメソッドを使用して単純なStudentクラスを作成しています。コマンドプロンプト自体では、クラスのオブジェクトを作成し、Displayメソッドを呼び出しています。

標準クラスの作成

コマンドプロンプトでメソッドを定義し、メソッドを呼び出すのは非常に簡単です。メソッドはdefタイプを使用して定義されることに注意してください。また、Displayメソッドが呼び出されたときに実際の値に置き換えられるnameというパラメーターが含まれていることにも注意してください。次の例は、これを実装する方法を示しています。

コマンドのプロンプトと呼び出し

コマンド

シェルにはさまざまなコマンドがあり、シェルの環境への豊富なアクセスを提供します。以下に、それらのリストとその機能を示します。

Sr.No	Command SMP Command Description
1	:help （：h）このヘルプメッセージを表示する
2	? (:? ）へのエイリアス：：help
3	:exit （：x）シェルを終了します
4	:quit （：q）エイリアス：：exit
5	import （：i）クラスを名前空間にインポートします
6	:display （：d）現在のバッファを表示します
7	:clear （：c）バッファーをクリアし、プロンプトカウンターをリセットします
8	:show （：S）変数、クラス、またはインポートを表示
9	:inspect （：n）GUIオブジェクトブラウザーで変数または最後の結果を検査する
10	:purge （：p）変数、クラス、インポート、または設定を削除する
11	:edit （：e）現在のバッファを編集します
12	:load （：l）ファイルまたはURLをバッファーにロードします
13	. (:. ）へのエイリアス：：load
14	.save （：s）現在のバッファをファイルに保存します
15	.record （：r）現在のセッションをファイルに記録します
16	:alias （：a）エイリアスを作成する
17	:set （：=）プリファレンスを設定（またはリスト）
18	:register （：rc）新しいコマンドをシェルに登録します
19	:doc （：D）引数のドキュメントを表示するブラウザウィンドウを開きます
20	:history （：H）編集行の履歴の表示、管理、呼び出し

Groovy-単体テスト

オブジェクト指向システムの基本単位はクラスです。したがって、ユニットテストはクラス内のtestigで構成されます。取られるアプローチは、テスト中のクラスのオブジェクトを作成し、それを使用して、選択したメソッドが期待どおりに実行されることを確認することです。すべてのメソッドをテストできるわけではありません。すべてのメソッドをテストすることが常に実用的ではないためです。ただし、重要かつ重要な方法についてはユニットテストを実施する必要があります。

JUnitは、Javaコードの自動ユニットテストで受け入れられている業界標準であるオープンソースのテストフレームワークです。幸いなことに、JUnitフレームワークはGroovyクラスのテストに簡単に使用できます。必要なのは、標準のGroovy環境の一部であるGroovyTestCaseクラスを拡張することだけです。 Groovyテストケースクラスは、Junitテストケースに基づいています。

簡単なJunitテストケースの作成

アプリケーションクラスファイルに次のクラスが定義されていると仮定しましょう-

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.name = "Joe";
      mst.ID = 1;
      println(mst.Display())
   }
}

public class Student {
   String name;
   int ID;

   String Display() {
      return name +ID;
   }
}

上記のプログラムの出力を以下に示します。

Joe1

そして、Studentクラスのテストケースを作成したいとします。典型的なテストケースは以下のようになります。次のポイントは、次のコードについて注意する必要があります-

テストケースクラスはGroovyTestCaseクラスを拡張します
アサートメソッドを使用して、Displayメソッドが正しい文字列を返すようにします。

class StudentTest extends GroovyTestCase {
   void testDisplay() {
      def stud = new Student(name : 'Joe', ID : '1')
      def expected = 'Joe1'
      assertToString(stud.Display(), expected)
   }
}

Groovyテストスイート

通常、単体テストの数が増えると、すべてのテストケースを1つずつ実行し続けることが難しくなります。したがって、Groovyは、すべてのテストケースを1つの論理ユニットにカプセル化できるテストスイートを作成する機能を提供します。次のコードスニペットは、これを実現する方法を示しています。次のことは、コードについて注意する必要があります-

GroovyTestSuiteは、すべてのテストケースを1つにカプセル化するために使用されます。
次の例では、2つのテストケースファイルがあると仮定しています。1つは StudentTest と呼ばれ、もう1つは必要なすべてのテストを含む EmployeeTest です。

import groovy.util.GroovyTestSuite
import junit.framework.Test
import junit.textui.TestRunner

class AllTests {
   static Test suite() {
      def allTests = new GroovyTestSuite()
      allTests.addTestSuite(StudentTest.class)
      allTests.addTestSuite(EmployeeTest.class)
      return allTests
   }
}

TestRunner.run(AllTests.suite())

Groovy-テンプレートエンジン

Groovyのテンプレートエンジンは、差し込み印刷（多くのアドレスへのメール、特に広告の送信を促進するために、データベースから文字と封筒に名前とアドレスを自動的に追加する）のように動作しますが、はるかに一般的です。

文字列の単純なテンプレート

以下の簡単な例を使用する場合、最初に文字列「Groovy」を保持する名前変数を定義します。 printlnステートメントでは、$記号を使用して、値を挿入できるパラメーターまたはテンプレートを定義しています。

def name = "Groovy"
println "This Tutorial is about ${name}"

上記のコードをgroovyで実行すると、次の出力が表示されます。出力は、$ nameがdefステートメントによって割り当てられた値に置き換えられたことを明確に示しています。

シンプルなテンプレートエンジン

次に、テンプレートでJSPのようなスクリプトレットとEL式を使用して、パラメータ化されたテキストを生成できるようにするSimpleTemplateEngineの例を示します。テンプレートエンジンを使用すると、パラメーターとその値のリストをバインドして、定義済みのプレースホルダーを持つ文字列で置き換えることができます。

def text ='This Tutorial focuses on $TutorialName. In this tutorial you will learn

about $Topic'

def binding = ["TutorialName":"Groovy", "Topic":"Templates"]
def engine = new groovy.text.SimpleTemplateEngine()
def template = engine.createTemplate(text).make(binding)

println template

上記のコードをgroovyで実行すると、次の出力が表示されます。

XMLファイルにテンプレート機能を使用してみましょう。最初のステップとして、次のコードをStudent.templateというファイルに追加します。次のファイルでは、要素の実際の値ではなく、プレースホルダーが追加されていることがわかります。したがって、$ name、$ is、および$ subjectはすべて、実行時に置き換える必要があるプレースホルダーとして配置されます。

<Student>
   <name>${name}</name>
   <ID>${id}</ID>
   <subject>${subject}</subject>
</Student>

次に、Groovyスクリプトコードを追加して、上記のテンプレートを実際の値に置き換えるために使用できる機能を追加します。次のコードについては、次のことに注意してください。

実際の値へのプレースホルダーのマッピングは、バインディングとSimpleTemplateEngineを介して行われます。バインディングは、プレースホルダーをキーとして、置換を値として持つマップです。

import groovy.text.*
import java.io.*

def file = new File("D:/Student.template")
def binding = ['name' : 'Joe', 'id' : 1, 'subject' : 'Physics']

def engine = new SimpleTemplateEngine()
def template = engine.createTemplate(file)
def writable = template.make(binding)

println writable

上記のコードをgroovyで実行すると、次の出力が表示されます。出力から、関連するプレースホルダーの値が正常に置換されていることがわかります。

<Student>
   <name>Joe</name>
   <ID>1</ID>
   <subject>Physics</subject>
</Student>

StreamingTemplateEngine

StreamingTemplateEngineエンジンは、Groovyで使用できる別のテンプレートエンジンです。これは、SimpleTemplateEngineと同等ですが、書き込み可能なクロージャーを使用してテンプレートを作成し、大規模なテンプレートに対してよりスケーラブルにします。具体的には、このテンプレートエンジンは64kを超える文字列を処理できます。

以下は、StreamingTemplateEngineの使用方法の例です-

def text = '''This Tutorial is <% out.print TutorialName %> The Topic name

is ${TopicName}'''
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)

def binding = [TutorialName : "Groovy", TopicName  : "Templates",]
String response = template.make(binding)
println(response)

上記のコードをgroovyで実行すると、次の出力が表示されます。

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngineは、テンプレートソースと期待される出力の両方がXMLであることが意図されているテンプレートシナリオで使用されます。テンプレートは、通常の$ \ {expression}および$ variable表記を使用して、テンプレートに任意の式を挿入します。

以下は、XMLTemplateEngineの使用方法の例です。

def binding = [StudentName: 'Joe', id: 1, subject: 'Physics']
def engine = new groovy.text.XmlTemplateEngine()

def text = '''\
   <document xmlns:gsp='http://groovy.codehaus.org/2005/gsp'>
      <Student>
         <name>${StudentName}</name>
         <ID>${id}</ID>
         <subject>${subject}</subject>
      </Student>
   </document>


def template = engine.createTemplate(text).make(binding)
println template.toString()

上記のコードをgroovyで実行すると、次の出力が表示されます

   Joe


   1


   Physics

Groovy-メタオブジェクトプログラミング

メタオブジェクトプログラミングまたはMOPを使用すると、メソッドを動的に呼び出したり、クラスやメソッドをその場で作成したりできます。

だからこれはどういう意味ですか？ Studentと呼ばれるクラスを考えてみましょう。これは、メンバー変数やメソッドのない空のクラスです。このクラスで次のステートメントを呼び出す必要があるとします。

Def myStudent = new Student()
myStudent.Name = ”Joe”;
myStudent.Display()

メタオブジェクトプログラミングでは、クラスにメンバ変数NameまたはメソッドDisplay（）がなくても、上記のコードは引き続き機能します。

これはどのように機能しますか？これを解決するには、Groovyの実行プロセスにフックするGroovyInterceptableインターフェースを実装する必要があります。このインターフェイスで使用できるメソッドは次のとおりです。

Public interface GroovyInterceptable {
   Public object invokeMethod(String methodName, Object args)
   Public object getproperty(String propertyName)
   Public object setProperty(String propertyName, Object newValue)
   Public MetaClass getMetaClass()
   Public void setMetaClass(MetaClass metaClass)
}

したがって、上記のインターフェースの説明で、invokeMethod（）を実装する必要がある場合、存在するか存在しないすべてのメソッドに対して呼び出されると仮定します。

プロパティがありません

では、欠落しているプロパティに対してメタオブジェクトプログラミングを実装する方法の例を見てみましょう。次のコードについて、次の重要事項に注意する必要があります。

クラスStudentには、NameまたはIDという名前のメンバー変数が定義されていません。
Studentクラスは、GroovyInterceptableインターフェイスを実装します。
その場で作成されるメンバー変数の値を保持するために使用されるdynamicPropsというパラメーターがあります。
メソッドgetpropertyおよびsetpropertyは、実行時にクラスのプロパティの値を取得および設定するために実装されています。

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;

      println(mst.Name);
      println(mst.ID);
   }
}

class Student implements GroovyInterceptable {
   protected dynamicProps=[:]

   void setProperty(String pName,val) {
      dynamicProps[pName] = val
   }

   def getProperty(String pName) {
      dynamicProps[pName]
   }
}

次のコードの出力は次のようになります-

Joe
1

欠落しているメソッド

では、欠落しているプロパティに対してメタオブジェクトプログラミングを実装する方法の例を見てみましょう。次のキーについては、次のコードについて注意する必要があります-

クラスStudentは、メソッドが存在するかどうかに関係なく呼び出されるinvokeMethodメソッドを実装します。

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;

      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   }
}

class Student implements GroovyInterceptable {
   protected dynamicProps = [:]

   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   }

   def getProperty(String pName) {
      dynamicProps[pName]
   }

   def invokeMethod(String name, Object args) {
      return "called invokeMethod $name $args"
   }
}

次のコードの出力は次のようになります。メソッドDisplayが存在しない場合でも、メソッド例外が見つからないというエラーはありません。

Joe
1

メタクラス

この機能は、MetaClassの実装に関連しています。デフォルトの実装では、ゲッターとセッターを呼び出さずにフィールドにアクセスできます。次の例は、metaClass関数を使用して、クラス内のプライベート変数の値を変更する方法を示しています。

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      println mst.getName()
      mst.metaClass.setAttribute(mst, 'name', 'Mark')
      println mst.getName()
   }
}

class Student {
   private String name = "Joe";

   public String getName() {
      return this.name;
   }
}

次のコードの出力は次のようになります-

Joe
Mark

メソッドがありません

GroovyはmethodMissingの概念をサポートしています。このメソッドは、指定された名前または引数、あるいはその両方のメソッドが見つからない場合、メソッドのディスパッチが失敗した場合にのみ呼び出されるという点で、invokeMethodとは異なります。次の例は、methodMissingの使用方法を示しています。

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;

      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   }
}

class Student implements GroovyInterceptable {
   protected dynamicProps = [:]

   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   }

   def getProperty(String pName) {
      dynamicProps[pName]
   }

   def methodMissing(String name, def args) {
      println "Missing method"
   }
}

次のコードの出力は次のようになります-

Joe
1
Missing method

Groovy-quick-guide

Groovy-概要

Groovyの機能

Groovy-環境

Gradle

メーベン

Groovy-基本構文

初めてのHello Worldプログラムを作成する

Groovyのインポートステートメント

Groovyのトークン

Groovyのコメント

セミコロン

識別子

キーワード

空白

リテラル

Groovy-データ型

組み込みデータ型

バインドされた値

クラス数値

Groovy-変数

可変宣言

変数の命名

変数の印刷

Groovy-オペレーター

算術演算子

関係演算子

論理演算子

ビット演算子

割り当て演算子

範囲演算子

演算子の優先順位

Groovy-ループ

ループ制御ステートメント

Groovy-意思決定

Groovy-メソッド

メソッドのパラメーター

デフォルトパラメータ

メソッドの戻り値

インスタンスメソッド

ローカルおよび外部パラメーター名

プロパティのこのメソッド

Groovy-ファイルI/O

ファイルを読む

ファイルの内容を文字列全体として読み取る

ファイルへの書き込み

ファイルのサイズを取得する

ファイルがディレクトリかどうかのテスト

ディレクトリを作成する

ファイルを削除する

ファイルをコピーする

ディレクトリの内容を取得する

Groovy-オプション

Groovy-数字

例

数値メソッド

Groovy-ストリング

文字列のインデックス付け

基本的な文字列操作

文字列メソッド

グルーヴィー-範囲

Groovy-リスト

Groovy-マップ

Groovy-日付と時刻

日付（）

構文

例

日付（長いミリ秒）

構文

例

Groovy-正規表現

Groovy-例外処理

例外をキャッチする

複数のキャッチブロック

最後にブロック

public String getMessage（）

public Throwable getCause（）

public String toString（）

public void printStackTrace（）

public StackTraceElement [] getStackTrace（）