springmvc-入门

文章目录

• 1 maven从0搭建
• • 1.1 添加依赖
  • 1.2 添加spring-mvc配置
  • 1.3 创建webapp
  • 1.4 测试Controller
• 2 核心解析
• • 2.1 核心控制处理方法
  • 2.2 三大组件
  • 2.3 修改视图解析器默认参数
• 3 Controller响应
• • 3.1 页面跳转
  • • 3.1.1 返回字符串
    • 3.1.2 返回ModelAndView对象
  • 3.2 回写数据
  • • 3.2.1 输出流
    • 3.2.2 返回字符串
    • 3.2.3 返回对象或集合
    • • 3.2.3.1 返回对象
      • 3.2.3.2 返回集合
• 4 Controller请求
• • 4.1 基本数据类型参数
  • 4.2 POJO类型参数
  • 4.3 数组类型参数
  • 4.4 集合类型参数
  • 4.5 自定义类型转换器
• 5 注解

SpringMVC 是一种基于Java 的实现 MVC 设计模型的请求驱动类型的轻量级Web框架。

1 maven从0搭建 1.1 添加依赖

   org.springframework
    spring-context
    5.3.10



    org.springframework
    spring-webmvc
    5.3.10



   javax.servlet
   servlet-api
   2.5



   javax.servlet.jsp
   jsp-api
   2.0

1.2 添加spring-mvc配置

1.3 创建webapp

创建maven项目后，src/main下添加webapp文件夹及下级文件及文件夹，如下图：

web.xml文件内容：

    
    
        dispatcherServlet
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            classpath:spring-mvc.xml
        
        1
    
    
        dispatcherServlet
        /
    
    
    
        CharacterEncodingFilter
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            UTF-8
        
    
    
        CharacterEncodingFilter
        /*
    

注意：/代表对所有请求都进行过滤操作，都要经过dispatcherServlet，但是某些静态资源通过dispatcherServlet是找不到的，所以需要在spring-mvc.xml中增加排除过滤的配置
或者dispatcherServlet找不到时交由tomcat找的配置。

1.4 测试Controller

@Controller
public class TestController {

    @RequestMapping("/test")
    @ResponseBody
    public String printSome(){
        return "spring mvc test";
    }
}

tomcat配置：

启动tomcat，测试结果：

2 核心解析 2.1 核心控制处理方法

DispatcherServlet中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;
                    //1 查询handler，返回处理器执行链
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
                    //2 请求执行handler
                    //2.1 获取处理器适配器
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
                    //2.2 执行handler，并返回结果
                    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);
                }
                // 3 视图解析器进行处理
                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);
            }

        }
    }

2.2 三大组件

处理器映射器、处理器适配器、视图解析器是springmvc的三大组件，spring-webmvc包下org/springframework/web/servlet/DispatcherServlet.properties
中配置了这三大组件：

# 处理器映射器
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,
	org.springframework.web.servlet.function.support.RouterFunctionMapping

# 处理器适配器
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter

# 视图解析器
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

2.3 修改视图解析器默认参数

修改视图解析器中默认值：
（UrlbasedViewResolver中默认prefix、suffix均为""）

3 Controller响应 3.1 页面跳转 3.1.1 返回字符串

@RequestMapping("/test")
public String test1(){
    return "test";
}

返回值为：视图解析器中默认的参数prefix+“test”+suffix，如果要跳转去执行另一个controller方法，返回值可以为：

forward：路径
redirect：路径

3.1.2 返回ModelAndView对象

@RequestMapping("/test2")
public ModelAndView test2(){
    ModelAndView modelAndView = new ModelAndView();
    //重定向
    //modelAndView.setViewName("redirect:test.jsp");
    //转发
    modelAndView.setViewName("forward:test.jsp");
    modelAndView.addObject("user","marry");
    return modelAndView;
}

test.jsp中可以通过${user}显示。

3.2 回写数据 3.2.1 输出流

@RequestMapping("/test3")
public void test3(HttpServletResponse response) throws IOException {
     response.getWriter().print("testspringmvc");
 }

3.2.2 返回字符串

增加@ResponseBody注解：

@RequestMapping("/test4")
@ResponseBody
 public String test4(){
     return "test4";
 }

3.2.3 返回对象或集合

添加jackson依赖：

    com.fasterxml.jackson.core
    jackson-databind
    2.9.0

spring-mvc.xml中添加配置，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换：

或者使用springmvc的注解驱动：

3.2.3.1 返回对象

@RequestMapping("/test6")
@ResponseBody
public Map test6() throws Exception {
    Map map = new HashMap();
    map.put("name","kk");
    map.put("skil",new String[]{"lis","lll"});
    return map;
}

3.2.3.2 返回集合

@RequestMapping("/test7")
@ResponseBody
public List test7() throws Exception {
    List