
# All properties

Every property `spring_boot_starter_web` reads, grouped by prefix. Each row gives the key, its type and allowed values, its default, what it does, and the page that explains it in detail.

## Why

Most of the starter is configured with properties, not code. This page is the one place where all of them are listed, so you can check a key, its default and its unit without reading every page. The starter's own metadata (`lib/spring_gen/spring_metadata.json`) lists the same 76 keys, so editors with completion offer them too.

## Example

A realistic configuration of a shop's backend behind a TLS proxy, with uploads, sessions and a built web app.

```yaml
# lib/resources/application.yml
server:
  port: 8080
  address: 127.0.0.1
  shutdown: graceful
  context-path: /shop
  max-http-request-body-size: 10MB
  connection-timeout: 30s
  request-timeout: 15s
  max-concurrent-requests: 500
  retry-after: 2s
  forward-headers-strategy: native
  forward-headers:
    trusted-proxies: 127.0.0.1,::1
  compression:
    enabled: true
    mime-types: text/html,text/css,text/javascript,application/javascript,application/json,application/problem+json
    min-response-size: 2KB
  mime-mappings:
    wasm: application/wasm
  session:
    timeout: 30m
    max-sessions: 10000
    cookie:
      name: SHOPSESSION
      path: /shop
      http-only: true
      same-site: lax
  websocket:
    max-text-message-size: 64KB
    max-binary-message-size: 1MB
    send-buffer-size-limit: 512KB
    send-time-limit: 10s
spring:
  main:
    register-shutdown-hook: true
  lifecycle:
    timeout-per-shutdown-phase: 20s
  mvc:
    log-request-details: false
    static-path-pattern: /**
    async:
      request-timeout: 30m
    sse:
      heartbeat-interval: 15s
  web:
    multipart:
      enabled: true
      max-file-size: 5MB
      max-request-size: 20MB
      max-part-count: 20
      file-size-threshold: 64KB
      location: /var/tmp/shop-uploads
    resources:
      static-locations: file:build/web/
      add-mappings: true
      spa-fallback: true
      directory-index: true
      cache:
        use-last-modified: true
        cachecontrol:
          max-age: 1h
          cache-public: true
          stale-while-revalidate: 1m
      chain:
        compressed: true
```

The same in `.properties`:

```properties
# lib/resources/application.properties
server.port=8080
server.address=127.0.0.1
server.shutdown=graceful
server.context-path=/shop
server.max-http-request-body-size=10MB
server.connection-timeout=30s
server.request-timeout=15s
server.max-concurrent-requests=500
server.retry-after=2s
server.forward-headers-strategy=native
server.forward-headers.trusted-proxies=127.0.0.1,::1
server.compression.enabled=true
server.compression.mime-types=text/html,text/css,text/javascript,application/javascript,application/json,application/problem+json
server.compression.min-response-size=2KB
server.mime-mappings.wasm=application/wasm
server.session.timeout=30m
server.session.max-sessions=10000
server.session.cookie.name=SHOPSESSION
server.session.cookie.path=/shop
server.session.cookie.http-only=true
server.session.cookie.same-site=lax
server.websocket.max-text-message-size=64KB
server.websocket.max-binary-message-size=1MB
server.websocket.send-buffer-size-limit=512KB
server.websocket.send-time-limit=10s
spring.main.register-shutdown-hook=true
spring.lifecycle.timeout-per-shutdown-phase=20s
spring.mvc.log-request-details=false
spring.mvc.static-path-pattern=/**
spring.mvc.async.request-timeout=30m
spring.mvc.sse.heartbeat-interval=15s
spring.web.multipart.enabled=true
spring.web.multipart.max-file-size=5MB
spring.web.multipart.max-request-size=20MB
spring.web.multipart.max-part-count=20
spring.web.multipart.file-size-threshold=64KB
spring.web.multipart.location=/var/tmp/shop-uploads
spring.web.resources.static-locations=file:build/web/
spring.web.resources.add-mappings=true
spring.web.resources.spa-fallback=true
spring.web.resources.directory-index=true
spring.web.resources.cache.use-last-modified=true
spring.web.resources.cache.cachecontrol.max-age=1h
spring.web.resources.cache.cachecontrol.cache-public=true
spring.web.resources.cache.cachecontrol.stale-while-revalidate=1m
spring.web.resources.chain.compressed=true
```

`spring.main.register-shutdown-hook` and `spring.lifecycle.timeout-per-shutdown-phase` belong to `spring_boot_dart`, not to this starter. They are in the example because a server needs them.

## Writing values

- **Durations:** `30s`, `500ms`, `5m`, `1h`, `2d`, or ISO 8601 (`PT30S`). A plain number is **milliseconds**, except for the keys marked "seconds without a unit" below. See [Durations](../spring-core-dart/conversion/durations.md).
- **Data sizes:** `512B`, `8KB`, `10MB`, `1GB`. A plain number is bytes. See [Data sizes](../spring-core-dart/conversion/data-size.md).
- **`-1`** means "no limit" where the table says so.
- **Enums** are written in lower case (`graceful`, `need`, `lax`). An unknown value stops the start with a binding failure that names the key.
- **Lists** are a comma list (`a,b`) or a YAML list. A list given in a higher source replaces the whole list.
- **Maps** (`server.mime-mappings.*`) take their entries from every source.
- **Relaxed names:** `server.max-http-request-body-size`, `server.maxHttpRequestBodySize` and the environment variable `SERVER_MAXHTTPREQUESTBODYSIZE` are the same key. On the command line: `--server.port=9090`.
- **Renamed keys:** `server.servlet.*` and `spring.servlet.multipart.*` (Spring Boot's names) stop the start and name the new keys (`server.*`, `spring.web.multipart.*`).

See [@ConfigurationProperties](../spring-core-dart/config/configuration-properties.md) and [Environment](../spring-core-dart/config/environment.md).

## `server.*`: the server

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.port` | `int` | `8080` | The port to listen on. `0` picks a free port, published in `local.server.port`. A port in use fails the start with `Web server failed to start. Port 8080 was already in use.` → [The embedded server](server/index.md) |
| `server.address` | `String`: IP address or host name | all interfaces; `127.0.0.1` in Flutter apps | The address to listen on. `localhost` is `127.0.0.1`; a host name is looked up at start. → [The embedded server](server/index.md) |
| `server.shutdown` | `graceful` / `immediate` | `graceful` | `graceful` takes no new connections and lets running requests finish within `spring.lifecycle.timeout-per-shutdown-phase`; `immediate` cuts them. → [Shutdown](server/shutdown.md) |
| `server.context-path` | `String` | none | A prefix of every path (`/shop`). It is removed before routing; other paths get a 404. A missing leading `/` is added, trailing ones dropped. → [The embedded server](server/index.md) |
| `server.max-http-request-body-size` | `DataSize`, or `-1` | `10MB` | A larger request body is answered with 413, whatever its type. Uploads use `spring.web.multipart.max-request-size` instead. `-1`: no limit. → [The embedded server](server/index.md) |
| `server.connection-timeout` | `Duration`; `0` or less: none | `60s` | How long a request body may send nothing before a 408 (the connection then closes); also how long an idle keep-alive connection stays open. → [Timeouts](server/timeouts.md) |
| `server.request-timeout` | `Duration`; `0` or less: none | none | The longest the filters and the handler may take to start the answer, else a 503; the request's `RequestDeadline`. Streams and WebSocket handshakes are not timed. → [Timeouts](server/timeouts.md) |
| `server.max-concurrent-requests` | `int`; `0` or less: none | none | The most requests an isolate answers at a time, event streams not counted. One past it is answered 503 with `Retry-After` at once, instead of waiting behind the others; its connection stays open for the next try. → [Overload](server/overload.md) |
| `server.max-connections` | `int`; `0` or less: none | none | The most connections an isolate keeps open. While it has more, every request is answered 503 with `Retry-After` and its connection closed, until the number is back under the limit. → [Overload](server/overload.md) |
| `server.retry-after` | `Duration` | `1s` | The `Retry-After` of those 503, in whole seconds, at least `1`. → [Overload](server/overload.md) |
| `server.mime-mappings.*` | map: extension → media type | empty | More `Content-Type`s of static files by extension, on top of the built-in ones; a listed extension wins. Matched in any case. Example: `server.mime-mappings.wasm=application/wasm`. → [The embedded server](server/index.md), [Static resources](static-resources.md) |

## `server.ssl.*`: TLS

TLS is on when `server.ssl.certificate` is set and `server.ssl.enabled` is not `false`.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.ssl.enabled` | `bool` | `true` | `false` ignores the other `server.ssl.*` keys: plain HTTP. → [TLS](server/ssl.md) |
| `server.ssl.certificate` | `String`: a file path | none | The certificate chain, a PEM file. Setting it turns TLS on. Not a `resources:` location. → [TLS](server/ssl.md) |
| `server.ssl.certificate-private-key` | `String`: a file path | none | The private key, a PEM file. Required with `certificate`, else the start fails with `server.ssl.certificate needs server.ssl.certificate-private-key`. → [TLS](server/ssl.md) |
| `server.ssl.key-password` | `String` | none | The password of an encrypted private key. → [TLS](server/ssl.md) |
| `server.ssl.trust-certificate` | `String`: a file path | none | The certificates client certificates must be signed by, a PEM file. Used with `client-auth`. → [TLS](server/ssl.md) |
| `server.ssl.client-auth` | `none` / `want` / `need` | `none` | Asks clients for a certificate. `want`: served anyway without one; `need`: a request without one gets a 403. → [TLS](server/ssl.md) |

## `server.compression.*`: gzip

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.compression.enabled` | `bool` | `false` | Gzip the answers of `mime-types` from `min-response-size` on (or of unknown length), for clients that accept gzip. Never partial content, an answer with a `Content-Encoding`, or one with a strong `ETag`. Adds `Vary: Accept-Encoding`. → [Compression](server/compression.md) |
| `server.compression.mime-types` | `List<String>` of media types; `text/*` allowed | `text/html`, `text/xml`, `text/plain`, `text/css`, `text/javascript`, `application/javascript`, `application/json`, `application/xml` | The media types compressed. Setting it replaces the list. Add `text/event-stream` to compress event streams. → [Compression](server/compression.md) |
| `server.compression.min-response-size` | `DataSize` | `2KB` | The smallest `Content-Length` compressed. → [Compression](server/compression.md) |

## `server.isolates.*`: the pool of isolates

Every isolate of the pool runs the whole application with its own beans. Read [What changes with more than one isolate](server/isolates.md#what-changes-with-more-than-one-isolate) before raising `count`.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.isolates.count` | a number, or `auto` | `1` | How many isolates serve the port at the start. `auto`: one per processor core. `1`: the application's own isolate only. → [A pool of isolates](server/isolates.md) |
| `server.isolates.drain-timeout` | `Duration` | `30s` | How long an isolate that leaves the pool may finish its requests before it is stopped anyway. → [Scaling the isolates](server/scaling.md#adding-and-removing) |
| `server.isolates.scaling` | `manual` / `auto` | `manual` | Who changes the number of isolates while the server runs: only the application, through the `IsolateScaler` bean, or the scaling policy too. → [Scaling the isolates](server/scaling.md) |
| `server.isolates.min` | `int` | `1` | The fewest isolates scaling goes down to. → [Scaling the isolates](server/scaling.md) |
| `server.isolates.max` | `int` | not set: the processor cores, or `count` when that is more | The most isolates scaling goes up to. Above one, the server has a pool (and an `IsolateScaler`) even with `count: 1`. → [Scaling the isolates](server/scaling.md) |
| `server.isolates.scale-up-lag` | `Duration` | `5ms` | How late the isolates' event loops run on average when the default policy calls them overloaded. → [Scaling the isolates](server/scaling.md#the-default-policy-by-lag) |
| `server.isolates.scale-up-after` | `Duration` | `5s` | How long the isolates must be late before the default policy adds some. → [Scaling the isolates](server/scaling.md#the-default-policy-by-lag) |
| `server.isolates.scale-down-after` | `Duration` | `2m` | How long the isolates must be free before the default policy removes one. → [Scaling the isolates](server/scaling.md#the-default-policy-by-lag) |
| `server.isolates.cooldown` | `Duration` | `15s` | The pause after a scaling step before the policy is asked again. → [Scaling the isolates](server/scaling.md#automatic-scaling) |

`server.max-concurrent-requests`, `server.max-connections` and `server.session.max-sessions` are per isolate.

## `server.session.*`: sessions

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.session.timeout` | `Duration`; seconds without a unit | `30m` | How long a session lives without a request. `server.session.timeout=90` is 90 seconds. → [Sessions](sessions.md) |
| `server.session.max-sessions` | `int`, or `-1` | `10000` | The most sessions kept at once. At the limit, expired sessions are removed first; if the store is still full, the new session is refused with a 503 and a warning `Session limit 10000 reached: refused a new session (raise server.session.max-sessions)`. A live session is never pushed out. `-1`: no limit. → [Sessions](sessions.md) |
| `server.session.cookie.name` | `String` | `JSESSIONID` | The name of the session cookie. → [Sessions](sessions.md) |
| `server.session.cookie.domain` | `String` | none | The cookie's `Domain`. None: the cookie goes back only to the host that set it. → [Sessions](sessions.md) |
| `server.session.cookie.path` | `String` | `server.context-path`, or `/` | The cookie's `Path`. → [Sessions](sessions.md) |
| `server.session.cookie.http-only` | `bool` | `true` | Sends `HttpOnly`: scripts cannot read the cookie. → [Sessions](sessions.md) |
| `server.session.cookie.secure` | `bool` | not set: secure when the request was | Sends `Secure`: HTTPS only. Not set: `Secure` on HTTPS requests (also behind a TLS proxy with `server.forward-headers-strategy`). → [Sessions](sessions.md) |
| `server.session.cookie.same-site` | `lax` / `strict` / `none` / `unset` | `lax` | The cookie's `SameSite`. `unset` sends none; browsers want `Secure` with `none`. → [Sessions](sessions.md) |

## `server.websocket.*`: WebSocket sessions

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.websocket.max-text-message-size` | `DataSize`, or `-1` | `8KB` | The largest text message a session reads, in UTF-8 bytes; a larger one closes the session with 1009. → [WebSocket](server/websocket.md) |
| `server.websocket.max-binary-message-size` | `DataSize`, or `-1` | `8KB` | The largest binary message a session reads; a larger one closes the session with 1009. → [WebSocket](server/websocket.md) |
| `server.websocket.send-buffer-size-limit` | `DataSize`, or `-1` | `512KB` | How much may wait to be sent to a slow client (pongs included); past it the connection is dropped with close status 4500. → [WebSocket](server/websocket.md) |
| `server.websocket.send-time-limit` | `Duration`, or `-1` | `10s` | How long what was sent may take to leave; past it the connection is dropped with 4500. → [WebSocket](server/websocket.md) |

## `server.forward-headers*`: behind a reverse proxy

| Key | Type | Default | Meaning |
|---|---|---|---|
| `server.forward-headers-strategy` | `none` / `native` / `framework` | `none` | `native` and `framework` (the same here) apply `Forwarded` or `X-Forwarded-Proto`, `-Host`, `-Port`, `-For` from trusted proxies: the scheme, host, port and client address. → [Reverse proxy](server/reverse-proxy.md) |
| `server.forward-headers.trusted-proxies` | `List<String>` of IP addresses and CIDR ranges | `127.0.0.0/8`, `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `169.254.0.0/16`, `100.64.0.0/10`, `::1/128`, `fc00::/7`, `fe80::/10` | Whose forwarded headers are believed. Setting it replaces the default list. An invalid entry stops the start (`Not an address or range: ...`). → [Reverse proxy](server/reverse-proxy.md) |

## `spring.mvc.*`: requests, streams, static path

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.mvc.log-request-details` | `bool` | `false` | Shows the values of parameters and headers in the dispatcher's debug and trace lines. Credentials stay `masked`. → [The embedded server](server/index.md) |
| `spring.mvc.static-path-pattern` | `String`: a path pattern | `/**` | The path the static resources of `spring.web.resources.static-locations` are served under: `/assets/**` serves `static/app.css` as `/assets/app.css`. The welcome page only with `/**`. → [Static resources](static-resources.md) |
| `spring.mvc.async.request-timeout` | `Duration` | none | The timeout of an `SseEmitter` created without one: its `onTimeout` callbacks run, then it completes. Not for `Stream` results. → [Server-sent events](streaming/sse.md), [Timeouts](server/timeouts.md) |
| `spring.mvc.sse.heartbeat-interval` | `Duration` | none | Sends a comment line in every open event stream at this interval, so proxies keep idle streams open. This starter's own key. → [Server-sent events](streaming/sse.md) |

## `spring.web.multipart.*`: uploads

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.multipart.enabled` | `bool` | `true` | `false`: `multipart/*` requests are not parsed, and `@RequestPart` parameters answer 400. → [Uploads](streaming/uploads.md) |
| `spring.web.multipart.max-file-size` | `DataSize`, or `-1` | `1MB` | The largest file (or other part) of an upload; above it a 413 (`MaxUploadSizeExceededException`). → [Uploads](streaming/uploads.md) |
| `spring.web.multipart.max-request-size` | `DataSize`, or `-1` | `10MB` | The largest multipart request as a whole; above it a 413. Replaces `server.max-http-request-body-size` for uploads. → [Uploads](streaming/uploads.md) |
| `spring.web.multipart.max-part-count` | `int`, or `-1` | `50` | The most parts (files and fields) of a multipart request; above it a 413. Spring Boot's `server.tomcat.max-part-count`. → [Uploads](streaming/uploads.md) |
| `spring.web.multipart.file-size-threshold` | `DataSize` | `0B` | Files above this size go to a temporary file; smaller ones stay in memory. With `0B` every file goes to disk (to memory where there is no `dart:io`). → [Uploads](streaming/uploads.md) |
| `spring.web.multipart.location` | `String`: a directory path | the system's temporary directory | Where the private directory (`0700`) of the temporary files is made. The files have random names and are deleted when the request ends or fails. → [Uploads](streaming/uploads.md) |

## `spring.web.resources.*`: static resources

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.resources.static-locations` | `List<String>` of `resources:` and `file:` locations | `resources:static/`, `resources:public/` | Where static files are read from, in order; the first location with the file wins. `resources:` is a folder of `lib/resources/` (embedded, files up to 1 MB), `file:` a directory read at run time. The root `resources:` or another prefix stops the start. → [Static resources](static-resources.md) |
| `spring.web.resources.add-mappings` | `bool` | `true` | `false` turns off the default mapping and the welcome page. Mappings of `WebMvcConfigurer.addResourceHandlers` stay. → [Static resources](static-resources.md) |
| `spring.web.resources.spa-fallback` | `bool` | `false` | A browser's `GET` or `HEAD` of a path with no file and no handler, whose last segment has no extension and whose `Accept` names `text/html`, gets `index.html` instead of a 404 (never under `.well-known/`). This starter's own key. → [Static resources](static-resources.md) |
| `spring.web.resources.directory-index` | `bool` | `false` | A path with no file whose folder holds an `index.html` gets it: `/guide` and `/guide/` get `guide/index.html`. Asked before `spa-fallback`. This starter's own key. → [Static resources](static-resources.md) |
| `spring.web.resources.chain.compressed` | `bool` | `false` | Serves `app.js.br` (first) or `app.js.gz` next to `app.js` to clients that accept it, with `Content-Encoding` and `Vary: Accept-Encoding`. → [Static resources](static-resources.md) |

### `spring.web.resources.cache.*`

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.resources.cache.period` | `Duration`; seconds without a unit | none: no `Cache-Control` | `Cache-Control: max-age=<seconds>`; `0` sends `no-store`. Any `cachecontrol.*` key replaces it. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.use-last-modified` | `bool` | `true` | Sends `Last-Modified` and answers `If-Modified-Since` with 304. → [Static resources](static-resources.md) |

### `spring.web.resources.cache.cachecontrol.*`

When any of these keys is set, they make the `Cache-Control` header and `cache.period` is not used. `no-store` wins over `no-cache`, which wins over `max-age`; the other directives are added after it. A boolean key does something only when `true`.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.resources.cache.cachecontrol.max-age` | `Duration`; seconds without a unit | none | `max-age`: how long the answer may be reused without asking the server. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.no-cache` | `bool` | none | `no-cache`: reused only after the server confirmed it. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.no-store` | `bool` | none | `no-store`: never stored. Wins over `no-cache` and `max-age`. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.must-revalidate` | `bool` | none | `must-revalidate`: once stale, not used without asking the server. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.no-transform` | `bool` | none | `no-transform`: proxies must not change the content. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.cache-public` | `bool` | none | `public`: shared caches (CDNs, proxies) may store the answer too. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.cache-private` | `bool` | none | `private`: only the user's own cache may store the answer. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.proxy-revalidate` | `bool` | none | `proxy-revalidate`: `must-revalidate` for shared caches only. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.s-max-age` | `Duration`; seconds without a unit | none | `s-maxage`: how long shared caches may keep the answer. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.stale-while-revalidate` | `Duration`; seconds without a unit | none | `stale-while-revalidate`: how long a stale answer may be used while a fresh one is fetched. → [Static resources](static-resources.md) |
| `spring.web.resources.cache.cachecontrol.stale-if-error` | `Duration`; seconds without a unit | none | `stale-if-error`: how long a stale answer may be used when the server fails. → [Static resources](static-resources.md) |

## `spring.web.rate-limit.*`: rate limiting

Off until `rules` has a rule or `enabled` is `true`. Every key, with its type and default, is on its page: → [Rate limiting](rate-limiting.md#properties).

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.rate-limit.enabled` | `bool` | not set: on when `rules` has a rule | Whether requests are limited. → [Rate limiting](rate-limiting.md) |
| `spring.web.rate-limit.rules[n].*` | list | empty | The rules: `path`, `methods`, `key`, `limit`, `burst`, `name`, `on-store-failure`. → [Rate limiting](rate-limiting.md#example) |
| `spring.web.rate-limit.store` | `memory` / `primary-isolate` / `jdbc` / `procedure` / `d1` | the most specific the application has | Where the buckets are kept. → [Rate limiting](rate-limiting.md#the-store-where-the-buckets-are-kept) |
| `spring.web.rate-limit.on-store-failure` | `deny` / `allow` | `deny` | What a request gets when the store cannot be reached: a `503`, or through and not counted. |
| `spring.web.rate-limit.verify-store` | `bool` | `true` | Whether the store is asked at startup that its table, function or binding is there; missing, the application does not start. |
| `spring.web.rate-limit.trusted-proxies` | list of addresses and CIDR ranges | empty | The reverse proxies whose `client-address-header` is read. → [Rate limiting](rate-limiting.md#the-clients-address) |

## `spring.web.debug.*`: debug features

Each is in the build only when asked for: the generator reads the `enabled` key from `application.yml` or `application.properties` when `build_runner` runs.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.web.debug.qps.enabled` | `bool` | `false` | `true`: the build has the filter that counts the requests and `RequestRates`, which logs requests per second and answers the actuator's `qps` endpoint. Without it, none of that code. → [Requests per second](server/qps.md) |
| `spring.web.debug.qps.log-interval` | `Duration` | `10s` | The length of a window: how often the rate is worked out and logged. `0`: nothing is logged, and a window is the time between two reads of `/actuator/qps/now`. → [Requests per second](server/qps.md) |

## `spring.main.*` and `spring.test.*`: whether a server runs

| Key | Type | Default | Meaning |
|---|---|---|---|
| `spring.main.web-application-type` | `String`: `none`, or anything else | not set: a server starts | `none` (any case): the web beans and `MockMvc` exist, but no server starts. Any other value starts it. → [The embedded server](server/index.md) |
| `spring.test.web-environment` | `mock` / `random-port` / `defined-port` / `none` | not set: a server starts | Set by the test support (`springBootTest`, `ApplicationContextRunner`), not by you. Only `random-port` (port `0`) and `defined-port` (`server.port`) start a server. → [The embedded server](server/index.md), [Testing](testing.md) |

## `local.server.*`: written by the server

| Key | Type | Default | Meaning |
|---|---|---|---|
| `local.server.port` | `int` | set once the server listens | The port the server really listens on (also in `WebServerInitializedEvent`). Read it; setting it does nothing. → [The embedded server](server/index.md) |

## Keys that are not read

These Spring Boot keys have no effect here, or stop the start:

| Key | Here |
|---|---|
| `server.servlet.*` (`context-path`, `session.*`) | stop the start: use `server.context-path`, `server.session.*` |
| `spring.servlet.multipart.*` | stop the start: use `spring.web.multipart.*` |
| `server.http2.enabled` | not read: `dart:io` speaks HTTP/1.1 |
| `server.max-http-request-header-size` | not read |
| `server.ssl.key-store`, `trust-store`, `bundle`, `protocol`, `ciphers` | not read: PEM files only |
| `server.compression.excluded-user-agents` | not read |
| `server.error.*`, `spring.mvc.problemdetails.enabled` | not read: errors are always `ProblemDetail`s |
| `spring.web.cors.*` | not read: CORS is set in code (see [CORS](cors.md)) |
| `spring.web.resources.chain.enabled`, `chain.cache`, `chain.strategy.*` | not read |
| `server.tomcat.*`, `server.jetty.*`, `server.undertow.*`, `server.netty.*` | not read |

## In Spring (Java)

The keys follow Spring Boot's `ServerProperties`, `WebMvcProperties`, `MultipartProperties` and `WebProperties.Resources`. Differences that matter:

- `server.servlet.*` is `server.*`, and `spring.servlet.multipart.*` is `spring.web.multipart.*`: there is no servlet container.
- These keys are this starter's own: `server.max-http-request-body-size`, `server.request-timeout`, `server.max-concurrent-requests`, `server.max-connections`, `server.retry-after`, `server.isolates.*`, `spring.web.debug.*`, `server.forward-headers.trusted-proxies`, `server.websocket.*`, `spring.mvc.sse.heartbeat-interval`, `spring.web.multipart.max-part-count` (Boot: `server.tomcat.max-part-count`), `spring.web.resources.spa-fallback` and `spring.web.resources.directory-index`.
- `server.connection-timeout` is the key Spring Boot 2.0 had (Boot 3 and 4: `server.tomcat.connection-timeout`).
- `spring.web.resources.static-locations` takes `resources:` and `file:`, not `classpath:`. `META-INF/resources/` and `resources/` are not in the defaults.
- `spring.web.multipart.file-size-threshold` is `0B` and `location` is this starter's own temporary directory.

## See also

- [Overview](index.md)
- [The embedded server](server/index.md)
- [Differences from Spring](differences.md)
- [@ConfigurationProperties](../spring-core-dart/config/configuration-properties.md)
- [Environment](../spring-core-dart/config/environment.md)
- [Profiles](../spring-core-dart/config/profiles.md)
- [Durations](../spring-core-dart/conversion/durations.md)
- [Data sizes](../spring-core-dart/conversion/data-size.md)
