problem
The previous project is springboot1.5. Later, I want to upgrade to 2.0. But after upgrading, I found that the webmvcconfigureadapter abstract class is out of date

@Deprecated
public abstract class WebMvcConfigurerAdapter implements WebMvcConfigurer {

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addFormatters(FormatterRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addInterceptors(InterceptorRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addCorsMappings(CorsRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addViewControllers(ViewControllerRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
}

/**
 * {@inheritDoc}
 * <p>This implementation is empty.
 */
@Override
public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
}

/**
 * {@inheritDoc}
 * <p>This implementation returns {@code null}.
 */
@Override
@Nullable
public Validator getValidator() {
    return null;
}

/**
 * {@inheritDoc}
 * <p>This implementation returns {@code null}.
 */
@Override
@Nullable
public MessageCodesResolver getMessageCodesResolver() {
    return null;
}

}
WebMvcConfigurerAdapter is a typical adapter. There is no abstract method in this abstract class. All methods are an empty implementation of the interface. This advantage is that the user class only needs to inherit the adapter class and implement the interested methods
This abstract class in springboot 2.0 is out of date. We can directly implement the WebMvcConfigurer interface. 2.0 uses the java8 feature default method

public interface WebMvcConfigurer {

/**
 * Helps with configuring HandlerMappings path matching options such as trailing slash match,
 * suffix registration, path matcher and path helper.
 * Configured path matcher and path helper instances are shared for:
 * <ul>
 * <li>RequestMappings</li>
 * <li>ViewControllerMappings</li>
 * <li>ResourcesMappings</li>
 * </ul>
 * @since 4.0.3
 */
default void configurePathMatch(PathMatchConfigurer configurer) {
}

/**
 * Configure content negotiation options.
 */
default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
}

/**
 * Configure asynchronous request handling options.
 */
default void configureAsyncSupport(AsyncSupportConfigurer configurer) {
}

/**
 * Configure a handler to delegate unhandled requests by forwarding to the
 * Servlet container's "default" servlet. A common use case for this is when
 * the {@link DispatcherServlet} is mapped to "/" thus overriding the
 * Servlet container's default handling of static resources.
 */
default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
}

/**
 * Add {@link Converter}s and {@link Formatter}s in addition to the ones
 * registered by default.
 */
default void addFormatters(FormatterRegistry registry) {
}

/**
 * Add Spring MVC lifecycle interceptors for pre- and post-processing of
 * controller method invocations. Interceptors can be registered to apply
 * to all requests or be limited to a subset of URL patterns.
 * <p><strong>Note</strong> that interceptors registered here only apply to
 * controllers and not to resource handler requests. To intercept requests for
 * static resources either declare a
 * {@link org.springframework.web.servlet.handler.MappedInterceptor MappedInterceptor}
 * bean or switch to advanced configuration mode by extending
 * {@link org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
 * WebMvcConfigurationSupport} and then override {@code resourceHandlerMapping}.
 */
default void addInterceptors(InterceptorRegistry registry) {
}

/**
 * Add handlers to serve static resources such as images, js, and, css
 * files from specific locations under web application root, the classpath,
 * and others.
 */
default void addResourceHandlers(ResourceHandlerRegistry registry) {
}

/**
 * Configure cross origin requests processing.
 * @since 4.2
 */
default void addCorsMappings(CorsRegistry registry) {
}

/**
 * Configure simple automated controllers pre-configured with the response
 * status code and/or a view to render the response body. This is useful in
 * cases where there is no need for custom controller logic -- e.g. render a
 * home page, perform simple site URL redirects, return a 404 status with
 * HTML content, a 204 with no content, and more.
 */
default void addViewControllers(ViewControllerRegistry registry) {
}

/**
 * Configure view resolvers to translate String-based view names returned from
 * controllers into concrete {@link org.springframework.web.servlet.View}
 * implementations to perform rendering with.
 * @since 4.1
 */
default void configureViewResolvers(ViewResolverRegistry registry) {
}

/**
 * Add resolvers to support custom controller method argument types.
 * <p>This does not override the built-in support for resolving handler
 * method arguments. To customize the built-in support for argument
 * resolution, configure {@link RequestMappingHandlerAdapter} directly.
 * @param resolvers initially an empty list
 */
default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
}

/**
 * Add handlers to support custom controller method return value types.
 * <p>Using this option does not override the built-in support for handling
 * return values. To customize the built-in support for handling return
 * values, configure RequestMappingHandlerAdapter directly.
 * @param handlers initially an empty list
 */
default void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {
}

/**
 * Configure the {@link HttpMessageConverter}s to use for reading or writing
 * to the body of the request or response. If no converters are added, a
 * default list of converters is registered.
 * <p><strong>Note</strong> that adding converters to the list, turns off
 * default converter registration. To simply add a converter without impacting
 * default registration, consider using the method
 * {@link #extendMessageConverters(java.util.List)} instead.
 * @param converters initially an empty list of converters
 */
default void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
}

/**
 * A hook for extending or modifying the list of converters after it has been
 * configured. This may be useful for example to allow default converters to
 * be registered and then insert a custom converter through this method.
 * @param converters the list of configured converters to extend.
 * @since 4.1.3
 */
default void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
}

/**
 * Configure exception resolvers.
 * <p>The given list starts out empty. If it is left empty, the framework
 * configures a default set of resolvers, see
 * {@link WebMvcConfigurationSupport#addDefaultHandlerExceptionResolvers(List)}.
 * Or if any exception resolvers are added to the list, then the application
 * effectively takes over and must provide, fully initialized, exception
 * resolvers.
 * <p>Alternatively you can use
 * {@link #extendHandlerExceptionResolvers(List)} which allows you to extend
 * or modify the list of exception resolvers configured by default.
 * @param resolvers initially an empty list
 * @see #extendHandlerExceptionResolvers(List)
 * @see WebMvcConfigurationSupport#addDefaultHandlerExceptionResolvers(List)
 */
default void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
}

/**
 * Extending or modify the list of exception resolvers configured by default.
 * This can be useful for inserting a custom exception resolver without
 * interfering with default ones.
 * @param resolvers the list of configured resolvers to extend
 * @since 4.3
 * @see WebMvcConfigurationSupport#addDefaultHandlerExceptionResolvers(List)
 */
default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
}

/**
 * Provide a custom {@link Validator} instead of the one created by default.
 * The default implementation, assuming JSR-303 is on the classpath, is:
 * {@link org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean}.
 * Leave the return value as {@code null} to keep the default.
 */
@Nullable
default Validator getValidator() {
    return null;
}

/**
 * Provide a custom {@link MessageCodesResolver} for building message codes
 * from data binding and validation error codes. Leave the return value as
 * {@code null} to keep the default.
 */
@Nullable
default MessageCodesResolver getMessageCodesResolver() {
    return null;
}

}

WebMvcConfigurationSupport can also be used in 2.0, but this will invalidate the automatic configuration, which can only be effective after it is reconfigured
@Override

protected void addResourceHandlers(ResourceHandlerRegistry registry) {

    registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");

    super.addResourceHandlers(registry);

}
To sum up, the implementation of WebMvcConfigure interface in 2.0 is the most appropriate to configure interceptors