Skip to main content

spring_boot_starter_web 0.8.3 copy "spring_boot_starter_web: ^0.8.3" to clipboard
spring_boot_starter_web: ^0.8.3 copied to clipboard

Spring MVC for Dart: @RestController with @GetMapping and @PostMapping on dart:io, JSON bodies, @Valid, ProblemDetail errors, server-sent events, filters, CORS.

0.8.3 #

  • No changes of its own; released with the family version 0.8.3.

0.8.2 #

  • No changes of its own; released with the family version 0.8.2.

0.8.1 #

  • No changes of its own; released with the family version 0.8.1.

0.8.0 #

  • The rate limiter's store is asked at startup that it is set up (RateLimitStoreVerifier, an ApplicationRunner; stores that implement VerifiableRateLimitStore: the SQL store, Supabase's database function, Cloudflare D1). A table, a function or a binding that is missing fails the start with what to run; before, a forgotten migration showed only at the first request under a limit, as a 503. A store that cannot be reached at that moment is a WARN and the start goes on. spring.web.rate-limit.verify-store=false skips the check and its one call to the store.
  • Fixed: a question for the first isolate asked in another one (PrimaryIsolate.ask, IsolateScaler.scaleTo there) no longer waits for ever when no answer comes (the first isolate is stopping, its handler never answers): it fails with a TimeoutException that names the question after one minute, a scaling step after three.
  • A graceful stop (server.shutdown: graceful, the default) of a server without TLS first stops accepting connections, answers what still arrives on the open ones with Connection: close, and closes when they have left or have sent nothing for a moment (five seconds at most). Before, every keep-alive connection that was idle at that instant was closed at once, and with it a request its client had just sent: an isolate leaving the pool (server.isolates) under load lost a few requests each time, and so did a rolling restart. With TLS (dart:io keeps that socket to itself) and with server.shutdown: immediate the stop is as it was.
  • requestTargetProblem(uri): the built-in server's check of a request target (an encoded /, \ or NUL, a . or .. segment, a broken percent-escape: 400), for a WebServer of another kind; the edge starter's fetch server asks it too.
  • A rate limiter (spring.web.rate-limit.*): rules by path and method with a limit as <count>/<duration> (a token bucket, burst for its size) and a key (user, the default: the authenticated user, else the client's address; ip; a SpEL expression in #{...}; a key of a RateLimitKeyResolver bean). A request past a limit is answered 429 with Retry-After and a ProblemDetail (TooManyRequestsException) before its body is read; every matching rule applies; RateLimit-Limit / -Remaining / -Reset on the answers (headers: false turns them off). Off unless enabled: true or a rule exists.
  • Two filters (RateLimitFilter): the rules keyed by ip at -5000, before the sessions and the security filter chain, the rules keyed by the user or an expression at -50, right after the chain, where request.principal is the authenticated user. @RateLimiter('10/1m', key: ...) on a controller method or class (RateLimiterInterceptor); a controller with the annotation while nothing turned the limiter on stops the start.
  • The client's address (ClientAddressResolver, TrustedProxyClientAddressResolver): the connection's own unless it comes from spring.web.rate-limit.trusted-proxies (addresses and CIDR ranges, IPv4 and IPv6); then the entry of X-Forwarded-For (or client-address-header, such as CF-Connecting-IP) the first trusted proxy added, counting from the right. Without trusted proxies no header is read. hash-addresses with hash-secret stores addresses as their HMAC-SHA-256. IpRange is public.
  • The buckets live in the application's RateLimitStore: a bean of its own, else the Supabase starter's database function, else the data starter's SQL store, else the first isolate's for a pool of isolates, else memory (spring.web.rate-limit.store names one). A store that fails denies with 503 and Retry-After by default (on-store-failure: deny | allow, also per rule), with one log line that names the rule and never the key.
  • Fixed: the rate limiter counts an IPv6 client by the first 64 bits of its address (spring.web.rate-limit.ipv6-prefix-length, 1 to 128; TrustedProxyClientAddressResolver(ipv6PrefixLength:)), the rest zeroed. Counted by its whole address, a client that changed address inside its /64 at every request never reached a limit keyed by ip and filled memory.max-entries with buckets of one request, pushing other clients' out. 128 counts every address by itself, as before. IPv4 addresses (also mapped into IPv6) are counted whole, and the trusted proxies are still compared by their whole address.
  • Fixed: a rate limit key such as #{request.headers['X-Api-Key']} counts by the header: request.headers exists, and a header is found in any case in headers[...] and request.headers[...] (it was found only as headers['x-api-key'], and the rule counted by address without a word). An expression that cannot be parsed fails the start with the rule's name; one that reads what does not exist (RateLimitKeyException, which a RateLimitKeyResolver of the application may throw too) counts by address and is logged once per rule at WARN on spring.web.ratelimit. A header the request does not have, or no user, counts by address as before, with no warning.
  • Fixed: a client that asks and does not read the response no longer holds its request for ever: a response none of whose bytes leave for server.connection-timeout (60 s; counted per 64 KB of the body, and only while written bytes wait for the client) is given up, its connection dropped and its place of server.max-concurrent-requests free again. Before, a few such connections made every later request a 503, each kept its body in memory, and a graceful stop waited its whole timeout for them. A download of any size that keeps moving and a stream that is quiet between two events (server-sent events, NDJSON, addStream of a slow producer) are not cut; a body larger than 64 KB is now handed to dart:io in slices, and what is written while a flush is under way waits for it instead of failing. 0 for the timeout turns it off, as for the request body.
  • Fixed: a request that shows both Content-Length and Transfer-Encoding is answered 400 with Connection: close, and the connection closes. dart:io shows both only when the length comes first and the encoding is not written exactly chunked (Chunked, gzip, chunked); otherwise it drops the Content-Length itself and reads the body as chunked, and such a request is still served as a chunked one: a proxy in front must refuse them.
  • Changed: server.request-timeout is 60s by default (it was not set): a request whose body arrives a little at a time, never idle, is answered 503 when the minute is over. Streams, event streams and WebSocket handshakes are not cut, as before; 0 turns it off.

0.7.4 #

  • A pool of isolates serves the port (server.isolates.count: a number or auto, one per core): each isolate runs the whole application with its own beans, the first one (main) starts the others (isolate-1, …), restarts one that ends unexpectedly and stops them with the context; every start, scaling step and failure is logged. One warning names the beans that keep state per isolate (IsolateLocalState: the in-memory sessions). The IsolateScaler bean (scaleTo, scaleBy; in every isolate, the pool itself in the first and a bean that hands the step to it in the others) changes their number while the server runs, an isolate that leaves finishing its requests first (server.isolates.drain-timeout); server.isolates.scaling: auto lets a policy do it between min and max (LagScalingPolicy: by how late the isolates' event loops run; scale-up-lag, scale-up-after, scale-down-after, cooldown; an IsolateScalingPolicy bean replaces it).
  • The requests in flight and taken are in the isolate's row of the task manager (WebServerLoadSource, WebServerActivity).
  • The debug feature qps (spring.web.debug.qps.enabled: true, without which the build has none of its code): RequestRateFilter counts the requests of its isolate and RequestRates works out requests per second, p50/p95/p99 and errors for every isolate and in total each spring.web.debug.qps.log-interval, logged on spring.web.qps, and answers the other isolates through PrimaryIsolate.
  • A full server says so at once: past server.max-concurrent-requests (event streams not counted) or server.max-connections a request is answered 503 with Retry-After (server.retry-after) instead of waiting (past the connection limit the connection is closed too); no limit unless set.
  • The module is only where a server can run (ModulePlatform.native): a browser build of an application that has the starter among its dependencies carries none of it.
  • WebServerInitializedEvent names itself (eventName), readable in a release build.

0.7.3 #

  • No changes of its own; released with the family version 0.7.3.

0.7.2 #

  • README: the link goes to the package's own page on farum-azula.org, and what the README says was checked against the code and brought up to date.
  • The package's page on pub.dev links its documentation, farum-azula.org (documentation in pubspec.yaml).

0.7.1 #

Changes #

  • Static resources, as Spring Boot's ResourceHttpRequestHandler: the files of lib/resources/static/ and lib/resources/public/ (embedded by the generator) and of file: directories read at run time (an AOT executable's files, a flutter build web output) are served under /**, after the controllers. spring.web.resources.static-locations, add-mappings, cache.period, cache.use-last-modified, cache.cachecontrol.*, chain.compressed (precompressed .br / .gz with Content-Encoding and Vary: Accept-Encoding), spring.mvc.static-path-pattern and server.mime-mappings. Answers: Content-Type by extension with X-Content-Type-Options: nosniff, a weak ETag and Last-Modified with 304, Cache-Control, Range, HEAD; OPTIONS gets Allow, other methods a 405; index.html is the welcome page at / for clients that take HTML. spring.web.resources.spa-fallback (this starter's own key) answers a browser's deep link of a single-page app with index.html.
  • WebMvcConfigurer.addResourceHandlers with ResourceHandlerRegistry / ResourceHandlerRegistration (locations, setCachePeriod, setCacheControl, setUseLastModified, setCompressed) adds mappings; one with the default's pattern replaces it. ResourceHttpRequestHandler and the resourceHandlerMapping bean (ResourceHandlerMapping, order Ordered.lowestPrecedence - 1) are public.
  • The static resources fail closed: a path is decoded once and refused (404) for dot segments, encoded or doubly encoded separators and dots, backslashes, invalid or overlong UTF-8, control characters, ; and empty segments, Windows' device names, short names, streams and trailing dots, look-alike characters, WEB-INF / META-INF, and dot files (except .well-known/, whose apple-app-site-association is sent as application/json). A file is resolved with its symbolic links and refused when it leaves its location or is not a regular file; directories are never listed. The global CORS rules apply to them; filters (the security chain) run before them.
  • ResponseWriter.checkNotModified (Spring's checkNotModified) is public, and writeResource takes conditional: false for a caller that checked the conditions itself; If-Range then also matches a strong ETag.
  • The handlers for the actuator's mappings endpoint, in Spring WebFlux's shape: the dispatcherHandlersMappingDescriptions bean (DispatcherHandlersMappingDescriptions, dispatcherHandlers → webHandler) lists every handler of every DescribableHandlerMapping of the dispatcher: the controllers' request mappings (predicate as Spring's RequestMappingInfo.toString(), handler, details.handlerMethod, details.requestMappingConditions) and the static resources (ResourceWebHandler [...], the welcome page, the single-page app's fallback). describeRequestMapping writes one entry of that shape.
  • spring.web.resources.directory-index (this starter's own key, off by default): a path with no file whose folder holds an index.html gets that file (/guide and /guide/ get guide/index.html), before spa-fallback, as static hosts answer; the pages of spring.flutter.web.seo.* are served at their addresses this way. The file is looked up with the same checks as any static resource.
  • Fix: a Range header whose positions are not plain decimal digits (a sign, another base) is malformed and answered with the whole content; one such header could make a range that starts after the content and end the answer with an error instead of a response.
  • Fix: Range: bytes=500- past the end of a resource is a 416, not the whole content.

0.7.0 #

  • No changes of its own: its generated code (lib/spring_gen/) is regenerated with spring_core_dart_generator 0.7.0.

0.6.3 #

Changes #

  • The editor metadata of server.*, spring.web.multipart.*, spring.mvc.*, spring.main.web-application-type, spring.test.web-environment and local.server.port is made from code and the starter reads the same classes: ServerSettings (ssl, compression, websocket, session, forward-headers; Shutdown, ClientAuth, ForwardHeadersStrategy and SessionSameSite are enums), MultipartSettings, MvcSettings, WebMainSettings, WebTestSettings and LocalServerSettings are bound by the Binder; ServerProperties.of, HttpSessionProperties.of and MultipartProperties.of bind them, and .from builds the settings from the bound classes. The hand-written spring_metadata_additional.json is gone. spring.mvc.log-request-details is now in the metadata; the constants webEnvironmentProperty and logRequestDetailsProperty are gone. A value that does not fit (a port that is not a number, an unreadable server.session.max-sessions) now fails the binding naming the property.

0.6.2 #

  • feat: 0.6.2 — the theme (typed keys and messages, states, every component, a theme from a URL), (#20)

0.6.1 #

  • feat(flutter): the desktop window from properties — title bar, initia… (#18)

0.6.0 #

Breaking #

  • Properties renamed: spring.servlet.multipart.* is spring.web.multipart.*; server.servlet.context-path is server.context-path and server.servlet.session.* is server.session.* (there is no servlet container). An old name stops the start, naming the new one. The Boot 1 key server.context-path, which was read when server.servlet.context-path was not set, is now the key itself.

Changes #

  • server.request-timeout, a deadline for every request (no limit by default, 0 or less: none; an extension, Spring Boot has no such key): the filters and the handler run under a RequestDeadline of that length, and when it passes before the answer starts the answer is a 503 Service Unavailable problem (AsyncRequestTimeoutException, a generic detail, logged as a warning at most every 10 seconds). What the handler does afterwards is dropped (no second answer, no unhandled error); a response already committed is left alone; a response that becomes a stream (server-sent events, SseEmitter, a streamed body) leaves the deadline when it starts, and a WebSocket handshake is not timed. Code the request calls can read the deadline (RequestDeadline.current), and an error that ends a request after its deadline, or a RequestDeadlineExceededException, is a 503 instead of a 500. AsyncRequestTimeoutException takes an optional detail.
  • HandlerExceptionResolver, Spring's extension point for turning an error into an answer: a bean returns an ErrorResponse (status, headers and problem) or null to pass the error on. The resolvers are asked in @Order after the @ExceptionHandler methods of the controller and of the @ControllerAdvice beans (the application's handlers always win) and before the default 500; not for an error that is already an ErrorResponse or that a filter throws; a resolver that throws is logged and skipped. A library maps its exceptions to HTTP with it: with spring_boot_starter_data among the dependencies the generator adds one, so an OptimisticLockingFailureException and a DuplicateKeyException are a 409 and an EmptyResultDataAccessException a 404 (see the data starter).
  • The framework logs its main steps as Spring does, so logging.level.root=debug (or logging.level.web=debug) shows what happens: GET "/api/books", parameters={masked}, Mapped to BookController#search(), Completed 200 OK and Resolved [Type: detail] for the dispatcher; N mappings in 'requestMappingHandlerMapping' at debug and each mapping at trace; created, invalidated and re-keyed sessions (never their ids); the forwarded headers applied (scheme and host only); the parts and bytes of a multipart request. Parameters show as masked, and headers (trace) as {masked}, unless spring.mvc.log-request-details=true; even then Authorization, Cookie, Set-Cookie and any header or parameter whose name contains token, secret, key, password or session stay masked. Paths, parameter values and other client text go through LogFormatUtils.formatValue: line breaks show as <EOL>. The query string is not logged in the request line (parameters are, when allowed), unlike Spring.

Fixes #

  • @RequestParam and @RequestHeader on a Map (every query parameter or header) answered 500 when the map was typed (Map<String, String>, Map<String, List<String>>, Map<String, int>): the map is now built with the parameter's own key and value types; the same for a form read into a Map with @RequestBody.

0.5.0 #

Breaking #

  • @CrossOrigin() without methods allows only the method the handler is mapped to, as in Spring (it allowed GET, HEAD and POST): a cross-origin HEAD to a @GetMapping needs methods: ['GET', 'HEAD'].
  • Every cross-origin request is checked as Spring's DefaultCorsProcessor checks it, its own method included: an allowed origin's DELETE, PUT, HEAD or OPTIONS that the rules do not list is a 403 before the handler runs, with or without a pre-flight.
  • Only the bean named corsConfigurationSource is a CORS source, as in Spring Security (a CorsConfigurationSource bean of another name is ignored, and several such beans no longer fail the start). It is no longer combined with @CrossOrigin or the WebMvcConfigurer mappings: where it has a configuration for a request, that configuration alone applies, with and without the security starter. Where it has none, @CrossOrigin and the mappings apply.
  • Answers whose type the app didn't set have no Content-Type (dart:io's text/plain; charset=utf-8 default is gone); 1xx, 204 and 304 answers have no Content-Length or Transfer-Encoding, a 304 or 1xx no Content-Type, and a body written to them is dropped, as Tomcat does.
  • * in the allowed origins together with allowCredentials or allowPrivateNetwork, also inside a comma-separated value, stops the startup for a @CrossOrigin and makes the requests a 500 for a mapping or a bean, as in Spring.
  • CORS origin patterns are compared with case (origins without), by AllowedOrigins.
  • Every answer of a handler with CORS rules gets Vary: Origin, Access-Control-Request-Method, Access-Control-Request-Headers, a CORS request or not, as Spring adds it; a handler's own Vary (of a ResponseEntity or an ErrorResponse) is merged with these names instead of replacing them.
  • A pre-flight to a mapped path without CORS rules, and one from the server's own origin, gets a 200 without CORS headers (was a 403), as in Spring; a pre-flight for a method no handler of the path maps is decided by the global rules alone (a 403 when they refuse it, never a 405).
  • An Origin, or a pre-flight's requested method or headers, with a character outside visible US-ASCII is a 403 (was a 500 with a stack trace).
  • A ResponseEntity with a status of 200 and an ETag or Last-Modified answers a conditional GET or HEAD with a 304 (or a 412 for If-Unmodified-Since), as Spring's HttpEntityMethodProcessor.
  • A @RequestBody object in a request without a Content-Type is a 415, as Spring reads such a body as application/octet-stream (it was read as JSON); a Content-Type that is not a media type is a 415 too.
  • server.max-http-request-body-size limits every body, multipart/* ones included (the media type is checked before the body is read); only the multipart resolver reads uploads with spring.servlet.multipart.max-request-size instead.
  • A multipart request may have at most 50 parts (spring.servlet.multipart.max-part-count, -1: no limit; Tomcat's default in Boot 4); more is a 413.
  • The server answers a 400 before any filter, as Tomcat does, for an encoded /, \ or NUL in the path (%2F, %5C, %00), a . or .. segment behind matrix parameters (/files/..;/secret), a % escape in the path or the query that is not UTF-8, and a malformed or missing Host (or an absolute target naming another host); a form with a malformed % escape is a 400 too.
  • WebSocket server sessions read at most 8 KB per message, as Tomcat in Spring (server.websocket.max-text-message-size and max-binary-message-size; above, the session closes with 1009), negotiate no permessage-deflate, and drop a client that takes nothing past 512 KB waiting or 10 seconds (server.websocket.send-buffer-size-limit and send-time-limit; 4500), as Spring's ConcurrentWebSocketSessionDecorator.
  • @ControllerAdvice beans are tried in @Order, as in Spring: the first bean with a handler for the error answers it, even when a later bean has a more specific one.
  • A request body that sends nothing for server.connection-timeout (60 s, Tomcat's default; 0 or less: no limit) ends with a 408, and idle keep-alive connections close after the same time.
  • At server.servlet.session.max-sessions the in-memory repository removes every expired session and, when it is still full, refuses the new session with a TooManyActiveSessionsException (503), as WebFlux's InMemoryWebSessionStore does; a live session is never pushed out for a new one. The constants InMemoryHttpSessionRepository.loginAttribute, principalNameAttribute and principalKeyAttribute are removed. The security starter creates a session only at a login, so anonymous requests cannot fill the store.

Changes #

  • server.forward-headers-strategy (native or framework, Spring Boot's) adds ForwardedHeaderFilter, first of all filters: behind a reverse proxy the request gets the scheme, host, port and client address of Forwarded (RFC 7239) or X-Forwarded-Proto, -Host, -Port and -For, so cookies get Secure behind a TLS proxy and redirect URIs are https://. Only from the proxies of server.forward-headers.trusted-proxies (loopback and private networks by default, as Tomcat's RemoteIpValve; Spring's filter believes every peer); the client's address is the first from the right that is not a trusted proxy; invalid values are ignored; the headers are removed for the rest of the chain. X-Forwarded-Prefix is not read.
  • The private directory of the uploads' temporary files is rwx------ on Linux too (dart:io's createTemp made it rwxr-xr-x there, readable by every user of the machine; on macOS it was already private). When it can't be made private, the upload fails.
  • DispatcherHandler.corsConfigurationFor(request) gives the CORS rules of the mapping that would take a request, in the dispatcher's order (Spring's HandlerMappingIntrospector): a WebSocket handshake gets the corsConfigurationSource bean's rules or none, never the WebMvcConfigurer mappings.
  • A port in use fails the start, as in Spring Boot: the application waits for the server to listen before the ApplicationStartedEvent, the runners and the ApplicationReadyEvent, runAsync throws the PortInUseException, and the program ends with a non-zero exit code.
  • Graceful shutdown lets running requests finish within spring.lifecycle.timeout-per-shutdown-phase before the beans are destroyed (the lifecycle processor now has that timeout too).
  • An upload that fails inside a part (a limit, a broken body, a client that went away) is answered (413 or 400) instead of hanging, and its temporary files are deleted at once.
  • Uploads go to a private directory of the process (0700, random file names), made again when the system cleans its temporary directory.
  • @CrossOrigin defaults no longer widen the global CORS rules, as Spring's default markers: @CrossOrigin(methods: ['PUT']) under /api/** keeps the global origins and adds PUT.
  • allowPrivateNetwork on @CrossOrigin, CorsConfiguration and CorsRegistration answers Chrome's Private Network Access pre-flights with Access-Control-Allow-Private-Network: true; CorsConfiguration.validateAllowCredentials() and validateAllowPrivateNetwork() are Spring's checks.
  • CORS origins are checked by AllowedOrigins: port lists (http://localhost:[3000,3001], [*]), comma-separated values and a trailing /, as in Spring. Differs from Spring: an Origin longer than 1024 characters is never allowed (a pattern with several * froze the server on a large Origin).
  • A pre-flight is answered from the CORS rules of the first handler of its path and method, and an actual request from those of the handler that answers it, chosen with all its conditions. Differs from Spring when several handlers match a pre-flight equally: Spring allows it from any origin, here the other handlers' origins get a 403 (give such handlers the same rules).
  • Event streams (Stream, EventStream, NDJSON) are paused while an event is written, so a client that reads slowly slows the stream down instead of filling the server's memory; an SseEmitter whose unawaited sends reach 1000 for a client that reads nothing fails the next send with a StateError and ends.
  • ResponseEntity<SseEmitter>, ResponseEntity<EventStream<T>> and ResponseEntity<Stream<T>> write their events with the entity's status and headers.
  • Compression covers every response of server.compression.mime-types (Spring Boot's list) of at least server.compression.min-response-size (2 KB), not only byte streams; never one with a strong ETag; and every answer that could be compressed gets Vary: Accept-Encoding, also for a client without gzip, as Tomcat.
  • A body the handler does not read (an upload answered with a 413 or 415) gets its answer first; then up to 2 MB are read and dropped, for at most 5 seconds, as Tomcat's max-swallow-size, so the connection can serve the next request.
  • A handler that fails after the response was committed drops the connection without finishing the response, as Tomcat does (the response looked complete).
  • A response header dart:io cannot send (non-ASCII, a line break) is dropped and the error answered with a 500 problem (was an empty 200).
  • The server answers the WebSocket handshake itself: a missing, repeated or malformed Sec-WebSocket-Key is a 400, another Sec-WebSocket-Version a 426.
  • A 5xx answer an exception asks for (a ResponseStatusException, the 503 of a refused session) is logged as a warning without a stack trace, at most once every 10 seconds for the same kind; an unexpected exception is logged with its stack trace.
  • ServerProperties has the new settings: compressionMimeTypes, compressionMinResponseSize, connectionTimeout, webSocketMaxTextMessageSize, webSocketMaxBinaryMessageSize, webSocketSendBufferSizeLimit, webSocketSendTimeLimit.

0.4.3 #

  • Flutter security (#15)
  • feat: single sign-on with OAuth 2.0 / OpenID Connect (spring_boot_sta… (#11)
  • docs: the READMEs and docs/ rewritten: what it is, why and when you need it, an example, then Spring (#10)

0.4.2 #

  • Docs (#9)

0.4.1 #

  • feat: guides replace the examples; optional parameters from Dart nullability; coloured logs
  • feat: guides replace the examples; optional parameters from Dart nullability; coloured logs

0.4.0 #

  • HttpSession: request.getSession(), an in-memory HttpSessionRepository with expiry and a limit (server.servlet.session.timeout, .max-sessions, .cookie.*; SameSite=Lax by default), changeSessionId(); the session cookie is written by HttpSessionFilter.
  • @RequestParam reads the fields of application/x-www-form-urlencoded bodies too, like Spring MVC (readFormParameters).
  • A request target starting with // is no longer read as a host by dart:io: the path keeps its // (and is answered 404, or refused by the security starter's firewall).

0.3.2 #

  • Initial version: Spring MVC for Dart. @RestController classes with @GetMapping, @PostMapping, ... on dart:io's HttpServer (server.* properties), path variables, request parameters, headers and cookies, JSON bodies through the ObjectMapper, @Valid bodies, ResponseEntity, errors as ProblemDetail with @ExceptionHandler and @RestControllerAdvice, server-sent events (EventStream, SseEmitter), filters, interceptors, CORS, WebSocket endpoints of spring_boot_starter_websocket on the same server; MockMvc and springBootTest(webEnvironment:) in spring_boot_starter_test.
0
likes
0
points
2.25k
downloads

Documentation

Documentation

Publisher

verified publisherfarum-azula.org

Weekly Downloads

Spring MVC for Dart: @RestController with @GetMapping and @PostMapping on dart:io, JSON bodies, @Valid, ProblemDetail errors, server-sent events, filters, CORS.

Repository (GitHub)
View/report issues

Topics

#http #rest #server #spring

License

unknown (license)

Dependencies

spring_boot_dart, spring_boot_starter_logging, spring_web_dart

More

Packages that depend on spring_boot_starter_web