如有侵权请联系删除
这是个人通过网上教学视频的总结：视频网址：https://www.bilibili.com/video/BV1mE411X7yp?p=164
Springmvc从头到尾讲解
以下是一些案例中用到的资料，如果有兴趣的可以下载以下
链接: https://pan.baidu.com/s/1bV0RbnkB0ww2karAquwh2A 提取码: funa
这个作者视频讲的很详细有空可以关注一下啊
首先以上的图片是服务器分为的三大框架，还有大概的运行顺序，接下来给大家讲解一下MVC（该博客讲解主要以截图为重）
什么是springmvc
Springmvc的优点
idea开发工具 Springmvc入门
首先我们先进行搭建环境
- 创建WEB工程，引入开发的jar包
在pom文件里面引入以下jar包注（里面只需要添加一个版本号即可）
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
//下面的这段代码是为了写一个版本号，这样jar包就不用重复写版本号了
<spring.version>5.0.2.RELEASE</spring.version>
</properties>
<dependencies>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency>
<dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope> </dependency>
</dependencies>```
- 在webapp/WEB-INF/web.xml配置核心的控制器（配置DispatcherServlet）
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<!-- 加载这个类路径下的配置文件 -->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 以后启动服务器就可以创建这个对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!--/ 表示你发任何请求都会经过这个servlet-->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
- 在resource文件中创建springmvc.xml文件，并且编写springmvc.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xontext="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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启注解扫描 -->
<xontext:component-scan base-package="cn.lc"/>
<!-- 配置 试视图解析器用来识别controller返回对象，也就是跳转到对应jsp id随便定义-->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- prefix:表示文件所在的目录 suffi表示文件的后缀名-->
<property name="prefix" value="/WEB-INF/pages/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!-- 开启springmvc框架注解的支持 -->
<mvc:annotation-driven/>
</beans>
接下来进行一个小案例练习
- 编写index.jsp和HelloController控制器类，结构如下图所示
a：index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>入门程序</h3>
<a href="hello">入门程序</a>
</body>
</html>
b：HelloController控制类
package cn.lc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//控制器
//把这个类交给ioc容器
@Controller
public class HelloController {
//请求的映射
@RequestMapping(path="/hello")
public String sayHello(){
System.out.println("hello stringmvc");
return "success";
}
}
c：WEB-INF目录下创建pages文件夹，编写success.jsp的成功页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>入门成功了</h3>
</body>
</html>
- 入门案例的执行流程
- 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件
- 开启了注解扫描，那么HelloController对象就会被创建
- 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到执行的具体方法
- 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
- Tomcat服务器渲染页面，做出响应
- SpringMVC官方提供图形
- 入门案例中的组件分析
- 前端控制器（DispatcherServlet）
- 处理器映射器（HandlerMapping）
- 处理器（Handler）
- 处理器适配器（HandlAdapter）
- 视图解析器（View Resolver）
- 视图（View）
- RequestMapping注解
- RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
- RequestMapping注解可以作用在方法和类上
- 作用在类上：第一级的访问目录
- 作用在方法上：第二级的访问目录
- 细节：路径可以不编写 / 表示应用的根目录开始
- 细节：${ pageContext.request.contextPath }也可以省略不写，但是路径上不能写 /
- RequestMapping的属性
- path 指定请求路径的url
- value value属性和path属性是一样的
- mthod 指定该方法的请求方式
- params 指定限制请求参数的条件
- headers 发送的请求中必须包含的请求头
请求参数绑定
绑定机制
- 表单提交的数据都是k=v格式的 username=haha&password=123
- SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
- 要求：提交表单的name和参数的名称是相同的
支持的数据类型
- 基本数据类型和字符串类型（分别有对应的代码解析）
a:在webapp下创建一个params.jsp（名字随便定义）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--请求参数绑定--%>
<a href="param/testParam?username=hehe">请求参数绑定</a>
</body>
</html>
b:在controller包中创建一个Paramcontroller
package cn.lc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/*
请求参数的绑定
*/
@Controller
@RequestMapping("/param")
public class ParamController {
@RequestMapping("/testParam")
public String testParam(String username){
System.out.println("执行了。。。");
System.out.println("用户名=："+username);
return "success";
}
}
注意：如果在jsp里面存在username这个值那么在controller也必须添加否则无法执行
- 实体类型（JavaBean）
把之前params.jsp修改一下就好
<-- 这个是为了可以防止输出中文的时候出现乱码 -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--请求参数绑定
<a href="param/testParam?username=hehe">请求参数绑定</a>--%>
<form action="param/saveAccount" method="post">
姓名：<input type="text" name="username"><br/>
密码：<input type="text" name="password"><br/>
金额：<input type="text" name="money"><br/>
<input type="submit" value="提交"/>
</form>
</body>
</html>
b：在ParamController增加一个方法代码如下
/*
把数据封装到 javabean的类中
*/
@RequestMapping("/saveAccount")
public String saveAccount(Account account){
System.out.println("执行了。。。");
System.out.println(account);
return "success";
}
- 集合数据类型（List、map集合等）
a：修改之前的jparams.jspsp文件
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="param/saveAccount" method="post">
姓名：<input type="text" name="username"><br/>
密码：<input type="text" name="password"><br/>
金额：<input type="text" name="money"><br/>
<%-- 把user对象存到list集合中下标为0的里面 --%>
用户姓名：<input type="text" name="list[0].uname"><br/>
用户年龄：<input type="text" name="list[0].age"><br/>
用户姓名：<input type="text" name="map['one'].uname"><br/>
用户年龄：<input type="text" name="map['one'].age"><br/>
<input type="submit" value="提交"/>
</form>
</body>
</html>
b：修改一下封装类Account前几个步骤没有写不过都用的是一个封装类
package cn.lc.domain;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
public class Account implements Serializable {
private String username;
private String password;
private Double money;
//private User user;
private List<User> list;
private Map<String,User> map;
public List<User> getList() {
return list;
}
public void setList(List<User> list) {
this.list = list;
}
public Map<String, User> getMap() {
return map;
}
public void setMap(Map<String, User> map) {
this.map = map;
}
// public User getUser() {
// return user;
// }
//
// public void setUser(User user) {
// this.user = user;
// }
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", money=" + money +
", list=" + list +
", map=" + map +
'}';
}
}
基本数据类型和字符串类型
- 提交表单的name和参数的名称是相同的
- 区分大小写
实体类型
- 提交表单的name和JavaBean中的属性名称需要一致
- 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对象.属性 例如： address.name
给集合属性封装数据
- JSP页面编写方式：list[0].属性
请求参数中文乱码的解决
只需要在web.xml文件里面加上以下的配置就好
<!-- 配置解决中文乱码的过滤器 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
自定义类型转换器
- 表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，说明
Spring框架内部会默认进行数据类型转换。 - 如果想自定义数据类型转换，可以实现Converter的接口
- 自定义类型转换器（日期格式）
代码体验一下
创建一个StringToDateConverter类但是必须继承Converter接口，这是规定
package cn.lc.utils;
import org.springframework.core.convert.converter.Converter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把字符串转换为日期
*/
public class StringToDateConverter implements Converter<String, Date>{
/**
* String source 传入进来字符串
* @param source
* @return
*/
@Override
public Date convert(String source) {
if(source == null){
throw new RuntimeException("请您传入数据");
}
//转换时间格式
SimpleDateFormat df = new SimpleDateFormat("yyyy-mm-dd");
//把字符串转换为日期
try {
return df.parse(source);
} catch (Exception e) {
throw new RuntimeException("数据类型转换出现错误");
}
}
}
接下里第二步：注册自定义类型转换器，在springmvc.xml配置文件中编写配置
<!-- 配置自定义的类型转换器 id的值可以随便写-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="cn.lc.utils.StringToDateConverter"></bean>
</set>
</property>
</bean>
<!-- 开启springmvc框架注解的支持 配置conversion-service="conversionService"是为了让自定义的类型转换器生效-->
<mvc:annotation-driven conversion-service="conversionService"/>
运行结果
接下来的案列我都会把案例结果附图，上面案列因为时间关系没有附图和运行结果，还请大家理解
在控制器中使用原生的ServletAPI对象
只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象
接下来代码演示走一波
a: 首先把params.jsp的代码进行修改
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--请求参数绑定
<a href="param/testParam?username=hehe">请求参数绑定</a>--%>
<%--<form action="param/saveAccount" method="post">--%>
<%-- 姓名：<input type="text" name="username"><br/>--%>
<%-- 密码：<input type="text" name="password"><br/>--%>
<%-- 金额：<input type="text" name="money"><br/>--%>
<%-- 用户姓名：<input type="text" name="user.uname"><br/>--%>
<%-- 用户年龄：<input type="text" name="user.age"><br/>--%>
<%-- <input type="submit" value="提交"/>--%>
<%--</form>--%>
<%--把数据封装Account类中，类中存在list个map的集合
<form action="param/saveAccount" method="post">
姓名：<input type="text" name="username"><br/>
密码：<input type="text" name="password"><br/>
金额：<input type="text" name="money"><br/>
<%-- 把user对象存到list集合中下标为0的里面
用户姓名：<input type="text" name="list[0].uname"><br/>
用户年龄：<input type="text" name="list[0].age"><br/>
用户姓名：<input tsaveUserype="text" name="map['one'].uname"><br/>
用户年龄：<input type="text" name="map['one'].age"><br/>
<input type="submit" value="提交"/>
</form>--%>
<%--自定义类型转换器
<form action="param/saveUser" method="post">
用户姓名：<input type="text" name="uname"><br/>
用户年龄：<input type="text" name="age"><br/>
用户生日: <input type="text" name="date"/><br/>
<input type="submit" value="提交"/>
</form>--%>
<a href="param/testServlet">Servlet原生的API</a>
</body>
</html>
b：在ParamController增加一个testServlet方法
/*
Servlet原生态API获取
找想要查询的类ctrl+n
*/
@RequestMapping("/testServlet")
//想要获取API直接在方法里面写入想要获取的参数即可
public String testServlet(HttpServletRequest request, HttpServletResponse response){
System.out.println("执行了。。。");
System.out.println(request);
HttpSession session = request.getSession();
System.out.println(session);
ServletContext servletContext = session.getServletContext();
System.out.println(servletContext);
System.out.println(response);
return "success";
}
启动服务器出现以下图片
编译结果如下图所示
接下来和大家分享一些常用的注解
1.RequestParam注解
作用：把请求中的指定名称的参数传递给控制器中的形参赋值
属性
value：请求参数中的名称
required：请求参数中是否必须提供此参数，默认值是true，必须提供
代码如下
a：在webapp下面创建一个anno.jsp
<html>
<head>
<title>Title</title>
</head>
<body>
<%--常用的注解 在下面的超链接当中有一个username--%>
<a href="anno/tesRtequestParam?name=haha"?>RequestParam</a>
</html>
b：在package cn.lc.controller;包下创建AnnoController类
package cn.lc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
@RequestMapping("/anno")
public class AnnoController {
@RequestMapping("/tesRtequestParam")
//前面我们说过如果jsp里面有username=“”这段代码，那么意味着方法的参数里面也许要有对应的username，否则返回的是一个null
//@RequestParam这个注解就是为了让方法里面参数的值随便些，不需要和jsp里面的保持一致，但是注解中name的值必须和jsp里面传入的名字保持一致
public String tesRtequestParam(@RequestParam(name="name") String username){
System.out.println("执行了");
System.out.println(username);
return "success";
}
}
注意：
前面我们说过如果jsp里面有username=“”这段代码，那么意味着controller层中方法的参数里面也必须要有对应的username，否则返回的是一个null
@RequestParam这个注解就是为了让方法里面参数的值随便些，不需要和jsp里面name的保持一致，但是注解中name的值必须和jsp里面传入的名字保持一致
启动服务器出现如下图片
idea控制台输出结果
2.RequestBody注解
作用：用于获取请求体的内容（注意：get方法不可以）
属性
required：是否必须有请求体，默认值是true
代码如下
a: 在anno.jsp中添加代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--常用的注解--%>
<a href="anno/tesRtequestParam?name=哈哈"?>RequestParam</a>
<br>
<form action="anno/tesRtequestBody" method="post">
用户姓名：<input type="text" name="username"><br/>
用户年龄：<input type="text" name="age"><br/>
<input type="submit" value="提交"/>
</form>
</html>
b：在AnnoController类中添加测试注解tesRtequestBody方法
/**
* 获取到请求体的内容
* @param body
* @return
*/
@RequestMapping("/tesRtequestBody")
//@RequestBody表示我想拿到anno.jsp中的请求体的内容
public String tesRtequestBody(@RequestBody String body){
System.out.println("执行了");
System.out.println(body);
return "success";
}
启动服务器
idea控制器输出结果
3. PathVariable注解
作用：拥有绑定url中的占位符的。例如：url中有/delete/{id}，{id}就是占位符
2. 属性
value：指定url中的占位符名称
Restful风格的URL
请求路径一样，可以根据不同的请求方式去执行后台的不同方法
restful风格的URL优点
结构清晰
符合标准
易于理解
扩展方便
代码如下（在之前的代码中直接添加新代码有重复代码可忽略）
a：在anno.jsp中写如下代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--常用的注解--%>
<a href="anno/tesRtequestParam?name=哈哈"?>RequestParam</a>
<br>
<form action="anno/tesRtequestBody" method="post">
用户姓名：<input type="text" name="username"><br/>
用户年龄：<input type="text" name="age"><br/>
<input type="submit" value="提交"/>
</form>
<a href="anno/testPathVariable/10">testPathVariable</a>
</html>
b：在AnnoController添加testPathVariable方法
/**
* @PathVariable注解
* @param id
* @return
*/
@RequestMapping("/testPathVariable/{sid}")
//@RequestBody表示我想拿到anno.jsp中的请求体的内容
public String testPathVariable(@PathVariable(name = "sid") String id){
System.out.println("执行了");
System.out.println(id);
return "success";
}
4. RequestHeader注解
作用：获取指定请求头的值
属性
value：请求头的名称
代码解析如下：
a：在anno.jsp中写如下代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--常用的注解--%>
<a href="anno/tesRtequestParam?name=哈哈"?>RequestParam</a>
<br>
<form action="anno/tesRtequestBody" method="post">
用户姓名：<input type="text" name="username"><br/>
用户年龄：<input type="text" name="age"><br/>
<input type="submit" value="提交"/>
</form>
<a href="anno/testPathVariable/10">testPathVariable</a>
<br>
<a href="anno/testRequestHeader">RequestHeader</a>
</html>
b：在AnnoController类中添加testRequestHeader方法
/**
* testRequestHeader注解
* @param header
* @return
*/
@RequestMapping("/testRequestHeader")
//@RequestBody表示我想拿到anno.jsp中的请求体的内容
public String testRequestHeader(@RequestHeader(value = "Accept") String header){
System.out.println("执行了");
System.out.println(header);
return "success";
}
启动服务器
idea编译器显示如下图所示
5. CookieValue注解
作用：用于获取指定cookie的名称的值
属性
value：cookie的名称
a：在anno.jsp中写如下代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--常用的注解--%>
<a href="anno/tesRtequestParam?name=哈哈"?>RequestParam</a>
<br>
<form action="anno/tesRtequestBody" method="post">
用户姓名：<input type="text" name="username"><br/>
用户年龄：<input type="text" name="age"><br/>
<input type="submit" value="提交"/>
</form>
<a href="anno/testPathVariable/10">testPathVariable</a>
<br>
<a href="anno/testRequestHeader">RequestHeader</a>
<a href="anno/testCookieValue">CookieValue</a>
<br>
</html>
b：在AnnoController类中添加testCookieValue方法
/**
* testRequestHeader注解
* @param cookieValue
* @return
*/
@RequestMapping("/testCookieValue")
//@RequestBody表示我想拿到anno.jsp中的请求体的内容
public String testCookieValue(@CookieValue(value = "JSESSIONID") String cookieValue){
System.out.println("执行了");
System.out.println(cookieValue);
return "success";
}
idea控制器输出如下
6. ModelAttribute注解
作用：
- 出现在方法上：表示当前方法会在控制器方法执行前先执行。
- 出现在参数上：获取指定的数据给参数赋值。
应用：
3. 当提交表单数据不是完整的实体数据时，保证没有提交的字段使用数据库原来的数据。
首先我们用代码解析执行以下这个注解的第一个作用
a：老规矩在anno.jsp里面添加如下代码
<form action="anno/testModelAttribute" method="post">
用户姓名：<input type="text" name="username"><br/>
用户年龄：<input type="text" name="age"><br/>
<input type="submit" value="提交"/>
</form>
<br>
b：在AnnoController里面添加一个testModelAttribute方法
/**
* ModelAttribute 注解
* @param
* @return
*/
@RequestMapping("/testModelAttribute")
//@RequestBody表示我想拿到anno.jsp中的请求体的内容
public String testModelAttribute(){
System.out.println("testModelAttribute执行了");
return "success";
}
//下面这个方法会先执行
@ModelAttribute
public void showUser(){
System.out.println("showUser执行了");
}
运行服务器以下结果
控制台编译结果
在这里看出加ModelAttribute注解的这个方法会先执行
接下来我们进行第二个作用的代码解析
直接修改AnnoController中的代码
@ModelAttribute
public User showUser(String uname){
System.out.println("showUser执行了");
//通过用户查询数据库（模拟）
User u = new User();
u.setUname(uname);
u.setAge(20);
u.setDate(new Date());
return u;
}
启动服务器
idea编译运行结果为
以上内容是第一部分讲解，接下来进行第二部分
首先我们先进行环境搭建
创建一个项目springmvc_day02_01_response1（名字可以随便写）
1.按照第一部分的配置来写一遍
注意（别忘记在java中创建两个文件）
2.配置pom文件
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>springmvc_day02_01_response1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>springmvc_day02_01_response1 Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<spring.version>5.0.2.RELEASE</spring.version>
</properties>
<dependencies>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency>
<dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency>
<dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope> </dependency>
</dependencies>
<build>
<finalName>springmvc_day02_01_response1</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
3.修改springxml配置文件（就是去掉了自定义的类型转换器的配置）代码如下
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xontext="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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启注解扫描 -->
<xontext:component-scan base-package="cn.lc"/>
<!-- 配置 试视图解析器用来识别controller返回对象，也就是跳转到对应jsp id随便定义-->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- prefix:表示文件所在的目录 suffi表示文件的后缀名-->
<property name="prefix" value="/WEB-INF/pages/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!-- 开启springmvc框架注解的支持 配置conversion-service="conversionService"是为了让自定义的类型转换器生效-->
<mvc:annotation-driven />
</beans>
4.写web.xml配置代码如下
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<!-- 加载这个类路径下的配置文件 -->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 以后启动服务器就可以创建这个对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!--/ 表示你发任何请求都会经过这个servlet-->
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置解决中文乱码的过滤器 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
5.在webapp/WEB-INF/pages下创建一个success.jsp（用来测试环境）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>执行成功</h3>
</body>
</html>
6.在webapp直接创建index.jsp（项目生成自带，建议删除出现创建一个）和response.jsp
a：index.jsp代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>返回String</h3>
</body>
</html>
b：response.jsp代码如下
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<a href="user/testString">testString</a>
</body>
</html>
<a href="user/testString">这个路径和下面UserController 类中的路径要保持一致
7.在jav中创建一个UserController（包名随便写）类我写的是cn.lc.controller包
package cn.lc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/testString")
public String testString(){
System.out.println("这个方法执行了。。。");
return "success";
}
}
运行服务器，结果如下
idea控制台输出结果为
接下来我们讲以下返回值分类（如果三大框架整合到一起就不用这么麻烦了）
1.返回一个字符串
a：创建一个包cn.lc.domain.User实体类（包名可以自己定义）
package cn.lc.domain;
import java.io.Serializable;
public class User implements Serializable {
private String username;
private String password;
private Integer age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
b：修改UserController代码
package cn.lc.controller;
import cn.lc.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/testString")
public String testString(Model model){
System.out.println("这个方法执行了。。。");
//模拟从数据库中查询出user对象
User user = new User();
user.setUsername("美美");
user.setAge(20);
user.setPassword("123");
//model对象
model.addAttribute("user",user);
return "success";
}
}
c：修改success.jsp（跟之前不一样的是加了一段isELIgnored="false"代码）
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>执行成功</h3>
${user.username}
${user.password}
</body>
</html>
启动服务器
返回值是void
a：修改response.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<a href="user/testString">testString</a>
<br/>
<a href="user/testvoid">testVoid</a>
</body>
</html>
b：在UserController中添加一个testvoid方法
/*
返回值类型是void
请求转发一次请求，不用写项目的名称
*/
@RequestMapping("/testvoid")
public void testvoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
System.out.println("testvoid这个方法执行了。。。");
//编写转发程序
request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
return;
}
解析：因为返回值是void所以系统会默认有一个返回地址，所以正常启动服务器如图
所以我们就需要添加一个编写转发程序上面代码所示
idea运行结果为
void返回值还有几个小方法，我只写代码就不一一启动了，有兴趣的可以尝试一下
/*
返回值类型是void
请求转发一次请求，不用写项目的名称
*/
@RequestMapping("/testvoid")
public void testvoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
System.out.println("testvoid这个方法执行了。。。");
//编写转发程序
// request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
//重定向方法（转发不可以直接写以上路径）
//response.sendRedirect(request.getContextPath()+"/index.jsp");
//设置中文乱码
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=UTF-8");
//直接会进行响应
response.getWriter().print("你好");
return;
}
ResponseBody响应json数据
首先我们得进行环境配置
在webapp下面创建一个js文件，并且在里面引入js
下载地址在最上面（链接: https://pan.baidu.com/s/1bV0RbnkB0ww2karAquwh2A 提取码: funa）
1.配置springmvc.xml在里面修改如下代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xontext="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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启注解扫描 -->
<xontext:component-scan base-package="cn.lc"/>
<!-- 配置 试视图解析器用来识别controller返回对象，也就是跳转到对应jsp id随便定义-->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- prefix:表示文件所在的目录 suffi表示文件的后缀名-->
<property name="prefix" value="/WEB-INF/pages/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!-- 前端控制器那些静态资源不拦截 location="/js/**"/>表示js文件里面下面所有的内容都不拦截-->
<mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
<mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
<mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->
<!-- 开启springmvc框架注解的支持 配置conversion-service="conversionService"是为了让自定义的类型转换器生效-->
<mvc:annotation-driven />
</beans>
2.修改response.jsp中的代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script src="js/jquery.min.js"></script>
<script>
//页面加载单机绑定事件
$(function () {
$("#btn").click(function () {
alert("hello");
});
});
</script>
</head>
<body>
<a href="user/testString">testString</a>
<br/>
<a href="user/testvoid">testVoid</a>
<br/>
<button id="btn">发送的ajax的请求</button>
</body>
</html>
启动服务器
使用@RequestBody注解把json的字符串转换成JavaBean的对象
1.json字符串和JavaBean对象互相转换的过程中，需要使用jackson的jar包，在pom包里导入
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
2.修改response.jsp的代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script src="js/jquery-3.5.1.min.js"></script>
<script>
//页面加载单机绑定事件
$(function () {
$("#btn").click(function () {
$.ajax({
//编写json格式，设置属性和值
url:"user/testAjax",
contentType:"application/json;charset=UTF-8",
data:'{"username":"hehe","password":"123","age":30}',
dataType:"json",
type:"post",
success:function (data) {
//data服务器端响应的json数据
alert(data);
alert(data.username);
alert(data.age);
alert(data.password);
}
});
});
});
</script>
</head>
<body>
<a href="user/testString">testString</a>
<br/>
<a href="user/testvoid">testVoid</a>
<br/>
<button id="btn">发送的ajax的请求</button>
<br/>
<a href="user/testModelAndView">testModelAndView</a>
</body>
</html>
3.在UserController增加一个testAjax方法
@RequestMapping("/testAjax")
@ResponseBody
public User testAjax(@RequestBody User user){
System.out.println("testAjax的方法执行了");
//客户端发送ajax的请求，传的是json字符串，后端把json字符串封装到user对象中
System.out.println(user);
//做响应，模拟假装去查询数据库
user.setUsername("haha");
user.setAge(40);
//做响应
return user;
}
启动服务器点击按钮
idea编译器显示结果
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
