`

03 - SpringBoot: Building a RESTful Web Service

    博客分类:
  • S2SH
阅读更多
Building a RESTful Web Service

This guide walks you through the process of creating a "hello world" RESTful web service with Spring.

What you’ll build
You’ll build a service that will accept HTTP GET requests at:
http://localhost:8080/greeting

and respond with a JSON representation of a greeting:
{"id":1,"content":"Hello, World!"}


You can customize the greeting with an optional name parameter in the query string:
http://localhost:8080/greeting?name=User

The name parameter value overrides the default value of "World" and is reflected in the response:
{"id":1,"content":"Hello, User!"}




What you’ll need

- About 15 minutes
- A favorite text editor or IDE
- JDK 1.8 or later
- Gradle 2.3+ or Maven 3.0+
- You can also import the code straight into your IDE:
   Spring Tool Suite (STS)
   IntelliJ IDEA





How to complete this guide

Like most Spring Getting Started guides, you can start from scratch and complete each step, or you can bypass basic setup steps that are already familiar to you. Either way, you end up with working code.

Build with Maven

1. Create the directory structure

In a project directory of your choosing, create the following subdirectory structure; for example, with mkdir -p src/main/java/hello on *nix systems:

└── src
    └── main
        └── java
            └── hello



2. pom.xml
<?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.springframework</groupId>
    <artifactId>gs-rest-service</artifactId>
    <version>0.1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <properties>
        <java.version>1.8</java.version>
    </properties>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-releases</id>
            <url>https://repo.spring.io/libs-release</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-releases</id>
            <url>https://repo.spring.io/libs-release</url>
        </pluginRepository>
    </pluginRepositories>
</project>



The Spring Boot Maven plugin provides many convenient features:

- It collects all the jars on the classpath and builds a single, runnable "über-jar", which makes it more convenient to execute and transport your service.

- It searches for the public static void main() method to flag as a runnable class.

- It provides a built-in dependency resolver that sets the version number to match Spring Boot dependencies. You can override any version you wish, but it will default to Boot’s chosen set of versions.




Create a resource representation class

To model the greeting representation, you create a resource representation class. Provide a plain old java object with fields, constructors, and accessors for the id and content data:

src/main/java/hello/Greeting.java
package hello;

public class Greeting {

    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId() {
        return id;
    }

    public String getContent() {
        return content;
    }
}

As you see in steps below, Spring uses the Jackson JSON library to automatically marshal instances of type Greeting into JSON.




Create a resource controller

In Spring’s approach to building RESTful web services, HTTP requests are handled by a controller. These components are easily identified by the @RestController annotation.

The GreetingController below handles GET requests for /greeting by returning a new instance of the Greeting class:


src/main/java/hello/GreetingController.java
package hello;

import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name", defaultValue="World") String name) {
        return new Greeting(counter.incrementAndGet(),
                            String.format(template, name));
    }
}


This controller is concise and simple, but there’s plenty going on under the hood.
Let’s break it down step by step.


- The @RequestMapping annotation ensures that HTTP requests to /greeting are mapped to the greeting() method.

The above example does not specify GET vs. PUT, POST, and so forth, because @RequestMapping maps all HTTP operations by default. Use @RequestMapping(method=GET) to narrow this mapping.


- @RequestParam binds the value of the query string parameter name into the name parameter of the greeting() method.

This query string parameter is explicitly marked as optional (required=true by default): if it is absent in the request, the defaultValue of "World" is used.


- The Greeting object must be converted to JSON. Thanks to Spring’s HTTP message converter support, you don’t need to do this conversion manually. Because Jackson 2 is on the classpath, Spring’s MappingJackson2HttpMessageConverter is automatically chosen to convert the Greeting instance to JSON.



A key difference between a traditional MVC controller and the RESTful web service controller above is the way that the HTTP response body is created.

Rather than relying on a view technology to perform server-side rendering of the greeting data to HTML, this RESTful web service controller simply populates and returns a Greeting object. The object data will be written directly to the HTTP response as JSON.


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.






Make the application executable

Although it is possible to package this service as a traditional WAR file for deployment to an external application server, the simpler approach demonstrated below creates a standalone application.

You package everything in a single, executable JAR file, driven by a good old Java main() method. Along the way, you use Spring’s support for embedding the Tomcat servlet container as the HTTP runtime, instead of deploying to an external instance.


src/main/java/hello/Application.java
package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}


@SpringBootApplication is a convenience annotation that adds all of the following:

- @Configuration tags the class as a source of bean definitions for the application context.

- @EnableAutoConfiguration tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.

- Normally you would add @EnableWebMvc for a Spring MVC app, but Spring Boot adds it automatically when it sees spring-webmvc on the classpath. This flags the application as a web application and activates key behaviors such as setting up a DispatcherServlet.

- @ComponentScan tells Spring to look for other components, configurations, and services in the hello package, allowing it to find the controllers.


The main() method uses Spring Boot’s SpringApplication.run() method to launch an application. Did you notice that there wasn’t a single line of XML? No web.xml file either. This web application is 100% pure Java and you didn’t have to deal with configuring any plumbing or infrastructure.






Build an executable JAR

You can run the application from the command line with Gradle or Maven.

Or you can build a single executable JAR file that contains all the necessary dependencies, classes, and resources, and run that.

This makes it easy to ship, version, and deploy the service as an application throughout the development lifecycle, across different environments, and so forth.


If you are using Maven, you can run the application using ./mvnw spring-boot:run. Or you can build the JAR file with:
./mvnw clean package.

Then you can run the JAR file:
java -jar target/gs-rest-service-0.1.0.jar


Logging output is displayed. The service should be up and running within a few seconds.


引用


The procedure above will create a runnable JAR.

You can also opt to build a classic WAR file instead.
https://spring.io/guides/gs/convert-jar-to-war/



-






-------------------------------------------------------------------

Spring 4.0 Restful 系列文章:


01 -Spring Framework: @RestController vs. @Controller
http://lixh1986.iteye.com/blog/2394351

02 - Difference between spring @Controller and @RestController annotation
http://lixh1986.iteye.com/blog/2394354

03 - SpringBoot: Building a RESTful Web Service
http://lixh1986.iteye.com/blog/2394363






- refer to :
https://spring.io/guides/gs/rest-service







-
分享到:
评论

相关推荐

    SpringBoot毕设资源-springboot+mybatis+restful实现论坛项目(毕业设计).zip

    SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目(毕业设计) SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目(毕业设计) SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目...

    Android-SpringBoot-MyBatis-RESTful-登录注册修改密码Demo

    在本项目"Android-SpringBoot-MyBatis-RESTful-登录注册修改密码Demo"中,我们探讨了如何构建一个完整的后端与移动端交互的系统,涵盖了多种技术栈的使用,包括Android、SpringBoot、MyBatis以及RESTful API的设计。...

    Webserver-springboot:springboot + Jpa + RESTful API

    标题 "Webserver-springboot: springboot + Jpa + RESTful API" 描述了一个使用Spring Boot框架、JPA(Java Persistence API)以及RESTful API技术构建的后台服务项目。这个项目名为“fangzhi webserver”,它基于...

    spring-boot-04-web-restfulcrud

    RESTful是Web服务的一种设计风格,强调资源的表述状态转移。在本项目中,我们将创建一套RESTful API,通过HTTP方法(GET、POST、PUT、DELETE)实现对数据的CRUD操作。这有助于实现无状态、可缓存的服务,并且易于...

    X-SpringBoot:X-SpringBoot是一个轻量级的Java快速开发平台,能快速开发项目并交付【接私活利器】

    X-SpringBoot|| |项目说明X-SpringBoot是一个轻量级的Java快速开发平台,基于各大开源项目组合而来,用于快速构建中小型API,RESTful API项目,该项目已经有过多个真实项目的实践,稳定,简单,快速,使我们可以那些...

    springboot底层机制实现: zzw-springboot项目

    3. **嵌入式Web服务器**:SpringBoot支持内嵌Tomcat、Jetty等Web服务器,避免了传统方式下需要单独部署服务器的步骤。zzw-springboot项目中,通过`spring-boot-starter-web` starter,我们使用的是内嵌的Tomcat。 4...

    springboot-restful-starter:SpringBoot RESTful API脚手架

    springboot-restful-starter SpringBoot RESTful API脚手架简介这是一个基于SpringBoot 2.1.1 RELEASE ,用于构建RESTful API工程的脚手架,只需三分钟你就可以开始编写业务代码,不再烦恼于建造项目与风格统一。...

    SpringBoot-Restful-Web-Service-Sample:SpringBoot Restful Web Service示例模拟了简单的2个事务操作

    SpringBoot Restful Web服务示例 这个宁静的WS有2个端点: 交易后 http://localhost:9005/transactions 如果时间戳比以前的60秒新,则只允许发布请求并接受事务。 如果请求符合保存条件,它将返回HTTP状态代码201...

    medium-springboot:Medium Blog上的medium-springboot

    总结,"medium-springboot"项目为学习和实践SpringBoot提供了具体的应用场景,通过这个项目,我们可以深入了解SpringBoot的各个功能,并掌握如何将其应用于实际的Web开发中。同时,结合Medium API的集成,还能学习到...

    使用SpringBoot整合jersey 实现Restful web service.同时整合springmvc。

    在本文中,我们将深入探讨如何使用SpringBoot框架与Jersey库整合来实现RESTful Web服务,并同时集成Spring MVC。这将使我们能够构建一个高效、灵活的后端系统,为客户端提供API接口。 首先,SpringBoot是Spring框架...

    lab-springboot-rest-sample:Spring Boot RESTful 服务的示例代码

    lab-springboot-rest-sample Spring Boot RESTful 服务研讨会的示例代码该代码基于 Greg Young 引入的 CQRS 模式(命令查询职责分离),将读/写操作的模型解耦。 Martin Fowler 在他的博客 ( ) 中更好地描述了该模式...

    SpringBoot-Restful-Webservice:Spring Boot Restful Web服务

    SpringBoot-Restful-Webservice RestfulWebserviceSpringBoot 用于使用邮递员进行测试启动应用程序时,它将创建10名员工,其ID从1到10。ID为AutoIncrement 获取所有员工GET ...

    demo-SpringBoot:SpringBoot示例代码

    - SpringBoot 支持创建 RESTful 风格的 Web 应用,可以使用 Spring MVC 框架或 Spring WebFlux。`@RestController`注解用于标记控制器类,而`@RequestMapping`、`@GetMapping`、`@PostMapping`等用于处理 HTTP 请求...

    xxl-job-springboot_xxl-job_

    此外,还提供了RESTful API,便于进行程序化操作或与其他系统集成。 综上所述,该压缩包`xxl-job-springboot`可能是用于演示或快速启动XXL-Job在SpringBoot环境下的集成项目,包含了必要的配置和代码示例,可以帮助...

    基于java的-149-springboot“漫画之家”系统--LW-源码.zip

    - RESTful API:可能使用Spring Web MVC来实现RESTful服务接口,便于前后端分离。 - 响应式编程:Spring WebFlux或R2DBC可以用于实现非阻塞式的响应式应用,提高系统性能。 - 配合前端框架:如React、Vue.js或...

    aipets-springboot:aipets springboot服务器端

    综上所述,"aipets-springboot"项目是一个利用SpringBoot框架构建的AI宠物服务端,集成了数据库操作、RESTful API设计、AI功能实现等多种技术,旨在为用户提供智能化的宠物管理体验。通过深入理解SpringBoot的原理和...

    RESTFUL的实现-springboot2.0版本

    REST(Representational State Transfer)是一种架构风格,用于构建Web服务,强调资源的表示和操作。Spring Boot是一个流行的Java框架,简化了Spring应用的创建,提供了一种快速开发RESTful API的方法。 首先,我们...

    antd-admin-springboot:基于 antd-admin 和 springboot 的前后端分离整合方案 http

    shiro 的 RBAC 权限控制,能动态配置菜单、 角色、权限等(用户对应角色(1对多),角色对应权限(1对多),菜单对应权限(1对1))统一异常处理及返回数据统一封装后端 RESTful api 设计开发、部署简单,能实现前后端同时...

    dangxia-springboot:当下app后台

    SpringBoot还常常结合Spring Data、MyBatis、Hibernate等持久层框架处理数据库操作,利用Spring Security进行权限管理,结合Thymeleaf、FreeMarker等模板引擎实现动态页面渲染,还可以与WebSocket、RESTful API、...

Global site tag (gtag.js) - Google Analytics