1) String Kullanımı

Groovy'de String kullanımı, birçok programlama diline benzer şekildedir, ancak Groovy'nin bazı özgün özellikleri vardır. İşte String kullanımına dair temel bilgiler:

String s1 = 'Tek tırnakla tanımlanan bir string'
String s2 = "Çift tırnakla tanımlanan bir string"
String s3 = '''Üç tırnakla 
tanımlanan 
çok satırlı 
bir string'''
GROOVY

Groovy'de çift tırnakla tanımlanan stringlerde değişken değerlerini direkt olarak ekleyebilirsiniz. Bu özellik, "String interpolasyonu" veya "GString" olarak adlandırılır.

String ad = "Ali"
String selam = "Merhaba, ${ad}!"
println(selam)  // Çıktı: Merhaba, Ali!
GROOVY

2) String'de Tek, Çift, Üç Defa Tırnak Kullanımlarının Farkları

Groovy'de String tanımlamak için tek tırnak ('), çift tırnak (") ve üç tırnak (''' veya """) kullanılabilir. Bu tırnakların kullanımındaki farklar şunlardır:

Tek Tırnak (' '):

  • Tek tırnakla tanımlanan stringler sıradan stringlerdir (plain strings).
  • İçerisinde string interpolasyonu (değişken yerleştirme) yapılamaz.
  • String s1 = 'Merhaba, ${isim}!' 
println(s1) // Çıktı: Merhaba, ${isim}!
    GROOVY


  • Tek tırnakla tanımlanan stringler sıradan stringlerdir (plain strings).
  • İçerisinde string interpolasyonu (değişken yerleştirme) yapılamaz.
  • String s1 = 'Merhaba, ${isim}!' 
println(s1) // Çıktı: Merhaba, ${isim}!
    GROOVY

Çift Tırnak ("):      

  • Çift tırnakla tanımlanan stringler "GString" olarak bilinir.
  • İçerisinde string interpolasyonu (değişken yerleştirme) yapılabilir.
  • String isim = "Ali"
String s2 = "Merhaba, ${isim}!" 
println(s2) // Çıktı: Merhaba, Ali!
    GROOVY


Üç Defa Tırnak('''):

  • Çok satırlı stringleri tanımlamak için kullanılır.
  • İçerisinde string interpolasyonu yapılabilir.
  • String isim = "Ali"
String s3 = '''Merhaba,
${isim}!
Nasılsın?'''
println(s3) 
// Çıktı:
// Merhaba,
// Ali!
// Nasılsın?
    GROOVY


3) Groovy'de String'in Boş Olup Olmadığını Kontrol Etme

Groovy'de bir string'in boş olup olmadığını kontrol etmek için isEmpty() metodu kullanılabilir.

String s = ""
if(s.isEmpty()) {
    println("String boş!")
} else {
    println("String boş değil!")
}
GROOVY

4) Groovy'de Nesnenin Boş Olup Olmadığını Kontrol Etme

Groovy'de bir nesnenin boş olup olmadığını kontrol etmek için == null ya da != null ifadeleri kullanılır.

def obj = null
if(obj) {
    println("Nesne boş değil!")
} else {
    println("Nesne boş!")
}
Çıktı: "Nesne boş!"
GROOVY

5) Groovy'de For Döngüsü

Groovy'de bir for döngüsü, Java'da olduğu gibi yazılır. Temel bir örnek:

def toplam = 0
for(int i = 0; i < 10; i++) {
   toplam +=i
   responseBodyTextToClient = "toplam: ${toplam}"
}

//Çıktı : "toplam: 45"
GROOVY

6) Groovy'de While Döngüsü

Groovy'de while döngüsü, diğer programlama dillerinde olduğu gibi kullanılır. İşte temel bir örnek:

int sayi = 0
while(sayi < 10) {
    sayi++
    
}
responseBodyTextToClient = sayi

//Çıktı:  "10"
GROOVY

7) Groovy'de Fonksiyon (Metod) Tanımlama

Groovy'de fonksiyonlar, genellikle "metod" olarak adlandırılır ve Java'ya benzer bir şekilde tanımlanır. Ancak Groovy, daha esnek bir sözdizimi sunar.

def fonksiyonAdi(parametre1, parametre2, ...) {
    // Fonksiyon içeriği
    return sonuc
}
GROOVY 
def topla(a, b) {
    return a + b
}


//Fonksiyonu tanımladıktan sonra ismiyle birlikte çağırarak kullanabilirsiniz.

def sonuc = topla(5, 3)
responseBodyTextToClient =sonuc  // Çıktı: 8
GROOVY

8) Groovy'de Try-Catch Kullanımı

Groovy'de try-catch yapısı, Java'da olduğu gibi hataların (exceptions) yakalanması ve işlenmesi için kullanılır. Sözdizimi ve kullanımı Java'ya çok benzerdir.

try {
    // Hata oluşturabilecek kodlar
    int sonuc = 10 / 0  // Bu satır bir ArithmeticException hatası üretecektir.
} catch (ArithmeticException e) {
    
responseBodyTextToClient ="Aritmetik bir hata oluştu: " + e.getMessage()
} catch (Exception e) {
    responseBodyTextToClient ="Bir hata oluştu: " + e.getMessage()
}

//Çıktı : "Aritmetik bir hata oluştu: divide by zero"
GROOVY

9) Groovy'de Concatenation

Groovy'de string birleştirme (concatenation) işlemi için birkaç yöntem bulunmaktadır. İşte bu yöntemlere dair bazı örnekler:

1. Basit + Operatörü ile Birleştirme:

String ad = "Ali"
String mesaj = "Merhaba, " + ad + "!"
GROOVY

2. GString (Parametreli String) Kullanımı:

Groovy, değerleri doğrudan string içerisine eklemek için ${...} yapısını kullanabilen bir string türü olan GString'i destekler.

String ad = "Ali"
String mesaj = "Merhaba, ${ad}!"
println(mesaj)  // Çıktı: Merhaba, Ali!
GROOVY

3. << Operatörü ile Birleştirme:

Bu yöntem, büyük veri setlerinde string birleştirme işlemleri için daha performanslıdır.

def sb = new StringBuilder()
sb << "Merhaba, "
sb << "Ali"
sb << "!"
println(sb.toString())  // Çıktı: Merhaba, Ali!
GROOVY

4. join() Metodu:

Listelerdeki elemanları birleştirmek için kullanılır.

def kelimeler = ["Merhaba", "Ali"]
String mesaj = kelimeler.join(", ") + "!"
println(mesaj)  // Çıktı: Merhaba, Ali!
GROOVY

10) Groovy'de Stringlerde Özel Karakterlerin Kaçış(Escaping) İşlemi

def mesaj = 'Merhaba, \'Ali\'. Bugün nasılsın?'
println(mesaj)  // Çıktı: Merhaba, 'Ali'. Bugün nasılsın?
GROOVY


11) Groovy'de Apache StringUtils Kullanımı

Groovy'de Java kütüphanelerini kullanmak için import anahtar kelimesini kullanabilirsiniz.

// StringUtils sınıfını import ediyoruz
import org.apache.commons.lang3.StringUtils

// Basit bir Groovy script
def mainString = "Hello, Groovy!"
def searchString = "Groovy"

// StringUtils kullanarak bir string içinde başka bir string'in olup olmadığını kontrol ediyoruz
if (StringUtils.contains(mainString, searchString)) {
    responseBodyTextToClient =("$searchString is found in $mainString")
} else {
    responseBodyTextToClient =("$searchString is not found in $mainString")
}
GROOVY

12) Java'da Apache Commons Codec ile Base64 Kodlama ve Çözme

Java'da Apache Commons Codec kütüphanesini kullanarak Base64 kodlama ve çözme işlemleri yapabilirsiniz. Bu kütüphane, Base64 işlemleri için Base64 sınıfını sağlar.

// Base64 sınıfını import ediyoruz
import org.apache.commons.codec.binary.Base64

def originalString = "Merhaba, Groovy!"

// String'i Base64 ile kodlama
byte[] encodedBytes = Base64.encodeBase64(originalString.getBytes())
String encodedString = new String(encodedBytes)

// Base64 ile kodlanmış string'i çözme
byte[] decodedBytes = Base64.decodeBase64(encodedString.getBytes())
String decodedString = new String(decodedBytes)


responseBodyTextToClient = "Orijinal String: $originalString" + ' ' +"Base64 ile Kodlanmış String: $encodedString"+ ' ' +"Base64 ile Çözülmüş String: $decodedString"

//Çıktı :  "Orijinal String: Merhaba, Groovy! Base64 ile Kodlanmış String: TWVyaGFiYSwgR3Jvb3Z5IQ== Base64 ile Çözülmüş String: Merhaba, Groovy!"
GROOVY

13) Groovy'de Java Import İle XmlUtil Sınıfının Kullanımı

Groovy, XML işlemleri için oldukça güçlü bir dil olup, XML içeriğini okuma, oluşturma ve düzenleme gibi işlemleri kolaylaştıran birçok yerleşik özelliğe sahiptir. XmlUtil sınıfı, XML içeriğini düzenli bir şekilde (pretty-print) yazdırmak için kullanılır.

// XmlUtil sınıfını import ediyoruz
import groovy.xml.XmlUtil

def xmlContent = '''
<root>
    <element1>Value1</element1>
    <element2>Value2</element2>
</root>
'''

def parsedXml = new XmlParser().parseText(xmlContent)
String prettyXml = XmlUtil.serialize(parsedXml)


responseBodyTextToClient = prettyXml


/* 
<?xml version="1.0" encoding="UTF-8"?>
<root>
   <element1>Value1</element1>
   <element2>Value2</element2>
</root>
*/
GROOVY

14) Groovy'de XML İçerisinden Veri Okuma

Groovy, XML içeriğini okumak için oldukça güçlü ve esnek bir dil sunar. XML içeriğini okumak için Groovy'de genellikle XmlSlurper veya XmlParser sınıflarını kullanabilirsiniz.

import groovy.xml.XmlSlurper

def xmlContent = '''
<root>
    <person>
        <name>John Doe</name>
        <age>30</age>
    </person>
    <person>
        <name>Jane Smith</name>
        <age>25</age>
    </person>
</root>
'''

def xml = new XmlSlurper().parseText(xmlContent)

// İlk kişinin adını okuma
def firstName = xml.person[0].name.text()
println "First person's name: $firstName"

// İkinci kişinin yaşını okuma
def secondPersonAge = xml.person[1].age.text()
responseBodyTextToClient = "Second person's age: $secondPersonAge"
GROOVY

15) Groovy'de XML İçerisine Element Ekleme

Groovy, XML içeriğine yeni bir element eklemek için oldukça kullanışlı araçlar sunar. Bu işlem için genellikle XmlParser veya XmlSlurper sınıflarını kullanabilirsiniz.

import groovy.xml.XmlParser
import groovy.xml.XmlUtil

// Örnek XML içeriği
def xmlContent = '''
<root>
    <person>
        <name>John Doe</name>
        <age>30</age>
    </person>
</root>
'''

def parsedXML = new XmlParser().parseText(xmlContent)

// 'person' elementine yeni bir 'address' elementi ekliyoruz
parsedXML.person.appendNode('address', '123 Main St')

// XML içeriğini düzenli bir şekilde yazdırma
def prettyXml = XmlUtil.serialize(parsedXML)
responseBodyTextToClient = prettyXml
GROOVY

16) Groovy'de XML İçerisinde Element Silme

Elbette, XML içeriğinden bir elementi silmek için Groovy'de XmlParser veya XmlSlurper sınıflarını kullanabilirsiniz.

import groovy.xml.XmlParser
import groovy.xml.XmlUtil

// Örnek XML içeriği
def xmlContent = '''
<root>
    <person>
        <name>John Doe</name>
        <age>30</age>
        <address>123 Main St</address>
    </person>
</root>
'''

def parsedXML = new XmlParser().parseText(xmlContent)

// 'person' elementi altındaki 'address' elementini bulup siliyoruz
parsedXML.person.address[0].replaceNode {}

// XML içeriğini düzenli bir şekilde yazdırma
def prettyXml = XmlUtil.serialize(parsedXML)
responseBodyTextToClient = prettyXml
GROOVY

17) Groovy'de XML İçerisinde Element Düzenleme

XML içeriğindeki bir elementi düzenlemek için Groovy'de XmlParser veya XmlSlurper sınıflarını kullanabilirsiniz.

import groovy.xml.XmlParser
import groovy.xml.XmlUtil

// Örnek XML içeriği
def xmlContent = '''
<root>
    <person>
        <name>John Doe</name>
        <age>30</age>
        <address>123 Main St</address>
    </person>
</root>
'''

def parsedXML = new XmlParser().parseText(xmlContent)

// 'person' elementi altındaki 'address' elementinin değerini değiştiriyoruz
parsedXML.person.address[0].value = '456 Elm St'

// XML içeriğini düzenli bir şekilde yazdırma
def prettyXml = XmlUtil.serialize(parsedXML)
responseBodyTextToClient = prettyXml
GROOVY

18) Groovy'de XML İçerisinde For İle Gezinme

XML içeriğindeki bir elementi düzenlemek için Groovy'de XmlParser veya XmlSlurper sınıflarını kullanabilirsiniz.

import groovy.xml.XmlParser

// Örnek XML içeriği
def xmlContent = '''
<root>
    <people>
        <person>
            <name>John Doe</name>
            <age>30</age>
        </person>
        <person>
            <name>Jane Smith</name>
            <age>25</age>
        </person>
        <person>
            <name>Bob Johnson</name>
            <age>40</age>
        </person>
    </people>
</root>
'''

def parsedXML = new XmlParser().parseText(xmlContent)

// 'people' altındaki 'person' elementlerini bir diziye alıyoruz
def personsList = []

for (person in parsedXML.people.person) {
    def personMap = [
        name: person.name.text(),
        age: person.age.text().toInteger()
    ]
    personsList << personMap
}

// Sonuç
responseBodyTextToClient = personsList


/*
Çıktı: 
[
    [name: "John Doe", age: 30],
    [name: "Jane Smith", age: 25],
    [name: "Bob Johnson", age: 40]
]
*/
GROOVY

19) Groovy'de JSON İçeriğinden Değer Okuma

Groovy, JSON işlemleri için oldukça güçlü bir dil olup, JSON içeriğini okuma, oluşturma ve düzenleme gibi işlemleri kolaylaştıran birçok yerleşik özelliğe sahiptir. JsonSlurper sınıfı, JSON içeriğini ayrıştırmak ve okumak için kullanılır.

import groovy.json.JsonSlurper

// Örnek JSON içeriği
def jsonString = '''
{
    "name": "John Doe",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "Springfield"
    }
}
'''

def json = new JsonSlurper().parseText(jsonString)

// JSON içeriğinden değerleri okuma
def name = json.name
def age = json.age
def street = json.address.street


responseBodyTextToClient = "Name: $name Age: $age Street: $street"  

//Çıktı: "Name: John Doe Age: 30 Street: 123 Main St"
GROOVY

20) Groovy'de JSON İçeriği Oluşturma

Groovy, JSON verilerini kolayca oluşturmak ve düzenlemek için JsonBuilder ve JsonOutput gibi yerleşik sınıflar sunar. Bu sınıflar, JSON formatında veri oluşturmak için oldukça kullanışlıdır.

import groovy.json.JsonBuilder
import groovy.json.JsonOutput

// Json oluşturulacak içerik
def nameValue = "John"
def surnameValue = "Doe"

def builder = new JsonBuilder()

// JSON yapısının tanımlandığı blok
def jsonRequestBodyExample = builder {
	name nameValue
	surname surnameValue
}

// JSON nesnesini JSON formatında bir string'e dönüştürme
responseBodyTextToClient = JsonOutput.toJson(jsonRequestBodyExample)

/* Çıktı: 

{
  "name" : "John",
  "surname" : "Doe",
}

*/
GROOVY

21) Groovy'de JSON İçeriğine Element Ekleme

Groovy, JSON işlemleri için JsonSlurper ve JsonBuilder gibi yerleşik sınıflar sunar. Bu sınıflar sayesinde JSON içeriğini kolayca ayrıştırabilir, düzenleyebilir ve yeni elementler ekleyebilirsiniz.

import groovy.json.JsonSlurper
import groovy.json.JsonBuilder

// Örnek JSON içeriği
def jsonString = '''
{
    "name": "John Doe",
    "age": 30
}
'''

def json = new JsonSlurper().parseText(jsonString)

// JSON içeriğine yeni bir element ekliyoruz
json.address = "123 Main St"

// JSON içeriğini tekrar string formatına dönüştürme
def updatedJsonString = new JsonBuilder(json).toPrettyString()

responseBodyTextToClient = updatedJsonString

/* Çıktı: 

{
  "name" : "John Doe",
  "age" : 30,
  "address" : "123 Main St"
}

*/
GROOVY

22) Groovy'de JSON İçeriğinden Element Silme

Groovy, JSON işlemleri için JsonSlurper ve JsonBuilder gibi yerleşik sınıflar sunar. Bu sınıflar, JSON içeriğini kolayca ayrıştırmak, düzenlemek ve elementleri silmek için oldukça kullanışlıdır.

import groovy.json.JsonSlurper
import groovy.json.JsonBuilder

// Örnek JSON içeriği
def jsonString = '''
{
    "name": "John Doe",
    "age": 30,
    "address": "123 Main St"
}
'''

def json = new JsonSlurper().parseText(jsonString)

// JSON içeriğinden 'address' elementini siliyoruz
json.remove('address')

// JSON içeriğini tekrar string formatına dönüştürme
def updatedJsonString = new JsonBuilder(json).toPrettyString()

responseBodyTextToClient = updatedJsonString


/* Çıktı: 

{
  "name" : "John Doe",
  "age" : 30
}

*/
GROOVY

23) Groovy'de JSON İçeriğindeki Elementi Düzenleme

Groovy, JSON işlemleri için JsonSlurper ve JsonBuilder gibi yerleşik sınıflar sunar. Bu sınıflar, JSON içeriğini kolayca ayrıştırmak, düzenlemek ve elementlerin değerlerini değiştirmek için oldukça kullanışlıdır.

import groovy.json.JsonSlurper
import groovy.json.JsonBuilder

// Örnek JSON içeriği
def jsonString = '''
{
    "name": "John Doe",
    "age": 30,
    "address": "123 Main St"
}
'''

def json = new JsonSlurper().parseText(jsonString)

// JSON içeriğindeki 'address' elementinin değerini değiştiriyoruz
json.address = "456 Elm St"

// JSON içeriğini tekrar string formatına dönüştürme
def updatedJsonString = new JsonBuilder(json).toPrettyString()

responseBodyTextToClient = updatedJsonString



/* Çıktı: 

{
  "name" : "John Doe",
  "age" : 30,
  "address": "456 Elm St"
}

*/
GROOVY

24) Groovy'de JSON İçeriğindeki Dizi Üzerinde For İle Gezinme

Groovy, JSON işlemleri için JsonSlurper ve JsonBuilder gibi yerleşik sınıflar sunar. Bu sınıflar, JSON içeriğini kolayca ayrıştırmak, düzenlemek ve elementlerin değerlerini değiştirmek için oldukça kullanışlıdır.

import groovy.json.JsonSlurper

// Örnek JSON içeriği
def jsonString = '''
{
    "people": [
        {"name": "John Doe", "age": 30},
        {"name": "Jane Smith", "age": 25},
        {"name": "Bob Johnson", "age": 40}
    ]
}
'''

def json = new JsonSlurper().parseText(jsonString)

// JSON içeriğindeki 'people' dizisi üzerinde for döngüsü ile gezinme
def personsList = []
for (person in json.people) {
    def personMap = [
        name: person.name,
        age: person.age
    ]
    personsList << personMap
}


responseBodyTextToClient = personsList

/* Çıktı: 

[{name=John Doe, age=30}, {name=Jane Smith, age=25}, {name=Bob Johnson, age=40}]

*/
GROOVY

25) Apinizer Değişkenleri

Script politikası ile mesajlardaki başlık (header), parametre (parameter), gövde (body) ve hata mesajı (error message) içerikleri seçilen script dili ile işlenebilir.

Gelen istek mesajın orijinal hali ile dönen yanıt mesajının orijinal hali üzerinde değişiklik yapılamaz, bu veriler üzerinde sadece okuma yapılabilir.

Backend API'ye gönderilecek olan istek ile istemciye dönecek yanıt üzerinde ise hem okuma hem de değişiklik yapılabilir.

Yapılacak olan okuma ve değişiklik işlemleri mesajın başlık, parametre ve gövde kısımlarını içerir. Bu alanlara script üzerinde erişim için çeşitli anahtar kelimeler kullanılmıştır. Bu anahtar kelimeler erişilmek istenen bölgeye göre değişmektedir.


  • Başlıklara erişmek için → <request|response>HeaderMap<From|To><Client|TargetAPI>
  • URL parametrelerine erişmek için → <request>UrlParamMap<From|To><Client|TargetAPI>
  • Gövdeye erişmek için → <request|response>BodyText<From|To><Client|TargetAPI>
  • Politikayı sonlandırıp özelleştirilmiş hata mesajı döndürmek için → <request|response>ErrorMessage<From|To><Client|TargetAPI> gösterimini kullanmanız gerekir.
  • Durum kodunu değiştirmek için→statusCode<From|To><Client|TargetAPI>
/* Request
{
  "data": {
    "alan": "1"
  }
}
*/   

//Script

import groovy.json.JsonSlurper


def jsonSlurper = new JsonSlurper()
def jsonMessage = jsonSlurper.parseText(requestBodyTextFromClient)

requestErrorMessageToTargetAPI = jsonMessages
statusCodeToTargetAPI = 500


//Sonuç: 

//{data={alan=1}} seklinde client'a dönülür.



//Script içerisinde requestHeaderMapFromClient değişkeni Map olarak Client'dan gelen Header'ları tutmaktadır, Read only olacak şekilde değişken kullanılabilir.

/* Request Header

userId : 123456

*/

//Script

def userID = requestHeaderMapFromClient.get('userId')

if(userID =='123456'){
requestErrorMessageToTargetAPI = userID
statusCodeToTargetAPI = 401
} 

//Çıktı:

// 123456   - statusCode = 401
GROOVY