GUI (Grafiksel Kullanıcı Arayüzü)
Gin Web Kütüphanesi
Gin Go'da yazılmış bir web kütüphanesidir. Performans ve üretkenlik odaklıdır. Sizlere basitçe web sunucu ve api oluşturmanız için kolaylık sağlar.
Kurulum için:
go get -u github.com/gin-gonic/gin
Daha sonra yine aynı yöntemle projemize dahil edebiliriz.
1
import "github.com/gin-gonic/gin"
Copied!
Basit bir web sunucu oluşturma örneği:
1
package main
2
3
import (
4
// kütüphanemizi içeri aktaralım
5
"github.com/gin-gonic/gin"
6
)
7
8
func main() {
9
//gin'in varsayılan ayarlarında bir yönlendirici oluşturalım.
10
router := gin.Default()
11
12
//anasayfayı inde fonksiyonumuz yakalayacak
13
router.GET("/", index)
14
15
//daha sonra sunucuyu başlatıyoruz
16
router.Run()
17
}
18
19
//anasayfayı yakalayacak olan fonksiyonumuz
20
func index(c *gin.Context) {
21
//c ile gin nesnemize bağlam oluşturduk.
22
//c'yi kullanarak artık gin özelliklerine erişebiliriz.
23
24
//sayfaya düz yazı gönderdik
25
c.String(200, "Merhaba Dünya")
26
//Buradaki 200 sunucudan bir cevap geldiğini anlamına gelir
27
}
Copied!
Programımızı çalıştırdığımızda aşağıdaki gibi konsol çıktısı alacağız.
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
  • using env: export GIN_MODE=release
  • using code: gin.SetMode(gin.ReleaseMode)
[GIN-debug] GET / --> main.index (3 handlers) [GIN-debug] Listening and serving HTTP on :8080
Bu çıktıyı incelediğimizde, Gin'in debug (hata ayıklama) modunda çalıştığını söylüyor ve hemen aşağısında sunucumuz ürün haline gelince Gin'i Release Moduna nasıl alacağımızı gösteriyor. Son olarak ise web sunucumuzun 8080 portunda çalıştığınız gösteriyor.
Yukarıdaki örnekte web sunucumuz varsayılan olarak 8080 protunda çalışacaktır. Bunun sebebi router.Run()'a parametre olarak port numarası vermememizdir.
Örneğe göre http://localhost:8080 adresine gittiğimizde komut satırında yeni detaylar belirecek. Tıpkı aşağıdaki gibi:
Komut satırı bilgisi
Bu bilgileri inceleyelim. İlk kayıt anasayfaya bağlanılmaya çalışıldığında alınmış. Bu kayıtta bağlantının zamanını, durum kodunu, bağlantı süresi, bağlantı yöntemini ve hangi adrese bağlantı denendiğini yazıyor. Hemen altındaki ise sitenin ikonuna istek yapmış fakat site ikonumuz bulunmadığı için 404 durum kodunu almış. Bu kısımdan da bağlantı isteklerini görebildiğimizi öğrenmiş olduk.

🔘 Çıktı Tipleri

➡️ JSON Çıktı Verme

1
func index(c *gin.Context) {
2
//JSON Fonksiyonunu kullanıyoruz.
3
c.JSON(200, gin.H{
4
"ad": "kaan",
5
"soyad": "kuşcu",
6
})
7
}
Copied!
Sonucumuz aşağıdaki gibi olacaktır.
JSON çıktısı

➡️ XML Çıktı Verme

1
//xml için örnek bir yapı oluşturalım
2
type xmlYapı struct {
3
Ad string `xml:"ad"`
4
Soyad string `xml:"soyad"`
5
}
6
7
//anasayfayı yakalayacak olan fonksiyonumuz
8
func index(c *gin.Context) {
9
//xml için örnek bir nesne oluşturduk
10
xmlOrnek := xmlYapı{"kaan", "kuşcu"}
11
12
//xml başlığını gönderelim
13
c.Writer.WriteString(xml.Header) //<?xml version="1.0" encoding="UTF-8"?>
14
15
//xml nesnesini XML fonksiyonu ile yolladık
16
c.XML(200, xmlOrnek)
17
}
Copied!
Bu kodlar sonucunda sayfamızı açtığımızda "kaankuşcu" sonucu göreceğiz. XML tipinde görmek için sayfanıza sağ tıklayıp "Sayfa Kaynağını Gör"e tıklayarak kontrol edebilirsiniz.
XML sonucu

➡️ Template Kullanımı

Template hakkında bilginiz yoksa önce aşağıdaki dökümanı okumanız önerilir.
Gin'de template (şablon) işlemleri bayağı kolaylaştırılmış. Ufak bir örnek uygulama yazalım. Öncelikle projemizin ana dizinine templates isimli bir klasör oluşturalım ve içerisine index.html dosyası oluşturalım. index.html dosyamızın içeriği ise aşağıdaki gibi olsun.
1
<html>
2
<h1>
3
{{ .başlık }}
4
</h1>
5
</html>
Copied!
Burada {{ .başlık }} yerine Go'dan değer göndereceğiz.
main.go dosyamız ise aşağıdaki gibi olsun.
1
package main
2
3
import (
4
"github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
router := gin.Default()
9
10
//Burada templates klasörünün içindeki tüm şablonları
11
//yüklemesini isteyelim.
12
router.LoadHTMLGlob("templates/*")
13
14
router.GET("/", index)
15
16
router.Run()
17
}
18
19
func index(c *gin.Context) {
20
21
//HTML şablonunu almak için
22
//HTML fonksiyonunu kullanıyoruz.
23
c.HTML(200, "index.html", gin.H{
24
//Şablondaki başlık yerine Anasayfa yazısını yollayalım.
25
"başlık": "Anasayfa",
26
})
27
}
Copied!
Web sunucumuza bağlandığımızda ise Anasayfa yazdığını görebiliriz.

🔘 Statik Dosyaları Yayınlama

Web sunucumuzda kullanacağımız Css, JS vb. statik dosyalarımız olabilir. Bunun için Static fonksiyonunu kullanabiliriz.
Statik dosyalarımızı projemizin ana dizindeki statik klasöründe barındırdığımızı varsayalım.
1
func main() {
2
router := gin.Default()
3
4
//(yönlendirme, klasör-ismi)
5
router.Static("/static", "./statik")
6
7
router.GET("/", index)
8
9
router.Run(":9000")
10
}
Copied!
statik klasörümüzün içerisinde index.js adında bir dosya olduğunu varsayarsak http://localhost:9000/static/index.js adresinden ulaşabiliriz.

🔘 Bağlantı Metodları

Örnek bağlantı oluştururken GET metoduna değindik. Metodları test ediyorken Postman'i kullanabilirsiniz. Ben bu konuda curl komut satırı aracını kullanacağım. Detaylarına bakacak olursak:

➡️ GET Metodu

GET metodu web sunucumuza normal bağlantı yapılırken kullanılır. Hazır bir kaynağı yüklemek için kullanılır.
1
router.GET("/", index)
Copied!
index fonksiyonu ile GET metodlu anasayfayı yakalayabilirsiniz.

➡️ POST Metodu

POST metodu genellikle form gönderimlerinde kullanılır. Yeni bir kaynak oluşturmak için kullanılır. (Yeni kayıt oluşturma, yeni gönderi oluşturma vb...)
Örnek kullanımını görelim.
1
package main
2
3
import (
4
"github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
router := gin.Default()
9
10
//Burada templates klasörünün içindeki tüm şablonları
11
//yüklemesini isteyelim.
12
router.LoadHTMLGlob("templates/*")
13
14
router.GET("/", getIndex)
15
router.POST("/", postIndex)
16
17
router.Run(":9000")
18
}
19
20
func getIndex(c *gin.Context) {
21
c.String(200, "GET metodu ile bağlanıldı.")
22
}
23
24
func postIndex(c *gin.Context) {
25
c.String(200, "POST metodu ile bağlanıldı.")
26
}
Copied!
Yukarıdaki örnekte anasayfa GET ile bağlanıldığında getIndex, POST ile bağlanıldığında postIndex fonksiyonu çalışacak. Tarayıcımızdan girdiğimizde "GET metodu ile bağlanıldı." yazısını görürüz. POST metodu ile bağlanmak için komut satırına şu komutları yazalım.
curl -X POST http://localhost:9000
Çıktısı "POST metodu ile bağlanıldı." olacaktır.
POST metodu üzerinden değer almayı görelim.
1
//json verisi için yapımız
2
type kişi struct {
3
Ad string `json:"ad"`
4
Soyad string `json:"soyad"`
5
}
6
7
func postIndex(c *gin.Context) {
8
//posttan gelen json'ın kaydedileceği değişken
9
var postkişi kişi
10
11
//postan gelen json'ı postkişi'ye atayalım
12
c.BindJSON(&postkişi)
13
14
15
c.String(200, "JSON Veri:")
16
//json'ı tekrar post ile gösterelim
17
c.JSON(200, postkişi)
18
}
Copied!
Komut satırına aşağıdaki komutu yazarak çıktısını görebilirsiniz.
curl -X POST -H "Content-Type: application/json" -d '{"ad":"kaan","soyad":"kuşcu"}' http://localhost:9000

➡️ Diğer Metodlar

Diğer metodlardan kısaca bahsedelim:
  • PATCH metodu: Bir kaynak üzerindeki belirli bir alanı değiştirmek için kullanılır.
  • DELETE metodu: Sunucudaki bir kaynağı silmeye yarar.
  • PUT metodu: Bir kaynağın yerine başka bir kaynağı koymaya yarar. (Komple değiştirme)
  • HEAD metodu: Sunucuya tıpkı GET metodu gibi fakat sadece başlığı olan bir istek gönderir.
  • OPTIONS metodu: Sunucunun desteklediği metodları kontrol etmek için kullanılır.

🔘 Adreslendirme

➡️ Parametre ile Adreslendirme

Örneğin:
Gin parametre örneği
1
package main
2
3
import (
4
"github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
router := gin.Default()
9
10
router.GET("/blog/:yazı", blog)
11
//Buradaki :yazı bizim parametremiz
12
//Bu parametre ile hangi blog yazısını
13
//göstereceğimizi belirleyeceğiz.
14
15
router.Run(":9000")
16
}
17
func blog(c *gin.Context) {
18
//yazı parametresininde geleni sayfaİsmi değişkenine atayalım.
19
sayfaİsmi := c.Param("yazı")
20
c.String(200, "Şuanda "+sayfaİsmi+" blogunu okuyorsunuz.")
21
}
Copied!
Yukarıdaki örneğe göre http://localhost:9000/blog/gin%20ile%20sunucu%20geli%C5%9Ftirme adresine gittiğimizde "Şuanda gin ile sunucu geliştirme blogunu okuyorsunuz." yazısı ile karşılacağız.
Tabi ki birden fazla parametre ekleyebilirsiniz.
1
package main
2
3
import (
4
"github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
router := gin.Default()
9
10
router.GET("/blog/:yazar/:yazı", blog)
11
12
router.Run(":9000")
13
}
14
func blog(c *gin.Context) {
15
yazar := c.Param("yazar")
16
yazı := c.Param("yazı")
17
c.String(200, "Yazar: "+yazar+" Yazı: "+yazı)
18
}
Copied!

➡️ Querystring (Sorgu dizesi) ile Adreslendirme

Örneğin:
Gin sorgu sizesi örneği
1
package main
2
3
import (
4
"github.com/gin-gonic/gin"
5
)
6
7
func main() {
8
router := gin.Default()
9
10
router.GET("/arama", arama)
11
12
router.Run(":9000")
13
}
14
func arama(c *gin.Context) {
15
tür := c.Query("tur")
16
sıralama := c.Query("siralama")
17
c.String(200, tür+" türünden filmler "+sıralama+" olarak sıralanıyor.")
18
}
Copied!
Yukarıdaki örneğe göre http://localhost:9000/arama?tur=bilim-kurgu&siralama=imdb adresine girdiğimizde "bilim-kurgu türünden filmler imdb olarak sıralanıyor." yazılı bir sonuç elde edeceğiz.

Göz atmanızı önerdiğim yazı:

https://kaanksc.com/go-web-sunucuda-kullanici-girisi-sistemi
kaanksc.com
Last modified 10mo ago