Você apenas envia para `Depends` e o **FastAPI** sabe como fazer o resto.

///

## Compartilhando dependências `Annotated` { #share-annotated-dependencies }

Nos exemplos acima, você pode ver que existe uma pequena **duplicação de código**.

```

这样，你只需编写一次共享代码，**FastAPI** 会在你的*路径操作*中为你调用它。

/// check | 检查

注意，无需创建专门的类并传给 **FastAPI** 去“注册”之类的操作。

只要把它传给 `Depends`，**FastAPI** 就知道该怎么做了。

///

## 共享 `Annotated` 依赖项 { #share-annotated-dependencies }

在上面的示例中，你会发现这里有一点点**代码重复**。

当你需要使用 `common_parameters()` 这个依赖时，你必须写出完整的带类型注解和 `Depends()` 的参数：

```Python
commons: Annotated[dict, Depends(common_parameters)]
```

   *
   * @param lists the lists to choose elements from, in the order that the elements chosen from
   *     those lists should appear in the resulting lists
   * @param <B> any common base class shared by all axes (often just {@link Object})
   * @return the Cartesian product, as an immutable list containing immutable lists
   * @throws IllegalArgumentException if the size of the cartesian product would be greater than

            } else {
                repoMetadata.setMetadata(metadata);
                setRepository = true;
            }
        }
        return setRepository;
    }

    /*
     * TODO share with DefaultPluginMappingManager.
     */
    protected Metadata readMetadata(File mappingFile) throws RepositoryMetadataReadException {

        try (InputStream in = Files.newInputStream(mappingFile.toPath())) {

        try {
            return Class.forName(
                name,
                // Don't initialize the class to save time. Not needed for this test and this doesn't share a VM with any other tests.
                false,
                isolatedClassLoader
            );
        } catch (ClassNotFoundException e) {

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import jakarta.servlet.http.HttpSession;

/**
 * Abstract base class for LLM client implementations.
 *
 * Provides shared infrastructure (HTTP client, availability checking) and
 * default implementations of RAG workflow methods with injectable prompt templates.
 * Subclasses implement provider-specific chat/streamChat and checkAvailabilityNow.
 */

        final Path baseDir = Files.createDirectories(tempDir.resolve("vardata"));
        System.setProperty("fess.var.path", baseDir.toString());

        // A directory that does NOT share the prefix
        final Path otherDir = Files.createDirectories(tempDir.resolve("other"));
        final File fileInOther = new File(otherDir.toFile(), "test.txt");
        fileInOther.createNewFile();

```

如此一來，你只需撰寫一次共用程式碼，**FastAPI** 會替你的各個「路徑操作」呼叫它。

/// check | 檢查

注意，你不必建立特殊的類別並把它傳到 **FastAPI** 去「註冊」或做類似的事。

只要把它傳給 `Depends`，**FastAPI** 就知道該怎麼處理其餘的部分。

///

## 共用 `Annotated` 依賴 { #share-annotated-dependencies }

在上面的範例中，可以看到有一點點的「重複程式碼」。

當你要使用 `common_parameters()` 這個依賴時，你得寫出完整的型別註解搭配 `Depends()`：

```Python
commons: Annotated[dict, Depends(common_parameters)]
```

 * and remove old {@code .sha1} files that are no longer needed.
 * <p>
 * Every jar must also have a LICENSE and NOTICE file. However, multiple jars can share
 * LICENSE and NOTICE files by mapping a pattern to the same name.
 * <pre>
 *   dependencyLicenses {
 *     mapping from: &#47;lucene-.*&#47;, to: "lucene"
 *   }
 * </pre>

     */
    @Nonnull
    @Override
    public String[] option(Iterable<? extends Path> paths) {
        return format(null, paths);
    }

    /**
     * Implementation shared with {@link Modular}.
     */
    final String[] format(String moduleName, Iterable<? extends Path> paths) {
        if (option == null) {