SpringBoot之web功能

最新推荐文章于 2024-05-13 12:03:34 发布
最新推荐文章于 2024-05-13 12:03:34 发布
阅读量387 收藏
点赞数
分类专栏： sprint boot 文章标签： spring boot 前端 java

1. 静态资源访问

只有把静态资源在类路径下：called /static (or /public or /resources or /META-INF/resources。如下图
在这里插入图片描述
访问资源：当前项目根路径/+ 静态资源名 ,如下图
在这里插入图片描述
原理：静态映射所有请求/**，当请求进来，先去找Controller看能不能处理，不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面

1.1 改变默认的静态资源路径

只需要在application.yml配置属性和在类路径下创建同名的文件夹即可。

spring:
  web:
    resources:
      static-locations: [classpath:/res/]

1.2 静态资源访问前缀

访问静态静态默认是无前缀的，但是为了过滤请求，一般都会自定义访问前缀。在application.yml配置属性

spring:
  mvc:
    static-path-pattern: /aa/**

1.3 源码分析

前面我们说过SpringBoot的自动配置原理，SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类），帮助我们自动配置很多组件。在spring-boot-autoconfigure-2.6.6.jar包org.springframework.boot.autoconfigure中配置了web组件。如图
在这里插入图片描述
SpringMVC功能的自动配置类 WebMvcAutoConfiguration，已经生效

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration {

WebMvcAutoConfiguration配置类中为我们配置了很多组件，并帮助我们和配置文件做了绑定

    @Configuration( proxyBeanMethods = false)
    @Import({WebMvcAutoConfiguration.EnableWebMvcConfiguration.class})
    @EnableConfigurationProperties({WebMvcProperties.class, WebProperties.class})
    @Order(0)
    public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware {

配置文件的相关属性和xxx进行了绑定。

  • WebMvcProperties和spring.mvc做了属性绑定
@ConfigurationProperties(
    prefix = "spring.mvc"
)
public class WebMvcProperties {
  • WebProperties和spring.web做了属性绑定。
@ConfigurationProperties("spring.web")
public class WebProperties {
  • 以后配置web功能的属性都可以参考这个类
  • 我们发现WebMvcAutoConfigurationAdapter配置类只有一个有参构造器，这代表有参构造器所有参数的值都会从容器中确定。
  /**
  *(WebProperties webProperties:获取和spring.web绑定的所有的值的对象
  *WebMvcProperties mvcProperties:获取和spring.mvc绑定的所有的值的对象
  *ListableBeanFactory beanFactory:Spring的beanFactory
  *ObjectProvider<HttpMessageConverters> messageConvertersProvider:获取所有的HttpMessageConverters
  *ObjectProvider<WebMvcAutoConfiguration.ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider：找到资源处理器的自定义器。
  *ObjectProvider<DispatcherServletPath> dispatcherServletPath, 
  *ObjectProvider<ServletRegistrationBean<?>> servletRegistrations：给应用注册Servlet、Filter....
  */
  public WebMvcAutoConfigurationAdapter(WebProperties webProperties, 
										WebMvcProperties mvcProperties, 
										ListableBeanFactory beanFactory,
										ObjectProvider<HttpMessageConverters> messageConvertersProvider,
										ObjectProvider<WebMvcAutoConfiguration.ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider, 
										ObjectProvider<DispatcherServletPath> dispatcherServletPath, 
										ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
            this.resourceProperties = webProperties.getResources();
            this.mvcProperties = mvcProperties;
            this.beanFactory = beanFactory;
            this.messageConvertersProvider = messageConvertersProvider;
            this.resourceHandlerRegistrationCustomizer = (WebMvcAutoConfiguration.ResourceHandlerRegistrationCustomizer)resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
            this.dispatcherServletPath = dispatcherServletPath;
            this.servletRegistrations = servletRegistrations;
            this.mvcProperties.checkConfiguration();
        }

资源处理的默认规则

//静态资源处理器
public void addResourceHandlers(ResourceHandlerRegistry registry) {
			//判断是否禁用静态处理器，spring:web:resourcesadd-mappings: false
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
            	//webjars的规则
                this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
                this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
                    registration.addResourceLocations(this.resourceProperties.getStaticLocations());
                    if (this.servletContext != null) {
                        ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
                        registration.addResourceLocations(new Resource[]{resource});
                    }

                });
            }
        }

spring:
  web:
    resources:
      add-mappings: true   #禁用所有静态资源规则

2. 欢迎页支持

静态资源路径下 index.html

  • 可以配置静态资源路径
  • 但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问
spring:
#  mvc:
#    static-path-pattern: /aa/**   这个会导致welcome page功能失效

  resources:
    static-locations: [classpath:/res/]

也可以通过controller来处理/index。

2.1 源码分析

HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。 WelcomePageHandlerMapping就是处理欢迎页的处理器映射。

 @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
            return welcomePageHandlerMapping;
        }

//处理欢迎页的处理器映射
 WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders, ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
 		//要用欢迎页功能，必须是/**,这就是我们加了前缀不生效的原因，默认写死
        if (welcomePage != null && "/**".equals(staticPathPattern)) {
            logger.info("Adding welcome page: " + welcomePage);
            this.setRootViewName("forward:index.html");
        } else if (this.welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
            logger.info("Adding welcome page template: index");
            // 调用Controller  /index
            this.setRootViewName("index");
        }

    }

3. 自定义 Favicon

favicon.ico 放在静态资源目录下即可

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

4. 请求参数处理

4.1 请求映射

4.1.1 REST使用与原理

Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）
以前使用url请求资源：

  • /getUser 获取用户
  • /deleteUser 删除用户
  • /editUser 修改用户
  • /saveUser 保存用户

使用Rest风格url请求资源：

  • /user GET-获取用户
  • DELETE-删除用户
  • PUT-修改用户
  • POST-保存用户

接下来我们使用SpringBoot实现Rest风格的Http请求。

  1. 第一步：我们在static路径下创建一个测试页面
<body>
<h1>Hello, SpringBoot</h1>

<form action="/user" method="get">
    <input type="submit" value="get提交">
</form>
<br>
<form action="/user" method="post">
    <input type="submit" value="post提交">
</form>
<br>
<form action="/user" method="PUT">
    <input type="submit" value="PUT提交">
</form>
<br>
<form action="/user" method="DELETE">
    <input type="submit" value="DELETE提交">
</form>
<br>

</body>
  1. 第二步：编写UserController控制器
@RestController
public class UserController {

    @GetMapping("/user")
    //@RequestMapping(value = "/user",method = RequestMethod.GET)
    public String getUser(){
        return "GET-张三";
    }

    @PostMapping("/user")
    //@RequestMapping(value = "/user",method = RequestMethod.POST)
    public String saveUser(){
        return "POST-张三";
    }


    @PutMapping("/user")
    // @RequestMapping(value = "/user",method = RequestMethod.PUT)
    public String putUser(){
        return "PUT-张三";
    }

    @DeleteMapping("/user")
    //@RequestMapping(value = "/user",method = RequestMethod.DELETE)
    public String deleteUser(){
        return "DELETE-张三";
    }
}
  1. 第三步：测试
    在这里插入图片描述

get提交的测试图：
在这里插入图片描述

post提交的测试图：
在这里插入图片描述

PUT提交的测试图和DELETE提交的测试图：
在这里插入图片描述

  • 我们发现PUT和DELETE请求的最后没有生效，还是使用默认的get请求。这是因为form表单只有get和post两种请求方式，Rest使用客户端工具，如PostMan直接发送Put、delete等方式请求，无需Filter。但是如果使用表单来发送其他请求，还必须借助HiddenHttpMethodFilter过滤器。
  • HiddenHttpMethodFilter可以帮我们通过表单method=post，隐藏域 _method=put或者delete的方式来发送请求。SpringBoot已经帮我们配置好了。但是默认是禁用的，必须手动开启
spring:
 mvc:
   hiddenmethod:
     filter:
       enabled: true   #开启页面表单的Rest功能

  @Bean
    @ConditionalOnMissingBean({HiddenHttpMethodFilter.class})
    @ConditionalOnProperty(
        prefix = "spring.mvc.hiddenmethod.filter",
        name = {"enabled"}
    )
    public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
        return new OrderedHiddenHttpMethodFilter();
    }
  • 启用配置好就能正常访问了，不过还需要修改页面
<body>
<h1>Hello, SpringBoot</h1>

<form action="/user" method="get">
    <input type="submit" value="get提交">
</form>
<br>
<form action="/user" method="post">
    <input type="submit" value="post提交">
</form>
<br>
<form action="/user" method="post">
    <input type="hidden" name="_method" value="PUT">
    <input type="submit" value="PUT提交">
</form>
<br>
<form action="/user" method="post">
    <input type="hidden" name="_method" value="DELETE">
    <input type="submit" value="DELETE提交">
</form>
<br>

</body>

4.1.2 原理分析

上面我们说过表单PUT和DELERTE请求是通过HiddenHttpMethodFilter过滤器来帮助我们重写包装请求。源码分析

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
		//获取request
        HttpServletRequest requestToUse = request;
        //如果是POST请求且没有发生异常
        if ("POST".equals(request.getMethod()) && request.getAttribute("javax.servlet.error.exception") == null) {
        	//获取this.methodParam也就是_method的属性的值
            String paramValue = request.getParameter(this.methodParam);
            //判断是否存在
            if (StringUtils.hasLength(paramValue)) {
           		 //帮我们转换成大写
                String method = paramValue.toUpperCase(Locale.ENGLISH);
                //是否是允许的请求范围之内
                if (ALLOWED_METHODS.contains(method)) {
                	// 原生request(post)，使用包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
                    requestToUse = new HiddenHttpMethodFilter.HttpMethodRequestWrapper(request, method);
                }
            }
        }
		//过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。
        filterChain.doFilter((ServletRequest)requestToUse, response);
    }

当表单提交要使用REST风格的时候

  • 表单提交会带上_method=PUT。
  • 请求过来被HiddenHttpMethodFilter拦截。
  • 如果请求是POST并且是正常的，先获取到_method的值，如果是小写也会自动帮我转换成大写，然后判断是否兼容以下请求；PUT，DELETE，PATCH。
  • 如果是兼容的请求，把原生request(post)，使用包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
  • 过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。

4.1.3 如何把_method 换成我们自己喜欢的

只需要自定义一个filter即可

	//自定义filter
    @Bean
    public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
        HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
        methodFilter.setMethodParam("_self");
        return methodFilter;
    }

4.2 请求映射原理

4.2.1 SpringMVC工作原理

在这里插入图片描述

  1. 用户将请求发送到前端控制器DispatcherServlet。
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
  3. 处理器映射器找到具体的处理器（可以根据xml配置、注解进行查找），生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet。
  4. DispatcherServlet调用HandlerAdapter处理器适配器。
  5. HandlerAdapter经过适配调用具体的处理器（Controller,也叫后端控制器）。
  6. Controller执行完成返回ModelAndView。
  7. HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet。
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
  9. ViewReslover解析后返回具体View。
  10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
  11. DispatcherServlet响应用户。

组件说明：
以下组件通常使用框架提供实现：

  • DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。
  • HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
  • HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器。
  • ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。

组件：

  1. 前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
    作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。
    用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。
  2. 处理器映射器HandlerMapping(不需要工程师开发),由框架提供
    作用：根据请求的url查找Handler
    HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
  3. 处理器适配器HandlerAdapter
    作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
    通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
  4. 处理器Handler(需要工程师开发)
    注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
    Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
    由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。
  5. 视图解析器View resolver(不需要工程师开发),由框架提供
    作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
    View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。
    一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。
  6. 视图View(需要工程师开发jsp…)
    View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）

4.2.2 SpringBoot中springmvc源码分析

当用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
之前ssm框架中还需要我们手动在web.xml中配置DispatcherServlet，但是在SpringBoot中已经帮我们自动配置了，可以直接使用。

   @Bean(
            name = {"dispatcherServlet"}
        )
        public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
            DispatcherServlet dispatcherServlet = new DispatcherServlet();
            dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
            dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
            dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
            dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
            dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
            return dispatcherServlet;
        }

SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet->doService（）->doDispatch（）。也就是说具体的逻辑都在doDispatch()方法中。

 protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
 //省略其他代码
        try {
            this.doDispatch(request, response);
        } finally {
            if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) {
                this.restoreAttributesAfterInclude(request, attributesSnapshot);
            }

            if (this.parseRequestPath) {
                ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
            }
        }

    }

doDispatch()方法源码

 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    // 找到当前请求使用哪个Handler（Controller的方法）处理
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = HttpMethod.GET.matches(method);
                    if (isGet || HttpMethod.HEAD.matches(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }
4.2.2.1 如何通过url获得HandlerMapping

HandlerMapping 将会把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；

比如我们通过访问一个http://localhost:9080/hello来分析源码中如何得到Handler 。

 // 找到当前请求使用哪个Handler（Controller的方法）处理
                    mappedHandler = this.getHandler(processedRequest);

    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    	//获取对应的HandlerMapping
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();

			//遍历HandlerMapping寻找到对应的Handler
            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }

通过debug分析，发现handlerMappings 存在五个HandlerMapping。

  • RequestMappingHandlerMapping：保存了所有@RequestMapping 和handler的映射规则。也就是我们自己编写的Controller。
  • welcomePageHandlerMapping:欢迎页的处理。
    在这里插入图片描述
    执行到HandlerMapping mapping = (HandlerMapping)var2.next();发现我们自己编写的Controller。

HandlerMapping mapping = (HandlerMapping)var2.next();
最后返回HandlerExecutionChain对象，（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象
在这里插入图片描述

  • 所有的请求映射都在HandlerMapping中。
  • SpringBoot自动配置了默认 的 RequestMappingHandlerMapping。
  • SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html。
  • 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。如果有就找到这个请求对应的handler，然后返回对应的handler和拦截器。如果没有就是下一个HandlerMapping。
  • 我们需要一些自定义的映射处理，我们也可以自己给容器中放HandlerMapping。自定义 HandlerMapping
4.2.2.2 HandlerAdapter处理器处理请求参数

DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；

接下来我们写一个UserController 类来测试

@RestController
public class UserController {

    @GetMapping("/user")
    public String getUser(@RequestParam("name") String name){
        return "GET-"+name;
    }
  }

在org.springframework.web.servlet.DispatcherServlet类的doDispatch()方法中。

  • 为当前Handler 找一个适配器 HandlerAdapter； RequestMappingHandlerAdapter
  • 适配器执行目标方法并确定方法参数的每一个值
 HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter adapter = (HandlerAdapter)var2.next();
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
    }

在这里插入图片描述

  • 0 ： 支持方法上标注@RequestMapping
  • 1 ：支持函数式编程的

执行目标方法

//DispatcherServlet -- doDispatch
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

在org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter类执行目标方法

mav = invokeHandlerMethod(request, response, handlerMethod); //执行目标方法

参数解析器-HandlerMethodArgumentResolver
确定将要执行的目标方法的每一个参数的值是什么;
SpringMVC目标方法能写多少种参数类型。取决于参数解析器。
在这里插入图片描述
在这里插入图片描述

  • 当前解析器是否支持解析这种参数
  • 支持就调用 resolveArgument

返回值处理器

在这里插入图片描述
真正执行目标方法

//ServletInvocableHandlerMethod
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
//获取方法的参数值
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

如何确定目标方法每一个参数的值
在InvocableHandlerMethod类中

 protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        MethodParameter[] parameters = this.getMethodParameters();
        if (ObjectUtils.isEmpty(parameters)) {
            return EMPTY_ARGS;
        } else {
            Object[] args = new Object[parameters.length];

            for(int i = 0; i < parameters.length; ++i) {
                MethodParameter parameter = parameters[i];
                parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
                args[i] = findProvidedArgument(parameter, providedArgs);
                if (args[i] == null) {
                    if (!this.resolvers.supportsParameter(parameter)) {
                        throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
                    }

                    try {
                        args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
                    } catch (Exception var10) {
                        if (logger.isDebugEnabled()) {
                            String exMsg = var10.getMessage();
                            if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                                logger.debug(formatArgumentError(parameter, exMsg));
                            }
                        }

                        throw var10;
                    }
                }
            }

            return args;
        }
    }

挨个判断所有参数解析器那个支持解析这个参数

 @Nullable
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        HandlerMethodArgumentResolver result = (HandlerMethodArgumentResolver)this.argumentResolverCache.get(parameter);
        if (result == null) {
            Iterator var3 = this.argumentResolvers.iterator();

            while(var3.hasNext()) {
                HandlerMethodArgumentResolver resolver = (HandlerMethodArgumentResolver)var3.next();
                if (resolver.supportsParameter(parameter)) {
                    result = resolver;
                    this.argumentResolverCache.put(parameter, resolver);
                    break;
                }
            }
        }

        return result;
    }

解析这个参数的值

调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可
4.2.2.3Map、Model原理缺少

37集到42集没看，后续补上。

4.2.2.3

5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

5. 视图解析与模板引擎

视图解析：SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。

5.1 视图解析

5.1 thymeleaf使用

5.1.1 引入Starter

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

5.1.1 自动配置好了thymeleaf

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ThymeleafProperties.class)
@ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })
@AutoConfigureAfter({ WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })
public class ThymeleafAutoConfiguration { }

自动配好的策略

  • 所有thymeleaf的配置值都在 ThymeleafProperties。
  • 配置好了 SpringTemplateEngine 。
  • 配好了 ThymeleafViewResolver 。
  • 我们只需要直接开发页面
	public static final String DEFAULT_PREFIX = "classpath:/templates/";

	public static final String DEFAULT_SUFFIX = ".html";  //xxx.html
qq_39093474
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot之webservice
清风自来
06-03 260
下面记录并分享一版用springboot写的webservice实例： 1、新建一个maven项目，并加入依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UT...
SpringBoot 集成Webservice
qq_42291606的博客
11-11 145
引用依赖 <!--Webservice--> <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-rt-frontend-jaxws</artifactId> ...
springframework.web.servlet.resource.NoResourceFoundException: No static resource favicon.ico.
li_tianyang的博客
01-29 6159
springboot 单体项目已请求接口就报这个错误，问题是spring boot没有找到favicon.ico图片资源，所以就抛出了这个异常，很鸡肋，不处理看着难受，处理的话又找不到原因。3、clear maven ，重新启动项目。这里有个小坑，需要彻底地重新加载资源，很多时候是放进去试一下，好像不不行，就认为这个方法不行（我就是这样）2、在项目resources创建static文件夹，把favicon.ico放到文件夹里面。1、随便找一张图片，命名为favicon.ico。
静态资源相关问题-springboot
前后端分离，人不分离！
02-08 3922
通过web访问项目中（resources文件夹下）的静态资源！
记录一个离谱的错误
最新发布
u013742687的博客
05-13 637
在spring boot 3.x版本中引入knife4j的时候，发现浏览器直接打开接口文档是正常的，但是试图将接口导入到apifox中的时候，报错。通过对比日志,发现当不拦截这个异常时,会触发。的初始化,可能跟拦截器的优先级有点关系吧。如果有清楚原因的大佬,欢迎评论区解惑~~不理解,但可以解决问题。
springboot工程集成前端编译包，用于uni-app webView工程，解决其需独立部署带来的麻烦，场景如页面-＞画布-＞图片-＞pdf
weixin_44659286的博客
08-11 1866
【代码】springboot工程集成前端编译包，用于uni-app webView工程，解决其需独立部署带来的麻烦，场景如生成页面->画布->图片->pdf。
Spring mvc 项目中页面访问不到静态文件，如img ， js ， css 等
responsecool的专栏
08-25 3599
Spring mvc 项目中页面访问不到静态文件，如img ， js ， css 等 起因：我们通常在springmvc项目中web.xml配置文件中的内容为： springmvc001-servlet org.springframework.web.servlet.DispatcherServlet contextConfigLocatio
4.springboot整合web及原理
qq_44959735的博客
07-06 1433
1、简介 使用SpringBoot； 1）、创建SpringBoot应用，选中我们需要的模块； 2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来 3）、自己编写业务代码； 自动配置原理？ 这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx xxxxAutoConfiguration：帮我们给容器中自动配置组件； xxxxProperties:配置类来封装配置文件的内容； 2、SpringBoot对静态资源的映射规
SpringBoot集成各种功能合集
04-07
1. **自动配置**：SpringBoot的核心特性之一是自动配置。通过`@EnableAutoConfiguration`注解，SpringBoot会根据项目依赖自动配置相应的Bean，极大地减少了手动配置的工作量。 2. **起步依赖（Starter）**：...
springboot-web的简单demo
08-20
在“springboot-web的简单demo”项目中，我们可以看到这个项目是一个基于 SpringBoot 构建的 Web 项目。SpringBoot 为 Web 开发提供了便捷的构建方式，通过内嵌的 Tomcat 或 Jetty 服务器，我们可以无需额外配置就能...
SpringBoot-Web素材.rar
03-02
SpringBoot是一款由Pivotal团队创建的Java框架，它旨在简化Spring应用的初始搭建以及开发过程，通过内嵌的Tomcat服务器和自动配置功能，让开发人员可以快速构建健壮的Web应用程序。 1. **SpringBoot核心概念**： -...
Springboot vue导出功能实现代码
08-19
Springboot Vue 导出功能实现代码知识点总结 一、Springboot Vue 导出功能实现代码概述 本文主要介绍了 Springboot Vue 导出功能实现代码，通过示例代码详细介绍了如何使用 Vue 2 和 Springboot 2.x 实现导出功能...
SpringBoot Web工程框架
06-09
在这个“SpringBoot Web工程框架”中，我们将会探讨如何使用SpringBoot搭建一个功能完备的Web平台。 首先，SpringBoot的核心特性包括自动配置、内嵌Servlet容器（如Tomcat）以及起步依赖（Starter POMs）。自动配置...
SpringBoot之Web开发基础
qq_58833273的博客
07-04 362
RequestMapping注解提供了method参数指定请求的Method类型，包括RequestMethod.GET、RequestMethod.POST、RequestMethod.DELETE等值，分别对应HTTP请求的Method。将请求参数绑定到控制器的方法参数上，接收的参数来自HTTP请求体或请求url的QueryString，当请求的参数名称与Controller的业务方法参数名称一致时,@RequestParam可以省略。如果请求的是页面和数据，使用@Controller注解即可;
SpringBoot 中,自定义资源文件夹为本地时. Resource not found
酸菜鱼
12-29 5452
通过实现 `WebMvcConfigurer` 接口的 `addResourceHandlers` 方法,为静态资源指定搜索的本地路径时,资源文件未找到.
@GetMapping,@PostMapping,@PutMapping注解无value值时的情况
热门推荐
一剑轻语
04-03 1万+
背景：来新公司看了一下公司的代码，发现很喜欢不写value值。都是@GetMapping,@PostMapping,@PutMapping等 知识：这三个注解都是基于@RequestMapping来的 @RequestMapping有多个属性。而@GetMapping()=@RequestMapping(method=RequestMethod.Get)。@PostMap...
SpringBoot第十三天 - Web视图解析
adas5f1a51的博客
05-29 290
SpringBoot - Web视图解析 了解认识视图解析器，学习视图解析原理，探讨SpringBoot解析视图的方式。 1. 返回视图的三种方式 我们知道处理器方法不加@ResponseBody注解时，处理请求后服务端返回的是一个页面。 让处理器返回视图一共有三种方式： 返回String字符串，字符串对应的是视图的逻辑视图名； 返回ModelAndView对象，并设置视图名； 返回值为空或其他类型，这时SpringMVC会解析请求路径为默认视图名。 2. 视图解析原理(源码) 我们常用第一种方式返回视
Spring Boot配置Spring MVC自定义404等异常
19：30的博客
08-12 1221
Spring Boot 前言 在如今前后端开发完全分离的当下，通常后端会返回统一的自定义json数据格式（全局异常也需要返回相同的格式），前端也会封装全局请求的回调处理。在写这篇文章时，我自己也正在单独开发了一套前后端完全分离的项目，用于巩固前后端知识。在这期间遇到的问题和解决方式会在下面进行展示,，温馨提醒，文章因为将代码都贴上了，所以比较长，并且代码都是从微服务各个模块中拷贝的，可能包名会不一样，建议先在web单体项目中进行完整复制测试。 总览 文章解决了哪些问题： 统一接口的返回格式 自定义异常 全
springboot搭建web项目
08-25
- *1* *3* [springboot搭建web项目完整步骤(简易，一看就会！)](https://blog.csdn.net/weixin_56281219/article/details/117121783)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值