RESTLET开发实例(三)基于spring的REST服务
resttemplate使用实例
RestTemplate是Spring框架提供的一个用于访问REST服务的模板类。
它提供了许多便捷的方法来发送HTTP请求，并且可以方便地将响应结果转换为Java对象。
RestTemplate的使用非常灵活，可以应对各种复杂的REST服务场景。
在本文中，我们将结合一个实际的案例，介绍RestTemplate的基本用法和常见的使用场景。
通过阅读本文，您将了解到如何使用RestTemplate来访问REST服务，并且掌握一些常见的技巧和注意事项。
一、RestTemplate的基本用法1.1 创建RestTemplate对象要使用RestTemplate，首先需要创建一个RestTemplate对象。
在Spring Boot应用中，通常可以通过注入的方式来获取RestTemplate 对象。
例如：```javaAutowiredprivate RestTemplate restTemplate;```如果没有使用Spring Boot，可以通过new关键字来创建RestTemplate对象：```javaRestTemplate restTemplate = new RestTemplate();```1.2 发送HTTP请求RestTemplate提供了多种发送HTTP请求的方法，包括getForObject、postForObject、exchange等。
下面以发送GET请求为例，介绍如何使用getForObject方法发送HTTP请求并获取响应结果：```javaString url = "{id}";User user = restTemplate.getForObject(url, User.class, 1);```在上面的例子中，我们使用getForObject方法发送了一个GET请求，并将响应结果转换为User对象。
在这个例子中，我们还使用了占位符{id}来替换URL中的参数。
restapi设计举例
restapi设计举例REST（Representational State Transfer）是一种软件架构风格，用于构建网络服务。
它基于HTTP协议，通过定义一组规范和约束来实现分布式系统的通信。
RESTful API是一种遵循REST原则的API 设计风格，它使用HTTP方法来实现资源的增删改查操作。
下面我将举例介绍十个符合RESTful API设计的实例。
1. 用户管理API- 创建用户：使用POST方法，请求体中包含用户信息，返回创建的用户资源。
- 获取用户列表：使用GET方法，返回所有用户资源的列表。
- 获取指定用户：使用GET方法，传入用户ID，返回指定用户资源。
- 更新用户：使用PUT方法，传入用户ID和更新的信息，返回更新后的用户资源。
- 删除用户：使用DELETE方法，传入用户ID，删除指定用户资源。
2. 文章管理API- 创建文章：使用POST方法，请求体中包含文章内容，返回创建的文章资源。
- 获取文章列表：使用GET方法，返回所有文章资源的列表。
- 获取指定文章：使用GET方法，传入文章ID，返回指定文章资源。
- 更新文章：使用PUT方法，传入文章ID和更新的内容，返回更新后的文章资源。
- 删除文章：使用DELETE方法，传入文章ID，删除指定文章资源。
3. 商品管理API- 创建商品：使用POST方法，请求体中包含商品信息，返回创建的商品资源。
- 获取商品列表：使用GET方法，返回所有商品资源的列表。
- 获取指定商品：使用GET方法，传入商品ID，返回指定商品资源。
- 更新商品：使用PUT方法，传入商品ID和更新的信息，返回更新后的商品资源。
- 删除商品：使用DELETE方法，传入商品ID，删除指定商品资源。
4. 订单管理API- 创建订单：使用POST方法，请求体中包含订单信息，返回创建的订单资源。
- 获取订单列表：使用GET方法，返回所有订单资源的列表。
- 获取指定订单：使用GET方法，传入订单ID，返回指定订单资源。
resttemplate 常用方法
resttemplate 常用方法RestTemplate 是 Spring 提供的一个用于远程调用 RESTful 服务的工具类，支持常见的 HTTP 请求协议，如 GET、POST、PUT、DELETE 等。
本文将介绍 RestTemplate 常用的方法，包括：1. 构造方法2. 请求方法3. 响应方法4. 错误处理方法5. 其他方法1. 构造方法RestTemplate 的构造方法有多种，我们可以选择使用默认构造方法或者自定义构造方法。
默认构造方法不需要参数，直接创建一个 RestTemplate 实例：```javaRestTemplate restTemplate = new RestTemplate();```如果我们需要在构造 RestTemplate 实例时添加一些自定义配置，如设置超时时间等，可以使用以下构造方法：```javaRestTemplate restTemplate = new RestTemplateBuilder().setConnectTimeout(Duration.ofSeconds(10)).setReadTimeout(Duration.ofSeconds(30)).build();```这个构造方法使用了 RestTemplateBuilder 类来构建 RestTemplate 实例，可以链式调用 setConnectTimeout 和 setReadTimeout 方法来设置超时时间。
2. 请求方法GET 请求：这里的 url 是远程服务的地址，request 是请求体，可以是 String、byte[]、InputStream 或 HttpEntity 对象等类型。
在发送请求时，RestTemplate 还支持在 URL 中传递参数和请求头，例如：HttpEntity<?> entity = new HttpEntity<>(headers);这里使用了 UriComponentsBuilder 类来拼接 URL 和查询参数，并使用了HttpHeaders 类来设置请求头。
详解springbootrest例子
详解springbootrest例⼦简介：本⽂将帮助您使⽤ Spring Boot 创建简单的 REST 服务。
你将学习1. 什么是 REST 服务？2. 如何使⽤ Spring Initializr 引导创建 Rest 服务应⽤程序？3. 如何创建获取 REST 服务以检索学⽣注册的课程？4. 如何为学⽣注册课程创建 Post REST 服务？5. 如何利⽤ postman 执⾏ rest 服务？本教程使⽤的 rest 服务在本教程中，我们将使⽤适当的 URI 和 HTTP ⽅法创建三个服务：@GetMapping（“/ students / {studentId} / courses”）：您可以使⽤请求⽅法 Get 和⽰例 uri / students / Student1 / courses 来查询特定学⽣已注册的课程。
@GetMapping(“/students/{studentId}/courses/{courseId}”)：您可以使⽤请求⽅法 Get 和⽰例 uri / students / Student1 / courses / Course1 获取特定学⽣的特定课程。
@PostMapping(“/students/{studentId}/courses”) ：您可以通过向 UURI /students/Student1/courses 发送 POST 请求来为学⽣注册⼀门课程您将需要的⼯具1. Maven 3.0+ 是您的构建⼯具2. 你最喜欢的 IDE。
我们使⽤ Eclipse。
3. JDK 1.8+完整的 spring booot rest Maven 项⽬代码⽰例⼦带有单元和集成测试的 REST 服务Website-springbootrestservices-simplerestserviceswithunitandintegrationtests.zip什么是 REST？REST 代表 REpresentational State Transfer。
restapi设计举例
restapi设计举例在现代软件开发中，REST（Representational State Transfer）架构风格已经成为一种广泛应用的设计模式，用于构建可伸缩、可扩展的网络服务。
RESTAPI（RESTful API）是REST架构设计的一个重要组成部分，用于实现不同应用之间的数据交互。
本文将通过一个具体的案例，对RESTAPI的设计进行举例说明。
案例背景假设我们要设计一个简单的社交媒体应用，允许用户发布动态、浏览他人的动态，并进行点赞和评论。
这个应用的RESTAPI需要支持以下功能：1. 用户注册和登录：用户可以通过注册账号和密码进行新用户的注册，已注册用户可以通过账号和密码进行登录。
2. 发布动态：已登录用户可以发布自己的动态，每个动态包含一个标题和正文内容。
3. 获取动态列表：已登录用户可以获取其他用户发布的动态列表，按照发布时间排序。
4. 点赞和取消点赞：已登录用户可以给其他用户发布的动态点赞，并取消已点赞的动态。
5. 评论动态：已登录用户可以对其他用户发布的动态进行评论，每个评论包含评论内容和评论时间。
RESTAPI设计基于上述功能需求，我们可以设计以下RESTAPI：1. 用户注册：- 请求方式：POST- URL：/api/user/register- 请求参数：账号、密码- 返回结果：注册成功或失败的消息2. 用户登录：- 请求方式：POST- URL：/api/user/login- 请求参数：账号、密码- 返回结果：登录成功或失败的消息3. 发布动态：- 请求方式：POST- URL：/api/post/create- 请求参数：用户身份验证信息、动态标题、动态内容 - 返回结果：动态发布成功或失败的消息4. 获取动态列表：- 请求方式：GET- URL：/api/post/list- 请求参数：用户身份验证信息- 返回结果：按照发布时间排序的动态列表5. 点赞动态：- 请求方式：POST- URL：/api/post/like- 请求参数：用户身份验证信息、动态ID - 返回结果：点赞成功或失败的消息6. 取消点赞动态：- 请求方式：POST- URL：/api/post/unlike- 请求参数：用户身份验证信息、动态ID - 返回结果：取消点赞成功或失败的消息7. 评论动态：- 请求方式：POST- URL：/api/post/comment- 请求参数：用户身份验证信息、动态ID、评论内容- 返回结果：评论发布成功或失败的消息设计解释上述RESTAPI的设计符合REST原则，并采用了RESTful风格的URL命名规范。
RESTLET开发实例(三)基于spring的REST服务
RESTLET开发实例（三）基于spring的REST服务这里介绍restlet如何整合spring框架进行开发。
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的，广泛的应用于应用项目中。
本篇文章将在上篇的基础上面做介绍，将上篇文章的介绍的rest，用spring整合来实现。
一、基于spring配置的Rest简单服务1、新建RestSpringApplication Web工程。
将restlet和spring的jar包复制进来。
红色部分为新加入进来的jar 包。
将上篇中的RestApplication工程项目中的src的源文件复制过来。
2、将web.xml加入下面代码<servlet><servlet-name>restlet</servlet-name><servlet-class>org.restlet.ext.spring.RestletFrameworkServlet</servlet-class><init-param><param-name>ponent</param-name><param-value>restletComponent</param-value></init-param></servlet><servlet-mapping><servlet-name>restlet</servlet-name><url-pattern>/*</url-pattern></servlet-mapping>上面代码指定了restlet使用spring的RestletFrameworkServlet。
3、建立restlet-servlet.xml文件，只需要配置org.restlet.ext.spring.SpringRouter，及对应的路径和资源文件。
resttemlate 流式
RestTemplate 是一个基于 Spring 的 HTTP 客户端，用于发送HTTP 请求和接收 HTTP 响应。
流式处理是指在处理数据时，将数据以流的形式逐个处理，而不是一次性将所有数据都加载到内存中。
在使用 RestTemplate 进行流式处理时，可以通过在回调方法中不断地接收响应流中的数据来实现。
具体步骤如下：1. 发送 HTTP 请求，并获取响应流对象。
```javaRestTemplate restTemplate = new RestTemplate();ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);InputStream stream = response.getBody();```2. 创建一个用于处理流的数据处理方法。
```javapublic void processStream(InputStream stream) throws IOException {BufferedReader reader = new BufferedReader(new InputStreamReader(stream));String line;while ((line = reader.readLine()) != null) {// 处理每一行数据System.out.println(line);}}```3. 在回调方法中调用数据处理方法，并传递响应流作为参数。
```javarestTemplate.exchange(url, HttpMethod.GET, null, new Callback<InputStream>() {@Overridepublic void onSuccess(InputStream result) {processStream(result);}});```以上代码示例展示了如何使用 RestTemplate 进行流式处理。
restful webservice构建小例子(restlet)
Restful Webservice构建1)简述主要使用restlet框架来实现rest风格的web服务构建。
为什么选用restlet呢?主要从以下角度考虑：1.完全的rest实现，完全抛弃Servlet API2.轻量级框架，可作为j2se程序独立运行，又可运行在现有的web容器中虽然struts2.0 spring3.0 jrs…很多都可以实现restful的应用，但是restlet可完美集成在spring等框架中3.服务端/客户端支持*其他特性请参照restlet的官网翻译片段2)具体实现1.采用restlet框架来支持rest，封装dbcp数据库连接池来提供数据库访问。
2.对某一类性的资源采用同一application来管理，此类型的资源可能有若干个资源类来支持。
下面以Rss新闻的服务来详细介绍下相关的实现以及配置1.首先建立的一个web工程，这里采用了Tomcat服务器作为单机调试用2.Web-inf/web.xml来注册restlet的监听3.Web-inf/restlet.xml来定义application级别的restful url映射以图中所示工程为例，当请求http://主机ip/UniteRestfulService/RssNewsPlaces的时候，restlet将会自动将此请求交由unite.client.service.rssNews.RssNewsApplication类来进行处理4.在application这一级别的类中(比如RssNewsApplication)类，可以对资源进行进一步的映射配置通过如上进一步的配置，http://主机ip/UniteRestfulService/RssNewsPlaces这个请求将会映射到RssNewsPlacesResource类；而http://主机ip/UniteRestfulService/RssNewsPlaces/{place}这个请求将会映射到RssNewsResource 类。
java rest的用法
java rest的用法摘要：1.Java REST简介2.创建REST服务3.构建REST客户端4.处理请求和响应5.安全性与过滤器6.高级REST概念7.实战案例正文：**一、Java REST简介**Java REST（Representational State Transfer，表述性状态转移）是一种基于Java构建Web服务的技术。
它遵循HTTP协议，通过URL来标识资源，并使用HTTP动词（GET、POST、PUT、DELETE等）对资源进行操作。
RESTful服务具有可扩展性、易于理解和使用的特点，广泛应用于Web开发领域。
**二、创建REST服务**要创建一个Java REST服务，我们需要使用Servlet容器（如Tomcat）和Web框架（如Spring Boot）。
以下是一个简单的Spring Boot REST服务示例：```java@RestController@RequestMapping("/api")public class ApiController {@GetMapping("/hello")public String hello() {return "Hello, World!";}@PostMapping("/user")public User createUser(@RequestBody User user) {// 保存用户并返回return user;}}```**三、构建REST客户端**要访问REST服务，我们可以使用Java客户端库（如Apache HttpClient、OkHttp）或构建工具（如Maven、Gradle）来编写客户端。
以下是一个使用OkHttp访问REST服务的示例：```javaimport okhttp3.*;public class RestClient {private OkHttpClient httpClient;public RestClient() {httpClient = new OkHttpClient();}public void sendGetRequest(String url) {Request request = new Request.Builder().url(url).build();try (Response response =httpClient.newCall(request).execute()) {System.out.println(response.body().string());} catch (IOException e) {e.printStackTrace();}}public void sendPostRequest(String url, String json) {MediaType JSON = MediaType.get("application/json; charset=utf-8");RequestBody requestBody = RequestBody.create(JSON, json);Request request = new Request.Builder().url(url).post(requestBody).build();try (Response response =httpClient.newCall(request).execute()) {System.out.println(response.body().string());} catch (IOException e) {e.printStackTrace();}}}```**四、处理请求和响应**在REST服务中，我们需要处理HTTP请求和响应。
elasticsearchresttemplate的使用方法
elasticsearchresttemplate的使用方法ElasticsearchRestTemplate 的使用方法ElasticsearchRestTemplate 是Spring Data Elasticsearch 提供的一个用于与Elasticsearch 进行交互的工具类。
它封装了Elasticsearch 提供的REST API，使得开发者能够通过Spring 的方式来操作Elasticsearch 数据库。
本文将详细介绍ElasticsearchRestTemplate 的使用方法，帮助开发者更好地利用它来操作Elasticsearch 数据库。
一、引入依赖首先，需要在项目的pom.xml 文件中引入spring-boot-starter-data-elasticsearch 依赖。
在Maven 项目中，可以通过在dependencies 节点下添加以下代码来引入依赖：xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency>二、配置Elasticsearch 连接信息接下来，需要在项目的配置文件中配置Elasticsearch 的连接信息，具体内容包括集群节点地址、端口号、用户名和密码等。
在Spring Boot 项目中，可以通过在application.properties 文件中添加以下配置来配置Elasticsearch 连接信息：propertiesspring.data.elasticsearch.cluster-nodes=127.0.0.1:9200spring.data.elasticsearch.cluster-name=my-applicationername=your-usernamespring.data.elasticsearch.password=your-password三、定义实体类在使用ElasticsearchRestTemplate 之前，需要定义一个实体类来映射Elasticsearch 中的文档。
springboot单元测试之RestTemplate（三）——api详解
springboot单元测试之RestTemplate（三）——api详解本篇内容来⾃翟永超的《Springcloud微服务实战》，转载请注明。
⼀、GET请求在RestTemplate中，对GET请求可以通过如下两个⽅法进⾏调⽤实现。
第⼀种：getForEntity函数。
该⽅法返回的是ResponseEntity,该对象是Spring对HTTP请求响应的封装，其中主要存储了HTTP的⼏个重要元素，⽐如HTTP请求状态码的枚举对象HttpStatus(也就是我们常说的404、500这些错误码）、在它的⽗类HttpEntity中还存储着HTTP请求的头信息对象HttpHeaders以及泛型类型的请求体对象。
⽐如下⾯的例⼦，就是访问USER-SERVER服务的/user请求，同时最后⼀个参数didi会替换url中的{1}占位符，⽽返回的ResponseEntity对象中的body内容类型会根据第⼆个参数转换为String类型。
RestTemplaterestTemplate=new RestTemplate();ResponseEntity<String>responseEntity=restTemplate.getForEntity("http://USERSERVICE/user?name={1}",String.class,"didi");Stringbody=responseEntity.getBody();若我们希望返回的body是⼀个User对象类型，也可以这样实现：RestTemplaterestTemplate=new RestTemplate();ResponseEntity<User>responseEntity=restTemplate.getForEntity("http://USERSERVICE/user?name={1}",User.class,"didi");Userbody=responseEntity.getBody();上⾯的例⼦是⽐较常⽤的⽅法，getForEntity函数实际上提供了以下三种不同的重载实现。
resttemplate注解原理
resttemplate注解原理RestTemplate是Spring提供的一个RESTful风格的HTTP客户端工具，它可以方便地进行HTTP请求和响应，且使用起来非常简单。
在Spring框架中，RestTemplate使用注解来实现请求和响应的映射，这些注解主要包括：- @RequestMapping：映射HTTP请求的URL和方法，可用于类级别和方法级别。
类级别的@RequestMapping通常用于指定基本的URL路径，而方法级别的@RequestMapping通常用于指定相对于类级别的URL路径。
- @PathVariable：用于获取URL路径上的变量值。
- @RequestParam：用于获取请求参数的值。
- @RequestBody：用于获取请求体中的对象。
- @ResponseBody：用于将方法的返回值转换为JSON或XML等格式，并作为响应体返回给客户端。
除了以上注解外，还有一些其他的注解用于处理HTTP响应的状态码，如@ResponseStatus、@ControllerAdvice、@ExceptionHandler等等。
下面我们来看一下RestTemplate是如何基于注解实现HTTP请求和响应的映射的。
1、方法一：使用注解映射HTTP请求和响应首先，我们需要定义一个RestController控制器类，其中我们编写HTTP请求的处理方法，并使用相关的注解来处理该请求。
例如，我们可以定义一个HelloController类，其中加入一个RequestMapping 注解，用于指定处理“/hello”的GET请求，示例如下：@RestControllerpublic class HelloController {@RequestMapping(value = "/hello", method = RequestMethod.GET)public String hello() {return "Hello World!";}}上面的例子中，我们使用了@RestController注解来标识该类为一个REST风格的控制器，其中的hello()方法将响应“Hello World!”字符串作为HTTP响应返回。
resttemplet用法
resttemplet用法RestTemplate是Spring框架中的一个HTTP客户端，它提供了便捷的方法来发送HTTP请求并处理响应。
在本文中，我们将详细介绍RestTemplate的用法，一步一步回答你的问题。
第1步：添加Maven依赖在使用RestTemplate之前，我们需要在项目的pom.xml文件中添加相应的Maven依赖。
在最新版本的Spring Boot中，RestTemplate已经被声明为弃用的类，而推荐使用WebClient来进行HTTP请求。
如果你正在使用较旧版本的Spring Boot，你仍然可以使用RestTemplate，但是强烈建议升级到WebClient。
以下是使用RestTemplate的Maven依赖：xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>第2步：创建RestTemplate对象在使用RestTemplate之前，我们需要先创建一个RestTemplate对象。
RestTemplate可以通过实例化RestTemplate类或通过使用RestTemplateBuilder类进行构建。
javaRestTemplate restTemplate = new RestTemplate();或者，你也可以通过使用RestTemplateBuilder：javaRestTemplate restTemplate = new RestTemplateBuilder().build();第3步：发送GET请求发送GET请求是RestTemplate最简单的用法之一。
你只需要提供目标URL和一个Class对象，RestTemplate将自动将响应转换为该Class对象的实例。
elasticsearchresttemplate常用示例
elasticsearchresttemplate常用示例什么是ElasticsearchRestTemplate? ElasticsearchRestTemplate是一种用于与Elasticsearch进行交互的Spring Data Elasticsearch的类。
它提供了一个方便的方法来执行各种Elasticsearch操作，例如索引文档、搜索、聚合等。
为什么使用ElasticsearchRestTemplate？ElasticsearchRestTemplate提供了一种简化和优化与Elasticsearch交互的方式。
它利用了Spring Data Elasticsearch的许多功能和特性，使开发人员能够轻松地操作Elasticsearch而无需编写复杂的代码。
使用ElasticsearchRestTemplate可以提高开发效率、减少错误，并且可以与Spring框架的其他组件无缝集成。
如何使用ElasticsearchRestTemplate？1. 添加依赖在你的pom.xml文件中添加以下依赖，以引入Spring Data Elasticsearch 和ElasticsearchRestTemplate：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency>2. 配置Elasticsearch在application.properties或application.yml文件中配置Elasticsearch 连接信息，例如：spring.data.elasticsearch.cluster-nodes=localhost:9200你也可以根据需要配置其他Elasticsearch相关的属性，例如集群名称、用户名、密码等。
利用SpringBoot如何开发REST服务详解
利⽤SpringBoot如何开发REST服务详解REST服务介绍RESTful service是⼀种架构模式，近⼏年⽐较流⾏了，它的轻量级web服务，发挥HTTP协议的原⽣的GET，PUT，POST，DELETE。
REST模式的Web服务与复杂的SOAP和XML-RPC对⽐来讲明显的更加简洁，越来越多的web服务开始采⽤REST风格设计和实现。
例如，提供接近REST风格的Web服务进⾏图书查找；雅虎提供的Web服务也是REST风格的。
REST 并⾮始终是正确的选择。
它作为⼀种设计 Web 服务的⽅法⽽变得流⾏，这种⽅法对专有中间件（例如某个应⽤程序服务器）的依赖⽐基于 SOAP 和 WSDL 的⽅法更少。
在某种意义上，通过强调URI和HTTP等早期 Internet 标准，REST 是对⼤型应⽤程序服务器时代之前的 Web ⽅式的回归。
如下图⽰例：使⽤REST的关键是如何抽象资源，抽象得越精确，对REST的应⽤就越好。
REST服务关键原则：1. 给⼀切物体⼀个ID2.连接物体在⼀起3.使⽤标准⽅法4.资源多重表述5.⽆状态通信本⽂介绍如何基于Spring Boot搭建⼀个简易的REST服务框架，以及如何通过⾃定义注解实现Rest服务鉴权搭建框架pom.xml⾸先，引⼊相关依赖，数据库使⽤mongodb，同时使⽤redis做缓存注意：这⾥没有使⽤tomcat，⽽是使⽤undertow<dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></exclusion></exclusions></dependency><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-undertow</artifactId></dependency><!--redis⽀持--><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!--mongodb⽀持--><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId></dependency>引⼊spring-boot-starter-web⽀持web服务引⼊spring-boot-starter-data-redis 和spring-boot-starter-data-mongodb就可以⽅便的使⽤mongodb和redis了配置⽂件spring.profiles.active=dev然后增加application-dev.properties作为dev配置⽂件。
Spring4MVCREST服务使用@RestController实例
Spring4MVCREST服务使⽤@RestController实例在这篇⽂章中，我们将通过开发使⽤ Spring4 @RestController 注解来开发基于Spring MVC4的REST风格的JSON服务。
我们将扩展这个例⼦通过简单的注释与JAXB标注域类⽀持XML输出和JSON输出。
在这个⽰例中，我们需要URL的后缀为 .xml 或 .json 以获得所需的输出。
使⽤以下技术：Spring 4.0.6.RELEASEjackson-mapper-asl 1.9.13Maven 3JDK 1.6Tomcat 7.0.54Eclipse JUNO Service Release 2让我们现在开始！第1步：创建⽬录结构之前的⽂章使⽤Eclipse创建Maven Web项⽬包含了⼀步⼀步的指导，使⽤ Eclipse 来创建⼀个Maven项⽬(Spring4MVCRestServiceDemo)。
下⾯是最终的项⽬⽬录结构：我们将使⽤ Spring Java配置⽽不使⽤XML。
现在，让我们来添加/更新上述项⽬结构中提到的内容。
第2步：使⽤ pom.xml 更新所需的依赖<?xml version="1.0"?><projectxsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"><modelVersion>4.0.0</modelVersion><groupId>com.yiibai.springmvc</groupId><artifactId>Spring4MVCRestServiceDemo</artifactId><packaging>war</packaging><version>1.0.0</version><name>Spring4MVCRestServiceDemo Maven Webapp</name><properties><springframework.version>4.0.6.RELEASE</springframework.version></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${springframework.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>${springframework.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${springframework.version}</version></dependency><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0</version></dependency><dependency><groupId>javax.servlet.jsp.jstl</groupId><artifactId>jstl-api</artifactId><version>1.2</version></dependency><dependency><groupId>javax.servlet.jsp</groupId><artifactId>javax.servlet.jsp-api</artifactId><version>2.3.1</version></dependency><dependency><groupId>org.codehaus.jackson</groupId><artifactId>jackson-mapper-asl</artifactId><version>1.9.13</version></dependency></dependencies><build><pluginManagement><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><version>2.4</version><configuration><warSourceDirectory>src/main/webapp</warSourceDirectory><warName>Spring4MVCRestServiceDemo</warName><failOnMissingWebXml>false</failOnMissingWebXml></configuration></plugin></plugins></pluginManagement><finalName>Spring4MVCRestServiceDemo</finalName></build></project>上⾯的 pom.xml 与以前的教程中定义的相同。
SpringMVC4实现RESTFulWebServices的CRUD实例和使用RestT。。。
SpringMVC4实现RESTFulWebServices的CRUD实例和使⽤RestT。
在这篇⽂章中，我们将使⽤Spring4 MVC编写⼀个CRUD RESTful Web服务，写⼀个REST客户端RestTemplate来使⽤这些服务。
我们也将利⽤外部客户端测试的服务。
下⾯将展⽰核⼼代码，更详细的代码实现参照Maven⽰例⼯程！简单介绍REST表⽰状态传输。
这是⼀个体系结构样式，可⽤于设计⽹络服务，可以被各种客户端消耗。
核⼼思想是，不使⽤如CORBA，RPC或SOAP复杂的机制在机器之间进⾏连接，简单的 HTTP ⽤于使它们之间调⽤。
在基于 REST 的设计中，资源被⼀套通⽤动词操作使⽤。
创建资源：应该使⽤ HTTP POST要获取资源：应该使⽤HTTP GET更新资源：应使⽤HTTP PUT要删除资源：应使⽤HTTP DELETE这意味着，作为⼀个REST服务开发⼈员或客户端，应符合上述标准，以便REST操作。
通常REST是基于Web服务返回JSON或XML数据格式作为响应，虽然它并不仅仅限于这些类型。
客户端可以指定（使⽤ HTTP Accept 报头），他们所感兴趣的资源类型，并且服务器可以返回资源，指定它所服务的内容类型资源。
基于REST的控制器下⾯是⼀个可能基于REST的控制器，实现REST API。
这⾥所说的“可能”，这意味着可以以另⼀种⽅式实现它，还是（或者更纯粹的⽅式）符合REST风格。
这就是我们的REST API功能/作⽤：GET请求/api/user/返回⽤户的列表GET请求/api/user/1返回ID为1的⽤户POST请求/api/user/以⽤户对象的JSON格式创建新的⽤户PUT请求/api/user/3以⽤户对象作为JSON更新ID为3的⽤户DELETE请求/api/user/4删除ID为4的⽤户DELETE请求/api/user/删除所有的⽤户package com.jsoft.springmvc.controller;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.HttpHeaders;import org.springframework.http.HttpStatus;import org.springframework.http.MediaType;import org.springframework.http.ResponseEntity;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.util.UriComponentsBuilder;import er;import erService;@RestControllerpublic class HelloWorldRestController {@AutowiredUserService userService; //Service which will do all data retrieval/manipulation work//-------------------Retrieve All Users--------------------------------------------------------@RequestMapping(value = "/user/", method = RequestMethod.GET)public ResponseEntity<List<User>> listAllUsers() {List<User> users = userService.findAllUsers();if(users.isEmpty()){return new ResponseEntity<List<User>>(HttpStatus.NO_CONTENT);//You many decide to return HttpStatus.NOT_FOUND}return new ResponseEntity<List<User>>(users, HttpStatus.OK);}//-------------------Retrieve Single User--------------------------------------------------------@RequestMapping(value = "/user/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<User> getUser(@PathVariable("id") long id) {System.out.println("Fetching User with id " + id);User user = userService.findById(id);if (user == null) {System.out.println("User with id " + id + " not found");return new ResponseEntity<User>(HttpStatus.NOT_FOUND);}return new ResponseEntity<User>(user, HttpStatus.OK);}//-------------------Create a User--------------------------------------------------------@RequestMapping(value = "/user/", method = RequestMethod.POST)public ResponseEntity<Void> createUser(@RequestBody User user, UriComponentsBuilder ucBuilder) {System.out.println("Creating User " + user.getName());if (userService.isUserExist(user)) {System.out.println("A User with name " + user.getName() + " already exist");return new ResponseEntity<Void>(HttpStatus.CONFLICT);}userService.saveUser(user);HttpHeaders headers = new HttpHeaders();headers.setLocation(ucBuilder.path("/user/{id}").buildAndExpand(user.getId()).toUri());return new ResponseEntity<Void>(headers, HttpStatus.CREATED);}//------------------- Update a User --------------------------------------------------------@RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)public ResponseEntity<User> updateUser(@PathVariable("id") long id, @RequestBody User user) {System.out.println("Updating User " + id);User currentUser = userService.findById(id);if (currentUser==null) {System.out.println("User with id " + id + " not found");return new ResponseEntity<User>(HttpStatus.NOT_FOUND);}currentUser.setName(user.getName());currentUser.setAge(user.getAge());currentUser.setSalary(user.getSalary());userService.updateUser(currentUser);return new ResponseEntity<User>(currentUser, HttpStatus.OK);}//------------------- Delete a User --------------------------------------------------------@RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)public ResponseEntity<User> deleteUser(@PathVariable("id") long id) {System.out.println("Fetching & Deleting User with id " + id);User user = userService.findById(id);if (user == null) {System.out.println("Unable to delete. User with id " + id + " not found");return new ResponseEntity<User>(HttpStatus.NOT_FOUND);}userService.deleteUserById(id);return new ResponseEntity<User>(HttpStatus.NO_CONTENT);}//------------------- Delete All Users --------------------------------------------------------@RequestMapping(value = "/user/", method = RequestMethod.DELETE)public ResponseEntity<User> deleteAllUsers() {System.out.println("Deleting All Users");userService.deleteAllUsers();return new ResponseEntity<User>(HttpStatus.NO_CONTENT);}}详细说明：@RestController：⾸先，我们使⽤Spring4的新@RestController注释。