springmvc

Spring Web MVC（了解概念；重点学习：配置与注解）

演变

JSP Model1

JSP+JavaBean

在一个项目中，如果业务流程比较简单的时候，可以把控制器的功能交给视图，项目架构中只有视图和模型，没有控制器。

Model1模式的基础是JSP，它由JSP和JavaBean组成，JSP从HTTPRequest中获取所需要的数据，并调用JavaBean进行业务逻辑的处理，然后通过HTTPResponse将结果返回给前端浏览器。可见，Model1一定程度上实现了MVC，只不过将控制层和视图层统一定位到JSP页面，JavaBean依然充当模型组件。这种模式下JSP身兼多职，既要负责视图层的数据展示，又要负责业务流程控制，结构较为混乱，也不是我们所希望的松耦合架构，所以在大型项目中或者当业务流程比较复杂的时候不建议这样做。

JSP Model2

JSP+Servlet+JavaBean

当业务流程比较复杂的时候，就需要把业务流程控制交给专门的控制器，JSP只专注于视图的渲染展现即可。这种模式就是JSP Model2，即JSP+Servlet+JavaBean，也就是典型的MVC设计模式。

相比于Model1，Model2是将控制层单独划分出来，以Servlet的形式存在于项目架构中，负责业务流程的控制，接收请求，创建所需的JavaBean组件，并将处理后的数据返回给视图（JSP/HTML）进行结果渲染展示。这样的结构比较清晰，效果明显优化很多，并且结合Spring的IoC和AOP，也是一个松耦合的架构模式。所以，除非项目特别简单，一般情况下推荐使用JSP Model1。

MVC的处理过程：

首先视图提供系统与用户交互的界面，并发送用户的输入给控制器；

控制器接收到用户的请求，根据判断，决定调用哪个模型的哪个方法进行处理；

模型被控制器调用，根据控制器的指令进行相应的业务逻辑处理，并返回处理结果（数据）；

控制器根据返回的结果，调用相应的视图来渲染、格式化模型返回的数据；

视图响应给客户端浏览器。

MVC处理流程及优缺点

优点：

可以多视图共享多个模型，大大提高了代码的复用性；

MVC的三个模块相互独立，松耦合架构；

控制器提高了应用程序的灵活性和可配置性；

有利于项目的管理和维护。

缺点：

原理较复杂，实现起来固然没有JSP+JavaBean的方式来得快；

增加了系统结构和实现的复杂性；

视图对模型数据的访问效率较低。

简介

Spring Web 模型视图控制器(MVC)框架是围绕DispatcherServlet设计的，该框架将请求分配给处理程序，并具有可配置的处理程序 Map，视图分辨器，语言环境，时区和主题分辨器，以及对文件上传的支持。默认处理程序基于@Controller和@RequestMapping注解，提供了多种灵活的处理方法。随着 Spring 3.0 的引入，@Controller机制还允许您通过@PathVariable注解和其他功能来创建 RESTful 网站和应用程序。

原则

开放扩展，封闭修改；Spring Web MVC 核心类中的某些方法标记为final。作为开发人员，您不能覆盖这些方法来提供自己的行为。这不是随意进行的，而是要牢记这一原则。

Spring MVC运行原理

1. 客户端发出HTTP请求，Web应用服务器接收此请求。如匹配DispatcherServlet的请求映射路径，则Web容器将该请求转交给DispatcherServlet处理；
2. DispatcherServlet拿到请求之后，根据请求的信息（URL、请求参数、HTTP方法等）及HandlerMapping的配置找到处理请求的处理器（Handler）；
3. 当DispatcherServlet找到相应的Handler之后，通过HandlerAdapter对Handler进行封装，再以统一的适配器接口调用Handler。HandlerAdapter可以理解为真正使用Handler来干活的人。
4. 在请求信息真正到达调用Handler的处理方法之前的这段时间，Spring MVC还完成了很多工作，它会将请求信息以一定的方式转换并绑定到请求方法的入参，对于入参的对象会进行数据转换、数据格式化以及数据校验等。这些都做完以后，最后才真正调用Handler的处理方法进行相应的业务逻辑处理。
5. 处理器完成业务处理之后，将一个ModelAndView对象返回给DispatcherServlet，其中包含了逻辑视图名和模型数据信息。
6. DispatcherServlet通过ViewResolver将逻辑视图名解析为真正的视图对象View，可以是JSP、HTML、XML、PDF、JSON等等，得到真正的视图对象之后，DispatcherServlet会根据ModelAndView对象中的模型数据对View进行视图渲染。最终客户端获得响应消息。

Spring MVC框架的特点

• 角色划分清晰。Model、View、Controller各司其职，耦合度较低。

• 灵活的配置功能。Spring的核心是IoC和AOP，统一可以实现在MVC上，把各种类当作Bean组件配置在Spring容器中。

• 提供了大量的接口和实现类，方便各种场景的开发。

• 真正做到与View层的实现无关。

• 结合Spring的依赖注入，更好地应用了面向接口编程的思想。

• 可以与Spring天衣无缝的整合

DispatcherServlet

DispatcherServlet其实就是个Servlet（它继承自HttpServlet基类），同样也需要在你web应用的web.xml配置文件下声明

DispatcherServlet依赖的bean

逻辑试图和物理视图

逻辑试图：控制器方法返回一个字符串，或者是通过 ModelAndView.setViewName(String viewName) 方法设置一个视图名，此时的视图成为逻辑视图，因为前端控制器需要通过视图解析器来解析逻辑视图名，得到一个视图对象，然后才响应给客户端。

物理视图：在控制器方法中直接通过 ModelAndView.setView(View v)方法设置视图对象，然后返回ModelAndView给前端控制器，这时的视图就是物理视图，因为它前端控制器不需要再使用视图解析器来解析它，直接将视图内容响应给客户端。

定制DispatcherServlet的配置

定制DispatcherServlet的配置，具体的做法，是在web.xml文件中，Servlet的声明元素上添加一些Servlet的初始化参数（通过init-param元素）

构建springmvc项目

1.create new project

2.maven—》 create from archetype–》maven-archetype-webapp》起组名 项目名

3.java文件夹 mark directory as sources root

4.test文件夹 mark directory as Test sources root

5.在java包同级建一个resource文件夹 mark directory as Resource root

6.在resource文件夹下建spring-bean.xml与log4j.properties,dispatcher-servlet.xml

7.在webapp文件夹下面创建static文件夹用于存放静态资源

8.在static文件夹创建css image js

9.在java目录下建班级名文件夹

10 在班级名文件夹下建

controller

mapper

pojo

service

until

配置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_3_1.xsd"
         version="3.1">

  <display-name>Archetype Created Web Applicationdisplay-name>
  
  <welcome-file-list>
    <welcome-file>index.jspwelcome-file>
  welcome-file-list>
  
  <filter>
    <filter-name>encodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>UTF-8param-value>
    init-param>
  filter>
  <filter-mapping>
    <filter-name>encodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:spring-bean.xmlparam-value>
    
  context-param>
  
  <servlet>
    <servlet-name>springMVCservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    <init-param>
      
      
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:dispatcher-servlet.xmlparam-value>
    init-param>
    <load-on-startup>1load-on-startup>
    
    <async-supported>trueasync-supported>
  servlet>


  <servlet-mapping>
    <servlet-name>springMVCservlet-name>
    <url-pattern>/url-pattern>
  servlet-mapping>
  

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>
  
web-app>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

配置dispatcher-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    

    
    <context:component-scan base-package="kj08.controller"/>
    
    
   
    <mvc:annotation-driven/>

    
    
    <mvc:resources mapping="/css/**" location="/static/css/"/>
    <mvc:resources mapping="/js/**" location="/static/js/"/>
    <mvc:resources mapping="/image/**" location="/static/images/"/>
    <mvc:default-servlet-handler />

    
    
    <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>

    bean>



beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

配置spring-bean.xml

<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"
       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"
>
<context:component-scan base-package="kj08"/>


beans>
1
2
3
4
5
6
7
8
9
10
11
12
13

配置tomcat

name:服务器名字

after launch 选你有的服务器

url:设置发布路径

deployment 选择 war exploded

（1）war模式这种可以称之为是发布模式，看名字也知道，这是先打成war包，再发布；

（2）war exploded模式是直接把文件夹、jsp页面 、classes等等移到Tomcat 部署文件夹里面，进行加载部署。因此这种方式支持热部署，一般在开发的时候也是用这种方式

再回过头将on update action 改成updateclassesandresources 实现热部署 ：改jsp不用重启项目了

log

localhost是运行中的日志，它主要 记录 运行的一些信息，尤其是一些异常 错误 日志信息 。
catelina是 访问 日志信息，它 记录 的 访问 的 时间 ， IP ， 访问 的 资 料等相 关 信息。

idea运行tomcat是创建副本再运行 副本共享tomcat代码

启动tomcat

弹出浏览器正确访问就是成功

请求

HTTP 的请求报文分为三个部分 请求行、请求头和请求体

Request Line:请求行

请求行（Request Line）分为三个部分：请求方法、请求地址和协议及版本，以CRLF(rn)结束。HTTP/1.1 定义的请求方法有8种：GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS、TRACE,最常的两种GET和POST，如果是RESTful接口的话一般会用到GET、POST、DELETE、PUT。

Request Methods

注意，仅有POST、PUT以及PATCH这三个动词时会包含请求体，而GET、HEAD、DELETE、CONNECT、TRACE、OPTIONS这几个动词时不包含请求体。

Header:请求头

Request Body:请求体

根据应用场景的不同，HTTP请求的请求体有三种不同的形式。

application/json

application/json 这个 Content-Type 作为响应头大家肯定不陌生。实际上，现在越来越多的人把它作为请求头，用来告诉服务端消息主体是序列化后的 JSON 字符串。由于 JSON 规范的流行，除了低版本 IE 之外的各大浏览器都原生支持 JSON.stringify，服务端语言也都有处理 JSON 的函数，使用 JSON 不会遇上什么麻烦。

JSON 格式支持比键值对复杂得多的结构化数据，这一点也很有用。

text/xml

没什么好讲的

Query String:application/x-www-form-urlencoded

这算是最常见的 POST 提交数据的方式了。浏览器的原生 表单，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据。

ModelAndView 类

从名字上看ModelAndView中的Model代表模型，View代表视图，这个名字就很好地解释了该类的作用。业务处理器调用模型层处理完用户请求后，把结果数据存储在该类的model属性中，把要返回的视图信息存储在该类的view属性中，然后让该ModelAndView返回该Spring MVC框架。框架通过调用配置文件中定义的视图解析器，对该对象进行解析，最后把结果数据显示在指定的页面上。

常用构造方法

ModelAndView(String viewName)

最简单的ModelAndView是持有View的名称返回，之后View名称被view resolver，也就是实作org.springframework.web.servlet.View接口的实例解析，例如 InternalResourceView或JstlView等等：

ModelAndView(String viewName, Map model)

如果您要返回Model对象，则可以使用Map来收集这些Model对象，然后设定给ModelAndView，使用下面这个版本的ModelAndView：

ModelAndView()

这个构造方法构造出来的ModelAndView

不能直接使用，应为它没有指定view，也没有绑定对应的model对象。当然，model对象不是必须的，但是view确实必须的。

用这个构造方法构造的实例主要用来在以后往其中加view设置和model对象。

给ModelAndView

实例设置view的方法有两

个：setViewName(String viewName) 和 setView(View view)。前者是使用view

name，后者是使用预先构造好的View对象。其中前者比较常用。事实上View是一个接口，而不是一个可以构造的具体类，我们只能通过其他途径来获取

View的实例。对于view

name，它既可以是jsp的名字，也可以是tiles定义的名字，取决于使用的ViewNameResolver如何理解这个view name。

如何获取View的实例以后再研究。

而对应如何给ModelAndView

实例设置model则比较复杂。有三个方法可以使用：

addObject(Object modelObject)

addObject(String modelName, Object modelObject)

addAllObjects(Map modelMap)

ModelAndView

可以接收Object类型的对象，ModelAndView

将它视为其众多model中的一个。当使用Object类型的对象的时候，必须指定一个名字。ModelAndView

也可以接收没有明显名字的对象，原因在于ModelAndView

将调用spring自己定义的Conventions 类的.getVariableName()方法来为这个model生成一个名字。显然，对model而言，名字是必须的。

Conventions.getVariableName()生成名字的规则是使用对象的类名的小写模式来作model名字。当这个model是集合或数组的时候，使用集合的第一个元素的类名加s来作model的名字。

ModelAndView

也可以接收Map类型的对象，ModelAndView

将这个Map中的元素视为model，而不是把这个Map本身视为model。但是其他的集合类可以用本身作为model对象。

Model 与 ModelMap

首先都是存键值值，只是方法多了点

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

return new ModelAndView(“redirect:/404.htm”);重定向

学习相关注解（结合postman工具）

@Controller

@Controller 声明该类为SpringMVC中的Controller控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中使用@Controller ，就无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。@Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。

方法的返回值

返回ModelAndView：需要方法结束时，定义ModelAndView，将model和view分别进行设置。

返回void：

在controller方法形参上可以定义request和response，使用request或response指定响应结果：

1、使用request转向页面，如下：

request.getRequestDispatcher(“页面路径”).forward(request, response);

2、也可以通过response页面重定向：

response.sendRedirect(“url”)

3、也可以通过response指定响应结果，例如响应json数据如下：

response.setCharacterEncoding(“utf-8”);

response.setContentType(“application/json;charset=utf-8”);

response.getWriter().write(“json串”);

返回字符串：（String）

return “xxxxx”;逻辑视图名

return "redirect:/xxxxx"重定向

return "forward:xxxxx"转发

@RequestMapping

@RequestMapping的作用是建立请求URL和处理方法之间的对应关系

@RequestMapping可以作用在方法和类上

作用在类上：第一级的访问目录
作用在方法上：第二级的访问目录

@RequestMapping的属性

path-指定请求路径的URL
value属性和path属性是一样的
mthod 指定该方法的请求方式
params 指定限制请求参数的条件
headers 发送的请求中必须包含的请求头

produces:produces = “application/json;charset=utf-8” 等于 response.setContentType(“application/json;charset=utf-8”);

@ModelAttribute

方法上注释

被@ModelAttribute注释的方法会在此controller每个方法执行前被执行，因此对于一个controller映射多个URL的用法来说，要谨慎使用。

@ModelAttribute注释void返回值的方法

@Controller
    public class HelloWorldController {

        @ModelAttribute
        public void populateModel(@RequestParam String abc, Model model) {
           model.addAttribute("attributeName", abc);
        }

        @RequestMapping(value = "/helloWorld")
        public String helloWorld() {
           return "helloWorld";
        }
    }
//这个例子，在获得请求/helloWorld 后，populateModel方法在helloWorld方法之前先被调用，它把请求参数（/helloWorld?abc=text）加入到一个名为attributeName的model属性中，在它执行后helloWorld被调用，返回视图名helloWorld和model已由@ModelAttribute方法生产好了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

@ModelAttribute注释返回具体类的方法

@ModelAttribute
    public Account addAccount(@RequestParam String number) {
       return accountManager.findAccount(number);
    }
//model属性的名称没有指定，它由返回类型隐含表示，如这个方法返回Account类型，那么这个model属性的名称是account。这个例子中model属性名称有返回对象类型隐含表示，model属性对象就是方法的返回值。它无须要特定的参数
1
2
3
4
5

@ModelAttribute(value=“”)注释返回具体类的方法

@Controller
    public class HelloWorldController {
 
        @ModelAttribute("attributeName")
        public String addAccount(@RequestParam String abc) {
           return abc;
        }
 
        @RequestMapping(value = "/helloWorld")
        public String helloWorld() {
           return "helloWorld";
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

@ModelAttribute和@RequestMapping同时注释一个方法

@Controller
    public class HelloWorldController {
 
        @RequestMapping(value = "/helloWorld.do")
        @ModelAttribute("attributeName")
        public String helloWorld() {
           return "hi";
        }
    }
1
2
3
4
5
6
7
8
9

参数上注释

@ModelAttribute注释一个方法的参数

@Controller
    public class HelloWorldController {
 
        @ModelAttribute("user")
        public User addAccount() {
           return new User("jz","123");
        }
 
        @RequestMapping(value = "/helloWorld")
        public String helloWorld(@ModelAttribute("user") User user) {
           user.setUserName("jizhou");
           return "helloWorld";
        }
    }
//@ModelAttribute("user") User user注释方法参数，参数user的值来源于addAccount()方法中的model属性。此时如果方法体没有标注@SessionAttributes("user")，那么scope为request，如果标注了，那么scope为session
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

从Form表单或URL参数中获取（实际上，不做此注释也能拿到user对象）

@Controller
    public class HelloWorldController {
 
        @RequestMapping(value = "/helloWorld")
        public String helloWorld(@ModelAttribute User user) {
           return "helloWorld";
        }
    }
1
2
3
4
5
6
7
8

注意这时候这个User类一定要有没有参数的构造函数

@SessionAttributes

知道是往session作用域中赋值的就行了，但是一般不用，一般都是用原生api去写session的值

提一句：在Controller中得到request 或者session的方式

1.在参数上写HttpServletRequest request

2.定义类属性并自动注入

3.定义一个父类定义属性然后继承

@PathVariable

REST 风格

REST 即 Representational State Transfer（资源）表现层状态转化，用 URL 定位资源，用 HTTP 描述操作，是目前最流行的一种互联网软件架构，它的结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用，使用POST，DELETE，PUT，GET 分别对应 CRUD，Spring3.0 开始支持 REST 风格的请求。

类似于http://localhost:8080/goods/1

/**
 * @author: BNTang
 */
@Controller
public class MyFirstController {

    @RequestMapping("/rest/{id}")
    public String show(@PathVariable Integer id) {
        System.out.println(id);
        return "/first";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

使用 @PathVariable 接收 REST 风格参数

@requestParam

锐快死怕mu

与@RequestBody

@requestParam

注解@RequestParam接收的参数是来自requestHeader中，即请求头。通常用于GET请求

@RequestParam有三个配置参数：

• required 表示是否必须，默认为 true，必须。
• defaultValue 可设置请求参数的默认值。
• value 为接收url的参数名（相当于key值）。

@RequestParam用来处理 Content-Type 为 application/x-www-form-urlencoded 编码的内容

@RequestParam也可用于其它类型的请求，例如：POST、DELETE等请求。

由于@RequestParam是用来处理 Content-Type 为 application/x-www-form-urlencoded 编码的内容的，所以在postman中，要选择body的类型为 x-www-form-urlencoded，这样在headers中就自动变为了 Content-Type : application/x-www-form-urlencoded 编码格式（postman工具）

@RequestBody

注解@RequestBody接收的参数是来自requestBody中，即请求体。一般用于处理非 Content-Type: application/x-www-form-urlencoded编码格式的数据，比如：application/json、application/xml等类型的数据。就application/json类型的数据而言，使用注解@RequestBody可以将body里面所有的json数据传到后端，后端再进行解析。
由于@RequestBody可用来处理 Content-Type 为 application/json 编码的内容，所以在postman中，选择body的类型为row -> JSON(application/json)，这样在 Headers 中也会自动变为 Content-Type : application/json 编码格式。
注意：前端使用$.ajax的话，一定要指定 contentType: “application/json;charset=utf-8;” type =“post”，默认为 application/x-www-form-urlencoded。data里的对象要变成json字符串用JSON.stringify()方法

form表单ajax提交

var  array=$("#fm").serializeArray();
var data={};
for(var i = 0;i<array.length;i++){
    data[array[i],name]=array[i].value;
}
1
2
3
4
5

在后端的同一个接收方法里，@RequestBody 与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。

总结

注解@RequestParam接收的参数是来自requestHeader中，即请求头。通常用于GET请求，像POST、DELETE等其它类型的请求也可以使用。

注解@RequestBody接收的参数是来自requestBody中，即请求体。一般用于处理非 Content-Type: application/x-www-form-urlencoded编码格式的数据，比如：application/json、application/xml等类型的数据。通常用于接收POST、DELETE等类型的请求数据，GET类型也可以适用。

**重点补充：**在使用注解@RequestParam的时候【不加注解的时候效果与@RequestParam类似】，在body data中我们不能传json字符串类型的参数，否则对象中是接收不到传递参数相应的值。相应的在@RequestBody注解标记的形式上传递表格参数则会报错。

@ResponseBody

作用：@ResponseBody注解通常使用在控制层的方法上，用于将Controller的方法返回的对象，通过springmvc提供的HttpMessageConverter接口转换为指定格式的数据如：json，通过Response响应给客户端。假如是字符串则直接将字符串写到客户端；假如是一个对象，此时会将对象转化为json串然后写到客户端。这里需要注意的是，如果返回对象，按utf-8编码。如果返回String，页面可能出现乱码。因此在注解中我们可以手动修改编码格式，例如@RequestMapping(value=“xxx”,produces=“text/html;charset=utf-8”)，前面是请求的路径，后面是编码格式。简短截说就是指该类中所有的API接口返回的数据，甭管你对应的方法返回Map或是其他Object，它会以Json字符串的形式返回给客户端

@RestController

@Controller + @ResponseBody

@GetMapping @PostMpping @PutMapping @DeleteMapping @PatchMapping

什么是RESTful

RESTful(RESTful Web Services)一种架构风格,表述性状态转移,它不是一个软件,也不是一个标准,而是一种思想,不依赖于任何通信协议,但是开发时要成功映射到某协议时也需要遵循其标准,但不包含对通信协议的更改

特征:

1.通过url地址来标识资源,系统中的每个对象或资源都可以通过其url地址来获取

2.统一接口,显式地使用HTTP方法,来进行crud(create,update,insert,delete)映射

创建资源使用POST

更新资源使用PUT

检索资源使用GET

删除资源使用DELETE

3.资源多重反映.通过url地址访问的每个资源都可以根据客户端的规定进行返回,例:JSON,XML

@GetMapping =@RequestMapping(value = “xxxx”, method = RequestMethod.GET)

其他的以此类推

springMVC拦截器

Spring MVC中的拦截器（Interceptor）类似于Servlet中的过滤器（Filter），它主要用于拦截用户请求并作相应的处理。例如通过拦截器可以进行权限验证、记录请求信息的日志、判断用户是否登录等。
要使用Spring MVC中的拦截器，就需要对拦截器类进行定义和配置。通常拦截器类可以通过两种方式来定义。

Filter不管是什么都会拦截

Interceptor 只会拦截访问控制器的方法 并且是依赖aop实现

自定义拦截器实现了HandlerInterceptor接口，并实现了接口中的三个方法

• preHandle() 方法：该方法会在控制器方法前执行，其返回值表示是否中断后续操作。当其返回值为true时，表示继续向下执行；
  当其返回值为false时，会中断后续的所有操作（包括调用下一个拦截器和控制器类中的方法执行等）。
• postHandle()方法：该方法会在控制器方法调用之后，且解析视图之前执行。可以通过此方法对请求域中的模型和视图做出进一步的修改。
• afterCompletion()方法：该方法会在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作。

    
    
        
         
        
            
            
            
            
            
            
        
        
            
            
            
            
        
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Interceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o)
            throws Exception {
        System.out.println("CustomInterceptor....preHandle");
        //对浏览器的请求进行放行处理
        return true;
    }

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

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e)
            throws Exception {
        System.out.println("CustomInterceptor....afterCompletion");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

拦截session登录

public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
			Object handle) throws Exception {
		
		//创建session
		HttpSession session =request.getSession();
		
		//无需登录，允许访问的地址
		String[] allowUrls =new String[]{"/login"};
			
		//获取请求地址
		String url =request.getRequestURL().toString();
		
		//获得session中的用户
		UserToken user =(UserToken) session.getAttribute("userToken");
	
		
		for (String strUrl : allowUrls) {
			if(url.contains(strUrl)){
				return true;
			}
		}
		
		if(user ==null)
		{
			throw new UnLoginException("您尚未登录！");	
								
		}
		//重定向
		//response.sendRedirect(request.getContextPath()+"/toLogin");
    
			return true;
		
		
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

贴士

vmoption加-Dfile.encoding=UTF-8解决日志乱码问题