• Erlang dili ile gelisitirilmistir. Erlang, yogun concurrent islem yapilan, distributed sistemler icin tasarlanan bir dildir. 
• 2007 yilinda open source olarak yayinlanmistir.
• Cross platform destekler.
• Bir cok dil icin destegi vardir.
• Anlisilir bir arayuze sahiptir.
• Guzel bir dokumantasyonu vardir.

RabbitMQ temel bilesenleri ve calisma mantigi en temel haliyle Sekil 1’deki gorselden anlasilabilir. Ozetle publisher tarafindan gonderilen mesaji, exchange ilgili queue ya iletir ve o kuyrugu dinleyen consumer tarafindan alip islenir.

Publisher/Producer

RabbitMQ ya mesajlari gonderen taraftir. Mesaj gonderilirken set edilen bazi bilgiler :

• Exchange = Bu mesaji yonlendirecek exchange bilgisi
• Rounting Key = Hangi queulara iletilecegini belirten yonlendirme anahtari
• Content Type = Icerik turu, json payload olan mesajlar icin application/json olarak set edilmelidir.
• Mandatory = Default olarak “false” set edilir. Gonderilmek istenen mesaj bir sebepten dolayi kuyruga yonlendirilemediginde discard edilir. Eger bu alan “true” olarak set edilirse. Mesaj bir kuyruga yonlendirilemediginde, mesaj geri dondurulur.

Bir mesajin RabbitMQ tarafindan basariyla kabul edildiginden emin olmak icin “confirm.select(Publisher confirms)” mekanizmasi kullanilir. Mesaj gonderildikten sonra, brokerdan Positive Ack(mesaji aldim) bilgisi donerse islem basarilidir. Eger Negative Ack(mesaji alamadim) donerse, loglama veya yeniden gondermeye calisma gibi islemler yapilabilir.

*Producer baglantilari genellikle uygulama ayaga kalkarken acilir ve uygulama calistigi surece yasarlar. Tek bir mesaj yayinlamak icin baglanti acma/kapama dogru bir yaklasim degildir.

Exchange

Gelen mesajlari, iclerindeki routing key ve exchant tipi bilgilerine gore ilgili kuyruklara yonlendiren aractir. 4 adet exchange tipi vardir.

Direct Exchange =Default exchange tipidir. Mesajlar yalnizca routung ile tam olarak eslesen binding keye sahip olan kuyruklara iletilir. Mesajlarin tek bir kuyruga yonlendirilmesi icin idealdir fakat birden cok kuyruga yonlendirmek icin de kullanilabilir.

Sekil 2’deki ornekte 3 farkli routing keyi olan mesaj exchange ‘e gonderilmistir. Exchange yalnizca routing key ile birebir eslesen kuyruklara mesajlari iletmistir. Hatta M1 mesaji iki ayri kuyruga gonderilmistir. Sizin de farkedeceginiz uzere M3 mesajinin keyi birebir eslesmedigi icin herhangi bir kuyruga iletilemedi.

Fanout Exchange = Mesajlar routing keylerine bakilmadan, bu exchange’e bagli tum kuyruklara iletilir. N adet kuyruk bu exchange’e bagliysa, yeni bir mesaj gonderildiginde N tane kuyruga iletilir.

Sekil 3’deki ornekte 2 farkli mesaj exchange’e gonderilmistir. Exchange routing keye bakmadan gelen mesajlari tum kuyruklara iletmistir.

Topic Exchange = En cok tercih edilen exchange tipidir. Mesajlar routing keylerine bakilarak, routing patterni ile eslesen kuyruklara iletilir.

Sekil 4’deki ornekte 2 farkli mesaj exchange’e gonderilmistir. Exchange routing keylere bakti ve M1 mesaji, patternlerine uydugu icin 2 ayri kuyruga iletildi. Fakat M2 mesaji hic bir patterne uymadigi icin iletilemedi.

Header Exchange = Mesajlar header bilgileri icerisindeki ozellikleri ile “x-match” keyi ile eslesen kuyruklara iletilirler. Cok fazla kullanilan bir exchange tipi degildir.

Queue

Kendisine gelen mesajlari dogru bir sekilde consumerlara dagitmaya yarayan aractir. Bir queue tanimlanirken set edilebilen bazi ozellikler:

• Durability = Kuyruk hakkindaki bilgilerin nerede tutulacaginin ve broker restart oldugunda da kuyrugun kaldigi yerden hayatina devam edip etmeyecegi kararinin verildigi ozelliktir. Durable/Transient olmak uzere iki secenek vardir. Default olarak durable secilidir, kuyruk bilgileri diskte tutulur ve broker restart olsa dahi kuyruk kaybolmaz. Transient de ise ram de saklanir.
• Exclusivity = Yalnizca bir connection icin kullanilir ve baglanti kapandiginda silinir.
• Auto-delete = Kuyrugu dinleyen consumer yoksa kuyruk otomatik olarak silinir.
• Args = Optional olarak set edilirler. Kullandigimiz bir kacina bakalim.
  • Time to live and expiration(TTL) = Bu ozellik ile kuyruktaki mesajlarin belirtilen sure bittikten sonra kuyruktan otomatik silinmesi saglanir. TTL kuyruga veya mesaja set edilebilir.
  • Dead Letter Exchange(DLX) = Consumer tarafindan Nack ve requeue=false olarak isaretlenen bir mesajin, TTL suresi dolup kuyruktan silinen bir mesajin veya kuyrugun uzunluk limiti asildigi icin drop edilen bir mesajin baska bir kuyruga yonlendirilmesini saglayan ozelliktir.

DLX nedir daha iyi anlamak icin daha once tanimlanan kuyrugu inceleyelim. Sekil 5’de kuyruga dusen mesaj, 25 saniye sonra bu kuyruktan silinecek ve “Merchant-Exchange” icerisindeki, binding keyi “Test.Deneme.CreatedEvent_TryAgain” olan kuyruga iletilecek.

Consumer

Kuyruklari dinleyip, gelen mesajlari islemeye yarayan aractir. Consumerlar kuyruklari dinlemeye baslarken Acknowledgement modu set edilir.

• Automatic = Mesaji kuyruktan silmek icin consumerdan onay beklemez. Fire and forget seklinde calisir.
• Manuel = Mesaji kuyruktan silmek icin consumerdan onay bekler. Consumer mesaji isledikten sonra herhangi bir hata almazsa RabbitMQ ya positive ack bilgisini gonderir ve mesaj kuyruktan silinir. Islem sirasinda bir hata alirsa RabbitMQ ya negative ack bilgisini ve mesaji yeniden kuyruga gonderilip gonderilmeyecegi bilgisini gonderir.
  

channel.basicAck(deliveryTag, true); //Positive ack bilgisini gonderir ve mesaj kuyruktan silinir.

** Nack ve reject arasindaki fark; reject yalnizca bir mesaj icin calisabiliryorken, nack birden fazla mesaj icin calisabilir.

channel.basicReject(deliveryTag, true); //Negative ack ve mesaji yeniden kuyruga al bilgisini gonderir.

channel.basicReject(deliveryTag, false); //Negative ack ve mesaji yeniden kuyruga alma,sal gitsin bilgisini gonderir.

channel.basicNack(deliveryTag, true, true); //Negative ack ve bu de

Pointer(ptr) : Slice’in ilk ogesinin bellekteki adresini tutar.
Length(len) : Slice’in uzunlugunu tutar.
Capacity(cap) : Slice’in kapasitesini tutar.

Yeni bir slice tanimlaninca bellekte bir yer ayrilir ve icerisinde ptr, len, cap bilgileri tutulur. Slice icerisindeki bir elemana erismek istenildiginde bu bilgiler yeterli olacaktir.

Slice’in 1. elemanina erismek istenildiginde, Golang once slice icerisindeki pointer bilgisi ile 0. elemana ulasir. Ardindan bellekte bulunan siradaki elemani isteyerek 1. elemana ulasir. Slice’in verileri bellekte stack’de sirali bir sekilde tutulur.

	var a [5]int             // 5 elementli int dizi tanimlar
	fmt.Println(a[0])        // 1. elementi yazar
	fmt.Println(a[len(a)-1]) // Son elementi yazar, a[4]

Degerleriyle beraber dizi tanimlamak icin array literal kullanilabilir.

	var a [3]int = [3]int{1, 2, 3}
	var b [3]int = [3]int{1, 2} // Uzunlugunu 3 set ettigimiz icin son elementini default 0 atar
	fmt.Println(b[2]) // "0"

Dizi tanimlarken uzunluk yerine “…” koyulursa, dizi uzunlugu elementlerin sayisina gore belirlenir. Asagidaki kod blogu calistirildiginda uzunluk ekrana 5 olarak yazilacaktir.

	a := [...]int{1, 2, 3, 4, 5}
	fmt.Print(len(a))

Bir dizinin boyutu, türünün bir parçasıdır yani [3] int ve [4] int farklı türlerdir. Ayni tip ve boyuttaki diziler karsilastirilabilirken, boyutlar farkli ise karsilastirirken hata verecektir. Diziler karsilastirilirken == veya != operatorleri kullanilabilir.

Golang ile uygulama gelistirilirken dizi yerine slice ler daha fazla tercih edilmektedir. Bir sonraki makalede slice leri inceleyecegiz.

Paket ismi best practice olarak içerisinde bulunduğu klasör ile aynı olmalıdır fakat bu zorunlu değildir. Paket tanımlama package keywordu ile yapılır. Aşağıdaki örnekte de gördüğünüz gibi testservice’i yazarken, kaynak kodun en üstünde paketi tanımladık ve adını içerisinde bulunduğu klasörün adıyla(services) aynı belirttik. Her bir kaynak kodunda paket tanımlaması yapmak zorunludur.

Yukarıda yazdığımız paketi başka bir paket içerisinde kullanacağımız zaman, import etmemiz gerekir. Paketin path’ini vererek import edebiliriz veya Github üzerinde bir repository’deki path’ini verebiliriz.

Golang’de erişim belirleyici olarak fonksiyon veya değişkenlerin ilk harfi kullanılır.Diğer dillerde bu iş için public, private vs. keywordleri kullanılırken, Go’da İlk harf büyük ise paket dışından erişilebilir, küçük ise dışarıdan erişilemez. Örnek olarak services paketi içerisinde bir tane ilk harfi büyük bir tane de küçük bir fonksiyon tanımlayıp, main paketi içerisinden çağırmayı deneyelim.

Yukarıdaki ekran görüntüsünde de göreceğiniz gibi Plus ve divide fonksiyonlarını tanımladık. Başka bir paketten divide fonksiyonunu çağırmak istediğimizde kodumuz build olmadı ve unexported bir fonksiyona erişemezsiniz dedi.

Pointer‘lar ise değişkenlerin adresleridir. Yani Pointer değerin saklandığı konumdur. Her değerin bir adresi yoktur ama her değişkenin mutalaka bir adresi vardır. Pointer ile bir değişkenin adını kullanmadan hatta adını bilmeden, dolaylı olarak o değişkenin değerini okuyabilir veya güncelleyebiliriz. Golang içerisinde Pointer denildiğin * ve & operatörlerini bilmemiz gerekir. & operatörü değişkenin adresini bulmakta kullanılırken, * operatörü ise Pointer’ın işaret ettiği adresteki değer alınır. Şimdi bu söylediklerimizi bir örnekle pekiştirelim.

package main

import "fmt"

func main() {
	kby := 58     //kby değişkenine 58 değerini atadık.
	emy := &kby   //emy bir pointer oldu. İçerisinde kby değişkeninin tutulduğu bellek adresi var.
	fmt.Println("kby=", kby)  //kby değeri
	fmt.Println("emy pointer address=", emy) //bellek adresi
	fmt.Println("emy pointer value=", *emy)  //bellek adresindeki değer
}

Şimdi daha önce söylediğimiz gibi adını bile bilmediğimiz bir değişkenin değerini değiştirelim

package main

import "fmt"

func main() {
	//Önce kby isimli bir değişken tanımlauyacağız.
	//Ardından kby değişkenini pointer olarak emy atayacağız.
	//emy pointerını da kay isimli başka bir pointera atayacağız.
	//kay pointerının değerine 34 atayacağız.
	//En son tümünün değerlerine bakacağız.

	kby := 58     //kby değişkenine 58 değerini atadık.
	emy := &kby   //emy bir pointer oldu. İçerisinde kby değişkeninin tutulduğu bellek adresi var.
	kay := emy
	*kay = 34

	fmt.Println("kby=", kby)  //kby değeri
	fmt.Println("emy pointer address=", emy) //bellek adresi
	fmt.Println("kay pointer address=", kay)  //bellek adresindeki değer

	fmt.Println("kby=", kby)  //kby değeri
	fmt.Println("emy value=", *emy) //bellek adresi
	fmt.Println("kay value=", *kay)  //bellek adresindeki değer
}

Fonksiyonlarda Pointer Kullanımı

Pointer bir değişkenin adresini içerdiğinden, bir fonksiyona Pointer bağımsız değişkeni iletilmesi, fonksiyonun dolaylı olarak gönderilen değişkeni güncelleştirmesini mümkün kılar. Sanırım örnekle daha iyi anlayacağız.

package main

import "fmt"

func main() {
	//İlk fonksiyonda parametre olarak pointer göndermedik.
	//Main fonksiyonu içerisindeki kby değişkenini etkilenmediğini gördük.
	
	//İkinci fonksiyonda ise pointer olarak gönderdik.
	//Kby değişkeninin değiştiğini siz de farketmiştirsiniz.
	//Alttaki çıktılara baktığımızda fonksiyon içerisindeki p değişkeni ile
	//Main fonksyionu içerisindeki kby değişkeninin hem değeri hem adresi aynıdır.

	kby := 58     //kby değişkenine 58 değerini atadık.

	incr(kby)
	fmt.Println("kby=", kby)  //kby değeri
	fmt.Println("kby pointer address=", &kby)

	fmt.Println("***********")

	incrWithPointer(&kby)
	fmt.Println("kby=", kby)  //kby değeri
	fmt.Println("kby pointer address=", &kby)
}

func incr(p int) {
	p += 1
	fmt.Println("p value=", p) //p değeri
	fmt.Println("p pointer address=", &p)  //p bellek adresi
}

func incrWithPointer(p* int) {
	*p += 1
	fmt.Println("p value=", *p) //p değeri
	fmt.Println("p pointer address=", p)  //p bellek adresi
}

func fonsiyon_adi(parametre_adi parametre_tipi) donus_degeri  {
	
}

Yukarıdaki kod örneğinden de anlayacağınız üzere; bir fonksiyon func anahtar sözcüğü ile başlar, fonksiyon adı ile devam eder. Parametre var ise parametre adı, parametre tipi ve son olarak fonksiyonun dönüş tipi belirtilir.

Şimdi dışarıdan iki tane integer parametre alıp, onların ortalamalarını dönen bir fonksiyon yazalım.

package main

import "fmt"

func main()  {
	val1 := 8
	var val2 int = 2

	avg := GetAvg(val1,val2)

	fmt.Println(avg)
}

func GetAvg(val1 int, val2 int) int  {
	return (val1+val2)/2

}

Golang’de fonksiyonlar birden fazla değer dönebilir. Şimdi ad ve soyadı aynı anda dönen bir fonksiyon yazalım. Ardından bu fonksiyondan dönen değerleri, değişkenlere set edip ekrana yazdıralım.

package main

import "fmt"

func main()  {
	val1,val2 := SetNames()

	fmt.Println(val1)
	fmt.Println(val2)
}


func SetNames() (string,string)  {
	name := "Burak"
	surname := "Yılmaz"

	return name,surname
}

Aşağıdaki örnekten de göreceğiniz gibi değişkenleri farklı tarzlarda tanımladık ve ekrana yazdırdık. Hepsinin çıktılarının aynı olduğunu göreceksiniz.

package main

import "fmt"

func main()  {
	//Tarz 1
	var name1 string = "Burak Yılmaz"

	//Tarz 2
	var name2 = "Burak Yılmaz"

	//Tarz 3
	name3 := "Burak Yılmaz"

	fmt.Println(name1)
	fmt.Println(name2)
	fmt.Println(name3)
}

Daha önce tanımladığımız bir değişkeni yeniden initialize etmeye çalıştığımızda aşağıdaki şekilde hata verecektir. Aşağıda name3 değişkenini yeniden tanımlamaya çalıştığımızda hata aldık.

Unit test(birim test), adından anlayacağımız üzere test edilebilen en küçük birimi test eden kod blogudur. Temelde yaptığı; kodun veya sınıfın, belli girdiler ile doğru çalışıp, istenilen sonucu üretip üretmediğini kontrol etmektir. Ufak ufak parçaları test ederek, bütün bir yazılımın en azından çalıştığını görebiliyoruz.

Peki unit testler ile akış içerisindeki tüm bugları bulabilir miyiz? Hayır! Birim testler yalnızca o birimi o fonksiyonu test eder.
Unit testler yazılım testlerinin ilk adımıdır. Komple akışı test etmek için başka testler(integration test, api test vs) yapmak gerekir.

Neden yazılır?

• Başka developerlar bizim yazdığımız kodları nasıl kullanacaklarını unit testlere bakarak daha iyi anlayabilir.
• Yazdığımız hiç bir kod sonsuza kadar aynı kalmaz. Elbet bir gün refactor edilecek veya eklemeler yapılacaktır. İşte kodun burasını değiştirirsem ne olur? Nereleri patlatırım vs gibi kafamızı kurcalayan sorulardan bizi kurtarır. Kodumuzu yazdıktan sonra unit testleri çalıştırmamız yeterli olacaktır. Bize patlayan çatlayan her yeri gösterir
• Bizleri kaliteli kod yazmaya teşvik eder. Düzgün birim testler yazabilmemiz için, test edeceğimiz sınıfın bileşenleri ile gevşek bağlı(loosely coupled) olması gerekir. Böylelikle biz de testlerimizi yazarken mocking yapabiliriz. Eğer sıkı sıkıya bağlı(tightly coupled) olsaydı; ki bu yazılımda istenmeyen bir durumdur, mock object kullanamazdık. Yazılım bileşenlerini birbirlerine gevşek bağlamak için Dependency Injection yöntemini kullanabiliri

Nasıl yazılmalıdır?

• Unit testler, kodu yazan developer tarafından yazılmalıdır.
• Okunaklı olmalıdır.
• Hızlı çalışmalıdır.
• Test yazılan birim, bileşenlerinden izole edilmelidir.
• Bağımlılıklar değil, yalnızca o birim test edilmelidir.
• Yazılan her test yalnız bir senaryoyu test etmelidir.
• Yazılan testler tak başına çalışabilmeli, birbirini hiç bir şekilde etkilememelidir.
• Unit test yazarken isimlendirme çok önemlidir.Test isimleri açıklayıcı olmalıdır. Uzun olabilir. MethodName_StateUnderTest_ExpectedBehavior  şeklindeki isimlerdirme standartını kullanabiliriz.
• Test başarısız olduğunda anlaşılabilir bir data dönmelidir.

Yukarıdaki şemadan da anlayacağınız gibi ilk önce Go Runtime’ı yükleyeceğiz. Bunun için aşağıdaki adrese giderek Windows sürümünü indirmeniz ve klasik next next diyerek yüklemeyi yapmanız yeterli olacak
https://golang.org/dl/

Environmentları da aşağıdaki şekilde set ediyoruz.

Bir sonraki adım Visual Studio Code’u yüklemek. Go geliştirmek için bir sürü IDE kullanabilirsiniz ama ben VsCode kullanıyorum. Aşağıdaki adresten indirerek, kolayca yükleyebilirsiniz.
https://code.visualstudio.com/

VsCode yüklemesi bittikten sonra extension’lardan Go eklentisi yüklememiz yeterli olacaktır.

Sıra geldi ilk kodumuzu yazmaya. my-first-go-app adında bir klasör oluşturdum ve VsCode’u açtım. Gerisi aşağıda

Go nedir? Go; 2007 yılında geliştirilmeye başlanmış, Google tarafından desteklenen, açık kaynak kodlu bir programlama dilidir. İlk kararlı sürümü 2012 yılında yayınlanmıştır.

Go; basit, güvenilir ve verimli bir yazılım oluşturmayı kolaylaştıran açık kaynaklı bir programlama dilidir.

https://golang.org/

Neden geliştirildi? Google’ın yaşadığı performans, zaman, uyumluluk, derleme gibi problemleri çözmek için geliştirmiştir. Go‘nun bir çok avantajı olduğu gibi, dezavantajları da var. Generics ve error handling olmaması dezavantaj gibi gözükmekte fakat bu özellikler performans kaybına sebep olduğu için bilerek konulmamış. Hatta performanslı çalışacağı bir yol bulmadıkça da eklemeyeceklermiş.

Neden öğrenmeliyiz? E öğrenmesi çok kolay Java veya C#’da olduğu gibi OOP’un derinliklerinde kaybolmuyor tam aksine kod yazarken şöyle bir ohhh diyorsunuz.

• İçerisinde sadece 25 tane keyword var :

break     default      func    interface  select
case      defer        go      map        struct
chan      else         goto    package    switch
const     fallthrough  if      range      type
continue  for          import  return     var

• Performans odaklı
• Tek bir binary dosyasına derlenir ve bunu çalıştığı sisteme göre yapar. Bağımlılığı yoktur ve runtime’ı içinde gelir. Yalnız bu durumda da output olarak çıkan bu dosyanın büyük olma gibi bir durum ortaya çıkıyor.
• Native olarak gelen concurreny mimarisi gerçekten etkileyici. Channel denilen kavramlar üzerinden aynı anda birden fazla fonksiyon çalıştırılabiliyoruz. Bu konuyu daha sonra derinlemesine inceleyelim bence