// Test static concatValues method
        List<String> dest = new java.util.ArrayList<>();
        dest.add("existing");

        SuggestItem.concatValues(dest, "new1", "new2", "existing");

        assertEquals(3, dest.size());
        assertTrue(dest.contains("existing"));
        assertTrue(dest.contains("new1"));
        assertTrue(dest.contains("new2"));
        // Should not have duplicate "existing"

# Dependencias { #dependencies }

**FastAPI** tiene un sistema de **<abbr title="también conocido como componentes, recursos, proveedores, servicios, inyectables">Inyección de Dependencias</abbr>** muy poderoso pero intuitivo.

Está diseñado para ser muy simple de usar, y para hacer que cualquier desarrollador integre otros componentes con **FastAPI** de forma muy sencilla.

## Qué es la "Inyección de Dependencias" { #what-is-dependency-injection }

Probablemente puedas saltarte esta parte.

///

Hay una forma alternativa de definir esta lógica para ser ejecutada durante el *startup* y durante el *shutdown*.

Puedes definir manejadores de eventos (funciones) que necesitan ser ejecutadas antes de que la aplicación se inicie, o cuando la aplicación se está cerrando.

Estas funciones pueden ser declaradas con `async def` o `def` normal.

Cada vez que te "logueas con" Facebook, Google, GitHub, Microsoft, X (Twitter), esa aplicación está usando OAuth2 con scopes.

En esta sección verás cómo manejar autenticación y autorización con el mismo OAuth2 con scopes en tu aplicación de **FastAPI**.

/// warning | Advertencia

Esta es una sección más o menos avanzada. Si estás comenzando, puedes saltarla.

También puedes crear una variable de entorno solo para una **invocación específica de un programa**, que está disponible solo para ese programa, y solo durante su duración.

Para hacer eso, créala justo antes del programa en sí, en la misma línea:

<div class="termy">

```console
// Crea una env var MY_NAME en línea para esta llamada del programa
$ MY_NAME="Wade Wilson" python main.py

// Ahora puede leer la variable de entorno

            return new MavenStaxReader().read(is, false, null);
        }
    }

    protected void write(Model model, Path dest) throws IOException, XMLStreamException {
        String version = model.getModelVersion();
        Files.createDirectories(dest.getParent());
        try (Writer w = Files.newBufferedWriter(dest)) {
            MavenStaxWriter writer = new MavenStaxWriter();

                        }
                        if (useNTSmbs) {
                            reqx.setParam(dest.fid, off, n, b, 0, n);
                            dest.send(reqx, resp);
                        } else {
                            req.setParam(dest.fid, off, n, b, 0, n);
                            dest.send(req, resp);
                        }
                    }

En particular, esta puede ser una buena alternativa a la lógica en un middleware.

Por ejemplo, si quieres leer o manipular el request body antes de que sea procesado por tu aplicación.

/// danger | Advertencia

Esta es una funcionalidad "avanzada".

Si apenas estás comenzando con **FastAPI**, quizás quieras saltar esta sección.

///

## Casos de uso { #use-cases }

	if v, ok := stmt.Dest.(map[string]interface{}); ok {
		v[name] = value
	} else if v, ok := stmt.Dest.([]map[string]interface{}); ok {
		for _, m := range v {
			m[name] = value
		}
	} else if stmt.Schema != nil {
		if field := stmt.Schema.LookUpField(name); field != nil {
			destValue := reflect.ValueOf(stmt.Dest)
			for destValue.Kind() == reflect.Ptr {

		</antcall>

		<antcall target="remove.jars" />
	</target>

	<target name="install.module">
		<get dest="${target.dir}">
			<url url="${repo.url}/${module.groupId}/${module.name.prefix}${module.name}/${module.version}/${module.name.prefix}${module.name}-${module.zip.version}.zip" />
		</get>
		<unzip dest="${modules.dir}/${module.name}" src="${target.dir}/${module.name.prefix}${module.name}-${module.zip.version}.zip">
			<patternset>