Day41——SpringMVC学习笔记2（拦截器、AJax、JSON）

配置好一个SpringMVC项目

在上一次整合SSM项目过程中，对于配置流程没有理的那么清晰，这次对这个流程再次梳理一下

Spring Web项目准备工作：

• 依赖配置齐全
• 服务器保证正常运行
• 整个项目的结果保证运行无误
• 理解配置文件的作用和搭配
  • web.xml
  • mybatis-config.xml
  • applicationContext.xml
  • spring-servlet.xml
  • …

具体实现：

首先建立空的Maven项目，加入web支持

1、将项目层级结构建立

com 
    feng
    	controller
 		dao
    		pojo	
    		service

2、导入依赖

<dependencies>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        
    <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
    <!--mybatis-spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>

    <!--Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    
    </dependencies>

3、web.xml中(DispatcherServlet、乱码过滤)

<?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-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置乱码filter-->
    <filter>
        <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

4、各种配置文件的建立

• 建立mybatis-config.xml（真正运行mybatis的时候，是可以完全不需要配置这个文件的），spring-dao.xml作用一致，所以可不要；
• spring-dao.xml（专注操作数据库相关的，还要建立一个db.properties）
• spring-beans.xml（专注管理所有的Bean）
• spring-webmvc.xml（专注操作Controller层）
• applicationContext.xml（将扫描所有组件，集成mybatis，springmvc，注册很多的bean）

spring-dao.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--专注操作数据库相关的-->
    <!-- 1.关联数据库文件 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--配置数据源(此处导入spring-jdbc的jar包)-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--SqlSessionFactory(记不住的去mybatis-spring官网找)相当于mybatis配置-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置MyBatis全局配置文件:mybatis-config.xml，可以在这里配置mybatis所有的配置 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/feng/dao/*.xml"/>
        <property name="typeAliasesPackage" value=""/>
    </bean>

    <!--创建SqlSession（用来执行sql的对象）-->
    <!-- 配置扫描Dao接口包，动态实现Dao接口注入到spring容器中 -->
    <!--解释 ： https://www.cnblogs.com/jpfss/p/7799806.html-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.feng.dao"/>
    </bean>
    
</beans>

db.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

spring-beans.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-->
    <!--<bean id="" class=""/>-->
    
</beans>

spring-webmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--专注操作MVC（Controller层的）-->
    <mvc:annotation-driven/>
    <mvc:default-servlet-handler/>

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

</beans>

applicationContext.xml:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">


    <!--扫描所有组件（写在总的配置文件中）-->
    <context:component-scan base-package="com.feng.dao"/>
    <context:component-scan base-package="com.feng.service"/>
    <context:component-scan base-package="com.feng.controller"/>


<!--集成mybatis-->
    <import resource="classpath:spring-dao.xml"/>
<!--集成springmvc-->
    <import resource="classpath:spring-webmvc.xml"/>

<!--注册很多bean（弄一个spring-beans.xml）-->
    <!--<import resource="classpath: spring-beans.xml"/>-->
    
</beans>

5、以上配置完，配置tomcat

6、在Project Structure中，看到Project Settings中Artifacts，在Output Layout中,将在WEB-INF目录下新建lib目录，将所有jar包导入lib中！

7、进行测试，在Controller层编写Hello Controller类

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("msg","hello");
        return "hello";
    }
}

8、在web/WEB-INF/下建立jsp目录，创建hello.jsp

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

9、运行tomcat服务器，在路径输入/hello，会跳转至hello.jsp，且屏幕打印hello，则成功

SpringMVC：JSON

JSON语法可以总结如下：

• 数据以 名称/值对 表示。
• 花括号括住对象，名称/值对由,分隔。
• 最后一个对象后不需要逗号
• 方括号保存数组，值用,分隔。

JSON支持以下两个数据结构：

数据结构	描述
名称/值对的集合	key:value,key:value,
有序的值列表	[1,2,3,4]

举个栗子:

指定一个Json对象

{
	"ID": 1001,
	"name": "张三",
	"age": 2
}

JSON数据指定书籍:(这是一个Json对象数组)

{
    "book": [
    {
       "id":"01",
       "language": "Java",
       "edition": "third",
       "author": "XXXX"
    },
    {
       "id":"02",
       "language": "JSON",
       "edition": "second"
       "author": "XXXX"
    }]
}

json对象，json对象数组。两种基本格式组合变形出其他的形式，但其本质还是json对象或者json对象数组中的一种。json对象或对象数组可以转化为json字符串，使用于不同的场合。

JSON 和 JavaScript 对象互转：

测试代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Json测试</title>
</head>
<body>
<script type="text/javascript">
    //编写一个js的对象
    let user = {
        name:"英子",
        age:3,
        sex:"女"
    };
    //将js对象转换成json字符串
    let str = JSON.stringify(user);
    console.log(str);

    //将json字符串转换为js对象
    let user2 = JSON.parse(str);
    console.log(user2.age,user2.name,user2.sex);

</script>

</body>
</html>

浏览器测试结果：

Controller返回JSON数据

Jackson

Jackson应该是目前比较好的json解析工具，使用它需要导入它的jar包，中间到入所有的jar包就一定在启动tomcat之前，在重复上面配置流程的第6步，不然会报错。

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

web.xml，applicationContext.xml等配置与上面搭建作用一样

测试一：

编写一个User的实体类，再编写测试Controller

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;
    private int age;
    private String sex;

}

@Controller
//@RestController
public class UserController {

    @RequestMapping("/json1")
    @ResponseBody//不用这个，可以直接在类上使用@RestController
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("英子", 4, "女");
        //将我们的对象解析成为json格式
        String s = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return s;
    }
}

配置完，启动tomcat，测试，在路径处输入localhost:8080/json1

发现中文变成乱码，进行解决：

方法一：@RequestMaping的produces属性来实现

@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

方法二：在spring-webmvc.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>

再次进行测试：

测试二

测试集合输出

@RequestMapping("/json2")
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        User user1 = new User("英子1", 4, "女");
        User user2 = new User("英子2", 4, "女");
        User user3 = new User("英子3", 4, "女");
        User user4 = new User("英子4", 4, "女");

        List<User> list = Arrays.asList(user1, user2, user3, user4);
        String s = mapper.writeValueAsString(list);
        return s;
    }

运行tomcat进行测试：

FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。

使用前需要导入依赖

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

fastjson 三个主要的类：

• JSONObject 代表 json 对象
• JSONArray 代表 json 对象数组
• JSON 代表 JSONObject和JSONArray的转化

测试代码：

建立一个demo类

public class Demo {
    public static void main(String[] args) {
        User user1 = new User("英子1", 4, "女");
        User user2 = new User("英子2", 4, "女");
        User user3 = new User("英子3", 4, "女");
        User user4 = new User("英子4", 4, "女");
        List<User> list = Arrays.asList(user1, user2, user3, user4);

        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 user = JSON.parseObject(str2, User.class);
        List<User> list1 = JSON.parseObject(str1, List.class);
        System.out.println("JSON.parseObject(str1,List.class)==>"+list1);
        System.out.println("JSON.parseObject(str2,User.class)==>"+user);

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

测试结果：

*******Java对象 转 JSON字符串*******
JSON.toJSONString(list)==>[{"age":4,"name":"英子1","sex":"女"},{"age":4,"name":"英子2","sex":"女"},{"age":4,"name":"英子3","sex":"女"},{"age":4,"name":"英子4","sex":"女"}]
JSON.toJSONString(user1)==>{"age":4,"name":"英子1","sex":"女"}

****** JSON字符串 转 Java对象*******
JSON.parseObject(str1,List.class)==>[{"sex":"女","name":"英子1","age":4}, {"sex":"女","name":"英子2","age":4}, {"sex":"女","name":"英子3","age":4}, {"sex":"女","name":"英子4","age":4}]
JSON.parseObject(str2,User.class)==>User(name=英子1, age=4, sex=女)

****** Java对象 转 JSON对象 ******
(JSONObject) JSON.toJSON(user2)==>英子2

****** JSON对象 转 Java对象 ******
JSON.toJavaObject(jsonObject1, User.class)==>User(name=英子2, age=4, sex=女)

---

SpringMVC：Ajax

简单介绍

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

AJAX 不是新的编程语言，而是一种使用现有标准的新方法。

AJAX 是一种用于创建快速动态网页的技术。

通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

传统的网页（不使用 AJAX）如果需要更新内容，必需重载整个网页面。

下面图中，展示访问页面中所涉及的Ajax

牛刀小试

测试一：

建立一个html页面，感受下局部页面刷新

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title>Testajax</title>
</head>
<body>

<script type="text/javascript">
window.onload = function(){
 var myDate = new Date();
 document.getElementById('currentTime').innerText = myDate.getTime();
};

function LoadPage(){
 var targetUrl =  document.getElementById('url').value;
 console.log(targetUrl);
 document.getElementById("iframePosition").src = targetUrl;
}

</script>

<div>
<p>请输入要加载的地址：<span id="currentTime"></span></p>
<p>
 <input id="url" type="text" value="https://www.baidu.com/"/>
 <input type="button" value="提交" onclick="LoadPage()">
</p>
</div>

<div>
<h3>加载页面位置：</h3>
<iframe id="iframePosition" style="width: 100%;height: 500px;"></iframe>
</div>

</body>
</html>

测试结果：

利用AJAX可以做：

• 注册时，输入用户名或者手机号注册时，自动检测用户是否已经存在。
• 登陆时，提示用户名密码错误
• 。。。等等

SpringMVC实现数据回显

利用上面建立的User类，在Controller层中UserController类中编写

    @RequestMapping("/a2")
    public List<User> ajax2(){
        List<User> list = new ArrayList<User>();
        list.add(new User("英子1", 4, "女"));
        list.add(new User("英子2", 4, "女"));
        list.add(new User("英子3", 4, "女"));
        return list; //由于@RestController注解，将list转成json格式返回
    }

再写前端展示页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<input type="button" id="btn" value="获取数据"/>
<table width="80%" align="center">
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
    </tbody>
</table>

<script type="text/javascript" src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
<script>

    $(function () {
        $("#btn").click(function () {
            $.post("${pageContext.request.contextPath}/a2",function (data) {
                console.log(data)
                var html="";
                for (var 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>
</body>
</html>

运行tomcat，在路径输入 http://localhost:8080/show.jsp

测试Demo

运用在平时大家注册网站时，输入框后面的实时提示我们有没有重复使用用户名，下面就一起学习下

接着在Controller层下的UserController中编写

@RequestMapping("/a3")
public String ajax3(String name,String pwd){
    String msg="";
    //模拟数据库中存在数据
    if(name!=null){
        if ("admin".equals(name)){
            msg="ok";
        }else {
            msg="用户名输入错误";
        }
    }
    if(pwd!=null){
        if ("123".equals(pwd)){
            msg="ok";
        }else {
            msg="密码输入错误";
        }
    }
    return msg;
}

再编写前端页面login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ajax3</title>
    <script type="text/javascript" src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
    <script>

        function a1(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{'name':$("#name").val()},
                success:function (data) {
                    if (data.toString()=='OK'){
                        $("#userInfo").css("color","green");
                    }else {
                        $("#userInfo").css("color","red");
                    }
                    $("#userInfo").html(data);
                }
            });
        }
        function a2(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{'pwd':$("#pwd").val()},
                success:function (data) {
                    if (data.toString()=='OK'){
                        $("#pwdInfo").css("color","green");
                    }else {
                        $("#pwdInfo").css("color","red");
                    }
                    $("#pwdInfo").html(data);
                }
            });
        }

    </script>
</head>
<body>
<p>
    用户名:<input type="text" id="name" οnblur="a1()"/>
    <span id="userInfo"></span>
</p>
<p>
    密码:<input type="password" id="pwd" οnblur="a2()"/>
    <span id="pwdInfo"></span>
</p>
</body>
</html>

运行Tomcat，转至login1.jsp页面

SpringMVC：拦截器

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

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

过滤器

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

拦截器

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

初识拦截器，实现

springmvc 中的拦截器是由实现 HandlerInterceptor 或者继承 HandlerInterceptorAdapter 来实现的。

自定义实现一个拦截器的步骤：

实验环境：在上面的环境中加一个jar包

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

在interceptor目录下编写自定义拦截类：

public class MyInterceptor implements HandlerInterceptor {
    //在请求处理的方法之前执行
    //如果返回true执行下一个拦截器
    //如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------");
        return true;
    }

    //在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------");
    }

    //在dispatcherServlet处理后执行,做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------");
    }
}

在spring-webmvc.xml中配置拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--/** 包括路径及其子路径-->
        <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
        <!--/admin/** 拦截的是/admin/下的所有-->
        <mvc:mapping path="/**"/>
        <!--bean配置的就是拦截器-->
        <bean class="com.feng.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

在Controller层下编写一个controller

@Controller
public class InterceptorController {
    @RequestMapping("/interceptor")
    @ResponseBody
    public String testFunction() {
        System.out.println("控制器中的方法执行了");
        return "hello";
    }
}

在首页index.jsp中

<a href="${pageContext.request.contextPath}/interceptor">拦截器测试</a>

启动Tomcat进行测试：

验证用户是否登录实验

1、一个登录页面，写对应Controller访问页面

2、登陆页面有提交表单的动作，在Controller中进行处理，判断用户名密码是否正确，若正确向session中写入用户信息，返回登陆成功

3、存在一个登陆成功后的页面，拦截用户请求，当用户登录可访问，若用户没登陆，跳转至登陆页面

写登录页面login2.jsp：

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

<h1>登录页面</h1>
<hr>

<body>
<form action="${pageContext.request.contextPath}/user/login">
    用户名：<input type="text" name="username"> <br>
    密码： <input type="password" name="pwd"> <br>
    <input type="submit" value="提交">
</form>
</body>
</html>

Controller处理请求

@Controller
@RequestMapping("/user")
public class LoginController {

    //跳转到登陆页面
    @RequestMapping("/jumplogin")
    public String jumpLogin() throws Exception {
        return "login2";
    }

    //跳转到成功页面
    @RequestMapping("/jumpSuccess")
    public String jumpSuccess() throws Exception {
        return "success";
    }

    //登陆提交
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String pwd) throws Exception {
        // 向session记录用户身份信息
        System.out.println("接收前端==="+username);
        session.setAttribute("user", username);
        return "success";
    }

    //退出登陆
    @RequestMapping("logout")
    public String logout(HttpSession session) throws Exception {
        // session 过期
        session.invalidate();
        return "login2";
    }
}

登陆成功的页面 success.jsp

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

<h1>登录成功页面</h1>
<hr>

用户名：${user}<br>
<a href="${pageContext.request.contextPath}/user/logout">注销</a>
</body>
</html>

在index.jsp中添加body

<h1>首页</h1>
<hr>
<%--登录--%>
<a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
<a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>

第一次测试，启动Tomcat访问：

点击登录：

提交之后：

进行注销，返回登陆页面，此时，转到首页，点击（应该只有登陆成功后才能访问的）成功页面，发现也能进行访问，所以进行拦截器的编写

public class LoginInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果是登陆页面则放行
        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/login2.jsp").forward(request, response);
        return false;
    }
    

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

在spring-webmvc.xml中注册拦截器

    <mvc:interceptors>
        <mvc:interceptor>
            <!--bean配置的就是拦截器-->
            <!--<bean class="com.feng.interceptor.MyInterceptor"/>-->
            <bean class="com.feng.interceptor.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

再次重启Tomcat测试

这次点击登录页面会跳转至登陆页面了

---

参考教程：https://blog.kuangstudy.com/index.php/tag/SpringMVC/