大家好,又见面了,我是你们的朋友全栈君。
原文:
文章收藏于IT老兵博客。
正文
理解一下@RestControlle的作用。
This code uses Spring 4’s new
@RestController
annotation, which marks the class as a controller where every method returns a domain object instead of a view. It’s shorthand for@Controller
and@ResponseBody
rolled together.
上文摘自官网。
由上面可见,@RestController=@Controller+@ResponseBody,下一步,理解@Controller。
Classic controllers can be annotated with the @Controller annotation. This is simply a specialization of the @Component class and allows implementation classes to be autodetected through the classpath scanning.
@Controller is typically used in combination with a @RequestMapping annotation used on request handling methods.
摘自这里,可以看出以下几点:
- @Controller 是一种特殊化的@Component 类。
- @Controller 习惯于和@RequestMapping绑定来使用,后者是用来指定路由映射的。
下一步,理解@ResponseBody。
The request handling method is annotated with @ResponseBody. This annotation enables automatic serialization of the return object into the HttpResponse.
摘自同样的地方,这里可以看出:
- @ResponseBody 是用来把返回对象自动序列化成HttpResponse的。
再参考这里:
3. @ResponseBody
The @ResponseBody annotation tells a controller that the object returned is automatically serialized into JSON and passed back into the HttpResponse object.
Suppose we have a custom Response object:
1
2
3
4
5
public
class
ResponseTransfer {
private
String text;
// standard getters/setters
}
Next, the associated controller can be implemented:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Controller
@RequestMapping
(
"/post"
)
public
class
ExamplePostController {
@Autowired
ExampleService exampleService;
@PostMapping
(
"/response"
)
@ResponseBody
public
ResponseTransfer postResponseController(
@RequestBody
LoginForm loginForm) {
return
new
ResponseTransfer(
"Thanks For Posting!!!"
);
}
}
In the developer console of our browser or using a tool like Postman, we can see the following response:
1
{"text":"Thanks For Posting!!!"}
Remember, we don’t need to annotate the @RestController-annotated controllers with the @ResponseBody annotation since it’s done by default here.
从上面可以看出:
- @ResponseBody告诉控制器返回对象会被自动序列化成JSON,并且传回HttpResponse这个对象。
再补充一下@RequestBody:
Simply put, the @RequestBody annotation maps the HttpRequest body to a transfer or domain object, enabling automatic deserialization of the inbound HttpRequest body onto a Java object.
First, let’s have a look at a Spring controller method:
1
2
3
4
5
6
7
@PostMapping
(
"/request"
)
public
ResponseEntity postController(
@RequestBody
LoginForm loginForm) {
exampleService.fakeAuthenticate(loginForm);
return
ResponseEntity.ok(HttpStatus.OK);
}
Spring automatically deserializes the JSON into a Java type assuming an appropriate one is specified. By default, the type we annotate with the @RequestBody annotation must correspond to the JSON sent from our client-side controller:
1
2
3
4
5
public
class
LoginForm {
private
String username;
private
String password;
// ...
}
Here, the object we use to represent the HttpRequest body maps to our LoginForm object.
Let’s test this using CURL:
1
2
3
4
5
curl -i \
-H
"Accept: application/json"
\
-H
"Content-Type:application/json"
\
-X POST --data
'{"username": "johnny", "password": "password"}'
"https://localhost:8080/.../request"
This is all that is needed for a Spring REST API and an Angular client using the @RequestBody annotation!
@RequestBody把HttpRequest body映射成一个 transfer or domain object(DTO或者DO),把一个入境(inbound)的HttpRequest的body反序列化成一个Java对象。
参考
https://spring.io/guides/gs/rest-service/
https://www.baeldung.com/spring-controller-vs-restcontroller
https://www.baeldung.com/spring-request-response-body
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/149858.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...