To create a Golang REST API server with the specified requirements, follow these steps:

1. Install required packages and tools

First, make sure you have Go installed on your machine. You can download it from https://golang.org/dl/. Then, install the following packages:

- Gorilla Mux for routing: `go get -u github.com/gorilla/mux`
- pq driver for PostgreSQL: `go get -u github.com/lib/pq`

2. Set up the PostgreSQL database

Create a new PostgreSQL database and table to store book information. The SQL command should look like this:

```sql
CREATE TABLE books (
    id SERIAL PRIMARY KEY,
    title VARCHAR(100) NOT NULL,
    author VARCHAR(100) NOT NULL,
    publication_year INT NOT NULL,
    genre VARCHAR(50) NOT NULL
);
```

3. Create the main.go file

In your project folder, create a `main.go` file and import the necessary packages:

```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
	_ "github.com/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "your_user"
	password = "your_password"
	dbname   = "your_db_name"
)

type Book struct {
	ID              int    `json:"id"`
	Title           string `json:"title"`
	Author          string `json:"author"`
	PublicationYear int    `json:"publication_year"`
	Genre           string `json:"genre"`
}

var db *sql.DB

func main() {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	var err error
	db, err = sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		panic(err)
	}

	router := mux.NewRouter()
	router.HandleFunc("/books", getBooks).Methods("GET")
	router.HandleFunc("/books/{id}", getBook).Methods("GET")
	router.HandleFunc("/books", createBook).Methods("POST")
	router.HandleFunc("/books/{id}", updateBook).Methods("PUT")
	router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

	log.Fatal(http.ListenAndServe(":8000", router))
}
```

4. Implement the API endpoints

Now, implement the functions for each endpoint:

```go
func getBooks(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var books []Book

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books")
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	for result.Next() {
		var book Book
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
		books = append(books, book)
	}

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

func getBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books WHERE id = $1", params["id"])
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	var book Book
	for result.Next() {
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
	}

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

func createBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var book Book
	_ = json.NewDecoder(r.Body).Decode(&book)

	err := db.QueryRow("INSERT INTO books (title, author, publication_year, genre) VALUES ($1, $2, $3, $4) RETURNING id;", book.Title, book.Author, book.PublicationYear, book.Genre).Scan(&book.ID)
	if err != nil {
		panic(err.Error())
	}

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

func updateBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)
	var book Book
	_ = json.NewDecoder(r.Body).Decode(&book)

	db.Exec("UPDATE books SET title=$1, author=$2, publication_year=$3, genre=$4 WHERE id=$5", book.Title, book.Author, book.PublicationYear, book.Genre, params["id"])

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books WHERE id = $1", params["id"])
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	for result.Next() {
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
	}

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

func deleteBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	db.Exec("DELETE FROM books WHERE id = $1", params["id"])

	json.NewEncoder(w).Encode(map[string]string{"result": "success"})
}
```

5. Run the server

Now, you can run your REST API server by executing `go run main.go`. The server will listen on port 8000 and provide endpoints for adding, updating, deleting, and retrieving book information.

You can test the endpoints using tools like Postman or curl.
지정된 요구 사항을 충족하는 Golang REST API 서버를 생성하려면 다음 단계를 따르세요.

1. 필요한 패키지 및 도구 설치

먼저, 컴퓨터에 Go가 설치되어 있는지 확인합니다. https://golang.org/dl/ 에서 다운로드할 수 있습니다. 그런 다음 다음 패키지를 설치합니다:

- 라우팅용 Gorilla Mux: `go get -u github.com/gorilla/mux`
- PostgreSQL용 pq 드라이버: `go get -u github.com/lib/pq`

2. PostgreSQL 데이터베이스 설정

도서 정보를 저장할 새 PostgreSQL 데이터베이스와 테이블을 생성합니다. SQL 명령은 다음과 같아야 합니다:

```sql
CREATE TABLE books (
    id SERIAL PRIMARY KEY,
    title VARCHAR(100) NOT NULL,
    author VARCHAR(100) NOT NULL,
    publication_year INT NOT NULL,
    genre VARCHAR(50) NOT NULL
);
```

3. main.go 파일 생성

프로젝트 폴더에 `main.go` 파일을 생성하고 필요한 패키지를 가져옵니다:

```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
	_ "github.com/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "your_user"
	password = "your_password"
	dbname   = "your_db_name"
)

type Book struct {
	ID              int    `json:"id"`
	Title           string `json:"title"`
	Author          string `json:"author"`
	PublicationYear int    `json:"publication_year"`
	Genre           string `json:"genre"`
}

var db *sql.DB

func main() {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	var err error
	db, err = sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		panic(err)
	}

	router := mux.NewRouter()
	router.HandleFunc("/books", getBooks).Methods("GET")
	router.HandleFunc("/books/{id}", getBook).Methods("GET")
	router.HandleFunc("/books", createBook).Methods("POST")
	router.HandleFunc("/books/{id}", updateBook).Methods("PUT")
	router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

	log.Fatal(http.ListenAndServe(":8000", router))
}
```

4. API 엔드포인트 구현

이제, 각 엔드포인트에 대한 함수를 구현합니다:

```go
func getBooks(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var books []Book

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books")
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	for result.Next() {
		var book Book
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
		books = append(books, book)
	}

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

func getBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books WHERE id = $1", params["id"])
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	var book Book
	for result.Next() {
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
	}

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

func createBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var book Book
	_ = json.NewDecoder(r.Body).Decode(&book)

	err := db.QueryRow("INSERT INTO books (title, author, publication_year, genre) VALUES ($1, $2, $3, $4) RETURNING id;", book.Title, book.Author, book.PublicationYear, book.Genre).Scan(&book.ID)
	if err != nil {
		panic(err.Error())
	}

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

func updateBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)
	var book Book
	_ = json.NewDecoder(r.Body).Decode(&book)

	db.Exec("UPDATE books SET title=$1, author=$2, publication_year=$3, genre=$4 WHERE id=$5", book.Title, book.Author, book.PublicationYear, book.Genre, params["id"])

	result, err := db.Query("SELECT id, title, author, publication_year, genre FROM books WHERE id = $1", params["id"])
	if err != nil {
		panic(err.Error())
	}
	defer result.Close()

	for result.Next() {
		err := result.Scan(&book.ID, &book.Title, &book.Author, &book.PublicationYear, &book.Genre)
		if err != nil {
			panic(err.Error())
		}
	}

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

func deleteBook(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	params := mux.Vars(r)

	db.Exec("DELETE FROM books WHERE id = $1", params["id"])

	json.NewEncoder(w).Encode(map[string]string{"result": "success"})
}
```

5. 서버 실행하기

이제 `go run main.go`를 실행하여 REST API 서버를 실행할 수 있습니다. 서버는 포트 8000에서 수신 대기하며 도서 정보 추가, 업데이트, 삭제, 검색을 위한 엔드포인트를 제공합니다.

포스트맨이나 curl과 같은 도구를 사용하여 엔드포인트를 테스트할 수 있습니다.