springWeb

springweb就是spring框架中的一个模块，对web层进行了封装，使用起来更加方便。如何方便？参数接收框架进行封装
SpringWeb拥有控制器，接收外部请求，解析参数传给服务层。

SpringWeb运行流程

1. 用户发起请求 ip:端口/项目名/类地址/方法地址/，表示所有的请求都可以到达DispatcherServlet
2. DispatcherServlet，请求分发，核心的，在springweb底层就是一个servlet，接收用户所有请求，并分发给对应的映射处理器、适配器
3. HandlerMapping 映射处理器，用来解析请求中的地址，有没有对应的处理器类；如果本次请求有对应的拦截器，会执行相应的拦截器
4. HandlerAdapter 适配器，封装请求中的参数
5. Handler 到达自己创建的处理器，接收参数、处理、响应

搭建SpringWeb

1.导入jar包

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.2.2.RELEASEversion>
dependency>
1
2
3
4
5
6

2.在 web.xml 文件中配置 DispatcherServlet
配置 spring 核心请求分发器

<servlet>
    <servlet-name>applicationservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    <init-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:spring.xmlparam-value>
    init-param>
    
    <load-on-startup>0load-on-startup>
servlet>

<servlet-mapping>
    <servlet-name>applicationservlet-name>
    <url-pattern>/url-pattern>   
servlet-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.开启 springmvc 注解

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    
    <mvc:annotation-driven>mvc:annotation-driven>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13

4.spring.xml中导入springmvc配置文件

<import resource="classpath:spring-mvc.xml">import>
1
2

5.创建自己的处理器，为类和方法定义地址

package com.ffyc.ssm.web;

@RestController//类似于@service这些注解标签，表示此类是控制层类，并创建对象
@RequestMapping(path = "/loginCtl")//用来为类和方法定义一个映射地址
public class LoginController {

    @Autowired
    LoginService loginService;

    @RequestMapping(path = "/test")
    public String test(Integer num){
        System.out.println(num);
        System.out.println("hello springweb");
        loginService.login(new Admin());
        return "springweb";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.将ssm项目发布到Tomact中访问
Edit Configurations中


在服务器启动成功后，输入以下地址：

接收请求

springweb层的控制器类中如何使用？web层 :接收 处理 响应

1、@RestController 修饰控制器类

2、@RequestMapping(path =“/loginCtl”)

可以在类和方法上使用。在类上面使用，整个项目中必须是唯一的，不能重复；在方法上使用时，同一个类中地址也必须是唯一的，可以使用path/value来定义地址。
类中必须要定义请求方式：get/post。@RequestMapping(value = “/test”,method = RequestMethod.POST)；@RequestMapping(value =“/test")。没有指定请求方式，get/post请求都可以访问。
@GetMapping(path =“/test”)，get请求
@PostMapping(path = “/test”)，post请求

3、如何接收请求中的数据

1.使用request对象接收，req.getParameter()

<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>javax.servlet-apiartifactId>
    <version>4.0.1version>
    <scope>providedscope>
dependency>
1
2
3
4
5
6

@RestController//类似于@service这些注解标签，表示此类是控制层类，并创建对象
@RequestMapping(path = "/loginCtl")//用来为类和方法定义一个映射地址
public class LoginController {

    @Autowired
    LoginService loginService;

    @RequestMapping(path = "/test")
    public String test(HttpServletRequest request, HttpServletResponse response){
        System.out.println(request.getParameter("num"));
        return "springweb";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.直接在参数列表中，定义形参接收，还可以帮助我们进行数据类型转换。
请求中的键名称与形参名一致，如果接收不一致需要通过注解标签@RequestParam进行绑定。例如java中参数是userName，请求的参数是user-name
请求头中的数据用：@RequestHeader

@RequestMapping(path = "/test")
public String test(Integer num, @RequestParam("user-name") String userName,
                   @RequestHeader("User-Agent")String userAgent){
    System.out.println(num);
    System.out.println(userName);
    System.out.println(userAgent);
    return "springweb";
}
1
2
3
4
5
6
7
8

3.使用对象接收。
把请求中的数据直接封装到对象里面，前提是请求中的数据和类中的属性名字一致
（保存，提交表单数据，数量比较多的时候用）
400，请求数据类型转换有问题

@RestController//类似于@service这些注解标签，表示此类是控制层类，并创建对象
@RequestMapping(path = "/loginCtl")//用来为类和方法定义一个映射地址
public class LoginController {

    @Autowired
    LoginService loginService;

    @GetMapping(path = "/login")
    public String login(Admin admin,Integer mark){
        System.out.println(admin);
        System.out.println(mark);
        return "springweb";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

前端的日期类型是字符串，后端是Date类型，需要加@DateTimeFormat(pattern = “yyyy-MM-dd”) 进行格式化

@Data
public class Admin {
    private Integer id;
    private String account;
    private String password;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
}
1
2
3
4
5
6
7
8

中文乱码处理

post请求方式中，中文会乱码，以前自己创建一个过滤器
SpringMVC 中已经为我们提供了这个编码过滤器，只需要在 web.xml 中配置好即可：

<filter>
    <filter-name>characterEncodingFilterfilter-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>characterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13

Ajax返回JSON

package com.ffyc.ssm.common;

public class CommonResult {
    private int code;//自定义的状态码
    private Object data;//数据 对象 集合
    private String message;//消息

    public CommonResult(int code, Object data, String message) {
        this.code = code;
        this.data = data;
        this.message = message;
    }

    public CommonResult(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
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

@RestController//类似于@service这些注解标签，表示此类是控制层类，并创建对象
@RequestMapping(path = "/loginCtl")//用来为类和方法定义一个映射地址
public class LoginController {

    @Autowired
    LoginService loginService;

    @GetMapping(path = "/login")
    public CommonResult login(Admin admin, Integer mark){
        CommonResult commonResult=new CommonResult(200,"保存成功");
        return commonResult;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

@RestController//类似于@service这些注解标签，表示此类是控制层类，并创建对象。集成了两个注解标签

• @Controller
• @ResponseBody：方法的返回值会自动的转为JSON字符串，并将返回的内容写入到响应体中，为Ajax请求使用的
  控制器中返回结果，由于使用@RestController，里面包含@ResponseBody的注解标签，所以方法返回结果默认是json格式，并将json字符串写入到响应体中。返回一个对象时，必须加入一个转json的第三方组件

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.13.3version>
dependency>
1
2
3
4
5
6

跨域配置

加入依赖

<dependency>
    <groupId>com.thetransactioncompanygroupId>
    <artifactId>cors-filterartifactId>
    <version>2.5version>
dependency>
1
2
3
4
5
6

在 web.xml 中配置跨域过滤器

<filter>
    <filter-name>CORSfilter-name>
    <filter-class>com.thetransactioncompany.cors.CORSFilterfilter-class>
filter>
<filter-mapping>
    <filter-name>CORSfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>
1
2
3
4
5
6
7
8
9

拦截器

拦截器—>过滤器，功能类似，但是有区别
过滤器是java Servlet规范中定义的，是当请求进入到servlet之前，可以对请求进行拦截，可以加入一些逻辑处理。
拦截器与过滤器是有区别的，拦截器是spring框架中自己定义的功能，和过滤器的位置不同；拦截器只拦截进入到自己控制器中的请求，其余的不拦截。

搭建拦截器

1.创建一个类，实现HandlerInterceptor接口，重写接口中preHandle（）方法；剩下两个方法是在MVC架构中使用（postHandle:当控制器执行完成后调用；afterCompletion:当响应结束后执行）。
预处理：当请求经过映射处理器检测对应的控制器是存在，判断该请求可以进入到该拦截器，执行调用。preHandle方法，如果返回true–>请求继续向下执行；返回false–>请求就不再向下执行。
其余两种是在MVC架构中使用的，当控制器执行完成后调用。

//自定义token验证的拦截器
public class TokenInterceptor implements HandlerInterceptor {
    //预处理
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return false;
    }
}
1
2
3
4
5
6
7
8
9

2.配置拦截器。在spring-mvc.xml中

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/> 
        <mvc:exclude-mapping path="/loginCtl/login"/>  
        <bean class="com.ffyc.ssm.common.TokenInterceptor">bean>  
    mvc:interceptor>
mvc:interceptors>
1
2
3
4
5
6
7
8

3.测试。如果preHandle方法返回的是false的话，test方法不执行；如果返回true，先执行preHandle（）后执行test（）

@GetMapping(path = "/test")
public CommonResult test(){
    System.out.println("test method");
    CommonResult commonResult=new CommonResult(200,"保存成功");
    return commonResult;
}
1
2
3
4
5
6