Groovy-퀵 가이드

Groovy는 Java 플랫폼을 기반으로하는 객체 지향 언어입니다. Groovy 1.0은 2007 년 1 월 2 일에 출시되었으며 Groovy 2.4는 현재 주요 릴리스입니다. Groovy는 Apache License v 2.0을 통해 배포됩니다.

Groovy의 특징

Groovy에는 다음과 같은 기능이 있습니다.

• 정적 및 동적 타이핑을 모두 지원합니다.
• 연산자 오버로딩 지원.
• 목록 및 연관 배열에 대한 기본 구문.
• 정규식에 대한 기본 지원.
• XML 및 HTML과 같은 다양한 마크 업 언어에 대한 기본 지원.
• Groovy는 Java와 Groovy의 구문이 매우 유사하기 때문에 Java 개발자에게는 간단합니다.
• 기존 Java 라이브러리를 사용할 수 있습니다.
• Groovy는 java.lang.Object를 확장합니다.

Groovy의 공식 웹 사이트는 http://www.groovy-lang.org/

Groovy 환경 설정을 얻는 방법에는 여러 가지가 있습니다.

Binary download and installation− www.groovy-lang.org/download.html 링크로 이동 하여 Windows Installer 섹션을 가져옵니다. Groovy 설치 프로그램의 다운로드를 시작하려면이 옵션을 클릭하십시오.

설치 프로그램을 시작하면 아래 단계에 따라 설치를 완료하십시오.

Step 1 − 언어 설치 프로그램을 선택합니다.

Step 2 − 다음 화면에서 다음 버튼을 클릭합니다.

Step 3 − '동의 함'버튼을 클릭합니다.

Step 4 − 기본 구성 요소를 수락하고 다음 버튼을 클릭합니다.

Step 5 − 적절한 대상 폴더를 선택하고 다음 버튼을 클릭합니다.

Step 6 − 설치 버튼을 클릭하면 설치가 시작됩니다.

Step 7 − 설치가 완료되면 다음 버튼을 클릭하여 구성을 시작하십시오.

Step 8 − 기본 옵션을 선택하고 다음 버튼을 클릭합니다.

Step 9 − 기본 파일 연결을 수락하고 다음 버튼을 클릭합니다.

Step 10 − 설치를 완료하려면 마침 버튼을 클릭하십시오.

위의 단계를 따르고 나면 Groovy를위한 완전한 통합 개발 환경 없이도 Groovy 언어의 다양한 측면을 테스트하는 데 도움이되는 Groovy 설치의 일부인 Groovy 셸을 시작할 수 있습니다. 이는 명령 프롬프트에서 groovysh 명령을 실행하여 수행 할 수 있습니다.

maven 또는 gradle 빌드의 일부로 그루비 바이너리를 포함하려면 다음 줄을 추가 할 수 있습니다.

Gradle

'org.codehaus.groovy:groovy:2.4.5'

메이븐

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

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 문은 코드에서 사용할 수있는 다른 라이브러리의 기능을 가져 오는 데 사용할 수 있습니다. 이것은import 예어.

다음 예제는 HTML 또는 XML 마크 업을 만드는 데 가장 많이 사용되는 클래스 중 하나 인 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”);

위의 코드 줄에는 두 개의 토큰이 있습니다. 첫 번째는 키워드 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에 정의 된 키워드를 나열합니다.

같이	주장하다	단절	케이스
잡기	수업	const	계속하다
데프	기본	하다	그밖에
열거 형	연장하다	그릇된	드디어
...에 대한	이동	만약	구현
수입	에	대신에	상호 작용
새로운	손잡이	꾸러미	반환
감독자	스위치	이	던지다
던지다	특성	진실	시험
동안

공백

공백은 공백, 탭, 개행 문자 및 주석을 설명하기 위해 Java 및 Groovy와 같은 프로그래밍 언어에서 사용되는 용어입니다. 공백은 명령문의 한 부분을 다른 부분과 분리하고 컴파일러가 명령문의 한 요소를 식별 할 수 있도록합니다.

예를 들어 다음 코드 예제에서는 키워드 사이에 공백이 있습니다. def그리고 변수 x. 이것은 컴파일러가def 사용해야하는 키워드이고 x는 정의해야하는 변수 이름이어야합니다.

def x = 5;

리터럴

리터럴은 groovy에서 고정 값을 나타내는 표기법입니다. 그루비 언어에는 정수, 부동 소수점 숫자, 문자 및 문자열에 대한 표기법이 있습니다. 다음은 Groovy 프로그래밍 언어의 리터럴 예제입니다.

12 
1.45 
‘a’ 
“aa”

모든 프로그래밍 언어에서 다양한 유형의 정보를 저장하려면 다양한 변수를 사용해야합니다. 변수는 값을 저장하기 위해 예약 된 메모리 위치 일뿐입니다. 이것은 변수를 만들 때 변수와 관련된 값을 저장하기 위해 메모리에 약간의 공간을 예약한다는 것을 의미합니다.

문자열, 문자, 와이드 문자, 정수, 부동 소수점, 부울 등과 같은 다양한 데이터 유형의 정보를 저장하고 싶을 수 있습니다. 운영 체제는 변수의 데이터 유형에 따라 메모리를 할당하고 예약 된 파일에 저장할 수있는 항목을 결정합니다. 기억.

내장 데이터 유형

Groovy는 다양한 기본 제공 데이터 유형을 제공합니다. 다음은 Groovy에 정의 된 데이터 유형의 목록입니다-

• byte− 바이트 값을 나타내는 데 사용됩니다. 예는 2입니다.

• short− 짧은 숫자를 나타내는 데 사용됩니다. 예는 10입니다.

• int− 정수를 나타내는 데 사용됩니다. 예는 1234입니다.

• long− 이것은 긴 숫자를 나타내는 데 사용됩니다. 예를 들면 10000090입니다.

• float− 32 비트 부동 소수점 수를 나타내는 데 사용됩니다. 예는 12.34입니다.

• double− 때때로 필요할 수있는 더 긴 십진수 표현 인 64 비트 부동 소수점 수를 나타내는 데 사용됩니다. 예는 12.3456565입니다.

• char− 이것은 단일 문자 리터럴을 정의합니다. 예는 'a'입니다.

• Boolean − 이것은 참 또는 거짓이 될 수있는 부울 값을 나타냅니다.

• String − 이들은 다음에서 표현되는 텍스트 리터럴입니다. the form캐릭터 체인의. 예 :“Hello World”.

바운드 값

다음 표는 숫자 및 10 진수 리터럴에 허용되는 최대 값을 보여줍니다.

바이트	-128에서 127
짧은	-32,768에서 32,767
int	-2,147,483,648에서 2,147,483,647
긴	-9,223,372,036,854,775,808 ~ +9,223,372,036,854,775,807
흙손	1.40129846432481707e-45 ~ 3.40282346638528860e + 38
더블	4.94065645841246544e-324d에서 1.79769313486231570e + 308d로

클래스 숫자

유형 기본 유형 외에도 다음 객체 유형 (래퍼 유형이라고도 함)이 허용됩니다.

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

또한 임의 정밀도 산술을 지원하기 위해 다음 클래스를 사용할 수 있습니다.

이름	기술	예
java.math.BigInteger	불변의 임의 정밀도 부호있는 정수	30g
java.math.BigDecimal	불변의 임의 정밀도 부호있는 십진수	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); 
   } 
}

위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

5 
100 
10.56 
1.05E41 
30 
3.5

Groovy의 변수는 두 가지 방법으로 정의 할 수 있습니다. native syntax 데이터 유형 또는 다음은 by using the def keyword. 변수 정의의 경우 형식 이름을 명시 적으로 제공하거나 대체 할 때 "def"를 사용해야합니다. 이것은 Groovy 파서에 필요합니다.

이전 장에서 설명한대로 Groovy에는 다음과 같은 기본 유형의 변수가 있습니다.

• byte− 바이트 값을 나타내는 데 사용됩니다. 예는 2입니다.

• short− 짧은 숫자를 나타내는 데 사용됩니다. 예는 10입니다.

• int− 정수를 나타내는 데 사용됩니다. 예는 1234입니다.

• long− 이것은 긴 숫자를 나타내는 데 사용됩니다. 예를 들면 10000090입니다.

• float− 32 비트 부동 소수점 수를 나타내는 데 사용됩니다. 예는 12.34입니다.

• double− 때때로 필요할 수있는 더 긴 십진수 표현 인 64 비트 부동 소수점 수를 나타내는 데 사용됩니다. 예는 12.3456565입니다.

• char− 이것은 단일 문자 리터럴을 정의합니다. 예는 'a'입니다.

• Boolean − 이것은 참 또는 거짓이 될 수있는 부울 값을 나타냅니다.

• String − 이들은 다음에서 표현되는 텍스트 리터럴입니다. the form캐릭터 체인의. 예 :“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

이름 지정 변수

변수 이름은 문자, 숫자 및 밑줄 문자로 구성 될 수 있습니다. 문자 또는 밑줄로 시작해야합니다. Java와 마찬가지로 Groovy는 대소 문자를 구분하는 프로그래밍 언어이기 때문에 대문자와 소문자는 구별됩니다.

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 대소 문자 구분으로 인해 두 개의 다른 변수이며 세 번째 경우 _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에서 사용할 수있는 산술 연산자입니다-

보기 예

운영자	기술	예
+	두 개의 피연산자 추가	1 + 2는 3을 줄 것입니다
−	첫 번째에서 두 번째 피연산자를 뺍니다.	2 − 1은 1을 제공합니다.
*	두 피연산자의 곱셈	2 * 2는 4를 줄 것입니다
/	분모로 분자 나누기	3/2는 1.5를 줄 것입니다.
%	계수 연산자 및 정수 / 부동 소수점 분할 후의 나머지	3 % 2는 1을 줄 것입니다
++	피연산자의 값을 1 씩 증가시키는 데 사용되는 증분 연산자	int x = 5; x ++; x는 6을 줄 것입니다
-	피연산자의 값을 1 씩 줄이는 데 사용되는 증분 연산자	int x = 5; 엑스--; x는 4를 줄 것입니다

관계 연산자

관계 연산자를 사용하면 개체를 비교할 수 있습니다. 다음은 Groovy에서 사용할 수있는 관계 연산자입니다-

보기 예

운영자	기술	예
==	두 개체 간의 동등성을 테스트합니다.	2 == 2는 사실을 제공합니다
! =	두 개체의 차이를 테스트합니다.	3! = 2는 사실을 줄 것입니다
<	왼쪽 개체가 오른쪽 피연산자보다 작은 지 확인합니다.	2 <3은 사실입니다
<=	왼쪽 개체가 오른쪽 피연산자보다 작거나 같은지 확인합니다.	2 <= 3은 사실입니다
>	왼쪽 개체가 오른쪽 피연산자보다 큰지 확인합니다.	3> 2는 사실입니다
> =	왼쪽 개체가 오른쪽 피연산자보다 크거나 같은지 확인합니다.	3> = 2는 true를 제공합니다.

논리 연산자

논리 연산자는 부울 표현식을 평가하는 데 사용됩니다. 다음은 Groovy에서 사용할 수있는 논리 연산자입니다-

보기 예

운영자	기술	예
&&	이것은 논리 "and"연산자입니다.	true && true는 true를 제공합니다.
||	이것은 논리 "or"연산자입니다.	맞아 || 사실은 사실을 줄 것이다
!	이것은 논리적 "아님"연산자입니다.	! false는 true를 제공합니다.

비트 연산자

Groovy는 4 개의 비트 연산자를 제공합니다. 다음은 Groovy에서 사용할 수있는 비트 연산자입니다-

보기 예

Sr. 아니요	연산자 및 설명
1	& 이것은 비트 "and"연산자입니다.
2	| 이것은 비트 "or"연산자입니다.
삼	^ 이것은 비트 "xor"또는 배타적 또는 연산자입니다.
4	~ 이것은 비트 부정 연산자입니다.

다음은 이러한 연산자를 보여주는 진리표입니다.

피	큐	p & q	p | 큐	피 ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

할당 연산자

Groovy 언어는 할당 연산자도 제공합니다. 다음은 Groovy에서 사용할 수있는 할당 연산자입니다-

보기 예

운영자	기술	예
+ =	이렇게하면 왼쪽 피연산자에 오른쪽 피연산자가 추가되고 결과가 왼쪽 피연산자에 할당됩니다.	정의 A = 5 A + = 3 출력은 8입니다.
-=	이렇게하면 왼쪽 피연산자에서 오른쪽 피연산자를 빼고 결과를 왼쪽 피연산자에 할당합니다.	정의 A = 5 A- = 3 출력은 2입니다.
* =	이것은 오른쪽 피연산자와 왼쪽 피연산자를 곱하고 결과를 왼쪽 피연산자에 할당합니다.	정의 A = 5 A * = 3 출력은 15입니다.
/ =	왼쪽 피연산자를 오른쪽 피연산자로 나누고 결과를 왼쪽 피연산자에 할당합니다.	정의 A = 6 A / = 3 출력은 2입니다.
% =	이것은 두 개의 피연산자를 사용하여 모듈러스를 취하고 결과를 왼쪽 피연산자에 할당합니다.	정의 A = 5 A % = 3 출력은 2입니다.

범위 연산자

Groovy는 범위 개념을 지원하고 .. 표기법의 도움으로 범위 연산자 표기법을 제공합니다. 범위 연산자의 간단한 예가 아래에 나와 있습니다.

def range = 0..5

이것은 단지 하한이 0이고 상한이 5 인 범위라는 지역 변수에 저장되는 단순한 정수 범위를 정의합니다.

다음 코드 스 니펫은 다양한 연산자를 사용하는 방법을 보여줍니다.

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

위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

로부터 println 문을 열면 범위 문에 정의 된 숫자의 전체 범위가 표시되는 것을 볼 수 있습니다.

get 문은 인덱스 값을 매개 변수로 사용하는 정의 된 범위에서 개체를 가져 오는 데 사용됩니다.

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

연산자 우선 순위

다음 표는 우선 순위에 따라 모든 그루비 연산자를 나열합니다.

Sr. 아니요	연산자 및 이름
1	++ -- + - 사전 증가 / 감소, 단항 더하기, 단항 빼기
2	* / % 곱하기, div, 모듈로
삼	+ - 더하기, 빼기
4	== != <=> 같음, 같지 않음, 비교 대상
5	& 이진 / 비트 및
6	^ 이진 / 비트 xor
7	| 이진 / 비트 또는
8	&& 논리적이고
9	|| 논리적 또는
10	= **= *= /= %= += -= <<= >>= >>>= &= ^= |= 다양한 할당 연산자

지금까지 우리는 순차적 인 방식으로 차례로 실행되는 명령문을 보았습니다. 또한 프로그램 로직에서 제어 흐름을 변경하기위한 명령문이 Groovy에 제공됩니다. 그런 다음 자세히 살펴볼 제어문의 흐름으로 분류됩니다.

S. 아니.	진술 및 설명
1	While 문 while 문은 먼저 조건식 (부울 값)을 평가하여 실행되며 결과가 참이면 while 루프의 문이 실행됩니다.
2	for 문 for 문은 값 집합을 반복하는 데 사용됩니다.
삼	for-in 문 for-in 문은 값 집합을 반복하는 데 사용됩니다.

루프 제어문

S. 아니.	진술 및 설명
1	Break 문 break 문은 루프 및 switch 문 내부의 제어 흐름을 변경하는 데 사용됩니다.
2	계속 진술 continue 문은 break 문을 보완합니다. 사용은 while 및 for 루프로 제한됩니다.

의사 결정 구조는 프로그래머가 프로그램이 평가하거나 테스트 할 하나 이상의 조건을 지정하고 조건이 다음과 같은 경우 실행될 명령문을 지정해야합니다. true및 선택적으로 조건이 다음과 같은 것으로 결정되는 경우 실행될 다른 명령문 false.

Sr. 아니.	진술 및 설명
1	if 문 이 명령문의 일반적인 작동은 먼저 조건이 if 명령문에서 평가된다는 것입니다. 조건이 참이면 명령문을 실행합니다.
2	if / else 문 이 명령문의 일반적인 작동은 먼저 조건이 if 명령문에서 평가된다는 것입니다. 조건이 참이면 그 후 명령문을 실행하고 else 조건 전에 중지하고 루프를 종료합니다. 조건이 거짓이면 else 문 블록의 문을 실행 한 다음 루프를 종료합니다.
삼	중첩 된 If 문 때로는 여러 if 문이 서로 내부에 포함되어야하는 요구 사항이 있습니다.
4	Switch 문 때로는 중첩 된 if-else 문이 매우 일반적이고 자주 사용되어 switch 문이라고하는 더 쉬운 문이 설계되었습니다.
5	중첩 된 스위치 문 중첩 된 switch 문 집합을 가질 수도 있습니다.

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은 일부 텍스트를 콘솔에 출력하는 데 사용되는 두 개의 println 문으로 구성된 간단한 메서드입니다. 정적 메인 메서드에서는 DisplayName 메서드 만 호출합니다. 위 방법의 출력은 다음과 같습니다.

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

방법 매개 변수

메서드는 하나 이상의 매개 변수 값에 의해 동작이 결정되는 경우 더 일반적으로 유용합니다. 메소드 매개 변수를 사용하여 호출 된 메소드로 값을 전송할 수 있습니다. 매개 변수 이름은 서로 달라야합니다.

아래 표시된 것과 같은 매개 변수가있는 가장 간단한 유형의 메소드-

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

이 예에서는 2 개의 매개 변수가있는 합계 방법을 생성합니다. a 과 b. 두 매개 변수는 모두 유형입니다.int. 그런 다음 main 메서드에서 sum 메서드를 호출하고 값을 변수에 전달합니다.a 과 b.

위 방법의 출력은 값 15입니다.

기본 매개 변수

Groovy에는 메서드 내 매개 변수에 대한 기본값을 지정하는 규정도 있습니다. 매개 변수의 메소드에 값이 전달되지 않으면 기본값이 사용됩니다. 기본값이 아닌 매개 변수와 기본 매개 변수를 모두 사용하는 경우 매개 변수 목록의 끝에 기본 매개 변수를 정의해야합니다.

다음은 매개 변수가있는 간단한 방법의 예입니다.

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

두 개의 숫자를 더하기 위해 이전에 보았던 동일한 예제를 살펴보고 하나의 기본값과 다른 기본값이 아닌 매개 변수를 갖는 메소드를 생성 해 보겠습니다.

class Example { 
   static void sum(int a,int b = 5) { 
      int c = a+b; 
      println(c); 
   } 
	
   static void main(String[] args) {
      sum(6); 
   } 
}

이 예에서는 두 개의 매개 변수가있는 sum 메서드를 생성합니다. a 과 b. 두 매개 변수는 모두 int 유형입니다. 이 예와 이전 예의 차이점은이 경우에 대한 기본값을 지정한다는 것입니다.b 그래서 우리가 우리의 메인 메소드에서 sum 메소드를 호출 할 때, 우리는 단지 하나의 값인 6을 전달하는 옵션이 있고 이것은 매개 변수에 할당 될 것입니다. a 내 sum 방법.

위 방법의 출력은 값 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 개의 값을 전달합니다. 두 번째 값인 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 문을 사용하고 있습니다. 이제 메서드의 값을 기본 메서드에서 사용할 수 있으므로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 클래스 내에서 액세스 할 수있는 전역 속성입니다. 변수에 액세스하려고하면lx 밖에서 getX() 함수를 사용하면 오류가 발생합니다.

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 작업을 위해 아래 나열된 일반 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"라는 단어가 표시됩니다.

파일 크기 얻기

파일 크기를 얻으려면 파일 클래스의 길이 속성을 사용하여 파일 크기를 얻을 수 있습니다. 다음 예는이를 수행하는 방법을 보여줍니다.

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

위의 코드는 파일의 크기를 바이트 단위로 표시합니다.

파일이 디렉토리인지 테스트

경로가 파일인지 디렉토리인지 확인하려면 다음을 사용할 수 있습니다. isFile 과 isDirectoryFile 클래스의 옵션. 다음 예는이를 수행하는 방법을 보여줍니다.

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

위의 코드는 다음 출력을 보여줍니다.

File? false 
Directory? True

디렉토리 생성

새 디렉토리를 만들려면 다음을 사용할 수 있습니다. mkdirFile 클래스의 기능. 다음 예는이를 수행하는 방법을 보여줍니다.

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는 드라이브에있는 드라이브와 파일을 나열하는 기능도 제공합니다.

다음 예는 다음을 사용하여 시스템의 드라이브를 표시하는 방법을 보여줍니다. listRoots File 클래스의 기능.

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

컴퓨터에서 사용 가능한 드라이브에 따라 출력이 달라질 수 있습니다. 표준 기계에서 출력은 다음과 유사합니다.

C:\ 
D:\

다음 예제는 다음을 사용하여 특정 디렉토리의 파일을 나열하는 방법을 보여줍니다. eachFile File 클래스의 기능.

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

출력은 E : \ Temp 디렉토리에있는 모든 파일을 표시합니다.

디렉토리와 그 하위 디렉토리에있는 모든 파일을 반복적으로 표시하려면 다음을 사용합니다. eachFileRecurseFile 클래스의 기능. 다음 예는이를 수행하는 방법을 보여줍니다.

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

출력은 E : \ Temp 디렉토리와 하위 디렉토리 (존재하는 경우)에있는 모든 파일을 표시합니다.

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에서 Numbers는 실제로 객체로 표현되며, 모두 Integer 클래스의 인스턴스입니다. 객체가 무언가를하게하려면 그 클래스에 선언 된 메소드 중 하나를 호출해야합니다.

Groovy는 정수 및 부동 소수점 숫자를 지원합니다.

• 정수는 분수를 포함하지 않는 값입니다.
• 부동 소수점 숫자는 소수를 포함하는 10 진수 값입니다.

Groovy의 숫자 예는 다음과 같습니다.

Integer x = 5; 
Float y = 1.25;

어디 x Integer 유형이고 y 플로트입니다.

그루비의 숫자가 객체로 정의되는 이유는 일반적으로 숫자에 대한 작업을 수행해야하는 요구 사항이 있기 때문입니다. 기본 유형보다 클래스를 제공하는 개념을 래퍼 클래스라고합니다.

기본적으로 다음 래퍼 클래스가 Groovy에서 제공됩니다.

래퍼 클래스의 객체는 각각의 기본 데이터 유형을 포함하거나 래핑합니다. 기본 데이터 유형을 객체로 변환하는 프로세스를 boxing이라고하며 컴파일러에서 처리합니다. 객체를 해당 기본 유형으로 다시 변환하는 프로세스를 unboxing이라고합니다.

예

다음은 권투 및 개봉의 예입니다-

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를 더하면 값이 Integer 유형에서 박스 해제됩니다.

번호 방법

Groovy의 숫자는 클래스로 표시되므로 다음은 사용 가능한 메소드 목록입니다.

S. 아니.	방법 및 설명
1	xxxValue () 이 메소드는 Number를 매개 변수로 취하고 호출 된 메소드를 기반으로 기본 유형을 리턴합니다.
2	compareTo () compareTo 메서드는 한 숫자를 다른 숫자와 비교하는 것입니다. 숫자 값을 비교하려는 경우 유용합니다.
삼	같음 () 메서드는 메서드를 호출하는 Number 개체가 인수로 전달 된 개체와 같은지 여부를 확인합니다.
4	valueOf () valueOf 메서드는 전달 된 인수의 값을 포함하는 관련 숫자 개체를 반환합니다.
5	toString () 이 메서드는 숫자 개체의 값을 나타내는 문자열 개체를 가져 오는 데 사용됩니다.
6	parseInt () 이 메소드는 특정 문자열의 기본 데이터 유형을 가져 오는 데 사용됩니다. parseXxx ()는 정적 메서드이며 하나 또는 두 개의 인수를 가질 수 있습니다.
7	abs () 이 메서드는 인수의 절대 값을 제공합니다. 인수는 int, float, long, double, short, byte가 될 수 있습니다.
8	올림() ceil 메소드는 인수보다 크거나 같은 가장 작은 정수를 제공합니다.
9	바닥() 메소드 floor는 인수보다 작거나 같은 가장 큰 정수를 제공합니다.
10	rint () rint 메서드는 인수 값에서 가장 가까운 정수를 반환합니다.
11	일주() round 메소드는 메소드 리턴 유형에서 제공하는 가장 가까운 long 또는 int를 리턴합니다.
12	min () 이 메서드는 두 인수 중 더 작은 인수를 제공합니다. 인수는 int, float, long, double 일 수 있습니다.
13	max () 이 메서드는 최대 두 개의 인수를 제공합니다. 인수는 int, float, long, double 일 수 있습니다.
14	exp () 이 메서드는 자연 로그 e의 밑을 인수의 거듭 제곱으로 반환합니다.
15	로그() 이 메서드는 인수의 자연 로그를 반환합니다.
16	펑 () 메서드는 두 번째 인수의 거듭 제곱으로 올린 첫 번째 인수의 값을 반환합니다.
17	sqrt () 이 메서드는 인수의 제곱근을 반환합니다.
18	죄() 이 메서드는 지정된 double 값의 사인을 반환합니다.
19	코사인() 이 메서드는 지정된 double 값의 코사인을 반환합니다.
20	탠 껍질() 이 메서드는 지정된 double 값의 탄젠트를 반환합니다.
21	asin () 이 메서드는 지정된 double 값의 아크 사인을 반환합니다.
22	acos () 이 메서드는 지정된 double 값의 아크 코사인을 반환합니다.
23	atan () 이 메서드는 지정된 double 값의 아크 탄젠트를 반환합니다.
24	atan2 () 이 메서드는 직사각형 좌표 (x, y)를 극좌표 (r, theta)로 변환하고 theta를 반환합니다.
25	toDegrees () 이 메서드는 인수 값을 각도로 변환합니다.
26	라디안 () 이 메서드는 인수 값을 라디안으로 변환합니다.
27	랜덤 () 이 방법은 0.0에서 1.0 사이의 난수를 생성하는 데 사용됩니다. 범위는 0.0 = <Math.random <1.0입니다. 산술을 사용하여 다른 범위를 얻을 수 있습니다.

문자열 리터럴은 문자열 텍스트를 따옴표로 묶어 Groovy에서 구성됩니다.

Groovy는 문자열 리터럴을 표시하는 다양한 방법을 제공합니다. Groovy의 문자열은 작은 따옴표 ( '), 큰 따옴표 ( ") 또는 삼중 따옴표 (" "")로 묶을 수 있습니다. 또한 삼중 따옴표로 묶인 Groovy String은 여러 줄에 걸쳐있을 수 있습니다.

다음은 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의 문자열은 순서가 지정된 문자 시퀀스입니다. 문자열의 개별 문자는 해당 위치로 액세스 할 수 있습니다. 이것은 인덱스 위치로 제공됩니다.

문자열 인덱스는 0에서 시작하여 문자열 길이보다 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. 아니.	문자열 작업 및 설명
1	두 문자열의 연결 문자열 연결은 간단한 '+'연산자로 수행 할 수 있습니다.
2	문자열 반복 문자열 반복은 간단한 '*'연산자로 수행 할 수 있습니다.
삼	문자열 길이 문자열의 length () 메서드에 의해 결정되는 문자열의 길이입니다.

문자열 방법

다음은 String 클래스에서 지원하는 메서드 목록입니다.

S. 아니.	방법 및 설명
1	센터() 왼쪽과 오른쪽이 공백 문자로 채워진 수신자로 구성된 numberOfChars 길이의 새 문자열을 리턴합니다.
2	compareToIgnoreCase () 대소 문자 차이를 무시하고 사전 식으로 두 문자열을 비교합니다.
삼	concat () 지정된 String을이 String의 끝에 연결합니다.
4	eachMatch () 주어진 문자열의 각 정규식 그룹 (다음 섹션 참조)과 일치하는 하위 문자열을 처리합니다.
5	로 끝나다() 이 문자열이 지정된 접미사로 끝나는 지 여부를 테스트합니다.
6	equalsIgnoreCase () 대소 문자 고려 사항을 무시하고이 문자열을 다른 문자열과 비교합니다.
7	getAt () 인덱스 위치에 문자열 값을 반환합니다.
8	indexOf () 이 문자열 내에서 지정된 부분 문자열의 첫 번째 발생 인덱스를 반환합니다.
9	성냥() 문자열이 주어진 정규식과 일치하는지 여부를 출력합니다.
10	마이너스() 문자열의 값 부분을 제거합니다.
11	다음() 이 메서드는 String 클래스에 대한 ++ 연산자에 의해 호출됩니다. 주어진 문자열의 마지막 문자를 증가시킵니다.
12	padLeft () 왼쪽에 추가 된 공백으로 문자열을 채 웁니다.
13	padRight () 오른쪽에 추가 된 공백으로 문자열을 채 웁니다.
14	을 더한() 문자열을 추가합니다.
15	이전() 이 메서드는 CharSequence의-연산자에 의해 호출됩니다.
16	모두 다 바꿔() 캡처 된 그룹의 모든 발생을 해당 텍스트의 클로저 결과로 바꿉니다.
17	역전() 이 String의 반대 인 새로운 String을 생성합니다.
18	스플릿() 이 문자열을 주어진 정규식과 일치하는 부분으로 분할합니다.
19	subString () 이 문자열의 하위 문자열 인 새 문자열을 리턴합니다.
20	toUpperCase () 이 String의 모든 문자를 대문자로 변환합니다.
21	toLowerCase () 이 String의 모든 문자를 소문자로 변환합니다.

범위는 일련의 값을 지정하는 축약 형입니다. 범위는 시퀀스의 첫 번째 및 마지막 값으로 표시되며 범위는 포함 또는 제외 될 수 있습니다. 포함 범위에는 처음부터 마지막까지의 모든 값이 포함되는 반면, 제외 범위에는 마지막을 제외한 모든 값이 포함됩니다. 다음은 범위 리터럴의 몇 가지 예입니다.

• 1..10-포괄적 범위의 예
• 1 .. <10-독점 범위의 예
• 'a'.. 'x'– 범위는 문자로 구성 될 수도 있습니다.
• 10..1 – 범위는 내림차순 일 수도 있습니다.
• 'x'.. 'a'– 범위는 문자로도 구성 될 수 있으며 내림차순입니다.

다음은 범위에 사용할 수있는 다양한 방법입니다.

Sr. 아니.	방법 및 설명
1	contains () 범위에 특정 값이 포함되어 있는지 확인
2	가져 오기() 이 Range의 지정된 위치에있는 요소를 반환합니다.
삼	getFrom () 이 범위의 더 낮은 값을 가져옵니다.
4	getTo () 이 범위의 상한값을 가져옵니다.
5	isReverse () 역순으로 반복되는 범위입니까?
6	크기() 이 Range의 요소 수를 반환합니다.
7	subList () 지정된 fromIndex (포함)와 toIndex (배타적) 사이에서이 Range 부분의 뷰를 반환합니다.

목록은 데이터 항목 모음을 저장하는 데 사용되는 구조입니다. Groovy에서 List는 일련의 객체 참조를 보유합니다. 목록의 개체 참조는 시퀀스에서 위치를 차지하며 정수 인덱스로 구분됩니다. 목록 리터럴은 쉼표로 구분되고 대괄호로 묶인 일련의 개체로 표시됩니다.

목록의 데이터를 처리하려면 개별 요소에 액세스 할 수 있어야합니다. Groovy 목록은 인덱싱 연산자 []를 사용하여 인덱싱됩니다. 목록 인덱스는 첫 번째 요소를 나타내는 0에서 시작합니다.

다음은 목록의 몇 가지 예입니다-

• [11, 12, 13, 14] – 정수 값 목록
• [ 'Angular', 'Groovy', 'Java'] – 문자열 목록
• [1, 2, [3, 4], 5] – 중첩 된 목록
• [ 'Groovy', 21, 2.11] – 이기종 객체 참조 목록
• [] – 빈 목록

이 장에서는 Groovy에서 사용할 수있는 목록 메서드에 대해 설명합니다.

Sr. 아니.	방법 및 설명
1	더하다() 이 목록의 끝에 새 값을 추가하십시오.
2	contains () 이 List에 지정된 값이 포함되어 있으면 true를 반환합니다.
삼	가져 오기() 이 List의 지정된 위치에있는 요소를 반환합니다.
4	비었다() 이 목록에 요소가 없으면 true를 반환합니다.
5	마이너스() 컬렉션에 지정되지 않은 원본 요소로 구성된 새 List를 만듭니다.
6	을 더한() 컬렉션에 지정된 요소와 함께 원본 요소로 구성된 새 목록을 만듭니다.
7	팝() 이 목록에서 마지막 항목을 제거합니다.
8	없애다() 이 List의 지정된 위치에서 요소를 제거합니다.
9	역전() 원래 목록의 요소를 반대로하는 새 목록 만들기
10	크기() 이 List의 요소 수를 가져옵니다.
11	종류() 원본 목록의 정렬 된 복사본을 반환합니다.

맵 (연관 배열, 사전, 테이블 및 해시라고도 함)은 정렬되지 않은 개체 참조 모음입니다. Map 컬렉션의 요소는 키 값으로 액세스됩니다. Map에서 사용되는 키는 모든 클래스가 될 수 있습니다. Map 컬렉션에 삽입 할 때 키와 값이라는 두 가지 값이 필요합니다.

다음은지도의 몇 가지 예입니다.

• [ 'TopicName': 'Lists', 'TopicName': 'Maps'] – TopicName을 키로하는 키 값 쌍의 모음과 각각의 값입니다.

• [:] – 빈지도.

이 장에서는 Groovy에서 사용할 수있는 맵 방법에 대해 설명합니다.

Sr. 아니.	방법 및 설명
1	containsKey () 이지도에이 키가 포함되어 있습니까?
2	가져 오기() 이 맵에서 키를 찾고 해당 값을 반환합니다. 이 맵에 키에 대한 항목이 없으면 null을 반환합니다.
삼	keySet () 이 맵에서 키 세트를 얻습니다.
4	놓다() 지정된 값을이 Map의 지정된 키와 연결합니다. 이 맵에 이전에이 키에 대한 매핑이 포함 된 경우 이전 값이 지정된 값으로 대체됩니다.
5	크기() 이 맵의 키-값 매핑 수를 반환합니다.
6	값 () 이 Map에 포함 된 값의 컬렉션 뷰를 반환합니다.

Date 클래스는 밀리 초 정밀도로 특정 순간을 나타냅니다. Date 클래스에는 아래와 같이 두 개의 생성자가 있습니다.

데이트()

통사론

public Date()

Parameters − 없음.

Return Value

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)

Parameters

Millisec – 표준 기준 시간 이후 지정할 밀리 세 콘드 수입니다.

Return Value − 할당 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. 아니.	방법 및 설명
1	후() 이 날짜가 지정된 날짜 이후인지 테스트합니다.
2	같음 () 두 날짜가 같은지 비교합니다. 결과는 인수가 null이 아니고이 객체와 동일한 시점 (밀리 초)을 나타내는 Date 객체 인 경우에만 참입니다.
삼	compareTo () 주문을 위해 두 개의 날짜를 비교합니다.
4	toString () 이 Date 객체를 String으로 변환합니다.
5	전에() 이 날짜가 지정된 날짜 이전인지 테스트합니다.
6	getTime () 이 Date 객체가 나타내는 1970 년 1 월 1 일 00:00:00 GMT 이후의 밀리 초 수를 반환합니다.
7	setTime () 1970 년 1 월 1 일 00:00:00 GMT 이후의 시간 밀리 초인 시점을 나타내도록이 Date 개체를 설정합니다.

정규식은 텍스트에서 하위 문자열을 찾는 데 사용되는 패턴입니다. Groovy는 기본적으로 ~”regex”표현식을 사용하는 정규 표현식을 지원합니다. 따옴표로 묶인 텍스트는 비교를위한 표현식을 나타냅니다.

예를 들어 아래와 같이 정규 표현식 객체를 만들 수 있습니다.

def regex = ~'Groovy'

Groovy 연산자 = ~가 조건 자 (부울을 반환하는 표현식)로 나타날 때 if 과 while명령문 (8 장 참조)에서 왼쪽의 문자열 피연산자는 오른쪽의 정규식 피연산자와 일치합니다. 따라서 다음 각 항목은 참된 가치를 제공합니다.

정규식을 정의 할 때 다음 특수 문자를 사용할 수 있습니다.

• 줄의 시작과 끝을 나타내는 데 사용되는 두 가지 특수 위치 문자가 있습니다. 캐럿 (∧)과 달러 기호 ($)입니다.

• 정규식은 수량자를 포함 할 수도 있습니다. 더하기 기호 (+)는 표현식의 이전 요소에 적용되는 한 번 이상을 나타냅니다. 별표 (*)는 0 개 이상의 발생을 나타내는 데 사용됩니다. 물음표 (?)는 0 또는 한 번을 나타냅니다.

• 메타 문자 {및}는 이전 문자의 특정 인스턴스 수를 일치시키는 데 사용됩니다.

• 정규식에서 마침표 기호 (.)는 모든 문자를 나타낼 수 있습니다. 이것은 와일드 카드 문자로 설명됩니다.

• 정규식에는 문자 클래스가 포함될 수 있습니다. 문자 집합은 [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'

응용 프로그램의 정상적인 흐름을 유지할 수 있도록 런타임 오류를 처리하려면 모든 프로그래밍 언어에서 예외 처리가 필요합니다.

예외는 일반적으로 응용 프로그램의 정상적인 흐름을 방해하므로 응용 프로그램에서 예외 처리를 사용해야하는 이유입니다.

예외는 크게 다음 범주로 분류됩니다.

• Checked Exception − RuntimeException 및 Error를 제외하고 Throwable 클래스를 확장하는 클래스는 검사 된 예외 (예 : IOException, SQLException 등)라고합니다. 검사 된 예외는 컴파일시 검사됩니다.

한 가지 고전적인 경우는 FileNotFoundException입니다. E 드라이브의 파일에서 읽는 다음 코드가 애플리케이션에 있다고 가정합니다.

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

파일 (file.txt)이 E 드라이브에 없으면 다음 예외가 발생합니다.

Caught : java.io.FileNotFoundException : E : \ file.txt (시스템이 지정된 파일을 찾을 수 없음).

java.io.FileNotFoundException : E : \ file.txt (시스템이 지정된 파일을 찾을 수 없음).

• Unchecked Exception − RuntimeException을 확장하는 클래스는 확인되지 않은 예외 (예 : ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException 등)로 알려져 있습니다. 확인되지 않은 예외는 런타임에 확인되는 것이 아니라 컴파일시 확인되지 않습니다.

한 가지 고전적인 경우는 배열 길이보다 큰 배열의 인덱스에 액세스하려고 할 때 발생하는 ArrayIndexOutOfBoundsException입니다. 다음은 이러한 종류의 실수에 대한 전형적인 예입니다.

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

위의 코드가 실행되면 다음 예외가 발생합니다.

포착 됨 : java.lang.ArrayIndexOutOfBoundsException : 5

java.lang.ArrayIndexOutOfBoundsException : 5

• Error − 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 블록을 가질 수 있습니다. 각 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 코드 블록은 예외 발생에 관계없이 항상 실행됩니다.

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. 
}

위의 코드를 수정하고 finally 코드 블록을 추가하겠습니다. 다음은 코드 조각입니다.

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에서 사용할 수있는 예외 방법입니다-

공용 문자열 getMessage ()

발생한 예외에 대한 자세한 메시지를 반환합니다. 이 메시지는 Throwable 생성자에서 초기화됩니다.

공개 Throwable getCause ()

Throwable 객체가 나타내는 예외의 원인을 반환합니다.

공용 문자열 toString ()

getMessage ()의 결과와 연결된 클래스 이름을 반환합니다.

public void printStackTrace ()

스택 추적과 함께 toString ()의 결과를 오류 출력 스트림 인 System.err에 인쇄합니다.

공용 StackTraceElement [] getStackTrace ()

스택 추적의 각 요소를 포함하는 배열을 반환합니다. 인덱스 0의 요소는 호출 스택의 맨 위를 나타내고 배열의 마지막 요소는 호출 스택의 맨 아래에있는 메서드를 나타냅니다.

공용 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에있는 클래스의 예입니다. 클래스 이름은 Student이며 두 개의 필드가 있습니다.StudentID 과 StudentName. 주요 기능에서 우리는이 클래스의 객체를 생성하고 값을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());
   }
}

위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

60

여러 개체 만들기

한 클래스의 여러 개체를 만들 수도 있습니다. 다음은이를 달성 할 수있는 방법의 예입니다. 여기에서는 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

계승

상속은 한 클래스가 다른 클래스의 속성 (메서드 및 필드)을 획득하는 프로세스로 정의 할 수 있습니다. 상속을 사용하면 정보를 계층 적 순서로 관리 할 수 ​​있습니다.

other의 속성을 상속하는 클래스를 하위 클래스 (파생 클래스, 자식 클래스)라고하고 속성이 상속 된 클래스를 수퍼 클래스 (기본 클래스, 부모 클래스)라고합니다.

확장

extends클래스의 속성을 상속하는 데 사용되는 키워드입니다. 다음은 extends 키워드 구문입니다. 다음 예에서 우리는 다음을 수행합니다.

• Person이라는 클래스를 만듭니다. 이 클래스에는 name이라는 인스턴스 멤버가 하나 있습니다.

• 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 클래스 내부에 내부 또는 중첩 클래스를 만듭니다.
• 내부 클래스에서는 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

추상 클래스

추상 클래스는 일반 개념을 나타내므로 인스턴스화 할 수 없으며 하위 클래스로 생성됩니다. 이들의 구성원에는 필드 / 속성 및 추상 또는 구체적인 방법이 포함됩니다. 추상 메서드에는 구현이 없으며 구체적인 하위 클래스로 구현해야합니다. 추상 클래스는 abstract 키워드로 선언해야합니다. 추상 메서드도 abstract 키워드로 선언해야합니다.

다음 예제에서 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. 인터페이스에서 protected 또는 private 메서드를 사용하는 것은 오류입니다.

다음은 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

제네릭은 클래스, 인터페이스 및 메소드를 정의 할 때 유형 (클래스 및 인터페이스)이 매개 변수가되도록합니다. 메서드 선언에 사용되는보다 친숙한 형식 매개 변수와 마찬가지로 형식 매개 변수는 다른 입력으로 동일한 코드를 재사용 할 수있는 방법을 제공합니다. 차이점은 형식 매개 변수에 대한 입력은 값이고 유형 매개 변수에 대한 입력은 유형이라는 것입니다.

컬렉션 용 일반

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 클래스의 객체를 선언 할 수 있지만 다른 유형의 객체를 선언 할 수 있습니다. 첫 번째는 Integer 유형이고 두 번째는 String 유형입니다.

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 Marks {
   void DisplayMarks() {
      println("Display Marks");
   } 
}

그런 다음 구현 키워드를 사용하여 인터페이스와 유사한 방식으로 특성을 구현할 수 있습니다.

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. 우리 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

클로저는 짧은 익명의 코드 블록입니다. 일반적으로 코드 몇 줄에 걸쳐 있습니다. 메서드는 코드 블록을 매개 변수로 사용할 수도 있습니다. 그들은 본질적으로 익명입니다.

다음은 간단한 클로저와 그 모양의 예입니다.

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

다음 그림은 이전 예를 반복하고 동일한 결과를 생성하지만 암시 적 단일 매개 변수를 사용할 수 있음을 보여줍니다. 여기 'it'은 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라는 정적 메서드를 정의하고 있습니다.

• 그런 다음 main 메서드에서 클로저를 정의하고 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}
   } 
}

위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

11 
12 
13 
14

지도에서 클로저 사용

다음 예제는지도에서 클로저를 사용하는 방법을 보여줍니다. 다음 예에서는 먼저 키 값 항목의 간단한 맵을 정의합니다. 그런 다음지도 컬렉션 유형은 .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. 아니.	방법 및 설명
1	찾기() find 메소드는 컬렉션에서 일부 기준과 일치하는 첫 번째 값을 찾습니다.
2	findAll () 수신 객체에서 폐쇄 조건과 일치하는 모든 값을 찾습니다.
삼	any () 및 every () 메서드 any는 컬렉션의 각 요소를 반복하여 부울 조건자가 하나 이상의 요소에 유효한지 확인합니다.
4	수집() collect 메소드는 컬렉션을 반복하여 클로저를 변환기로 사용하여 각 요소를 새 값으로 변환합니다.

주석은 프로그램 자체의 일부가 아닌 프로그램에 대한 데이터를 제공하는 메타 데이터의 한 형태입니다. 주석은 주석이 달린 코드의 작동에 직접적인 영향을주지 않습니다.

주석은 주로 다음과 같은 이유로 사용됩니다.

• Information for the compiler − 컴파일러는 주석을 사용하여 오류를 감지하거나 경고를 억제 할 수 있습니다.

• Compile-time and deployment-time processing − 소프트웨어 도구는 주석 정보를 처리하여 코드, XML 파일 등을 생성 할 수 있습니다.

• Runtime processing − 일부 주석은 런타임에 검사 할 수 있습니다.

Groovy에서 기본 주석은 다음과 같습니다.

@interface-at 기호 문자 (@)는 다음에 오는 것이 주석임을 컴파일러에 나타냅니다.

주석은 다음에서 멤버를 정의 할 수 있습니다. the form 본문이없는 메서드 및 선택적 기본값입니다.

주석은 다음 유형에 적용 할 수 있습니다.

문자열 유형

문자열에 대한 주석의 예는 다음과 같습니다.

@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는 클래스 값을 기반으로 작성됩니다. 그런 다음 주석은 숫자 변수의 값에 따라 결과 변수에 다른 메시지를 게시하는 두 가지 방법에 적용됩니다.

@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 {}

XML은 프로그래머가 운영 체제 및 / 또는 개발 언어에 관계없이 다른 응용 프로그램에서 읽을 수있는 응용 프로그램을 개발할 수 있도록하는 이식 가능한 오픈 소스 언어입니다. 이것은 애플리케이션간에 데이터를 교환하는 데 사용되는 가장 일반적인 언어 중 하나입니다.

XML이란 무엇입니까?

Extensible Markup Language XML은 HTML 또는 SGML과 매우 유사한 마크 업 언어입니다. 이것은 World Wide Web Consortium에서 권장하며 개방형 표준으로 제공됩니다. XML은 SQL 기반 백본 없이도 중소 량의 데이터를 추적하는 데 매우 유용합니다.

Groovy의 XML 지원

Groovy 언어는 또한 XML 언어에 대한 풍부한 지원을 제공합니다. 사용되는 가장 기본적인 두 가지 XML 클래스는 다음과 같습니다.

• XML Markup Builder− Groovy는 다양한 트리 구조 객체 표현을 만들기 위해 서브 클래 싱 할 수있는 트리 기반 마크 업 생성기 BuilderSupport를 지원합니다. 일반적으로 이러한 빌더는 XML 마크 업, HTML 마크 업을 나타내는 데 사용됩니다. Groovy의 마크 업 생성기는 의사 메서드에 대한 호출을 포착하여 트리 구조의 요소 또는 노드로 변환합니다. 이러한 의사 메소드에 대한 매개 변수는 노드의 속성으로 처리됩니다. 메서드 호출의 일부인 클로저는 결과 트리 노드에 대해 중첩 된 하위 콘텐츠로 간주됩니다.

• XML Parser− Groovy XmlParser 클래스는 XML 문서를 Node 인스턴스 트리로 파싱하기위한 간단한 모델을 사용합니다. 각 노드에는 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 문서의 다양한 요소를 생성 할 수 있습니다.

위의 XML 문서에서 하나의 블록, 즉 하나의 동영상 요소를 만드는 방법의 예를 살펴 보겠습니다.

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')− 이러한 의사 방법은 값이있는 태그를 생성하는이 방법으로 자식 태그를 생성합니다. 제목이라는 값을 지정하면 실제로 요소에 대한 속성을 만들어야 함을 나타냅니다.

• XML 문서의 나머지 요소를 만들기 위해 의사 메서드에 클로저가 제공됩니다.

• MarkupBuilder 클래스의 기본 생성자는 생성 된 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> 
</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 문서를 Node 인스턴스 트리로 구문 분석하기위한 간단한 모델을 사용합니다. 각 노드에는 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

위의 코드에 대해 유의해야 할 중요한 사항입니다.

• XML 문서를 구문 분석하는 데 사용할 수 있도록 XmlParser 클래스의 개체가 형성되고 있습니다.

• 파서에는 XML 파일의 위치가 제공됩니다.

• 각 영화 요소에 대해 클로저를 사용하여 각 하위 노드를 탐색하고 관련 정보를 표시합니다.

영화 요소 자체의 경우 @ 기호를 사용하여 영화 요소에 첨부 된 title 속성을 표시합니다.

JMX는 Java 가상 환경과 관련된 모든 애플리케이션을 모니터링하는 데 사용되는 사실상의 표준입니다. Groovy가 Java 바로 위에 위치한다는 점을 감안할 때 Groovy는 JMX에 대해 Java로 이미 수행 된 엄청난 양의 작업을 활용할 수 있습니다.

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을 검색하고, 웹 모듈을 확인하고, 각 웹 모듈에 대한 처리 시간을 추출합니다.

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 
}

이 장에서는 JSON 객체를 구문 분석하고 생성하기 위해 Groovy 언어를 사용하는 방법을 다룹니다.

JSON 함수

Sr. 아니요	기능 및 라이브러리
1	JsonSlurper JsonSlurper는 JSON 텍스트 또는 리더 콘텐츠를 Groovy 데이터로 구문 분석하는 클래스입니다. 맵, 목록 및 Integer, Double, Boolean 및 String과 같은 기본 유형과 같은 구조.
2	JsonOutput 이 메서드는 Groovy 개체를 JSON 문자열로 직렬화합니다.

JsonSlurper를 사용하여 데이터 구문 분석

JsonSlurper는 JSON 텍스트 또는 리더 콘텐츠를 맵, 목록 및 Integer, Double, Boolean 및 String과 같은 기본 유형과 같은 Groovy 데이터 구조로 구문 분석하는 클래스입니다.

통사론

def slurper = new JsonSlurper()

JSON slurper는 텍스트 또는 리더 콘텐츠를 목록 및지도의 데이터 구조로 구문 분석합니다.

JsonSlurper 클래스에는 파서 구현을위한 몇 가지 변형이 함께 제공됩니다. 때로는 특정 문자열을 구문 분석 할 때 다른 요구 사항이있을 수 있습니다. 웹 서버의 응답에서 반환 된 JSON을 읽어야하는 인스턴스를 살펴 보겠습니다. 이러한 경우 파서 JsonParserLax 변형을 사용하는 것이 좋습니다. 이 구문 분석에서는 따옴표 문자열 등을 사용하지 않고 JSON 텍스트의 주석을 허용합니다. 이러한 종류의 구문 분석기를 지정하려면 JsonSlurper의 객체를 정의 할 때 JsonParserType.LAX 구문 분석기 유형을 사용해야합니다.

아래에 주어진 예를 보겠습니다. 이 예제는 http 모듈을 사용하여 웹 서버에서 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 문자열을 구문 분석하는 동안 새 문자 배열 또는 문자열 인스턴스를 생성하지 않도록 가능한 한 열심히 시도합니다. 기본 원래 문자 배열에 대한 포인터 만 유지합니다. 또한 가능한 한 늦게 개체 생성을 연기합니다.

• 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)

Parameters − 매개 변수는 숫자, 부울, 문자, 문자열, 날짜,지도, 클로저 등 데이터 유형의 객체가 될 수 있습니다.

Return type − 반환 유형은 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은 일반 오래된 그루비 개체에도 사용할 수 있습니다. 다음 예제에서 실제로 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를 사용하면 최상위 문에 대한 메서드 호출의 인수 주위에 괄호를 생략 할 수 있습니다. 이를 "명령 체인"기능이라고합니다. 이 확장은 괄호가없는 메서드 호출을 연결하도록 허용하여 인수 주위에 괄호 나 연결 호출 사이에 점이 필요하지 않습니다.

호출이 다음과 같이 실행되는 경우 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-sql 모듈은 현재 Java의 JDBC 기술에 대해 더 높은 수준의 추상화를 제공합니다. Groovy SQL API는 다음과 같은 다양한 데이터베이스를 지원합니다.

• HSQLDB
• Oracle
• SQL 서버
• MySQL
• MongoDB

이 예에서는 MySQL DB를 예로 사용할 것입니다. Groovy와 함께 MySQL을 사용하려면 먼저 mysql 사이트에서 MySQL jdbc jar 파일을 다운로드해야합니다.The forMySQL의 매트는 아래와 같습니다.

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 기본 사항 을 이해했습니다.

다음 예는 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 " + "(${firstname}, ${lastname}, ${age}, ${sex}, ${income} )"
			
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      } catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
		
      sql.close()
   }
}

읽기 작업

모든 데이터베이스에 대한 읽기 작업은 데이터베이스에서 유용한 정보를 가져 오는 것을 의미합니다. 데이터베이스 연결이 설정되면이 데이터베이스에 쿼리 할 준비가 된 것입니다.

읽기 작업은 SQL 클래스의 eachRow 메서드를 사용하여 수행됩니다.

통사론

eachRow(GString gstring, Closure closure)

결과 집합의 각 행과 함께 지정된 Closure를 호출하는 지정된 SQL 쿼리를 수행합니다.

Parameters

• 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 작업은 데이터베이스에서 이미 사용 가능한 하나 이상의 레코드를 업데이트하는 것을 의미합니다. 다음 절차는 SEX가 'M'인 모든 레코드를 업데이트합니다. 여기에서는 모든 남성의 AGE를 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 + 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()
   } 
}

거래 수행

트랜잭션은 데이터 일관성을 보장하는 메커니즘입니다. 거래에는 다음 네 가지 속성이 있습니다.

• Atomicity − 거래가 완료되거나 아무 일도 일어나지 않습니다.

• Consistency − 트랜잭션은 일관된 상태에서 시작하고 시스템을 일관된 상태로 유지해야합니다.

• Isolation − 거래의 중간 결과는 현재 거래 외부에서 볼 수 없습니다.

• Durability − 트랜잭션이 커밋되면 시스템 장애 후에도 효과가 지속됩니다.

다음은 트랜잭션을 구현하는 방법에 대한 간단한 예입니다. 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()

롤백 작업

하나 이상의 변경 사항에 만족하지 않고 해당 변경 사항을 완전히 되돌리려면 롤백 방법을 사용하십시오. 위의 예에서 이것은 다음 진술에 의해 달성됩니다.

sql.rollback()

데이터베이스 연결 해제

데이터베이스 연결을 끊으려면 close 메소드를 사용하십시오.

sql.close()

소프트웨어 개발 과정에서 때때로 개발자는 데이터 구조, 도메인 클래스, XML, GUI 레이아웃, 출력 스트림 등을 생성하는 데 많은 시간을 할애하고 때로는 이러한 특정 요구 사항을 생성하는 데 사용되는 코드로 인해 동일한 스 니펫이 반복됩니다. 여러 곳에서 코드를 작성합니다. 이것은 Groovy 빌더가 작동하는 곳입니다. Groovy에는 표준 개체 및 구조를 만드는 데 사용할 수있는 빌더가 있습니다. 이러한 빌더는 개발자가 이러한 빌더를 생성하기 위해 자체 코드를 작성할 필요가 없기 때문에 시간을 절약합니다. 이 장에서는 그루비에서 사용할 수있는 다양한 빌더를 살펴 보겠습니다.

스윙 빌더

groovy에서는 groovy에서 사용 가능한 스윙 빌더를 사용하여 그래픽 사용자 인터페이스를 만들 수도 있습니다. 스윙 컴포넌트 개발을위한 메인 클래스는 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)

위 프로그램의 출력은 다음과 같습니다. 다음 출력은 Hello World 텍스트가있는 JLabel과 함께 JFrame을 보여줍니다.

텍스트 상자가있는 입력 화면을 만드는 다음 예제를 살펴 보겠습니다. 다음 예에서는 학생 이름, 과목 및 학교 이름에 대한 텍스트 상자가있는 양식을 작성하려고합니다. 다음 예에서 다음과 같은 핵심 사항을 볼 수 있습니다.

• 화면에서 컨트롤의 레이아웃을 정의하고 있습니다. 이 경우 그리드 레이아웃을 사용하고 있습니다.
• 레이블에 정렬 속성을 사용하고 있습니다.
• 화면에 텍스트 상자를 표시하기 위해 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의 두 처리기를 정의합니다.

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 빌더

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 빌더를 사용하는 방법을 보여줍니다.

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"')
      }
   } 
}

위의 코드를 실행하면 main / submain / Tutorial 폴더에 sample.txt라는 파일이 생성됩니다. 그리고 sample.txt 파일에는“Hello World”라는 텍스트가 있습니다.

groovysh로 알려진 Groovy 쉘은 groovy 표현식을 평가하고 클래스를 정의하며 간단한 프로그램을 실행하는 데 쉽게 사용할 수 있습니다. Groovy가 설치되면 명령 줄 셸이 설치됩니다.

다음은 Groovy에서 사용할 수있는 명령 줄 옵션입니다-

명령 줄 매개 변수	성명	세부
-씨	--color [= FLAG]	ANSI 색상 사용 활성화 또는 비활성화
-디	--define = 이름 = 값	시스템 속성 정의
-티	--terminal = TYPE	사용할 터미널 유형을 지정하십시오.
-V	--버전	버전 표시
-classpath		클래스 파일을 찾을 위치 지정 – 첫 번째 인수 여야합니다.
-cp	--classpath	'-classpath'에 대한 별칭
-디	-디버그	--debug 디버그 출력 활성화
-이자형	--evaluate = arg	대화 형 세션을 시작할 때 첫 번째 옵션 평가
-h	--도움	이 도움말 메시지 표시
-큐	--조용한	불필요한 출력 억제
-V	--말 수가 많은	자세한 출력 사용

다음 스냅 샷은 Groovy 셸에서 실행되는 표현식의 간단한 예를 보여줍니다. 다음 예제에서는 groovy 셸에 "Hello World"를 인쇄하고 있습니다.

클래스와 기능

명령 프롬프트에서 클래스를 정의하고 새 개체를 만들고 클래스에서 메서드를 호출하는 것은 매우 쉽습니다. 다음 예제는 이것이 어떻게 구현 될 수 있는지 보여줍니다. 다음 예제에서는 간단한 메서드로 간단한 Student 클래스를 만듭니다. 명령 프롬프트 자체에서 클래스의 개체를 만들고 Display 메서드를 호출합니다.

명령 프롬프트에서 메서드를 정의하고 메서드를 호출하는 것은 매우 쉽습니다. 메서드는 def 유형을 사용하여 정의됩니다. 또한 Display 메서드가 호출 될 때 실제 값으로 대체되는 name이라는 매개 변수가 포함되어 있습니다. 다음 예제는 이것이 어떻게 구현 될 수 있는지 보여줍니다.

명령어

셸에는 셸 환경에 대한 풍부한 액세스를 제공하는 다양한 명령이 있습니다. 다음은 그들 목록과 그들이하는 일입니다.

Sr. 아니요	명령 & smp; 명령어 설명
1	:help (: h)이 도움말 메시지 표시
2	? (:?) 별칭 : : help
삼	: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) 편집 라인 이력 표시, 관리 및 호출

객체 지향 시스템의 기본 단위는 클래스입니다. 따라서 단위 테스트는 클래스 내의 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 메서드가 올바른 문자열을 반환하는지 확인하기 위해 assert 문을 사용하고 있습니다.

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

Groovy 테스트 스위트

일반적으로 단위 테스트 수가 증가하면 모든 테스트 케이스를 하나씩 실행하기가 어려워집니다. 따라서 Groovy는 모든 테스트 케이스를 하나의 논리 단위로 캡슐화 할 수있는 테스트 스위트를 생성하는 기능을 제공합니다. 다음 코드 스 니펫은이를 달성하는 방법을 보여줍니다. 코드에 대해 다음 사항에 유의해야합니다.

• GroovyTestSuite는 모든 테스트 케이스를 하나로 캡슐화하는 데 사용됩니다.

• 다음 예에서는 두 개의 테스트 케이스 파일이 있다고 가정합니다. StudentTest 그리고 다른 하나는 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"문자열을 포함 할 이름 변수를 정의합니다. 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 and $제목은 모두 런타임에 교체해야하는 자리 표시 자로 배치됩니다.

<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} and $임의의 표현식을 템플릿에 삽입하기위한 변수 표기법.

다음은 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

메타 개체 프로그래밍 또는 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 구현과 관련이 있습니다. 기본 구현에서는 getter 및 setter를 호출하지 않고 필드에 액세스 할 수 있습니다. 다음 예제는 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