精华内容
下载资源
问答
  • Spring-MVC基础】由浅入深-Spring MVC

    万次阅读 多人点赞 2020-04-24 19:19:55
    本文致力于由浅入深的去介绍,使用Spring MVC;细节比较多,希望能对正在观看的你有所帮助! 博主水平有限,难免存在缺陷和错误,欢迎大佬的指出与补充,谢谢! 0x01.认识Spring MVC 1.Spring MVC概述 Spring MVC...

    本文致力于由浅入深的去介绍,使用Spring MVC;细节比较多,希望能对正在观看的你有所帮助!
    博主水平有限,难免存在缺陷和错误,欢迎大佬的指出与补充,谢谢!

    0x01.认识Spring MVC

    1.Spring MVC概述

    • Spring MVC属于SpringFrameWork的后续产品,已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
    • 使用 Spring 可插入的 MVC 架构,从而在使用Spring进行WEB开发时,可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架,如Struts1(现在一般不用),Struts 2(一般老项目使用)等。
    • Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架,通过把模型-视图-控制器分离,将web层进行职责解耦,把复杂的web应用分成逻辑清晰的几部分,简化开发,减少出错,方便组内开发人员之间的配合。
    • Spring MVC属于表现层的框架。

    2.MVC的理解

    • MVC全名是Model View Controller模型视图控制器,每个部分各司其职。
    • Model:数据模型,JavaBean的类,用来进行数据封装。
    • View:指JSP、HTML用来展示数据给用户。
    • Controller:用来接收用户的请求,整个流程的控制器。用来进行数据校验等。

    在这里插入图片描述

    3.Spring MVC在Spring中的地位

    在这里插入图片描述

    0x02.简单使用Spring MVC

    1.写一个jsp页面

    • 写一个测试使用的index.jsp页面,仅包含一个超链接标签。
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Spring MVC来啦~</title>
    </head>
    <body>
        <h1>测试</h1>
        <a href="atfwus">开始</a>
    </body>
    </html>
    

    2.写一个控制器

    • 加上Spring MVC的注解。
    • 返回字符串success
    @Controller
    public class ATFWUS {
        @RequestMapping(path = "/atfwus")
        public String sayHello(){
            System.out.println("ATFWUS!!!");
            return "success";
        }
    }
    

    3.编写Spring MVC的配置文件

    • 配置视图解析器,并告知Spring需要扫描的包。
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation=" http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd  http://www.springframework.org/schema/mvc
     http://www.springframework.org/schema/mvc/spring-mvc.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd">
        <!-- 配置spring创建容器时要扫描的包 -->
        <context:component-scan base-package="com.atfwus"></context:component-scan>
        <!-- 配置视图解析器 -->
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
        <mvc:annotation-driven/>
    </beans>
    

    4.编写成功的跳转页面

    -在WEB-INF/pages里面写 success.jsp页面。

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Success</title>
    </head>
    <body>
        <h3>Success!!!</h3>
    </body>
    </html>
    

    5.配置web.xml文件

    • 配置Spring MVC的核心控制器。
    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    </web-app>
    
    

    6.启动服务器,测试

    在这里插入图片描述
    在这里插入图片描述

    0x03.Spring MVC工作流程剖析

    1.例子中的流程分析

    麻雀虽小,五脏俱全,在上述的小case中,已经包含Spring MVC的主要部分。我们看一下上述case的执行流程吧:

    • 因为在web.xml中配置了load-on-startup,所以,服务器一启动,就创建了DispatcherServlet对象。
    • DispatcherServlet标签的内部,配置了springmvc.xml的位置,所以服务器开始加载这个配置文件。
    • 用户点击index.jsp的超链接标签,向服务器发送了请求。
    • 请求到达DispatcherServlet核心控制器。
    • 控制器根据配置@RequestMapping注解找到执行的具体方法。
    • 方法执行完毕,返回字符串success
    • 根据配置的视图解析器,前往指定的目录中查找指定名称且后缀为jsp的文件。
    • 查找文件成功,服务器开始渲染页面,做出响应。
    • 跳转到success页面。

    2.Spring MVC的请求响应流程

    (1) 用户通过浏览器发送请求至服务器,然后直接进入前端控制器DispatcherServlet
    (2)DispatcherServlet收到请求后,开始调用HandlerMapping处理器映射器,请求获取Handle
    (3)处理器映射器根据请求url找到具体的处理器,生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServ3let
    (4)DispatcherServlet 调用 HandlerAdapter处理器适配器,请求执行Handler
    (5) HandlerAdapter 经过适配调用 具体处理器(Handler,也叫后端控制器);
    (6)Handler执行完成返回ModelAndView
    (7)HandlerAdapterHandler执行结果ModelAndView返回给DispatcherServlet
    (8)DispatcherServletModelAndView传给ViewResolver视图解析器进行解析;
    (9)ViewResolver解析后视图后返回具体View对象;
    (10)DispatcherServlet将模型数据填充至视图中(对View进行渲染视图);
    (11)DispatcherServlet通过服务器返回响应的结果给用户。
    在这里插入图片描述

    3.Spring MVC核心组件

    (1)前端控制器 DispatcherServlet

    • 接收请求、转发请求,响应结果,相当于是一个中转站,是整个流程中的核心部分。
    • 统一调度,降低组件之间的耦合性,提高每个组件的扩展性。
    • 此组件框架提供。

    (2)处理器映射器HandlerMapping

    • 根据请求的URL来查找Handler。
    • 此组件框架提供。

    (3)处理器适配器HandlerAdapter

    • 按照特定规则去执行Handler。
    • 需要对适配器进行拓展。

    (4)处理器Handler

    • Handler 是继DispatcherServlet前端控制器的后端控制器,在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
    • 此组件需要根据需求编写。

    (5)视图解析器View resolver

    • 进行视图的解析,根据视图逻辑名解析成真正的视图。
    • 此组件框架提供。

    (6)视图View

    • View是一个接口, 它的实现类支持不同的视图类型,如(html,jsp,pdf)。
    • 此组件需要根据具体需求编写。

    0x04.Spring MVC参数绑定机制

    1.绑定说明

    • SpringMVC的参数绑定过程是把表单提交的请求参数,作为控制器中方法的参数进行绑定的。

    • 表单提交的数据都是k=v格式。

    • 支持绑定的数据类型:

      • 基本数据类型和字符串类型。
      • 实体类型(JavaBean)。
      • 集合数据类型(List、map集合等)。

    2.基本数据类型和String类型

    • 必须保证提交表单的name和参数的名称是相同的。
    控制类:
    @Controller
    @RequestMapping("/param")
    public class ParamController {
     
        @RequestMapping("/saveAccount")
        public String saveAccount(String username,String password){
            System.out.println(username+password);
            return "success";
        }
    
    }
    
    jsp页面:
    <a href="param/testParam?username=atfwus&password=atfwus">请求参数绑定</a>
    

    3.JavaBean

    • 提交表单的name和JavaBean中的属性名称需要一致。
    • 如果一个JavaBean类中包含其他的引用类型,那么表单的name属性需要编写成:对象.属性。(如data.msg

    bean:

    public class Data implements Serializable {
        private Integer status;
        private String msg;
    
        //getters and setters
    
        @Override
        //Override toString methond
    }
    
    public class Account implements Serializable {
        private String username;
        private String password;
        private double money;
        private Data data;
    
        //getters and setters
    
        @Override
        //Override toString methond
    }
    

    控制器:

    @Controller
    @RequestMapping("/param")
    public class ParamController {
    
        @RequestMapping("/saveAccount")
        public String saveAccount(Account acount){
            System.out.println(acount);
            return "success";
        }
        
    }
    

    jsp页面:

    <form action="param/saveAccount" method="post">
        名称:<input type="text" name="username"/><br/>
        密码:<input type="text" name="password"/><br/>
        余额:<input type="text" name="money"/><br/>
        状态:<input type="text" name="data.status"/><br/>
        信息:<input type="text" name="data.msg"/><br/>
        <input type="submit" value="提交" />
    </form>
    

    4.集合类型封装

    • 在jsp页面中的表单name里面写list[index].属性(index为集合下标)。
    • 其它部分与JavaBean基本一致。

    5.Spring MVC解决请求参数乱码

    • SpringMVC内置了解决请求参数乱码的过滤器,只需在web.xml中配置即可。
    <!--  配置解决中文乱码的控制器-->
    <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>
    </filter>
    <filter-mapping>
      <filter-name>characterEncodingFilter</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>
    

    6.自定义类型转换器

    • 表单提交的任何数据类型全部都是字符串类型。
    • Spring框架内部会默认进行数据类型转换。
    • 如果想自定义数据类型转换,可以实现Converter的接口
    自定义一个类型转换的工具类并实现Converter接口:
    public class StringToDate implements Converter<String,Date> {
        @Override
        public Date convert(String source) {
            if(source==null){
                throw new RuntimeException("数据为空!");
            }
            DateFormat df=new SimpleDateFormat("yyyy年-MM月-dd号");
            try {
                return df.parse(source);
            } catch (ParseException e) {
                throw new RuntimeException("转换异常!");
            }
        }
    }
    
    配置文件中注册自定义类型转换器:
    <!--    配置自定义类型转换器-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
         <property name="converters">
            <set>
                <bean id="StringToDate" class="com.atfwus.utils.StringToDate"></bean>
            </set>
        </property>
    </bean>
    <mvc:annotation-driven conversion-service="conversionService"/>
    

    7.获取servlet原生API

    • SpringMVC支持使用原始 ServletAPI对象作为控制器方法的参数。

    • 具体API如下:

      • HttpServletRequestHttpServletResponseHttpSessionjava.security.PrincipalLocaleInputStreamOutputStreamReaderWriter
    • 只需要在控制器的方法参数定义这些这些API的对象即可。

    0x05.Spring MVC常用注解

    1.@RequestMapping

    • 用于处理请求 url 映射的注解,可用于类或方法上。用于类上,则表示类中的所有响应请求的方法都是以该地址作为父路径。

    • 作用在类上是 第一级的访问目录,作用在方法上是 第二级的访问目录。

    • 路径可以不写 / 表示应用的根目录开始。

    • 在请求的页面中,路径可以省略${ pageContext.request.contextPath },但是不能写/

    • 属性:

      • path:指定请求路径的url
      • value:和path属性是一样的。
      • mthod:指定该方法的请求方式。
      • params:指定限制请求参数的条件。
      • headers:发送的请求中必须包含的请求头。
      • consumes:指定处理请求的提交内容类型,如application/json, text/html。
      • produces: 指定返回的内容类型,仅当request请求头中的类型中包含该指定类型才返回。

    2.@RequestParam

    • 作用:把请求中的指定名称的参数传递给控制器中的形参赋值。

    • 属性:

      • value:请求参数中的名称。
      • required:请求参数中是否必须提供此参数,默认值是true,必须提供。

    例如:

    public String atfwus(@RequestParam(value="username",required=false)String name) 
    

    3.@RequestBody:

    • 作用:用于获取请求体的内容(get方式没有请求体)。

    • 属性:

      • required:是否必须有请求体,默认值是true。

    例如:

    public String atfwus(@RequestBody String body) 
    

    4.@PathVariable

    • 作用:用于绑定url中的占位符。例如:url中有/delete/{id},{id}就是占位符。

    • url支持占位符是 springmvc支持 rest风格 URL的一个重要标志。

    • 属性:

      • value:指定url中的占位符名称。

    例如:

    @RequestMapping(path="/hello/{id}")
    public String atfwus(@PathVariable(value="id") String id) {
    

    5.@RequestHeader:

    • 作用:获取指定请求头的值.

    • 属性:

      • value:请求头的名称。

    例如:

    public String atfwus(@RequestHeader(value="Accept") String header) 
    

    6.@CookieValue

    • 作用:用于获取指定cookie的名称的值。

    • 属性:

      • value:cookie的名称。

    例如:

    public String atfwus(@CookieValue(value="JSESSIONID") String cookieValue)
    

    7.@ModelAttribute

    • 出现在方法上:表示当前方法会在控制器方法执行前先执行。
    • 出现在参数上:获取指定的数据给参数赋值。
    • 用途:当提交表单数据不是完整的实体数据时,保证没有提交的字段使用数据库原来的数据。
    • 如果所在方法有返回值,那么直接返回,如果没有,需要提供一个map集合,先将数据存入map集合。

    8.@SessionAttributes

    • 作用:用于多次执行控制器方法间的参数共享。

    • 属性:

      • value:指定存入属性的名称。

    例如:

    @Controller
    @RequestMapping("/anno")
    @SessionAttributes(value={"msg"})   
    public class AnnoController {
        @RequestMapping(value="/testSessionAttributes")
        public String testSessionAttributes(Model model){
            model.addAttribute("msg","atfwus");
            return "success";
        }
        @RequestMapping(value="/getSessionAttributes")
        public String getSessionAttributes(ModelMap modelMap){
            String msg = (String) modelMap.get("msg");
            System.out.println(msg);
            return "success";
        }
        @RequestMapping(value="/delSessionAttributes")
        public String delSessionAttributes(SessionStatus status){
            status.setComplete();
            return "success";
        }
    }
    

    0x06.Spring MVC响应数据

    1.String类型返回值

    • Controller方法返回字符串可以指定逻辑视图的名称,根据视图解析器为物理视图的地址。
    • 如上述例子中,返回success,然后试图解析器解析后,跳转到success.jsp页面。
    • 实际用途:调用此方法的同时,将数据存入到model中,然后框架将数据存入request中,将数据转发到新的页面。

    2.void类型返回值

    • 果控制器的方法返回值编写是void,默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面。
    • 可以使用请求转发或者重定向跳转到指定的页面。还可以直接响应。
    @RequestMapping("/testVoid")
    public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 请求转发
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
    
        // 重定向
        response.sendRedirect(request.getContextPath()+"/index.jsp");
    
        // 解决中文乱码
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
    
        // 直接进行响应
        response.getWriter().print("响应");
    }
    

    3.ModelAndView对象类型返回值

    • ModelAndView对象是Spring提供的一个对象,可以用来调整具体的JSP视图。
    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView(){
        // 创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        String name="ATFWUS";
        // 把name存储到mv对象中,也会把name存入到request对象
        mv.addObject("user",name);
        // 跳转页面
        mv.setViewName("success")
        return mv;
    }
    

    4.Spring MVC提供的转发和重定向

    • forward请求转发:
     return "forward:/WEB-INF/pages/success.jsp";
    
    • redirect重定向:
     return "redirect:/add.jsp";
    

    5.响应json数据(ResponseBody)

    配置静态资源不进行拦截:
    • DispatcherServlet会拦截到所有的资源,导致静态资源(img、css、js)也会被拦截到,如果需要设置不拦截,需要在springmvc.xml中进行配置。
    • mvc:resources:标签配置不过滤。
    • location元素表示webapp目录下的包下的所有文件
    • mapping元素表示以/static开头的所有请求路径。
    <!-- 设置静态资源不过滤 -->
    <mvc:resources location="/css/" mapping="/css/**"/> 
    <mvc:resources location="/images/" mapping="/images/**"/> 
    <mvc:resources location="/js/" mapping="/js/**"/>  
    
    使用@RequestBody注解把json的字符串转换成JavaBean的对象:

    发送ajax请求:

    <script>
        $(function(){
            $("#btn").click(function(){
                $.ajax({
                    // 编写json格式,设置属性和值
                    url:"user/testAjax",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"atfwus","password":"atfwus","age":19}',
                    dataType:"json",
                    type:"post",
                    success:function(data){
                     // 服务器端响应的json的数据,进行解析
                     alert(data);
                    }
                });
            });
        });
    </script>
    

    控制器代码:

    • 在导入相关的jar包的前提下,Spring MVC可以直接把相关的json数据转换成JavaBean。
    • jar包:jackson-annotationsjackson-datablindjackson-core
    @RequestMapping("/testJson")
    public void testJson(@RequestBody User user) {
    	 System.out.println(user);
    }
    
    使用@ResponseBody注解把JavaBean对象转换成json字符串:
    • @ResponseBody作用: 该注解用于将Controller的方法返回的对象,通过适当的HttpMessageConverter转换为指定格式后,写入到Response对象的body数据区。
    @RequestMapping("/testAjax")
    public @ResponseBody User testAjax(@RequestBody User user){
        // 后端把json字符串封装到user对象中
        System.out.println(user);
        // 响应
        user.setUsername("ATFWUS");
        return user;
    }
    

    0x07.Spring MVC文件上传

    • 文件上传时form表单的 enctype取值必须是:multipart/form-data
    • 文件上传时method属性取值必须是 Post
    • 文件上传需要提供一个文件选择域<input type=”file” />
    • 下列代码需要的jar包:commons-fileuploadcommons-iojersey-clientjersey-core

    1.jsp页面

    <form action="/user/fileupload1" method="post" enctype="multipart/form-data">
            选择文件:<input type="file" name="upload" /><br/>
            <input type="submit" value="上传" />
    </form>
    

    2.传统文件上传

    // 使用fileupload组件完成文件上传
    @RequestMapping("/fileupload1")
    public String fileuoload1(HttpServletRequest request) throws Exception {
        // 上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断,该路径是否存在
        File file = new File(path);
        if(!file.exists()){
            // 创建该文件夹
            file.mkdirs();
        }
        // 解析request对象,获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        // 解析request
        List<FileItem> items = upload.parseRequest(request);
        // 遍历
        for(FileItem item:items){
            // 进行判断,当前item对象是否是上传文件项
            if(item.isFormField()){
                // 说明普通表单向
            }else{
                // 说明上传文件项
                // 获取上传文件的名称
                String filename = item.getName();
                // 把文件的名称设置唯一值,uuid
                String uuid = UUID.randomUUID().toString().replace("-", "");
                filename = uuid+"_"+filename;
                // 完成文件上传
                item.write(new File(path,filename));
                // 删除临时文件
                item.delete();
            }
        }
        return "success";
    }
    

    3.Spring MVC上传文件

    • SpringMVC框架提供了MultipartFile对象,该对象表示上传的文件,要求变量名称必须和表单file标签的name属性名称相同。
    • 配置文件解析器:
    <!--配置文件解析器对象-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="1000000" />
    </bean>
    
    • 控制器代码:
    // 使用fileupload组件完成文件上传
    @RequestMapping("/fileupload2")
    public String fileuoload2(HttpServletRequest request, MultipartFile upload) throws Exception {
        // 上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断,该路径是否存在
        File file = new File(path);
        if(!file.exists()){
            // 创建该文件夹
            file.mkdirs();
        }
        // 说明上传文件项
        // 获取上传文件的名称
        String filename = upload.getOriginalFilename();
        // 把文件的名称设置唯一值,uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        filename = uuid+"_"+filename;
        // 完成文件上传
        upload.transferTo(new File(path,filename));
        return "success";
    }
    

    4.跨服务器文件上传:

    • 将文件跨服务器进行上传。
    @RequestMapping("/fileupload3")
    public String fileuoload3(MultipartFile upload) throws Exception {
        // 定义上传文件服务器路径
        String path = "http://localhost:8090/uploads/";
        // 说明上传文件项
        // 获取上传文件的名称
        String filename = upload.getOriginalFilename();
        // 把文件的名称设置唯一值,uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        filename = uuid+"_"+filename;
        // 创建客户端的对象
        Client client = Client.create();
        // 和图片服务器进行连接
        WebResource webResource = client.resource(path + filename);
        // 上传文件
        webResource.put(upload.getBytes());
        return "success";
    }
    

    0x08.Spring MVC异常处理

    • 系统的 dao、service、controller出现异常都会通过 throws Exception向上抛出,最后由 Spring MVC前端控制器交由异常处理器进行异常处理。

    1.自定义异常类

    public class SysException extends Exception{
    
        // 存储提示信息的
        private String message;
        
        //get and set
        
        public SysException(String message) {
            this.message = message;
        }
    }
    

    2.自定义异常处理器

    public class SysExceptionResolver implements HandlerExceptionResolver{
    
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            // 获取到异常对象
            SysException e = null;
            if(ex instanceof SysException){
                e = (SysException)ex;
            }else{
                e = new SysException("出异常了");
            }
            // 创建ModelAndView对象
            ModelAndView mv = new ModelAndView();
            mv.addObject("errorMsg",e.getMessage());
            mv.setViewName("error");
            return mv;
        }
    }
    

    3.配置异常处理器

     <!-- 配置异常处理器 -->
    <bean id="sysExceptionResolver" class="cn.atfwus.exception.SysExceptionResolver"/>
    

    4.测试异常处理

    @RequestMapping("/testException")
    public String testException() throws SysException {
        try {
            // 模拟异常
            int a = 0/0;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 抛出自定义异常
            throw new SysException("出异常了");
        }
        return "success";
    }
    

    0x09.Spring MVC拦截器

    • Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter,用于对处理器进行预处理和后处理。

    • 拦截器和过滤器的区别:

      • 过滤器是Servlet规范的一部分,任何框架都可以使用过滤器技术。拦截器是SpringMVC框架独有的。
      • 过滤器配置了/*,可以拦截任何资源。拦截器只会对控制器中的方法进行拦截。
    • 拦截器是AOP思想的一种实现方式。

    • 可以定义拦截器链,连接器链就是将拦截器按着一定的顺序结成一条链,在访问被拦截的方法时,拦截器链中的拦截器会按着定义的顺序执行。

    • 如果需要自定义拦截器,需要实现HandlerInterceptor接口。

    1.自定义拦截器类

    • 需要实现HandlerInterceptor接口。
    public class MyInterceptor1 implements HandlerInterceptor{
    
    
         // 预处理,controller方法执行前
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("MyInterceptor前");
            // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
            return true;
        }
    
    
         // 后处理方法,controller方法执行后,success.jsp执行之前
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("MyInterceptor执行");
            // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        }
    
        
         //success.jsp页面执行后,该方法会执行
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("MyInterceptor最后");
        }
    
    }
    

    2.配置拦截器

    <!--配置拦截器-->
    <mvc:interceptors>
        <!--配置拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/user/*"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
                -->
            <!--配置拦截器对象-->
            <bean class="cn.atfwus.controller.cn.itcast.interceptor.MyInterceptor1" />
        </mvc:interceptor>
    
        <!--配置第二个拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/**"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
            -->
            <!--配置拦截器对象-->
            <bean class="cn.itcast.controller.cn.atfwus.interceptor.MyInterceptor2" />
        </mvc:interceptor>
    </mvc:interceptors>
    

    3.接口中的方法

    • preHandle方法:是controller方法执行前拦截的方法。可以使用request或者response跳转到指定的页面。return true放行,执行下一个拦截器,如果没有拦截器,执行controller中的方法。3return false不放行,不会执行controller中的方法。

    • postHandle方法:是controller方法执行后执行的方法,在JSP视图执行前。可以使用request或者response跳转到指定的页面。如果指定了跳转的页面,那么controller方法跳转的页面将不会显示。

    • postHandle方法:是在JSP执行后执行。request或者response不能再跳转页面了。

    0x0A.再回首,Spring MVC优势分析

    (01)方便与Spring框架集成(如IoC容器、AOP等);
    (02)能够使我们进行更简洁的Web层的开发;
    (03)清晰的角色划分,前端控制器(dispatcherServlet) , 请求到处理器映射(handlerMapping), 处理器适配器(HandlerAdapter), 视图解析器(ViewResolver)。
    (04)可以支持各种视图技术,而不仅仅局限于JSP;
    (05)支持各种请求资源的映射策略。
    (06)可适配、非侵入:可以根据不同的应用场景,选择合适的控制器子类 (simple型、command型、form型、wizard型、multi-action型或者自定义),而不是从单一控制器 (比如Action/ActionForm)继承。
    (07)简单而强大的JSP标签库(SpringTag Library):支持包括诸如数据绑定和主题之类的许多功能。
    (08)非常灵活的数据验证、格式化和数据绑定机制。
    (09)支持Restful风格。
    (10)灵活的model转换:在Springweb框架中,使用基于Map的 键/值对来达到轻易地与各种视图技术的集成。

    SpringMVC 和 Struts2 对比:

    相同点:
    • 它们都是表现层框架,都是基于 MVC模型编写的。
    • 它们的底层都离不开原始 ServletAPI。
    • 它们处理请求的机制都是一个核心控制器。
    不同点:
    • Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter。
    • Spring MVC 是基于方法设计的,而 Struts2是基于类,Struts2每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。
    • Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便。
    • Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些,但执行效率并没有比 JSTL 提升,尤其是 struts2的表单标签,远没有 html执行效率高。
    • 与spring整合不一样。Spring MVC是spring框架的一部分,不需要整合。

    再次感谢耐心的你看到了这,谢谢!

    参考书籍与文献:

    • 《SSM实战》
    • 《Spring实战》第4版
    • 《轻量级J2EE企业应用实战》
    • 百度百科(图1和图2)
    • Spring MVC源代码

    ATFWUS --Writing By 2020–04-24

    展开全文
  • Spring-MVC-model

    2018-05-03 12:08:23
    Spring-MVC-model Spring-MVC-model Spring-MVC-model Spring-MVC-model
  • spring-mvc-custom-exception 在 Spring MVC 中自定义现有的 ExceptionHandlerExceptionResolver 类以动态处理异常的示例 如何运行示例 git clone https://github.com/sbcoba/spring-mvc-custom-exception.git cd ...
  • spring-mvc-官方中文文档
  • spring mvcspring-mvc配置

    千次阅读 2016-01-14 11:49:44
    spring-mvc精简配置,spring-mvc.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"
           default-lazy-init="true">
        <!-- 默认懒加载 -->
    
        <!-- 自动扫描注册bean -->
        <!--<context:annotation-config />-->
        <!-- 扫描controller(controller层注入) -->
        <context:component-scan base-package="com.aaaaa">
            <context:include-filter type="annotation"
                                    expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
    
        <!-- 校验器,入参校验 -->
        <bean id="validator"
              class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
        </bean>
    
        <!-- 格式转换器.例如Date等 -->
        <bean id="conversionService"
              class="org.springframework.format.support.FormattingConversionServiceFactoryBean"/>
    
        <!-- 数据绑定 -->
        <bean id="webBindingInitializer"
              class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
            <property name="conversionService" ref="conversionService"/>
            <property name="validator" ref="validator"/>
        </bean>
    
        <!-- 配置请求驱动适配器HandlerAdapter,MappingHandler由默认的驱动提供 -->
        <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
            <property name="webBindingInitializer" ref="webBindingInitializer"/>
            <property name="messageConverters">
                <list>
                    <bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/>
                    <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
                </list>
            </property>
        </bean>
    
        <!-- 注册为springMVC -->
        <mvc:annotation-driven/>
    
        <!-- 视图解析器 -->
        <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
            <property name="prefix" value="/views/"/>
            <property name="suffix" value=".jsp"/>
            <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
        </bean>
    
    </beans>


    展开全文
  • spring-mvc-3.0.xsd

    2012-04-12 10:07:11
    spring-mvc-3.0.xsd
  • spring-mvc helloworld demo

    2016-01-05 19:34:28
    spring-mvc的一个helloworld的demo,需要的拿去用
  • 今天来聊聊spring-mvc是如何来执行Controller中的method的。spring-mvc默认的HandlerAdapter是RequestMappingHandlerAdapter,DispatcherServlet将处理逻辑交由HandlerAdapter,而HandlerAdapter,由交给...

    今天来聊聊spring-mvc是如何来执行Controller中的method的。

    spring-mvc默认的HandlerAdapter是RequestMappingHandlerAdapter,

    DispatcherServlet将处理逻辑交由HandlerAdapter,而HandlerAdapter,由交给ServletInvocableHandlerMethod来invokeAndHandle.

    requestMappingMethod.invokeAndHandle(webRequest, mavContainer);

    跟踪源代码

    public void invokeAndHandle(ServletWebRequest webRequest,
                ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    
            Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
            setResponseStatus(webRequest);
    
            if (returnValue == null) {
                if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {
                    mavContainer.setRequestHandled(true);
                    return;
                }
            }
            else if (StringUtils.hasText(this.responseReason)) {
                mavContainer.setRequestHandled(true);
                return;
            }
    
            mavContainer.setRequestHandled(false);
            try {
                this.returnValueHandlers.handleReturnValue(
                        returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
            }
            catch (Exception ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
                }
                throw ex;
            }
        }

    主要是Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs)整个执行过程都在这步代码中,那么到底是如何处理的。

    public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
                Object... providedArgs) throws Exception {
    
            Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
            if (logger.isTraceEnabled()) {
                StringBuilder sb = new StringBuilder("Invoking [");
                sb.append(getBeanType().getSimpleName()).append(".");
                sb.append(getMethod().getName()).append("] method with arguments ");
                sb.append(Arrays.asList(args));
                logger.trace(sb.toString());
            }
            Object returnValue = doInvoke(args);
            if (logger.isTraceEnabled()) {
                logger.trace("Method [" + getMethod().getName() + "] returned [" + returnValue + "]");
            }
            return returnValue;
        }

    我们知道利用反射来执行一个方法的时候,我们需要入参。那么Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);就是获取Controller的入参。也就是需要用到参数解析了,spring-mvc为我们提供了强大的数据绑定机制,

    private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
                Object... providedArgs) throws Exception {
    
            MethodParameter[] parameters = getMethodParameters();
            Object[] args = new Object[parameters.length];
            for (int i = 0; i < parameters.length; i++) {
                MethodParameter parameter = parameters[i];
                parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
                GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
                args[i] = resolveProvidedArgument(parameter, providedArgs);
                if (args[i] != null) {
                    continue;
                }
                //argumentResolvers是RequestMappingHandlerAdapter传过来的参数解析器。
                //这里是循环遍历,查找能够解析该参数的
                if (this.argumentResolvers.supportsParameter(parameter)) {
                    try {
                        args[i] = this.argumentResolvers.resolveArgument(
                                parameter, mavContainer, request, this.dataBinderFactory);
                        continue;
                    }
                    catch (Exception ex) {
                        if (logger.isTraceEnabled()) {
                            logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);
                        }
                        throw ex;
                    }
                }
                if (args[i] == null) {
                    String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);
                    throw new IllegalStateException(msg);
                }
            }
            return args;
        }

    下一步就是找到参数解析器来解析该参数了 。spring-mvc为我们提供了23种参数解析器。这里就不一一介绍了,
    得到参数之后,然后调用Object returnValue = doInvoke(args);得到执行的返回结果。

    this.returnValueHandlers.handleReturnValue(
                        returnValue, getReturnValueType(returnValue), mavContainer, webRequest);

    下面的处理逻辑:如果是视图,就调用ViewResolver,render出jsp,如何是JSON。则用response写到应用。

    展开全文
  • spring+spring-mvc+mybatis+bootstrap+ajax详细项目案例
  • spring-mvc.xml

    千次阅读 2019-01-07 13:11:35
    1.spring-mvc.xml pom.xml &lt;!--springmvc spring--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&lt;/groupId&gt; &lt;artifactId&gt;spring-web...

    1.spring-mvc.xml

    1. pom.xml
    <!--springmvc spring-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
                <scope>test</scope>
            </dependency>
    
    
     <!-- 文件上传-->
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>1.3.3</version>
            </dependency>

     2.spring-mvc.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!--只扫描@Controller-->
        <context:component-scan base-package="net.wanho.controller"/>
    
        <!--注解方式-->
        <mvc:annotation-driven>
            <mvc:message-converters>
                <ref bean="fastjsonBean"/>
            </mvc:message-converters>
        </mvc:annotation-driven>
    
        <!--使用fastjson-->
        <bean id="fastjsonBean" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <property name="supportedMediaTypes">
                <list>
                    <value>text/html;charset=UTF-8</value>
                    <value>application/json;charset=UTF-8</value>
                </list>
            </property>
            <property name="fastJsonConfig">
                <bean class="com.alibaba.fastjson.support.config.FastJsonConfig">
                    <property name="features">
                        <list>
                            <value>AllowArbitraryCommas</value>
                            <value>AllowUnQuotedFieldNames</value>
                            <value>DisableCircularReferenceDetect</value>
                        </list>
                    </property>
                    <property name="dateFormat" value="yyyy-MM-dd HH:mm:sss"/>
                </bean>
    
            </property>
        </bean>
    
        <!--视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    
        <!--静态资源-->
        <mvc:resources mapping="/img/**" location="/WEB-INF/img/"/>
        <mvc:resources mapping="/css/**" location="/WEB-INF/css/"/>
        <mvc:resources mapping="/js/**" location="/WEB-INF/js/"/>
    
        <!--文件上传-->
        <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <property name="defaultEncoding" value="UTF-8"/>
            <property name="maxUploadSize" value="10240000"/>
        </bean>
    
        <!--登录拦截器-->
        <mvc:interceptors>
            <mvc:interceptor>
                <mvc:mapping path="/**"/>
                <mvc:exclude-mapping path="/**/**.html"/>
                <mvc:exclude-mapping path="/**/**.js"/>
                <mvc:exclude-mapping path="/**/**.css"/>
                <mvc:exclude-mapping path="/**/**.jpg"/>
                <mvc:exclude-mapping path="/**/**.png"/>
                <mvc:exclude-mapping path="/**/**.gif"/>
                <bean class="net.wanho.interceptor.LoginInterCeptor"/>     <!--自定义的登陆拦截-->
            </mvc:interceptor>
        </mvc:interceptors>
    
    </beans>

    3.LoginInterCeptor.java

    package net.wanho.interceptor;
    
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    import java.util.Arrays;
    
    public class LogInteceptor extends HandlerInterceptorAdapter {
        @Override
        public boolean preHandle(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response, Object handler) throws Exception {
    //        System.out.println("preHandle=======");
            String path = request.getServletPath();
    //        System.out.println(path);
            if(Arrays.asList("/login.jsp","/login").contains(path)){
                return true;
            }
    
            if(request.getSession().getAttribute("currentUser")!=null) {
               return true;
           }
    
           response.sendRedirect("login.jsp");
           return false;
        }
    
    }
    

     

    4.web.xml

    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
    
      <!--spring-->
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml,classpath:spring-mybatis.xml</param-value>
      </context-param>
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
        
         <!-- restful-->
      <filter>
        <filter-name>mf</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>mf</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    
      <!--spring-mvc-->
      <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    
    
    </web-app>
    

     

    展开全文
  • 弹簧 mvc 演示 Spring MVC Demo 集成了 Spring Framework、Spring MVC 和 iBATIS。
  • org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: Failed to import bean definitions from relative location [context-spring-mvc.xml] Offending resource: ...
  • java版微信授权认证登录spring-mvc by WangJx
  • spring-mvc.xml 和 application-context.xml的配置与深入理解

    万次阅读 多人点赞 2018-09-06 16:31:21
    在java框架这个话题,前几篇文章是基于搭建ssm项目框架,以及web.xml的配置讲解,本篇主要就...2、spring-mvc.xml。   回顾一下application-context.xml和spring-mvc.xml在web.xml中的配置是怎样的。 目录  (...
  • 解决spring-mvc spring拦截器 跨域问题

    千次阅读 2017-12-04 20:44:51
    1.解决spring-mvc解决跨域问题, 2.解决spring mvc拦截器跨域问题 mvc:cors> mvc:mapping path="/**" allowed-origins="*" allow-credentials="true" max-age="1800" a
  • spring-mvc 与jquery-easyui整合

    千次阅读 热门讨论 2014-12-26 01:02:28
    spring-webmvc-4.0.8.RELEASE Jquery-easyui-1.4.0 以上是在整合layout页面所用的各自版本号。 配置 Spring-mvc.xml配置 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context=
  • spring-mvc中使用swagger2遇到的问题汇总

    万次阅读 热门讨论 2017-07-17 11:14:28
    swagger spring spring-mvc
  • application.xml和spring-mvc.xml的区别

    千次阅读 2016-10-19 14:04:30
    大概的说法是,application.xml文件是Struts为了引入spring才需要的文件,为了加载spring的东西,不属于spring mvc,只有spring-mvc才可以用。 spring-mvc.xml默认路径是放在WEB-INF下面的,
  • Spring-MVC中使用logback和slf4j

    千次阅读 2016-07-21 15:06:16
    一、在Spring-MVC框架下使用logback和slf4j日志信息: 1.假如在你的项目中已经有了Spring-MVC的JAR包。 2.步骤如下: 1.在你的POM文件中加入如下jar文件: ch.qos.logback logback-classic 1.1.3 ...
  • Spring MVC 教程。 我们在所有示例中都使用了最新版本的 Spring Framework 5+。 本教程为您提供构建基于 Spring 的企业 J2EE Web 应用程序或 RESTful API 所需的所有可能的 Spring MVC 功能。 在本教程中,您将学习...
  • 基于spring-mvc开发HTTP接口

    千次阅读 2018-07-01 20:17:17
    基于spring-MVC开发一个HTTP接口还是比较简单的,没啥好说的,直接上代码@RestController @RequestMapping("/demo") public class test { @RequestMapping(value = "/test", method = Request...
  • Referenced file contains errors (http://www.springframework.org/schema/mvc/spring-mvc.xsd). For more information, right click on the message in the Problems View and select “Show Details…” 解决办法...
  • spring-mvc4.2.4 中文API文档下载

    千次阅读 2017-07-14 15:28:44
    在线查看地址:...gitbook下载地址(很慢):https://www.gitbook.com/book/linesh/spring-mvc-documentation-linesh-translation/details csdn下载地址(免积分):http://download.csdn.net/detail/lei
  • spring-mvc跳转根目录下的jsp文件

    千次阅读 2016-08-09 10:36:52
    使用spring-mvc的视图控制器进行页面跳转时,如果页面没有放在WEB-INF下面,可以使用如下的方式进行跳转 ModelAndView mv = new ModelAndView(); mv.setViewName("redirect:/index.jsp");
  • HTTP ERROR 404(spring-mvc时无法访问静态页面问题)。
  • spring-mvc 为什么我不能继承simpleformcontroller???求解!
  • SPRING-MVC 启动重复加载两次映射

    千次阅读 2015-04-24 17:59:13
    如下web.xml示例: part1.用spring的配置加载...2.配置spring-mvc的contextConfigLocation   contextConfigLocation classpath:spring-*.xml --------------------------------------
  • Spring-mvc-jdbc知识点小结

    千次阅读 2010-07-22 17:20:00
    1、首先谈谈Spring-mvc 在使用Spring-mvc之前,为一直使用的是struts,关于struts的介绍为前面也曾小结过,所以这里就不多说了。还是来谈谈Springmvc吧. Web开发大家都知道Servlet,和大多数基于...
  • 1.问题描述 在pom.xml中,已经包含了所有的spring相关包。...在红字部分Ctrl+F1,提示cannot resolve servlet 'spring-mvc' 2.解决 在Project Structure>Modules>Web中,配置web.xml和web资源目录,具体如下:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390,479
精华内容 156,191
关键字:

spring-mvc

spring 订阅