SpringMVC框架学习笔记

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:context=""xmlns:mvc=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd://www.springframework/schema/mvc/spring-mvc.xsd"><!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 --><context:component-scan base-package=&#h.controller"/><!-- 让Spring MVC不处理静态资源，像.css .js .html .mp3 .mp4等文件，这些文件过滤，不然也走视图解析器会出现问题,这句不加，加了就无法访问/user/json1，其实加了@ResponseBody(),controller返回就不会经过视图解析器--><!-- <mvc:default-servlet-handler /> --><!-- 视图解析器 --><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><!-- 前缀 --><property name="prefix" value="/WEB-INF/jsp/" /><!-- 后缀 --><property name="suffix" value=".jsp" /></bean></beans>

我们随便编写一个User的实体类，然后我们去编写我们的测试Controller；

h.pojo;public class User {private String name;private int age;private String sex;//这里省略setter&getter，toString方法，全参数构造和无参构造
}

这里我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象，我们看下具体的用法

编写一个Controller：

Java对象的输出

@ResponseBody

备注了这个注解，Controller的方法返回就不会走视图解释器，会直接返回一个字符串。

@Controller
@RequestMapping("/user")
public class UserController {@RequestMapping("/json1")@ResponseBodypublic String json1() throws JsonProcessingException {//创建一个对象User user = new User("秦疆1号", 3, "男");//创建一个jackson的对象映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//将我们的对象解析成为json格式String str = mapper.writeValueAsString(user);//由于@ResponseBody注解，这里会将str转成json格式返回；十分方便return str;}
}

配置Tomcat ， 启动测试一下！

localhost:8080/user/json1

对应输出的就是JSON的对象

（乱码的解决见7.3.2）

Java数组结构输出

增加一个新的方法

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {//创建一个jackson的对象映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//创建一个对象User user1 = new User("秦疆1号", 3, "男");User user2 = new User("秦疆2号", 3, "男");User user3 = new User("秦疆3号", 3, "男");User user4 = new User("秦疆4号", 3, "男");List<User> list = new ArrayList<User>();list.add(user1);list.add(user2);list.add(user3);list.add(user4);//将我们的对象解析成为json格式String str = mapper.writeValueAsString(list);return str;
}

运行结果 : 十分完美，没有任何问题！

• List、Set、Vector、数组输出的是JSON的数组

• Map不同，输出的是JSON对象

  @RequestMapping("/json5")
  public String json5() throws JsonProcessingException {//创建一个对象User user1 = new User("秦疆1号", 3, "男");Map<String, User> map = new HashMap<>();map.put("user1",user1);String json = Json(map);return json;
  }
  

Java时间对象输出

增加一个新的方法

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {ObjectMapper mapper = new ObjectMapper();//创建时间一个对象，java.util.DateDate date = new Date();//将我们的对象解析成为json格式String str = mapper.writeValueAsString(date);return str;
}

运行结果：

• 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
• Jackson 默认是会把时间转成timestamps形式

解决方案：取消timestamps形式 ， 自定义时间格式

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {ObjectMapper mapper = new ObjectMapper();//不使用时间戳的方式figure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);//自定义日期格式对象SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//指定日期格式mapper.setDateFormat(sdf);Date date = new Date();String str = mapper.writeValueAsString(date);return str;
}

运行结果 : 成功的输出了时间！

7.3.2 乱码问题

发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；

通过**@RequestMaping的produces属性**来实现，修改下代码

• produces：指定响应体返回类型和编码

//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

再次测试， localhost:8080/json1 ， 乱码问题OK！

代码优化:

⭐乱码统一解决

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！

我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！

<mvc:annotation-driven><mvc:message-converters register-defaults="true"><bean class="org.verter.StringHttpMessageConverter"><constructor-arg value="UTF-8"/></bean><bean class="org.verter.json.MappingJackson2HttpMessageConverter"><property name="objectMapper"><bean class="org.verter.json.Jackson2ObjectMapperFactoryBean"><property name="failOnEmptyBeans" value="false"/></bean></property></bean></mvc:message-converters>
</mvc:annotation-driven>

返回json字符串统一解决

@RestController

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

@RestController
public class UserController {@RequestMapping("/json1")public String json1() throws JsonProcessingException {//创建一个对象User user = new User("秦疆1号", 3, "男");//创建一个jackson的对象映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//将我们的对象解析成为json格式String str = mapper.writeValueAsString(user);return str;}}

启动tomcat测试，结果都正常输出！

7.3.3 抽取为工具类

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中

h.utils;import com.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;SimpleDateFormat;public class JsonUtils {public static String getJson(Object object) {return getJson(object,"yyyy-MM-dd HH:mm:ss");}public static String getJson(Object object,String dateFormat) {ObjectMapper mapper = new ObjectMapper();//不使用时间戳的方式figure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);//自定义日期格式对象SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);//指定日期格式mapper.setDateFormat(sdf);try {return mapper.writeValueAsString(object);} catch (JsonProcessingException e) {e.printStackTrace();}return null;}
}

我们使用工具类，代码就更加简洁了！

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {Date date = new Date();String json = Json(date);return json;
}

大功告成！完美！

7.3.4 FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

fastjson 的 pom依赖！依赖点这

<dependency><groupId>com.alibaba.fastjson2</groupId><artifactId>fastjson2</artifactId><version>2.0.12</version>
</dependency>

fastjson 三个主要的类：

JSONObject 代表 json 对象

• JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。

• JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。

  其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray 代表 json 对象数组

• 内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

• JSON类源码分析与使用
• 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

具体就没有学了，狂神19年讲的也有点过时了，有方法已经淘汰了。

8. ssm整合

要求：熟练掌握MySQL数据库，Spring，JavaWeb及MyBatis知识，简单的前端知识

8.1 数据库环境

创建一个存放书籍数据的数据库表

CREATE DATABASE `ssmbuild`;USE `ssmbuild`;DROP TABLE IF EXISTS `books`;CREATE TABLE `books` (
`bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT(11) NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8-- 上下代码分开运行，不然会报错，因为同批次运行表会还没有建好。
INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

8.2 基本环境搭建

1、新建一Maven项目！“ssmbuild”， 添加web的支持

2、导入相关的pom依赖！junit，数据库驱动，连接池，servlet，jsp，mybatis，mybatis-spring，spring

<dependencies><!--Junit--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version></dependency><!--数据库驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.30</version></dependency><!-- 数据库连接池 --><dependency><groupId&hange</groupId><artifactId>c3p0</artifactId><version>0.9.5.5</version></dependency><!--Servlet - JSP --><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet.jsp</groupId><artifactId>javax.servlet.jsp-api</artifactId><version>2.3.3</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency><!--Mybatis--><dependency><groupId&batis</groupId><artifactId>mybatis</artifactId><version>3.5.10</version></dependency><dependency><groupId&batis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.7</version></dependency><!--Spring--><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.22</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.22</version></dependency><!--lombok--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.24</version><scope>compile</scope></dependency>
</dependencies>

3、Maven资源过滤设置

<!-- 静态资源导出问题-->
<build><resources><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource></resources>
</build>

4、建立基本结构和配置框架！

1. 基本结构

2. 配置

   • （mybatis的核心配置文件）

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE configurationPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd">
     <configuration></configuration>
     

   • （spring的核心配置文件）

     <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns=""xmlns:xsi=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd"></beans>
     

8.3 Mybatis层编写

1、数据库配置文件 database.properties

jdbc.driver&#sql.cj.jdbc.Driver
# 如果使用的是MYSQL8.0+，增加一个时区的配置
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
jdbc.username=root
jdbc.password=123456

2、IDEA 关联数据库

3、编写MyBatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd">
<configuration><!-- MyBatis本来是要配置数据源的，但是和Spring整合后，就在Spring配置中完成就行了 --><!--  设置日志 使用<settings>标签--><settings><setting name="logImpl" value="STDOUT_LOGGING"/></settings><!-- 取别名 --><typeAliases><package name=&#h.pojo"/></typeAliases><!-- 映射文件还没有写，这个放后面完成，如果映射文件与映射接口相同命名，可以用class绑定，不一致就用resource绑定 --><mappers><mapper resource="com/torch/l"/></mappers></configuration>

4、编写数据库对应的实体类 h.pojo.Books

使用lombok插件！

h.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books { //pojo 尽量保持成员名 和 表的列名 一致private int bookID;private String bookName;private int bookCounts;private String detail;
}

我们可以点开 Structure窗口 查看

5、编写Dao层的 Mapper接口 BookMapper！

h.dao;h.pojo.Books;
import java.util.List;public interface BookMapper {//增加一个Bookint addBook(Books book);//根据id删除一个Book,不同于传入对象，可以通过成员名获取对应的参数，对于单个数据，最好添加@Param注解署名映射的参数名称int deleteBookById(@Param("bookID") int id);//更新Bookint updateBook(Books books);//根据id查询,返回一个BookBooks queryBookById(@Param("bookID") int id);//查询全部Book,返回list集合List<Books> queryAllBook();
}

6、编写接口对应的映射文件 。需要导入MyBatis的包；

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis//DTD Mapper 3.0//EN"".dtd"><mapper namespace=&#h.dao.BookMapper"><!--增加一个Book--><insert id="addBook" parameterType="Books">insert into ssmbuild.books(bookName,bookCounts,detail)values (#{bookName}, #{bookCounts}, #{detail})</insert><!--根据id删除一个Book--><delete id="deleteBookById" parameterType="int">delete from ssmbuild.books where bookID=#{bookID}</delete><!--更新Book--><update id="updateBook" parameterType="Books">update ssmbuild.booksset bookName = #{bookName},bookCounts = #{bookCounts},detail = #{detail}where bookID = #{bookID}</update><!--根据id查询,返回一个Book--><select id="queryBookById" resultType="Books">select * from ssmbuild.bookswhere bookID = #{bookID}</select><!--查询全部Book--><select id="queryAllBook" resultType="Books">SELECT * from ssmbuild.books</select></mapper>

7、编写Service层的接口和实现类

业务一般是和数据库对应的，一般会有些差别。

接口：BookService:底下需要去实现,调用dao层

h.service;h.pojo.Books;
import java.util.List;public interface BookService {//增加一个Bookint addBook(Books book);//根据id删除一个Bookint deleteBookById(int id);//更新Bookint updateBook(Books books);//根据id查询,返回一个BookBooks queryBookById(int id);//查询全部Book,返回list集合List<Books> queryAllBook();
}

实现类：

h.service;h.dao.BookMapper;
h.pojo.Books;
import java.util.List;@Service
public class BookServiceImpl implements BookService {//调用dao层的操作，设置一个set接口，方便Spring管理private BookMapper bookMapper;public void setBookMapper(BookMapper bookMapper) {this.bookMapper = bookMapper;}public int addBook(Books book) {return bookMapper.addBook(book);}public int deleteBookById(int id) {return bookMapper.deleteBookById(id);}public int updateBook(Books books) {return bookMapper.updateBook(books);}public Books queryBookById(int id) {return bookMapper.queryBookById(id);}public List<Books> queryAllBook() {return bookMapper.queryAllBook();}
}

OK，到此，底层需求操作编写完毕！

8.4 Spring层

1、配置Spring整合MyBatis，我们这里数据源使用c3p0连接池；

spring配置文件的上下文具体的设置在这，同个module尽量都在同一个上下文中。

这样我们就不需要自己去import了，IDEA会自动进行配置，形成相互联系的一种关系，加入到这种联系的配置文件，会有下面的矩阵图案。

2、我们去编写Spring整合Mybatis的相关的配置文件&#l

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:context=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd"><!--  这里配置关于dao的Spring配置，需要和其他的配置文件在一个上下文中  --><!-- 配置整合mybatis --><!-- 1.关联数据库文件 --><context:property-placeholder location="classpath:database.properties"/><!-- 2.数据库连接池 --><!--数据库连接池dbcp 半自动化操作 不能自动连接c3p0 自动化操作（自动的加载配置文件 并且可以自动设置到对象里面）druid: hikari 两个企业经常使用的。这里使用的是c3p0，还可以 使用spring自带的dbcp见spring框架（二）11.3.1的2--><bean id="dataSource" class=&#hange.v2.c3p0.ComboPooledDataSource"><!-- 配置连接池属性 这种调用参数属于调用properties文件中的参数--><property name="driverClass" value="${jdbc.driver}"/><property name="jdbcUrl" value="${jdbc.url}"/><property name="user" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/><!-- c3p0连接池的私有属性 --><property name="maxPoolSize" value="30"/><property name="minPoolSize" value="10"/><!-- 关闭连接后不自动commit --><property name="autoCommitOnClose" value="false"/><!-- 获取连接超时时间 --><property name="checkoutTimeout" value="10000"/><!-- 当获取连接失败重试次数 --><property name="acquireRetryAttempts" value="2"/></bean><!-- 3.配置SqlSessionFactory对象 --><bean id="sqlSessionFactory" class=&#batis.spring.SqlSessionFactoryBean"><!-- 注入数据库连接池 --><property name="dataSource" ref="dataSource"/><!-- 配置MyBaties全局配置文件:l --><property name="configLocation" value="l"/></bean><!-- 之前我们把Mapper注入sqlSessionFactory，再将其注入sqlSessionTemplate，再将其注入Mapper实现类里，最后实现调用方法；或者 SqlSessionDaoSupport的改版，主要见spring框架（二）11.3  --><!-- 4.配置扫描Dao接口包，动态实现Dao接口注入到spring容器中 --><!--解释 ：.html--><bean class=&#batis.spring.mapper.MapperScannerConfigurer"><!-- 注入sqlSessionFactory --><property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/><!-- 给出需要扫描Dao接口包 --><property name="basePackage" value=&#h.dao"/></bean></beans>

3、Spring整合service层 l

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:context=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd"><!--  这里配置关于service的Spring配置，需要和其他的配置文件在一个上下文中  --><!-- 1.扫描service相关的bean --><context:component-scan base-package=&#h.service" /><!--2.BookServiceImpl注入到IOC容器中--><bean id="BookServiceImpl" class=&#h.service.BookServiceImpl"><property name="bookMapper" ref="bookMapper"/></bean><!-- 3.配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><!-- 注入数据库连接池 --><property name="dataSource" ref="dataSource" /></bean><!-- 4.aop事务支持织入到指定的位置（具体见spring框架（二）13.3.1的3）；如果不写，其实导入DataSourceTransactionManager就已经有事务的功能了，只是默认自动都会创建事务--></beans>

Spring层搞定！再次理解一下，Spring就是一个大杂烩，一个容器！对吧！

8.5 SpringMVC层

1、

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"version="4.0"><welcome-file-list><welcome-file>/index.jsp</welcome-file></welcome-file-list><!--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>l</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><!--encodingFilter--><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></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><!--为了安全性，会有设置Session过期时间，15min--><session-config><session-timeout>15</session-timeout></session-config></web-app>

2、

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:context=""xmlns:mvc=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd://www.springframework/schema/mvc/spring-mvc.xsd"><!--  这里配置关于springmvc的Spring配置，需要和其他的配置文件在一个上下文中  --><!-- 配置SpringMVC --><!-- 1.开启SpringMVC注解驱动 --><mvc:annotation-driven /><!-- 2.静态资源默认servlet配置--><mvc:default-servlet-handler/><!-- 3.配置jsp 显示ViewResolver视图解析器 --><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="viewClass" value="org.springframework.web.servlet.view.JstlView" /><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /></bean><!-- 4.扫描web相关的bean --><context:component-scan base-package="ller" /></beans>

3、Spring配置整合文件&#l

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd"><import resource=&#l"/><import resource=&#l"/><import resource=&#l"/></beans>

配置文件，暂时结束！

8.6 Controller 和 视图层 编写

1、BookController 类编写 ， 方法一：查询全部书籍

@Controller
@RequestMapping("/book")
public class BookController {//controller 调用 service层private final BookService bookService;/*** Autowired 注解**默认优先ByType进行自动装配**，当发现装配类型于spring容器中<u>存在两个及以上实例时</u>，会采用ByName的方式继续寻找对应的实例进行装配。* 如果多个相同类型，可以搭配 @Qualifier，按照 @Qualifier(value=“id”) 去辅助配置 @Autowired的使用。*/@Autowiredpublic BookController(@Qualifier("BookServiceImpl") BookService bookService) {this.bookService = bookService;}//查询全部的书籍，并且返回到一个书籍展示页面@RequestMapping("/allBook")public String list(Model model) {List<Books> list = bookService.queryAllBook();model.addAttribute("list", list);return "allBook";}
}

2、编写首页 index.jsp

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE HTML>
<html>
<head><title>首页</title><style type="text/css">a {text-decoration: none;color: black;font-size: 18px;}h3 {width: 180px;height: 38px;margin: 100px auto;text-align: center;line-height: 38px;background: deepskyblue;border-radius: 4px;}</style>
</head>
<body><h3><a href="${tPath}/book/allBook">进入书籍页面</a></h3>
</body>
</html>

3、书籍列表页面 allBook.jsp

<%@ taglib prefix="c" uri="" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>书籍列表</title><meta name="viewport" content="width=device-width, initial-scale=1.0"><!-- 引入 Bootstrap 在线的cdn ，美化界面 --><link href=".4.1/css/bootstrap.min.css" rel="stylesheet">
</head>
<body><div class="container"> <!-- 栅格系统 --><!--标题--><div class="row clearfix"> <!-- 一行 清楚浮动 --><div class="col-md-12 column"> <!-- md中等屏幕分成12份，我们沾满总共的12份 --><div class="page-header"><!-- 头部 --><h1><small>书籍列表 —— 显示所有书籍</small></h1></div></div></div><!--新增数据按钮--><div class="row"> <!-- 一行 --><div class="col-md-4 column"><!-- 占屏幕的4份 --><a class="btn btn-primary" href="${tPath}/book/toAddBook">新增书籍</a></div></div><!--显示数据，并操作数据--><div class="row clearfix"> <!-- 一行 消除浮动--><div class="col-md-12 column"><!-- 占屏幕的12份 --><table class="table table-hover table-striped"><!-- 表格 hover隔行交替变色 striped显示格子 --><thead> <!--表格头部--><tr><th>书籍编号</th><th>书籍名字</th><th>书籍数量</th><th>书籍详情</th><th>操作</th></tr></thead><tbody><!--表格身体--><!--书籍从数据库中查询出来，从这个list中遍历出来，c标签的foreach--><c:forEach var="book" items="${('list')}"> <!--或者直接从model中获取 items="${list}"--><tr><td>${BookID()}</td><td>${BookName()}</td><td>${BookCounts()}</td><td>${Detail()}</td><td><a href="${tPath}/book/toUpdateBook?id=${BookID()}">更改</a>&nbsp; | &nbsp;<a href="${tPath}/book/del/${BookID()}">删除</a></td></tr></c:forEach></tbody></table></div></div></div></body>

4、BookController 类编写 ， 方法二：添加书籍

//当allBool页面，点击”新增书籍“按钮；跳转到添加书籍的页面
@RequestMapping("/toAddBook")
public String toAddPaper() {return "addBook";
}//添加书籍的请求，addBook页面点击“添加”按钮，完成书籍的添加，最后重定位到allBook页面
@RequestMapping("/addBook")
public String addPaper(Books books) {System.out.println(books);bookService.addBook(books);return "redirect:/book/allBook";
}

5、添加书籍页面：addBook.jsp

<%@ taglib prefix="c" uri="" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %><html>
<head><title>新增书籍</title><meta name="viewport" content="width=device-width, initial-scale=1.0"><!-- 引入 Bootstrap --><link href=".4.1/css/bootstrap.min.css" rel="stylesheet">
</head>
<body><div class="container"><div class="row clearfix"><div class="col-md-12 column"><div class="page-header"><h1><small>新增书籍</small></h1></div></div></div><form action="${tPath}/book/addBook" method="post"><div class="form-group"><label for="bookName">书籍名称：</label><input type="text" class="form-control" id="bookName" name="bookName" required> <!--加入required属性，表示必须填入内容后才能提交--></div><div class="form-group"><label for="bookCounts">书籍数量：</label><input type="number" class="form-control" id="bookCounts" name="bookCounts" required></div><div class="form-group"><label for="detail">书籍详情：</label><input type="text" class="form-control" id="detail" name="detail" required></div><div class="form-group"><input type="submit" class="form-control" value="添加"></div></form></div></body>

6、BookController 类编写 ， 方法三：修改书籍

//跳转到修改书籍页面，allBook页面点击书籍的“更改”链接
@RequestMapping("/toUpdateBook")
public String toUpdateBook(Model model, int id) {Books books = bookService.queryBookById(id);System.out.println(books);model.addAttribute("book",books );return "updateBook";
}//对书籍进行修改，updateBook页面点击“修改”按钮，最后重定位到allBook页面
@RequestMapping("/updateBook")
public String updateBook(Model model, Books book) {System.out.println(book);bookService.updateBook(book);Books books = bookService.BookID());model.addAttribute("books", books);return "redirect:/book/allBook";
}

7、修改书籍页面 updateBook.jsp

<%@ taglib prefix="c" uri="" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>修改信息</title><meta name="viewport" content="width=device-width, initial-scale=1.0"><!-- 引入 Bootstrap --><link href=".4.1/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container"><div class="row clearfix"><div class="col-md-12 column"><div class="page-header"><h1><small>修改书籍</small></h1></div></div></div><form action="${tPath}/book/updateBook" method="post"><input type="hidden" name="bookID" value="${BookID()}"/> <!--千万不能忘了id--><div class="form-group"><label for="bookName">书籍名称：</label><input type="text" class="form-control" id="bookName" name="bookName" value="${BookName()}" required> <!--加入required属性，表示必须填入内容后才能提交--></div><div class="form-group"><label for="bookCounts">书籍数量：</label><input type="number" class="form-control" id="bookCounts" name="bookCounts" value="${BookCounts()}" required></div><div class="form-group"><label for="detail">书籍详情：</label><input type="text" class="form-control" id="detail" name="detail" value="${Detail()}" required></div><div class="form-group"><input type="submit" class="form-control" value="修改"></div></form></div>

8、BookController 类编写 ， 方法四：删除书籍

//删除书籍，allBook页面点击“删除”链接，最后重定位到allBook页面
@RequestMapping("/del/{bookId}")//Restful风格
public String deleteBook(@PathVariable("bookId") int id) {bookService.deleteBookById(id);return "redirect:/book/allBook";
}

配置Tomcat，进行运行！

到目前为止，这个SSM项目整合已经完全的OK了，可以直接运行进行测试

项目结构图

8.7 新增搜索功能

1. 在allBook页面添加前端的查询交互（展示部分被修改的代码）

   <!--新增数据按钮-->
   <div class="row"> <!-- 一行 --><div class="col-md-4 column"><!-- 占屏幕的4份 --><a class="btn btn-primary" href="${tPath}/book/toAddBook">新增书籍</a><a class="btn btn-primary" href="${tPath}/book/allBook">查询全部书籍</a></div><div class="col-md-4 column"></div><div class="col-md-4 column"><!-- 占屏幕的4份 --><!--查询书籍--><form action="${tPath}/book/queryBook" method="post" style="float:right" class="form-inline"><span style="color: red;font-weight: bold">${error}</span><input type="text" name="queryBookName" class="form-control" placeholder="请输入要查询的书籍名称"><input type="submit" value="查询" class="btn btn-primary"></form></div>
   </div>
   

2. BookMapper接口添加方法

   Books queryBookByName(@Param("bookName") String bookName);
   

3. BookMapper映射文件 添加 sql语句

   <!--查询Book-->
   <select id="queryBookByName" resultType="Books">SELECT * from ssmbuild.books where bookName=#{bookName}
   </select>

4. BookService接口 添加方法

   Books queryBookByName(String bookName);
   

5. BookServiceImpl 添加实现方法

   public Books queryBookByName(String bookName) {return bookMapper.queryBookByName(bookName);
   }
   

6. BookController 添加查询

   //查询书籍
   @RequestMapping("/queryBook")
   public String queryBook(String queryBookName,Model model){Books books = bookService.queryBookByName(queryBookName);model.addAttribute("book",books);List<Books> list = new ArrayList<>();list.add(books);if (books == null){list = bookService.queryAllBook();model.addAttribute("error","未查到");}model.addAttribute("list", list);return "allBook";
   }
   

9. SpringMVC：Ajax技术

9.1 简介

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

• AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

• Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。

Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。就和国内百度的搜索框一样！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a3DV1JzN-1664025486143)(SpringMVC框架.assets/image-20220914154504116.png)]

传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。

• 使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。

• 使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。

9.2 伪造Ajax

我们可以使用前端的一个标签来伪造一个ajax的样子。iframe标签

1. 新建一个module ：springmvc-06-ajax ， 导入web支持，web配置（DispatcherServlet），spring配置

   • <?xml version="1.0" encoding="UTF-8"?>
     <web-app xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"version="4.0"><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>l</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><filter><filter-name>encoding</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>encoding</filter-name><url-pattern>/*</url-pattern></filter-mapping>
     </web-app>

   • <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns=""xmlns:xsi=""xmlns:context=""xmlns:mvc=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd  .xsd"><!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 --><context:component-scan base-package=&#h.controller"/><!--静态资源过滤，使用jQuery的js时一定要加上--><mvc:default-servlet-handler /><!--注解驱动--><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>

2. 编写一个 ajax-frame.html (web下)使用 iframe 测试，感受下效果

   <!DOCTYPE html>
   <html>
   <head lang="en"><meta charset="UTF-8"><title>kuangshen</title>
   </head>
   <body><script type="text/javascript"&load = function(){var myDate = new Date();ElementById('currentTime').innerText = Time();};function LoadPage(){var targetUrl =  ElementById('url').value;console.log(targetUrl);ElementById("iframePosition").src = targetUrl;}</script><div><p>请输入要加载的地址：<span id="currentTime"></span></p><p><input id="url" type="text" value="/"/><input type="button" value="提交" onclick="LoadPage()"></p></div><div><h3>加载页面位置：</h3><iframe id="iframePosition" style="width: 100%;height: 500px;"></iframe></div></body>
   </html>
   

3. 使用IDEA开浏览器测试一下！

利用AJAX可以做：

• 注册时，输入用户名自动检测用户是否已经存在。
• 登陆时，提示用户名密码错误
• 删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除。
• …等等

9.3 jQuery.ajax

纯JS原生实现Ajax我们不去讲解这里，直接使用jquery提供的，方便学习和使用，避免重复造轮子，有兴趣的同学可以去了解下JS原生XMLHttpRequest ！

Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。

jQuery 提供多个与 AJAX 有关的方法：

通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。

jQuery 不是生产者，而是大自然搬运工。

jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery官网下载

下载开发版本的

将文件放到web/statics/js 文件夹下

jQuery.ajax(…)

部分参数：

• url：请求地址，可以是请求也可以是真正的页面 ⭐
• type：请求方式，GET、POST、还有其他的方式（1.9.0之后用method） ⭐
• headers：请求头
• data：要发送的数据 ⭐
• contentType：即将发送信息至服务器的内容编码类型(默认: “application/x-www-form-urlencoded; charset=UTF-8”)
• async：是否异步
• timeout：设置请求超时时间（毫秒）
• beforeSend：发送请求前执行的函数(全局)
• complete：完成之后执行的回调函数(全局)
• success：成功之后执行的回调函数(全局) ⭐
• error：失败之后执行的回调函数(全局) ⭐
• accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
• dataType：将服务器端返回的数据转换成指定类型
• “xml”：将服务器端返回的内容转换成xml格式
• “text”：将服务器端返回的内容转换成普通文本格式
• “html”：将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
• “script”：尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
• “json”：将服务器端返回的内容转换成相应的JavaScript对象
• “jsonp”：JSONP 格式使用 JSONP 形式调用函数时，如 “myurl?callback=?” jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

简单测试

我们来个简单的测试，使用最原始的HttpServletResponse处理 , 最简单 , 最通用

1、配置l 和 springmvc的配置文件，按照9.2 进行配置 【记得⭐静态资源过滤和注解驱动配置上】

2、编写一个AjaxController

@Controller
public class AjaxController {@RequestMapping("/a1")public void ajax1(String name , HttpServletResponse response) throws IOException {if ("admin".equals(name)){Writer().print("true");}else{Writer().print("false");}}}

3、导入jquery ， 可以使用在线的CDN ， 也可以下载导入

<!--在线的CDN-->
<script src=".1.1.min.js"></script><!--下载导入-->
<script src="${tPath}/statics/js/jquery-3.1.1.min.js"></script>

4、编写index.jsp测试

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>$Title$</title><%--导入 jQuery的js --%>
<%--  <script src=".6.1.js"></script>--%><script src="${tPath}/statics/js/jquery-3.6.1.js"></script><%--jQuery的缩写就是'$'--%><script>function a1(){$.post({  <%--这里传入了三个参数：url，data(可省略)，success(callback)--%>url:"${tPath}/a1",<%--data参数的值，用键值对的形式；键"name"要与后端命名相同； $()为选择器，"#txtName"为查询对应id的元素；$("#txtName").val() 获取对应id元素的值 --%>data:{'name':$("#txtName").val()},success:function (data,status) { <%--回调函数--%>console.log("data="+data);console.log("status="+status);}});}</script>
</head>
<body><%--失去焦点的时候，发起一个请求(携带信息)到后台--%>
<%--onblur：失去焦点触发事件，调用a1函数，用来发起请求--%>
用户名:<input type="text" id="txtName" οnblur="a1()"/>
</body>
</html>

5、启动tomcat测试！打开浏览器的控制台，当我们鼠标离开输入框的时候，可以看到发出了一个ajax的请求！是后台返回给我们的结果！测试成功！

运行流程：

Springmvc实现

实体类user

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

我们来获取一个集合对象，展示到前端页面

@RequestMapping("/a2")
public List<User> ajax2(){List<User> list = new ArrayList<User>();list.add(new User("秦疆1号",3,"男"));list.add(new User("秦疆2号",3,"男"));list.add(new User("秦疆3号",3,"男"));return list; //由于@RestController注解，里面所有的方法都只会返回字符串，这样会将list转成json格式返回
}

前端页面（随意命名，我这就写个test2.jsp直接放到web文件夹下，方便访问）

<%@ 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 src="${tPath}/statics/js/jquery-3.1.1.min.js"></script>
<script>$(function () {$("#btn").click(function () {$.post("${tPath}/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>

成功实现了数据回显！可以体会一下Ajax的好处！

9.4 注册提示效果

我们再测试一个小Demo，思考一下我们平时注册时候，输入框后面的实时提示怎么做到的；如何优化

我们写一个Controller

@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 ("123456".equals(pwd)){msg = "OK";}else {msg = "密码输入有误";}}return msg; 
}

前端页面 login.jsp （直接放到web文件夹下，方便访问）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>ajax</title><script src="${tPath}/statics/js/jquery-3.1.1.min.js"></script><script>function a1(){$.post({url:"${tPath}/a3",data:{'name':$("#name").val()},success:function (data) {if (String()=='OK'){$("#userInfo").css("color","green");}else {$("#userInfo").css("color","red");}$("#userInfo").html(data);}});}function a2(){$.post({url:"${tPath}/a3",data:{'pwd':$("#pwd").val()},success:function (data) {if (String()=='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="text" id="pwd" οnblur="a2()"/> //应用场景：密码格式是否正确<span id="pwdInfo"></span></p>
</body>
</html>

【记得处理json乱码问题，见7.3.2】

测试一下效果，动态请求响应，局部刷新，就是如此！

9.5 获取baidu接口Demo

将百度的搜索框的接口获取

（随意命名，我这就写个test4.jsp直接放到web文件夹下，方便访问）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>JSONP百度搜索</title><style>#q{width: 500px;height: 30px;border:1px solid #ddd;line-height: 30px;display: block;margin: 0 auto;padding: 0 10px;font-size: 14px;}#ul{width: 520px;list-style: none;margin: 0 auto;padding: 0;border:1px solid #ddd;margin-top: -1px;display: none;}#ul li{line-height: 30px;padding: 0 10px;}#ul li:hover{background-color: #f60;color: #fff;}</style><script>// 2.步骤二// 定义demo函数 (分析接口、数据)function demo(data){var Ul = ElementById('ul');var html = '';// 如果搜索数据存在 把内容添加进去if (data.s.length) {// 隐藏掉的ul显示出来Ul.style.display = 'block';// 搜索到的数据循环追加到li里for(var i = 0;i<data.s.length;i++){html += '<li>'+data.s[i]+'</li>';}// 循环的li写入ulUl.innerHTML = html;}}// 1.步骤一load = function(){ //load:在网页加载完毕后立刻执行的操作，即当 HTML 文档加载完毕后，立刻执行某个方法。// 获取输入框和ulvar Q = ElementById('q');var Ul = ElementById('ul');// 输入=>事件鼠标抬起时候执行的事件Q.onkeyup = function(){// 如果输入框不等于空if (this.value !== '') {// ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆JSONPz重点☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆// 创建标签var script = ateElement('script');//给定要跨域的地址 赋值给src//这里是要请求的跨域的地址 我写的是百度搜索的跨域地址script.src = '='+this.value+'&cb=demo';//demo是函数// 将组合好的带src的script标签追加到body里document.body.appendChild(script);}}}</script>
</head><body><input type="text" id="q" /> //输入搜索内容<ul id="ul"> //显示搜索到的内容</ul>
</body>
</html>

10. 拦截器

10.1 概述

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

过滤器与拦截器的区别：

• 拦截器是AOP思想的具体应用（可以从下面实现HandlerInterceptor 接口的三个方法看出）。

过滤器

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

拦截器

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

10.2 自定义拦截器

那如何实现拦截器呢？

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

1. 新建一个Moudule ， springmvc-07-Interceptor ， 添加web支持

2. 配置l 和 l 文件（直接用ajax模块的来用）

   • <?xml version="1.0" encoding="UTF-8"?>
     <web-app xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"version="4.0"><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>l</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><filter><filter-name>encoding</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>encoding</filter-name><url-pattern>/*</url-pattern></filter-mapping>
     </web-app>

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns=""xmlns:xsi=""xmlns:context=""xmlns:mvc=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd  .xsd"><!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 --><context:component-scan base-package=&#h.controller"/><!--静态资源过滤--><mvc:default-servlet-handler /><mvc:annotation-driven ><!--解决json乱码--><mvc:message-converters register-defaults="true"><bean class="org.verter.StringHttpMessageConverter"><constructor-arg value="UTF-8"/></bean><bean class="org.verter.json.MappingJackson2HttpMessageConverter"><property name="objectMapper"><bean class="org.verter.json.Jackson2ObjectMapperFactoryBean"><property name="failOnEmptyBeans" value="false"/></bean></property></bean></mvc:message-converters></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>
   

   这里我们先到项目结构给部署天上lib，再确认项目能够跑之后，再继续项目的bian’xie

3. 编写一个拦截器

   h.interceptor;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 {//在请求处理的方法之前执行//如果返回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("------------清理------------");}
   }
   

4. 在springmvc的配置文件中配置拦截器

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

5. 编写一个Controller，接收请求

   h.controller;import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.ResponseBody;//测试拦截器的控制器
   @Controller
   public class InterceptorController {@RequestMapping("/interceptor")@ResponseBodypublic String testFunction() {System.out.println("控制器中的方法执行了");return "hello";}
   }

6. 前端 index.jsp

   <a href="${tPath}/interceptor">拦截器测试</a>

7. 启动tomcat 测试一下！

   访问控制器，拦截器执行：

   如果访问其他，如jsp，拦截器没有执行，server 没有任何输出。

10.3 验证用户是否登录 (认证用户)

实现思路

1. 有一个登陆页面，需要写一个controller访问页面。
2. 登陆页面有一提交表单的动作。需要在controller中处理。判断用户名密码是否正确。如果正确，向session中写入用户信息。返回登陆成功。
3. 拦截用户请求，判断用户是否登陆。如果用户已经登陆。放行， 如果用户未登陆，跳转到登陆页面

测试：

1. 编写一个登陆页面 login.jsp（web/WEB-INF下）

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
   <head><title>Title</title>
   </head><h1>登录页面</h1>
   <hr><body>
   <form action="${tPath}/user/login">用户名：<input type="text" name="username"> <br>密码：<input type="password" name="pwd"> <br><input type="submit" value="提交">
   </form>
   </body>
   </html>

2. 编写一个Controller处理请求

   h.controller;import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.RequestMapping;import javax.servlet.http.HttpSession;@Controller
   @RequestMapping("/user")
   public class UserController {//跳转到登陆页面@RequestMapping("/jumplogin")public String jumpLogin() throws Exception {return "login";}//跳转到成功页面@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 "login";}
   }

3. 编写一个登陆成功的页面 success.jsp（web/WEB-INF下）

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
   <head><title>Title</title>
   </head>
   <body><h1>登录成功页面</h1>
   <hr>${user}
   <a href="${tPath}/user/logout">注销</a>
   </body>
   </html>

4. 在 index 页面上测试跳转！启动Tomcat 测试，未登录也可以进入主页！

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html><head><title>$Title$</title></head><body><h1>首页</h1><hr>
   <%--登录--%><a href="${tPath}/user/jumplogin">登录</a><a href="${tPath}/user/jumpSuccess">成功页面</a></body>
   </html>

5. 编写用户登录拦截器

   h.interceptor;import org.springframework.web.servlet.HandlerInterceptor;
   import org.springframework.web.servlet.ModelAndView;import javax.servlet.ServletException;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import javax.servlet.http.HttpSession;
   import java.io.IOException;public class LoginInterceptor implements HandlerInterceptor {public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {//一般最后返回false，中间加上通过的条件// 如果访问的是登陆控制器则放行System.out.println("uri: " + RequestURI());if (RequestURI().contains("login")) {return true;}HttpSession session = Session();// 如果用户已登陆也放行Attribute("user") != null) {return true;}// 用户没有登陆跳转到登陆页面RequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);return false;}
   }

6. 在Springmvc的配置文件中注册拦截器

   <!--关于拦截器的配置-->
   <mvc:interceptors><mvc:interceptor><mvc:mapping path="/**"/><bean id="loginInterceptor" class=&#h.interceptor.LoginInterceptor"/></mvc:interceptor>
   </mvc:interceptors>

7. 再次重启Tomcat测试！

OK，测试登录拦截功能无误.

11. 文件上传和下载

11.1 准备工作

文件上传是项目开发中最常见的功能之一 ，springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。

如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

对表单中的 enctype 属性做个详细的说明：

• application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
• multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
• text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

举例：

<form action="" enctype="multipart/form-data" method="post"><input type="file" name="file"/><input type="submit">
</form>

一旦设置了enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。

在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

• Servlet3.0规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成。
• 而Spring MVC则提供了更简单的封装，Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。
• Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类：CommonsMultipartResolver。
• 因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。

11.2 文件上传

1. 新建一个Moudule ， springmvc-08-file ， 添加web支持，配置l 和 l

   创建好模块后，记得测试能否正常运行。

2. 导入文件上传的jar包，commons-fileupload ， Maven会自动帮我们导入他的依赖包 commons-io包；

   在父pos中添加依赖

   <!--文件上传-->
   <dependency><groupId>commons-fileupload</groupId><artifactId>commons-fileupload</artifactId><version>1.4</version>
   </dependency>
   <!--servlet-api导入高版本的-->
   <dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version>
   </dependency>
   

   添加了新的依赖，记得lib也需要添加，不然运行tomcat的时候找不到类报错。

3. 配置bean：multipartResolver

   【注意！！！这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误，因为其他地方需要调用它（以这个id名）】

   <!--文件上传配置-->
   <bean id="multipartResolver"  class="org.springframework.web.multipartmons.CommonsMultipartResolver"><!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 --><property name="defaultEncoding" value="utf-8"/><!-- 上传文件大小上限，单位为字节（10485760=10M） --><property name="maxUploadSize" value="10485760"/><property name="maxInMemorySize" value="40960"/>
   </bean>
   

   CommonsMultipartFile 的 常用方法：

   • String getOriginalFilename()：获取上传文件的原名
   • InputStream getInputStream()：获取文件流
   • void transferTo(File dest)：将上传文件保存到一个目录文件中

   我们去实际测试一下

4. 编写前端页面（就写在index.jsp中了）

   <form action="${tPath}/upload" enctype="multipart/form-data" method="post"><input type="file" name="file"/><input type="submit" value="upload">
   </form>

5. Controller

   h.controller;import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RequestParam;
   import org.springframework.web.multipartmons.CommonsMultipartFile;import javax.servlet.http.HttpServletRequest;
   import java.io.*;@Controller
   public class FileController {//@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象//批量上传CommonsMultipartFile则为数组即可@RequestMapping("/upload")public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {//获取文件名 : OriginalFilename();String uploadFileName = OriginalFilename();//如果文件名为空，直接回到首页！if ("".equals(uploadFileName)){return "redirect:/index.jsp";}System.out.println("上传文件名 : "+uploadFileName);//上传路径保存设置（即保存文件的真实路径[当这里还是文本]）//如果有个servlet 叫 UploadServlet，它部署在tomcat 下面以后的绝对路径如下："C:Program Filesapache-tomcat-8.0.3webappsUploadServlet"//那么&#RealPath("/upload")返回："C:Program Filesapache-tomcat-8.0.3webappsUploadServletupload"String path = ServletContext().getRealPath("/upload");//如果路径不存在，创建一个File realPath = new File(path);if (!ists()){realPath.mkdir();}System.out.println("上传文件保存地址："+realPath);InputStream is = InputStream(); //文件输入流OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流//读取写出int len=0;byte[] buffer = new byte[1024];while ((len&#ad(buffer))!=-1){//read成功返回读取文件的字节数，返回-1表示读取失败；所以这里while判断不是-1才执行循环的内部语句os.write(buffer,0,len);os.flush();//刷新此输出流并强制写出所有缓冲的输出字节。}os.close();is.close();return "redirect:/index.jsp";}
   }

6. 测试上传文件，OK！

   D:WorkspaceSpringMVCspringmvc-studyoutartifactsspringmvc_08_file_war_explodedupload

   或者在idea上查看

采用ansferTo() 来保存上传的文件（会更简单）

1. 编写Controller

   /*
   * 采用ansferTo() 来保存上传的文件
   */
   @RequestMapping("/upload2")
   public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {//上传路径保存设置String path = ServletContext().getRealPath("/upload");File realPath = new File(path);if (!ists()){realPath.mkdir();}//上传文件地址System.out.println("上传文件保存地址："+realPath);//通过CommonsMultipartFile的方法直接写文件（注意这个时候&#ansferTo(new File(realPath +"/"+ OriginalFilename()));return "redirect:/index.jsp";
   }
   

2. 前端表单提交地址修改

3. 访问提交测试，OK！

11.3 文件下载

文件下载步骤：

1. 设置 response 响应头
2. 读取文件 – InputStream
3. 写出文件 – OutputStream
4. 执行操作
5. 关闭流 （先开后关）

代码实现：

在使用的时候，只需要改动路径，还有文件名就好了（文件名可以用过连接传入）

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{//要下载的图片地址String  path = ServletContext().getRealPath("/upload"); String  fileName = "基础语法.jpg";//1、设置response 响应头set(); //设置页面不缓存,清空bufferresponse.setCharacterEncoding("UTF-8"); //字符编码response.setContentType("multipart/form-data"); //二进制传输数据//设置响应头response.setHeader("Content-Disposition","attachment;fileName="&#de(fileName, "UTF-8"));File file = new File(path,fileName);//2、 读取文件--输入流InputStream input=new FileInputStream(file);//3、 写出文件--输出流OutputStream out = OutputStream();byte[] buff =new byte[1024];int index=0;//4、执行 写出操作while((index= ad(buff))!= -1){out.write(buff, 0, index);out.flush();}out.close();input.close();return "ok";
}

前端：index加一句

<a href="${tPath}/download">点击下载</a>

测试，文件下载OK，大家可以和我们之前学习的JavaWeb原生的方式对比一下，就可以知道这个便捷多了!

当对应文件的路径找不到，网页会说找不到。

DeBug Log

1. Services 控制台输出乱码

   • Phenomenon

   • 解决：

     1. 第一部分Server的解决

        IDEA的控制台编码控制

        setting =》 Editor =》 Console =》修改 Default Encoding 为 UTF-8

     2. Tomcat Localhost Log 和 Tomcat Catalina Log 的乱码

        首先，找到本地tomcat的conf目录下的logging.properties，这个文件中有5个编码的位置

        修改这里的UTF-8 为 GBK

        最后重启下idea即可

2. 找不到HttpServlet类

   • 问题

   • 解决 帖子

     这是因为Tomcat版本的适配问题。

     在Tomcat的官网中，我们可以看到不同版本的Tomcat适配的JDK、Servlet、Jsp以及EL的版本，如下：

     我使用的是Tomcat10.0.16，Servlet 和 jsp 依赖如下

     <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.2</version>
     </dependency>
     

     这将导致Tomcat版本无法兼容Servlet版本（tomcat10将JavaEE更换成了Jakarta® EE，所以原Servlet包"javax.servlet.“更改成了"jakarta.servlet.”），我使用的是Servlet是javax包里的，而Tomcat能够识别（适配）的是Jakarta包里的，而javax包里的Servlet类无法转换为Jakarta包里的Servlet类，所以显示了找不到类。

     因为tomcat10才改成Jakarta，故只需将Tomcat版本降低到10以下，例如Tomcat9等。

     当然还要结合具体情况进行分析，让使用的Tomcat版本能够匹配自己使用的JSP或JDK等的版本。

     在Tomcat官网下载9版本，放至指定的路径下。点击run configuration

     在点击 Application server 的 Configure 添加新的tomcat，再选择Tomcat9，最后点击应用即可。

     9版本可以使用下面对应的Servlet、JSP 和 jstl 的依赖。

     <!-- .servlet/javax.servlet-api -->
     <dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version><scope>provided</scope>
     </dependency>
     <!-- .servlet.jsp/javax.servlet.jsp-api -->
     <dependency><groupId>javax.servlet.jsp</groupId><artifactId>javax.servlet.jsp-api</artifactId><version>2.3.3</version><scope>provided</scope>
     </dependency>
     <!-- .servlet/jstl -->
     <dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version>
     </dependency>
     

3. idea 加载页面后，页面上出现乱码

   • 问题同上

   • 解决

     settings / Editor /File Encodings 圈红的地方改为UTF-8，还有把下面的勾上。

     如果不想每次新项目都修改的话，可以 settings/New Project Setup/Settings for New Project 进行修改