## Recap { #recap }

With what you have seen up to now, you can set up a secure **FastAPI** application using standards like OAuth2 and JWT.

In almost any framework handling the security becomes a rather complex subject quite quickly.

            // Mock implementation that doesn't require client
            entity.setLastUpdated(System.currentTimeMillis());
        }
    }

    // Simple mock class without complex interface requirements
    private static class MockLaCron implements LaCron {
        @Override

But here's the key point.

The security and dependency injection stuff is written once.

And you can make it as complex as you want. And still, have it written only once, in a single place. With all the flexibility.

But you can have thousands of endpoints (*path operations*) using the same security system.

    String SELF_COMBINATION_REMOVE = XmlService.SELF_COMBINATION_REMOVE;

    /**
     * In case of complex XML structures, combining can be done based on id.
     */
    @Deprecated(since = "4.0.0", forRemoval = true)
    String ID_COMBINATION_MODE_ATTRIBUTE = XmlService.ID_COMBINATION_MODE_ATTRIBUTE;

    /**
     * In case of complex XML structures, combining can be done based on keys.
     * This is a comma separated list of attribute names.

* Conversão de dados
* Validação de dados
* Documentação automatica

## Tipos especiais e validação

Além dos tipos singulares normais como `str`, `int`, `float`, etc. Você também pode usar tipos singulares mais complexos que herdam de `str`.

---

Des exemples communs d'opérations "CPU bounds" sont les procédés qui requièrent des traitements mathématiques complexes.

Par exemple :

* Traitements d'**audio** et d'**images**.

        ASN1EncodableVector authDataVector = new ASN1EncodableVector();
        ASN1EncodableVector authElementVector = new ASN1EncodableVector();
        // Use an auth type that doesn't require complex parsing (e.g., 999 - unknown type)
        authElementVector.add(new DERTaggedObject(0, new ASN1Integer(999))); // ad-type
        authElementVector.add(new DERTaggedObject(1, new DEROctetString(new byte[] { 1, 2, 3, 4 })));

Enviar um corpo em uma requisição `GET` não tem um comportamento definido nas especificações, porém é suportado pelo FastAPI, apenas para casos de uso bem complexos/extremos.

Como é desencorajado, a documentação interativa com Swagger UI não irá mostrar a documentação para o corpo da requisição para um `GET`, e proxies que intermediarem podem não suportar o corpo da requisição.

///

do exactly this.
</p>

<p>
A read of an array, struct, or complex number
may be implemented as a read of each individual sub-value
(array element, struct field, or real/imaginary component),
in any order.
Similarly, a write of an array, struct, or complex number
may be implemented as a write of each individual sub-value,
in any order.
</p>

<p>

The most common is the implicit flow.

The most secure is the code flow, but it's more complex to implement as it requires more steps. As it is more complex, many providers end up suggesting the implicit flow.

/// note

It's common that each authentication provider names their flows in a different way, to make it part of their brand.