or run

npx @tessl/cli init

tessl/maven-org-springframework--spring-webmvc

Spring Web MVC framework for building web applications and RESTful services with Model-View-Controller architecture

Workspace: tessl
Visibility: Public
Created: 1 day ago
Last updated: 1 day ago
Describes: pkg:maven/org.springframework/spring-webmvc@7.0.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework--spring-webmvc@7.0.0

Spring Web MVC

Spring Web MVC is the comprehensive web application framework within the Spring Framework that implements the Model-View-Controller pattern for building web applications and RESTful web services on the Java platform. It provides a flexible, annotation-based programming model for handling HTTP requests, rendering views, managing data binding and validation, handling exceptions, and serving static resources.

Package Information

Package Name: spring-webmvc
Maven Coordinates: org.springframework:spring-webmvc:7.0.1
Package Type: maven
Language: Java
Installation: Add to your Maven pom.xml:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>7.0.1</version>
</dependency>

Or Gradle build.gradle:

implementation 'org.springframework:spring-webmvc:7.0.1'

Core Imports

// Core annotations for controllers
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PatchMapping;

// Request parameter binding
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.ModelAttribute;

// Configuration
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

// Core framework classes
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.http.ResponseEntity;

Basic Usage

REST Controller Example

import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping
    public List<User> getAllUsers() {
        // Returns list of users as JSON
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User created = userService.save(user);
        return ResponseEntity.status(201).body(created);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(
            @PathVariable Long id,
            @RequestBody User user) {
        User updated = userService.update(id, user);
        return ResponseEntity.ok(updated);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

Configuration Example

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
            .allowedOrigins("http://localhost:3000")
            .allowedMethods("GET", "POST", "PUT", "DELETE");
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoggingInterceptor())
            .addPathPatterns("/api/**");
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
            .addResourceLocations("/public/");
    }
}

Architecture

Spring Web MVC is built around several key components that work together to handle web requests:

DispatcherServlet: The central front controller that dispatches requests to handlers and manages the request processing workflow
Handler Mappings: Map incoming requests to appropriate handler methods based on URL patterns, HTTP methods, and other criteria
Handler Adapters: Invoke handler methods and manage method argument resolution and return value handling
View Resolvers: Resolve logical view names to actual view implementations for rendering responses
Message Converters: Convert HTTP request/response bodies to/from Java objects (e.g., JSON, XML)
Exception Resolvers: Handle exceptions thrown during request processing and map them to appropriate responses
Interceptors: Provide pre- and post-processing of requests with the ability to intercept handler execution
Data Binding: Bind request parameters to method parameters and handle type conversion and validation

The framework follows a layered architecture where requests flow through the DispatcherServlet to handler mappings, then to controllers, through interceptors, with views rendered via view resolvers, and exceptions handled by exception resolvers.

Capabilities

Controller Annotations

Annotations for declaring controllers and mapping HTTP requests to handler methods. Essential for building web applications and REST APIs.

@Controller(String value() default "")
public @interface Controller {}

@RestController(String value() default "")  // Combines @Controller and @ResponseBody
public @interface RestController {}

@RequestMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    RequestMethod[] method() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface RequestMapping {}

@GetMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface GetMapping {}

@PostMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface PostMapping {}

@PutMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface PutMapping {}

@DeleteMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface DeleteMapping {}

@PatchMapping(
    String name() default "",
    String[] value() default {},
    String[] path() default {},
    String[] params() default {},
    String[] headers() default {},
    String[] consumes() default {},
    String[] produces() default {},
    String version() default ""  // Since 7.0
)
public @interface PatchMapping {}

Controller Annotations

Request Parameter Binding

Annotations for binding HTTP request data to method parameters including path variables, query parameters, headers, cookies, and request bodies.

@PathVariable(
    String value() default "",
    String name() default "",
    boolean required() default true
)
public @interface PathVariable {}

@RequestParam(
    String value() default "",
    String name() default "",
    boolean required() default true,
    String defaultValue() default ValueConstants.DEFAULT_NONE
)
public @interface RequestParam {}

@RequestBody(boolean required() default true)
public @interface RequestBody {}

@RequestHeader(
    String value() default "",
    String name() default "",
    boolean required() default true,
    String defaultValue() default ValueConstants.DEFAULT_NONE
)
public @interface RequestHeader {}

@CookieValue(
    String value() default "",
    String name() default "",
    boolean required() default true,
    String defaultValue() default ValueConstants.DEFAULT_NONE
)
public @interface CookieValue {}

@ModelAttribute(
    String value() default "",
    String name() default "",
    boolean binding() default true
)
public @interface ModelAttribute {}

@SessionAttribute(
    String value() default "",
    String name() default "",
    boolean required() default true
)
public @interface SessionAttribute {}

@RequestAttribute(
    String value() default "",
    String name() default "",
    boolean required() default true
)
public @interface RequestAttribute {}

@MatrixVariable(
    String value() default "",
    String name() default "",
    String pathVar() default "",
    boolean required() default true,
    String defaultValue() default ValueConstants.DEFAULT_NONE
)
public @interface MatrixVariable {}

Request Parameter Binding

Response Handling

Classes and annotations for handling HTTP responses, including ResponseEntity for fine-grained control, response body serialization, and response status codes.

public class ResponseEntity<T> extends HttpEntity<T> {
    // Constructors
    public ResponseEntity(HttpStatusCode status) {}
    public ResponseEntity(@Nullable T body, HttpStatusCode status) {}
    public ResponseEntity(HttpHeaders headers, HttpStatusCode status) {}  // Since 7.0
    public ResponseEntity(@Nullable T body, HttpHeaders headers, HttpStatusCode status) {}  // Since 7.0
    public ResponseEntity(@Nullable T body, @Nullable HttpHeaders headers, int rawStatus) {}  // Since 7.0

    // Static factory methods - Status codes
    public static BodyBuilder status(HttpStatusCode status) {}
    public static BodyBuilder status(int status) {}

    // Static factory methods - Success responses
    public static BodyBuilder ok() {}
    public static <T> ResponseEntity<T> ok(T body) {}
    public static <T> ResponseEntity<T> of(Optional<T> body) {}
    public static <T> ResponseEntity<T> ofNullable(@Nullable T body) {}

    // Static factory methods - Redirect/Created
    public static BodyBuilder created(URI location) {}
    public static BodyBuilder accepted() {}

    // Static factory methods - No content
    public static HeadersBuilder<?> noContent() {}

    // Static factory methods - Client errors
    public static BodyBuilder badRequest() {}
    public static HeadersBuilder<?> notFound() {}
    public static BodyBuilder unprocessableContent() {}  // Since 7.0
    @Deprecated(since = "7.0")
    public static BodyBuilder unprocessableEntity() {}

    // Static factory methods - Server errors
    public static BodyBuilder internalServerError() {}

    // Static factory methods - Problem details
    public static HeadersBuilder<?> of(ProblemDetail body) {}
}

@ResponseBody
public @interface ResponseBody {}

@ResponseStatus(
    HttpStatus value() default HttpStatus.INTERNAL_SERVER_ERROR,  // Alias for code
    HttpStatus code() default HttpStatus.INTERNAL_SERVER_ERROR,   // Since 4.2, alias for value
    String reason() default ""
)
public @interface ResponseStatus {}

Response Handling

Exception Handling

Annotations and classes for handling exceptions globally and locally, mapping exceptions to HTTP responses, and providing error handling advice.

@ExceptionHandler(
    Class<? extends Throwable>[] value() default {},
    Class<? extends Throwable>[] exception() default {},  // Since 6.2, alias for value
    String[] produces() default {}  // Since 6.2
)
public @interface ExceptionHandler {}

@ControllerAdvice(
    String name() default "",  // Since 6.1
    String[] value() default {},
    String[] basePackages() default {},
    Class<?>[] basePackageClasses() default {},
    Class<?>[] assignableTypes() default {},
    Class<? extends Annotation>[] annotations() default {}
)
public @interface ControllerAdvice {}

@RestControllerAdvice(
    String name() default "",  // Since 6.1
    String[] value() default {},
    String[] basePackages() default {},
    Class<?>[] basePackageClasses() default {},
    Class<?>[] assignableTypes() default {},
    Class<? extends Annotation>[] annotations() default {}
)  // Combines @ControllerAdvice and @ResponseBody
public @interface RestControllerAdvice {}

public abstract class ResponseEntityExceptionHandler {
    protected ResponseEntity<Object> handleExceptionInternal(
        Exception ex,
        Object body,
        HttpHeaders headers,
        HttpStatusCode status,
        WebRequest request) {}
}

Exception Handling

Configuration

Java-based configuration for Spring MVC including the @EnableWebMvc annotation and WebMvcConfigurer interface for customizing framework behavior.

@EnableWebMvc
public @interface EnableWebMvc {}

public interface WebMvcConfigurer {
    default void configurePathMatch(PathMatchConfigurer configurer) {}
    default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {}
    default void configureApiVersioning(ApiVersionConfigurer configurer) {}  // Since 7.0
    default void configureAsyncSupport(AsyncSupportConfigurer configurer) {}
    default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {}
    default void addFormatters(FormatterRegistry registry) {}
    default void addInterceptors(InterceptorRegistry registry) {}
    default void addResourceHandlers(ResourceHandlerRegistry registry) {}
    default void addCorsMappings(CorsRegistry registry) {}
    default void addViewControllers(ViewControllerRegistry registry) {}
    default void configureViewResolvers(ViewResolverRegistry registry) {}
    default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {}
    default void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {}
    default void configureMessageConverters(HttpMessageConverters.ServerBuilder builder) {}  // Since 7.0
    default void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {}
    default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {}  // Since 4.3
    default void addErrorResponseInterceptors(List<ErrorResponse.Interceptor> interceptors) {}  // Since 6.2
    default Validator getValidator() { return null; }
    default MessageCodesResolver getMessageCodesResolver() { return null; }

    // Deprecated methods (replaced in 7.0)
    @Deprecated(since = "7.0")
    default void configureMessageConverters(List<HttpMessageConverter<?>> converters) {}
    @Deprecated(since = "7.0")
    default void extendMessageConverters(List<HttpMessageConverter<?>> converters) {}
}

Configuration

View Resolution

View resolvers for rendering server-side templates and views including JSP, Thymeleaf, FreeMarker, and other template engines.

public interface ViewResolver {
    @Nullable View resolveViewName(String viewName, Locale locale) throws Exception;
}

public interface View {
    // Constants
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";

    // Methods
    String getContentType();
    void render(@Nullable Map<String,?> model, HttpServletRequest request, HttpServletResponse response)
        throws Exception;
}

public class ModelAndView {
    // Constructors
    public ModelAndView() {}
    public ModelAndView(String viewName) {}
    public ModelAndView(View view) {}
    public ModelAndView(String viewName, Map<String,?> model) {}
    public ModelAndView(String viewName, String modelName, Object modelObject) {}
    public ModelAndView(String viewName, HttpStatusCode status) {}
    public ModelAndView(String viewName, Map<String,?> model, HttpStatusCode status) {}
    public ModelAndView(View view, Map<String,?> model) {}
    public ModelAndView(View view, String modelName, Object modelObject) {}

    // View configuration
    public void setViewName(String viewName) {}
    public String getViewName() {}
    public void setView(View view) {}
    public View getView() {}
    public boolean hasView() {}
    public boolean isReference() {}

    // Model management
    public ModelMap getModelMap() {}
    public Map<String,Object> getModel() {}
    public ModelAndView addObject(String attributeName, Object attributeValue) {}
    public ModelAndView addObject(Object attributeValue) {}
    public ModelAndView addAllObjects(Map<String,?> modelMap) {}

    // Status management
    public void setStatus(HttpStatusCode status) {}
    public HttpStatusCode getStatus() {}

    // Utility methods
    public void clear() {}
    public boolean isEmpty() {}
    public boolean wasCleared() {}
}

View Resolution

Data Binding and Validation

Data binding capabilities for binding request parameters to form objects, type conversion, and validation using JSR-303/Bean Validation.

@Validated
public @interface Validated {}

@Valid  // From javax.validation
public @interface Valid {}

public interface Errors {
    String getObjectName();
    void reject(String errorCode);
    void reject(String errorCode, String defaultMessage);
    void rejectValue(String field, String errorCode);
    void rejectValue(String field, String errorCode, String defaultMessage);
    boolean hasErrors();
    boolean hasGlobalErrors();
    boolean hasFieldErrors();
    boolean hasFieldErrors(String field);
    List<ObjectError> getAllErrors();
    List<ObjectError> getGlobalErrors();
    List<FieldError> getFieldErrors();
    List<FieldError> getFieldErrors(String field);
    Object getFieldValue(String field);
}

public interface BindingResult extends Errors {
    Object getTarget();
    Map<String,Object> getModel();
}

Data Binding and Validation

CORS Configuration

Cross-Origin Resource Sharing (CORS) support for enabling cross-origin requests with fine-grained control over allowed origins, methods, and headers.

@CrossOrigin(
    String[] origins() default {},
    String[] originPatterns() default {},
    String[] allowedHeaders() default {},
    String[] exposedHeaders() default {},
    RequestMethod[] methods() default {},
    String allowCredentials() default "",
    String allowPrivateNetwork() default "",  // Since 5.3.32
    long maxAge() default -1
)
public @interface CrossOrigin {}

public class CorsConfiguration {
    public void setAllowedOrigins(List<String> origins) {}
    public void setAllowedOriginPatterns(List<String> patterns) {}
    public void setAllowedMethods(List<String> methods) {}
    public void setAllowedHeaders(List<String> headers) {}
    public void setExposedHeaders(List<String> headers) {}
    public void setAllowCredentials(Boolean allowCredentials) {}
    public void setAllowPrivateNetwork(Boolean allowPrivateNetwork) {}  // Since 5.3.32
    public void setMaxAge(Long maxAge) {}
}

CORS Configuration

Async Request Processing

Support for asynchronous request processing using Callable, DeferredResult, and reactive types for improved scalability.

public class DeferredResult<T> {
    public DeferredResult() {}
    public DeferredResult(Long timeoutValue) {}
    public DeferredResult(Long timeoutValue, Object timeoutResult) {}

    public boolean setResult(T result) {}
    public boolean setErrorResult(Object result) {}
    public void onTimeout(Runnable callback) {}
    public void onCompletion(Runnable callback) {}
    public void onError(Consumer<Throwable> callback) {}
}

public class ResponseBodyEmitter {
    public ResponseBodyEmitter() {}
    public ResponseBodyEmitter(Long timeout) {}

    public void send(Object object) throws IOException {}
    public void send(Object object, MediaType mediaType) throws IOException {}
    public void complete() {}
    public void completeWithError(Throwable ex) {}
    public void onTimeout(Runnable callback) {}
    public void onCompletion(Runnable callback) {}
    public void onError(Consumer<Throwable> callback) {}
}

public class SseEmitter extends ResponseBodyEmitter {
    public SseEmitter() {}
    public SseEmitter(Long timeout) {}

    public void send(SseEventBuilder builder) throws IOException {}
    public static SseEventBuilder event() {}

    public interface SseEventBuilder {
        SseEventBuilder id(String id);
        SseEventBuilder name(String eventName);
        SseEventBuilder reconnectTime(long reconnectTimeMillis);
        SseEventBuilder comment(String comment);
        SseEventBuilder data(Object object);
        SseEventBuilder data(Object object, MediaType mediaType);
    }
}

Async Request Processing

Static Resource Handling

Configuration for serving static resources like CSS, JavaScript, and images with support for caching, versioning, and content compression.

public class ResourceHttpRequestHandler extends WebContentGenerator
        implements HttpRequestHandler {
    public void setLocations(List<Resource> locations) {}
    public void setResourceResolvers(List<ResourceResolver> resolvers) {}
    public void setResourceTransformers(List<ResourceTransformer> transformers) {}
    public void setCacheControl(CacheControl cacheControl) {}
}

public interface ResourceResolver {
    Resource resolveResource(
        HttpServletRequest request,
        String requestPath,
        List<? extends Resource> locations,
        ResourceResolverChain chain);

    String resolveUrlPath(
        String resourcePath,
        List<? extends Resource> locations,
        ResourceResolverChain chain);
}

public interface ResourceTransformer {
    Resource transform(
        HttpServletRequest request,
        Resource resource,
        ResourceTransformerChain chain) throws IOException;
}

Static Resource Handling

Interceptors

Handler interceptors for pre-processing and post-processing of requests, enabling cross-cutting concerns like logging, authentication, and localization.

public interface HandlerInterceptor {
    default boolean preHandle(
        HttpServletRequest request,
        HttpServletResponse response,
        Object handler) throws Exception {
        return true;
    }

    default void postHandle(
        HttpServletRequest request,
        HttpServletResponse response,
        Object handler,
        ModelAndView modelAndView) throws Exception {}

    default void afterCompletion(
        HttpServletRequest request,
        HttpServletResponse response,
        Object handler,
        Exception ex) throws Exception {}
}

public interface AsyncHandlerInterceptor extends HandlerInterceptor {
    default void afterConcurrentHandlingStarted(
        HttpServletRequest request,
        HttpServletResponse response,
        Object handler) throws Exception {}
}

Interceptors

Functional Endpoints

Functional programming model for defining routes and handlers as an alternative to annotation-based controllers.

@FunctionalInterface
public interface HandlerFunction<T extends ServerResponse> {
    T handle(ServerRequest request) throws Exception;
}

@FunctionalInterface
public interface RouterFunction<T extends ServerResponse> {
    Optional<HandlerFunction<T>> route(ServerRequest request);

    default RouterFunction<T> and(RouterFunction<T> other) {}
    default RouterFunction<T> andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {}
    default <S extends ServerResponse> RouterFunction<S> filter(
        HandlerFilterFunction<T,S> filterFunction) {}
}

public interface ServerRequest {
    HttpMethod method();
    URI uri();
    HttpHeaders headers();
    <T> T body(Class<T> bodyType) throws IOException;
    Optional<String> param(String name);
    Map<String,String> pathVariables();
}

public interface ServerResponse {
    HttpStatusCode statusCode();
    HttpHeaders headers();

    static BodyBuilder ok() {}
    static BodyBuilder status(HttpStatusCode status) {}
    static BodyBuilder created(URI location) {}
}

Functional Endpoints

Multipart File Upload

Support for handling multipart file uploads in forms and API endpoints with automatic binding to method parameters.

public interface MultipartFile {
    String getName();
    String getOriginalFilename();
    String getContentType();
    boolean isEmpty();
    long getSize();
    byte[] getBytes() throws IOException;
    InputStream getInputStream() throws IOException;
    void transferTo(File dest) throws IOException, IllegalStateException;
    default void transferTo(Path dest) throws IOException, IllegalStateException {}  // Since 5.1
    default Resource getResource() {}  // Since 5.1
}

public interface MultipartResolver {
    boolean isMultipart(HttpServletRequest request);
    MultipartHttpServletRequest resolveMultipart(HttpServletRequest request)
        throws MultipartException;
    void cleanupMultipart(MultipartHttpServletRequest request);
}

@RequestPart(String value() default "", boolean required() default true)
public @interface RequestPart {}

Multipart File Upload

Internationalization

Locale resolution and message source integration for building internationalized applications with support for multiple languages.

public interface LocaleResolver {
    Locale resolveLocale(HttpServletRequest request);
    void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale);
}

public interface LocaleContextResolver extends LocaleResolver {
    LocaleContext resolveLocaleContext(HttpServletRequest request);
    void setLocaleContext(
        HttpServletRequest request,
        HttpServletResponse response,
        LocaleContext localeContext);
}

public class LocaleChangeInterceptor extends HandlerInterceptorAdapter {
    public void setParamName(String paramName) {}
    public void setHttpMethods(String... httpMethods) {}
    public void setIgnoreInvalidLocale(boolean ignoreInvalidLocale) {}
}

Internationalization

API Versioning

API versioning support introduced in Spring MVC 7.0 for managing multiple API versions with version extraction from headers, parameters, or paths.

// Version attribute on mapping annotations (since 7.0)
@RequestMapping(String version() default "")
@GetMapping(String version() default "")
@PostMapping(String version() default "")
@PutMapping(String version() default "")
@DeleteMapping(String version() default "")
@PatchMapping(String version() default "")

public class ApiVersionConfigurer {
    public ApiVersionConfigurer useRequestHeader(String headerName) {}
    public ApiVersionConfigurer useQueryParam(String paramName) {}
    public ApiVersionConfigurer useMediaTypeParameter(MediaType compatibleMediaType, String paramName) {}
    public ApiVersionConfigurer usePathSegment(int index) {}
    public ApiVersionConfigurer useVersionResolver(ApiVersionResolver... resolvers) {}
    public ApiVersionConfigurer setVersionParser(ApiVersionParser<?> versionParser) {}
    public ApiVersionConfigurer setVersionRequired(boolean required) {}
    public ApiVersionConfigurer setDefaultVersion(String defaultVersion) {}
    public ApiVersionConfigurer addSupportedVersions(String... versions) {}
    public ApiVersionConfigurer detectSupportedVersions(boolean detect) {}
    public void setSupportedVersionPredicate(Predicate<Comparable<?>> predicate) {}
    public ApiVersionConfigurer setDeprecationHandler(ApiVersionDeprecationHandler handler) {}
}

API Versioning

Content Negotiation

Content negotiation for determining the best representation format (JSON, XML, etc.) based on request headers and parameters.

public class ContentNegotiationManager implements ContentNegotiationStrategy {
    public ContentNegotiationManager(ContentNegotiationStrategy... strategies) {}
    public ContentNegotiationManager(Collection<ContentNegotiationStrategy> strategies) {}

    public List<MediaType> resolveMediaTypes(NativeWebRequest request)
        throws HttpMediaTypeNotAcceptableException;
}

public interface ContentNegotiationStrategy {
    List<MediaType> resolveMediaTypes(NativeWebRequest webRequest)
        throws HttpMediaTypeNotAcceptableException;
}

public class ContentNegotiationConfigurer {
    public ContentNegotiationConfigurer favorParameter(boolean favorParameter) {}
    public ContentNegotiationConfigurer parameterName(String parameterName) {}
    public ContentNegotiationConfigurer ignoreAcceptHeader(boolean ignoreAcceptHeader) {}
    public ContentNegotiationConfigurer defaultContentType(MediaType... defaultContentTypes) {}
    public ContentNegotiationConfigurer mediaType(String extension, MediaType mediaType) {}
}

Content Negotiation

Flash Attributes

Flash attributes for passing data between requests during redirects, commonly used for the Post/Redirect/Get pattern.

public class FlashMap extends HashMap<String,Object> {
    public void setTargetRequestPath(String path) {}
    public String getTargetRequestPath() {}
    public FlashMap addTargetRequestParams(MultiValueMap<String,String> params) {}
    public MultiValueMap<String,String> getTargetRequestParams() {}
}

public interface FlashMapManager {
    FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response);
    void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response);
}

public interface RedirectAttributes extends Model {
    RedirectAttributes addAttribute(String attributeName, Object attributeValue);
    RedirectAttributes addAttribute(Object attributeValue);
    RedirectAttributes addFlashAttribute(String attributeName, Object attributeValue);
    RedirectAttributes addFlashAttribute(Object attributeValue);
    Map<String,?> getFlashAttributes();
}

Flash Attributes

URI Building

Utilities for building URIs from controller mappings and request information with proper encoding and context path handling.

public class ServletUriComponentsBuilder extends UriComponentsBuilder {
    public static ServletUriComponentsBuilder fromContextPath(HttpServletRequest request) {}
    public static ServletUriComponentsBuilder fromServletMapping(HttpServletRequest request) {}
    public static ServletUriComponentsBuilder fromRequestUri(HttpServletRequest request) {}
    public static ServletUriComponentsBuilder fromRequest(HttpServletRequest request) {}
    public static ServletUriComponentsBuilder fromCurrentContextPath() {}
    public static ServletUriComponentsBuilder fromCurrentServletMapping() {}
    public static ServletUriComponentsBuilder fromCurrentRequestUri() {}
    public static ServletUriComponentsBuilder fromCurrentRequest() {}
}

public class MvcUriComponentsBuilder {
    public static UriComponentsBuilder fromController(Class<?> controllerType) {}
    public static UriComponentsBuilder fromMethodName(
        Class<?> controllerType,
        String methodName,
        Object... args) {}
    public static UriComponentsBuilder fromMethodCall(Object invocationInfo) {}
    public static UriComponentsBuilder fromMappingName(String mappingName) {}
    public static <T> T on(Class<T> controllerType) {}
}

URI Building

Core Framework Classes

Core framework classes including DispatcherServlet, handler mappings, handler adapters, and other central components.

public class DispatcherServlet extends FrameworkServlet {
    public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
    public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
    public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
    public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
    public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
    public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
    public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";

    public DispatcherServlet() {}
    public DispatcherServlet(WebApplicationContext webApplicationContext) {}

    public void setDetectAllHandlerMappings(boolean detectAllHandlerMappings) {}
    public void setDetectAllHandlerAdapters(boolean detectAllHandlerAdapters) {}
    public void setDetectAllHandlerExceptionResolvers(boolean detectAll) {}
    public void setDetectAllViewResolvers(boolean detectAllViewResolvers) {}
}

public interface HandlerMapping {
    // Constants for request attributes
    String BEST_MATCHING_HANDLER_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingHandler";
    String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";
    String BEST_MATCHING_PATTERN_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingPattern";
    String INTROSPECT_TYPE_LEVEL_MAPPING = HandlerMapping.class.getName() + ".introspectTypeLevelMapping";
    String URI_TEMPLATE_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".uriTemplateVariables";
    String MATRIX_VARIABLES_ATTRIBUTE = HandlerMapping.class.getName() + ".matrixVariables";
    String PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE = HandlerMapping.class.getName() + ".producibleMediaTypes";
    String API_VERSION_ATTRIBUTE = HandlerMapping.class.getName() + ".apiVersion";  // Since 7.0

    @Deprecated
    String LOOKUP_PATH = HandlerMapping.class.getName() + ".lookupPath";

    // Methods
    HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
    boolean usesPathPatterns();
}

public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(
        HttpServletRequest request,
        HttpServletResponse response,
        Object handler) throws Exception;
}

Core Framework Classes

Version

Tile

Files

tessl/maven-org-springframework--spring-webmvc

To install, run

index.mddocs/

Spring Web MVC

Package Information

Core Imports

Basic Usage

REST Controller Example

Configuration Example

Architecture

Capabilities

Controller Annotations

Request Parameter Binding

Response Handling

Exception Handling

Configuration

View Resolution

Data Binding and Validation

CORS Configuration

Async Request Processing

Static Resource Handling

Interceptors

Functional Endpoints

Multipart File Upload

Internationalization

API Versioning

Content Negotiation

Flash Attributes

URI Building

Core Framework Classes

Version

Tile

Files

tessl/maven-org-springframework--spring-webmvc

To install, run

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Spring Web MVC

Package Information

Core Imports

Basic Usage

REST Controller Example

Configuration Example

Architecture

Capabilities

Controller Annotations

Request Parameter Binding

Response Handling

Exception Handling

Configuration

View Resolution

Data Binding and Validation

CORS Configuration

Async Request Processing

Static Resource Handling

Interceptors

Functional Endpoints

Multipart File Upload

Internationalization

API Versioning

Content Negotiation

Flash Attributes

URI Building

Core Framework Classes

index.mddocs/