SpringMVC框架的使用
文章目录
- 1.什么是MVC
- 1.1回顾Servlet
- 1.2分析:
- 2.什么是SpringMVC
- 2.1SpringMVC的优点
- 2.2 第一个SpringMVC程序
- 2.3中心控制器
- 2.4SpringMVC执行原理
- 3.注解开发SpringMVC
- 4.@RequestMapping及RestFul风格
- 4.1使用@RequestMapping映射请求
- 4.1.1模拟post提交方式:
- 4.1.2@RequestMapping注解变体
- 4.2RestFul风格
- 5.重定向和转发
- 6.接收请求参数及回显参数
- 6.1提交的域名称和处理方法的参数名一致
- 6.2提交的域名称和处理方法的参数名不一致
- 6.3提交的是一个对象
- 6.4参数乱码问题
- 7.Json交互处理
- 7.1什么是JSON?
- 7.1.1JSON语法
- 7.2Jackson的使用
- 7.3Fastjson的使用
1.什么是MVC
MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。
-
Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
-
View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
-
Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。
最典型的MVC就是JSP + servlet + javabean的模式。
1.1回顾Servlet
第一步：导入依赖
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13version>
<scope>testscope>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>jstlartifactId>
<version>1.2version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.6.RELEASEversion>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>servlet-apiartifactId>
<version>2.5version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>jsp-apiartifactId>
<version>2.2version>
<scope>providedscope>
dependency>
dependencies>
第二步：获得Web app 的支持
第三步：编写一个Servlet类，用来处理用户的请求
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.获取前端参数
String method = req.getParameter("method");
if (method.equals("add")){
req.getSession().setAttribute("msg", "执行了add方法");
}
if (method.equals("delete")){
req.getSession().setAttribute("msg","执行了delete方法");
}
//2.调用业务层
//3.视图转发或者重定向
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
第四步：web.xml 中注册Servlet
<servlet>
<servlet-name>helloservlet-name>
<servlet-class>com.li.servlet.HelloServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>helloservlet-name>
<url-pattern>/hellourl-pattern>
servlet-mapping>
第五步：WEB-INF目录下创建jsp文件夹，新建一个test.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
第六步：测试
配置Tomcat
访问：http://localhost:8080/hello?method=add
http://localhost:8080/hello?method=delete
1.2分析:
用户发请求
1.Servlet接收请求数据，并调用对应的业务逻辑方法
2.业务处理完毕，返回更新后的数据给servlet
3.servlet转向到JSP，由JSP来渲染页面
4.响应给前端更新后的页面
2.什么是SpringMVC
2.1SpringMVC的优点
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
Springmvc的优点:
（1）可以支持各种视图技术,而不仅仅局限于JSP；
（2）与Spring框架集成（如IoC容器、AOP等）；
（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。
（4） 支持各种请求资源的映射策略。
2.2 第一个SpringMVC程序
第一步:配置web.xml文件
<servlet>
<servlet-name>springmvcservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc-servlet.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>springmvcservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
第二步：编写springmvc-servlet.xml文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
bean>
<bean id="/hello" class="com.li.controller.HelloController"/>
beans>
第三步：编写HelloController类
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象，放在ModelAndView中。Model
mv.addObject("msg","HelloSpringMVC!");
//封装要跳转的视图，放在ModelAndView中
mv.setViewName("hello");// /WEB-INF/jsp/hello.jsp
return mv;
}
}
第四步：WEB-INF目录下创建jsp文件夹，新建一个hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
第五步：部署Tomcat及相关环境
进入Run下的文件
配置Tomcat 修改名字、确认本地服务
问题：
一：出现的问题： Tomcat 服务器无法正常启动
原因： Tomcat 服务器找不到相关的 jar 包
解决方法： 将【lib】文件夹整个剪贴到【WEB-INF】下，并重新建立依赖：
二：maven资源过滤问题：
导入依赖
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties
**/ *.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties
**/ *.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
第六步：启动服务器
访问地址:http://localhost:8080/hello
2.3中心控制器
Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
前端控制器（DispatcherServlet）：
客户在页面输入
通过HTTP协议 利用request将数据(请求))带入前端控制器
前端控制器依据请求 指定对应的控制器 controller
控制器依据业务实际 进行处理后 调用业务逻辑产生数据,返回给前端控制器
此时前端控制器再将这些业务数据分发给业务视图
由业务视图将数据产生在业务页面中
业务页面再将生成的页面返回到前端控制器,
前端控制器再将业务页面反馈给用户界面
2.4SpringMVC执行原理
简要分析执行流程
1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
如上url拆分成三部分：
http://localhost:8080服务器域名
SpringMVC部署在服务器上的web站点
hello表示控制器
通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
2.HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
3.HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
4.HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
5.HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
6.Handler让具体的Controller执行。
7.Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
8.HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
9.DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
10.视图解析器将解析的逻辑视图名传给DispatcherServlet。
11.DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
12.最终视图呈现给用户。
3.注解开发SpringMVC
前端控制器依据请求 指定对应的控制器 controller 之前我们的做法是定义一个类去继承Controller类，这样一个类中只能写一个方法如果我们有很多的业务逻辑，会有controller1、controller2、3等很显然很繁琐，所以有了用注解开发。
注解的好处：
在Spring MVC中一个控制器类可以包含多个方法
在Spring MVC中，对于Controller的配置方式有很多种
第一步：web.xml文件不会有变化
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</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>
</web-app>
第二步：编写springmvc-servlet.xml的配置
<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"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<context:component-scan base-package="com.li.controller"/>
<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>
第三步：注册HelloController类，使用@Controller
@Controller 相当于
@RequestMapping("/hello")映射请求
@Controller
public class HelloController {
@RequestMapping("/hello")
public String hello(Model model){
//封装数据
model.addAttribute("msg","Hello，springMVC！");
return "hello";//交给视图解析器
}
}
第四步：编写hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Titletitle>
head>
<body>
${msg}
body>
html>
4.@RequestMapping及RestFul风格
4.1使用@RequestMapping映射请求
@RequestMapping映射请求替代了原来
@RequestMapping("Demo2")
@Controller
public class ControllerDemo2 {
@RequestMapping("/t1")
@RequestMapping(value = "/t2",method = RequestMethod.GET)
public String test(Model model){
//封装数据
model.addAttribute("msg","hello,ControllerDemo2");
return "test";
}
}
浏览器默认的提交方式是GET!
4.1.1模拟post提交方式:
编写from.jsp文件：
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%-- 表单两种提交方式:post、method--%>
<form action="/t3" method="post">
<input type="submit">
</form>
</body>
</html>
编写ControllerDemo2类
- value与action请求的地址保持一致
- @RequestMapping源码中参数name的别名分别是@AliasFor(“value”)、@AliasFor(“path”)
- 提交的方式是post
@Controller
public class ControllerDemo2 {
@RequestMapping(value = "/t3",method = RequestMethod.POST)
public String test3(Model model){
model.addAttribute("msg","我使用的是post提交方式");
return "test";
}
}
4.1.2@RequestMapping注解变体
GET、 PUT，POST等等，因为 @RequestMapping默认情况下会映射所有HTTP方法。使用@RequestMapping(method=GET)或 @GetMapping缩小映射。
- @GetMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.GET)
- @PostMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.POST)
- @PutMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.PUT)
- @DeleteMapping替代@RequestMapping(value ="/t2",method=RequestMethod.DELETE)
- @PatchMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.PATCH)
4.2RestFul风格
场景：完成两个数相加并且返回给前端页面
@GetMapping("/t4")
public String test4(int a,String b,Model model) {
String result = a + b;
model.addAttribute("msg","结果为："+result);
return "test";
}
浏览器上面的请求地址 http://localhost:8080/t4?a=2&b=3是我们之前用的方式。
- 缺点是不安全,为了安全起见一般都要使用@PathVariable
@GetMapping("/t4/{a}/{b}")
public String test4(@PathVariable int a,@PathVariable String b,Model model) {
String result = a + b;
model.addAttribute("msg","结果为："+result);
return "test";
}
5.重定向和转发
通过SpringMVC来实现转发和重定向 - 无需视图解析器；
@Controller
public class RedirectTest {
@GetMapping("/for")
public String test(Model model){
model.addAttribute("msg","RedirectTest");
//重定向
return "Redirect:/index.jsp";
}
}
@Controller
public class ForwardTest {
@GetMapping("/for")
public String test(Model model){
model.addAttribute("msg","RedirectTest");
//转发
return "forward:/index.jsp";
}
}
6.接收请求参数及回显参数
6.1提交的域名称和处理方法的参数名一致
@Controller
@RequestMapping("/user")
public class UserController {
// http://localhost:8080/user/u2?name=lirui
@GetMapping("/u2")
public String userName(String name,Model model){
//接收前端的参数
System.out.println("接收前端的参数"+name);
//接收的参数返回给前端 Model
model.addAttribute("msg","前端参数为"+name);
return "test";
}
}
浏览器页面：
控制台：
接收前端的参数李瑞
6.2提交的域名称和处理方法的参数名不一致
/**
* 如果前端没有按照name=xxx传参
* 那么后台接收的前端参数为null
* 解决：1.使用@RequestParam("username")
*/
@GetMapping("/u3")
public String userName2(@RequestParam("username") String name, Model model) {
//接收前端的参数
System.out.println("接收前端的参数" + name);
//接收的参数返回给前端 Model
model.addAttribute("msg", "前端参数为" + name);
return "test";
}
6.3提交的是一个对象
要求提交的表单域和对象的属性名一致 , 参数使用对象即可
实体类：
public class User {
private int id;
private String name;
private int age;
public User(){
}
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
处理方法：
@Controller
@RequestMapping("/user")
public class UserController {
@GetMapping("/u1")
public String userMessage(User user, Model model){
//接收前端的参数
System.out.println(user);
//接收的参数返回给前端 Model
model.addAttribute("msg",user);
return "test";
}
}
6.4参数乱码问题
1.编写一个form表单
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="/test" method="post">
<input type="text" name="name"> <br>
<input type="submit">
</form>
</body>
</html>
2.后台编写对应的处理类
@Controller
public class EncodingController {
@RequestMapping("/test")
public String test(String name, Model model){
model.addAttribute("msg",name);
return "test";
}
}
一般情况提交form表单，post方式会出现乱码
如果form表单的提交方式为get
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="/test" method="get">
<input type="text" name="name"> <br>
<input type="submit">
</form>
</body>
</html>
以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 修改了xml文件需要重启服务器
<filter>
<filter-name>encodingfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>encodingfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
7.Json交互处理
7.1什么是JSON?
-
JSON 是一种数据格式。它本身是一串字符串，只是它有固定格式的字符串，符合这个数据格式要求的字符串，我们称之为JSON。
-
JSON 常用来数据传输，因为它易于程序之前读写操作。
-
JSON 它其实是来自JavaScript对对象（Object）的定义。但是它作为数据格式来使用的时候，和JavaScript没有任何关系，它只是参照了JavaScript对对象定义的数据格式。
-
JSON 它可以服务任何语言，C、C++、Java、Objective-C、Python、Go、等，在各个语言中的字典、Map和JSON是类似的结构，所以它们之间可以相互转换。
1.JSON键值，以 “{” 开始，以 “}” 结束。中间包裹的为Key : Value的数据结构。
如:
{“name”:“小明”}
表达的意思就是 name = sojson，他们是字符串(String)，所以要以双引号引起来。
2.JSON数组，以 “[” 开始，以 “]” 结束。中间为装起来的数据，而Value可以为以下的任意数据类型。
String、number、object、array、boolean（true/false）,null 这几种数据类型。
{
"type1": "string",
"type2": 31,
"type3": {"name":"张三"},
"type4": ["张三","李四"],
"type5": true,
"type6": null,
}
7.1.1JSON语法
Json语法规则
- 数据在名称/值对中
- 数据由逗号分隔
- 花括号保存对象
- 方括号保存数组
JSON 名称/值对
JSON 数据的书写格式是：{Key:Value}、{Key:Array}。
{Key:Value}，前面是键，中间是英文的“:”（冒号），然后是值。但是注意的是如果是字符串，严格来说都是英文双引号引起来的
如：{“Key”:“Value”}
{“name” : “鹿晗”}
等价于这条JavaScript语句
name:“鹿晗”
Json对象
<script type="text/javascript">
var user = {
name:"李瑞",
age:22,
id:02
}
console.log(user);
script>
JSON 数组
<script type="text/javascript">
var star_male = [
{
"name": "黄晓明",
"age": "26"
},
{
"name": "陈思诚",
"age": "29"
},
{
"name": "陈赫",
"age": "31"
}
]
//遍历数组元素
for (var i in star_male) {
alert("name:" + star_male[i].name);
alert("age:" + star_male[i]['age']);
}
for (var i = 0;i<star_male.length;i++){
alert("name:"+star_male[i].name)
alert("age:"+ star_male[i].age)
}
script>
Json使用
<script type="text/javascript">
//将js对象解析为json对象
let s = JSON.stringify(user);
console.log(s);//{"name":"李瑞","age":22,"id":2018060160}
//将json对象转换为js对象
console.log("================");
let parse = JSON.parse(s);
console.log(parse)
script>
为什么要用JSON？
1.其实用JSON主要是因为它轻量，各个平台语言都支持JSON交互、JSON解析和存储。
2.JSON常用于我们接口交互，前后端交互中，有解析速度快，方便的特点。
3.JSON常用于我们一些配置文件也是因为解析方便，JSON存储数据体积小等特征，而不像XML、PList（也是xml的一种）等格式，定义各种Dom节点（当然复杂的格式还是建议XML）。
用JSON的好处是什么？
1.JSON是大家公认的传输格式，所以学习成本低，程序员之间交流经常会问，您接口返回什么格式？答曰：“JSON”，其实就没啥问题了。
2.各个语言、各个框架（第三方组件）都支持JSON，所以使用上来讲，复用率更高，不用格式转来转去。
3.上面也讲了，体积小、解析速度快也是JSON的优点。
7.2Jackson的使用
1.使用Jackson导入jar包
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.11.0version>
dependency>
2.配置SpringMVC需要的配置 web.xml文件
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>SpringMVCservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:springmvc-servlet.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>SpringMVCservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
<filter>
<filter-name>encodingfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>encodingfilter-name>
<url-pattern>/url-pattern>
filter-mapping>
web-app>
3.配置springmvc-servlet.xml
<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"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<context:component-scan base-package="com.kuang.controller"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
id="internalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
bean>
beans>
4.编写实体类User
public class User {
private int id;
private String name;
private int age;
public User() {
}
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
5.编写一个Controller类
1.@ResponseBody注解，这里会将str转成json格式返回；十分方便
2.ObjectMapper对象，用来解析数据
@Controller
public class JsonController {
@RequestMapping("/j2")
@ResponseBody
public String json2() throws JsonProcessingException {
//创建一个Jackson的对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User(2,"小华",12);
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(user);
//由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
return str;//{"id":2,"name":"??","age":12}
}
}
出现乱码的问题：要设置编码格式
//produces:指定响应体返回类型和编码 @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")
解决后：
在springmvc中一般我们都会在springmvc-servlet.xml配置一些StringHttpMessageConverter转换配置!
<mvc:annotation-driven>
<mvc:message-converters register-defaults="true">
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<constructor-arg value="UTF-8"/>
bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper">
<bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
<property name="failOnEmptyBeans" value="false"/>
bean>
property>
bean>
mvc:message-converters>
mvc:annotation-driven>
6.返回json字符串统一解决
- 在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用
@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
//创建一个Jackson对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User(4,"小李",8);
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(user);
return str;//{"id":4,"name":"小李","age":8}
}
集合输出
@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
//创建一个Jackson对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User(4,"小李",15);
User user1 = new User(5, "小李", 13);
User user2 = new User(6, "小李", 10);
User user3 = new User(7, "小李", 8);
List<User> userList = new ArrayList<User>();
userList.add(user);
userList.add(user1);
userList.add(user2);
userList.add(user3);
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(userList);
return str;//{"id":4,"name":"小李","age":8}
}
时间对象输出 两种方式
方式一：
@RequestMapping("/j6")
public String json6() throws JsonProcessingException {
//将时间显示在页面上
Date date = new Date();
String str = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
return "现在是北京时间："+str;
}
方式二：
/**
*解决： ObjectMapper mapper = new ObjectMapper();
* return mapper.writeValueAsString(new Date());
* 页面结果是时间戳；我们希望看到的格式：现在是北京时间："2020-06-13 17:52:00"
*/
@RequestMapping("/j7")
public String json7() throws JsonProcessingException {
//运用Jackson中的方法实现时间显示
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳的方式
mapper.configure(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;
}
为了提高代码的复用性：抽取工具类
public class JsonUtil {
public static String getJson(User user){
String str = null;
//创建Jackson对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
try {
str = mapper.writeValueAsString(user);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return str ;
}
public static String getJson(Object object){
return getJson(object,"yyyy-MM-dd HH:mm:ss");
}
public static String getJson(Object object, String format){
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳的方式
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//自定义日期格式对象
SimpleDateFormat sdf = new SimpleDateFormat(format);
//指定日期格式
mapper.setDateFormat(sdf);
try {
return mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
}
只需要传Date对象即可
@RequestMapping("/j8")
public String json8() throws JsonProcessingException {
Date date = new Date();
return "现在是北京时间："+JsonUtil.getJson(date);
}
7.3Fastjson的使用
- fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。
fastjson 的 pom依赖！
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.60version>
dependency>
fastjson 三个主要的类：
1.JSONObject 代表 json 对象
- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
2.JSONArray 代表 json 对象数组
- 内部是有List接口中的方法来完成操作的。
3.JSON代表 JSONObject和JSONArray的转化
- JSON类源码分析与使用
仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
测试：FastJsonDemo
public class FastJsonDemo {
public static void main(String[] args) {
//创建一个对象
User user1 = new User(1,"小李",22);
User user2 = new User(2,"小张",15);
User user3 = new User(3,"小黄",17);
User user4 = new User(4,"小明",26);
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
System.out.println("*******Java对象 转 JSON字符串*******");
String str1 = JSON.toJSONString(list);
System.out.println("JSON.toJSONString(list)==>" + str1);
String str2 = JSON.toJSONString(user1);
System.out.println("JSON.toJSONString(user1)==>" + str2);
System.out.println("\n****** JSON字符串 转 Java对象*******");
User jp_user1 = JSON.parseObject(str2, User.class);
System.out.println("JSON.parseObject(str2,User.class)==>" + jp_user1);
System.out.println("\n****** Java对象 转 JSON对象 ******");
JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
System.out.println("(JSONObject) JSON.toJSON(user2)==>" + jsonObject1.getString("name"));
System.out.println("\n****** JSON对象 转 Java对象 ******");
User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>" + to_java_user);
}
}
以上就是SpringMVC框架的使用如果有不足的地方，谢谢留言