golang 채널이란?

1. 데이터를 주고 받는 통로.
2. make를 통해 미리 생성.
3. 채널 연산자 <- 를 통해 데이터를 보내고 받는다.
보통 고루틴들 사이에 데이터를 주고 받을때 상대편이 준비 될때까지 채널에서 대기 -> 별도의 lock을 걸지 않고 
데이터를 동기화 하는데 사용 한다.

채널 만들기

1. ch := make(chan int) // 정수형 채널이 생성.

채널 송수신

1. 채널로 데이터를 보낼 때
채널 <- 데이터
ch <- 123
2. 채널로 부터 데이터를 받는다.
변수로 받을수도 있고 아래와 같은 형태로도 사용.
<- ch // go에서  , error := 블라블라 등 처럼  로 생각하면 된다.

특징

송&수신자가 서로를 기다리는 특성이 있다.(매우 중요)

go 채널 버퍼링

1. unbuffered channel
2. buffered channel

채널 파라미터

함수의 파라미터에 사용 가능 함.
1) 송신 파라미터
p chan<-int
2) 수신 파라미터
p <- chan int

채널 닫기

닫으면 송신은 불가하나 수신은 가능!

채널 select문

복수 채널들을 기다리면서 준비된(데이터를 보내온) 채널을 실행하는 기능.
동시에 올 경우는 go 런타임이 랜덤으로 골라서 진행.

참고 사이트 : http://golang.site/go/article/22-Go-%EC%B1%84%EB%84%90

소스코딩을 통해 더욱 더 자세하게 알아봐야 함!

갑자기 헤더 오류가 나서 뭔가 싶었는데 알고 봤더니 앞단과 뒷단간에 통신할 때 Request가 Bad였던것!

그래서 아래와 같이 오류가 떨어짐.

수정사항으로는 앞단(클라이언트, 프론트) encodeURL로 뒷단(서버)에서는 decoode를 수행.

특이사항으로는 로컬에서는 잘되어짐. 서버단에서 버그 발생.

톰캣 버전에 따라서 달라진다는것을 알수 있었음. -_-;;

톰캣!!~~

   - 끝 -

// Mux is a simple HTTP route multiplexer that parses a request path,
// records any URL params, and executes an end handler. It implements
// the http.Handler interface and is friendly with the standard library.
//
// Mux is designed to be fast, minimal and offer a powerful API for building
// modular and composable HTTP services with a large set of handlers. It's
// particularly useful for writing large REST API services that break a handler
// into many smaller parts composed of middlewares and end handlers.

멀티플렉서?

복수의 입력 중에서 1개를 선택해서 출력하는 전환회로. 복수의 입력은 제어신호에 의해 1개의 출력에 시간분할로 이어 바꿔진다. 논리 게이트로 구성되는 조합 논리 회로이다. 멀티플렉서의 역기능 회로를 디멀티플렉서(demultiplexer)라고 한다.

Mux는 요청경로를 파싱하는 간단한 HTTP route multiplexer이며, URL params을 기록하고 종료 처리기를 실행합니다.

이것은 http.Handler를 구현하며 표준 라이브러리와 친합니다.

Mux는 빠르고 최소한으로 설계되어 modular나 많은 handler를 가지는 http services를 만들기 위해 강력한 api를 제공 합니다.

또한 미들웨어와 엔드 핸들러로 구성된 매우 작은 파트들인 핸들러를 구성하는 rest api service를 만드는데 특히 유용 합니다.

type Mux struct {
   // The radix trie router
   tree *node

   // The middleware stack
   middlewares []func(http.Handler) http.Handler

   // Controls the behaviour of middleware chain generation when a mux
   // is registered as an inline group inside another mux.
   inline bool
   parent *Mux

   // The computed mux handler made of the chained middleware stack and
   // the tree router
   handler http.Handler

   // Routing context pool
   pool sync.Pool

   // Custom route not found handler
   notFoundHandler http.HandlerFunc

   // Custom method not allowed handler
   methodNotAllowedHandler http.HandlerFunc
}

middleware stack가 뭔지 궁금했는데  []func(http.Handler) http.Handler 였다. 굿굿!

관련하여 chi package를 살펴보자.

2018/03/02 - [Language/go lang] - chi package

보호글

Permanently added the RSA host key

공개키 에러인데 ..github서버에 파일을 push하려고 보니 현재 인증된게 하나도 없는 상태이다.
공개키를 github에 등록을 해주어야한다.

아래처럼 우선 공개키가 있는지 확인해보자.

공개키가 없다면..

2016/08/29 - [OS/Linux&Unix] - SSH 유용정보!

github에 id_rsa.pub 의 내용을 넣으면 된다.

잘 push  되었음을 알수가 있다.

  - 끝 -

github에 push하는데 있어서 무시해야하는 파일들은 무시하도록 설정한다. 아래 링크 참고!

2016/03/23 - [OpenSource/Spring Boot] - ace-t의 Spring Boot 따라잡기(기본 - SourceTree에 연결 및 Repository에 올리기)

https://www.gitignore.io/

에서 go와 intelij+imi를 선택한다.

복사 후 아래의 파일에 저장 시키면 된다.

다시 github을 열었을 때 imi파일들은 사라지고 아래의 커밋대상만 보이면 성공!

  - 끝 -

잘못된 예

잘된 예

아래와 같이 github.com/ace-t/golangArch로 만드는데 이렇게 하는 이유는 golang은 라이브러리 자체가 github에 올려서 공유하는 그런 형태이다.

그러므로 우리도 자기자신의 github url형식으로 프로젝트를 만들어보자!(글쓴이는 golang IDE를 사용한다.)

  - 끝 -

참조 : golang 셋팅

1. Go 설치
1. https://golang.org/dl/

HTTP Service를 구현할 때 사용한다.

Go 1.7이나 그 이상에서 사용이 가능하다.

package main

import (
	"net/http"

	"github.com/go-chi/chi"
	"github.com/go-chi/chi/middleware"
)

func main() {
	r := chi.NewRouter()
	r.Use(middleware.Logger)
	r.Use(middleware.Recoverer)

	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("root."))
	})

	http.ListenAndServe(":3333", r)
}

여러가지 함수들이 다양하기 때문에 가지고 놀아봐야 제대로 알듯 하다.

chi package는 크게 Context, Middleware, Mux, Route 등으로 구성되어져있다고 보면 된다.

참고 : https://godoc.org/github.com/go-chi/ch

// Use appends a middleware handler to the Mux middleware stack.
//
// The middleware stack for any Mux will execute before searching for a matching
// route to a specific handler, which provides opportunity to respond early,
// change the course of the request execution, or set request-scoped values for
// the next http.Handler.
func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
   if mx.handler != nil {
      panic("chi: all middlewares must be defined before routes on a mux")
   }
   mx.middlewares = append(mx.middlewares, middlewares...)
}

// Middlewares type is a slice of standard middleware handlers with methods
// to compose middleware chains and http.Handler's.
type Middlewares []func(http.Handler) http.Handler

// Route creates a new Mux with a fresh middleware stack and mounts it
// along the `pattern` as a subrouter. Effectively, this is a short-hand
// call to Mount. See _examples/.
func (mx *Mux) Route(pattern string, fn func(r Router)) Router {
   subRouter := NewRouter()
   if fn != nil {
      fn(subRouter)
   }
   mx.Mount(pattern, subRouter)
   return subRouter
}

// Mount attaches another http.Handler or chi Router as a subrouter along a routing
// path. It's very useful to split up a large API as many independent routers and
// compose them as a single service using Mount. See _examples/.
//
// Note that Mount() simply sets a wildcard along the `pattern` that will continue
// routing at the `handler`, which in most cases is another chi.Router. As a result,
// if you define two Mount() routes on the exact same pattern the mount will panic.
func (mx *Mux) Mount(pattern string, handler http.Handler) {

// Handle and HandleFunc adds routes for `pattern` that matches
// all HTTP methods.
Handle(pattern string, h http.Handler)
HandleFunc(pattern string, h http.HandlerFunc)

// A Handler responds to an HTTP request.
//
// ServeHTTP should write reply headers and data to the ResponseWriter
// and then return. Returning signals that the request is finished; it
// is not valid to use the ResponseWriter or read from the
// Request.Body after or concurrently with the completion of the
// ServeHTTP call.
//
// Depending on the HTTP client software, HTTP protocol version, and
// any intermediaries between the client and the Go server, it may not
// be possible to read from the Request.Body after writing to the
// ResponseWriter. Cautious handlers should read the Request.Body
// first, and then reply.
//
// Except for reading the body, handlers should not modify the
// provided Request.
//
// If ServeHTTP panics, the server (the caller of ServeHTTP) assumes
// that the effect of the panic was isolated to the active request.
// It recovers the panic, logs a stack trace to the server error log,
// and either closes the network connection or sends an HTTP/2
// RST_STREAM, depending on the HTTP protocol. To abort a handler so
// the client sees an interrupted response but the server doesn't log
// an error, panic with the value ErrAbortHandler.
type Handler interface {
   ServeHTTP(ResponseWriter, *Request)
}

type Router interface {
    http.Handler
    Routes

    // Use appends one of more middlewares onto the Router stack.
    Use(middlewares ...func(http.Handler) http.Handler)

    // With adds inline middlewares for an endpoint handler.
    With(middlewares ...func(http.Handler) http.Handler) Router

    // Group adds a new inline-Router along the current routing
    // path, with a fresh middleware stack for the inline-Router.
    Group(fn func(r Router)) Router

    // Route mounts a sub-Router along a `pattern`` string.
    Route(pattern string, fn func(r Router)) Router

    // Mount attaches another http.Handler along ./pattern/*
    Mount(pattern string, h http.Handler)

    // Handle and HandleFunc adds routes for `pattern` that matches
    // all HTTP methods.
    Handle(pattern string, h http.Handler)
    HandleFunc(pattern string, h http.HandlerFunc)

    // Method and MethodFunc adds routes for `pattern` that matches
    // the `method` HTTP method.
    Method(method, pattern string, h http.Handler)
    MethodFunc(method, pattern string, h http.HandlerFunc)

    // HTTP-method routing along `pattern`
    Connect(pattern string, h http.HandlerFunc)
    Delete(pattern string, h http.HandlerFunc)
    Get(pattern string, h http.HandlerFunc)
    Head(pattern string, h http.HandlerFunc)
    Options(pattern string, h http.HandlerFunc)
    Patch(pattern string, h http.HandlerFunc)
    Post(pattern string, h http.HandlerFunc)
    Put(pattern string, h http.HandlerFunc)
    Trace(pattern string, h http.HandlerFunc)

    // NotFound defines a handler to respond whenever a route could
    // not be found.
    NotFound(h http.HandlerFunc)

    // MethodNotAllowed defines a handler to respond whenever a method is
    // not allowed.
    MethodNotAllowed(h http.HandlerFunc)
}

Go를 홍보하는? 노래가 있다(Write in Go) (자막켜기 하면 자막 있음)

퍼옴 : https://www.youtube.com/watch?v=LJvEIjRBSDA

재밌네 ㅋㅋ

golang factory?

[ 호출부]

json.NewDecoder(reader).Decode(&msg)

[Decode]

func (dec *Decoder) Decode(v interface{}) error {
   if dec.err != nil {
      return dec.err
   }

   if err := dec.tokenPrepareForDecode(); err != nil {
      return err
   }

   if !dec.tokenValueAllowed() {
      return &SyntaxError{msg: "not at beginning of value"}
   }

   // Read whole value into buffer.
   n, err := dec.readValue()
   if err != nil {
      return err
   }
   dec.d.init(dec.buf[dec.scanp : dec.scanp+n])
   dec.scanp += n

   // Don't save err from unmarshal into dec.err:
   // the connection is still usable since we read a complete JSON
   // object from it before the error happened.
   err = dec.d.unmarshal(v)

   // fixup token streaming state
   dec.tokenValueEnd()

   return err
}

위의 소스에서 Decode 함수를 보자.

err = dec.d.unmarshal(v)라는게 눈에 띈다.

아래의 Encode함수도 마찬가지로 err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML}) 이라는게 있다.

[Encode]

func (enc *Encoder) Encode(v interface{}) error {
   if enc.err != nil {
      return enc.err
   }
   e := newEncodeState()
   err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML})
   if err != nil {
      return err
   }

   // Terminate each value with a newline.
   // This makes the output look a little nicer
   // when debugging, and some kind of space
   // is required if the encoded value was a number,
   // so that the reader knows there aren't more
   // digits coming.
   e.WriteByte('\n')

   b := e.Bytes()
   if enc.indentPrefix != "" || enc.indentValue != "" {
      if enc.indentBuf == nil {
         enc.indentBuf = new(bytes.Buffer)
      }
      enc.indentBuf.Reset()
      err = Indent(enc.indentBuf, b, enc.indentPrefix, enc.indentValue)
      if err != nil {
         return err
      }
      b = enc.indentBuf.Bytes()
   }
   if _, err = enc.w.Write(b); err != nil {
      enc.err = err
   }
   encodeStatePool.Put(e)
   return err
}

아래의 링크를 타고 내용을 보면 Marshal의 값은 v를 재귀적으로 호출한다.  v는 인터페이스!  또한 발생한 값이 Marshal 인터페이스를 구현하고 nil pointer가

아닐 경우 MarshalJSON 메소드를 호출하여 JSON을 생성하는 프로세스이다. 그러므로 아래처럼 MarshalJSON메소드를 구현 해주면 그녀석이 발동 된다는 것이다.

func Marshal(v interface{}) ([]byte, error)

2018/02/09 - [Language/go lang] - golang - Package json

예를 들어 아래와 같이 메소드가 있다면 아래의 MarshalJSON()을 호출하여 그안에서 factory를 생성한다.

func (m *AceTMessage) MarshalJSON(b []byte) error {

   m.Test = newFactory(m.Header.Type)

}

newFactory() 가 factory관련 소스이다.
var exFactory = map[string]func() Test{   // type에 따라 처리가 되어지는 구조.

- 끝 - 

import "encoding/json"

json 패키지는 RFC 4627에 정의 된 JSON의 인코딩 및 디코딩을 구현합니다. 

JSON 및 Go 값 간의 매핑은 marshal 및 unmarshal 함수에 대한 설명서에 설명되어 있습니다.

func Marshal(v interface{}) ([]byte, error)

Marshal은 v의 JSON 인코딩을 반환합니다. Marshal은 값 v를 재귀적으로 호출한다.
발생한 값이 Marshal 인터페이스를 구현하고 nil 포인터가 아닌 경우 MarshalJSON 메서드를 호출하여 JSON을 생성합니다. 
MarshalJSON 메서드가 없지만 값이 encoding.TextMarshaler를 대신 구현하면 Marshal은 해당 MarshalText 메서드를
호출하고 결과를 JSON 문자열로 인코딩합니다. 
nil 포인터 예외가 반드시 필요한 것은 아니지만 UnmarshalJSON의 동작에서 비슷하고 필요한 예외를 모방합니다.
그렇지 않은 경우, Marshal은 다음과 같은 유형 종속 기본 인코딩을 사용합니다.

부울 값은 JSON 부울 값으로 인코딩됩니다. 부동 소수점, 정수 및 숫자 값은 JSON 숫자로 인코딩됩니다.

문자열 값은 유효한 UTF-8로 강제 변환 된 JSON 문자열로 인코딩되어 유효하지 않은 바이트를 유니 코드 대체 문자로 대체합니다. 꺽쇠 괄호 "<"및 ">"는 "\ u003c"및 "\ u003e"로 이스케이프 처리되어 일부 브라우저가 JSON 출력을 HTML로 오해하지 않게합니다. 앰퍼샌드 "&"도 같은 이유로 "\ u0026"로 이스케이프됩니다. 이 이스케이프는 SetEscapeHTML (false)가 호출 된 인코더를 사용하여 비활성화 할 수 있습니다. 배열 및 슬라이스 값은 JSON 배열로 인코딩됩니다. 단, [] 바이트는 base64 인코딩 된 문자열로 인코딩되고 nil 슬라이스는 null JSON 값으로 인코딩됩니다. 구조체 값은 JSON 객체로 인코딩됩니다. 각 내보내기 된 구조체 필드는 개체 이름으로 필드 이름을 사용하여 개체의 멤버가됩니다. 필드가 아래에 나와있는 이유 중 하나로 생략되지 않는 한 각 구조체 필드의 인코딩은 구조체 필드의 태그에서 "json"키 아래에 저장된 형식 문자열을 사용하여 사용자 정의 할 수 있습니다. 형식 문자열은 필드의 이름을 제공하며 그 뒤에 쉼표로 구분 된 옵션 목록이옵니다. 기본 필드 이름을 무시하지 않고 옵션을 지정하려면 이름이 비어있을 수 있습니다.

"omitempty"옵션은 필드에 빈 값이 있거나 false, 0, nil 포인터, nil 인터페이스 값 및 빈 배열, 슬라이스, 맵 또는 문자열로 정의 된 필드가 인코딩에서 생략되어야한다고 지정합니다. ex) Field int `json:"myName,omitempty"` / Field int `json:",omitempty"`

특수한 경우 필드 태그가 "-"인 경우 필드는 항상 생략됩니다. ex) Field int `json:"-"`

이름이 "-"인 필드는 여전히 "-"태그를 사용하여 생성 할 수 있습니다. ex) Field int `json:"-,"`

유니 코드 문자, 숫자 및 ASCII 구두점 (인용 부호, 백 슬래시 및 쉼표 제외)으로 구성된 비어 있지 않은 문자열 인 경우 키 이름이 사용됩니다.

익명 구조체 필드는 일반적으로 내부 내보내기 필드가 외부 구조체의 필드 인 것처럼 마샬링되며 다음 단락에서 설명하는대로 일반적인 Go 가시성 규칙이 수정됩니다. JSON 태그에 주어진 이름을 가진 익명 구조체 필드는 익명이 아닌 해당 이름을 가진 것으로 취급됩니다. 인터페이스 유형의 익명 구조체 필드는 익명이 아닌 이름으로 해당 유형을 갖는 것과 동일하게 취급됩니다.

마샬링 또는 언 마샬링 할 필드를 결정할 때 구조체 필드에 대한 가시성 규칙이 JSON에 맞게 수정되었습니다. 같은 레벨에 여러 개의 필드가 있고 해당 레벨이 가장 작은 중첩 된 경우 (따라서 일반 Go 규칙에 의해 선택된 중첩 레벨이 됨) 다음과 같은 추가 규칙이 적용됩니다.
1) 이러한 필드 중 JSON 태그가 있는 경우 태그가없는 필드가 여러 개있는 경우에도 태그가있는 필드만 고려됩니다.
2) 정확히 하나의 필드 (첫 번째 규칙에 따라 태그가 지정 되었는지 여부)가 선택되면 해당 필드가 선택됩니다.

3) 그렇지 않으면 여러 필드가 있으며 모두 무시됩니다. 오류가 발생하지 않습니다.

익명 구조체 필드의 처리는 Go 1.1에서 새로 추가되었습니다. Go 1.1 이전에는 익명 구조체 필드가 ​​무시되었습니다. 현재 버전과 이전 버전의 익명 구조체 필드를 강제로 무시하려면 해당 필드에 "-"JSON 태그를 지정하십시오.

예제)

func Unmarshal(data []byte, v interface{}) error

Unmarshal은 JSON으로 인코딩 된 데이터를 구문 분석하고 결과가 v가 가리키는 값에 저장합니다. v가 nil이거나 포인터가 아닌 경우 Unmarshal은 InvalidUnmarshalError를 반환합니다.

Unmarshal은 마샬러가 사용하는 인코딩의 역함수를 사용하여 필요에 따라 maps, slices 및 포인터를 할당하고 다음과 같은 추가 규칙을 사용합니다.

Unmarshal은 JSON을 포인터로 unmarshal하기 위해 먼저 JSON 리터럴 null 인 JSON의 대소문자를 처리합니다. 이 경우 Unmarshal은 포인터를 nil로 설정합니다. 그렇지 않으면, Unmarshal은 JSON을 포인터가 가리키는 값으로 unmarshal합니다. 포인터가 nil이면 Unmarshal은 포인터가 가리키는 새 값을 할당합니다.

JSON을 Unmarshaler 인터페이스를 구현하는 값으로 unmarshal하기 위해 Unmarshal은 입력 값이 JSON null 인 경우를 포함하여 해당 값의 UnmarshalJSON 메서드를 호출 합니다. 그렇지 않은 경우 값이 encoding.TextUnmarshaler를 구현하고 입력 값이 JSON 인용 문자열이면 Unmarshal은 해당 값의 UnmarshalText 메소드를 인용되지 않은 문자열 형식으로 호출합니다.

JSON을 구조체로 unmarshal하려면 Unmarshal이 들어오는 객체 키를 marshal(구조체 필드 이름 또는 해당 태그)에서 사용하는 키와 일치 시키며 정확히 일치하는 것을 선호하지만 대 / 소문자를 구분하지 않는 일치를 허용합니다. Unmarshal은 구조체의 내 보낸 필드 만 설정합니다.

JSON 배열을 Go 배열로 unmarshal하기 위해 Unmarshal은 JSON 배열 요소를 해당 Go 배열 요소로 디코딩합니다. Go 배열이 JSON 배열보다 작은 경우 추가 JSON 배열 요소가 삭제됩니다. JSON 배열이 Go 배열보다 작은 경우 추가 Go 배열 요소는 0 값으로 설정됩니다.

.

func checkRequired(v reflect.Value, t reflect.StructField, options tagOptionsMap) (bool, error) {
   if requiredOption, isRequired := options["required"]; isRequired {
      if len(requiredOption) > 0 {
         return false, Error{t.Name, fmt.Errorf(requiredOption), true}
      }
      return false, Error{t.Name, fmt.Errorf("non zero value required"), false}
   } else if _, isOptional := options["optional"]; fieldsRequiredByDefault && !isOptional {
      return false, Error{t.Name, fmt.Errorf("All fields are required to at least have one validation defined"), false}
   }
   // not required and empty is valid
   return true, nil
}

위의 validator.go 소스를 살펴보자.

requried면 value를 가지고 체킹을 하게 된다.

즉, 값이 0이 들어오는데 required를 사용하게 된다면 false인 것이다. 즉 valid가 유효하지 못하다.

제거를 해주면 0이나 "" 이 들어와도 값이 없는 것으로 간주하지는 않을 것이다.

golang ref : 

 - https://godoc.org/

 - https://play.golang.org/

열공 열공~!

java 말고 golang

input / output은 동일하게 / export되지 않는 함수면 소문자로 SetValue (X) setValue(O)

acet.EntityInfo = setValue(acet.EntityInfo)

interface conversion

switch문을 사용할 수 있다. 해당 case의 타입이 들어오면 맞는 case 구문을 타게 된다.

ex) Body가 인터페이스 형태  

switch acet.Body.(type) {

case *xxx.xxxx:

case *aaa.xxxx:

java나 go lang이나 테스트 코드가 있다.

테스트 주도 개발이 좋다고 책에서 많이 보았다. 하지만 정작 그러한 책들을 보았음에도 불구하고..

간만에 코드를 짜게 되었는데..(그동안 서버 발주부터 셋팅, ACL 신청 등등 이러한 일들을 했다.)

테스트 코드를 짜야겠다는 생각을 하지 않은채 코드를 짰고, 테스트도 리퀘스트 부분만 잘들어가는지 대충 확인하고 다되었다고 PR을 날렸다.

리뷰의 결과는 창피했다.

왜 나는 꼼꼼하게 테스트 코드를 짜면서 테스트를 하지 않았을까?

당연..테스트 코드를 짜기가 부담스러웠나보다..또는 단순하게만 테스트 코드를 짜왔을지도 모른다.

막상 하려고보니..멍~하다. 

자..그럼 이제 무엇을 해야할까?

1) 앞으로 계속 두려워하며 쫄아서 피할것인가?

                   OR

2) 두려움을 극복하려고 노력할 것인가?

당연히 2번인가? 그렇다면 어떻게 노력할 것인가? 이게 가장 중요한 포인트 이다.

지금 이렇게 포스팅을 하는 이유도 노력의 시작의 일부임에는 틀림없다.

이제 시작되었으니 제대로 파악해서 제대로 사용해보자.

화이팅!

https://golang.org/pkg/context/   or https://godoc.org/golang.org/x/net/context

Package context는 마감 시간, 취소 신호 및 기타 요청 범위 값을 API 경계와 프로세스간에 전달하는 컨텍스트 유형을 정의합니다.

서버에 들어오는 요청은 컨텍스트를 만들어야하며 서버로 나가는 호출은 컨텍스트를 받아 들여야합니다. 이들 사이의 함수 호출 체인은 컨텍스트를 전파해야하며 선택적으로 WithCancel, WithDeadline, WithTimeout 또는 WithValue를 사용하여 생성 된 파생 된 컨텍스트로 대체해야합니다. 컨텍스트가 취소되면 그 컨텍스트도 파생됩니다.

작성 중~