Day41——SpringMVC学习笔记2（拦截器、AJax、JSON）
文章目录
- 配置好一个SpringMVC项目
- SpringMVC：JSON
- JSON 和 JavaScript 对象互转：
- Controller返回JSON数据
- Jackson
- 测试一：
- 测试二
- FastJson
- SpringMVC：Ajax
- 简单介绍
- 牛刀小试
- SpringMVC实现数据回显
- SpringMVC：拦截器
- 初识拦截器，实现
- 验证用户是否登录实验
配置好一个SpringMVC项目
在上一次整合SSM项目过程中，对于配置流程没有理的那么清晰，这次对这个流程再次梳理一下
Spring Web项目准备工作：
- 依赖配置齐全
- 服务器保证正常运行
- 整个项目的结果保证运行无误
- 理解配置文件的作用和搭配
- web.xml
- mybatis-config.xml
- applicationContext.xml
- spring-servlet.xml
- …
具体实现：
首先建立空的Maven项目，加入web支持
1、将项目层级结构建立
com
feng
controller
dao
pojo
service2、导入依赖
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.2.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.2.RELEASEversion>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.2version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>2.0.2version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
dependencies>3、web.xml中(DispatcherServlet、乱码过滤)
<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>DispatcherServletservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:applicationContext.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>DispatcherServletservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
<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>
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:
<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:property-placeholder location="classpath:db.properties"/>
<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>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/feng/dao/*.xml"/>
<property name="typeAliasesPackage" value=""/>
bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<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
<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">
beans>spring-webmvc.xml
<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: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"/>
<import resource="classpath:spring-dao.xml"/>
<import resource="classpath:spring-webmvc.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" %>
Title
${msg}
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 对象互转：
测试代码：
<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步，不然会报错。
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.8version>
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.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.60version>
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页面，感受下局部页面刷新
<html>
<head lang="en">
<meta charset="UTF-8">
<title>Testajaxtitle>
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" %>
Title
姓名
年龄
性别
运行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" %>
ajax3
用户名:
密码:
运行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.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>4.0.1version>
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>
<mvc:mapping path="/**"/>
<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中
拦截器测试
启动Tomcat进行测试：
验证用户是否登录实验
1、一个登录页面，写对应Controller访问页面
2、登陆页面有提交表单的动作，在Controller中进行处理，判断用户名密码是否正确，若正确向session中写入用户信息，返回登陆成功
3、存在一个登陆成功后的页面，拦截用户请求，当用户登录可访问，若用户没登陆，跳转至登陆页面
写登录页面login2.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
登录页面
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" %>
Title
登录成功页面
用户名：${user}
注销
在index.jsp中添加body
首页
<%--登录--%>
登录
成功页面
第一次测试，启动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 class="com.feng.interceptor.LoginInterceptor"/>
mvc:interceptor>
mvc:interceptors>再次重启Tomcat测试
这次点击登录页面会跳转至登陆页面了
参考教程：https://blog.kuangstudy.com/index.php/tag/SpringMVC/