728x90
반응형

Goroutine

  • Go 런타임이 관리하는 가상(논리) 쓰레드
    • go 키워드로 고루틴 실행 가능
  • 비동기적으로 함수 루틴을 수행하며, 동시 동작 수행에 사용됨
  • OS 스레드보다 훨씬 가볍고, 생성할 때 비용이 적음
    • OS 스레드는 1mb의 메모리 스택, goroutine은 kb 단위 (동적 증가 가능)
  • 기본적으로 CPU 1개를 시분할하여 사용

다중 처리

  • Go는 기본적으로 CPU 개를 사용한다
  • 다중 병렬 처리를 위해 CPU를 여러개 사용하기 위해선 GOMAXPROCS로 증가시킬 수 있다.
runtime.GOMAXPROCS(4) // CPU 4개 사용

익명함수 (go func)

  • 익명 함수 go func() {}() 으로 비동기 실행 가능
func main() {  
  var wait sync.WaitGroup // Go 루틴 대기열 두개 생성  
  wait.Add(2)


  go func (parameter string) {
      defer wait.Done()
      //
  } ("parameterValue")

  wait.Wait() // Go 루틴 끝날 때 까지 대기
 }

Graceful Shutdown

  • Go 언어에서 여러 고루틴을 운영할 때 Graceful Shutdown 로직이 필요한 이유는, Go 애플리케이션이 종료 신호를 받았을 때 하위 고루틴들이 메인 고루틴보다 먼저 종료될 가능성이 있기 때문
  • 쉽게 말하면, 작업 지시서이다

Context

  • 동시성을 관리
  • 여러 goroutine에 값을 전달
  • 취소 신호 전파
  • 분산 시스템 / 서비스 간의 상호 작용에서 아용

context.Background

  • 모든 context 의 기본이 되는 빈 context 를 반환
  • 대부분의 context 는 이를 기반으로 생성

context.TODO()

  • 아직 구현되지 않은 부분을 나타내는 context 를 반환
728x90
반응형
728x90
반응형

계기

  • Go 로 사이드 프로젝트 개발을 하다, 동적 쿼리가 필요한 경우도 많았고 동일한 유틸/함수들을 다양한 프로젝트에서 동일하게 사용해야 하는 경우가 너무나 많았다.
  • 문득 내가 모든 프로젝트들에 사용하는, 내가 만든 함수들을 패키지화 시키고 간편하게 사용하면 어떨까 생각하게 되었다.
    • 그렇게 '동적 쿼리 유틸'과 'DB 연결 및 쿼리' 유틸들을 오픈소스 패키지화 하기로 결정하였다.

버전 릴리즈

  • 우선 깃허브에 퍼블릭 레포를 파고 패키지 소스코드를 푸시 하였다.
  • 패키지를 임포트 해 사용할 것이기 때문에, 메인 함수의 패키지명은 사용할 패키지 명으로 설정해야 한다.
package gqbd

// ... 코드
  • 테스트 코드들로 각 함수및 유틸들이 원하는 리턴값을 가져오는지 검증을 진행하였다.

    • 여담이지만 <>_test.go 파일들을 테스트 코드로 인식한다.
    • t *testing.T 타입을 인자로 넘겨주면 테스트 진행할 함수로 인식된다.
  • 완료된 후 버전을 릴리즈했다. 최초 베타 테스트이므로 v0.1.0 으로 잡았다.

git tag v0.1.0
git push origin v0.1.0
  • 위처럼 레포에 v0.1.0으로 푸시를 했다면, 이제 Go 쪽에 해당 패키지와 버전을 알려주면 배포가 완료된다.
GOPROXY=proxy.golang.org go list -m github.com/<repo_owner>/<repo_name>@<version>
  • 이렇게 하면 GoDoc에서 내가 배포한 레포를 확인할 수 있다.
    • 다만 배포했다고 GoDoc이 빠르게 반영되는건 아니라는 함정.
    • 그리고 레포의 README.md 파일은 GODOC의 메인 설명 페이지로 나온다는 것.

결과

  • 아래는 내가 배포한 두가지 패키지들이다. 지속적으로 유지보수하면서 버전업 시킬 예정이다.
  • GQBD : Go-Query-Builder
  • GDCT : Go-Database-ConnecT
728x90
반응형
728x90
반응형

개요

  • 로그인 시 발급되는 access token을 쿠키에 세팅
  • 미들웨어에서 쿠키의 access token 을 검증

Cookie 세팅

  • 생성된 토큰을 쿠키에 세팅한다
func Login(res http.ResponseWriter, req *http.Request) {

    /*
        로그인 로직
    */

    accessTokenCookie := http.Cookie{
        Name: "accessToken",
        Value: accessToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    refreshTokenCookie := http.Cookie{
        Name: "refreshToken",
        Value: refreshToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    http.SetCookie(res, &accessTokenCookie)
    http.SetCookie(res, &refreshTokenCookie)

    /*
        응답 보내기
    */
}

검증 미들웨어

  • 쿠키에서 토큰을 추출해서 컨텍스트에 담는다
  • 담은 컨텍스트의 정보를 컨트롤러에서 사용한다.
// 사용자 정의 키 타입을 사용하여 컨텍스트 충돌 방지

type contextKey string

const (
    // JWT 서명에 사용할 비밀 키 (환경 변수로 관리하는 것이 좋습니다)

    // jwtSecret = configs.GlobalConfig.JwtKey // 실제 배포 시 환경 변수로 관리

    // 컨텍스트에 사용자 정보를 저장할 키
    userContextKey = contextKey("user")
)

// 사용자 정보 구조체

type User struct {
    UserId string
    UserEmail string
    UserStatus string
}

var excludeRouteList = []string{
    "/", "/api", 
    "/user/signup", "/user/login",
}

// AuthMiddleware는 accessToken 쿠키를 추출하고 JWT를 검증하는 미들웨어입니다.
func AuthMiddleware(next http.Handler) http.Handler {

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

        // 제외할 경로는 바로 다음 핸들러로 넘김
        for _, route := range excludeRouteList {
            if r.URL.Path == route {
                log.Printf("Found Match Route: %s", route)
                next.ServeHTTP(w, r)
                return
            }
        }

        // accessToken 쿠키 추출
        cookie, err := r.Cookie("accessToken")

        log.Printf("Cookie: %s", cookie)

        if err != nil {
            log.Printf("Get Cookie Error :%v", err)  

            if err == http.ErrNoCookie {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH001",
                    Message: "No access token provided",    
                })

                return
            }

            // 다른 쿠키 에러 처리

            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH002",
                Message: "Invalid cookie format",
            })

            return
        }

        accessToken := cookie.Value

        userId, userEmail, userStatus, validateErr := auth.ValidateJwtTokenFromString(accessToken)


        if validateErr != nil {
            log.Printf("ValidateErr Cookie Error :%v", validateErr)

            // 토큰 만료에 대한 응답
            if strings.Contains(validateErr.Error(), "token expired") {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH003",
                    Message: "Token expired",
                })

                return
            }

            // 일반적인 JWT 검증 실패 응답
            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH004",
                Message: "Invalid token",
            })

            return        
        }

        // 사용자 정보를 구조체로 생성

        user := User{
            UserId: userId,
            UserEmail: userEmail,
            UserStatus: userStatus,
        }

        // 사용자 정보를 컨텍스트에 추가
        ctx := context.WithValue(r.Context(), userContextKey, user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}



// 사용자 정보를 핸들러 및 컨트롤러에서 가져오는 헬퍼 함수
func GetUserFromContext(ctx context.Context) (User, bool) {
    user, ok := ctx.Value(userContextKey).(User)
    return user, ok
}

컨트롤러에서 추출된 정보들 사용


func SampleController(res http.ResponseWriter, req *http.Request) {
    user, ok := middlewares.GetUserFromContext(req.Context())

    if !ok {    
        dto.SetErrorResponse(res, 401, "01", "JWT Verifying Error", nil)

        return
    }
    /*
        이후 로직
    */

    dto.SetResponse(res, 200, "01")
}
728x90
반응형
728x90
반응형

기존

  • 기존에는 직접 CORS 체크 미들웨어를 작성해 사용했다.
func CorsMiddlewares(next http.Handler) http.Handler {
    return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {

        origin := req.Header.Get("Origin")

        if origin == "" {
            origin = "unknown"
        }

        for _, o := range originList {
            if o == origin {    
                log.Printf("Allowed Origin: %s", origin)
                res.Header().Set("Access-Control-Allow-Origin", origin)
                res.Header().Set("Access-Control-Max-Age", "86400")
                res.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
                res.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
                res.Header().Set("Access-Control-Allow-Credentials", "true")
                break
            }
        }

        // Handle preflight request
        if req.Method == http.MethodOptions {
            res.WriteHeader(http.StatusOK)
            return
        }

        next.ServeHTTP(res, req)
    })
}

변경

  • 그러나 조금 더 심플하고 편하게 설정할 수 있는 패키지가 있어 가져와 사용했다.
get -u github.com/rs/cors
  • 이후 세팅은 이렇게 된다.
func CorsHanlder() *cors.Cors {
    corHandler := cors.New(cors.Options{
        AllowedOrigins: originList,
        AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodOptions},
        AllowedHeaders: []string{"Origin", "Accept", "Content-Type", "Authorization"},
        AllowCredentials: true,
        MaxAge: 86400,        
        Debug: false,
    })

    return corHandler
}

미들웨어 등록하기

  • 현재 표준 라이브러리인 net/http 에서 gorilla/mux 로 변경한 상태이다.
func OpenServer() *http.Server {
    router := mux.NewRouter()

    routers.DefaultRouter(router)

    routers.UploadImageController(router)

    routers.AdminUserRouter(router)

    routers.AdminPostRouter(router)

    routers.UserRouter(router)

    routers.PostRouter(router)

    router.Use(middlewares.AuthMiddleware)

    // CORS 핸들러
    handler := middlewares.CorsHanlder().Handler(router)

    // 기존 방식  
    // handler := middlewares.CorsMiddlewares(router)

    serving := &http.Server{
        Handler: handler,
        Addr: configs.GlobalConfig.AppHost,
        WriteTimeout: 30 * time.Second,
        ReadTimeout: 30 * time.Second,
    }

    return serving
}
728x90
반응형
728x90
반응형

Nullable 데이터

  • DB의 필드 중에 NULL 값이 들어갈 수 있는 값들이 있다. 이 값들을 쿼리해서 코드단에서 처리할 때 어떻게 해야 할까?
  • 다른 언어들은 그냥 쿼리해서 사용하면 null 값으로 처리되던데...

Struct 정의

  • 우선 쿼리된 결과를 원하는 값들에 할당해준다. 아래는 기존에 사용하던 코드
type SampleQueryItem struct {
  UserId string `json:"userId"`
  UserName string `json:"userName"`
  UserEmail string `json:"userEmail"`
}
  • 이렇게 하면 받아오는 데이터 세개 전부 값이 있다고 가능하는 셈이다.
    • 이렇게 된다면 null 값들은 처리할 수 없다.

포인터 사용하기

type SampleQueryItem struct {
  UserId string `json:"userId"`
  UserName string `json:"userName"`
  UserEmail *string `json:"userEmail"` // 포인터 사용
}
  • 이렇게 처리하면 userEmail 값은 null 로 받아올 수 있다.

번외; 단건 조회 데이터가 없을 때

  • 한 건 조회할 때, 쿼리 데이터가 없다면?
  • golang은 심플함을 강조하기 때문에, 이러한 상황들을 직접 핸들링 해 줘야 한다.

기존 코드

var dataItem SampleQueryItem

if scanErr := queryResult.Scan(&dataItem.UserId, &dataItem.UserName, &dataItem.UserEmail);
    scanErr != nil {
        log.Printf("Scan Error: %v", scanErr)
        return scanErr
    }
  • 이렇게 해 주면 scan 에러가 발생한다. 그 이유는 쿼리된 데이터가 없다는 것

수정된 코드

var dataItem SampleQueryItem

if scanErr := queryResult.Scan(&dataItem.UserId, &dataItem.UserName, &dataItem.UserEmail);
    scanErr != nil {
        // 데이터가 없는 에러는 error 에러를 리턴하지 않게 해서 에러로 빠지지 않게 한다.
        if scanErr == sql.NoRowError {
            return SampleQueryItem{}, nil
        }

        log.Printf("Scan Error: %v", scanErr)
        return SampleQueryItem{}, scanErr
    }
  • 조회된 데이터가 없는 것은 에러로 처리된다. scan 할 데이터가 없기 때문
    • 위 처럼 쿼리 후 에러 핸들링을 하면, 에러 처리로 넘기지 않고 빈 데이터를 넘길 수 있다.
728x90
반응형
728x90
반응형
  • 본 글은 데보션 글을 기반으로 정리 형식에서 작성되었습니다. (해당 링크는 하단에)

gRPC 란?

  • 구글에서 개발한 고성능 RPC 프레임워크
  • HTTP/2 에서 동작하며 양방향 스트리밍 및 흐름 제어 제공
  • 원경으로 호출할 수 있는 메서드 지정하여 서비스 정의하는 개념 기반
    • 클라이언트 어플리케이션이 로컬 객체처럼 다른 컴퓨터의 서버 어플리케이션의 메서드를 직접 호출 가능 -> 분산 어플리케이션 및 서비스 개발에 용이함
  • protobuf(IDL로 사용)를 기본 메세지 형식으로 사용
    • IDL (Interface Definition Language)

gRPC 특징

  • 언어 독립성: 다양한 언어 지원. 클라이언트와 서버가 다른 언어로 작성되어도 상호작용 가능
  • 양방향 스트리밍: HTTP/2를 기반으로 하는 클라이언트 - 서버 간 양방향 스트리밍 지원
  • 강력한 타입 체크: 메세지 형식으로 protobufs로 정의하면, gRPC는 Type 체크 제공
  • 높은 성능: HTTP/2와 protobufs 를 활용한 높은 성능 제공
  • 구글 API 연동: 구글 API 인터페이스에 gRPC가 제공되므로 연동에 용이함

gRPC 4가지 서비스 정의 방법

  1. 단항 RPC: 클라이언트가 서버에 단일 요청 전송 후 일반 함수 호출처럼 단일 응답
rpc SayHello(HelloRequest) returns (HelloResponse);
  1. 서버 스트리밍 RPC: 클라이언트가 서버에 요청 보내고, 일련의 메시지 읽을 수 있는 스트림을 다시 받는 방식
rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);
  1. 클라이언트 스트리밍 RPC: 클라이언트가 일련의 메시지 작성하고 제공된 스트림을 사용하여 다시 서버로 보내는 방식
rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);
  1. 양방향 스트리밍 RPC: 양쪽이 읽기-쓰기 스트림을 사용해 일련의 메시지를 보내는 방식
rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

protobuf

  • 프로토콜 버퍼 데이터
  • 개발 언어, 플랫폼과 상관 없이 직렬화 가능하게 하는 데이터 구조
    • 메시지로 구조화 됨
    • 각 메세지는 필드라고 하는 일련의 이름-값 쌍을 포함함
  • 서로 다른 시스템끼리 데이터 공유, 저장하기 위해 사용
  • xml, json 보다 더 효율적인 방식으로 데이터 관리
    • 때문에 전송 및 저장 시 데이터를 더 적게 사용할 수 있다.
  • 파일 확장자는 .proto로 정의된다

코드 작성해 보기

  • proto 파일 생성
// https://github.com/grpc/grpc-go

syntax = "proto3";

// 패키지로 생성하기 위해 추가
option go_package = "grpc/helloworld";

// 패키지로 생성하기 위해 추가
package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}
  • .proto 파일 생성 후, protoc 을 이용해 각 언어에 맞는 코드 생성
protoc --go\_out=. --go\_opt=paths=source\_relative --go-grpc\_out=. --go-grpc\_opt=paths=source\_relative helloworld/helloworld.proto
  • go 서버 코드 작성
package main

import (
    "context"
    "flag"
    "fmt"
    pb "grpc/helloworld" // protoc 로 생성된 코드
    "log"
    "net"

    "google.golang.org/grpc"
)

var (
    port = flag.Int("port", 50051, "The server port")
)

// helloworld.GreeterServer 구현체 시용하는 서버
type server struct {
    pb.UnimplementedGreeterServer // 이부분은 안하면 에러가 발생한다. protobuf generate시 생성됨
}

type GreeterServer struct {
    SayHello(context.Context, *HelloRequest) (*HelloReply, error)
    // protobuf 빌드 시 생성되는 메서드
    mustEmbedUnimplementedGreeterServer()
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.GetName())
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    flag.Parse()
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{}) //client가 사용할 수 있도록 등록
    log.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

REFERENCE

728x90
반응형
728x90
반응형

Graph DB 핸들링

  • MATCH 로 조회한 데이터는 전부 Map으로 매핑된 데이터들
    • 따라서 쿼리한 데이터를 가져올 때 GET 메서드로 데이터를 가져와야 함
    • 아래는 처음에 짰던 코드
      • 코드가 길고 가독성도 별로라서 다른 방안 고민 중 - 아래에 수정 내용 추가
result, queryErr := dbCon.Query(GetWordAndRelatedWord, map[string]interface{}{"word": word})

if queryErr != nil {
    log.Printf("[SEARCH] Query Word Error: %v", queryErr)
    return []SearchWordResult{}, queryErr
}

var queryResult []SearchWordResult

for _, data := range result {

    name, isName := data.Get("name")

    if !isName {
        log.Printf("[SEARCH] No Name Found. Ignore. Word: %s", word)
        continue
    }

    description, isDescription := data.Get("description")

    if !isDescription {
        log.Printf("[SEARCH] No Description Found. Ignore. Word: %s", word)
        continue
    }

    createdAt, isCreatedAt := data.Get("created_at")

    if !isCreatedAt {
        log.Printf("[SEARCH] No CreatedAt Found. Ignore. Word: %s", word)
        continue
    }

    updatedAt, isUpdatedAt := data.Get("updated_at")  

    if !isUpdatedAt {
        log.Printf("[SEARCH] No UpdatedAt Found. Ignore. Word: %s", word)
        continue
    }

    category, isCategory := data.Get("category")  

    if !isCategory {

        log.Printf("[SEARCH] No Category Found. Ignore. Word: %s", word)

        continue

    }

    createdBy, isCreatedBy := data.Get("created_by")

    if !isCreatedBy {
        log.Printf("[SEARCH] No CreatedBy Found. Ignore. Word: %s", word)
        continue
    }

    var node = SearchWordResult{
        Name: name.(string),
        Category: category.(string),
        Description: description.(string),
        CreatedBy: createdBy.(string),
        CreatedAt: createdAt.(string),
        UpdatedAt: updatedAt.(string),
    }
    queryResult = append(queryResult, node)

}

데이터 핸들링 수정

  • 처음에는 위처럼 데이터를 핸들링 했지만, 읽는 노드 개수가 여러개가 됨에 따라 그 데이터 형태가 달라졌다.
    • 따라서 쿼리 방식을 바꿔야 했고, 데이터 형태 파악부터 해야 했다.
      • 데이터는 배열 안에 각각 노드 Label에 따라 노드들이 배열에 담겨있었다.
      • 따라서 쿼리 결과를 iteration 하며, 각각 label과 함께 나온 데이터를 핸들링하게 끔 수정했다.
    • 쿼리 결과를 GET해서 가져왔을 때, 그 타입이 any 였다.
      • 때문에 이를 dbtype.Node로 캐스팅하고, Node의 Properties를 뽑아와 사용했다.
        • dbType은 neo4j에서 제공하는 노드 타입
        • properties는 map[string]any 타입

responseMap := make(map[string]*SearchWordResult)

for _, data := range result {
    wNode, isNode := data.Get("word")

    if !isNode {
        log.Printf("[SEARCH] No Node Found")
        continue
    }

    targetNode := wNode.(dbtype.Node)

    rNode, isRelated := data.Get("related")

    if !isRelated {
        log.Printf("[SEARCH] No Related Node Found")
        continue    
    }

    relatedNodeList := rNode.(dbtype.Node)

    wordeNode := SearchWordItem{
        Name: targetNode.GetProperties()["name"].(string),
        Category: targetNode.GetProperties()["category"].(string),
        Description: targetNode.GetProperties()["description"].(string),
        CreatedBy: targetNode.GetProperties()["created_by"].(string),
        CreatedAt: targetNode.GetProperties()["created_at"].(string),
        UpdatedAt: targetNode.GetProperties()["updated_at"].(string),
    }

    relatedNode := SearchWordItem{
        Name: relatedNodeList.GetProperties()["name"].(string),
        Category: relatedNodeList.GetProperties()["category"].(string),
        Description: relatedNodeList.GetProperties()["description"].(string),
        CreatedBy: relatedNodeList.GetProperties()["created_by"].(string),
        CreatedAt: relatedNodeList.GetProperties()["created_at"].(string),
        UpdatedAt: relatedNodeList.GetProperties()["updated_at"].(string),
    }

    if _, exists := responseMap[wordeNode.Name]; !exists {
        responseMap[wordeNode.Name] = &SearchWordResult{
            Word: wordeNode,
            Related: []SearchWordItem{},
        }
    }

    responseMap[wordeNode.Name].Related = append(responseMap[wordeNode.Name].Related, relatedNode)

}

var responseList []SearchWordResult

for _, response := range responseMap {
    responseList = append(responseList, *response)
}

노드 및 관계 읽기

  • 아래 쿼리 방식은 관계를 통한 조회이다.
    • relations가 RELATED 혹은 PARENT 인 노드 관계들을 조회하고
    • 1..2 는 hop에 관한 내용이다
      • 1 은 직접적으로 연관된 노드들
      • 2는 중간에 노드가 하나 있는 노드들
    • 조회에 성공한 노드들 정보를 리턴한다
      • SQL과 동일하게 DISTINCT 해서 리턴
      • word의 경우 name 프로퍼티에 대한 조건 쿼리랑 동일하기 때문에 하나 혹은 동일한 이름을 가진 노드들 리턴
      • related의 경우, 특정 이름을 가진 노드와 1홉 혹은 2홉의 관계를 가진 모든 노드들
MATCH (w:Word {name: $word})-[:RELATED|PARENT*1..2]-(related:Word)
RETURN DISTINCT word, related

관계 property 설정

  • 실제 짜서 사용중인 코드이다. 아래처럼 관계를 설정한다.
    • 방향이 설정되지 않은 관계는 RELATED
    • 부모/자식 노드들의 관계를 PARENT / CHILDREN이라는 관계로 정의함
// Create Relations
var CreateWordRelatinon = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:RELATED]-(w2)
    SET r.weight = $weight
`

// Create Relations; w1 is Parent, w2 is Children
var CreateWordParent = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:PARENT]->(w2)
    SET r.weight = $weight
`

// Create Relations; w2 is Parent, w1 is Children
var CreateWordChildren = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:CHILDREN]->(w2)
    SET r.weight = $weight
`
728x90
반응형
728x90
반응형

계속 적을 글

  • 본 글은 계속해서 적어갈 예정

Create

  • 메서드 설명
    • CREATE: 동일한 내용의 노드가 있더라도 생성함
    • MERGE: 동일한 노드가 있다면 무시하고 진행함
  • 쿼리 문에 들어갈 파라미터들은 Prepared 하게 런타임에서 주입
    • Golang에서는 map 에 담아서 사용
CREATE 
(p:Person {name: $name, age: $age, languages: $languages})-[l:LIKES]->(t:Technology {name: $tech})

MERGE 
(p:Person {name: $name, age: $age, languages: $languages})-[l:LIKES]->(t:Technology {name: $tech})

// 각각 노드 생성하고 관계 추가
MERGE (a:Person {name: $name})
MERGE (b:Person {name: $friend})
MERGE (a)-[friendship:KNOWS {since: $friendsSince}]->(b)

// Golang
queryArguments := map[string]interface{}{
    "name": name,
    "age": age,
    "languages": languageList,
    "tech": techName,
}

queryErr := dbCon.Insert(CreatePersonQuery, queryArguments)

Select(Match)

  • ExecuteQuery 로 쿼리 수행하고, 나온 데이터를 핸들링한다.
    • []*db.Record 타입으로 리턴됨
내가 핸들링한 방법
  • dbtype.node 의 Props로 감싸고, 키 값으로 처리
  • 공식문서는 AsMap()으로 처리
// ============== 내가 한 방식 ==============
for _, record := range result {
    person, isPersonExist := record.Get("p")

    if !isPersonExist {
        log.Printf("[SINGLE_PERSON] No Person Data Found: %v", isPersonExist)
        continue
    }

    log.Printf("[SINGLE_PERSON] Get single person: %v", person)

    personProperties := person.(dbtype.Node).Props

    personData := Person{
        Name: personProperties["name"].(string),
        Age: personProperties["age"].(string),
        Languages: personProperties["languages"].([]string),
    }

    personList = append(personList, personData)
}

// ============== 공식문서 ==============
 if employeesN := org.AsMap()["employeesN"].(int64);
       employeesN < employeeThreshold {
        err = addPersonToOrganization(ctx, tx, name, orgId)

        if err != nil {
            return nil, err
            // Transaction will roll back
            // -> not even Person is created!
        }
    }
728x90
반응형

'백엔드 Backend > Golang' 카테고리의 다른 글

[gRPC] Go 언어로 gRPC 사용해보기  (2) 2024.12.24
[Neo4J] 데이터 핸들링하기  (1) 2024.12.09
[Neo4j] Golang으로 Neo4j 연동  (0) 2024.12.05
[GO] Ubuntu 서버에 설치  (1) 2024.10.30
[GO] Goroutine이란?  (0) 2024.10.02
728x90
반응형

공식 문서

Golang으로 연결

  • neo4j 드라이버 설치
    • 연결의 인증은 여러 방식이 있음; BasicAuth, BearerAuth, AuthToken, CustomAuth, ...
    • 본 예시는 유저 이름과 패스워드로 인증하는 방식
go get -u github.com/neo4j/neo4j-go-driver/v5/neo4j
  • 드라이버 인스턴스 생성
import (
    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth(<USER>, <PASSWD>, ""),
    )
}
  • 연결 체크
import (
    "context"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth(<USER>, <PASSWD>, ""),
    )

    ctx := context.Background()

    err := driver.VerifyConnectivity(ctx)

    if err != nil {
        log.Printf("[GRAPH_DB] Check Connection Error: %v", err)
        return err
    }

    defer driver.Close(ctx)

    return nil
}

Golang으로 쿼리

  • 쿼리 실행
    • ExecuteQuery 메서드로 쿼리 실행
import (
    "context"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth("<USER>", "<PASSWD>", ""),
    )

    ctx := context.Background()

    // 쿼리 실행
    result, queryErr := neo4j.ExecuteQuery(
        ctx, 
        driver, 
        "MERGE (n:Node {name:"$nodeName"})", // Node라는 유니크 노드 생성
        []map[string]interface{ // 파라미터 생성. nodeName에 들어갈 값
            nodeName: "New Node"
        }, 
        neo4j.EagerResultTransformer, // 쿼리 결과 변환
        neo4j.ExecuteQueryWithDatabase("neo4j"),
    )

    if queryErr != nil {
        return nil, queryErr
    }

    defer db.Close(ctx)

    for _, record := range result.Records {
        log.Printf("[GRAPH_DB] Query Result: %v", record.Values...)
    }

    // 쿼리 결과에 대한 요약
    log.Printf("The query `%v` returned %v records in %+v.\n",
        result.Summary.Query().Text(), len(result.Records),
        result.Summary.ResultAvailableAfter())
}
728x90
반응형

'백엔드 Backend > Golang' 카테고리의 다른 글

[gRPC] Go 언어로 gRPC 사용해보기  (2) 2024.12.24
[Neo4J] 데이터 핸들링하기  (1) 2024.12.09
[Neo4j] Golang 으로 쿼리 핸들링  (0) 2024.12.06
[GO] Ubuntu 서버에 설치  (1) 2024.10.30
[GO] Goroutine이란?  (0) 2024.10.02
728x90
반응형

UBUNTU에 Go 설치하기

  • 항상 컨테이너로 GO 프로그램을 돌렸지만, 불가피하게 로컬에 GO를 설치해 빌드하고 돌려야 할 상황이 와서 해당 내용을 기록한다.

소스 다운 받아서 설치하기

최신 버전 확인

  • 공식 사이트의 Golang 버전 확인 후 다운받기 (2024.10.21 시점 1.23.2)
  • 공식 사이트

WGET을 이용해 다운로드

  • WGET을 이용해 다운받기
    wget https://go.dev/dl/go1.23.2.linux-amd64.tar.gz

압축 해제

  • 다운 받은 압축 파일 해제
    sudo tar -C /usr/local -xzf go1.23.2.linux-amd64.tar.gz

경로 설정

vi ~/.profile

# 파일 마지막 줄 아래에 내용 추가
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

변경 사항 적용

source ~/.profile

Go 버전 확인

go version

UBUNTU 피키지 매니저로 다운받기

패키지 인덱스 업데이트

sudo apt update

GO 설치

sudo apt-get install golang-go

Go 버전 확인

go version
728x90
반응형

'백엔드 Backend > Golang' 카테고리의 다른 글

[gRPC] Go 언어로 gRPC 사용해보기  (2) 2024.12.24
[Neo4J] 데이터 핸들링하기  (1) 2024.12.09
[Neo4j] Golang 으로 쿼리 핸들링  (0) 2024.12.06
[Neo4j] Golang으로 Neo4j 연동  (0) 2024.12.05
[GO] Goroutine이란?  (0) 2024.10.02

+ Recent posts