springMVC 入门
今天开始学习springmvc，首先献上一个小demo来感受一下springmvc的魅力和使用普通的servlet方式建站的区别。
SpringMVC是spring的一个基于MVC的轻量级WEb框架，本质上来讲还是servlet。不过该框架可以和spring无缝衔接，把脱了servlet的一些繁琐的配置，拥有卓越的性能优势。
下面来看一则小demo，之后在正式开始学习。
和servlet一样首先配置web.xml：
springmvc
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:springmvc-servlet.xml
1
springmvc
/
在web.xml中我们只对DispatcherServlet进行了注册配置，这是框架中的请求分发器，会将请求按配置文件中的内容为各个控制器进行分发，这里的配置文件就是
springmvc-servlet.xml，看一下：
该配置文件是一个bean文件，之后所有的控制器的相关绑定就在这里进行，前三个分别是映射器，适应器和视图解析器，都是框架内置的，在视图解析器中，我们规定了前缀和后缀，之后再控制器中进行视图跳转时，只需给出文件名就好，框架会自动将前缀和后缀补齐，比如在控制器中写入转向hello，就是转向/WEB-INF/jsp/hello.jsp视图（在本项目中）。
下面id为/hello的bean就是对控制器的绑定，下面来看一下控制器的内容：
package com.yang.controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class hellospringmvc implements Controller {
@Override
public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws Exception {
//ModelAndView模型与视图
ModelAndView mv = new ModelAndView();
//封装对象，直接在model中封装就好了，不用在session中进行操作了
mv.addObject("msg","hellospringmvc!");
//封装要跳转的视图，放在ModelAndView中，下面的hello会根据配置文件中给出的前缀和后缀自动组装为/WEB-INF/jsp/hello.jsp
mv.setViewName("hello");
return mv;
}
}
注释很清晰，下面需要在/WEB-INF/jsp文件夹下写入一个hello.jsp的文件，如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Title
${msg}
接收msg的参数并显示下面运行一下，访问/hello
注（这里备注一个经典的404报错，在上面的demo中就可能遇到）：
当jar包没有如约打包到Tomcat服务器中的项目文件中时，就可能报404错误，这时候我们需要在项目结构->Artifacts->当前打包的项目中查看WEB-INF中是否有lib文件夹，如果没有需要创建一个，然后将项目中的jar导入。
下面开始正式入门
springmvc 框架原理（以下内容借鉴自莫乐的知乎文章）
springmvc全名是spring web mvc，springmvc是spring的一个模块，并且看名字即可知道，springmvc是一个基于mvc设计模式的前端web框架。mvc：m(model模型)、v(view视图)、c(control控制)
对上图进行分步骤解释：
1，用户向发送请求到情断控制器(DispatcherServlet)，前端控制器根据web-xml中的配置过滤出需要进行处理的请求（主要根据url-pattern配置项），然后去加载springmvc.xml文件。
2，前端控制器向处理器映射器（HandlerMapping）询问与请求url相对应的处理器controller的组件。该部分是通过springmvc.xml中的bean项或者通过注解来查找的，这种映射关系是通过map
3、通过HandlerMapping有了这些映射关系，并且找到了url对应的处理器，HandlerMapping就会将其处理器(图中红色标明的handler)返回，在其返回之前，在加上很多的拦截器，其作用后面进行讲解，这里知道在返回的处理器前会有很多的拦截器即可。
4、DispatcherServlet拿到了handler之后，找到HandlerAdapter(处理器适配器)，通过它来访问处理器，并且执行处理器。
这里会有人会有疑惑，为什么需要处理器适配器，我们都获得了处理类了，直接调用不就行了吗？
不行，因为我们只知道处理类在哪里，并不知道执行处理类中的哪个方法，其实也就是不知道处理类是通过哪种方式创建出来的，实现HttpRequestHandler？还是注解方式，或者是其他方式，我们不知道，所以需要HandlerAdapter来帮我们确认调用哪个方法。
5，执行处理器
6，处理器返回一个ModelAndView（模型与视图）返回给处理器适配器。
7，处理器适配器再将该模型与视图返回给前端控制器。
8、前端控制器请求视图解析器(ViewResolver)去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)，其实就是将ModelAndView对象中存放视图的名称进行查找，找到对应的页面形成视图对象
9，视图解析器将解析好的视图对象返回给前端控制器
10、视图渲染，就是将ModelAndView对象中的数据放到request域中，用来让页面加载数据的。
11、通过第8步，通过名称找到了对应的页面，通过第10步，request域中有了所需要的数据，那么就能够进行视图渲染了。最后将其返回
组件说明：
DispatcherServlet：作为前端控制器，是整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。
HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器。
ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。
注意事项：在上面的整个流程中，除了web.xml与springmvc.xml这样的配置文件，还有controller中的类以及相对应的视图文件（比如jsp）需要我们自己编写，剩下的都是框架内置的内容。
使用注解开发
在多数情况下，使用spring mvc开发项目，多使用注解形式开发，下面进行简单介绍。
web-xml不需要更改，配置文件主要更改springmvc-servlet.xml就可以：
然后看控制器：
@Controller
public class Hello {
@RequestMapping("/hello")
public String hello(Model model){
//为模型添加参数
model.addAttribute("msg","Hello SpringMVC !!");
return "hello"; //返回的字符串会交由试图解析器去解析，这里根据配置文件前后缀的设置，会获取到文件/WEB-INF/jsp/hello.jsp
}
}
- @Controller 表示将类注册为控制器，类似于在配置文件中使用
标签进行注册。 - Model是Modelandview的简化版，作用是一样的
@RequestMapping("/hello") 将该方法与/hello这个路由绑定到一起。如果在类前面加一个@RequestMapping("/h")的话，就表示该类中所有方法的路由都要加上'/h'这个前缀。比如上面的类要是写成下面这样的话：
@Controller
@RequestMapping("/h")
public class Hello {
@RequestMapping("/hello")
public String hello(Model model){
//为模型添加参数
model.addAttribute("msg","Hello SpringMVC !!");
return "hello"; //返回的字符串会交由试图解析器去解析，这里根据配置文件前后缀的设置，会获取到文件/WEB-INF/jsp/hello.jsp
}
}
访问hello这个方法时的url就是url/h/hello。
下面对各个注解进行解析：
- @Controller：使用该注解修饰某个类之后，代表这个类会被spring接管，类中所有的方法如果放回为字符穿，并且由具体页面可以跳转，就会被视图解析器解析。
- @RequestMapping：用于映射url到控制器类或者一个特地给的处理程序方法，可用于类或者方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
Restful风格介绍
Restful就是一个资源定位及资源操作的风格，不是标准也不是协议，只是一种风格，基于这个风格设计的软件可以更加简洁，更有层次感，更易于实现话缓存机制。简单来说Restful就是一中urI的构建风格，相对于传统的URI风格来讲，更加的简洁。
传统方式操作资源：通过不同的参数实现不同的效果！方法单一，一般主要为POST和GET
- http://127.0.0.1/item/queryItem.action?id=1 查询，GET
- http://127.0.0.1/item/saveItem.action?id=1 新增，POST
- http://127.0.0.1/item/updateItem.action?id=1 更新，POST
- http://127.0.0.1/item/deleteItem.action?id=1 删除，GET 或POST
使用Restful操作资源：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样的但是功能可以不同。 - http://127.0.0.1/item/1 查询，GET
- http://127.0.0.1/item 新增，POST
- http://127.0.0.1/item 更新，PUT
- http://127.0.0.1/item/1 查询，DELETE
二者的区别主要体现在参数的传递上，传统的URI必须显示的将参数体现出来，采用GET或者POST的方式进行传递，而且请求方法可以根据参数传递方式轻松得出，比如url/?a=1&b=2那就是GET方法传参。
Restful不再使用显示的GET或者POST去传递参数，而是直接从URI中获取得到，比如url/a/b，就可获得a和b的值在进行一些操作。
为理解二者区别，下面我们进行实操，程序功能为获取a和 b的值，进行相加，然后返回。
传统风格
@RequestMapping("/restful")
public String test1(int a, int b, Model model){
int res = a + b;
model.addAttribute("msg"," 结果为:" + res);
return "test";
}
访问url:http://localhost:8080/s/restful?a=1&b=3
restful风格
@RequestMapping("/add/{a}/{b}")
public String test2(@PathVariable int a,@PathVariable int b, Model model){
int res = a + b;
model.addAttribute("msg", "结果为：" + res);
return "test";
}
请求url:http://localhost:8080/s/add/1/2
@PathVariable 可以让方法参数的值绑定到一个URI模板变量上。也就是说该注解修饰的变量会直接从URI中获取变量值。这里给出的URI模板为/add/{a}/{b},a和b会从对应的位置分别取值。
URI模板
在springmvc中我们一般使用@RequestMapping来定义URI模板。该注解默认接受一个path作为请求URI的地址，同时也支持限定请求的类型。像上文中只传入path的方式表示接受所有类型的请求类型，下面我们对请求类型进行限制：
@RequestMapping(value = "/add/{a}/{b}", method = RequestMethod.GET) //限定只能使用GET请求
public String test2(@PathVariable int a,@PathVariable int b, Model model){
int res = a + b;
model.addAttribute("msg", "结果为：" + res);
return "test";
}
加入请求方法，@RequestMapping就相当于传入了两个参数，这时候必须加上变量名，不然会混淆。RequestMethod是一个枚举类型：
public enum RequestMethod {
GET,
HEAD,
POST,
PUT,
PATCH,
DELETE,
OPTIONS,
TRACE;
private RequestMethod() {
}
}
用于为method赋值。
为使用方便，springmvc还提供方法级别的注解变体，即注解本身就已经对请求方法进行了限定。
@GetMapping
@PostMapping
@DeleteMapping
@PutMapping
@PatchMapping
分别限制前缀表示的方法，比如@GetMapping（"/add/{a}/{b}"）就相当于
@RequestMapping(value = "/add/{a}/{b}", method = RequestMethod.GET)。
总体而言Restful的请求风格相对于传统的URI风格而言更加简洁，而且更加安全，因为第三方很难直接获取传入的参数。
重定向和转发
在上面的所有示例中我们都是直接返回字符串交由视图解析器进行处理，视图解析器的主要作用就是为返回的字符串拼接上前缀和后缀，然后在项目中找到对应的视图文件，再将该文件返回。为了更好的理解，我们可以将试图解析器先注释掉，然后给出控制器代码：
public String redirct(Model model){
model.addAttribute("msg","Hello SpringMVC!!");
return "/WEB-INF/jsp/test.jsp";
}
返回的字符串是一个完整的文件路径，这样我没不需要试图解析器也可以正确返回文件。
下面进入正题，学习过javaweb的小伙伴都清楚，在servlet中，request可以实现转发，response可以实现重定向。Springmvc是基于servlet的，所以一样可以实现转发和重定向的功能。在直接返回字符串的情况下，默认是做转发操作的。当然也可以在返回的字符串中显示的使用forward:标明要做转发，代码:
public String redirct(Model model){
model.addAttribute("msg","Hello SpringMVC!!");
return "forward:/WEB-INF/jsp/test.jsp";
}
使用redirect:标明重定向：
public String redirct(Model model){
model.addAttribute("msg","Hello SpringMVC!!");
return "redirect:/WEB-INF/jsp/test.jsp";
}
注：在做重定向操作时必须关闭视图解析器，不然会进行字符串拼接，发生错误。
接受请求参数
servlet中我们使用request.getparameters()方法获取请求信息中的对应标签的参数。下面本文介绍在springmvc中如何接收请求参数。
- 1，接收单个普通参数
如果是传入单个普通类型的参数，只需要在方法的参数列表中直接列出要接受的参数就可以了。
//***下面的方法接收一个name的字符串参数***
public String test(String name, Model model){
//1, 接收参数
System.out.println("name: " + name);
//2, 将返回的结果传给前端
model.addAttribute("msg", "Hello " + name);
//3, 跳转试图页面
return "test";
}
请求域名：http://localhost:8080/ss/user?name=yangsir
测试结果：
- 如果前端传入的参数名和方法中的参数名不一致，可以使用@@RequestParam()注解进行参数绑定。如下：
@RequestMapping("/user")
//***下面的方法接收一个name的字符串参数***
public String test(@RequestParam("username")String name, Model model){
//1, 接收参数
System.out.println("name: " + name);
//2, 将返回的结果传给前端
model.addAttribute("msg", "Hello " + name);
//3, 跳转试图页面
return "test";
}
请求域名：http://localhost:8080/ss/user?username=yangsir
测试结果:
- 传入参数为类对象。测试之前先构造User类：
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String sex;
}
如果前端传入该类的各个属性的值，我们该如何接收？第一种方法将传入的参数全部接收，在赋值给对象的各个属性。这种没问题但是不推荐，因为springmvc有其他接收方法，可以直接将User类对象当作参数接收，spring会自动将各个参数整合至对象中:
@RequestMapping("/user2")
public String test2(User user,Model model){
System.out.println("user: " + user);
return "test";
}
请求域名： http://localhost:8080/ss/user2?name=yangsir&id=2&sex=man
测试结果：
这种方法的缺点是传入表单的字段名必须和类对象的属性名一致，不然会直接返回null。
我们在上面的所有操作都是使用Model这个类去完成，除了Model还有ModelMap和ModelAndView可以用，基本大同小异，有兴趣可以查一下，最常用的还是Model。
乱码问题
在学习web编程时经常遇到乱码问题，一般都是因为浏览器和服务器后台设置的编码格式不一致导致的，下面介绍几个经常用到的解决方法以及排查点：
- 在servlet中为request设置编码，如下：
@RequestMapping("/encode")
public String encode(Model model, String name, HttpServletRequest request) throws UnsupportedEncodingException {
request.setCharacterEncoding("utf-8");
System.out.println("name: " + name);
model.addAttribute("msg", name);
return "test";
}
不过这种方法一般不会奏效，因为程序跑到Controller中时已经编码过了，所以在此此进行编码肯定会出错。应该servlet之前进行编码，也就是设置过滤器。
- 设置过滤器
编辑过滤器
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
filterChain.doFilter(servletRequest,servletResponse);
}
添加映射与web.xml中：
springmvc
/
Encoding
com.yang.filter.Encodingfilter
Encoding
/*
重启服务器。成功解决乱码。
- 使用springmvc提供的编码过滤器。
springmvc提供了编码过滤器，直接在web.xml中配置就好了：
encoding
org.springframework.web.filter.CharacterEncodingFilter
encoding
utf-8
encoding
/*
原理其实就是通过过滤器的方式修改编码。
-
修改tomcat配置文件server.cml
image.png
当然，如果通过前面的方法已经解决了乱码问题，就不需要修改tomcat配置文件了。
JSON传输数据
什么是JSON
JSON，全称是 JavaScript Object Notation，即 JavaScript 对象标记法。这是一种 轻量级 （Light-Weight）、 基于文本的 （Text-Based）、 可读的 （Human-Readable）数据交换格式。
大部分语言都支持JSON数据格式的交互，以Javascript为例。在JavaScript中，一切数据都是对象，因此任何JavaScript支持的数据都可以使用JSON来表示。看一下他的格式和要求：
- 对象由键值对表示，数据由逗号隔开
- 花括号保存对象
- 中括号保存数组
JSON键值对可以用来保存JavaScript中的对象，数据由逗号隔开，键名用双引号引起来，键和值使用冒号隔开。
例如：
{"name":"yangsir"}
{"age":13}
到这可能很多小伙伴会进入一个误区，认为JSON字符串就是JavaScript对象。其实不然，JSON数据本质是一个字符串，可以保存JavaScript对象的信息，但还不是JavaScript对象，看下面的例子就知道了：
var obj = {name:"yangsir", age:13} //这是一个javascript对象（键名也可以使用双引号包裹）
var obj_str = '{"name":"yangsir", "age":13}'//这是一个JSON字符串，本质是一个字符串，保存了对象信息
JSON字符串和JavaScript对象之间的转换
- JSON.parse()可实现由JSON字符串到JavaScript对象的转换。
var obj = JSON.parse('{"name":"yangsir", "age":13}');
- JSON.stringify()可实现由JavaScript对象到JSON字符串的转换
var obj_str = JSON.stringify({name:"yangsir", age:13});
controller返回JSON
Jackson
首先在controller中测试返回一个字符串：
//返回普通字符串
@RequestMapping("/j1")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json1(){
//创建一个对象
User user = new User("yangsir", 18, "man");
return user.toString();
}
结果
[图片上传中...(image.png-ed074b-1640150852850-0)]
没有问题，下面使用jackson将user转变为json格式返回，首先添加依赖
添加依赖：
com.fasterxml.jackson.core
jackson-databind
2.13.0
测试代码（单个对象）：
//使用jackson
@RequestMapping(value = "/j2", produces = "application/json;charset=utf-8")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json2() throws JsonProcessingException {
//创建一个对象
User user = new User("yangsir", 18, "男");
// 获取jackson对象
ObjectMapper mapper = new ObjectMapper();
//将类保存到字符串
String user_str = mapper.writeValueAsString(user);
System.out.println(user_str);
return user_str;
}
测试结果
结合上面对json字符串的描述，没有问题。
注释
@RequestMapping(value = "/j2", produces = "application/json;charset=utf-8")中的参数produces = "application/json;charset=utf-8"是用于设置字符编码，处理乱码问题。这里请将请求的乱码处理和json的乱码处理区分开，处理请求信息中的乱码，需要在过滤器中设置，因为传入参数是在客户端就已经编码为utf-8，需要在过滤器中设置对应的编码格式进行接收。处理json的乱码，需要在后台controller处处理，因为此时数据由后台产生，需要设置数据的编码格式与客户端一致（均为utf-8）。换句话说，一个是设置解码格式，一个是设置编码格式。**
上面的乱码解决方法有一个缺点，就是每一个方法都要在注解里加上编码格式。如果觉着这样麻烦，可以使用springmvc提供的乱码处理方法，在配置文件（springmvc-servlet.xml）中对mvc:annotation-driven进行配置。配置内容如下：
将上面的配置直接写进配置文件就好了。
一个对象mapper.writeValueAsString是转化为json的标准格式（花括号），那么如果是一个列表呢。
对象列表
@RequestMapping(value = "/j3", produces = "application/json;charset=utf-8")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json3() throws JsonProcessingException {
//创建一个对象
User user1 = new User("yangsir", 18, "男");
User user2 = new User("yang", 16, "女");
User user3 = new User("sir", 28, "男");
List userList = new ArrayList();
userList.add(user1);
userList.add(user2);
userList.add(user3);
// 获取jackson对象
ObjectMapper mapper = new ObjectMapper();
//将类保存到字符串
String user_str = mapper.writeValueAsString(userList);
System.out.println(user_str);
return user_str;
}
结果
返回了数组格式。
时间进行序列化
@RequestMapping("/j4")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json4() throws JsonProcessingException {
//创建一个对象
Date date = new Date();
return (new ObjectMapper()).writeValueAsString(date);
}
结果
使用writeValueAsString对时间进行序列化，默认返回时间戳格式。下面介绍两种方法改变时间序列化格式。
按格式序列化时间（1）
指定日期的格式，先将日期进行格式化，在进行序列化。直接撸代码：
@RequestMapping("/j4")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json4() throws JsonProcessingException {
//创建一个对象
Date date = new Date();
//自定义日期格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return (new ObjectMapper()).writeValueAsString(simpleDateFormat.format(date));
}
结果
按格式序列化时间（2）
对ObjectMapper进行配置，直接指定序列化时间的格式。
@RequestMapping("/j4")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json4() throws JsonProcessingException {
//创建一个对象
Date date = new Date();
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳方式,该项配置默认为true，即默认使用时间戳方式进行序列化
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//自定义日期对象
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//指定日期格式
mapper.setDateFormat(dateFormat);
return mapper.writeValueAsString(date);
}
结果
为了代码更加简洁且可复用，我们可以将上面的代码写成一个工具类，可以任意设置时间的序列化格式：
工具类
public static String getTimeJson(Object object) throws JsonProcessingException {
return getTimeJson(object,"yyyy-MM-dd HH:mm:ss");
}
public static String getTimeJson(Object object, String dataformat) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳方式,该项配置默认为true，即默认使用时间戳方式进行序列化
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//自定义日期对象
SimpleDateFormat dateFormat = new SimpleDateFormat(dataformat);
//指定日期格式
mapper.setDateFormat(dateFormat);
return mapper.writeValueAsString(object);
}
默认返回标准格式的时间，也可以传入自定义的时间格式进行定义。
调用
@RequestMapping("/j4")
@ResponseBody //配置该注解后，不会走视图解析器，直接返回字符串
public String json4() throws JsonProcessingException {
//创建一个对象
Date date = new Date();
return jsonUtils.getTimeJson(date);
}
fastjson
fastjosn是一个由阿里开发的用于处理json对象的工具类，功能与Jackson类似。
导入依赖
com.alibaba
fastjson
1.2.79
fastjson的三个主要类：
- 【JSONObject 代表json对象】
*JSONObject实现了Map接口，猜想JSONObject底层操作是由Map来实现- JSONObject对应接送对象，通过各种形式的get()方法可以获取到json对象中的数据，也可以利用诸如size(),isEmpty()等方法获取“键值对”的个数和是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
- 【JSONOArray 代表接送对象数组】
- 内部是由List接口中的方法来完成操作
- 【JSON 代表JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法，主要实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
代码测试
public class jsontest {
public static void main(String[] args) {
User user1 = new User(17, "yangsir","男");
User user2 = new User(18, "sir","女");
User user3 = new User(19, "yang","男");
List users = new ArrayList<>();
users.add(user1);
users.add(user2);
users.add(user3);
System.out.println("####将对象转换为Json字符串：####");
System.out.println("==========================");
System.out.println("****单个对象****");
String str = JSON.toJSONString(user1); //将单个对象转换为字符串
System.out.println(str);
System.out.println("==========================");
System.out.println("****对象列表****");
str = JSON.toJSONString(users);//将对象列表转换为字符串
System.out.println(str);
System.out.println("==========================");
System.out.println("\r\n####将json字符串转换为类对象：####");
System.out.println("==========================");
str = "{\"id\":17,\"name\":\"yangsir\",\"sex\":\"男\"}";
User user = JSON.parseObject(str,User.class);
System.out.println(user);
System.out.println("==========================");
System.out.println("\r\n####Java对象转JSON对象：####");
System.out.println("==========================");
JSONObject jsonObject = (JSONObject)JSON.toJSON(user);
System.out.println("jsonObject: " + jsonObject);
System.out.println("name: " + jsonObject.getString("name"));
System.out.println("==========================");
System.out.println("\r\n####JSON对象转JAVA对象：####");
System.out.println("==========================");
User user4 = JSON.toJavaObject(jsonObject,User.class);
System.out.println(user4);
System.out.println("==========================");
}
}
测试结果
注： 常用方法都以包含到测试代码中，且注释很清晰，请自行阅读。
文章最后，附上spring开发框架结构，欢迎批评指正：