// （A) Session: 基本的な共通設定
    sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))
    
    // (B) Service client: 単独のAWSサービスを利用するための設定（ここではAmazon DynamoDB）
    svc := dynamodb.New(sess)
    
    // (C) Request: 具体的なAWSサービス利用（ここではAmazon DynamoDBのitem取得）【本記事で扱うパート】
    result, err := svc.GetItem(&dynamodb.GetItemInput{
        TableName: aws.String(tableName),
        Key: map[string]*dynamodb.AttributeValue{
            "Year": {
                N: aws.String(movieYear),
            },
            "Title": {
                S: aws.String(movieName),
            },
        },
    })

    // (C) Request: 具体的なAWSサービス利用（今回はAmazon DynamoDBのitem取得）
    result, err := svc.GetItem(&dynamodb.GetItemInput{
        TableName: aws.String(tableName),
        Key: map[string]*dynamodb.AttributeValue{
            "Year": {
                N: aws.String(movieYear),
            },
            "Title": {
                S: aws.String(movieName),
            },
        },
    })

DynamoDB.GetItem()    # GetItem　リクエストの作成・送信・結果取得を行うメソッド
├── DynamoDB.GetItemRequest()      # GetItem　用の　Request　作成を行うメソッド
│   └── DynamoDB.newRequest()      # Client.NewRequest　のラッパーメソッド
│       └── Client.NewRequest()    # request.New　のラッパーメソッド
│           └── request.New()      # 新規　Requset　を作成する関数
└── Request.Send()    # HTTP リクエスト作成・リクエスト送信を行うメソッド
    ├── Request.Sign()      # HTTP リクエスト作成・署名を行うメソッド
    │   ├── (★) Request.Build()    # HTTP リクエストの検証・作成を行うメソッド 
    │   │   └── Request.Handlers.Build.Run()    # HTTP リクエスト作成を行う HandlerList
    │   │       └── jsonrpc.Build()       # HTTP リクエストボディ・ヘッダの作成を関数
    │   └── (★) Request.Handlers.Sign.Run()     # HTTP リクエストへの署名付与を行う HandlerList
    │       └── Signer.signWithBody()     # 署名に利用する AWS 認証情報を取得するメソッド
    │           └── signingCtx.build()    # SigV4 署名を生成・付与するメソッド
    ├── Request.sendRequest()      # HTTP リクエストの送信・レスポンスの受信ｗ行うメソッド                   
    └── (★) Request.Handlers.AfterRetry.Run(r)  # リトライ判定、リトライ間隔設定を行う HandlerList
        └── corehandlers.AfterRetryHandler      # リトライ判定、リトライ間隔設定を行う Handler

func (c *DynamoDB) GetItem(input *GetItemInput) (*GetItemOutput, error) {
    req, out := c.GetItemRequest(input)
    return out, req.Send()
}

&dynamodb.GetItemInput{
    TableName: aws.String(tableName),
    Key: map[string]*dynamodb.AttributeValue{
        "Year": {
            N: aws.String(movieYear),
        },
        "Title": {
            S: aws.String(movieName),
        },
    },
}

func (c *DynamoDB) GetItemRequest(input *GetItemInput) (req *request.Request, output *GetItemOutput) {
    op := &request.Operation{
        Name:       opGetItem,
        HTTPMethod: "POST",
        HTTPPath:   "/",
    }

    if input == nil {
        input = &GetItemInput{}
    }

    output = &GetItemOutput{}
    req = c.newRequest(op, input, output)
    // if custom endpoint for the request is set to a non empty string,
    // we skip the endpoint discovery workflow.
    if req.Config.Endpoint == nil || *req.Config.Endpoint == "" {
        if aws.BoolValue(req.Config.EnableEndpointDiscovery) {
            de := discovererDescribeEndpoints{
                Required:      false,
                EndpointCache: c.endpointCache,
                Params: map[string]*string{
                    "op": aws.String(req.Operation.Name),
                },
                Client: c,
            }

            for k, v := range de.Params {
                if v == nil {
                    delete(de.Params, k)
                }
            }

            req.Handlers.Build.PushFrontNamed(request.NamedHandler{
                Name: "crr.endpointdiscovery",
                Fn:   de.Handler,
            })
        }
    }
    return
}

func (c *DynamoDB) newRequest(op *request.Operation, params, data interface{}) *request.Request {
    req := c.NewRequest(op, params, data)

    // Run custom request initialization if present
    if initRequest != nil {
        initRequest(req)
    }

    return req
}

func (c *Client) NewRequest(operation *request.Operation, params interface{}, data interface{}) *request.Request {
    return request.New(c.Config, c.ClientInfo, c.Handlers, c.Retryer, operation, params, data)
}

func New(cfg aws.Config, clientInfo metadata.ClientInfo, handlers Handlers,
    retryer Retryer, operation *Operation, params interface{}, data interface{}) *Request {

    if retryer == nil {
        retryer = noOpRetryer{}
    }

    method := operation.HTTPMethod
    if method == "" {
        method = "POST"
    }

    httpReq, _ := http.NewRequest(method, "", nil)

    var err error
    httpReq.URL, err = url.Parse(clientInfo.Endpoint)
    if err != nil {
        httpReq.URL = &url.URL{}
        err = awserr.New("InvalidEndpointURL", "invalid endpoint uri", err)
    }

    if len(operation.HTTPPath) != 0 {
        opHTTPPath := operation.HTTPPath
        var opQueryString string
        if idx := strings.Index(opHTTPPath, "?"); idx >= 0 {
            opQueryString = opHTTPPath[idx+1:]
            opHTTPPath = opHTTPPath[:idx]
        }

        if strings.HasSuffix(httpReq.URL.Path, "/") && strings.HasPrefix(opHTTPPath, "/") {
            opHTTPPath = opHTTPPath[1:]
        }
        httpReq.URL.Path += opHTTPPath
        httpReq.URL.RawQuery = opQueryString
    }

    r := &Request{
        Config:     cfg,
        ClientInfo: clientInfo,
        Handlers:   handlers.Copy(),

        Retryer:     retryer,
        Time:        time.Now(),
        ExpireTime:  0,
        Operation:   operation,
        HTTPRequest: httpReq,
        Body:        nil,
        Params:      params,
        Error:       err,
        Data:        data,
    }
    r.SetBufferBody([]byte{})

    return r
}

type Handlers struct {
    Validate         HandlerList
    Build            HandlerList
    BuildStream      HandlerList
    Sign             HandlerList
    Send             HandlerList
    ValidateResponse HandlerList
    Unmarshal        HandlerList
    UnmarshalStream  HandlerList
    UnmarshalMeta    HandlerList
    UnmarshalError   HandlerList
    Retry            HandlerList
    AfterRetry       HandlerList
    CompleteAttempt  HandlerList
    Complete         HandlerList
}

func (r *Request) Send() error {
    defer func() {
        // Regardless of success or failure of the request trigger the Complete
        // request handlers.
        r.Handlers.Complete.Run(r)
    }()

    if err := r.Error; err != nil {
        return err
    }

    for {
        r.Error = nil
        r.AttemptTime = time.Now()

        if err := r.Sign(); err != nil {
            debugLogReqError(r, "Sign Request", notRetrying, err)
            return err
        }

        if err := r.sendRequest(); err == nil {
            return nil
        }
        r.Handlers.Retry.Run(r)
        r.Handlers.AfterRetry.Run(r)

        if r.Error != nil || !aws.BoolValue(r.Retryable) {
            return r.Error
        }

        if err := r.prepareRetry(); err != nil {
            r.Error = err
            return err
        }
    }
}

func (r *Request) Sign() error {
    r.Build()
    if r.Error != nil {
        debugLogReqError(r, "Build Request", notRetrying, r.Error)
        return r.Error
    }

    SanitizeHostForHeader(r.HTTPRequest)

    r.Handlers.Sign.Run(r)
    return r.Error
}

func (r *Request) Build() error {
    if !r.built {
        r.Handlers.Validate.Run(r)
        if r.Error != nil {
            debugLogReqError(r, "Validate Request", notRetrying, r.Error)
            return r.Error
        }
        r.Handlers.Build.Run(r)
        if r.Error != nil {
            debugLogReqError(r, "Build Request", notRetrying, r.Error)
            return r.Error
        }
        r.built = true
    }

    return r.Error
}

op := &request.Operation{
    Name:       opGetItem,    // 中身は “GetItem” という文字列
    HTTPMethod: "POST",
    HTTPPath:   "/",
}

&dynamodb.GetItemInput{
    TableName: aws.String(tableName),
    Key: map[string]*dynamodb.AttributeValue{
        "Year": {
            N: aws.String(movieYear),
        },
        "Title": {
            S: aws.String(movieName),
        },
    },
}

POST / HTTP/1.1
Host: dynamodb.<region>.<domain>;
Accept-Encoding: identity
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.0
Authorization: AWS4-HMAC-SHA256 Credential=<Credential>, SignedHeaders=<Headers>, Signature=<Signature>
X-Amz-Date: <Date>
X-Amz-Target: DynamoDB_20120810.GetItem

{
    "TableName": "Movies",
    "Key": {
        "Year": {
            "N": "2015"
        },
        "Title": {
            "S": "The Big New Movie"
        }
    }
}

func Build(req *request.Request) {
    var buf []byte
    var err error
    if req.ParamsFilled() {
        buf, err = jsonutil.BuildJSON(req.Params)
        if err != nil {
            req.Error = awserr.New(request.ErrCodeSerialization, "failed encoding JSON RPC request", err)
            return
        }
    } else {
        buf = emptyJSON
    }

    // Always serialize the body, don't suppress it.
    req.SetBufferBody(buf)

    if req.ClientInfo.TargetPrefix != "" {
        target := req.ClientInfo.TargetPrefix + "." + req.Operation.Name
        req.HTTPRequest.Header.Add("X-Amz-Target", target)
    }

    // Only set the content type if one is not already specified and an
    // JSONVersion is specified.
    if ct, v := req.HTTPRequest.Header.Get("Content-Type"), req.ClientInfo.JSONVersion; len(ct) == 0 && len(v) != 0 {
        jsonVersion := req.ClientInfo.JSONVersion
        req.HTTPRequest.Header.Set("Content-Type", "application/x-amz-json-"+jsonVersion)
    }
}

Authorization: AWS4-HMAC-SHA256 Credential=<Credential>, SignedHeaders=<Headers>, Signature=<Signature>

func (v4 Signer) signWithBody(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, isPresign bool, signTime time.Time) (http.Header, error) {
    currentTimeFn := v4.currentTimeFn
    if currentTimeFn == nil {
        currentTimeFn = time.Now
    }

    ctx := &signingCtx{
        Request:                r,
        Body:                   body,
        Query:                  r.URL.Query(),
        Time:                   signTime,
        ExpireTime:             exp,
        isPresign:              isPresign,
        ServiceName:            service,
        Region:                 region,
        DisableURIPathEscaping: v4.DisableURIPathEscaping,
        unsignedPayload:        v4.UnsignedPayload,
    }

    for key := range ctx.Query {
        sort.Strings(ctx.Query[key])
    }

    if ctx.isRequestSigned() {
        ctx.Time = currentTimeFn()
        ctx.handlePresignRemoval()
    }

    var err error
    ctx.credValues, err = v4.Credentials.GetWithContext(requestContext(r))
    if err != nil {
        return http.Header{}, err
    }

    ctx.sanitizeHostForHeader()
    ctx.assignAmzQueryValues()
    if err := ctx.build(v4.DisableHeaderHoisting); err != nil {
        return nil, err
    }

    // （〜省略〜）
    
    return ctx.SignedHeaderVals, nil
}

func (ctx *signingCtx) build(disableHeaderHoisting bool) error {
    ctx.buildTime()             // no depends
    ctx.buildCredentialString() // no depends

    if err := ctx.buildBodyDigest(); err != nil {
        return err
    }

    unsignedHeaders := ctx.Request.Header
    if ctx.isPresign {
        if !disableHeaderHoisting {
            urlValues := url.Values{}
            urlValues, unsignedHeaders = buildQuery(allowedQueryHoisting, unsignedHeaders) // no depends
            for k := range urlValues {
                ctx.Query[k] = urlValues[k]
            }
        }
    }

    ctx.buildCanonicalHeaders(ignoredHeaders, unsignedHeaders)
    ctx.buildCanonicalString() // depends on canon headers / signed headers
    ctx.buildStringToSign()    // depends on canon string
    ctx.buildSignature()       // depends on string to sign

    if ctx.isPresign {
        ctx.Request.URL.RawQuery += "&" + signatureQueryKey + "=" + ctx.signature
    } else {
        parts := []string{
            authHeaderPrefix + " Credential=" + ctx.credValues.AccessKeyID + "/" + ctx.credentialString,
            "SignedHeaders=" + ctx.signedHeaders,
            authHeaderSignatureElem + ctx.signature,
        }
        ctx.Request.Header.Set(authorizationHeader, strings.Join(parts, ", "))
    }

    return nil
}

func (c *Credentials) GetWithContext(ctx Context) (Value, error) {
    // Check if credentials are cached, and not expired.
    select {
    case curCreds, ok := <-c.asyncIsExpired():
        // ok will only be true, of the credentials were not expired. ok will
        // be false and have no value if the credentials are expired.
        if ok {
            return curCreds, nil
        }
    case <-ctx.Done():
        return Value{}, awserr.New("RequestCanceled",
            "request context canceled", ctx.Err())
    }

    // Cannot pass context down to the actual retrieve, because the first
    // context would cancel the whole group when there is not direct
    // association of items in the group.
    resCh := c.sf.DoChan("", func() (interface{}, error) {
        return c.singleRetrieve(&suppressedContext{ctx})
    })
    select {
    case res := <-resCh:
        return res.Val.(Value), res.Err
    case <-ctx.Done():
        return Value{}, awserr.New("RequestCanceled",
            "request context canceled", ctx.Err())
    }
}

func (r *Request) sendRequest() (sendErr error) {
    defer r.Handlers.CompleteAttempt.Run(r)

    r.Retryable = nil
    r.Handlers.Send.Run(r)
    if r.Error != nil {
        debugLogReqError(r, "Send Request",
            fmtAttemptCount(r.RetryCount, r.MaxRetries()),
            r.Error)
        return r.Error
    }

    r.Handlers.UnmarshalMeta.Run(r)
    r.Handlers.ValidateResponse.Run(r)
    if r.Error != nil {
        r.Handlers.UnmarshalError.Run(r)
        debugLogReqError(r, "Validate Response",
            fmtAttemptCount(r.RetryCount, r.MaxRetries()),
            r.Error)
        return r.Error
    }

    r.Handlers.Unmarshal.Run(r)
    if r.Error != nil {
        debugLogReqError(r, "Unmarshal Response",
            fmtAttemptCount(r.RetryCount, r.MaxRetries()),
            r.Error)
        return r.Error
    }

    return nil
}

func setCustomRetryer(c *client.Client) {
    maxRetries := aws.IntValue(c.Config.MaxRetries)
    if c.Config.MaxRetries == nil || maxRetries == aws.UseServiceDefaultRetries {
        maxRetries = 10    // 最大リトライ回数は10回
    }

    c.Retryer = client.DefaultRetryer{
        NumMaxRetries: maxRetries,
        MinRetryDelay: 50 * time.Millisecond,    // 最小リトライ間隔は50ミリ秒
    }
}

var AfterRetryHandler = request.NamedHandler{
    Name: "core.AfterRetryHandler",
    Fn: func(r *request.Request) {
        // If one of the other handlers already set the retry state
        // we don't want to override it based on the service's state
        if r.Retryable == nil || aws.BoolValue(r.Config.EnforceShouldRetryCheck) {
            r.Retryable = aws.Bool(r.ShouldRetry(r))
        }

        if r.WillRetry() {
            r.RetryDelay = r.RetryRules(r)

            if sleepFn := r.Config.SleepDelay; sleepFn != nil {
                // Support SleepDelay for backwards compatibility and testing
                sleepFn(r.RetryDelay)
            } else if err := aws.SleepWithContext(r.Context(), r.RetryDelay); err != nil {
                r.Error = awserr.New(request.CanceledErrorCode,
                    "request context canceled", err)
                r.Retryable = aws.Bool(false)
                return
            }

            // when the expired token exception occurs the credentials
            // need to be expired locally so that the next request to
            // get credentials will trigger a credentials refresh.
            if r.IsErrorExpired() {
                r.Config.Credentials.Expire()
            }

            r.RetryCount++
            r.Error = nil
        }
    }}

    // Logic to cap the retry count based on the minDelay provided
    actualRetryCount := int(math.Log2(float64(minDelay))) + 1
    if actualRetryCount < 63-retryCount {
        delay = time.Duration(1<<uint64(retryCount)) * getJitterDelay(minDelay)    // エクスポネンシャルバックオフ待機時間の計算
        if delay > maxDelay {
            delay = getJitterDelay(maxDelay / 2)
        }
    } else {
        delay = getJitterDelay(maxDelay / 2)
    }
    return delay + initialDelay

2^(リトライ回数) * (ランダム化された遅延+最小待ち時間)