///

## Multiple body parameters { #multiple-body-parameters }

In the previous example, the *path operations* would expect a JSON body with the attributes of an `Item`, like:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}
```

But you can also declare multiple body parameters, e.g. `item` and `user`:

                throw new RuntimeException(e);
            }
        }, "Multiple close operations should not cause issues");

        // Verify iterator still works after multiple closes
        assertFalse(emptyIterator.hasNext(), "Iterator should still work after multiple closes");
        assertNull(emptyIterator.next(), "Iterator should still return null after multiple closes");
    }

    @Test

minio server --address :9003 /data/tenant3
```

![Example-1](https://github.com/minio/minio/blob/master/docs/screenshots/Example-1.jpg?raw=true)

### 1.2 Host Multiple Tenants on Multiple Drives (Erasure Code)

Use the following commands to host 3 tenants on multiple drives:

```sh
minio server --address :9001 /disk{1...4}/data/tenant1
minio server --address :9002 /disk{1...4}/data/tenant2

///

## Multiple Workers { #multiple-workers }

You can start multiple workers with the `--workers` command line option:

//// tab | `fastapi`

If you use the `fastapi` command:

<div class="termy">

```console

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Using the same dependency multiple times { #using-the-same-dependency-multiple-times }

If one of your dependencies is declared multiple times for the same *path operation*, for example, multiple dependencies have a common sub-dependency, **FastAPI** will know to call that sub-dependency only once per request.

        // Then
        assertNotNull(transportPool, "Transport pool should not be null");
        assertSame(transportPool, context.getTransportPool(), "Should return same instance on multiple calls");
    }

    @Test
    @DisplayName("getConfig should return the provided configuration")
    void testGetConfig() {
        // When
        Configuration config = context.getConfig();

        String[] permissions = fessUserBean.getPermissions();
        assertEquals(1, permissions.length);
        assertEquals("read", permissions[0]);

        // Test with multiple permissions
        testUser.setPermissions(new String[] { "read", "write", "delete" });
        permissions = fessUserBean.getPermissions();
        assertEquals(3, permissions.length);

        authenticationManager.insert(user);

        assertEquals(1, chain.updateCallCount);
        assertEquals(user, chain.lastUpdatedUser);
    }

    // Test insert with multiple chains
    public void test_insert_multipleChains() {
        User user = createTestUser("testuser");
        TestAuthenticationChain chain1 = new TestAuthenticationChain();

    }

    @Nested
    @DisplayName("Performance and concurrency")
    class PerformanceTests {

        @Test
        @DisplayName("Should handle multiple lookups efficiently")
        void testMultipleLookups() throws IOException {
            // Test that multiple lookups work correctly
            for (int i = 0; i < 100; i++) {
                assertEquals("application/pdf", mimeMap.getMimeType("pdf"));

## Query parameter list / multiple values { #query-parameter-list-multiple-values }

When you define a query parameter explicitly with `Query` you can also declare it to receive a list of values, or said in another way, to receive multiple values.

For example, to declare a query parameter `q` that can appear multiple times in the URL, you can write: