SpringMVC-02

8、数据在域中的保存

8.1、Request对象中保存数据

Controller中的代码：

@RequestMapping(value = "/requestScope")
public String requestScope(HttpServletRequest request){
    System.out.println(" requestScope() ");
    request.setAttribute("reqKey1","reqValue1");
    request.setAttribute("reqKey2","reqValue2");

    return "scope_out";
}

jsp页面的输出：

Request域 reqKey1 的值是： ${ requestScope.reqKey1 } <br>
Request域 reqKey2 的值是： ${ requestScope.reqKey2 } <br>
<hr>

8.2、Session域中保存数据

Controller中的代码：

@RequestMapping(value = "/sessionScope")
public String sessionScope(HttpSession session){
    session.setAttribute("seKey1", "seValue1");
    session.setAttribute("seKey2", "seValue2");

    return "scope_out";
}

jsp页面的输出：

Session 域 seKey1 的值是： ${ sessionScope.seKey1 } <br>
Session 域 seKey2 的值是： ${ sessionScope.seKey2 } <br>
<hr>

8.3、ServletContext域中保存数据

在Controller中的代码。在Controller的中获取SerlvetContext对象有两种方法，

一种是@Autowired注入，

一种是通过Session获取。

//    @Autowired
//    ServletContext servletContext;

    @RequestMapping(value = "/applicationScope")
    public String applicationScope(HttpSession session){

        ServletContext servletContext = session.getServletContext();

        System.out.println(" applicationScope() ");
        servletContext.setAttribute("scKey1", "scValue1");
        servletContext.setAttribute("scKey2", "scValue2");

        return "scope_out";
    }

jsp页面的输出：

ServletContext 域 scKey1 的值是： ${ applicationScope.scKey1 } <br>
ServletContext 域 scKey2 的值是： ${ applicationScope.scKey1 } <br>
<hr>

8.4、Map或Model或ModelMap形式保存数据在request域中

在四个域中，我们使用最频繁的域就是request对象。往request域对象中，保存数据，还在以下的几种形式。

我们可以在Controller的方法中，添加Map类型的参数，或者是Model类型的参数。或者是ModelMap类型的参数。都可以直接用来保存域数据到Request对象中。

Map全类名是： java.util.Map

Model全类名是： org.springframework.ui.Model

ModelMap全类名是： org.springframework.ui.ModelMap

Map的形式保存数据到Request域中：

@RequestMapping(value = "/mapToRequest")
public String mapToRequest(Map<String,Object> map){
    System.out.println(" mapToRequest() ");

    map.put("mapKey1","mapValue1");
    map.put("mapKey2","mapValue2");

    return "scope_out";
}

Model的形式保存数据到Reqeust域中：

@RequestMapping(value = "/modelToRequest")
public String modelToRequest(Model model){

    System.out.println(" modelToRequest() ");

    model.addAttribute("modelKey1","modelValue1");
    model.addAttribute("modelKey2","modelValue2");

    return "scope_out";

}

以ModelMap的形式保存到Reqeust域中：

@RequestMapping(value = "/modelMapToRequest")
public String modelMapToRequest(ModelMap modelMap){

    System.out.println(" modelToRequest() ");

    modelMap.addAttribute("modelMapKey1","modelMapValue1");
    modelMap.addAttribute("modelMapKey2","modelMapValue2");

    return "scope_out";

}

隐含模型对象BindingAwareModelMap类，
作用是： 隐含模型对象专门用来保存数据，并带到视图中进行渲染

/**
 * BindingAwareModelMap类 隐含模型对象，隐含模型对象专门用来保存数据，并带到视图中进行渲染。<br/>
 *
 * class org.springframework.validation.support.BindingAwareModelMap类
 *                                                      /\
 *                                                      ||
 *                                              extends ExtendedModelMap
 *                                                      /\
 *                                                      ||
 *                                           extends ModelMap implements Model
 *                                                      /\
 *                                                      ||
 *                                             extends LinkedHashMap<String, Object>
 *
 *
 * @return
 */
@RequestMapping(value = "/mapAndModelAndModelMap")
public String mapAndModelAndModelMap(Map<String, Object> map, Model model, ModelMap modelMap) {

    System.out.println(map);
    System.out.println(model);
    System.out.println(modelMap);
    System.out.println("=================================");

    map.put("mapKey1", "mapValue1");
    System.out.println(map);
    System.out.println(model);
    System.out.println(modelMap);
    System.out.println("=================================");

    model.addAttribute("modelKey1","modelValue1");
    System.out.println(map);
    System.out.println(model);
    System.out.println(modelMap);
    System.out.println("=================================");


    modelMap.addAttribute("modelMapKey1","modelMapValue1");
    System.out.println(map);
    System.out.println(model);
    System.out.println(modelMap);
    System.out.println("=================================");


    System.out.println(map.getClass());
    System.out.println(model.getClass());
    System.out.println(modelMap.getClass());
    System.out.println("=================================");

    return "scope_out";
}

8.5、ModelAndView方式保存数据到request域中

ModelAndView 其实就是Model 和 View。

View是指的是视图（跳转的路径）。

Model是隐含模型

Controller类中的代码：

@RequestMapping(value = "/modelAndViewToRequest")
public ModelAndView modelAndViewToRequest(){
    ModelAndView modelAndView = new ModelAndView("scope_out");

    // 把数据保存到ModelAndView中，也会自动同步到Reqeust域中
    modelAndView.addObject("mavKey1","mavValue1");
    modelAndView.addObject("mavKey2","mavValue2");

    return modelAndView;
}

jsp页面的输出：

Request 域 mavKey1 的值是： ${ requestScope.mavKey1 } <br>
Request 域 mavKey2 的值是： ${ requestScope.mavKey2 } <br>
<hr>

8.6、@SessionAttributes保存数据到Session域中（了解内容）

@SessionAttributes可以告诉SpringMVC，将隐含模型中哪些数据也同步到Session域中

@SessionAttributes 注解可以标注在类上。它的作用是指定哪些数据可以保存到Session域中。

@SessionAttributes(names= { “key1”,”key2” }, types = { String.class, Book.class })

value属性，它表示把request域中key为key1，key2的键值对信息，也保存到Session中

types属性，它表示把request域中value类型为String.class**或Book.**class类型的键值对，也保存到Session中

Controller中的代码：

/**
 * @SessionAttributes是用在类上<br/>
 * 作用：是指定哪些隐含模型中的数据也可以同步到Session域中<br/>
 * names = "key1" 表示隐含模型中 key1的数据也同步到Session域中<br/>
 * names = {"key1","key2"} 表示隐含模型中 key1和key2的数据也同步到Session中<br/>
 * types 指定隐含模型中，value的值，哪些类型是需要同步到Session域中 <br/>
 * types = Integer.class 表示隐含模型中，值如果是Integer类型，也同步到Session域中<br/>
 */
@SessionAttributes(types = Integer.class)
@Controller
public class ScopeController {

    @RequestMapping(value = "/sessionAttributes")
    public String sessionAttributes(Map<String,Object> map){
        map.put("key1","value1");
        map.put("key2",new Integer(100));

        return "scope_out";
    }
}

jsp页面的输出：

Request 域 key1 的值是： ${ requestScope.key1 } <br>
Reqeust 域 key2 的值是： ${ requestScope.key2 } <br>
Session 域 key1 的值是： ${ sessionScope.key1 } <br>
Session 域 key2 的值是： ${ sessionScope.key2 } <br>

<hr>

8.7、@ModelAttribute注解

@ModelAttribute这个注解可以标注在方法和参数上。

@ModelAttribute三个常见作用：

1、被标注了@ModelAttribute的方法都会在Controller的目标方法之前执行。

2、为目标方法的参数（JavaBean对象）准备一个默认值（从隐含模型中）。

3、被标注在参数上，参数值会按照指定的key从隐含模型中获取值。

@ModelAttribute
public void abc(Map<String,Object> map){
    System.out.println(" 被注解 @ModelAttribute 标识的方法 abc() ");
    map.put("bb",new Book(100,"国哥，最帅！"));
}

/**
 * 会取参数的具体类名，首字母改小写，做为key到隐含模型中去取数据<br/>
 * Book ==>> book
 * @return
 */
@RequestMapping(value = "/target")
public String target(@ModelAttribute(name = "bb") Book book1){
    System.out.println(" Controller控制器中的目标方法 target() ===>>> " + book1);
    return "scope_out";
}

9、传统的增删改查

9.1、准备单表的数据库

drop database if exists springmvc;

create database springmvc;

use springmvc; 

##创建图书表
create table t_book(
	`id` int(11) primary key auto_increment, 	## 主键
	`name` varchar(50) not null,				## 书名 
	`author` varchar(50) not null,				## 作者
	`price` decimal(11,2) not null,				## 价格
	`sales` int(11) not null,					## 销量
	`stock` int(11) not null					## 库存
);


## 插入初始化测试数据
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'java从入门到放弃' , '国哥' , 80 , 9999 , 9);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '数据结构与算法' , '严敏君' , 78.5 , 6 , 13);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '怎样拐跑别人的媳妇' , '龙伍' , 68, 99999 , 52);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '木虚肉盖饭' , '小胖' , 16, 1000 , 50);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'C++编程思想' , '刚哥' , 45.5 , 14 , 95);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '蛋炒饭' , '周星星' , 9.9, 12 , 53);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '赌神' , '龙伍' , 66.5, 125 , 535);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'Java编程思想' , '阳哥' , 99.5 , 47 , 36);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'JavaScript从入门到精通' , '婷姐' , 9.9 , 85 , 95);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'cocos2d-x游戏编程入门' , '国哥' , 49, 52 , 62);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'C语言程序设计' , '谭浩强' , 28 , 52 , 74);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'Lua语言程序设计' , '雷丰阳' , 51.5 , 48 , 82);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '西游记' , '罗贯中' , 12, 19 , 9999);

insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '水浒传' , '华仔' , 33.05 , 22 , 88);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '操作系统原理' , '刘优' , 133.05 , 122 , 188);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '数据结构 java版' , '封大神' , 173.15 , 21 , 81);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'UNIX高级环境编程' , '乐天' , 99.15 , 210 , 810);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , 'javaScript高级编程' , '国哥' , 69.15 , 210 , 810);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '大话设计模式' , '国哥' , 89.15 , 20 , 10);
 
insert into t_book(`id` , `name` , `author` , `price` , `sales` , `stock`) 
values(null , '人月神话' , '刚哥' , 88.15 , 20 , 80); 


## 查看表内容
select id,name,author,price,sales,stock from t_book;

9.2、SpringMVC的单表的增，删，改，查

先创建一个web模块，然后导入需要的jar包：

druid-1.1.9.jar

junit_4.12.jar

mysql-connector-java-5.1.37-bin.jar

org.hamcrest.core_1.3.0.jar

spring-aop-5.2.5.RELEASE.jar

spring-aspects-5.2.5.RELEASE.jar

spring-beans-5.2.5.RELEASE.jar

spring-context-5.2.5.RELEASE.jar

spring-core-5.2.5.RELEASE.jar

spring-expression-5.2.5.RELEASE.jar

spring-jcl-5.2.5.RELEASE.jar

spring-jdbc-5.2.5.RELEASE.jar

spring-orm-5.2.5.RELEASE.jar

spring-test-5.2.5.RELEASE.jar

spring-tx-5.2.5.RELEASE.jar

spring-web-5.2.5.RELEASE.jar

spring-webmvc-5.2.5.RELEASE.jar

在src源码目录下创建jdbc.properties属性配置文件：

user=root
password=root
url=jdbc:mysql://localhost:3306/springmvc
driverClassName=com.mysql.jdbc.Driver
initialSize=5
maxActive=10

在src源码目录下创建springmvc.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"
       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">

    <!-- 配置包扫描 -->
    <context:component-scan base-package="com"></context:component-scan>

    <!-- 加载jdbc.properties属性配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!-- 配置数据库连接池 -->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="username" value="${user}" />
        <property name="password" value="${password}" />
        <property name="url" value="${url}" />
        <property name="driverClassName" value="${driverClassName}" />
        <property name="initialSize" value="${initialSize}" />
        <property name="maxActive" value="${maxActive}" />
    </bean>

    <!-- 配置用于执行sql语句的jdbcTemplate工具类 -->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>


</beans>

测试是否可以访问数据库：

package com.atguigu.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;
import java.sql.SQLException;

@ContextConfiguration(locations = "classpath:springmvc.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringTest {

    @Autowired
    DataSource dataSource;

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
    public void test() throws SQLException {
        System.out.println(dataSource.getConnection());
        System.out.println(jdbcTemplate);
    }

}

编写Bean对象

public class Book {
    private Integer id;
    private String name;
    private String author;
    private BigDecimal price;
    private Integer sales;
    private Integer stock;

}

编写Dao和测试

BookDao接口

package com.atguigu.dao;

import com.atguigu.pojo.Book;

import java.util.List;

public interface BookDao {

    public int saveBook(Book book);

    public int updateBook(Book book);

    public int deleteBookById(Integer id);

    public Book queryBookById(Integer id);

    public List<Book> queryBooks();
}

BookDao实现类：

package com.atguigu.dao.impl;

import com.atguigu.dao.BookDao;
import com.atguigu.pojo.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Override
    public int saveBook(Book book) {
        String sql = "insert into t_book(`name`,`author`,`price`,`sales`,`stock`) values(?,?,?,?,?)";
        return jdbcTemplate.update(sql,book.getName(),book.getAuthor(),book.getPrice(),book.getSales(),book.getStock());
    }

    @Override
    public int updateBook(Book book) {
        String sql = "update t_book set `name`=?,`author`=?,`price`=?,`sales`=?,`stock`=? where id=?";
        return jdbcTemplate.update(sql,book.getName(),book.getAuthor(),book.getPrice(),book.getSales(),book.getStock(),book.getId());
    }

    @Override
    public int deleteBookById(Integer id) {
        String sql = "delete from t_book where id = ?";
        return jdbcTemplate.update(sql,id)  ;
    }

    @Override
    public Book queryBookById(Integer id) {
        String sql = "select `name`,`author`,`price`,`sales`,`stock`,`id` from t_book where id = ?";
        return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
    }

    @Override
    public List<Book> queryBooks() {
        String sql = "select `name`,`author`,`price`,`sales`,`stock`,`id` from t_book";
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
    }
}

测试代码：

package com.atguigu.test;

import com.atguigu.dao.BookDao;
import com.atguigu.pojo.Book;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.math.BigDecimal;

@ContextConfiguration(locations = "classpath:springmvc.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class BookDaoTest {

    @Autowired
    BookDao bookDao;

    @Test
    public void saveBook() {
        bookDao.saveBook(new Book(null,"抖音真经","0713",new BigDecimal(99),100,0));
    }

    @Test
    public void updateBook() {
        bookDao.updateBook(new Book(21,"国哥真经","0713",new BigDecimal(99),10000,0));
    }

    @Test
    public void deleteBookById() {
        bookDao.deleteBookById(21);
    }

    @Test
    public void queryBookById() {
        System.out.println(bookDao.queryBookById(1));
    }

    @Test
    public void queryBooks() {
        bookDao.queryBooks().forEach(System.out::println);
    }
}

编写Service程序和测试

Service接口

package com.atguigu.service;

import com.atguigu.pojo.Book;

import java.util.List;

public interface BookService {

    public void addBook(Book book);

    public void deleteBookById(Integer id);

    public void updateBook(Book book);

    public Book queryBookById(Integer id);

    public List<Book> queryBooks();

}

BookService实现类：

package com.atguigu.service.impl;

import com.atguigu.dao.BookDao;
import com.atguigu.pojo.Book;
import com.atguigu.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    BookDao bookDao;

    @Override
    public void addBook(Book book) {
        bookDao.saveBook(book);
    }

    @Override
    public void deleteBookById(Integer id) {
        bookDao.deleteBookById(id);
    }

    @Override
    public void updateBook(Book book) {
        bookDao.updateBook(book);
    }

    @Override
    public Book queryBookById(Integer id) {
        return bookDao.queryBookById(id);
    }

    @Override
    public List<Book> queryBooks() {
        return bookDao.queryBooks();
    }
}

测试代码：

package com.atguigu.test;

import com.atguigu.pojo.Book;
import com.atguigu.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.math.BigDecimal;

@ContextConfiguration(locations = "classpath:springmvc.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class BookServiceTest {

    @Autowired
    BookService bookService;

    @Test
    public void addBook() {
        bookService.addBook(new Book(null,"社会我国哥，人狠话还多","会所大哥",new BigDecimal(9999),99999,1))   ;
    }

    @Test
    public void deleteBookById() {
        bookService.deleteBookById(22);
    }

    @Test
    public void updateBook() {
        bookService.updateBook(new Book(1,"从入门，到删库跑路","国哥",new BigDecimal(10),1,99999));
    }

    @Test
    public void queryBookById() {
        System.out.println(bookService.queryBookById(1));
    }

    @Test
    public void queryBooks() {
        for (Book queryBook : bookService.queryBooks()) {
            System.out.println(queryBook);
        }
    }
}

在web.xml中先配置前端控制器

<!-- 前端控制器 -->
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

拷贝crud的页面

springmvc.xml配置文件中添加视图解析器

<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/book/" />
    <property name="suffix" value=".jsp" />
</bean>

在首页添加一个请求地址

BookController中的代码

@RequestMapping(value = "/book")
@Controller
public class BookController {

    @Autowired
    BookService bookService;

    @RequestMapping(value = "/queryAll")
    public String queryAll(Map<String,Object> map) {
        // 调用xxxService.xxx()查询全部图书
        List<Book> books = bookService.queryBooks();
        // 保存到Request域中
        map.put("books",books);
        // 请求转发到，/book/bookList.jsp
        return "bookList";
    }

}

到book/bookList.jsp页面中遍历数据

导入jstl标签库的jar包：

taglibs-standard-impl-1.2.1.jar

taglibs-standard-spec-1.2.1.jar

bookList.jsp页面的内容：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>图书列表</title>
      <%
         String basePath = request.getScheme() 
                        + "://"
                        + request.getServerName()
                        + ":"
                        + request.getServerPort()
                        + request.getContextPath()
                        + "/";
      %>
      <base href="<%=basePath %>" />
      <style type="text/css">
         table {
            border: 1px blue solid;
            width: 700px;
            border-collapse: collapse;
         }
         td,th{
            border: 1px green solid;
         }
         div.menu {
            width: 700px;
            text-align: right;
         }
      </style>
   </head>
   <body>
      <center>
         <h2>图书列表管理页面</h2>
         <div class="menu"><a href="#">添加图书</a></div>
         <table>
            <tr bgcolor="#FF8888">
               <th>书名</th>
               <th>作者</th>
               <th>价格</th>
               <th>销量</th>
               <th>库存</th>
               <th>操作</th>
            </tr>
            <%-- c:forEach 遍历数据
                  items是遍历的数据源
                  var 当前正在遍历到的数据
             --%>
            <c:forEach items="${requestScope.books}" var="book">
            <tr>
               <td>${book.name}</td>
               <td>${book.author}</td>
               <td>${book.price}</td>
               <td>${book.sales}</td>
               <td>${book.stock}</td>
               <td><a href="#">删除</a>、<a href="#">修改</a></td>
            </tr>
            </c:forEach>


         </table>
      </center>
   </body>
</html>

其他的就不写了，没必要，写一些需要注意的

在web.xml中添加解决中文乱码的Filter过滤器

<!--
    配置解决中文乱码的Filter
-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <!-- 配置使用哪种字符集，都是UTF-8 -->
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <!-- 是否解决请求的中文乱码 -->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!-- 配置是否解决响应的中文乱码 -->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

解决SpringMVC无法支持静态资源请求的方法：

以后只要使用SpringMVC开发，以下两个标签是标配

<!-- 以后只要使用SpringMVC开发，以下两个标签是标配 -->
<!-- 支持静态资源的请求 -->
<mvc:default-servlet-handler></mvc:default-servlet-handler>
<!-- 配置支持SpringMVC 注解的高级功能 -->
<mvc:annotation-driven></mvc:annotation-driven>