四十二、SpringMVC

前言

• springMVC依赖。

  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.2.0.RELEASE</version>
  </dependency>

一、springMVC

1.MVC模型

• 模型（models），视图（view），控制器（controller），是一种软件设计的规范。
• 把业务逻辑，视图，数据分离开来组织代码。
• 降低视图和业务逻辑的耦合性。

2.springMVC的执行过程

1. 用户发送请求，DispatcherServle控制器接收请求并拦截请求。
2. DispatcherServlet调用HandlerMapping，查找具体的Handler。
3. HandlerExecution是具体的Handler，主要作用是根据请求的url找到具体的控制器（controller），HandlerExecution将解析后的信息返回给DispatcherServlet。
4. DispatcherServlet调用HandlerAdapter，HandlerAdapter按照特定的规则（实现controller接口）执行Handler。
5. Handler会让具体的控制器（controller）执行。
6. 控制器（controller）执行完成后返回给HandlerAdapter一个ModelAndView。
7. HandlerAdapter把ModerAndView返回给DispatcherServlet。
8. DispatherServlet把ModelAndView传给ViewResolver。
9. ViewResolver执行完成后返回给DispatherServlet一个具体的View。
   • viewResolver获取mv的数据；
   • 解析mv的视图名字；
   • 拼接视图名字找到对应的视图；
   • 将数据渲染到视图上。
10. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
11. DispatcherServlet把视图响应呈现给用户。

3.springMVC的配置文件的方式

1. web.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0">
   <!--配置DispatcherServlet: 这个是SpringMVC的核心：请求分发器，前端控制器-->
   <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:springmvc-servlet.xml</param-value>
       </init-param>
       <!--启动级别：1-->
       <load-on-startup>1</load-on-startup>
   </servlet>
   <!--
       在SpringMVC中，  /  /*
       / : 只匹配所有的请求，不会去匹配jsp页面
       /* : 匹配所有的请求，包括jsp页面
   -->
   <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
   </web-app>

1. springmvc-servlet.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
   <!--处理器映射器-->
   <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
   <!--处理器适配器-->
   <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
   <!--视图解析器：模板引擎可以替换，Thymeleaf,Freemarker...-->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
       <property name="prefix" value="/WEB-INF/jsp/"/>
       <property name="suffix" value=".jsp"/>
   </bean>
   <!--BeanNameUrlHandlerMapping:bean-->
   <bean id="/hello" class="com.sywl.servlet.HelloServlet"></bean>
   </beans>

4.springMVC的注解配置的方式

springMVC的web.xml的配置不变

springMVC的springmvc-servlet.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.shuai.controller"/>
    <!--tomcat提供了默认的Servlet来处理静态资源-->
    <mvc:default-servlet-handler/>
    <!--
    帮助我们完成DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter实例的注册，这两个实例是为了让@RequestMapping注解生效
    -->
    <mvc:annotation-driven/>
    <!--视图控制器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

5.springMVC的转发和重定向

1. 跳转页面通过ModelAndView
   设置ModelAndView对象，根据view的名称和视图解析器跳转到指定的页面。
   页面：{视图解析器前缀}+viewName+{视图解析器后缀}

   public class HelloController implements Controller {
   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       ModelAndView mv = new ModelAndView();
       // 业务代码
       String result = "HelloSpringMVC";
       mv.addObject("msg",result);
       // 试图跳转
       mv.setViewName("test");
       return mv;
   }
   }

1. 通过设置ServletAPI，不需要视图解析器
   • 通过HttpServletResponse进行输出：resp.getWriter().println(“Hello,Spring By Servlet API”);
   • 通过HttpServletResponse实现重定向：resp.sendRedirect(“/index.jsp”);
   • 通过HttpServletResponse实现转发：resp.getRequestDispatcher(“/WEB-INF/jsp/test.jsp”).forward(req,resp);
2. springMVC的转发和重定向

6.springMVC接收请求参数

• 前端传递的参数名和方法上的参数名相同，可以直接接收参数使用。
• 前端传递的参数名和方法上的参数名不相同，可以使用@RequestParam指定前端传递的参数名和方法上的参数名绑定。

  @RequestMapping("/add")
  public String test(@RequestParam("username") String name){
   // @RequestParam限定前端传递的参数名只能是username并且和方法上的参数名name绑定。
   // 如果前端传递的参数名不是username,则会报错。
   return "test";
  }

• 前端传递对象时，方法上可以用实体类进行接收。
  （前端传递的一个对象User,后端User实体类匹配传递来的User对象中的字段名:如果名字一致则接收参数，否则匹配不到）

  @GetMapping("/t2")
  public String test2(User user, Model model){
   // 1.接收前端参数
   System.out.println("前端接收到的参数为："+user);
   model.addAttribute("msg",user);
   return "test";
  }

7.springMVC的数据回显

• Model:简化版，只有简单的几个方法适用于存储数据，对新手友好。
• ModelMap:继承了LinkedMap，除自身方法，还继承了LinkedMap的方法和特性。
• ModelAndView:可以在存储数据的同时，设置返回的逻辑视图，控制展示的跳转。

8.springMVC的乱码解决

post提交中文乱码的解决，一般配置springMVC过滤器就可以解决。实在解决不掉，把视频再看一遍。

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <!--注意是/*-->
     <!--/* : 匹配所有的请求，包括jsp页面-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

二、Restful风格

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。
基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

• 使用RESTful操作资源：可以通过不同的请求方式来实现不同的效果！比如:请求地址一样，但是功能可以不同。
  • GetMapping
  • PostMapping
  • DeleteMapping
  • PutMapping
• 路径参数
  @PathVariable

  @RequestMapping("add/{a}/{b}")
  public String test1(@PathVariable int a,@PathVariable int b, Model model){
   int res = a + b;
   model.addAttribute("msg","结果为："+res);
   return "test";
  }

三、JSON

1.json

• json是一种轻量级的数据交换格式。
• json和js对象的关系：json是js对象的字符串表示法，json本质上就是一个字符串。
• json和js对象的互相转换。
• 对象的键名也可以使用引号包裹。

  var obj = JSON.parse('{"name":"zs","age":"12"}')
  // {name:"zs",age:12}           反序列化
  var json = JSON.Stringify({name:"zs",age:12})
  // '{"name":"zs","age":"12"}'   序列化

2.Jackson（对象转成json字符串）

1. 导入Jackson包。

   <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.9.2</version>
   </dependency>

1. springmvc的配置文件配置中文乱码的问题。

   <!--jackson乱码问题配置-->
   <mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="ObjectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
   </mvc:annotation-driven>

1. 写工具包JsonUtil

   public class JsonUtil {
   public static String getJson(Object obj){
       return getJson(obj,"yy-MM-dd HH:mm:ss");
   }
   public static String getJson(Object obj,String dateFormat){
       // 创建一个解析器对象
       ObjectMapper mapper = new ObjectMapper();
       // 不使用时间戳的方式
       mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
       // 自定义日期格式对象
       SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
       // 指定日期格式
       mapper.setDateFormat(sdf);
       try {
           return mapper.writeValueAsString(obj);
       } catch (JsonProcessingException e) {
           e.printStackTrace();
       }
       return null;
   }
   }

1. 我们使用工具类，代码就更加简洁了

   @RequestMapping("/j5")
   public String json5(){
   Date date = new Date();
   String json = JsonUtil.getJson(date);
   return json;
   }

2.Fastjson（对象转成json字符串）

1. 导入Fastjson包。

   <dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.60</version>
   </dependency>

1. 使用

   @RequestMapping("/j6")
   public String json6() throws JsonProcessingException {
   // 创建一个对象
   User user1 = new User("小帅一号", 21, "男");
   User user2 = new User("小帅二号", 21, "男");
   User user3 = new User("小帅三号", 21, "男");
   User user4 = new User("小帅四号", 21, "男");
   ArrayList<User> list = new ArrayList<User>();
   list.add(user1);
   list.add(user2);
   list.add(user3);
   list.add(user4);
   String str = JSON.toJSONString(list);
   return str;
   }

Fastjson的三个主要的类

1. JSONObject 代表json对象
   • JSONObject实现了Map接口.猜想JSONObject底层操作是由Map实现的
   • JSONObject对应json对象,通过各种形式的get()方法可以获取json对象中的数据,也可利用size(), isEmpty()等方法获取”键:值”对的个数和判断是否为空,其本质是通过实现Map接口并调用接口中的方法完成的.
2. JSONArray 代表json对象数组
   • 内部是有List接口中的方法来完成操作的。
3. JSON代表 JSONObject和JSONArray的转化
   • JSON类源码分析与使用
   • 仔细观察这些方法,主要是实现json对象,json对象数组,javabean对象,json字符串之间的相互转化。

四、AJax

1. AJAX是Asynchronous JavaScript and XML(异步的JavaScript 和 XML)。
2. AJAX是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
3. Ajax不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

了解%2C#card=math&code=.ajax%28%7B%7D%29%2A%2A%2C%2A%2A&id=KsMiS).post({}),$.get({}) 请求的区别

https://blog.csdn.net/csucsgoat/article/details/117726102

$.ajax({
    url:"${pageContext.request.contextPath}/a1",   // 请求url
    data:{'name':$("#name").val()},   // 携带的数据data
    success:function (data) {   // 回调函数
});

五、拦截器

1.概念

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

2.拦截器和过滤器的区别

2.1过滤器

1. servlet规范中的一部分，在任何的Javaweb工程中都可以使用。
2. 在中配置了/*，可以对所有要访问的资源进行拦截。

2.2拦截器

1. 拦截器是springMVC框架自己的，只有使用了springMVC框架的工程才能使用。（最早在struct框架中就有）
2. 拦截器只会拦截访问的控制器方法，如果访问的是html/css/js/jsp/image则不会进行拦截。
3. 拦截器是AOP思想的具体应用。

3.拦截器配置和使用

1. 在logininterceptor包下编写拦截器函数

   public class LoginInterceptor implements HandlerInterceptor {
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
       // 如果是登陆页面则放行
       System.out.println("uri: " + request.getRequestURI());
       if (request.getRequestURI().contains("login")) {
           return true;
       }
       HttpSession session = request.getSession();
       // 如果用户已登陆也放行
       if(session.getAttribute("user") != null) {
           return true;
       }
       // 用户没有登陆跳转到登陆页面
       request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
       return false;
   }
   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
   }
   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
   }
   }

1. 在springmvc-servlet.xml中配置

   <mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean id="loginInterceptor" class="com.shuai.interceptor.LoginInterceptor"/>
   </mvc:interceptor>
   </mvc:interceptors>

六、文件上传和下载

1.前端表单要求

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

对表单中的 enctype 属性做个详细的说明：

• application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
• multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
• text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

<form action="" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>    
    <input type="submit">
</form>

一旦设置了enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

• Servlet3.0规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成。
• 而Spring MVC则提供了更简单的封装。
• Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。
• Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类：
• CommonsMultipartResolver。因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。

2.后端的要求

1. 导入包

   <!--文件上传-->
   <dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.3</version>
   </dependency>
   <!--servlet-api导入高版本的-->
   <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>4.0.1</version>
   </dependency>

1. springMVC文件上传配置

   <!--文件上传配置-->
   <bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
   <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
   <property name="defaultEncoding" value="utf-8"/>
   <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
   <property name="maxUploadSize" value="10485760"/>
   <property name="maxInMemorySize" value="40960"/>
   </bean>

1. 编写前端页面

   <form action="/upload" enctype="multipart/form-data" method="post">
   <input type="file" name="file"/>
   <input type="submit" value="upload">
   </form>

1. Controller

   @Controller
   public class FileController {
   //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
   //批量上传CommonsMultipartFile则为数组即可
   @RequestMapping("/upload")
   public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {
      //获取文件名 : file.getOriginalFilename();
      String uploadFileName = file.getOriginalFilename();
      //如果文件名为空，直接回到首页！
      if ("".equals(uploadFileName)){
          return "redirect:/index.jsp";
     }
      System.out.println("上传文件名 : "+uploadFileName);
      //上传路径保存设置
      String path = request.getServletContext().getRealPath("/upload");
      //如果路径不存在，创建一个
      File realPath = new File(path);
      if (!realPath.exists()){
          realPath.mkdir();
     }
      System.out.println("上传文件保存地址："+realPath);
      InputStream is = file.getInputStream(); //文件输入流
      OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
      //读取写出
      int len=0;
      byte[] buffer = new byte[1024];
      while ((len=is.read(buffer))!=-1){
          os.write(buffer,0,len);
          os.flush();
     }
      os.close();
      is.close();
      return "redirect:/index.jsp";
   }
   }

1. 测试上传文件，OK！

采用file.Transto 来保存上传的文件

1. 编写Controller ```java /*

• 采用file.Transto 来保存上传的文件 */ @RequestMapping(“/upload2”) public String fileUpload2(@RequestParam(“file”) CommonsMultipartFile file, HttpServletRequest request) throws IOException {

  //上传路径保存设置 String path = request.getServletContext().getRealPath(“/upload”); File realPath = new File(path); if (!realPath.exists()){

   realPath.mkdir();

  } //上传文件地址 System.out.println(“上传文件保存地址：”+realPath);

  //通过CommonsMultipartFile的方法直接写文件（注意这个时候） file.transferTo(new File(realPath +”/“+ file.getOriginalFilename()));

  return “redirect:/index.jsp”; } ```

1. 前端表单提交地址修改
2. 访问提交测试，OK！

文件下载

狂神说Java