使用SpringBoot构建REST服务-什么是REST服务

最新推荐文章于 2024-08-20 18:22:37 发布
最新推荐文章于 2024-08-20 18:22:37 发布
阅读量262 收藏
点赞数
文章标签： rest
原文链接：https://www.cnblogs.com/viwofer/p/13225958.html
版权

前言：

本文按照Spring官网构建REST服务的步骤测试，可以得到结论：

到底什么样的风格才是RESTful风格呢？

1，约束请求命令如下：

GET，获取资源。例如：/employees表示获取列表资源，/employees/{id}表示获取单个对象资源。
POST，新增。例如：/employees，body为json对象，表示新增。
PUT，更新。例如：/employees/{id}，body为json对象，表示更新。
DELETE，删除。例如： /employees/{id}，表示删除。
2，约束返回结果： 返回数据为列表，则每个对象资源附加自己的资源链接、列表资源链接以及可操作性链接。

参考链接：

官网demo地址：https://spring.io/guides/tutorials/bookmarks/
官网demo的git地址：https://github.com/spring-guides/tut-rest/
官网demo按照如下步骤介绍如何使用SpringBoot构建REST服务，并强调

Pretty URLs like /employees/3 aren’t REST.

Merely using GET, POST, etc. aren’t REST.

Having all the CRUD operations laid out aren’t REST.

一、普通的http服务
pom.xml文件如下所示：

复制代码

<?xml version="1.0" encoding="UTF-8"?>


4.0.0
com.htkm.demo
demo-restful
0.0.1-SNAPSHOT
demo-restful
Demo project for Spring Boot

<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.3.0.RELEASE</spring-boot.version>



org.springframework.boot
spring-boot-starter-web


org.springframework.boot
spring-boot-starter-hateoas


org.springframework.boot
spring-boot-starter-data-jpa


org.projectlombok
lombok


com.h2database
h2
runtime





org.springframework.boot
spring-boot-dependencies
${spring-boot.version}
pom
import






org.apache.maven.plugins
maven-compiler-plugin

1.8
1.8
UTF-8



org.springframework.boot
spring-boot-maven-plugin




复制代码
JPA类型的实体类：

复制代码
@Data
@Entity
public class Employee {
@Id
@GeneratedValue
private Long id;
private String name;
private String role;
public Employee() {}
public Employee(String name, String role) {
this.name = name;
this.role = role;
}
}
复制代码
使用H2内存数据库，创建测试数据库：

复制代码
@Configuration
@Slf4j
public class LoadDatabase {
@Bean
CommandLineRunner initDatabase(EmployeeRepository repository) {
return args -> {
log.info("Preloading " + repository.save(new Employee(“Bilbo Baggins”, “burglar”)));
log.info("Preloading " + repository.save(new Employee(“Frodo Baggins”, “thief”)));
};
}
}
复制代码
JPA类型的DAO：

public interface EmployeeRepository extends JpaRepository<Employee, Long> {}
EmployeeContrller控制器：

复制代码
@RestController
public class EmployeeController {
@Autowired
private EmployeeRepository repository;

@GetMapping("/employees")
List<Employee> all() {
    return repository.findAll();
}
@PostMapping("/employees")
Employee newEmployee(@RequestBody Employee newEmployee) {
    return repository.save(newEmployee);
}
@GetMapping("/employees/{id}")
Employee one(@PathVariable Long id) {
    return repository.findById(id)
            .orElseThrow(() -> new EmployeeNotFoundException(id));
}
@PutMapping("/employees/{id}")
Employee replaceEmployee(@RequestBody Employee newEmployee, @PathVariable Long id) {
    return repository.findById(id)
            .map(employee -> {
                employee.setName(newEmployee.getName());
                employee.setRole(newEmployee.getRole());
                return repository.save(employee);
            })
            .orElseGet(() -> {
                newEmployee.setId(id);
                return repository.save(newEmployee);
            });
}
@DeleteMapping("/employees/{id}")
void deleteEmployee(@PathVariable Long id) {
    repository.deleteById(id);
}

}
复制代码
自定义异常：

public class EmployeeNotFoundException extends RuntimeException {
public EmployeeNotFoundException(Long id) {
super("Could not find employee " + id);
}
}
增加@ControllerAdvice注解，实现异常处理器：

复制代码
@ControllerAdvice
public class EmployeeNotFoundAdvice {
@ResponseBody
@ExceptionHandler(EmployeeNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
String employeeNotFoundHandler(EmployeeNotFoundException ex) {
return ex.getMessage();
}
}
复制代码
使用postman或者curl工具测试执行：

1，GET http://localhost:8080/employees

复制代码
[
{
“id”: 1,
“name”: “Bilbo Baggins”,
“role”: “burglar”
},
{
“id”: 2,
“name”: “Frodo Baggins”,
“role”: “thief”
}
]
复制代码
2，GET http://localhost:8080/employees/1

{
“id”: 1,
“name”: “Bilbo Baggins”,
“role”: “burglar”
}
3，DELETE http://localhost:8080/employees/1 资源被删除

二、restful的http服务
pom.xml增加hateoas依赖 ：

org.springframework.boot spring-boot-starter-hateoas 控制器更改，在原来的返回json基础之上附加操作链接，红色加粗部分可以重构简化，在下一章节。

复制代码
@GetMapping("/employees")
CollectionModel<EntityModel> all() {
List<EntityModel> employees = repository.findAll().stream()
.map(employee -> EntityModel.of(employee,
linkTo(methodOn(EmployeeController.class).one(employee.getId())).withSelfRel(), // 附加自身链接
linkTo(methodOn(EmployeeController.class).all()).withRel(“employees”))) // 附加all操作链接
.collect(Collectors.toList());
return CollectionModel.of(employees, linkTo(methodOn(EmployeeController.class).all()).withSelfRel()); // 附加自身链接
}
@GetMapping("/employees/{id}")
EntityModel one(@PathVariable Long id) {
Employee employee = repository.findById(id) //
.orElseThrow(() -> new EmployeeNotFoundException(id));

return EntityModel.of(employee,             linkTo(methodOn(EmployeeController.class).one(id)).withSelfRel(),  // 附加自身链接
        linkTo(methodOn(EmployeeController.class).all()).withRel("employees")); // 附加all操作链接

}
复制代码
Postman测试执行

1，GET http://localhost:8080/employees，可以看到附加链接

复制代码
{
“_embedded”: {
“employeeList”: [
{
“id”: 1,
“name”: “Bilbo Baggins”,
“role”: “burglar”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees/1”
},
“employees”: {
“href”: “http://localhost:8080/employees”
}
}
},
{
“id”: 2,
“name”: “Frodo Baggins”,
“role”: “thief”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees/2”
},
“employees”: {
“href”: “http://localhost:8080/employees”
}
}
}
]
},
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees”
}
}
}
复制代码
2，GET http://localhost:8080/employees/1

复制代码
{
“id”: 1,
“name”: “Bilbo Baggins”,
“role”: “burglar”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees/1”
},
“employees”: {
“href”: “http://localhost:8080/employees”
}
}
}
复制代码

三、扩展的restful服务
扩展实体，将name拆分为fristname和lastname，同时通过增加虚拟的get/set保留name属性：

复制代码
@Data
@Entity
public class Employee {
@Id
@GeneratedValue
private Long id;
private String firstName;
private String lastName;
private String role;
public Employee() {}
public Employee(String firstName, String lastName, String role) {
this.firstName = firstName;
this.lastName = lastName;
this.role = role;
}
public String getName() {
return this.firstName + " " + this.lastName;
}
public void setName(String name) {
String[] parts = name.split(" ");
this.firstName = parts[0];
this.lastName = parts[1];
}
}
复制代码
重构简化代码，增加对象包装处理类 ：

复制代码
@Component
class EmployeeModelAssembler implements RepresentationModelAssembler<Employee, EntityModel> {

@Override
public EntityModel<Employee> toModel(Employee employee) {
    return EntityModel.of(employee, 
            linkTo(methodOn(EmployeeController.class).one(employee.getId())).withSelfRel(),
            linkTo(methodOn(EmployeeController.class).all()).withRel("employees"));
}

}
复制代码
控制器更改：

复制代码
@RestController
public class EmployeeController {

@Autowired
private EmployeeRepository repository;

@Autowired
private EmployeeModelAssembler assembler;

@GetMapping("/employees")
CollectionModel<EntityModel<Employee>> all() {
    List<EntityModel<Employee>> employees = repository.findAll().stream()
            .map(assembler::toModel)  // 包装对象
            .collect(Collectors.toList());
    return CollectionModel.of(employees, linkTo(methodOn(EmployeeController.class).all()).withSelfRel()); // 附加自身链接
}

@PostMapping("/employees")
ResponseEntity<?> newEmployee(@RequestBody Employee newEmployee) {
    EntityModel<Employee> entityModel = assembler.toModel(repository.save(newEmployee));
    return ResponseEntity
            .created(entityModel.getRequiredLink(IanaLinkRelations.SELF).toUri())
            .body(entityModel); // 返回状态码201，增加Location头 http://localhost:8080/employees/3

}

@GetMapping("/employees/{id}")
EntityModel<Employee> one(@PathVariable Long id) {
    Employee employee = repository.findById(id) //
            .orElseThrow(() -> new EmployeeNotFoundException(id));

    return assembler.toModel(employee); // 包装对象
}

@PutMapping("/employees/{id}")
ResponseEntity<?> replaceEmployee(@RequestBody Employee newEmployee, @PathVariable Long id) {
    Employee updatedEmployee = repository.findById(id) //
            .map(employee -> {
                employee.setName(newEmployee.getName());
                employee.setRole(newEmployee.getRole());
                return repository.save(employee);
            }) //
            .orElseGet(() -> {
                newEmployee.setId(id);
                return repository.save(newEmployee);
            });
    EntityModel<Employee> entityModel = assembler.toModel(updatedEmployee);
    return ResponseEntity
            .created(entityModel.getRequiredLink(IanaLinkRelations.SELF).toUri())
            .body(entityModel); // 返回状态码201，增加Location头 http://localhost:8080/employees/3

}

@DeleteMapping("/employees/{id}")
ResponseEntity<?> deleteEmployee(@PathVariable Long id) {
    repository.deleteById(id);
    return ResponseEntity.noContent().build();// 返回状态码204

}

}
复制代码
curl测试执行

$ curl -v -X POST localhost:8080/employees -H ‘Content-Type:application/json’ -d ‘{“name”: “Samwise Gamgee”, “role”: “gardener”}’

请求相应状态为201，包含Location 响应头

复制代码

POST /employees HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.54.0
Accept: /
Content-Type:application/json
Content-Length: 46

< Location: http://localhost:8080/employees/3
< Content-Type: application/hal+json;charset=UTF-8
< Transfer-Encoding: chunked
< Date: Fri, 10 Aug 2018 19:44:43 GMT
<
{
“id”: 3,
“firstName”: “Samwise”,
“lastName”: “Gamgee”,
“role”: “gardener”,
“name”: “Samwise Gamgee”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees/3”
},
“employees”: {
“href”: “http://localhost:8080/employees”
}
}
}
复制代码
$ curl -v -X PUT localhost:8080/employees/3 -H ‘Content-Type:application/json’ -d ‘{“name”: “Samwise Gamgee”, “role”: “ring bearer”}’

复制代码

PUT /employees/3 HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.54.0
Accept: /
Content-Type:application/json
Content-Length: 49

< HTTP/1.1 201
< Location: http://localhost:8080/employees/3
< Content-Type: application/hal+json;charset=UTF-8
< Transfer-Encoding: chunked
< Date: Fri, 10 Aug 2018 19:52:56 GMT
{
“id”: 3,
“firstName”: “Samwise”,
“lastName”: “Gamgee”,
“role”: “ring bearer”,
“name”: “Samwise Gamgee”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/employees/3”
},
“employees”: {
“href”: “http://localhost:8080/employees”
}
}
}
复制代码
$ curl -v -X DELETE localhost:8080/employees/1

复制代码

DELETE /employees/1 HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.54.0
Accept: /

< HTTP/1.1 204
< Date: Fri, 10 Aug 2018 21:30:26 GMT
复制代码

四、附加可操作链接的restful服务
订单实体转换器,如果订单状态为可执行的订单则附加取消和完成链接 ：

复制代码
@Component
public class OrderModelAssembler implements RepresentationModelAssembler<Order, EntityModel> {
@Override
public EntityModel toModel(Order order) {
// Unconditional links to single-item resource and aggregate root
EntityModel orderModel = EntityModel.of(order,
linkTo(methodOn(OrderController.class).one(order.getId())).withSelfRel(),
linkTo(methodOn(OrderController.class).all()).withRel(“orders”));
// Conditional links based on state of the order
if (order.getStatus() == Status.IN_PROGRESS) {
orderModel.add(linkTo(methodOn(OrderController.class).cancel(order.getId())).withRel(“cancel”)); // 附加cancel链接
orderModel.add(linkTo(methodOn(OrderController.class).complete(order.getId())).withRel(“complete”)); // 附加complete链接
}
return orderModel;
}
}
复制代码
控制器中取消和完成操作

复制代码
@DeleteMapping("/orders/{id}/cancel")
ResponseEntity<?> cancel(@PathVariable Long id) {

  Order order = orderRepository.findById(id)
        .orElseThrow(() -> new OrderNotFoundException(id));

  if (order.getStatus() == Status.IN_PROGRESS) {
     order.setStatus(Status.CANCELLED);
     return ResponseEntity.ok(assembler.toModel(orderRepository.save(order)));
  }

  return ResponseEntity
        .status(HttpStatus.METHOD_NOT_ALLOWED)
        .header(HttpHeaders.CONTENT_TYPE, MediaTypes.HTTP_PROBLEM_DETAILS_JSON_VALUE)
        .body(Problem.create()
              .withTitle("Method not allowed")
              .withDetail("You can't cancel an order that is in the " + order.getStatus() + " status"));

}
@PutMapping("/orders/{id}/complete")
ResponseEntity<?> complete(@PathVariable Long id) {

  Order order = orderRepository.findById(id)
        .orElseThrow(() -> new OrderNotFoundException(id));

  if (order.getStatus() == Status.IN_PROGRESS) {
     order.setStatus(Status.COMPLETED);
     return ResponseEntity.ok(assembler.toModel(orderRepository.save(order)));
  }

  return ResponseEntity
        .status(HttpStatus.METHOD_NOT_ALLOWED)
        .header(HttpHeaders.CONTENT_TYPE, MediaTypes.HTTP_PROBLEM_DETAILS_JSON_VALUE)
        .body(Problem.create()
              .withTitle("Method not allowed")
              .withDetail("You can't complete an order that is in the " + order.getStatus() + " status"));

}
复制代码
PostMan测试执行：

1，GET http://localhost:8080

复制代码
{
“_links”: {
“employees”: {
“href”: “http://localhost:8080/employees”
},
“orders”: {
“href”: “http://localhost:8080/orders”
}
}
}
复制代码
2，GET http://localhost:8080/orders

复制代码
{
“_embedded”: {
“orderList”: [
{
“id”: 3,
“description”: “MacBook Pro”,
“status”: “COMPLETED”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/3”
},
“orders”: {
“href”: “http://localhost:8080/orders”
}
}
},
{
“id”: 4,
“description”: “iPhone”,
“status”: “IN_PROGRESS”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/4”
},
“orders”: {
“href”: “http://localhost:8080/orders”
},
“cancel”: {
“href”: “http://localhost:8080/orders/4/cancel”
},
“complete”: {
“href”: “http://localhost:8080/orders/4/complete”
}
}
}
]
},
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders”
}
}
}
复制代码
3，DELETE http://localhost:8080/orders/3/cancel

{
“title”: “Method not allowed”,
“detail”: “You can’t cancel an order that is in the COMPLETED status”
}
4，DELETE http://localhost:8080/orders/4/cancel

复制代码
{
“id”: 4,
“description”: “iPhone”,
“status”: “CANCELLED”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/4”
},
“orders”: {
“href”: “http://localhost:8080/orders”
}
}
}
复制代码
5，POST localhost:8080/orders

设置header为Content-Type:application/json

body为{“name”: “Samwise Gamgee”, “role”: “gardener”}’

复制代码
{
“id”: 5,
“description”: “新的订单”,
“status”: “IN_PROGRESS”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/5”
},
“orders”: {
“href”: “http://localhost:8080/orders”
},
“cancel”: {
“href”: “http://localhost:8080/orders/5/cancel”
},
“complete”: {
“href”: “http://localhost:8080/orders/5/complete”
}
}
}
复制代码
五、总结
RESTful风格的http服务，包含以下特征（百度百科摘录）：

1、每一个URI代表1种资源；
2、客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源；
3、通过操作资源的表现形式来操作资源；
4、资源的表现形式是XML或HTML；
5、客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。
官网demo描述：

  What’s important to realize is that REST, however ubiquitous, is not a standard, per se, but an approach, a style, a set of constraints on your architecture that can help you build web-scale systems.

到底什么样的风格才是为RESTful风格呢？

首先约束请求命令如下：

GET，获取资源。例如：/employees表示获取列表资源，/employees/{id}表示获取单个对象资源。
POST，新增。例如：/employees，body为json对象，表示新增。
PUT，更新。例如：/employees/{id}，body为json对象，表示更新。
DELETE，删除。例如： /employees/{id}，表示更新。
其次约束返回结果： 返回数据为列表，则每个对象资源附加自己的资源链接、列表资源链接以及可操作性链接。

以下例子是可能的返回结果：

复制代码
{
“_embedded”: {
“orderList”: [
{
“id”: 3,
“description”: “MacBook Pro”,
“status”: “COMPLETED”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/3”
},
“orders”: {
“href”: “http://localhost:8080/orders”
}
}
},
{
“id”: 4,
“description”: “iPhone”,
“status”: “IN_PROGRESS”,
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders/4”
},
“orders”: {
“href”: “http://localhost:8080/orders”
},
“cancel”: {
“href”: “http://localhost:8080/orders/4/cancel”
},
“complete”: {
“href”: “http://localhost:8080/orders/4/complete”
}
}
}
]
},
“_links”: {
“self”: {
“href”: “http://localhost:8080/orders”
}
}
}

zhaimouren123
关注
SpringBoot整合Elasticsearch-elasticsearch-rest-high-level-client
程序员劝退师的博客
07-11 1万+
前言 在前面几篇文章中演示ES安装时对外暴露有两个端口，一个是9200，一个是9300，这里9300是一个TCP端口，ES集群环境下也是通过9300端口通信的，是长连接的形式通信的，这里不推荐使用SpringBoot操作9300端口通信，其原因有两个， 第一个：是由于SpringBoot的版本不同，整合的ES版本也不同，而且最新的SpringBoot也没整合到7.X版本，只整合到6.X.X,那么版本不适配就会倒是语法问题 第二点：是ES 官方在7.X版本就已经不建议使用9300端口了，将在8.X废弃9300
REST Service 开发 - 客户端
pmlpml的专栏
04-22 4125
REST Service 的客户端开发是比较简单的，每种框架都提供了各种访问服务端的实现，如 Apache Httpclient, JAX-RS2 client，Feign Client。本文重点罗列客户端异步服务编排技术，服务端异步技术，这些将使得你的云服务更加健壮、高效。
REST服务介绍
weixin_30877755的博客
01-28 83
RESTful service是一种架构模式，近几年比较流行了，它的轻量级web服务，发挥HTTP协议的原生的GET，PUT，POST，DELETE。 REST模式的Web服务与复杂的SOAP和XML-RPC对比来讲明显的更加简洁，越来越多的web服务开始采用REST风格设计和实现。例如，Amazon.com提供接近REST风格的Web服务进行图书查找；雅虎提供的Web...
Spring REST 教程（一）
最新发布
龙哥盟
08-20 1309
在本章中，我们将学习以下内容:休止符基础REST 资源及其表示HTTP 方法和状态代码理查森的成熟度模型今天，网络已经成为我们生活中不可或缺的一部分——从在脸书上查看状态到在线订购产品，再到通过电子邮件交流。Web 的成功和无处不在导致组织将 Web 的架构原则应用于构建分布式应用。在这一章中，我们将深入 REST，一种形式化这些原则的架构风格。REST 代表表述性状态转移，是一种用于设计分布式网络应用的架构风格。罗伊·菲尔丁在他的博士论文1。
REST 服务
qq_43806430的博客
11-15 569
例如服务端通过token缓存已登录过的用户信息，客户端请求会带一个token过来，后台服务通过带过来的token在缓存中取出用户信息，提高效率。Server提供的RESTful API中，URL中只使用名词来指定资源，原则上不使用动词。Server和Client之间传递某资源的一个表现形式，比如用JSON，XML传输文本，或者用JPG，WebP传输图片等。例如，一个项目的所有模块都整合到一起，all-in-one，打成一个包，多个服务，整合到一个端口下。用HTTP协议里的动词来实现资源的添加，修改。
REST服务
u011460876的专栏
04-24 205
REST：即 Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便， 所以正得到越来越多网站的采用；POST, DELETE, PUT, GET 分别对应 CRUD。Spring3.0 开始支持 REST 风格的请求，是通过 org.springframework.web.filter.H...
springboot-rest-api-design:使用SpringBoot的REST API设计
05-02
该应用程序是一个示例项目，演示了如何使用SpringBoot，SpringSecurity，Spring Data JPA构建REST API。 怎么跑？ 将BlogApplication.java作为Java应用程序运行。 要探索和调用REST端点，请访问 一些端点需要身份...
springboot-REST-jwt-h2-mariadb-starter:一个可以在任何tomcat服务器中部署的Springboot REST API
05-02
可部署的Springboot REST API 一个基于Springboot令牌的安全入门工具包，其数据库具有 （ ）MariaDB。 该项目在构建项目后即可部署，...git clone --depth 1 https://github.com/bfwg/springboot-angular-REST-jwt-de
Springboot-Rest-Hibernate-Spring-Data-JPA
04-06
在Spring Boot中，我们可以使用Spring MVC或Spring WebFlux构建RESTful API。 【Hibernate】 Hibernate是一个Java持久化框架，它提供了对象关系映射(ORM)功能，使开发者能够以面向对象的方式操作数据库，减少了对...
springboot-dubbox-simple：Dubbox整合Spring Boot基于Avro，Thrift协议构建REST服务
01-30
《Dubbox整合Spring Boot构建REST服务详解》 在现代企业级应用开发中，微服务架构逐渐成为主流。Spring Boot以其简洁、高效的特性深受开发者喜爱，而Dubbo作为阿里巴巴开源的一款高性能、轻量级的服务治理框架，也...
HTTP的REST服务简介和最佳实践
05-16
一说到REST，我想大家的第一反应就是“啊，就是那种前后台通信方式。”但是在要求详细讲述它所提出的各个约束，以及如何开始搭建REST服务时，却很少有人能够清晰地说出它到底是什么，需要遵守什么样的准则。 博文地址：https://blog.csdn.net/adparking/article/details/52278794 此PDF文档，只为方便阅读查看
最简单的Rest服务
panguoyuan的专栏
07-25 1297
1、编写提供外部访问的服务类 package com.rest.test; import java.net.URI; import java.util.logging.Level; import java.util.logging.Logger; import org.glassfish.grizzly.http.server.HttpServer; import org.glassfish
使用SpringBoot构建JSON REST服务
Spring Boot简化了构建REST服务的过程。使用Spring Boot，开发者可以快速创建独立的、生产级别的基于Spring的应用程序，无需大量的配置。在Spring Boot中，可以使用`@RestController`注解来标记控制器类，该类会处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值