Scribd
Upload
14 views8 pages

Go Programming Language Tutorial (Part 4)

A Go Programming Language Tutorial (Part 4)

Uploaded by

eowug
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
14 views8 pages

Go Programming Language Tutorial (Part 4)

A Go Programming Language Tutorial (Part 4)

Uploaded by

eowug
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Go Programming Language Tutorial (Part 4)

This tutorial dives into code organization, dependency injection, advanced concurrency patterns,
profiling and performance optimization, logging, and deployment strategies.

1. Advanced Code Organization


Project Structure
Organizing your code properly is crucial for scalability. Here's a typical structure for a production-
grade Go application:
go
Copy code
myapp/
├── cmd/
│ └── myapp/
│ └── main.go
├── pkg/
│ ├── user/
│ │ ├── user.go
│ │ ├── service.go
│ │ └── repository.go
│ └── utils/
│ └── utils.go
├── internal/
│ └── config/
│ └── config.go
├── api/
│ ├── handlers.go
│ └── routes.go
├── go.mod
└── go.sum

Best Practices
1. Use cmd/ for entry points of your application.
2. Place reusable code in pkg/ and restrict internal use with internal/.
3. Group files by domain (e.g., user, auth).

Example: Config Management


File: internal/config/config.go
go
Copy code
package config

import (
"github.com/spf13/viper"
)
type Config struct {
Port string
Database struct {
Host string
Port int
Username string
Password string
Name string
}
}

func LoadConfig() (*Config, error) {


viper.SetConfigFile("config.yaml")
if err := viper.ReadInConfig(); err != nil {
return nil, err
}
var config Config
if err := viper.Unmarshal(&config); err != nil {
return nil, err
}
return &config, nil
}

2. Dependency Injection (DI)


Dependency injection improves testability and maintainability by separating dependencies.

Example: Injecting Repositories


go
Copy code
package main

import "fmt"

// Repository Interface
type Repository interface {
FetchData() string
}

// Implementation of Repository
type DBRepository struct{}

func (db DBRepository) FetchData() string {


return "Data from database"
}

// Service Layer
type Service struct {
repo Repository
}

func (s Service) Process() {


fmt.Println(s.repo.FetchData())
}
func main() {
repo := DBRepository{}
service := Service{repo: repo}
service.Process()
}

3. Advanced Concurrency Patterns


Rate Limiting
Rate limiting is essential for preventing overuse of resources.

Token Bucket Implementation


go
Copy code
package main

import (
"fmt"
"time"
)

type RateLimiter struct {


tokens int
maxTokens int
refillRate time.Duration
refillTimer *time.Ticker
}

func NewRateLimiter(maxTokens int, refillRate time.Duration) *RateLimiter {


rl := &RateLimiter{
tokens: maxTokens,
maxTokens: maxTokens,
refillRate: refillRate,
refillTimer: time.NewTicker(refillRate),
}
go func() {
for range rl.refillTimer.C {
if rl.tokens < rl.maxTokens {
rl.tokens++
}
}
}()
return rl
}

func (rl *RateLimiter) Allow() bool {


if rl.tokens > 0 {
rl.tokens--
return true
}
return false
}
func main() {
rl := NewRateLimiter(5, time.Second)
for i := 0; i < 10; i++ {
fmt.Println("Request", i+1, "allowed:", rl.Allow())
time.Sleep(200 * time.Millisecond)
}
}

4. Profiling and Performance Optimization


Profiling with pprof
Use net/http/pprof for profiling.

Add Profiling to Your App


go
Copy code
package main

import (
"net/http"
_ "net/http/pprof"
)

func main() {
go func() {
http.ListenAndServe(":6060", nil)
}()
// Your application logic
}

Run Profiling
bash
Copy code
go tool pprof http://localhost:6060/debug/pprof/profile

Benchmark Testing
Use the testing package for benchmarks.
go
Copy code
package main

import "testing"

func Add(a, b int) int {


return a + b
}

func BenchmarkAdd(b *testing.B) {


for i := 0; i < b.N; i++ {
Add(1, 2)
}
}

Run the benchmark:


bash
Copy code
go test -bench=.

5. Logging
Using log Package
go
Copy code
package main

import (
"log"
"os"
)

func main() {
file, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
logger := log.New(file, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
logger.Println("Application started")
}

Structured Logging with zap


Install:
bash
Copy code
go get go.uber.org/zap

Example:
go
Copy code
package main

import (
"go.uber.org/zap"
)

func main() {
logger, _ := zap.NewProduction()
defer logger.Sync()

logger.Info("Starting application",
zap.String("environment", "production"),
zap.Int("version", 1),
)
}

6. Building REST APIs


Use the gorilla/mux router for building REST APIs.

Example API
go
Copy code
package main

import (
"encoding/json"
"net/http"
"github.com/gorilla/mux"
)

type User struct {


ID int `json:"id"`
Name string `json:"name"`
}

var users = []User{{ID: 1, Name: "John Doe"}}

func getUsers(w http.ResponseWriter, r *http.Request) {


json.NewEncoder(w).Encode(users)
}

func main() {
r := mux.NewRouter()
r.HandleFunc("/users", getUsers).Methods("GET")
http.ListenAndServe(":8080", r)
}

7. Deployment
Cross-Compiling
Go makes it easy to compile for different platforms:
bash
Copy code
GOOS=linux GOARCH=amd64 go build -o myapp
Dockerizing Go Applications
1. Create a Dockerfile:
dockerfile
Copy code
FROM golang:1.19
WORKDIR /app
COPY . .
RUN go build -o main .
CMD ["./main"]

2. Build and run:


bash
Copy code
docker build -t myapp .
docker run -p 8080:8080 myapp

8. Monitoring and Observability


Using Prometheus
Install the prometheus/client_golang library:
bash
Copy code
go get github.com/prometheus/client_golang/prometheus

Add a simple metric:


go
Copy code
package main

import (
"net/http"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
)

var requestCount = prometheus.NewCounter(


prometheus.CounterOpts{
Name: "http_requests_total",
Help: "Total number of HTTP requests",
},
)

func main() {
prometheus.MustRegister(requestCount)

http.Handle("/metrics", promhttp.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
requestCount.Inc()
w.Write([]byte("Hello, World!"))
})

http.ListenAndServe(":8080", nil)
}

This tutorial provides a roadmap for building production-ready applications in Go. Master these
techniques, and you’ll be well-equipped to handle scalability, maintainability, and performance in your
projects.

You might also like