///

## Pasos Previos Antes de Iniciar { #previous-steps-before-starting }

Hay muchos casos en los que quieres realizar algunos pasos **antes de iniciar** tu aplicación.

Por ejemplo, podrías querer ejecutar **migraciones de base de datos**.

Pero en la mayoría de los casos, querrás realizar estos pasos solo **una vez**.

     * This method queries the search engine for child documents and extracts their URLs.
     *
     * @param searchEngineClient the search engine client to query
     * @param id the parent document ID to find children for
     * @return a set of RequestData objects for the child URLs, or null if no children found
     */

But by using `Security` instead of `Depends`, **FastAPI** will know that it can declare security scopes, use them internally, and document the API with OpenAPI.

But when you import `Query`, `Path`, `Depends`, `Security` and others from `fastapi`, those are actually functions that return special classes.

///

## Use `SecurityScopes` { #use-securityscopes }

/// info | 技术细节

`Security` 实际上是 `Depends` 的子类，它只多了一个我们稍后会看到的参数。

但当你使用 `Security` 而不是 `Depends` 时，**FastAPI** 会知道它可以声明安全作用域，在内部使用它们，并用 OpenAPI 文档化 API。

另外，从 `fastapi` 导入的 `Query`、`Path`、`Depends`、`Security` 等，实际上都是返回特殊类的函数。

///

## 使用 `SecurityScopes` { #use-securityscopes }

现在更新依赖项 `get_current_user`。

上面那些依赖会用到它。

这里我们使用之前创建的同一个 OAuth2 方案，并把它声明为依赖：`oauth2_scheme`。

/// info | 技術細節

`Security` 其實是 `Depends` 的子類別，僅多了一個我們稍後會看到的參數。

改用 `Security` 而不是 `Depends`，能讓 FastAPI 知道可以宣告安全性 scopes、在內部使用它們，並用 OpenAPI 文件化 API。

另外，當你從 `fastapi` 匯入 `Query`、`Path`、`Depends`、`Security` 等時，實際上它們是回傳特殊類別的函式。

///

## 使用 `SecurityScopes` { #use-securityscopes }

現在更新相依性 `get_current_user`。

上面的相依性就是使用它。

	},
}

// Recycle the underlying map.
func (m *MSS) Recycle() {
	if m != nil && *m != nil {
		mssPool.Put(*m)
		*m = nil
	}
}

// ToQuery constructs a URL query string from the MSS, including "?" if there are any keys.
func (m MSS) ToQuery() string {
	if len(m) == 0 {
		return ""
	}
	var buf strings.Builder
	buf.WriteByte('?')
	keys := make([]string, 0, len(m))

Esse desacoplamento de partes, e ser um "microframework" que pode ser estendido para cobrir exatamente o que é necessário era uma funcionalidade chave que eu queria manter.

Dada a simplicidade do Flask, ele parecia uma boa opção para construção de APIs. A próxima coisa a encontrar era um "Django REST Framework" para Flask.

/// check | Inspirou o **FastAPI** a

		return AuthNResponse{}, nil
	}

	if roleArn != o.args.RoleARN {
		return AuthNResponse{}, fmt.Errorf("Invalid role ARN value: %s", roleArn.String())
	}

	u := url.URL(*o.args.URL)
	q := u.Query()
	q.Set("token", token)
	u.RawQuery = q.Encode()

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

    return new ConcurrentHashMultiset<>(countMap);
  }

  private ConcurrentHashMultiset(ConcurrentMap<E, AtomicInteger> countMap) {
    this.countMap = countMap;
  }

  // Query Operations

  /**
   * Returns the number of occurrences of {@code element} in this multiset.
   *
   * @param element the element to look for
   * @return the nonnegative number of occurrences of the element

	public final fun password ()Ljava/lang/String;
	public final fun pathSegments ()Ljava/util/List;
	public final fun pathSize ()I
	public final fun port ()I
	public final fun query ()Ljava/lang/String;
	public final fun queryParameter (Ljava/lang/String;)Ljava/lang/String;
	public final fun queryParameterName (I)Ljava/lang/String;
	public final fun queryParameterNames ()Ljava/util/Set;