restful json_Spring Restful Web服务示例，带有JSON，Jackson和客户端程序

最新推荐文章于 2024-10-09 17:12:21 发布
最新推荐文章于 2024-10-09 17:12:21 发布
阅读量195 收藏
点赞数
文章标签： spring java 深度学习 spring boot xml
原文链接：https://www.journaldev.com/2552/spring-rest-example-tutorial-spring-restful-web-services
版权

restful json

Spring is one of the most widely used Java EE frameworks. We have earlier seen how to use Spring MVC to create Java-based web applications. Today we will learn to create Spring Restful Web Services using Spring MVC and then test it out with the Rest client. In the end, we will also look into how to invoke Spring Restful web service using Spring RestTemplate API.

Spring是使用最广泛的Java EE框架之一。 前面我们已经看到了如何使用Spring MVC创建基于Java的Web应用程序。 今天，我们将学习使用Spring MVC创建Spring Restful Web服务 ，然后使用Rest客户端对其进行测试。 最后，我们还将研究如何使用Spring RestTemplate API调用Spring Restful Web服务。

SpringREST (Spring REST)

We will use Spring latest version 4.0.0.RELEASE and utilize Spring Jackson JSON integration to send JSON response in the rest call response. The tutorial is developed in Spring STS IDE for creating Spring MVC skeleton code easily and then extended to implement Restful architecture.

我们将使用Spring最新版本4.0.0.RELEASE并利用Spring Jackson JSON集成在其余调用响应中发送JSON响应。 该教程是在Spring STS IDE中开发的，用于轻松创建Spring MVC框架代码，然后扩展为实现Restful架构。

Create a new Spring MVC Project in the STS, our final project will look like the below image. We will look into each of the components one by one.

在STS中创建一个新的Spring MVC项目，我们的最终项目将如下图所示。 我们将逐一研究每个组件。

Spring REST配置XML文件 (Spring REST Configuration XML Files)

Our pom.xml file looks like below.

我们的pom.xml文件如下所示。 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev</groupId>
	<artifactId>SpringRestExample</artifactId>
	<name>SpringRestExample</name>
	<packaging>war</packaging>
	<version>1.0.0-BUILD-SNAPSHOT</version>
	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.0.0.RELEASE</org.springframework-version>
		<org.aspectj-version>1.7.4</org.aspectj-version>
		<org.slf4j-version>1.7.5</org.slf4j-version>
		<jackson.databind-version>2.2.3</jackson.databind-version>
	</properties>
	<dependencies>
		<!-- Jackson -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.databind-version}</version>
		</dependency>
		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework-version}</version>
			<exclusions>
				<!-- Exclude Commons Logging in favor of SLF4j -->
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>

		<!-- AspectJ -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>

		<!-- Logging -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${org.slf4j-version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.15</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
			</exclusions>
			<scope>runtime</scope>
		</dependency>

		<!-- @Inject -->
		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>

		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.7</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<artifactId>maven-eclipse-plugin</artifactId>
				<version>2.9</version>
				<configuration>
					<additionalProjectnatures>
						<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
					</additionalProjectnatures>
					<additionalBuildcommands>
						<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
					</additionalBuildcommands>
					<downloadSources>true</downloadSources>
					<downloadJavadocs>true</downloadJavadocs>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.5.1</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<compilerArgument>-Xlint:all</compilerArgument>
					<showWarnings>true</showWarnings>
					<showDeprecation>true</showDeprecation>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>exec-maven-plugin</artifactId>
				<version>1.2.1</version>
				<configuration>
					<mainClass>org.test.int1.Main</mainClass>
				</configuration>
			</plugin>
		</plugins>
		
	</build>
</project>

STS tool generates the pom.xml file for us. However, I have updated the Spring Framework, AspectJ, SLF4J and Jackson version to the latest one as of today. Most of the part is common and generated automatically, the important point to note is that I have added Jackson JSON libraries in the dependency because we will use that to convert Objects to JSON and vice versa.

STS工具会为我们生成pom.xml文件。 但是，我已经将Spring Framework，AspectJ，SLF4J和Jackson的版本更新为今天的最新版本。 大多数部分是通用的并且是自动生成的，需要注意的重要一点是，我在依赖项中添加了Jackson JSON库，因为我们将使用它来将Objects转换为JSON，反之亦然。 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/spring/root-context.xml</param-value>
	</context-param>
	
	<!-- Creates the Spring Container shared by all Servlets and Filters -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- Processes application requests -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
		
	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

</web-app>

This file is generated automatically and I haven’t changed anything in that. However, if you want to change context configuration files and their location, you can do it in the web.xml file.

这个文件是自动生成的，我没有做任何更改。 但是，如果要更改上下文配置文件及其位置，则可以在web.xml文件中进行操作。 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
		
</beans>

This file contains the shared resources that will be visible to all the web components, we will be developing a simple rest service and that’s why I haven’t changed anything here.

该文件包含对所有Web组件可见的共享资源，我们将开发一个简单的rest服务，这就是为什么我在这里没有进行任何更改的原因。 

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
	
	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>
	
	<!-- Configure to plugin JSON as request and response in method handler -->
	<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<beans:property name="messageConverters">
			<beans:list>
				<beans:ref bean="jsonMessageConverter"/>
			</beans:list>
		</beans:property>
	</beans:bean>
	
	<!-- Configure bean to convert JSON to POJO and vice versa -->
	<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
	</beans:bean>	
	
	<context:component-scan base-package="com.journaldev.spring.controller" />
	
</beans:beans>

Most of the part is auto generated and contains boiler-plate configurations. However important points to note are annotation-driven element to support annotations based configuration and plugging in MappingJackson2HttpMessageConverter to the RequestMappingHandlerAdapter messageConverters so that Jackson API kicks in and converts JSON to Java Beans and vice versa. By having this configuration, we will be using JSON in request body and we will receive JSON data in the response.

大部分零件是自动生成的，包含样板配置。 但是，需要注意的重点是注释驱动的元素，该元素支持基于注释的配置，并将MappingJackson2HttpMessageConverter插入RequestMappingHandlerAdapter messageConverters以便Jackson API启动并将JSON转换为Java Bean，反之亦然。 通过进行此配置，我们将在请求正文中使用JSON，并将在响应中接收JSON数据。

Spring REST模型类 (Spring REST Model Classes)

Let’s write a simple POJO class that will serve as input and output to our Restful web service methods.

让我们编写一个简单的POJO类，作为我们的Restful Web服务方法的输入和输出。 

package com.journaldev.spring.model;

import java.io.Serializable;
import java.util.Date;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;

public class Employee implements Serializable{

	private static final long serialVersionUID = -7788619177798333712L;
	
	private int id;
	private String name;
	private Date createdDate;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@JsonSerialize(using=DateSerializer.class)
	public Date getCreatedDate() {
		return createdDate;
	}
	public void setCreatedDate(Date createdDate) {
		this.createdDate = createdDate;
	}
	
	
}

The only important point to note is the use of @JsonSerialize annotation to use DateSerializer class for Date conversion from Java type to JSON format and vice versa.

要注意的唯一重要一点是使用@JsonSerialize批注，以将DateSerializer类用于从Java类型到JSON格式的日期转换，反之亦然。

Spring Restful Web服务端点 (Spring Restful web service End Points)

We will have the following rest web services endpoints.

我们将具有以下其余Web服务终结点。

Sl. NoURIHTTP MethodDetails
1/rest/emp/dummyGETHealth Check service, to insert a dummy data in the Employees data storage
2/rest/emp/{id}GETTo get the Employee object based on the id
3/rest/empsGETTo get the list of all the Employees in the data store
4/rest/emp/createPOSTTo create the Employee object and store it
5/rest/emp/delete/{id}PUTTo delete the Employee object from the data storage based on the id
Sl。 没有 URI HTTP方法 细节
1个 / rest / emp / dummy 得到 运行状况检查服务，用于在员工数据存储中插入虚拟数据
2 / rest / emp / {id} 得到 根据ID获取Employee对象
3 / rest / emps 得到 获取数据存储区中所有员工的列表
4 / rest / emp / create 开机自检 创建Employee对象并存储它
5 / rest / emp / delete / {id} 放 根据ID从数据存储中删除Employee对象

We have a class defining all these URI as String constants.

我们有一个将所有这些URI定义为String常量的类。 

package com.journaldev.spring.controller;

public class EmpRestURIConstants {

	public static final String DUMMY_EMP = "/rest/emp/dummy";
	public static final String GET_EMP = "/rest/emp/{id}";
	public static final String GET_ALL_EMP = "/rest/emps";
	public static final String CREATE_EMP = "/rest/emp/create";
	public static final String DELETE_EMP = "/rest/emp/delete/{id}";
}

Spring Restful Web服务控制器类 (Spring Restful web service Controller class)

Our EmployeeController class will publish all the web service endpoints mentioned above. Let’s look at the code of the class and then we will learn about each of the methods in detail.

我们的EmployeeController类将发布上述所有Web服务端点。 让我们看一下该类的代码，然后我们将详细了解每种方法。 

package com.journaldev.spring.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
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.ResponseBody;

import com.journaldev.spring.model.Employee;

/**
 * Handles requests for the Employee service.
 */
@Controller
public class EmployeeController {
	
	private static final Logger logger = LoggerFactory.getLogger(EmployeeController.class);
	
	//Map to store employees, ideally we should use database
	Map<Integer, Employee> empData = new HashMap<Integer, Employee>();
	
	@RequestMapping(value = EmpRestURIConstants.DUMMY_EMP, method = RequestMethod.GET)
	public @ResponseBody Employee getDummyEmployee() {
		logger.info("Start getDummyEmployee");
		Employee emp = new Employee();
		emp.setId(9999);
		emp.setName("Dummy");
		emp.setCreatedDate(new Date());
		empData.put(9999, emp);
		return emp;
	}
	
	@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
	public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
		logger.info("Start getEmployee. ID="+empId);
		
		return empData.get(empId);
	}
	
	@RequestMapping(value = EmpRestURIConstants.GET_ALL_EMP, method = RequestMethod.GET)
	public @ResponseBody List<Employee> getAllEmployees() {
		logger.info("Start getAllEmployees.");
		List<Employee> emps = new ArrayList<Employee>();
		Set<Integer> empIdKeys = empData.keySet();
		for(Integer i : empIdKeys){
			emps.add(empData.get(i));
		}
		return emps;
	}
	
	@RequestMapping(value = EmpRestURIConstants.CREATE_EMP, method = RequestMethod.POST)
	public @ResponseBody Employee createEmployee(@RequestBody Employee emp) {
		logger.info("Start createEmployee.");
		emp.setCreatedDate(new Date());
		empData.put(emp.getId(), emp);
		return emp;
	}
	
	@RequestMapping(value = EmpRestURIConstants.DELETE_EMP, method = RequestMethod.PUT)
	public @ResponseBody Employee deleteEmployee(@PathVariable("id") int empId) {
		logger.info("Start deleteEmployee.");
		Employee emp = empData.get(empId);
		empData.remove(empId);
		return emp;
	}
	
}

For simplicity, I am storing all the employee’s data in the HashMap empData. @RequestMapping annotation is used to map the request URI to the handler method. We can also specify the HTTP method that should be used by client application to invoke the rest method.

为简单起见，我将所有员工数据存储在HashMap empData中。 @RequestMapping批注用于将请求URI映射到处理程序方法。 我们还可以指定客户端应用程序应使用的HTTP方法来调用rest方法。

@ResponseBody annotation is used to map the response object in the response body. Once the response object is returned by the handler method, MappingJackson2HttpMessageConverter kicks in and convert it to JSON response.

@ResponseBody批注用于将响应对象映射到响应主体中。 通过处理程序方法返回响应对象后，MappingJackson2HttpMessageConverter就会启动并将其转换为JSON响应。

@PathVariable annotation is the easy way to extract the data from the rest URI and map it to the method argument.

@PathVariable注释是从其余URI提取数据并将其映射到method参数的简单方法。

@RequestBody annotation is used to map the request body JSON data into the Employee object, again this is done by the MappingJackson2HttpMessageConverter mapping.

@RequestBody批注用于将请求正文JSON数据映射到Employee对象，同样由MappingJackson2HttpMessageConverter映射完成。

Rest of the code is simple and self-understood, our application is ready for deployment and testing. Just export as WAR file and copy it in the servlet container web app directory. If you have the server configured in the STS, you can simply run it on the server to get it deployed.

其余代码简单易懂，我们的应用程序已准备好进行部署和测试。 只需将其导出为WAR文件并将其复制到servlet容器的Web应用程序目录中即可。 如果在STS中配置了服务器，则只需在服务器上运行它即可进行部署。

I am using WizTools RestClient to invoke the rest calls but you can also use Chrome extension Postman.

我正在使用WizTools RestClient调用其余的调用，但您也可以使用Chrome扩展程序Postman。

Below screenshots shows the different invocations of the rest APIs exposed by our application and it’s output.

下面的屏幕快照显示了我们的应用程序公开的其余API的不同调用及其输出。

Health Check – Get Dummy Employee Rest Call

Spring-Rest-Example-1

健康检查–接到假员工休息电话

Create Employee POST Rest Call: Make sure request Content-Type is set to “application/json” otherwise you will get HTTP Error Code 415.

Sping-Rest-Example-POST

创建员工POST休息呼叫 ：确保将请求Content-Type设置为“ application / json”，否则您将获得HTTP错误代码415。

Get Employee Rest Call

Spring-Rest-Example-GET-1

接到员工休息电话

Delete Employee Rest Call

Spring-Rest-Example-PUT

删除员工休息电话

Get All Employees Rest Call

Spring-Rest-Example-GET

让所有员工休息

Spring Rest客户程序 (Spring Rest Client Program)

Rest Clients are good to test our rest web service but most of the times, we need to invoke rest services through our program. We can use Spring RestTemplate to invoke these methods easily. Below is a simple program invoking our application rest methods using RestTemplate API.

Rest客户端很好地测试了我们的Rest Web服务，但是大多数时候，我们需要通过程序来调用Rest服务。 我们可以使用Spring RestTemplate轻松地调用这些方法。 以下是一个使用RestTemplate API调用我们的应用程序rest方法的简单程序。 

package com.journaldev.spring;

import java.util.LinkedHashMap;
import java.util.List;

import org.springframework.web.client.RestTemplate;

import com.journaldev.spring.controller.EmpRestURIConstants;
import com.journaldev.spring.model.Employee;

public class TestSpringRestExample {

	public static final String SERVER_URI = "https://localhost:9090/SpringRestExample";
	
	public static void main(String args[]){
		
		testGetDummyEmployee();
		System.out.println("*****");
		testCreateEmployee();
		System.out.println("*****");
		testGetEmployee();
		System.out.println("*****");
		testGetAllEmployee();
	}

	private static void testGetAllEmployee() {
		RestTemplate restTemplate = new RestTemplate();
		//we can't get List<Employee> because JSON convertor doesn't know the type of
		//object in the list and hence convert it to default JSON object type LinkedHashMap
		List<LinkedHashMap> emps = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.GET_ALL_EMP, List.class);
		System.out.println(emps.size());
		for(LinkedHashMap map : emps){
			System.out.println("ID="+map.get("id")+",Name="+map.get("name")+",CreatedDate="+map.get("createdDate"));;
		}
	}

	private static void testCreateEmployee() {
		RestTemplate restTemplate = new RestTemplate();
		Employee emp = new Employee();
		emp.setId(1);emp.setName("Pankaj Kumar");
		Employee response = restTemplate.postForObject(SERVER_URI+EmpRestURIConstants.CREATE_EMP, emp, Employee.class);
		printEmpData(response);
	}

	private static void testGetEmployee() {
		RestTemplate restTemplate = new RestTemplate();
		Employee emp = restTemplate.getForObject(SERVER_URI+"/rest/emp/1", Employee.class);
		printEmpData(emp);
	}

	private static void testGetDummyEmployee() {
		RestTemplate restTemplate = new RestTemplate();
		Employee emp = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.DUMMY_EMP, Employee.class);
		printEmpData(emp);
	}
	
	public static void printEmpData(Employee emp){
		System.out.println("ID="+emp.getId()+",Name="+emp.getName()+",CreatedDate="+emp.getCreatedDate());
	}
}

Most of the program is simple to understand, however when invoking rest method returning a Collection, we need to use LinkedHashMap because JSON to object conversion doesn’t know about the Employee object and converts it to the collection of LinkedHashMap. We can write a utility method to convert from LinkedHashMap to our Java Bean object.

大多数程序易于理解，但是当调用rest方法返回Collection时，我们需要使用LinkedHashMap因为JSON到对象的转换并不了解Employee对象，而是将其转换为LinkedHashMap的集合。 我们可以编写一个实用程序方法，以将LinkedHashMap转换为Java Bean对象。

When we run the above program, we get the following output in the console.

当我们运行上述程序时，我们将在控制台中获得以下输出。 

ID=9999,Name=Dummy,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
2
ID=1,Name=Pankaj Kumar,CreatedDate=1393995761654
ID=9999,Name=Dummy,CreatedDate=1393995761381

Another point is that RestTemplate put methods doesn’t have option to set response object because PUT method should be used to store something on the server and a simple HTTP 200 status code should be sufficient.

另一点是RestTemplate put方法没有设置响应对象的选项，因为应该使用PUT方法将某些内容存储在服务器上，并且简单的HTTP 200状态代码就足够了。

That’s all for the Spring Restful web application tutorial. Download the sample project from the above link and play around with it to learn more.

这就是Spring Restful Web应用程序教程的全部内容。 从上面的链接下载示例项目，并进行试用以了解更多信息。

UPDATE: Because of so many requests to provide similar example with XML as well as supporting both XML and JSON, I have extended this application in Spring REST XML JSON Example to support both XML and JSON requests and response. I strongly suggest you go through that to see the beauty of the spring framework and how easy it is to achieve this.

更新 ：由于有太多请求提供类似示例的XML并同时支持XML和JSON，因此我在Spring REST XML JSON Example中扩展了该应用程序，以支持XML和JSON请求和响应。 我强烈建议您仔细阅读一下，以了解Spring框架的美丽以及实现这一目标有多容易。

GitHub Repository. GitHub Repository下载完整的项目。

翻译自: https://www.journaldev.com/2552/spring-rest-example-tutorial-spring-restful-web-services

restful json

cunchi4221
关注
RESTful Web服务和JSON数据处理
guanglihuan的专栏
03-26 1014
在 Java 项目中创建 RESTful Web 服务并处理 JSON 数据涉及到几个关键的步骤和技术。REST（Representational State Transfer）是一种软件架构风格，用于定义 Web 服务，它使用 HTTP 协议的方法来提供与资源的交互。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。以下是创建一个基本的 RESTful Web 服务的步骤，并包含了如何处理 JSON 数据。
Restful接口接收JSON字符串案例实战
Peter_Changyb的博客
08-10 6943
   代码实战编写： @RequestMapping(method=RequestMethod.POST,value="/uploadWeightDatas",params={"datas"})         public void uploadWeightDatas(HttpServletRequest request,HttpServletResponse response)     { ...
Spring Restful Web服务示例 - 使用JSON，Jackson和客户端程序
YunWisdom
03-11 683
Spring Restful Web服务示例 -使用JSON，Jackson和客户端程序 Spring是最广泛使用的Java EE框架之一。我们之前已经看到了如何使用Spring MVC来创建基于Java的Web应用程序。今天我们将学习使用Spring MVC创建Spring Restful Web Services，然后使用Rest客户端进行测试。最后，我们还将研究如何使用Sp...
使用eclipse创建restful webservice 工程
12-13
使用eclipse创建restful webservice 工程.d
TensorFlow笔记（4）--Keras，TensorFlow高级API（英）
Techblog of HaoWANG
03-20 2233
Table of Contents Keras简介 Import tf.keras Build a simple model Sequential model Configure the layers Train and evaluate Set up training Input NumPy data Input tf.data datasets Evaluate and p...
springmvc返回json（使用jackson的方式）
不敲代码的码农的博客
12-27 6396
现在多数的应用为了提高交互性多使用异步刷新，即在不刷新整个页面的情况下，只刷新局部，局部刷新用得最多就是ajax，ajax和后台进行交互的数据格式使用的最多的是JSON，这里简单描述，在springmvc的开发架构下如何返回JSON串。有两种方式进行配置，一：fastjson；二、jackson，因为用到了jackson这种方式，下面就讲讲jackson的方法（后面有时间会将fastjson的方式
Spring Restful Web服务示例 - 使用JSON/Jackson和客户端程序
YunWisdom
03-19 263
Spring Restful Web服务示例 - 使用JSON/Jackson和客户端程序 Spring是最广泛使用的Java EE框架之一。我们之前已经看到了如何使用Spring MVC来创建基于Java的Web应用程序。今天我们将学习使用Spring MVC创建Spring Restful Web Services，然后使用Rest客户端进行测试。最后，我们还将研究如何使用Sp...
Spring mvc实现Restful返回json格式数据实例详解
01-08
在本示例中，我们将向您展示如何将对象转换成json格式并通过spring mvc框架返回给用户。 使用技术及环境： Spring 3.2.2.RELEASE Jackson 1.9.10 JDK 1.6 Eclipse 3.6 Maven 3 PS：在spring 3 中，要输出json...
AngularJS_Spring:带有 JSON Spring4 的 Angular 示例
07-12
**AngularJS_Spring:带有 JSON Spring4 的 Angular 示例** 这个项目是关于如何将流行的前端JavaScript框架AngularJS与后端Java的Spring框架相结合，利用JSON进行数据交换，构建一个完整的MVC应用程序。AngularJS是...
Spring restful Json
09-15
在IT行业中，Spring RESTful JSON 是一种常见的技术组合，它结合了Spring框架的RESTful服务设计和JSON数据格式，用于构建高效、灵活的Web服务。本文将深入探讨Spring RESTful JSON的相关知识点，包括其概念、核心...
第3章 springboot接口返回json 3-2 Jackson的基本演绎法
weixin_30636089的博客
10-28 97
@JsonIgnore private String password; @JsonFormat(pattern="yyyy-MM-dd hh:mm:ss a",locale="zh", timezone="GMT+8") private Date birthday; @JsonInclude(Include.NON_NULL) ...
java restful返回json_Spring mvc实现Restful返回json格式数据实例详解
weixin_42102634的博客
02-13 371
在本示例中，我们将向您展示如何将对象转换成json格式并通过spring mvc框架返回给用户。使用技术及环境：Spring 3.2.2.RELEASEJackson 1.9.10JDK 1.6Eclipse 3.6Maven 3PS：在spring 3 中，要输出json数据，只需要添加Jackson 库到你的classpath。1、项目依赖spring和jackson的依赖：xmlns:xsi...
Spring 4 Spring MVC 4 REST + Jackson @JsonView集成实例详解
青山师
11-19 8521
一个使用SpringMVC4 Rest 和Jackson的@JsonView注解集成的实例。@JsonView用来过滤JSON响应。Spring4.1开始直接支持@JsonView注解。要使用@JsonView，首先我们需要定义视图，我们可以定义多个视图。一个视图定义可以继承其他视图定义。我们的POJO使用@JsonView注解属性传递已经定义的视图。在Spring的Controller我们可以使用Jackson的@
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
qq_51321722的博客
10-05 596
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
【Spring Security】基于SpringBoot3.3.4版本②如何配置免鉴权Path
Java技术栈，分享不断学习、不断超越、不断积累的历程！
10-03 1288
[【Spring Security】基于SpringBoot3.3.4版本①整合JWT的使用教程](https://blog.csdn.net/friendlytkyj/article/details/142679120) 在这篇文章中，详细演示了使用最新版`Spring Boot`，完成一个微服务开发，并使用`Spring Security`组件完成登录认证，同时整合了`JWT`，使用的`RSA`公私钥签名、验签。 接下来继续讲解下一个业务场景：一个真实场景的微服务，难免会有一些请求`Path`不需要任
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
岁岁岁平安的博客
10-09 652
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
springboot 整合 rabbitMQ（2）
最新发布
WYH1233211234567的博客
10-09 767
解决重复消费问题，实现订阅者模式
Spring MVC实战：登录注册与JSON数据转换详解
本文探讨了Spring MVC中的用户登录注册流程，以及如何利用Jackson库处理JSON数据，这些都是构建RESTful Web服务的基础。通过理解这些概念和实践，开发者能够更好地构建与客户端交互的高效、灵活的Web应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值