มาลองประยุกต์ใช้ Pattern ต่างๆ

package main

import (
  "fmt"
  "time"
)

func main() {
  // สร้าง channel เพื่อส่งข้อความ
  ch := make(chan string)

  // สร้าง goroutine เพื่อส่งข้อความไปยัง channel
  go func() {
    for i := 0; i < 10; i++ {
      ch <- fmt.Sprintf("Hello, world! %d", i)
      time.Sleep(1 * time.Second)
    }
  }()

  // สร้าง goroutine เพื่อรับข้อความจาก channel
  go func() {
    for {
      msg := <-ch
      fmt.Println(msg)
    }
  }()

  // รอให้ goroutines ทำงานเสร็จสิ้น
  time.Sleep(5 * time.Second)
}

go get github.com/gofiber/fiber/v2

package main

import (
  "fmt"
  "github.com/gofiber/fiber/v2"
)

var pubsub = &PubSub{
  Subscribers: make(map[uint]*Subscriber),
}

const (
  host     = "localhost"  // or the Docker service name if running in another container
  port     = 5432         // default PostgreSQL port
  user     = "myuser"     // as defined in docker-compose.yml
  password = "mypassword" // as defined in docker-compose.yml
  dbname   = "mydatabase" // as defined in docker-compose.yml
)

func main() {
  app := fiber.New()

  // Start a subscription routine
  go func() {
    subscriber := pubsub.Subscribe()
    defer pubsub.Unsubscribe(subscriber.ID)

    for msg := range subscriber.Channel {
      // Handle the message, e.g., log, process, etc.
      fmt.Printf("Received message: %s\n", msg.Content)
    }
  }()

  // Publish endpoint
  app.Post("/publish", func(c *fiber.Ctx) error {
    var msg Message
    if err := c.BodyParser(&msg); err != nil {
      return err
    }

    go pubsub.Publish(msg)
    return c.SendString("Message published")
  })

  app.Listen(":8888")
}

package main

import (
  "sync"
)

// Message represents a simple message structure
type Message struct {
  Content string
}

// Subscriber represents a subscriber to a topic
type Subscriber struct {
  ID      uint `gorm:"primaryKey"`
  Channel chan Message
}

// PubSub represents the publish/subscribe mechanism
type PubSub struct {
  mu           sync.RWMutex
  Subscribers  map[uint]*Subscriber
  subscriberID uint
}

func (ps *PubSub) Subscribe() *Subscriber {
  ps.mu.Lock()
  defer ps.mu.Unlock()

  ps.subscriberID++
  subscriber := &Subscriber{
    ID:      ps.subscriberID,
    Channel: make(chan Message),
  }
  ps.Subscribers[subscriber.ID] = subscriber
  return subscriber
}

func (ps *PubSub) Unsubscribe(id uint) {
  ps.mu.Lock()
  defer ps.mu.Unlock()

  close(ps.Subscribers[id].Channel)
  delete(ps.Subscribers, id)
}

func (ps *PubSub) Publish(message Message) {
  ps.mu.RLock()
  defer ps.mu.RUnlock()

  for _, subscriber := range ps.Subscribers {
    subscriber.Channel <- message
  }
}

package main

import (
  "fmt"
  "time"
)

func main() {
  // สร้าง channel เพื่อกำหนดช่วงเวลาที่ต้องการเรียกใช้งานงาน
  ch := time.Tick(1 * time.Second)

  // สร้าง goroutine เพื่อเรียกใช้งานงานซ้ำ ๆ ในช่วงเวลาที่กำหนด
  go func() {
    for range ch {
      fmt.Println("Hello, world!")
    }
  }()

  // รอให้ goroutine ทำงานเสร็จสิ้น
  time.Sleep(5 * time.Second)
}

go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres

package main

import (
  "fmt"
  "github.com/robfig/cron/v3"
  "gorm.io/driver/postgres"
  "gorm.io/gorm"
  "log"
)

const (
  host     = "localhost"  // or the Docker service name if running in another container
  port     = 5432         // default PostgreSQL port
  user     = "myuser"     // as defined in docker-compose.yml
  password = "mypassword" // as defined in docker-compose.yml
  dbname   = "mydatabase" // as defined in docker-compose.yml
)

func main() {
  // Configure your PostgreSQL database details here
  dsn := fmt.Sprintf("host=%s port=%d user=%s "+
    "password=%s dbname=%s sslmode=disable",
    host, port, user, password, dbname)
  db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
  if err != nil {
    panic("failed to connect to database")
  }
  // Migrate the schema
  db.AutoMigrate(&ExampleModel{})
  fmt.Println("Database migration completed!")

  c := cron.New()
  _, err = c.AddFunc("@every 1m", func() {
    go task(db)
  })

  if err != nil {
    log.Fatal("Error scheduling a task:", err)
  }

  c.Start()

  // Block the main thread as the cron job runs in the background
  select {}
}

package main

import (
  "fmt"
  "gorm.io/gorm"
  "log"
  "time"
)

// ExampleModel represents a database model
type ExampleModel struct {
  gorm.Model
  Name string
}

// task is the function to be executed on a schedule
func task(db *gorm.DB) {
  now := time.Now()
  log.Println("Task is being run...", now)

  // Example database operation
  newRecord := ExampleModel{Name: fmt.Sprintf("Record at %s", now.Format(time.RFC3339))}
  db.Create(&newRecord)
}