葡萄牙波尔图/英国伦敦高薪招聘资深Golang开发工程师 - Teya公司

葡萄牙波尔图/英国伦敦高薪招聘资深Golang开发工程师 - Teya公司 ![挥手] 大家好！

我正在寻找一位高级软件工程师加入我的团队。 我们的服务使用 Golang，现在加入正是非常有趣的时机！

Teya 正在为中小企业构建支付解决方案。我们的团队是核心——我们正在开发一项服务，旨在为所有服务提供可复用且准确的商户档案。 您的贡献将对我们数十万宝贵的商户产生显著影响。您将有机会与公司内外各个团队合作，共同塑造我们运营的支柱。

我们的技术栈 ![齿轮] Golang, Kafka, Postgres, Redis, AWS ![地球_非洲] 英国伦敦 / 葡萄牙波尔图。混合办公（每周集中办公1-2天对我们来说效果很好！） ![钱袋] ![英国] £60,000 - £90,000 ![葡萄牙] €60,000 - €90,000 ![日历] 开始日期 = 尽快

该职位在波尔图或伦敦为混合办公模式。如果您感兴趣——请联系我，我很乐意提供帮助！ 我的 LinkedIn 邮箱：oleg.zhelenkov@teya.com


更多关于葡萄牙波尔图/英国伦敦高薪招聘资深Golang开发工程师 - Teya公司的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

你好 @Oleg_Zhelenkov 我想帮助你。 请查看你的电子邮件和私信。

此致， Nicole

更多关于葡萄牙波尔图/英国伦敦高薪招聘资深Golang开发工程师 - Teya公司的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你好，奥列格，

如果你正在寻找一个软件开发人员团队，人员扩充可能也是一个选择，即使你只寻找一位，这同样可以作为一种方案。

资深Golang工程师的技术视角分析

从技术角度看，这个职位涉及的核心技术栈相当典型且成熟。以下是针对Golang开发部分的具体分析：

核心技术要点

  1. Golang在支付系统的优势
// 支付系统中典型的并发处理模式
package main

import (
    "context"
    "sync"
    "time"
)

type PaymentProcessor struct {
    mu     sync.RWMutex
    rates  map[string]float64
    redis  *RedisClient
    db     *PostgresDB
}

func (p *PaymentProcessor) ProcessBatch(ctx context.Context, payments []Payment) error {
    var wg sync.WaitGroup
    errCh := make(chan error, len(payments))
    
    for _, payment := range payments {
        wg.Add(1)
        go func(pmt Payment) {
            defer wg.Done()
            if err := p.validateAndProcess(ctx, pmt); err != nil {
                errCh <- err
            }
        }(payment)
    }
    
    wg.Wait()
    close(errCh)
    
    return p.handleErrors(errCh)
}
  1. 与Kafka的集成模式
// 使用Sarama或confluent-kafka-go的典型实现
package messaging

import (
    "github.com/Shopify/sarama"
    "log"
)

type KafkaProducer struct {
    producer sarama.SyncProducer
    topic    string
}

func (kp *KafkaProducer) SendPaymentEvent(event PaymentEvent) error {
    msg := &sarama.ProducerMessage{
        Topic: kp.topic,
        Value: sarama.ByteEncoder(event.ToJSON()),
        Key:   sarama.StringEncoder(event.MerchantID),
    }
    
    partition, offset, err := kp.producer.SendMessage(msg)
    if err != nil {
        return err
    }
    
    log.Printf("Message sent to partition %d at offset %d", partition, offset)
    return nil
}
  1. Postgres数据层设计
// 使用sqlx或pgx的数据库操作示例
package repository

import (
    "github.com/jmoiron/sqlx"
    "time"
)

type MerchantRepository struct {
    db *sqlx.DB
}

func (r *MerchantRepository) UpdateBalance(ctx context.Context, merchantID string, amount decimal.Decimal) error {
    tx, err := r.db.BeginTxx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()
    
    query := `
        UPDATE merchants 
        SET balance = balance + $1,
            updated_at = $2
        WHERE id = $3
        RETURNING balance, version
    `
    
    var result struct {
        Balance decimal.Decimal
        Version int64
    }
    
    err = tx.GetContext(ctx, &result, query, amount, time.Now(), merchantID)
    if err != nil {
        return err
    }
    
    return tx.Commit()
}

系统架构考虑

  1. 分布式事务处理
// Saga模式实现示例
type PaymentSaga struct {
    steps []SagaStep
    compensation []CompensationStep
}

func (s *PaymentSaga) Execute(ctx context.Context) error {
    for i, step := range s.steps {
        if err := step.Execute(ctx); err != nil {
            return s.compensate(ctx, i)
        }
    }
    return nil
}
  1. Redis缓存策略
// 商户档案缓存实现
type MerchantCache struct {
    redis *redis.Client
    ttl   time.Duration
}

func (mc *MerchantCache) GetProfile(merchantID string) (*MerchantProfile, error) {
    key := fmt.Sprintf("merchant:%s:profile", merchantID)
    
    // 尝试从缓存获取
    data, err := mc.redis.Get(ctx, key).Bytes()
    if err == nil {
        var profile MerchantProfile
        if err := json.Unmarshal(data, &profile); err == nil {
            return &profile, nil
        }
    }
    
    // 缓存未命中，从数据库加载
    profile, err := mc.loadFromDB(merchantID)
    if err != nil {
        return nil, err
    }
    
    // 异步更新缓存
    go mc.updateCache(merchantID, profile)
    
    return profile, nil
}

性能优化建议

  1. 连接池管理
// 数据库连接池配置
func NewDBPool() *sqlx.DB {
    db, err := sqlx.Connect("postgres", "user=...")
    if err != nil {
        log.Fatal(err)
    }
    
    // 优化连接池参数
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(25)
    db.SetConnMaxLifetime(5 * time.Minute)
    
    return db
}
  1. 监控和指标收集
// Prometheus指标集成
var (
    paymentRequests = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "payment_requests_total",
            Help: "Total payment requests",
        },
        []string{"status", "currency"},
    )
    
    processingDuration = prometheus.NewHistogram(
        prometheus.HistogramOpts{
            Name:    "payment_processing_duration_seconds",
            Help:    "Payment processing duration",
            Buckets: prometheus.DefBuckets,
        },
    )
)

func init() {
    prometheus.MustRegister(paymentRequests)
    prometheus.MustRegister(processingDuration)
}

这个职位涉及的技术栈在支付领域很常见，Golang的并发特性特别适合处理高并发的支付请求。薪资范围在两地都相当有竞争力，反映了对资深Golang工程师的市场需求。

回到顶部