SpringMVC

qdyones

已于 2022-04-25 17:07:16 修改

阅读量760

点赞数

分类专栏：基础学习文章标签： java

于 2022-04-21 22:43:34 首次发布

本文链接：https://blog.youkuaiyun.com/qdyones/article/details/124234750

版权

基础学习专栏收录该内容

73 篇文章

订阅专栏

文章目录

1.回顾MVC架构
- 添加所需依赖
- 创建一个新项目
2. 使用注解开发SpringMVC
- 2.1 确定导入依赖
- 2.2 确定structure都有lib的全部依赖
- 2.3 配置DispatchServlet
- 2.4 创建一个xml文件
- 2.5 编写springmvc-servlet.xml配置文件
- 2.6编写HelloController
3.注解开发SpringMVC！！！
4.RequestMapping解释
5.Restful风格
6. 重定向和转发
7. 请求参数及数据回显
8.乱码问题解决
9.JSON（重点！！）
- 前端JSON与js的转换
10.jackson的使用
- 10.1 使用json需要先导入依赖
- 10.2 配置web.xml
- 10.3 配置springmvc-servlet.xml
- 10.4 编写实体类和控制层
- 10.5 创建jsp包，先第一次尝试不经过视图解析器
- 10.6 第二次尝试json的ObjectMapper().writeValueAsString
- 10.7 JSON乱码问题（MVC自带解决方案）
- json返回当前时间格式
- 使用JSON自定义时间返回对象（了解即可）
11.AOP编程（补充内容-切面编程）
- 第一步先写实体类
- 第二步配置bean
- 最后测试（自行体会，反正就是半路插进去做事情）
- 测试结果为：
12. FastJSON使用
13.SSM框架整合
14.Ajax初体验
15.Ajax异步加载数据
16.Ajax验证用户名体验
17.SpringMVC拦截器
18.登录判断验证

1.回顾MVC架构

MVC :模型(dao，service) 视图(jsp) 控制器(Servlet)

添加所需依赖

     <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

创建一个新项目

创建一个空maven，然后创建Framework Support
在这里插入图片描述

2. 使用注解开发SpringMVC

2.1 确定导入依赖

在这里插入图片描述

2.2 确定structure都有lib的全部依赖

在这里插入图片描述

2.3 配置DispatchServlet

这个是SpringMVC的核心; 请求分发器，前端控制器

<!--配置DispatcherServlet，springmvc的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        绑定MVC配置文件-->
        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

2.4 创建一个xml文件

在这里插入图片描述

2.5 编写springmvc-servlet.xml配置文件

一开始用的就是spring 的配置文件

<?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 class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <bean id="/hello" class="com.qiu.controller.HelloController"/>

</beans>

2.6编写HelloController

继承的接口是web底下的在这里插入图片描述

需要注意的是主要就改动了业务代码和视图跳转的代码

package com.qiu.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();
        
        //业务代码
        String result="Hello Springmvc";
        mv.addObject("msg",result);

        //视图跳转
        mv.setViewName("test");

        return mv;
    }
}

3.注解开发SpringMVC！！！

在这里插入图片描述

package com.qiu.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
//@RequestMapping("/hello")
public class HelloController {

    //两级的RequestMapping需要拼接地址栏/hello/h1
    @RequestMapping("h1")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,SpringMVC");
        return "hello";//会被视图解析器处理
    }
}

<?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.qiu.controller"/>
    <!-- 让Spring MVC不处理静态资源: HTML、JS、CSS、图片、视频 .....-->
    <mvc:default-servlet-handler />
    <mvc:annotation-driven />
<!--    <mvc:annotation-driven />实现Mapping和Adapter实例注入 -->


    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

总结：拼接页面的名字、文件路径、以及在页面中加入msg，动态设置页面
降低耦合

4.RequestMapping解释

就是多个包名的情况下，设置好多层级的RequestMapping，最好直接在方法中直接设置好固定的
访问路径，不然测试的时候比较麻烦

5.Restful风格

还是一样使用注解，然后传入参数

原来使用的是/test？a=1&b=2
通过前端传入参数

使用Restful之后
使用@PathVariable注解
在这里插入图片描述
还可以在RequestMapping之中添加method 的各种方法

使用这种风格的好处在于安全，也为了更加简洁

6. 重定向和转发

如果没有配置视图解析器的情况下，可以使用以下方法来转发、重定向
/**/
如果配置了视图解析器，就只有重定向的时候在前面加上redirect：即可

7. 请求参数及数据回显

从前端可以实现传参
在这里插入图片描述
传入为User，必须保证属性名一一对应，否则显示为null

8.乱码问题解决

乱码问题解决的方法有几种
1.req.setEncoding……（utf-8）
2.过滤器
3 post改成get
4.spring的web配置过滤器，直接加就可以
5.检查Tomcat的server.xml文件有没有设置UTF-8格式
6.SpringMVC默认乱码解决

<filter>
        <filter-name>encodingFilter</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

通用彻底解决乱码

package com.qiu.filter;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class GenericEncodingFilter implements Filter {

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        response.setContentType("text/html;charset=utf-8");
        chain.doFilter(myrequest, response);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

}

// 自定义request对象
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    private boolean hasEncode;

    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();
    }

    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }

    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }

}

9.JSON（重点！！）

JSON：JavaScript Object Notation, JS对象标记

理解为，用"/"风格在前端输入，却在后端有相应的模板输入对应参数得到想要的结果

实例：1/2 后端为1+2，页面显示为3

前端JSON与js的转换

记住以下两个方法：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试</title>
    <script type="text/javascript">
        var user={
            name:"随便",
            age:15,
            sex:男
        };
        //将js转换成JSON
        var js=JSON.stringify(user);
        console.log(js);

        //将JSON转换成js
        var a=JSON.parse(js);
        console.log(a);
        
    </script>
</head>
<body>

</body>
</html>

10.jackson的使用

10.1 使用json需要先导入依赖

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

10.2 配置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">
    <!--    配置DispatchServlet:这个是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:a.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>
<!--Spring乱码过滤器-->
    <filter>
        <filter-name>encodingFilter</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

10.3 配置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">
<!--扫描哪里的包-->
    <context:component-scan base-package="com.qiu.pojo"/>
    <!-- 让Spring MVC不处理静态资源: HTML、JS、CSS、图片、视频 .....-->
    <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>

10.4 编写实体类和控制层

在这里插入图片描述

package com.qiu.controller;

import com.qiu.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @RequestMapping("/j1")
    @ResponseBody//这个注解会使得不经过视图解析器
    public String json1(){
        User user = new User("suibian",15,"nan");
        return user.toString();
    }
}

package com.qiu.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

10.5 创建jsp包，先第一次尝试不经过视图解析器

@ResponseBody//这个注解会使得不经过视图解析器
所以当我们输入/j1，就会得到不经过视图解析器的结果
在这里插入图片描述

10.6 第二次尝试json的ObjectMapper().writeValueAsString

主要是ObjectMapper().writeValueAsString，这几个操作，可以对应输入时间，以及多组字符串等等的格式。

第二次修改控制类尝试

@Controller
public class UserController {
    @RequestMapping("/j1")
    @ResponseBody//这个注解会使得不经过视图解析器
    public String json1() throws JsonProcessingException {
        User user = new User("suibian",15,"nan");

        return new ObjectMapper().writeValueAsString(user);
    }
}

这个时候还是会出现乱码（中文的时候），一下解决方案
（注意了解json的格式）
在这里插入图片描述

10.7 JSON乱码问题（MVC自带解决方案）

在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>

即使json使用中有中文测试结果也可以成功
在这里插入图片描述

json返回当前时间格式


package com.qiu.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.SimpleDateFormat;
import java.util.Date;

@RestController
public class UserController {
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        Date date = new Date();
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return new ObjectMapper().writeValueAsString(s.format(date));
    }

}

关闭时间戳也可以使用json的mapper关闭（了解即可）
在这里插入图片描述

使用JSON自定义时间返回对象（了解即可）

在这里插入图片描述

11.AOP编程（补充内容-切面编程）

简单解释：很多个东西在执行，比作很多件事情，但是你要在中间插入别的事情，
让许多件事情同步在中间做这件事情
画图！↓（不知道理解对不对，可以百度再参考~）

在这里插入图片描述

代码先实现四个实体，分别为
在这里插入图片描述
代码如下

第一步先写实体类

package com.qiu.pojo;

public interface HelloWorld {
    void printHelloWorld();
    void doPrint();
}

package com.qiu.pojo;

public class HelloWorldImpl1 implements HelloWorld{
    @Override
    public void printHelloWorld() {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }

    @Override
    public void doPrint() {
        System.out.println("Enter HelloWorldImpl1.doPrint()");
    }
}

package com.qiu.pojo;

public class HelloWorldImpl2 implements HelloWorld{
    @Override
    public void printHelloWorld() {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    }

    @Override
    public void doPrint() {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
    }
}

package com.qiu.pojo;

public class TimeHandler {
    public void printTime(){
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

第二步配置bean

<?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:aop="http://www.springframework.org/schema/aop"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

<!--    全部设置好bean，备用，以下太多注释可以先看再删除掉比较舒服，能看的清楚-->
    <bean id="helloWorldImpl1" class="com.qiu.pojo.HelloWorldImpl1" />
    <bean id="helloWorldImpl2" class="com.qiu.pojo.HelloWorldImpl2" />
    <bean id="timeHandler" class="com.qiu.pojo.TimeHandler" />

    <aop:config>
<!--        要插入的东西-->
        <aop:aspect id="time" ref="timeHandler">
<!--            执行哪个实体-->
            <aop:pointcut id="addAllMethod" expression="execution(* com.qiu.pojo.HelloWorld.*(..))"/>
<!--            之前和之后插入的方法-->
            <aop:before method="printTime" pointcut-ref="addAllMethod" />
            <aop:after method="printTime" pointcut-ref="addAllMethod" />
        </aop:aspect>
    </aop:config>
</beans>

最后测试（自行体会，反正就是半路插进去做事情）

import com.qiu.pojo.HelloWorld;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

        HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
        HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");

        hw1.printHelloWorld();

        hw1.doPrint();


        hw2.printHelloWorld();

        hw2.doPrint();
    }
}

测试结果为：

CurrentTime = 1650551677460
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1650551677460
CurrentTime = 1650551677461
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1650551677461
CurrentTime = 1650551677462
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1650551677462
CurrentTime = 1650551677462
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1650551677462

12. FastJSON使用

13.SSM框架整合

可以查看小小酒馆的掌柜，代码太多了，刚刚csdn给我笔记弄丢了，
以下是链接

https://blog.youkuaiyun.com/weixin_45535873/article/details/118880112

简单来说就是ssm框架整合起来做了对数据库的增删改查的网站
在这里插入图片描述

14.Ajax初体验

异步无刷新请求
通过与后台少量的数据交换实现异步局部更新
动态web用户界面

1.编写好基础的代码以后下载jquery，开发版然后在web包下创建static、jsp的包
2.applicationContext.xml必须配置好静态资源滤过率

15.Ajax异步加载数据

注意点：
javascript6才可以使用let块区域循环

简单解释概念：不需要整个刷新页面，只需要在前端向后端请求部分需要的数据即可

步骤：先导入jquery文件，配置好web（乱码、servlet、）
applicationContext的配置（扫描包、静态资源过滤、驱动、视图解析器）
控制层：关联到前端
jsp前端：设置按钮、按钮关联post请求，将后端的数据请求到前端来展示html
还有一个实体类（名字、年龄、性别）（这个就不贴代码了）

AjaxController

package com.qiu.controller;

import com.qiu.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@RestController
public class AjaxController {
    @RequestMapping("/h1")
    public String test(){
        return "hello";
    }
    @RequestMapping("/a1")
    public void a1(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1==>"+name);
        if ("suibian".equals(name)){
            response.getWriter().println("true");
        }else {
            response.getWriter().println("false ");
        }
    }

    @RequestMapping("/a2")
    public List<User> a2(){
        List<User> userList = new ArrayList<>();
        //添加数据
        userList.add(new User("suibian",1,"男"));
        userList.add(new User("suibian2",2,"男"));
        userList.add(new User("suibian3",3,"男"));

        return userList;
    }
}

test2.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>
    <script>
        $(function (){
            $("#btn").click(function (){
                //$.post(url,param[可以省略],success)
                $.post("${pageContext.request.contextPath}/a2",function(data){
                    // console.log(data);
                    var html="";
                    for (let i = 0; i < data.length ; i++) {
                        html+="<tr>"+
                            "<td>"+data[i].name+"<td/>"+
                            "<td>"+data[i].age+"<td/>"+
                            "<td>"+data[i].sex+"<td/>"+
                            "<tr>"
                    }
                    $("#content").html(html);
                });
            });
        });

    </script>

</head>


<body>
<input type="button" value="加载数据" id="btn">
<table>
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
        <%--    数据、后台--%>
    </tbody>
</table>


</body>
</html>

16.Ajax验证用户名体验

xml配置好json乱码配置

AjaxController

package com.qiu.controller;

import com.qiu.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@RestController
public class AjaxController {
    @RequestMapping("/h1")
    public String test(){
        return "hello";
    }
    @RequestMapping("/a1")
    public void a1(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1==>"+name);
        if ("suibian".equals(name)){
            response.getWriter().println("true");
        }else {
            response.getWriter().println("false ");
        }
    }

    @RequestMapping("/a2")
    public List<User> a2(){
        List<User> userList = new ArrayList<>();
        //添加数据
        userList.add(new User("suibian",1,"男"));
        userList.add(new User("suibian2",2,"男"));
        userList.add(new User("suibian3",3,"男"));

        return userList;
    }

    @RequestMapping("/a3")
    public String a3(String name,String pwd){
        String msg="";
        //admin这里写死了，正常要去数据库去查询

        if (name!=null){
            if("admin".equals(name)){
                msg="ok";
            }else {
                msg="user~no~ok";
            }
        }
      if (pwd!=null){
          if("123456".equals(pwd)){
              msg="ok";
          }else {
              msg="密码错误";
          }
      }
        return msg;
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录验证</title>
    <script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>
    <script>
        function a1(){
            //失去焦点要请求查询用户有没有这个人
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{"name":$("#name").val()},
                success:function (data){
                    //如果验证为ok了那就显示为绿色
                    if (data.toString()=='ok'){//这里的ok是布尔值为true，不是单纯的ok字符
                        $("#userInfo").css("color","green");
                    }else{
                        $("#userInfo").css("color","red");
                    }
                    //成功了之后显示文字
                    $("#userInfo").html(data);
                  }
            })
        }
        function a2(){
            //失去焦点要请求查询密码是否正确
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{"pwd":$("#password").val()},
                success:function (data){
                    //如果验证为ok了那就显示为绿色
                    if (data.toString()=='ok'){//这里的ok是布尔值为true，不是单纯的ok字符
                        $("#passwordInfo").css("color","green");
                    }else{
                        $("#passwordInfo").css("color","red");
                    }
                    //成功了之后显示文字
                    $("#passwordInfo").html(data);

                }
            })
        }


    </script>

</head>
<body>
<%--onblur失去焦点事件、离开输入就会产生a()事件--%>
<p>
    用户名：<input type="text" id="name" onblur="a1()">
    <span id="userInfo"></span>
</p>
<p>
    密码：<input type="text" id="password" onblur="a2()">
    <span id="passwordInfo"></span>
</p>

</body>
</html>

17.SpringMVC拦截器

拦截器是原来AOP 的一个思想

拦截器只会拦截对于控制器的请求，不会拦截js\jsp\html\image的请求

自定义拦截器：想要自定义拦截器，必须实现HandlerInterceptor接口

步骤：写一个拦截器的类，继承HandlerInterceptor接口，在applicationContext配置拦截器
让拦截器在执行语句前后经过拦截器的类达到效果

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">
    <!--    配置DispatchServlet:这个是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:applicationContext.xml.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>
    <!--Spring乱码过滤器-->
    <filter>
        <filter-name>encodingFilter</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

applicationContext.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">
<!--扫描哪里的包-->
    <context:component-scan base-package="com.qiu.controller"/>
    <!-- 让Spring MVC不处理静态资源: HTML、JS、CSS、图片、视频 .....-->
    <mvc:default-servlet-handler/>
    <!--
     支持mvc注解驱动
         在 spring 中一般采用 @RequestMapping 注解来完成映射关系
         要想使 @RequestMapping 注解生效
         必须向上下文中注册 DefaultAnnotationHandlerMapping
         和一个 AnnotationMethodHandlerAdapter 实例
         这两个实例分别在类级别和方法级别处理。
         而 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>

<!--    JSON乱码问题-->
    <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>
    
<!--    拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.qiu.config.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

拦截器的类（true就是放行，false就是拦截）

package com.qiu.config;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    //return true就执行下一个拦截器，就是放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("===拦截器之前===");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}