SpringMVC

本文主要是介绍SpringMVC，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1、SpringMVC

什么是MVC

MVC是一种软件的构想将软件按照模型、视图、控制器来划分

M：Model 模型，指的是JavaBean 实体Bean和业务处理Bean（实体类和Dao、Service）

V：View 视图，指Html或者JSP等页面

C：Controller 控制器，值工程中的Servlet，作用接收请求、响应请求

MVC工作流程：

用户通过视图发生请求到服务器，在服务器中被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller在根据请求处理的结果找到相应的View视图层，渲染数据后最终响应给游览器

2.什么是SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子模块，是Spring为表述层开发提供的一整套完备的解决方案

3.SpringMVC的特点

Spring家族原生产品，与IOC容器等基础设施无缝对接
基于原生的Servlet，通过功能强大的DispatchServlet，对请求和响应进行统一处理
代码清晰简洁
性能卓越

2、HelloWorld

web.xml配置

spring中要求配置文件位于recesouces下，则可以在web.xml的servlet配置中，配置init-param指定配置文件的位置，如果没有配置init-param，则需要在WEB-INF下创建名称为[servlet-name]-servlet.xml的配置文件

<!--    1.配置控制器 DispatcherServlet-->
<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!-- 指定SpringMVC配置文件的位置 -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <!-- 指定当前servlet的启动顺序 -->
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- "/" 所有的请求（不包括.jsp），交由控制器DispatcherServlet去处理 -->
    <!-- "/*" 所有的请求（包括.jsp) -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

springMVC.xml

<!--    1.组件加载-->
<context:component-scan base-package="com.potato.controller"/>
<!--    2.静态资源处理  需要和 <mvc:annotation-driven />   一起使用-->
<mvc:default-servlet-handler />
<!--    3.开启mvc注解驱动-->
<mvc:annotation-driven />
<!--    4.视图配置-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/static/html/" />
    <property name="suffix" value=".jsp" />
</bean>

HelloController.java

@Controller
@RequestMapping("/test")
public class HelloController {

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

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

index.jsp

在/WEB-INF/static/html/下创建index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<a href="${pageContext.request.contextPath}/hello">跳转</a>
</body>
</html>

配置启动Tomacat 即可完成web项目的访问

3、 @ReuqestMapping 注解

用于标识类或者方法

@Controller
@RequestMapping("/test")
public class HelloController {

    @RequestMapping("/index")  //访问路径为 /test/index
    public String index() {
        return "index";
    }

    @RequestMapping("/error")  //访问路径为 /test/error
    public String error() {
        return "error";
    }
}

@ReuqestMapping 属性值：

value：通过请求路径匹配请求映射。可以是一个数组，表示该请求映射可以处理多个请求地址
method：通过请求方式匹配请求映射，请求方式 get/post/delete/put
params：通过请求参数匹配请求映射
headers：通过请求头匹配请求映射

@Controller
@RequestMapping("/test")
public class HelloController {
 	// value
    // 可以处理 /test/index 和 /test/main  请求
    @RequestMapping(value = {"index", "main"})
    public String index() {
        return "index";
    }

    // method
    // 只能处理 /test/index2  并且 请求方式为GET的请求
    @RequestMapping(value = "index2", method = RequestMethod.GET)
    public String index2() {
        return "index";
    }

    // params
    // 只能处理 /test/index3  并且 携带username参数,password参数的值必须是123456,age参数不能等于20,不允许有sex参数
    @RequestMapping(value = "index3", params = {"username", "password=123456", "age!=20", "!sex"})
    public String index3() {
        return "index";
    }

    //headers
    // 只能处理 /test/index4  并且 请求头的Host值必须为localhost:8080
    @RequestMapping(value = "index3", headers = {"Host=localhost:8080"})
    public String index4() {
        return "index";
    }

}

ant风格，路径规则、匹配

“?” ：表示任意单个字符

“*” ：表示任意0个或多个字符

“**” ：表示任意一层或多层目录

//注意：在使用 ”**“时，只能使用 /**/xxx 的形式
// 表示无论是 /aat/test 或者 /abt/test、/act/test 等等请求，都可以匹配到当前映射方法
@RequestMapping("/a?t/test")  
public String test() {
    return "index";
}

restful风格，路径占位符、传值

路径占位符常用于restful风格，在响应的@RequestMapping注解的value属性中通过占位符{xxx}表示要传输的数据，在通过@PathVarlable注解获取占位符中的值

/**  3. restful风格 */
//在@RequestMapping注解的value属性中通过占位符{xxx}表示要传输的数据，在通过@PathVarlable注解获取占位符中的值
@RequestMapping("/restful/{id}/{pageIndex}")
public String restful(@PathVariable("id") String id,@PathVariable("pageIndex") Integer pageIndex) {
    System.out.println("id:"+id);
    System.out.println("pageIndex:"+pageIndex);
    return "index";
}

派生注解

@GetMapping、@PostMapping、@DeleteMapping、@PutMapping

4、获取请求数据

原生ServletAPI获取请求参数

控制器方法形参获取请求参数

@RequestParam

@RequesHeader

@CookieValue

通过POJO获取请求参数

解决请求乱码问题

/**
* 1.原生ServletAPI获取请求参数
*/
@RequestMapping("index")
public String index(HttpServletRequest request) {
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    System.out.println("username:" + username);
    System.out.println("password:" + password);
    return "index";
}

/**
* 2.控制器方法形参获取请求参数,请求参数名和形参名 必须要一致
*/
@RequestMapping("index2")
public String index2(String username, String password) {
    System.out.println("username:" + username);
    System.out.println("password:" + password);
    return "index";
}

/**
* 3.@RequestParam, 请求参数名和形参名 不一致
* value/name: 请求参数的名称，name和value两个属性基本是等价的,
* required:当前参数是否必须存在
* defaultValue:当前参数的默认值
*/
@RequestMapping(value = "index3")
public String index3(@RequestParam("user_name") String username) {
    System.out.println("username:" + username);
    return "index";
}
/**
* 4.@RequestHeader 获取请求头信息
* 和@RequestParam 一样的使用方法
*/
@RequestMapping(value = "index4")
public String index4(@RequestHeader("Host") String host) {
    System.out.println("host:" + host);
    return "index";
}

/**
* 5.@CookieValue 获取cookie数据
* 和@RequestParam 一样的使用方法
*/
@RequestMapping(value = "index5")
public String index5(@CookieValue("JSESSIONID") String JSESSIONID) {
    System.out.println("JSESSIONID:" + JSESSIONID);
    return "index";
}

/**
* 6.通过POJO获取请求参数
* 请求参数的名称和POJO类对象的属性名 要一致
*/
@RequestMapping(value = "index6")
public String index6(User user) {
    System.out.println(user);
    return "index";
}

解决乱码

get请求乱码由tomcat照成，修改tomcat的配置文件

post乱码配置CharacterEncodingFilter

<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

4、域对象数据共享

1.ServletAPI向request域对象共享数据

2.ModelAndView向request域对象共享数据

3.Model向request域对象共享数据

4.Map向request域对象共享数据

5.ModelMap向request域对象共享数据

6.Model、ModelMap、Map的关系

7.向session域对象共享数据

8.向application域对象共享数据

//1.ServletAPI向request域对象共享数据
@RequestMapping("/testServletApi")
public String testServletApi(HttpServletRequest request) {
    request.setAttribute("testRequestScope", "向域对象中共享的数据");
    return "index";
}

//2.ModelAndView向request域对象共享数据
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(ModelAndView mav) {
    // 向域对象中添加数据
    mav.addObject("testRequestScope", "向域对象中共享的数据");
    // 跳转的视图页面
    mav.setViewName("index");
    return mav;
}

//3.Model向request域对象共享数据
@RequestMapping("/testModel")
public String testModel(Model model) {
    model.addAttribute("testRequestScope", "向域对象中共享的数据");
    return "index";
}

//4.Map向request域对象共享数据
@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) {
    map.put("testRequestScope", "向域对象中共享的数据");
    return "index";
}

//5.ModelMap向request域对象共享数据
@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap) {
    modelMap.addAttribute("testRequestScope", "向域对象中共享的数据");
    return "index";
}

//6.Model、ModelMap、Map的关系  都是BindingAwareModelMap
//    public interface Model
//    public class ModelMap extends LinkedHashMap<String, Object>
//    public class ExtendedModelMap extends ModelMap implements Model
//    public class BindingAwareModelMap extends ExtendedModelMap

//7.向session域对象共享数据
@RequestMapping("/testSessionScopeByServletApi")
public String testSessionScopeByServletApi(HttpSession session) {
    session.setAttribute("testSessionScope", "向域对象中共享的数据");
    return "index";
}

//8.向application域对象共享数据
@RequestMapping("/testApplicationScopeByServletApi")
public String testApplicationScopeByServletApi(HttpSession session) {
    ServletContext servletContext = session.getServletContext();
    servletContext.setAttribute("testApplicationScope", "向域对象中共享的数据");
    return "index";
}

5、视图

转发视图 InternalResourceView

重定向视图 RedirectView

@Controller
@RequestMapping("/test")
public class ViewController {
    
    @RequestMapping("/index")
    public String index() {
        return "index";
    }

    //    转发视图，游览器发送了一次请求  请求地址不变
    @RequestMapping("testForward")
    public String testForward() {
        return "forward:/test/index";
    }

    //    重定向视图，游览器发送了两次请求  请求地址改变
    @RequestMapping("testForward")
    public String testRedirect() {
        return "redirect:/test/index";
    }
}

视图控制器 InternalResourceViewResolver

路径只是为了跳转页面 mvc:view-controller

<!--    
当访问路径仅仅只是为了跳转页面，可以通过配置 mvc:view-controller
但是配置此标签后，其他控制器将失效，因此还需要配置 <mvc:annotation-driven/>
-->
<mvc:view-controller path="/" view-name="index"/>
<mvc:annotation-driven/>

6、HttpMessageConverter 报文信息转换器

HttpMessageConverter ：将请求报文转换为java对象，或将java对象转换为响应报文

HttpMessageConverter提供两个注解和两个类型：

@RequestBody，@ResponseBody，RequestEntity，ResponseEntity，@RestController

@RequestBody

将请求报文（请求体）转换为java对象

//    @RequestBody，
@RequestMapping("form")
public String request(@RequestBody String formData) {
    //  表单的数据以JSON字符串 的形式赋值给formData
    System.out.println(formData);
    return "success";
}

@ResponseBody

将java对象转换为响应报文（响应体）

//    @ResponseBody
//此处响应的"success" 不在作为视图进行解析，而是直接作为响应体返回给客户端
//如果响应的数据是一个java对象类型的  则需要导入json依赖，则返回的java对象自动转换为json对象
@ResponseBody
@RequestMapping("response")
public String response(){
    return "success";
}

RequestEntity

可以接受整个请求报文，包括请求头和请求体

//    RequestEntity，
@RequestMapping("request2")
public String request2(RequestEntity<String> request) {
    // 获取请求头信息
    HttpHeaders headers = request.getHeaders();
    // 获取请求体信息
    String body = request.getBody();

    return "success";
}

ResponseEntity

ResponseEntity用于控制方法的返回值类型，该控制器方法的返回值就是响应到游览器的响应报文

（也就是自定义响应报文）

@RestController

@RestController 替代 @Controller

表示当前控制器所有方法返回的结果都是响应体，不是视图

7、文件下载、上传

文件下载

通过ResponseEntity 进行文件下载

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    //获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    //获取服务器中文件的真实路径
    String realPath = servletContext.getRealPath("/static/img/1.jpg");
    //创建输入流
    InputStream is = new FileInputStream(realPath);
    //创建字节数组
    byte[] bytes = new byte[is.available()];
    //将流读到字节数组中
    is.read(bytes);
    //创建HttpHeaders对象设置响应头信息
    MultiValueMap<String, String> headers = new HttpHeaders();
    //设置要下载方式以及下载文件的名字
    headers.add("Content-Disposition", "attachment;filename=1.jpg");
    //设置响应状态码
    HttpStatus statusCode = HttpStatus.OK;
    //创建ResponseEntity对象
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
    //关闭输入流
    is.close();
    return responseEntity;
}

文件上传

要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”

SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

上传步骤：

a>添加依赖

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

b>在SpringMVC的配置文件中添加配置：

<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

c>控制器方法：

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    //获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();
    //处理文件重名问题
    String hzName = fileName.substring(fileName.lastIndexOf("."));
    fileName = UUID.randomUUID().toString() + hzName;
    //获取服务器中photo目录的路径
    ServletContext servletContext = session.getServletContext();
    String photoPath = servletContext.getRealPath("photo");
    File file = new File(photoPath);
    if(!file.exists()){
        file.mkdir();
    }
    String finalPath = photoPath + File.separator + fileName;
    //实现上传功能
    photo.transferTo(new File(finalPath));
    return "success";
}

8、拦截器

1.拦截器的配置

SpringMVC中的拦截器用于拦截控制器方法的执行

SpringMVC中的拦截器需要实现HandlerInterceptor接口，重写preHandle方法

public class FirstInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 拦截后进行逻辑处理的内容  返回true 代表放行，返回false 表示拦截
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：

<mvc:interceptors>
    <!--        指定规则进行拦截-->
    <mvc:interceptor>
        <!--  拦截所有请求但是不包括 "/test" 请求   /* 表示只有一层路径  /**表示任意多层路径-->
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/test"/>
        <!--  拦截请求后 进行处理的类-->
    	<bean id="firstInterceptor" class="com.potato.interceptor.FirstInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

2.拦截器的三个抽象方法

SpringMVC中的拦截器有三个抽象方法：

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法

postHandle：控制器方法执行之后执行postHandle()

afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()

3.多个拦截器的执行顺序

a>若每个拦截器的preHandle()都返回true

此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：

preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行

b>若某个拦截器的preHandle()返回了false

preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行

客户端–> 过滤器 --> DispatcherServlet --> 拦截器 -->Controller

9、异常处理器

1.基于配置的异常处理

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!--
                prop的键表示 需要进行处理的异常
                prop的值表示 若出现异常时，需要跳转到的视图名称
             -->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
        exceptionAttribute属性设置一个值，将异常信息在 请求域 中进行共享，通过ex可以获取异常的信息内容
     -->
    <property name="exceptionAttribute" value="ex"/>
</bean>

2.基于注解的异常处理

@ControllerAdvice
public class ExceptionController {

    /**
     * @param ex 异常信息
     * @param model 把异常信息添加到域对象中
     * @return 异常页面
     */
    @ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
    public String exceptionMethod(Exception ex, Model model) {
        model.addAttribute(ex);
        return "error";
    }
}

10、注解配置SpringMVC

1.WebInit

创建初始化类，代替web.xml

在Servlet3.0+环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。
Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    /**
     * 指定spring的配置类
     *
     * @return
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 指定SpringMVC的配置类
     *
     * @return
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 指定DispatcherServlet的映射规则，即url-pattern
     *
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 添加过滤器
     *
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

2.WebConfig

代替SpringMVC的配置文件

// 1.组件扫描  2.视图解析  3.view-controller  4.default-servlet-handler
// 5.mvc注解驱动  6.文件上传解析器  7.拦截器   8.异常处理

@Configuration
// 1.组件扫描
@ComponentScan("com.potato.controller")
// 5.mvc注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {


    //2.视图解析
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/static/");
        viewResolver.setSuffix(".jsp");
        registry.viewResolver(viewResolver);
    }

    //3.view-controller
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
        WebMvcConfigurer.super.addViewControllers(registry);
    }

    //4.default-servlet-handler
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
        WebMvcConfigurer.super.configureDefaultServletHandling(configurer);
    }

    //6.文件上传解析器
    public CommonsMultipartResolver multipartResolver(CommonsMultipartResolver commonsMultipartResolver) {
        commonsMultipartResolver.setDefaultEncoding("UTF-8");
        commonsMultipartResolver.setMaxUploadSize(419430400);
        return commonsMultipartResolver;
    }

    //7.拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册自己定义的拦截器
        //registry.addInterceptor(new FirstInterceptor()).addPathPatterns("/**");
        WebMvcConfigurer.super.addInterceptors(registry);
    }

    //8.异常处理  可以使用注解配置代替
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        //设置异常映射
        resolver.setExceptionMappings(prop);
        //设置共享异常信息的键
        resolver.setExceptionAttribute("ex");
        resolvers.add(resolver);
        WebMvcConfigurer.super.configureHandlerExceptionResolvers(resolvers);
    }
}

11、SpringMVC的执行流程

用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：
根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。
如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】
提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。
此时将开始执行拦截器的postHandle(…)方法【逆向】。
根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图。
渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
将渲染结果返回给客户端。

这篇关于SpringMVC的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！