与GO，CHI，POSTGRE和SQLX一起使用API-DEV365 开发者社区

这是较早的REST API with Go, Chi and InMemory Store的延续。在本教程中，我将扩展服务以将数据存储在Postgres数据库中。我将使用Docker运行Postgres并运行数据库迁移。

项目设置

我将首先复制https://github.com/kashifsoofi/blog-code-samples/tree/main/movies-api-with-go-chi-and-memory-store的内容，将其放置在新文件夹movies-api-with-go-chi-and-postgres中，然后在go.mod中更新模块名称，以匹配新文件夹并在使用的源文件中更新。这通常是您的git repo的根源，并且不会像这样详细说明。

设置数据库服务器

我将使用Docker-Compose在Docker容器中运行Postgres。这将使我们添加更多的服务，例如，我们的REST API在例如REDIS服务器用于分布式缓存。

让我们从添加一个名为docker-compose.dev-env.yml的新文件开始，随时随意命名它。添加以下内容以添加电影REST API的数据库实例。

version: '3.7'

services:
  movies.db:
    image: postgres:14-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=Password123
      - POSTGRES_DB=moviesdb
    volumes:
      - moviesdbdata:/var/lib/postgresql/data/
    ports:
      - “5432:5432”
    restart: on-failure
    healthcheck:
      test: [ “CMD-SHELL”, “pg_isready -q -d moviesdb -U Password123“]
      timeout: 10s
      interval: 5s
      retries: 10

volumes:
  moviesdbdata:

在docker-compose文件为位置并执行以下命令以启动数据库服务器的解决方案的根部打开一个终端。

docker-compose -f docker-compose.dev-env.yml up -d

数据库迁移

在开始使用Postgres之前，我们需要创建一个表以存储数据。我将使用出色的migrate数据库迁移工具，也可以将其导入为图书馆。

对于迁移，我创建了一个文件夹db和另一个名为migrations的文件夹。我执行了以下命令创建迁移的命令。

migrate create -ext sql -dir db/migrations -seq extension_uuid_ossp_create
migrate create -ext sql -dir db/migrations -seq table_movies_create

这将创建4个文件，对于每个迁移，都会有一个up，并且一个down脚本，在应用迁移时将执行up，并且在返回更改时将执行down。

。

000001_extension_uuid_ossp_create.up.sql

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

000001_extension_uuid_ossp_create.down.sql

DROP EXTENSION IF EXISTS "uuid-ossp";

000002_table_movies_create.up.sql

CREATE TABLE IF NOT EXISTS movies (
    id uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
    title VARCHAR(100) NOT NULL,
    director VARCHAR(100) NOT NULL,
    release_date TIMESTAMP NOT NULL,
    ticket_price DECIMAL(12, 2) NOT NULL,
    created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (now() AT TIME ZONE 'utc') NOT NULL,
    updated_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (now() AT TIME ZONE 'utc') NOT NULL
)

000002_table_movies_create.down.sql

DROP TABLE IF EXISTS movies;

i通常会创建一个具有所有数据库迁移和执行这些迁移的工具的容器。运行数据库迁移的Dockerfile如下

FROM migrate/migrate

# Copy all db files
COPY ./migrations /migrations

ENTRYPOINT [ "migrate", "-path", "/migrations", "-database"]
CMD ["postgresql://postgres:Password123@movies.db:5432/moviesdb?sslmode=disable up"]

在docker-compose.dev-env.yml文件中添加以下内容以添加迁移容器并在启动时运行迁移。请记住，如果您添加了新的迁移，则需要删除容器和movies.db.migrations图像以在容器中添加新的迁移文件。

  movies.db.migrations:
    depends_on:
      - movies.db
    image: movies.db.migrations
    build:
      context: ./db/
      dockerfile: Dockerfile
    command: "postgresql://postgres:Password123@movies.db:5432/moviesdb?sslmode=disable up"

在项目的根部打开一个终端，其中Docker-Compose文件的位置并执行以下命令以启动数据库服务器并应用迁移以创建uuid-ossp扩展名和movies表。

docker-compose -f docker-compose.dev-env.yml up -d

Postgres电影商店

我将使用sqlx执行查询和映射列到struct字段，反之亦然，sqlx是一个库，它在GO的标准database/sql库中提供了一组扩展名。

添加一个名为postgres_movies_store.go的新文件。添加一个包含databaseUrl的新结构PostgresMoviesStore和一个指向sqlx.DB的指针，还将助手方法添加到connect到数据库和close连接。

package store

import (
    "context"
    "movies-api/store"

    _ "github.com/jackc/pgx/stdlib"
    "github.com/jmoiron/sqlx"
)

const driverName = "pgx"

type PostgresMoviesStore struct {
    databaseUrl string
    dbx         *sqlx.DB
}

func NewPostgresMoviesStore(databaseUrl string) *PostgresMoviesStore {
    return &PostgresMoviesStore{
        databaseUrl: databaseUrl,
    }
}

func (s *PostgresMoviesStore) connect(ctx context.Context) error {
    dbx, err := sqlx.ConnectContext(ctx, driverName, s.databaseUrl)
    if err != nil {
        return err
    }

    s.dbx = dbx
    return nil
}

func (s *PostgresMoviesStore) close() error {
    return s.dbx.Close()
}

添加DB标签

在movies_store.go文件中更新Movie struct以添加数据库标签，这允许SQLX映射结构成员到列名。

type Movie struct {
    ID          uuid.UUID
    Title       string
    Director    string
    ReleaseDate time.Time `db:"release_date"`
    TicketPrice float64   `db:"ticket_price"`
    CreatedAt   time.Time `db:"created_at"`
    UpdatedAt   time.Time `db:"updated_at"`
}

语境

我们没有在较早的样本中使用Context，因为我们正在连接到外部存储和软件包，我们将用于运行查询方法接受Context我们将更新我们的store.Interface以接受Context并使用Context并使用运行查询时。 store.Interface将进行以下更新

type Interface interface {
    GetAll(ctx context.Context) ([]Movie, error)
    GetByID(ctx context.Context, id uuid.UUID) (Movie, error)
    Create(ctx context.Context, createMovieParams CreateMovieParams) error
    Update(ctx context.Context, id uuid.UUID, updateMovieParams UpdateMovieParams) error
    Delete(ctx context.Context, id uuid.UUID) error
}

我们还需要更新MemoryMoviesStore方法以接受Context以满足store.Interface的更改和更新movies_handler中的方法，以在调用store方法时使用r.Context()传递请求上下文。

。

创造

我们使用connect助手方法连接到数据库，创建一个Movie的新实例，然后使用NamedExecContext插入查询。如果SqlState为23505，我们正在处理error并返回DuplicateKeyError。如果插入成功，我们返回nil。
创建功能看起来像

func (s *PostgresMoviesStore) Create(ctx context.Context, createMovieParams CreateMovieParams) error {
    err := s.connect(ctx)
    if err != nil {
        return err
    }
    defer s.close()

    movie := Movie{
        ID:          createMovieParams.ID,
        Title:       createMovieParams.Title,
        Director:    createMovieParams.Director,
        ReleaseDate: createMovieParams.ReleaseDate,
        TicketPrice: createMovieParams.TicketPrice,
        CreatedAt:   time.Now().UTC(),
        UpdatedAt:   time.Now().UTC(),
    }

    if _, err := s.dbx.NamedExecContext(
        ctx,
        `INSERT INTO movies
            (id, title, director, release_date, ticket_price, created_at, updated_at)
        VALUES
            (:id, :title, :director, :release_date, :ticket_price, :created_at, :updated_at)`,
        movie); err != nil {
        if strings.Contains(err.Error(), "SQLSTATE 23505") {
            return &DuplicateKeyError{ID: createMovieParams.ID}
        }
        return err
    }

    return nil
}

得到所有

我们使用connect助手方法连接到数据库，然后使用sqlx的SelectContext方法执行查询，sqlx将将列映射到字段。如果查询成功，那么我们返回已加载的电影的切片。

func (s *PostgresMoviesStore) GetAll(ctx context.Context) ([]Movie, error) {
    err := s.connect(ctx)
    if err != nil {
        return nil, err
    }
    defer s.close()

    var movies []Movie
    if err := s.dbx.SelectContext(
        ctx,
        &movies,
        `SELECT
            id, title, director, release_date, ticket_price, created_at, updated_at
        FROM movies`); err != nil {
        return nil, err
    }

    return movies, nil
}

GetByid

我们使用connect助手方法连接到数据库，然后使用GetContext方法执行选择查询，sqlx将列将列映射到字段。如果驾驶员返回sql.ErrNoRows，则我们返回store.RecordNotFoundError。如果返回了成功的加载movie记录。

func (s *PostgresMoviesStore) GetByID(ctx context.Context, id uuid.UUID) (Movie, error) {
    err := s.connect(ctx)
    if err != nil {
        return Movie{}, err
    }
    defer s.close()

    var movie Movie
    if err := s.dbx.GetContext(
        ctx,
        &movie,
        `SELECT
            id, title, director, release_date, ticket_price, created_at, updated_at
        FROM movies
        WHERE id = $1`,
        id); err != nil {
        if err != sql.ErrNoRows {
            return Movie{}, err
        }

        return Movie{}, &RecordNotFoundError{}
    }

    return movie, nil
}

更新

我们使用connect助手方法连接到数据库，然后使用NamedExecContext方法执行查询以更新现有记录。

func (s *PostgresMoviesStore) Update(ctx context.Context, id uuid.UUID, updateMovieParams UpdateMovieParams) error {
    err := s.connect(ctx)
    if err != nil {
        return err
    }
    defer s.close()

    movie := Movie{
        ID:          id,
        Title:       updateMovieParams.Title,
        Director:    updateMovieParams.Director,
        ReleaseDate: updateMovieParams.ReleaseDate,
        TicketPrice: updateMovieParams.TicketPrice,
        UpdatedAt:   time.Now().UTC(),
    }

    if _, err := s.dbx.NamedExecContext(
        ctx,
        `UPDATE movies
        SET title = :title, director = :director, release_date = :release_date, ticket_price = :ticket_price, updated_at = :updated_at
        WHERE id = :id`,
        movie); err != nil {
        return err
    }

    return nil
}

删除

我们使用connect助手方法连接到数据库，然后执行查询以使用ExecContext删除现有记录。

func (s *PostgresMoviesStore) Delete(ctx context.Context, id uuid.UUID) error {
    err := s.connect(ctx)
    if err != nil {
        return err
    }
    defer s.close()

    if _, err := s.dbx.ExecContext(
        ctx,
        `DELETE FROM movies
        WHERE id = $1`, id); err != nil {
        return err
    }

    return nil
}

数据库配置

在config.go中添加一个名为Database的新结构

type Configuration struct {
    HTTPServer
    Database
}
...
type Database struct {
    DatabaseURL        string `envconfig:"DATABASE_URL" required:"true"`
    LogLevel           string `envconfig:"DATABASE_LOG_LEVEL" default:"warn"`
    MaxOpenConnections int    `envconfig:"DATABASE_MAX_OPEN_CONNECTIONS" default:"10"`
}

依赖注入

更新main.go如下所示，以创建PostgresMoviesStore的新实例，我选择创建PostgresMoviesStore的实例，而不是MemoryMoviesStore，可以增强解决方案以基于配置创建一个依赖性。

// store := store.NewMemoryMoviesStore()
store := store.NewPostgresMoviesStore(cfg.DatabaseURL)

测试

我没有为本教程添加任何单元或集成测试，也许是以下教程。但是所有终点都可以使用邮递员进行测试，以通过以下来自previous article的测试计划进行测试。

您可以通过执行以下
来启动使用Postgres的REST API

DATABASE_URL=postgresql://postgres:Password123@localhost:5432/moviesdb?sslmode=disable go run main.go

来源

演示应用程序的源代码托管在blog-code-samples存储库的GitHub上。

参考

没有特定顺序