2021-6-23--------------02springmvc

ssm:mybatis+Spring+SpringMVC 三层架构

如何学习？

框架：研究官方文档，锻炼自学能力，锻炼笔记能力

官方介绍：https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc

学习流程：

SpringMVC+Vue+SpringBoot+SpringBoot+SpringCloud+linux

==MVC：==模型（dao,service）+视图(jsp)+控制器(Servlet)

Controller：负责接收用户的请求，调用相关业务逻辑后把结果返回
给视图，是 Model 和 View 的中间控制中枢。

1. 取得表单数据
2. 调用业务逻辑
3. 转向指定页面

Model:模型:代表业务数据、状态、处理逻辑，以及数据库等；

1. 业务逻辑
2. 保存数据的状态

View：视图，代表用户界面数据，是用户可以直观看到的界面数据。

1. 显示页面

dao-----service-----servlet-----jsp

前端 数据传输 实体类

实体类：用户名，密码，生气，爱好

前端：用户名 密码

pojo:User

vo:UserVo 实体类，拆掉了一些不必要的东西

dto:

Model1时代：

JSP：本质就是一个servlet

假设：你的项目的架构师设计好的还是演进的？

• Alibaba PHP
• 随着用户大，java才能做一些东西
• mysql：—》AliSQL、AliRedis
• ALL in one —>微服务的项目

MVVM：M V VM：双向绑定

什么是SpringMVC?

基于java实现的MVC的轻量级框架

为什么学习springmvc？

• Servlet的开发配置相对麻烦，servlet特别多的时候web.xml文件将会非常臃肿
• 每个Servlet都只能处理一个功能，如果需要多个功能就需要开发多个Servlet，项目中存在大量Servlet显得
  臃肿。
• 获取请求参数 进行类型转换 封装数据到bean的 过程比较繁琐
• 其他开发中不方便的地方，例如，乱码问题…数据格式处理…表单校验。
• 轻量级，简单易学
• 高效，基于请求响应的MVC框架
• 约定大于配置
• 功能强大：RESTful、数据验证、格式化、本地化、主题
• 与spring无缝结合

一、springmvc例子

启动

1.web启动时，会默认去读取web.xml的配置，根据此配置启动项目。

执行流程：

1. DispatcherServlet表示前置控制器，本质上是一个Servlet，相当于一个中转站，所有的访问都会走到这个Servlet中，再根据配置进行中转到相应的Handler中进行处理,获取到数据和视图后，在使用相应视图做出响应。

• 假设我们接收的url:http://localhost:8081/hello
• 拆分为三部分：
• http://localhost:8081服务器域名
• springmvc部署在服务器上的web站点
• hello表示控制器
• 通过分析，url表示位于服务器http://localhost:8081上的springmvc的站点的hello控制器

2. HandlerMapping为处理器映射。本质上就是一段映射关系，将访问路径和对应的Handler存储为映射关系，在需要时供前端控制器查阅。

   a. HandlerAdapter表示处理器适配器,
   本质上是一个适配器，可以根据要求找到对应的Handler来运行。前端控制器通过处理器映射器找到对应的
   Handler信息之后，将请求响应和对应的Handler信息交由处理器适配器处理，处理器适配器找到真正
   handler执行后，将结果即model和view返回给前端控制器
   b. 视图解析器(ViewResolver)
   本质上也是一种映射关系，可以将视图名称映射到真正的视图地址。前端控制器调用处理器适配完成后得到
   model和view，将view信息传给视图解析器得到真正的view。
   c.视图
   本质上就是将handler处理器中返回的model数据嵌入到视图解析器解析后得到的jsp页面中，向客户端做出
   响应
   web.xml

    
    
        springmvc
        org.springframework.web.servlet.DispatcherServlet
        
        
            contextConfigLocation
            classpath:springmvc-servlet.xml
        
    
    
        springmvc
        /
    

springmvc-servlet.xml

public class HelloController implements Controller {


    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //模型和视图
        ModelAndView view = new ModelAndView();
        //封装对象，放在ModelAndView中，Model
        view.addObject("msg","HelloSpringmvc");
        //封装要跳转的视图，放在ModelAndView中
        view.setViewName("hello");///WEB-INF/jsp/hello.jsp
        return view;
    }
}

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


${msg}

使用springMVC必须配置的三大件

处理器映射器、处理器适配器、视图解析器

1. RequestMapping参数的配置，value
   指定要将当前处理器绑定到哪个访问路径上。
   可以配置多个路径。
   路径中也可以使用*号作为通配符匹配部分路径。
2. params
   用来限定当前请求中必须包含指定名称的请求参数才会被当前
   处理器处理
   通过params属性指定只处理请求参数符合指定要
   求的请求

在实际项目中使用注解方式

web.xml

<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">
    
    <servlet>
        <servlet-name>SpringMVCservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc-servlet.xmlparam-value>
        init-param>
        
        <load-on-startup>1load-on-startup>
    servlet>

    
    <servlet-mapping>
        <servlet-name>SpringMVCservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>
web-app>

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
       http://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.kuang.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
  支持mvc注解驱动
      在spring中一般采用@RequestMapping注解来完成映射关系
      要想使@RequestMapping注解生效
      必须向上下文中注册DefaultAnnotationHandlerMapping
      和一个AnnotationMethodHandlerAdapter实例
      这两个实例分别在类级别和方法级别处理。
      而annotation-driven配置帮助我们自动完成上述两个实例的注入。
   -->
    <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>

HelloController.java

@Controller
//@RestController   json字符串
//@RequestMapping("/hello")
public class HelloController {
/**
    * String[] value属性
    * 配置当前处理器方法和哪些路径进行绑定
    * 可以绑定多个路径
    * 代表通配符可以匹配所有
    *   RequestMethod[] method()属性
    * 限制当前处理器可以接受哪些请求方式请求
    * 如果不配置则可以接受任意的请求方式的请求
    * * String[] params() 属性
    * 用来限定对请求方式的要求，只有请求参数符合要求的请求才能被接收
    * 如果不配置默认对请求参数没有任何要求
    *   配置方式
    *       格式1:指定名称，要求必须具有该名称的请求参数
    *       格式2:以"!名称"方式必须不包含指定名称的请求参数
    *       格式3:以"名称=值"或"名称!=值"方式指定必须具有某个请求参数且值必须等于或不等于给定值
    *  http://localhost/SpringMVC01_02_RequestMapping/my02/test03.action?uname=zs&addr=bj&gender=female
    * http://localhost/SpringMVC01_02_RequestMapping/my02/test03.action?uname=zs&uage=1&addr=bj&gender=female
    * http://localhost/SpringMVC01_02_RequestMapping/my02/test03.action?addr=bj&gender=female
    * http://localhost/SpringMVC01_02_RequestMapping/my02/test03.action?uname=zs&addr=bj&gender=male
    * String[] headers属性
    *  用来限定对请求头的要求，只有请求头符合要求的请求才能接收
    *   如果不配置对于请求头的内容没有任何要求
    *       配置格式
    *           格式1:只指定名称 要求必须具有该名称的请求头
    *           格式2：以"!名称"方法指定必须不包含指定名称的请求头
    *           格式3:以"名称=值"或"名词！=值" 方式指定必须含有某个请求头且必须等于值或不等于值
    * */
    @RequestMapping(value={"/test02.action","/test002.action","/test0
02*.action"},method= RequestMethod.POST,params= 
{"name","gender=male","!age","addr!=bj"},headers = {"Host","Connection"})
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello");
        return "hello";//会被视图解析器处理
    }
}

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


${msg}

可以接收的参数

web开发相关对象

在控制器方法中可以直接接收和web开发相关的对象
可以直接利用这些对象完成web开发相关功能
1. HttpServletRequest
2. HttpServletResponse
3. HttpSession
4. WebRequest
WebRequest对象相当于是request对象和session
对象的合体
同时提供了request具有的方法和session具有的方
法

数据模型对象

可以接收Model、Map、ModelMap类型的参数作为数据模型对象
这三个对象功能类似，api有所不同

• 向model中写入数据，默认就是写入request域

	@RequestMapping("/test04.action")
	public String test04(ModelMap mm){
		 mm.put("k1","v1");
		 mm.addAttribute("k2","v2");
		 return "my03test04";
	}
	@RequestMapping("/test03.action")
	public String test03(Map map){
		 map.put("k1","v1");
		 map.put("k2","v2");
		 return "my03test03";
	}
	@RequestMapping("/test02.action")
	public String test02(Model model){
		 model.addAttribute("k1","v1");
		 model.addAttribute("k2","v2");
		 return "my03test02";
	}
	@RequestMapping("/test01.action")
	public ModelAndView test01(){
		 ModelAndView mav = new ModelAndView();
		 mav.addObject("k1","v1");
		 mav.addObject("k2","v2");
		 mav.setViewName("my03test1");
		 return mav;
	}

请求参数

直接接收请求参数

可以在Controller方法中直接接收请求参数相同名称的方法形参，可以直接得到请求参数的值

请求参数中的名称和属性名不同的处理@RequestParam

value	参数名字，即入参的请求参数名字，如value=“delId”表示请求的参数区中的名字为delId的参数的值将传入
required	是否必须，默认是true，表示请求中一定要有相应的参数，否则将报400错误码；
defaultValue	默认值，表示如果请求中没有同名参数时的默认值

value来指定 将那个请求参数赋值给当前形参
将required声明为true，则请求参数中必须有该属
性，如果没有客户端将受到400

 /*
    * 获取请求参数--传统方式
    * */
    @RequestMapping("/test01.action")
    public void test01(HttpServletRequest request){
        String uname = request.getParameter("uname");
        int uage=Integer.parseInt(request.getParameter("uage"));
        System.out.println(uname+"#"+uage);
    }
    /*
     * 获取请求参数--SpingMVC方式  直接获取请求参数
     * */
    @RequestMapping("/test02.action")
    public void test02(String uname,int uage){
        System.out.println(uname+"#"+uage);
    }

    /*
    *获取请求参数--SpingMVC方式 手动映射请求参数
    * @RequestParam("uname")获取的是前端的值
    * */
    @RequestMapping("/test03.action")
    public void test03(@RequestParam("uname") String name, @RequestParam("uage")int age){
        System.out.println(name+"#"+age);
    }

请求参数中存在多个同名参数

	@RequestMapping("/test04_1.action")
    public void test04_1(String like){
        //把多个重名的请求参数值拼接成一个字符串
        System.out.println(like);
    }
    @RequestMapping("/test04_2.action")
    public void test04_2(String[] like){
        //把多个重名的请求参数值放到数组中
        System.out.println(Arrays.toString(like));
    }

封装请求参数到bean

自动封装请求参数信息到bean
SpringMVC框架可以自动将请求参数封装到bean中要求bean中必须提供属性的setXxx方法，且bean的属性名和请求参数中请求参数的名字必
须一致，才可以自动设置。

GET提交
        

            用户名
            地址
            
        

.java

/*
    * 把数据（请求参数）封装到bean中
    *   传统方式
    * */
    @RequestMapping("/test05_1.action")
    public void test05_1(HttpServletRequest request){
        String uname = request.getParameter("uname");
        String uaddr = request.getParameter("uaddr");
        int uage=Integer.parseInt(request.getParameter("uage"));
        User user=new User();
        user.setUname(uname);
        user.setUaddr(uaddr);
        user.setUage(uage);
        System.out.println(user);
    }
    /*
    * 把数据（请求参数）封装到bean中
    * SpingMVC方式（bean中属性要和请求参数名一致）
    * */
    @RequestMapping("/test05_2.action")
    public void test05_2(User user){
        System.out.println(user);
    }

域属性

• @RequestAttribute

• @SessionAttrribute

/*
    * request域---SpringMVC形式
    * */
    @RequestMapping("/test01.action")
    public String test01(HttpServletRequest request){
        request.setAttribute("k1","v1");
        request.setAttribute("k2","v2");
        return "forward:/my05/test02.action";
    }
    @RequestMapping("/test02.action")
    public void test02(@RequestAttribute String k1,@RequestAttribute String k2){
        System.out.println(k1);
        System.out.println(k2);
    }

    /*
     * request域---SpringMVC形式
     * */
    @RequestMapping("/test03.action")
    public String test03(HttpSession session){
        session.setAttribute("sk1","sv1");
        session.setAttribute("sk2","sv2");
        return "forward:/my05/test04.action";
    }
    @RequestMapping("/test04.action")
    public void test04(@SessionAttribute String sk1,@SessionAttribute String sk2){
        System.out.println(sk1);
        System.out.println(sk2);
    }

@CookieValue

用在控制器方法参数上
用来从Cookie中获取指定名称的Cookie值

//创建Cookie对象
        Cookie cookie=new Cookie("time","20210827");
        cookie.setPath(request.getContextPath()+"/");
        response.addCookie(cookie);

        Cookie[] cookies = request.getCookies();
        Cookie finC=null;
        if(cookies!=null){
            for(Cookie c:cookies){
                if("time".equals(c.getName())){
                    finC=c;
                    break;
                }
            }
        }
        if(finC!=null){
            String value = finC.getValue();
            System.out.println(value);
        }else {
            System.out.println("没有找到");
        }
    }
    /*
     *
     * 获取cookie值    SpringMVC方式
     *
     * */
    @RequestMapping("/test02.action")
    public void test02(@CookieValue("time") String time){
        System.out.println(time);
    }

@RequestHeader

用在控制器方法参数上
用来获取指定名称请求头的值

/*
     *
     * 获取请求头的值  传统方式
     *
     * */
    @RequestMapping("/test03.action")
    public void test03(HttpServletRequest request){
        String host = request.getHeader("Host");
        System.out.println(host);
    }

    /*
     *
     * 获取请求头的值    SpringMVC方式
     *
     * */
    @RequestMapping("/test04.action")
    public void test04(@RequestHeader("Host") String host){
        System.out.println(host);
    }

@RequestBody

• 注解用来获取请求体的内容，可以
  直接获取为字符串或将json自动解析为对象
• 被@ResponseBody修饰的方法直接将返回值加入
  响应体发送给浏览器

/*
    *
    * 获取请求体   传统方式
    * */
    @RequestMapping("/test01.action")
    public void test01(HttpServletRequest request) throws IOException {
        //request获取输入流从实体内容中来读取数据
        ServletInputStream in = request.getInputStream();
        //字节创建的目的地为字节数组的输出流
        ByteArrayOutputStream out=new ByteArrayOutputStream();
        //对接两个流传输数据
        int len=-1;
        byte[] bs=new byte[1024];
        while ((len=in.read(bs))!=-1){
            out.write(bs,0,len);
        }
        out.flush();
        //将写好的数组取出
        byte[] bytes = out.toByteArray();
        //转成字符串打印
        System.out.println(new String(bytes));
        //关闭流
        out.close();
    }

    /*
     *
     * 获取请求体   SpringMVC方式
     * */
    @RequestMapping("/test02.action")
    public void test02(@RequestBody String body){
        System.out.println(body);
    }

• 返回json字符串
  通过配置@ResponseBody利用内置的jackson
  将对象处理为json返回

/**
* 向客户端直接返回数据 - json
* http://localhost/SpringMVCDay02_02
_Details3/my01/test05.action
*/
@ResponseBody
@RequestMapping(value="/test05.action",produces="ap
plication/json;charset=utf-8")
public User test05() throws Exception {
	User user = new User(99,"张 三",Arrays.asList("bj","sh","gz"));
	return user;
}

ModelAttribute

• 用在方法上：
  则被修饰的方法将会在当前类的任意控制器方
  法执行之前执行
  该方法返回的返回值会自动存入model供后续
  使用
• 方法参数前
  则会从model中获取属性值赋值到被修饰的方
  法参数上

@ModelAttribute("uname")
    public String modelAttributeDemo(String name){
        return "zs";
    }

    @RequestMapping("/test")
    public String mo(@ModelAttribute("uname")String uanme){
        System.out.println(uanme);
        return "";
    }

void

如果返回值类型是void，则springmvc会采用默认视图
名来作为当前请求的视图名称来使用
所谓的默认视图名，就是当前访问的控制器方法访问路
径去除后缀的结果

/**
     * 如果是void所谓
     * /my01/test05.action   去掉后缀应该是/my01/test05
     */
    @RequestMapping("/test05.action")
    public void test07(){

    }

二、Springmvc：Controller以及RestFul风格

2.1、控制器Controller

• 控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
• 控制器负责解析用户的请求并将其转换为一个模型。
• 在Spring MVC中一个控制器类可以包含多个方法
• 在Spring MVC中，对于Controller的配置方式有很多种

2.2、RestFul风格

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

功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应 添加、 删除、修改、查询。

2.3、例子：

@Controller
public class RestfulController{
    //普通风格：http://localhost:8081/h3?a=1&b=2

    @RequestMapping("/h3")
    public String test1(int a, int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为"+res);
        return "test1";
    }
    //RestFul风格：http://localhost:8081/h4/1/2
    //@RequestMapping(value = "/h4/{a}/{b}",method = RequestMethod.GET)
    @GetMapping("/h4/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为"+res);
        return "test1";
    }
}

思考：使用路径变量的好处？

• 使路径变得更加简洁；
• 获得参数更加方便，框架会自动进行类型转换。
• 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/h4/1/2，则路径与方法不匹配，而不会是参数转换失败。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

三、数据处理及跳转

1.ModelAndView

设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面

页面 : {视图解析器前缀} + viewName +{视图解析器后缀}

2.ServletAPI

通过设置ServletAPI , 不需要视图解析器 .

1、通过HttpServletResponse进行输出

2、通过HttpServletResponse实现重定向

3、通过HttpServletResponse实现转发

3.通过SpringMVC来实现转发和重定向 - 无需视图解析器；

转发和定向：

@Controller
public class ModelTest{
        //转发
        @RequestMapping("/m1")
        public String test(){
            return "/WEB-INF/jsp/test1.jsp";
        }
        //重定向
    @RequestMapping("m2")
        public String test1(){
            return "redirect:/index.jsp";
        }

}

4.通过SpringMVC来实现转发和重定向 - 有视图解析器；

@Controller
public class ModelTest{
        //转发
        @RequestMapping("/m1")
        public String test(){
            return "test1";
        }
        //重定向
        @RequestMapping("m2")
        public String test1(){
            return "redirect:/index.jsp";
        }

}

5.数据处理

接收请求参数及数据回显

@Controller
@RequestMapping("/user")
public class UserController {
    //http://localhost:8081/user/t1?username=pcy
    //@RequestParam("username") 可以固定传入的参数的变量名必须是username
    @RequestMapping("/t1")
    public String test(@RequestParam("username") String name, Model model){
        //前端接收的参数
        System.out.println("前端接收的参数："+name);
        //返回给前端
        model.addAttribute("msg",name);
        return "test1";
    }
    //前端接收的是一个对象 id,name,age
    /*
    1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
    2.假设传递的是一个对象，匹配对象的字段名，如果名字一样则成功，否则匹配不到
     */
    @GetMapping("/t2")
    public String test1(User user){
        System.out.println(user);
        return "test1";
    }
    @GetMapping("/t3")
    public String test2(ModelMap modelMap){
        return "test1";
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    int id;
    String name;
    int age;
}

四、乱码问题

这里用get方法就不会乱码，但是post会出现乱码问题，后台编码会出现问题，如果后台乱码就是服务器乱码，需要在server.xml里面配置

解决post请求时乱码问题

1、web.xml里面加上

//乱码过滤
<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>
   <url-pattern>/*

2、自定义过滤器

package com.kuang.filter;


import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
public class GenericEncodingFilter implements Filter {
    public void destroy() {
    }
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
    public void init(FilterConfig filterConfig) throws ServletException {
    }
}
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
    //取一个值
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
    //取所有值
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

<filter>
        <filter-name>encodingfilter-name>
        <filter-class>com.kuang.filter.GenericEncodingFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>encodingfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

解决响应时乱码

 /*
    * 中文乱码  对应响应乱码通过produces属性来解决
    * */
    @ResponseBody
    @RequestMapping(value = "/test07.action",produces = "text/html;charset=utf8")
    public String test07(HttpServletResponse response){
        //返回数据之后会默认添加指定码表的过程就会把手动添加乱码解决的代码进行覆盖
        //response.setContentType("text/html;charset=utf8");
        return "哇深V吃";
    }

五、SpringMVC：JSON讲解

前后端分离时代：后端部署后端，提供接口：@RequestMapping，提供数据

​ JSON

前端独立部署，负责渲染后端的数据

什么是json?

• JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
• 采用完全独立于编程语言的文本格式来存储和表示数据。
• 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
• 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。

• 对象表示为键值对，数据由逗号分隔
• 花括号保存对象
• 方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

区别：

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

测试

Controller返回JSON数据

导入包

    com.fasterxml.jackson.core
    jackson-databind
    2.12.1

controller包HelloController1

@Controller
public class HelloController1 {
    //produces:指定响应体返回类型和编码
    @RequestMapping(value = "/t3")
    @ResponseBody//它就不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //创建一个对象
        User user=new User(1,"pcy",10);
        //jackson,objectMapper
        ObjectMapper mapper=new ObjectMapper();

        String s = mapper.writeValueAsString(user);
        return s;
    }
    //produces:指定响应体返回类型和编码
    @RequestMapping(value = "/t4")
    @ResponseBody//它就不会走视图解析器，会直接返回一个字符串
    public String json2() throws JsonProcessingException {
        List list=new ArrayList();

        //创建一个对象
        User user=new User(1,"pcy",10);
        User user2=new User(1,"pcy",10);
        User user3=new User(1,"pcy",10);
        list.add(user);
        list.add(user2);
        list.add(user3);
        //jackson,objectMapper
        ObjectMapper mapper=new ObjectMapper();

        String s = mapper.writeValueAsString(list);
        return s;//new ObjectMapper().writeValueAsString(list)
    }
    //produces:指定响应体返回类型和编码
    @RequestMapping(value = "/t5")
    @ResponseBody//它就不会走视图解析器，会直接返回一个字符串
    public String json3() throws JsonProcessingException {
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //jackson,objectMapper
        ObjectMapper mapper=new ObjectMapper();

        //时间戳   Timestamp
        String s = mapper.writeValueAsString(dateFormat.format(date));
        return s;//new ObjectMapper().writeValueAsString(list)
    }
    @RequestMapping("/t6")
    @ResponseBody
    public String json4() throws JsonProcessingException {

        ObjectMapper mapper = new ObjectMapper();

        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //指定日期格式
        mapper.setDateFormat(sdf);

        Date date = new Date();
        String str = mapper.writeValueAsString(date);

        return str;
    }
    @RequestMapping("/t7")
    @ResponseBody
    public String json5() throws JsonProcessingException {

        Date date = new Date();


        return JsonUtil.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }
}

util包JsonUtil.java

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

springmvc-servlet.xml

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <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>

fastjson

    com.alibaba
    fastjson
    1.2.75

@Controller
public class fashjsonDemo {
    @RequestMapping("/t11")
    @ResponseBody
    public String json(){
        List list=new ArrayList();
        User user=new User(1,"pcy",4);
        User user1=new User(1,"pcy",4);
        User user2=new User(1,"pcy",4);
        list.add(user);
        list.add(user2);
        list.add(user1);
        String s = JSON.toJSONString(list);
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);

        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
        return s;
    }

}

六、拦截器

**过滤器与拦截器的区别：**拦截器是AOP思想的具体应用。

过滤器

• servlet规范中的一部分，任何java web工程都可以使用
• 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

• 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
• 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

第一个实例：

MyInterceptor.java

public class MyInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        //return true;执行下一个拦截器，放行
        System.out.println("处理前");
        return true;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("处理后");
    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("清理");
    }
}

配置拦截器

applicationContext.xml

    <mvc:interceptors>
        <mvc:interceptor>
            
            <mvc:mapping path="/**"/>
            <bean class="com.kuang.config.MyInterceptor"/>
        mvc:interceptor>
    mvc:interceptors>

pom.xml

    
    
    javax
    javaee-api
    7.0
    
    provided
    
    
    javax.servlet
    jsp-api
    2.0
    
    
    
    javax.servlet
    javax.servlet-api
    4.0.1
    
    
    
    org.springframework
    spring-core
    ${spring.version}
    
    
    org.springframework
    spring-web
    ${spring.version}
    
    
    org.springframework
    spring-oxm
    ${spring.version}
    
    
    org.springframework
    spring-tx
    ${spring.version}
    
    
    org.springframework
    spring-jdbc
    ${spring.version}
    
    
    org.springframework
    spring-webmvc
    ${spring.version}
    
    
    org.springframework
    spring-aop
    ${spring.version}
    
    
    org.springframework
    spring-context-support
    ${spring.version}
    
    
    org.springframework
    spring-test
    ${spring.version}
    
    
    
    org.apache.taglibs
    taglibs-standard-spec
    1.2.5
    
    
    org.apache.taglibs
    taglibs-standard-impl
    1.2.5
    
    
    junit
    junit
    4.11
    test
    

七、文件上传

文件上传表单必须满足以下三个条件

a. 文件上传项必须有name属性
b. 表单必须是Post提交
c. 表单必须是enctype=“multipart/form-data”

在springmvc配置文件中配置文件上传工具

在Controller中实现文件上传

八、定时上传

SpringMVC中没有提供实现定时刷新的便捷方式，只能用传统
方式实现定时刷新

/**
* 定时刷新 - 传统方式
*/
@RequestMapping("/test01.action")
public void test01(HttpServletRequest request,HttpServletResponse 
response) throws IOException {
 response.setContentType("text/html;charset=utf-8");
 response.getWriter().write("注册成功，3秒后回到主页..");
 
response.setHeader("refresh","3;url="+request.getContextPath()+"/index.
jsp

九、异常处理

为当前Controller配置错误处理

注解方式配置全局的错误处理

配置文件方式配置全局错误处理

<bean 
class="org.springframework.web.servlet.handler.SimpleMappingExcept
ionResolver">
<property name="exceptionMappings">
	<props>
		<prop key="java.lang.NullPointerException">
		null_err</prop>
		<!--配置视图展示错误-->
		<prop key="java.io.IOException">io_err</prop>
		<prop key="java.lang.Throwable">g_err</prop>
	</props>
</property>
</bean>