* be created automatically.
     *
     * @param output The file to serialize the settings to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param settings The settings to serialize, must not be {@code null}.
     * @throws IOException If the settings could not be serialized.
     */

     * created automatically.
     *
     * @param output The file to serialize the model to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param model The model to serialize, must not be {@code null}.
     * @throws IOException If the model could not be serialized.
     */

import com.esotericsoftware.kryo.serializers.CollectionSerializer;
import com.esotericsoftware.kryo.serializers.MapSerializer;

/**
 * A serializer class for handling object serialization and deserialization.
 * <p>
 * This class provides serialization capabilities using different serializers,
 * currently supporting Kryo and JavaBin serialization formats. The serializer

        assertTrue(s.contains("hello"));
    }

    @Test
    @DisplayName("Should serialize and deserialize preserving message and cause")
    void testJavaSerialization() throws Exception {
        // Given
        SpnegoException original = new SpnegoException("serialize me", new IllegalArgumentException("iaex"));

        // When
        byte[] bytes;

     * the method returns.
     *
     * @param output The writer to serialize the toolchains to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.
     * @param toolchains The toolchains to serialize, must not be {@code null}.
     * @throws IOException If the toolchains could not be serialized.
     */

  "content": "hello"
}
```

## Pydantic `bytes` for Output Data { #pydantic-bytes-for-output-data }

You can also use `bytes` fields with `ser_json_bytes` in the model config for output data, and Pydantic will *serialize* the bytes as base64 when generating the JSON response.

{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}

		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

// serialize will serialize the provided keys and values.
// The function will panic if keys/value slices aren't of equal length.
// Payload size can give an indication of expected payload size.
// If plSize is <= 0 it will be calculated.
func (x *xlMetaInlineData) serialize(plSize int, keys [][]byte, vals [][]byte) {
	if len(keys) != len(vals) {

    category=FastAPIDeprecationWarning,
    stacklevel=2,
)
class UJSONResponse(JSONResponse):
    """JSON response using the ujson library to serialize data to JSON.

    **Deprecated**: `UJSONResponse` is deprecated. FastAPI now serializes data
    directly to JSON bytes via Pydantic when a return type or response model is
    set, which is faster and doesn't need a custom response class.

    Read more in the

With a response model, FastAPI will use Pydantic to serialize the data to JSON, without using intermediate steps, like converting it with `jsonable_encoder`, which would happen in any other case.

And under the hood, Pydantic uses the same underlying Rust mechanisms as `orjson` to serialize to JSON, so you will already get the best performance with a response model.

When you create a **FastAPI** *path operation* you can normally return any data from it: a `dict`, a `list`, a Pydantic model, a database model, etc.

If you declare a [Response Model](../tutorial/response-model.md) FastAPI will use it to serialize the data to JSON, using Pydantic.

If you don't declare a response model, FastAPI will use the `jsonable_encoder` explained in [JSON Compatible Encoder](../tutorial/encoder.md) and put it in a `JSONResponse`.