【02】SSM的知识与应用之SpingMVC

XQ_898878888

已于 2024-06-27 07:30:13 修改

阅读量307

点赞数

分类专栏： # SSM 文章标签： mybatis java spring

于 2021-08-15 14:55:07 首次发布

本文链接：https://blog.csdn.net/XQ_898878888/article/details/119696402

版权

SSM 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

1. 项目管理（企业级框架）

1.1 架构图

前端涉及到的技术有：
H5、CSS3、JavaScript，CSS升级为Bootstrap再升级到ElementUI，JavaScript升级到jQuery再升级到Vue+NodeJS。
后端涉及到的技术有：
SpringBoot、Maven、SpringMVC、Spring、Mybatis。
这样前后端都学习完，整个软件项目所需要的基本技术就全线贯通，就可以自己独立完成企业级项目的开发了。

1.2 项目框架图

2. 项目构建工具 Maven

2.1 概述

Maven是跨平台的项目管理工具。作为Apache组织中的一个颇为成功的开源项目，主要服务于基于java平台的项目构建、依赖管理和项目信息管理。

2.2 为什么要使用maven

传统的Java工程中，需要我们自己去找jar包，或者来自官网，或者来自网友的分享，或者来自项目团队的共享，不论何种方式，都需要把jar文件复制到项目工程下的lib目录中，并且buildpath进行引用。

Maven改变这种手动维护jar包的方式，设计出一套自动维护jar包的体系，已经广泛在软件项目中使用，是软件开发人员必须掌握的技术。
Maven作为项目管理工具，主要是管理jar包，包括：jar包的下载，安装，保存。

2.3 Maven的三大特征

2.3.1 仓库 repository

Maven是分布式架构，它有三大仓库：
中央仓库：是一个国外网址，全球开发者都可以连接它来自动下载jar包。
镜像仓库：就是一个国内的网址,一些大公司去连接中央仓库把下载好的所有jar包，存到自己的服务器里。(华为/阿里)
本地仓库：需要自己创建一个文件夹，用来存储从镜像仓库中下载好的一些jar包.。

当用户需要某个jar包时，先到本地仓库寻找，如果没有再去镜像仓库，最后再没有就去中央仓库。中央仓库找到后，并不是直接返回到本地仓库，而是保存一份到镜像仓库，镜像仓库返回本地仓库，本地仓库也保存一份，然后返回给调用者。

2.3.2 坐标

坐标：存jar包的唯一定位的方式。

	- groupId指定了jar包的组id
	- artifactId指定了jar包的项目id
	- version指定了jar包的版本

2.3.3 依赖 dependency

每个核心jar包形成一个依赖，maven底层对它进行相关的jar包的自动导入。
例如，添加mysql的依赖：

<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.21</version>
	</dependency>

管理jar包常用的命令说明

clean 清理
compile 编译
test 测试
site 站点文档
package 打包jar、war
deploy 部署到私服
install 安装jar到本地仓库中
run 运行

2.4 Maven的使用

2.4.1 下载Maven

官网： http://maven.apache.org
下载：apache-maven-3.6.3.bin.tar.gz

2.4.2 相关配置

第一步：解压maven3.6的压缩包
第二步：修改conf/settings.xml配置文件

（1）修改本地仓库：
${user.home}/.m2/repository表示maven默认的本地仓库，下载的jar包都在这个目录里。
推荐修改仓库目录—— 例如：G:\JAVA\maven\evn

   <localRepository>G:\JAVA\maven\evn</localRepository>

（2）修改镜像仓库:配置阿里云的网址

 <mirror>
	<id>alimaven</id>
	<name>aliyun maven</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	<mirrorOf>central</mirrorOf>       
    </mirror>

2.4.3 在eclipse中使用maven

（1）windows——>preferences——>Maven
（2）Maven配置：
进入eclipse的preferences菜单，选中Maven项，将“Download Artifact Sources”打钩。
a.选择源码 Download Artifact Sources（自动下载对应源码包，看源码就可以直接看）
b.在Installations中选择安装路径，添加到eclipse中，打钩关联。
c.选择settings.xml文件（修改过的），如果目录变化，就代表安装成功。

2.4.4 pom.xml文件

Maven工程的特点就是在根目录下多了个pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.tedu</groupId>
  <artifactId>jk</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</project>

2.4.5 创建maven工程

2.5 maven依赖的说明

使用依赖后，maven会自动给我们下载jar包。
jar的出处：它是你配置的maven环境，它默认到中央仓库（镜像仓库：阿里云）下载。
Maven发明仓库、依赖、坐标，目的就是来管理jar包，自动管理。
坐标：起到区分的作用，每级坐标就是一个目录，最终jar包就放在这个多级目录中。
SpringBoot它利用官网：start.spring.io，输入关键字，加入依赖，它自动会升到最高版本。一旦使用SpringBoot技术，就会被牵着鼻子走，它会把所有它的依赖更新到最新。
副作用：版本不兼容，需要小范围修改个别代码。
依赖在pom.xml保存时，就自动下载。pom.xml有检查语法，如果没问题，就会下载所有依赖，jak需要提升到jdk1.8，一旦jar包在仓库中，无需再次下载。

3. SpringBoot

3.1 概述

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。
其具有一下特点：

创建独立的Spring应用程序
嵌入的Tomcat，无需部署WAR文件
简化Maven配置
自动配置Spring
SpringBoot全面接管项目启动和加载

3.2 SpringBoot全新的pom.xml

它产生整个项目目录，其实我们只需要pom.xml文件覆盖本地maven工程的pom.xml文件。
修改pom.xml后，把项目进行maven-update 操作，下载依赖的jar包。
注：可以使用idea直接创建springboot项目，其本质也是去调用上面的网站，只不过在本地访问外网https://start.spring.io。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.tedu</groupId>
	<artifactId>jk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>jk</name>
	<description>Demo project for Spring Boot</description>

  	<!-- 提供相关的 Maven 默认依赖 -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<!-- 使用jdk8 -->
		<java.version>1.8</java.version>
	</properties>
	
	<!-- 添加依赖 -->
	<dependencies>
		<!-- 使用springmvc构建程序并使用默认的嵌入式容器Tomcat -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<!-- 使用Junit测试springboot程序 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
	</dependencies>

	<build>
		<!-- 添加插件 -->
		<plugins>
			<!-- springboot添加maven插件,会打包成一个可以直接运行的 JAR 文件,直接部署到服务器 -->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

4. Spring MVC

4.1 Spring Mvc框架的概述

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架或集成其他MVC开发框架。

4.2 MVC模型

SpringMVC就是基于MVC设计模式来实现的。

MVC(Model模型、View视图、Control控制层)，将软件进行分层达到松耦合的效果。
现在主流基于SSM三大框架开发都是在MVC上继续演化，又分为持久层DAO，业务层Service，控制层Controller。
持久层用来和数据库读写ORM，业务层用来处理复杂的业务逻辑，控制层用来处理MVC的控制。
通用的软件编程思想, 在MVC设计模式中认为, 任何软件都可以分三层：数据处理模型（Model）、负责展示数据的视图（View）、控制层
（Controller）。
在MVC设计思想中要求一个符合MVC设计思想的软件应该保证上面这三部分相互独立，互不干扰，每一个部分只负责自己擅长的部分。如果某一个模块发生变化，应该尽量做到不影响其他两个模块。提高代码的可读性，实现程序间的松耦合、提高代码复用性。

4.3 工作原理

在这里插入图片描述

SpringMVC要完成框架的任务，里面有很多组件：
1)DispatcherServlet，底层是java web的规范，Servlet，封装。把请求进行分发，找到对应的类里的方法进行执行。
2)HandlerMapping，处理器映射器，负责url的解析。根据url找到对应的类中的方法进行执行。
3)HandlerAdapator，处理器适配器，负责找到Controller。
4)Controller，实现request请求的映射，调用它的业务方法，最终响应reponse。
4)最后返回ModelAndView的对象，这个对象其实已经被替代了，最终返回java对象。
具体过程（重点内容）：

用户发送请求至前端控制器DispatcherServlet ——> DispatcherServlet收到请求调用HandlerMapping处理器映射器 —— >

处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给

DispatcherServlet —— > DispatcherServlet调用HandlerAdapter处理器适配器 ——> HandlerAdapter经过适配调用具体的处理器

(Controller，也叫后端控制器) ——> Controller执行完成并返回ModelAndView ——> andlerAdapter将controller执行结果ModelAndView返回

给DispatcherServlet ——> DispatcherServlet将ModelAndView传给ViewReslover视图解析器 ——> ViewReslover解析后返回具体View

——> DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中) ——> DispatcherServlet响应用户。

4.4 入门案例

展示汽车数据：
需求：
访问链接： http://localhost:8080/car/get
得到JSON数据： {“id”:718,“name”:“保时捷”,“type”:“Cayman T”,“color”:“红色”,“price”:641000.0}

4.4.1 创建maven工程

4.4.2 创建主启动类RunApp.java

package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RunApp {
    public static void main(String[] args) {
        SpringApplication.run(RunApp.class, args);
    }
}

4.4.3 创建主体类pojo.Car

package cn.tedu.pojo;

public class Car {
    private Integer id;		//718
    private String name;		//保时捷
    private String type;		//Cayman T
    private String color;		//红色
    private Double price;	//641000


    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [id=" + id + ", name=" + name + ", type=" + type + ", color=" + color + ", price=" + price + "]";
    }
}

4.4.4 创建请求控制类CarController.java

package cn.tedu.controller;

import cn.tedu.pojo.Car;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController //接受请求，并返回json数据
@RequestMapping("/cars/") //规定了url的访问路径
public class CarController {
    @GetMapping("/get")
    public Car getCar(){
        Car car = new Car();
        car.setId(718);
        car.setName("保时捷");
        car.setType("Cayman T");
        car.setColor("红色");
        car.setPrice(641000.0);

        return car;
    }
}

4.4.5 测试

http://localhost:8080/cars/get

结果：

4.6 SpringMVC解析请求参数

传统解析参数的方法：

public void getParm1(){//自己解析参数
        String url = "http://localhost:8080/car/get?id=10&name=BM&price=9.9";
        String[] s = url.split("\\?")[1].split("&");
        for (String str : s){
            String key = str.split("=")[0];
            String value = str.split("=")[1];
            System.out.println(key:value);
        }
    }

使用springmvc解析参数的方法：
Get的提交方式

@RestController
@RequestMapping("/cars/")
  @RequestMapping("/getParm2")
    public String getParm2(Integer id,String name,Car car){//使用SpringMVC框架来解析参数,数据类型要使用引用类型，可以避免一些异常。
        System.out.println("解析到参数为："+id+"--"+name);
        System.out.println("解析到对象为："+car.getId()+car.getName());
        return "传参成功！" ;
    }

4.7 处理请求参数的方式

当客户端打开浏览器要访问服务器时,可能会带着一些http请求参数过来，这时,服务器需要获取http参数进行业务处理。
总共有8种请求方式，常用的两种方式：GET方式和POST方式。

4.7.1 Get请求方式

向特定的资源发出请求，并返回实体，有固定的写法，而且数据有最大长度，不能超出。可以在浏览器地址栏看到携带的参数。
第一个参数：？参数1，后面的多个参数：&参数2&参数3&参数4…
例如：http://localhost:8080/car/insert?id=1&name=张三&age=18

创建前后端关联，利用get请求方式：

前端代码:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>get方式提交参数</title>
	</head>
	<body>
		<div> <a href="http://localhost:8080/cars/getParm4?id=10&name=Boss&age=20">点我可以get方式提交数据</a></div>
	</body>
</html>

后端代码：

  //将解析的参数存入数据库
@RestController
@RequestMapping("/cars/")
   @RequestMapping("/getParm4")
    public String getParm4(Integer id,String name,String age) throws Exception {
        //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取链接
        String url ="jdbc:mysql:///school-system?characterEncoding=utf8&amp;serverTimezone=Asia/Shanghai";
        Connection con = DriverManager.getConnection(url,"root","root");
        //3.获取传输器
        String sql = " insert into user values(?,?,?)";//所有字段设置值
        PreparedStatement ps = con.prepareStatement(sql);
        //4.给sql设置参数
        ps.setInt(1, id);
        ps.setString(2, name);
        ps.setString(3, age);
        //5.执行SQL
        int rows = ps.executeUpdate();
        System.out.println("新增完成");
        //6.释放资源
        con.close();
        return "解析到参数为："+id+"——"+name+"——"+age ;
    }

4.7.2 Post请求方式

向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中，是不能直接看到参数的。POST请求可能会导致新资源的建立或已有资源的修改。

创建前后端关联（提交表单），使用post请求方式：
前端代码：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>学生信息注册表</title>
		
<!--引入外部第三方css文件，rel固定值：样式表，href表示链接地址.
    .min意思是最小文件，压缩（把文件所有内容换行和空格缩进都去掉）-->
		<link rel="stylesheet" href="css/bootstrap.min.css"/>
	</head>
	<body>
		<!-- action指定提交到后台的链接地址，method:get/post请求方式  -->
		<form action="http://localhost:8080/stu/add" method="post">	
		<h2 style="padding-left: 800px;">学生管理系统</h2>
		<div class="container"> 	
			<div class="form-group">	
				<label for="id">学号</label>
				<input type="text" name="id" id="id"  class="form-control" placeholder="请输入学号..."/>	
		<!--label标签，for属性可以光标定位，点击后可以对应相应的id框-->
				<label for="name">姓名：</label>   
		<!--文本输入框，h5新特性placeholder属性-->
				<input type="text" name="name" id="name"  class="form-control" placeholder="请输入姓名..."/>	
			</div>
			
			<div class="form-group">
				<label for="age">年龄</label> 
				<input type="number" name="age" id="age" class="form-control" placeholder="请输入年龄...">
			</div>
			
			<div class="form-group">
				<label for="sex">性别：（单选框）</label>
		        <!--radio互斥,同名只能选择一个	-->
				<div class="radio-inline">
				<input type="radio" name="sex" id="sex" value="1" checked="checked"/> 男 </div>
				<div class="radio-inline">
				<input type="radio" name="sex" id="sex" value="0" /> 女 </div>
			</div>
			
			<div class="form-group">
				<label for="hobby">爱好：(多选)</label>
				<div class="checkbox-inline">
				<input type="checkbox" name="hobby" value="钓鱼" id="hobby"/> 钓鱼 
				</div>
				<div class="checkbox-inline">
				<input type="checkbox" name="hobby" value="乒乓球" id="hobby" />乒乓球 
				</div>
				<div class="checkbox-inline">
				<input type="checkbox" name="hobby" value="羽毛球" id="hobby" />羽毛球 
				</div>
			</div>
			
			<div class="form-group">
				<label>学历：（下拉框）</label>
				<!--单选，选择"幼儿园"，表单提交“1”，性能提高-->
				<select name="edu" id="edu">
					<option value="1">幼儿园</option>
					<option value="2">小学</option>
					<option value="3">初中</option>
					<option value="4">高中</option>
					<option value="5">大专</option>
					<option value="6" selected="selected">本科</option>
					<option value="7">研究生</option>
					<option value="8">博士</option>
				</select>
			</div>
			
			<div>
				<tr>
				    <td>
				         入学日期:
				    </td>
				    </tr>
				    <tr>
				        <td>
				           <input type="date" name="intime"/>
				        </td>
				    </tr>
			</div>
			
			<div class="form-group">
				<!--class属性支持多个样式，样式之间用空格隔开,btn和btn-primary是两个样式-->
				<input class="btn btn-primary" type="submit" name="submit" value="保存"/>
				<button class="btn btn-danger" name="clear">取消</button>
			</div>
		</div>
		</form>
	</body>
</html>

后端代码：
student类：

/**
 * 充当MVC中的M层，用来封装数据(数据要与页面上的name属性一致)
 */
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private String[] hobby;
    private String edu;
    @DateTimeFormat(pattern="yyyy-MM-dd")
    //网页上的日期是string,注解用来转换格式,不然400错误
    private Date intime;
    }

studentcontroller类：

/**
 * 充当MVC中的C层，接收请求，处理响应
 */

@RestController
@CrossOrigin //放行所有请求，解决跨域问题
@RequestMapping("/stu/")
public class StudentController {

    @RequestMapping("/add")
    public Object add(Student stu){
        return "已从表单获取到提交信息为："+stu;
    }
}

运行结果：

改造成Ajax提交post请求的数据
第一步：把form标签的内容改成：<form action="#" method="post" id="f1">
第二步：把提交按钮的内容改成：<input type="button" value="保存" onclick="fun();"/>
第三步：添加Aiax代码。
注意：这个过程可能存在跨域问题，需要在controller类上添加注解：@CrossOrigin 它会放行所有请求，解决跨域问题

<!--1. 使用jQuery提供的ajax，导入jQuery提供的函数库 -->
<script src="jquery-1.8.3.min.js"></script>
<!--2. 开始写ajax的代码 -->
<script>
	function fun(){
		$.ajax({
			url: "http://localhost:8080/stu/add" , //指定要请求的路径 
			data: $("#f1").serialize()  , //请求时要携带的参数，serialize表示使参数序列化
			success: function(data){ //成功时会回调的函数
				alert(data);
			}
		});
	}
</script>

4.7.3 RESTFul方式（推荐）

为了简化GET请求的写法,可以使用RESTFul方式,用法:
1、通过{}绑定地址中的参数位置。
2、再使用注解@PathVariable绑定值，来获取请求路径中这个{}位置的参数值。
3、以前GET的访问方式即将被简化成：http://localhost:8080/car/insert/1/张三/18

@RestController
@RequestMapping("/cars/")
  //使用RESTFul来解析参数：通过{}绑定地址中的参数位置,注解@PathVariable来获取这个{}位置的值。
    @RequestMapping("/getParm3/{id}/{name}/{age}/{sex}/{address}/{school}")
    public String getParm3(@PathVariable Integer id,
                           @PathVariable String name,
                           @PathVariable Integer age,
                           @PathVariable String sex,
                           @PathVariable String address,
                           @PathVariable("school") String university){ //RESTFul方式提交数据,
        // 如果地址中的参数名与方法中的形参名对应不一致时，可在@PathVariable注解后+("school")说明
        
       Integer ID = id;
       String Name = name;
       Integer Age = age;
       String Sex = sex;
       String Address = address;
       String University = university;

       return ("解析到参数为："+ID+"——"+Name+"——"+Age+"——"+Sex+"——"+Address+"——"+University);
    }

4.8 SpringMVC的实例

4.8.1 框架图

4.8.2 实现过程

第一步：写前端网页

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>实现MVC的结构</title>
	</head>
	<body>
		<a href="http://localhost:8080/car/get">点我提交请求</a>
	</body>
</html>

第二步：创建工程

第三步：创建RunApp启动类

@SpringBootApplication
public class RunApp {
    public static void main(String[] args) {
        SpringApplication.run(RunApp.class, args);
    }
}

第四步：创建Car类

package cn.tedu.pojo;
import org.springframework.stereotype.Component;

//POJO 类，充当了MVC里的M，用来封装数据
@Component //spring的注解，用来ioc(new)
public class Car {
    private String name ;
    private String color ;
    private Double price ;//用引用类型，避免springmvc请求时抛出异常

    //get set toString
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                '}';
    }
}

第五步：创建CarService 接口

package cn.tedu.service;

import cn.tedu.pojo.Car;
import org.springframework.stereotype.Service;

//业务层的接口
@Service
public interface CarService {
    //获取汽车数据
    Car getCar();
}

第六步：创建CarServiceImpl实现类

package cn.tedu.service;

import cn.tedu.pojo.Car;
import org.springframework.stereotype.Component;

@Component //交给Spring容器进行IOC
//实现类实现接口的所有抽象方法
public class CarServiceImpl implements CarService{
    @Override
    public Car getCar() {
        Car car = new Car();
        car.setName("路虎揽胜");
        car.setColor("白色");
        car.setPrice(1550000.0);
        return car;
    }
}

第七步：创建CarController 类


@RestController
@RequestMapping("/car")
public class CarController {

    @Autowired
    private CarService carService; //依赖注入，自动装配

    @GetMapping("/getCar")
    public Car getCar(){
        Car c = carService.getCar();//实现都在业务层，直接调用即可。
        return c;
    }
}

第八步：测试

4.9 SpringMVC 小结分析

4.9.1 原理

见上面4.3 工作原理

4.9.2 常用注解

@RestController：接收用户的请求，并响应json数据。
@RequestMapping: 与请求路径匹配
@PathVariable：获取RESTFul里的各个位置上的参数值
@CrossOrigin：解决跨域问题(IP不同或者端口不同)
@ResponseBody：返回对象并利用jackson工具类将其转换为json字符串
@RequestParam：当参数名与请求参数名不同时可自行指定名称进行注入，可以设置默认值

4.9.3 解析参数

SpringMVC 可以处理一个参数，也可以处理多个参数。如果需要，也可以把多个参数封装成一个java对象。
可以用GET方式提交数据，在Controller层直接用方法的参数列表，匹配解析就可以了。
可以用Restful方式提交数据，在Controller层,使用@PathVariable注解获取地址栏里对应的值，直接用方法的参数列表匹配解析就可以了。
可以用POST方式提交数据，在Controller层直接用java对象接受请求参数就可以了。