- 浏览: 1111043 次
文章分类
- 全部博客 (379)
- S2SH (16)
- stuts2 (0)
- java语言 (81)
- JSP (17)
- <html>元素 (11)
- javaweb (4)
- web容器 (3)
- ext (23)
- javaScript (48)
- ant (1)
- liferay (1)
- sql (9)
- css (42)
- 浏览器设置 (3)
- office_world (1)
- eclipse (4)
- 其它 (28)
- 操作系统 (5)
- android (6)
- Struts2 (11)
- RegEx (3)
- mysql (5)
- BigDATA (1)
- Node.js (1)
- Algorithm (10)
- Apache Spark (1)
- 数据库 (5)
- linux (2)
- git (1)
- Adobe (3)
- java语言,WebSocket (1)
- Maven (3)
- SHELL (1)
- XML (2)
- 数学 (2)
- Python (2)
- Java_mysql (1)
- ReactJS (6)
- 养生 (4)
- Docker (1)
- Protocols (3)
- java8 (2)
- 书籍 (1)
- Gradle (2)
- AngularJS (5)
- SpringMVC (2)
- SOAP (1)
- BootstrapCSS (1)
- HTTP协议 (1)
- OAuth2 (1)
最新评论
-
Lixh1986:
Java并发编程:自己动手写一把可重入锁https://blo ...
Java之多线程之Lock与Condition -
Lixh1986:
http://win.51apps.com.cn/https: ...
temp -
ztwsl:
不错,支持很好
HttpServletRequest和ServletRequest的区别 -
guodongkai:
谢谢您能将知识精华汇编总结,让初学者们从原理中学会和提高。
javaScript之function定义 -
kangwen23:
谢谢了,顶顶
struts2中的ValueStack学习
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:
2. pom.xml
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
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
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
@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
-
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
-
发表评论
-
Spring之Interceptor之path patterns路径匹配规则
2018-12-26 11:20 8762Spring之Interceptor之path pattern ... -
Spring4.X之Constructor Injection 构造方法注入
2018-12-24 17:37 1567Spring4.X之Constructor Injection ... -
SpringMVC之@RequestMapping @ResponseBody 和 @RequestBody 注解的用法
2018-05-30 10:55 15791、@RequestMapping @RequestMappi ... -
Spring4.X之Bean的Scope
2017-11-06 16:29 1197https://docs.spring.io/spring/d ... -
Spring4.X之基于Java注解的配置(与SpringBoot的诞生)
2017-11-02 16:57 4145最近项目用到了SpringBoot,对其没有xml配置就可以运 ... -
02 - Difference between spring @Controller and @RestController annotation
2017-09-25 17:04 885Difference between spring @Con ... -
01 -Spring Framework: @RestController vs. @Controller
2017-09-25 16:45 744Spring MVC Framework and REST ... -
Spring - MVC 思维导图,让Spring不再难懂
2017-08-09 03:21 1077引用: http://www.iteye.com/news/3 ... -
hibernate merge与update区别
2017-04-18 15:38 2193今天做了个测试,写了 ... -
Struts2拦截器原理以及实例
2017-02-15 12:49 468Struts2拦截器原理以及实例 http://www.cnb ... -
SSH之Struts2 VS. SpringMVC
2017-02-07 10:26 989Struts 2 vs SpringMVC - Battl ... -
Maven之POM之SSH之libs之configuration
2017-02-05 08:56 778Maven repo libs: Servlet API, ... -
Hibernate自定义查询
2014-02-24 16:29 1580public void addCarmera(Carmera ... -
Hibernate对象的生命周期
2013-07-10 16:32 1831一、情景描述 鉴于:hibernate是面向对象(实体、en ... -
通过配置struts.xml解决 struts2和 dwr兼容的问题
2012-11-20 10:20 2077众所周知,strust2 通过在 web.xml中配置 fil ...
相关推荐
SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目(毕业设计) SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目(毕业设计) SpringBoot毕设资源--springboot+mybatis+restful实现论坛项目...
在本项目"Android-SpringBoot-MyBatis-RESTful-登录注册修改密码Demo"中,我们探讨了如何构建一个完整的后端与移动端交互的系统,涵盖了多种技术栈的使用,包括Android、SpringBoot、MyBatis以及RESTful API的设计。...
标题 "Webserver-springboot: springboot + Jpa + RESTful API" 描述了一个使用Spring Boot框架、JPA(Java Persistence API)以及RESTful API技术构建的后台服务项目。这个项目名为“fangzhi webserver”,它基于...
RESTful是Web服务的一种设计风格,强调资源的表述状态转移。在本项目中,我们将创建一套RESTful API,通过HTTP方法(GET、POST、PUT、DELETE)实现对数据的CRUD操作。这有助于实现无状态、可缓存的服务,并且易于...
X-SpringBoot|| |项目说明X-SpringBoot是一个轻量级的Java快速开发平台,基于各大开源项目组合而来,用于快速构建中小型API,RESTful API项目,该项目已经有过多个真实项目的实践,稳定,简单,快速,使我们可以那些...
3. **嵌入式Web服务器**:SpringBoot支持内嵌Tomcat、Jetty等Web服务器,避免了传统方式下需要单独部署服务器的步骤。zzw-springboot项目中,通过`spring-boot-starter-web` starter,我们使用的是内嵌的Tomcat。 4...
springboot-restful-starter SpringBoot RESTful API脚手架简介这是一个基于SpringBoot 2.1.1 RELEASE ,用于构建RESTful API工程的脚手架,只需三分钟你就可以开始编写业务代码,不再烦恼于建造项目与风格统一。...
SpringBoot Restful Web服务示例 这个宁静的WS有2个端点: 交易后 http://localhost:9005/transactions 如果时间戳比以前的60秒新,则只允许发布请求并接受事务。 如果请求符合保存条件,它将返回HTTP状态代码201...
总结,"medium-springboot"项目为学习和实践SpringBoot提供了具体的应用场景,通过这个项目,我们可以深入了解SpringBoot的各个功能,并掌握如何将其应用于实际的Web开发中。同时,结合Medium API的集成,还能学习到...
在本文中,我们将深入探讨如何使用SpringBoot框架与Jersey库整合来实现RESTful Web服务,并同时集成Spring MVC。这将使我们能够构建一个高效、灵活的后端系统,为客户端提供API接口。 首先,SpringBoot是Spring框架...
lab-springboot-rest-sample Spring Boot RESTful 服务研讨会的示例代码该代码基于 Greg Young 引入的 CQRS 模式(命令查询职责分离),将读/写操作的模型解耦。 Martin Fowler 在他的博客 ( ) 中更好地描述了该模式...
SpringBoot-Restful-Webservice RestfulWebserviceSpringBoot 用于使用邮递员进行测试启动应用程序时,它将创建10名员工,其ID从1到10。ID为AutoIncrement 获取所有员工GET ...
- SpringBoot 支持创建 RESTful 风格的 Web 应用,可以使用 Spring MVC 框架或 Spring WebFlux。`@RestController`注解用于标记控制器类,而`@RequestMapping`、`@GetMapping`、`@PostMapping`等用于处理 HTTP 请求...
此外,还提供了RESTful API,便于进行程序化操作或与其他系统集成。 综上所述,该压缩包`xxl-job-springboot`可能是用于演示或快速启动XXL-Job在SpringBoot环境下的集成项目,包含了必要的配置和代码示例,可以帮助...
- RESTful API:可能使用Spring Web MVC来实现RESTful服务接口,便于前后端分离。 - 响应式编程:Spring WebFlux或R2DBC可以用于实现非阻塞式的响应式应用,提高系统性能。 - 配合前端框架:如React、Vue.js或...
综上所述,"aipets-springboot"项目是一个利用SpringBoot框架构建的AI宠物服务端,集成了数据库操作、RESTful API设计、AI功能实现等多种技术,旨在为用户提供智能化的宠物管理体验。通过深入理解SpringBoot的原理和...
REST(Representational State Transfer)是一种架构风格,用于构建Web服务,强调资源的表示和操作。Spring Boot是一个流行的Java框架,简化了Spring应用的创建,提供了一种快速开发RESTful API的方法。 首先,我们...
shiro 的 RBAC 权限控制,能动态配置菜单、 角色、权限等(用户对应角色(1对多),角色对应权限(1对多),菜单对应权限(1对1))统一异常处理及返回数据统一封装后端 RESTful api 设计开发、部署简单,能实现前后端同时...
SpringBoot还常常结合Spring Data、MyBatis、Hibernate等持久层框架处理数据库操作,利用Spring Security进行权限管理,结合Thymeleaf、FreeMarker等模板引擎实现动态页面渲染,还可以与WebSocket、RESTful API、...