`

Jersey GET POST PUT DELETE

 
阅读更多

原创转载请注明出处:http://agilestyle.iteye.com/blog/2322905

 

Project Directory

 

Maven Dependency

<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/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.fool.jersey</groupId>
	<artifactId>jersey</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>jersey Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-server</artifactId>
			<version>2.23.2</version>
		</dependency>

		<dependency>
			<groupId>org.glassfish.jersey.containers</groupId>
			<artifactId>jersey-container-servlet</artifactId>
			<version>2.23.2</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.8.2</version>
		</dependency>

		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>19.0</version>
		</dependency>
	</dependencies>

	<build>
		<finalName>jersey</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.5.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>

			<plugin>
				<groupId>org.eclipse.jetty</groupId>
				<artifactId>jetty-maven-plugin</artifactId>
				<version>9.3.11.v20160721</version>
				<configuration>
					<scanIntervalSeconds>10</scanIntervalSeconds>
					<httpConnector>
						<port>8888</port>
					</httpConnector>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

 

web.xml

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

	<display-name>jersey</display-name>

	<servlet>
		<servlet-name>jerseyservlet</servlet-name>
		<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
		<init-param>
			<param-name>jersey.config.server.provider.packages</param-name>
			<param-value>org.fool.jersey</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>jerseyservlet</servlet-name>
		<url-pattern>/rest/*</url-pattern>
	</servlet-mapping>
</web-app>

 

JsonUtils.java

package org.fool.jersey.util;

import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtils {
	private static final ObjectMapper MAPPER = new ObjectMapper();

	public static String objectToJson(Object data) {
		try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
		
		return null;
	}

	public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
		try {
			T t = MAPPER.readValue(jsonData, beanType);
			return t;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
		JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);

		try {
			List<T> list = MAPPER.readValue(jsonData, javaType);
			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	public static <K, V> Map<K, V> jsonToMap(String jsonData, Class<K> keyType, Class<V> valueType) {
		JavaType javaType = MAPPER.getTypeFactory().constructMapType(Map.class, keyType, valueType);

		try {
			Map<K, V> map = MAPPER.readValue(jsonData, javaType);
			return map;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}
}

 

ActionResponse.java

package org.fool.jersey.blog;

/*
 * to demonstrate the DELETE method
 */
public class ActionResponse {
	private String actionStatus;
	private String additionalMessage;

	public String getActionStatus() {
		return actionStatus;
	}

	public void setActionStatus(String actionStatus) {
		this.actionStatus = actionStatus;
	}

	public String getAdditionalMessage() {
		return additionalMessage;
	}

	public void setAdditionalMessage(String additionalMessage) {
		this.additionalMessage = additionalMessage;
	}

}

 

BlogPostRequest.java

package org.fool.jersey.blog;

/*
 * to demonstrate the POST and PUT method
 */
public class BlogPostRequest {
	private String postTitle;
	private String postContent;
	private String author;

	public String getPostTitle() {
		return postTitle;
	}

	public void setPostTitle(String postTitle) {
		this.postTitle = postTitle;
	}

	public String getPostContent() {
		return postContent;
	}

	public void setPostContent(String postContent) {
		this.postContent = postContent;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

}

 

BlogPostResponse.java

package org.fool.jersey.blog;

import java.util.List;

import com.google.common.collect.Lists;

/*
 * to demonstrate the GET method
 */
public class BlogPostResponse {
	private String postName;
	private String postTitle;
	private String postContent;
	private String author;
	private String dateValue;
	private String blogCategory;
	private List<String> blogKeywords;

	public BlogPostResponse() {
		blogKeywords = Lists.newArrayList();
	}

	public String getPostName() {
		return postName;
	}

	public void setPostName(String postName) {
		this.postName = postName;
	}

	public String getPostTitle() {
		return postTitle;
	}

	public void setPostTitle(String postTitle) {
		this.postTitle = postTitle;
	}

	public String getPostContent() {
		return postContent;
	}

	public void setPostContent(String postContent) {
		this.postContent = postContent;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public String getDateValue() {
		return dateValue;
	}

	public void setDateValue(String dateValue) {
		this.dateValue = dateValue;
	}

	public String getBlogCategory() {
		return blogCategory;
	}

	public void setBlogCategory(String blogCategory) {
		this.blogCategory = blogCategory;
	}

	public List<String> getBlogKeywords() {
		return blogKeywords;
	}

	public void setBlogKeywords(List<String> blogKeywords) {
		this.blogKeywords = blogKeywords;
	}

}

 

BlogService.java

package org.fool.jersey.blog;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;

import org.fool.jersey.util.JsonUtils;

@Path("/blog")
public class BlogService {

	@Path("/{year}/{month}/{day}/{postName}")
	@GET
	public String getBlogDetail(
			@PathParam("year") int year, 
			@PathParam("month") int month, 
			@PathParam("day") int day, 
			@PathParam("postName") String postName) {
		BlogPostResponse bpr = new BlogPostResponse();
		bpr.setPostName(postName);
		bpr.setAuthor("Mr Big");
		bpr.setBlogCategory("My Favorite");
		bpr.setDateValue(String.format("%d/%d/%d", month, day, year));
		bpr.setPostContent("Jesey, so fucking awesome, why do you still use spring mvc?");
		bpr.setPostTitle("My very first blog post. Hello world!");
		bpr.getBlogKeywords().add("hello");
		bpr.getBlogKeywords().add("world");
		bpr.getBlogKeywords().add("first post");
		bpr.getBlogKeywords().add("awesome");

		String result = JsonUtils.objectToJson(bpr);

		return result;
	}

	@Path("/{year}/{month}/{day}/{postName}")
	@DELETE
	public String deleteBlogPost(
			@PathParam("year") int year, 
			@PathParam("month") int month, 
			@PathParam("day") int day, 
			@PathParam("postName") String postName) {
		ActionResponse ar = new ActionResponse();
		ar.setActionStatus("Successfully");
		ar.setAdditionalMessage(String.format("Blog post [%s] created on [%d/%d/%d] was deleted. Operation is successful.", postName, month, day, year));

		String result = JsonUtils.objectToJson(ar);
		
		return result;
	}
	
	@Path("/{year}/{month}/{day}/{postName}")
	@POST
	@Consumes("text/plain")
	public String createNewBlogPost(
			@PathParam("year") int year, 
			@PathParam("month") int month, 
			@PathParam("day") int day, 
			@PathParam("postName") String postName,
			String requestBody) {
		BlogPostRequest request = JsonUtils.jsonToPojo(requestBody, BlogPostRequest.class);

		System.out.println(request.getAuthor());
		System.out.println(request.getPostTitle());
		System.out.println(request.getPostContent());

		BlogPostResponse response = new BlogPostResponse();
		response.setAuthor(request.getAuthor());
		response.setBlogCategory("[no category]");
		response.setDateValue(String.format("%d/%d/%d", month, day, year));
		response.setPostContent(request.getPostContent());
		response.setPostName(postName);
		response.setPostTitle(request.getPostTitle());

		String result = JsonUtils.objectToJson(response);

		return result;
	}
	
	@Path("/{year}/{month}/{day}/{postName}")
	@PUT
	@Consumes("text/plain")
	public String updateBlogPost(@PathParam("year") int year, 
			@PathParam("month") int month, 
			@PathParam("day") int day, 
			@PathParam("postName") String postName,
			String requestBody) {
		BlogPostRequest request = JsonUtils.jsonToPojo(requestBody, BlogPostRequest.class);

		System.out.println(request.getAuthor());
		System.out.println(request.getPostTitle());
		System.out.println(request.getPostContent());
		
		ActionResponse response = new ActionResponse();
		response.setActionStatus("Successful");
		response.setAdditionalMessage(String.format("Blog post [%s] created on [%d/%d/%d] was updated. Operation is successful.", postName, month, day, year));
		
		String result = JsonUtils.objectToJson(response);

		return result;
	}
}

  

Test

GET


 

DELETE


 

POST


 

PUT


 
参考资料:《RESTFul Web Service Development with Jersey 2.x》—— Han Bo Sun

  • 大小: 18.3 KB
  • 大小: 96.2 KB
  • 大小: 96.7 KB
  • 大小: 106.2 KB
  • 大小: 111 KB
分享到:
评论

相关推荐

    jersey@POST

    9. **扩展性**:除了基本的POST请求处理,Jersey还支持其他HTTP方法,如GET、PUT、DELETE等,以及更多高级特性,如分页、查询参数、响应编码等,可以根据需求进行扩展。 10. **最佳实践**:遵循REST原则,保持接口...

    Jersey所需Jar包

    开发者可以使用这个库来与RESTful服务进行交互,例如GET、POST、PUT、DELETE等HTTP方法。它包含了构建请求实体、处理响应头和实体、以及执行HTTP请求的相关类和接口。 2. **jersey-core**: Jersey的核心库,提供...

    jersey-core、jersey-client jar包.rar

    这个库使得开发者能够轻松地创建RESTful服务,提供HTTP方法(如GET、POST、PUT、DELETE)的实现,并支持XML、JSON等多种数据格式的交换。 jersey-client则是Jersey框架的客户端组件,它允许开发者从Java应用中发起...

    jersey服务demo

    - `@GET`, `@POST`, `@PUT`, `@DELETE`: 这些注解分别对应 HTTP 的 GET、POST、PUT 和 DELETE 方法,用于定义资源的方法处理这些请求。 - `@Produces`: 指定资源返回的数据类型,如 `@Produces("application/json...

    jersey实现简单的rest接口

    进一步探索Jersey,你可以学习如何处理POST、PUT、DELETE请求,如何进行参数绑定,使用过滤器和拦截器,以及如何利用JAXB或Jackson进行JSON序列化和反序列化。Jersey还提供了许多高级特性,如服务发现、安全控制和...

    jersey-archive-1.19.1

    在REST设计原则中,每个资源都有其唯一的URL,通过HTTP的不同方法(如GET、POST、PUT、DELETE等)对资源进行操作。`@GET`注解正是用来处理获取或列举资源的操作。 REST(Representational State Transfer,表述性...

    jersey1.18jar包

    通过官方文档,开发者可以学习如何配置服务,定义资源类,处理HTTP请求方法(GET、POST、PUT、DELETE等),以及如何利用注解进行参数绑定和验证。 在实际开发中,使用Jersey1.18时,首先需要在项目的类路径下添加...

    jersey框架

    通过使用注解,开发者可以轻松地将 HTTP 方法(如 GET、POST、PUT 和 DELETE)映射到 Java 类和方法,从而简化服务的创建。例如,使用 `@Path` 注解可以定义资源的 URI,而 `@GET`、`@POST` 等注解则用于指定响应...

    使用Jersey和Tomcat搭建的RESTful WebService

    1. **注解驱动的编程模型**:在本项目中,开发者可能会使用诸如`@Path`、`@GET`、`@POST`、`@PUT`、`@DELETE`等注解来标记资源类和方法,指定它们与哪些URI对应,以及如何响应不同类型的HTTP请求。 2. **资源类与...

    Eclipse中使用Jersey和Tomcat构建RESTful WebService及其调用

    客户端应用程序使用HTTP方法(GET/POST/PUT/DELETE)操作资源或资源集。 Jersey和JAX-RS -------------- JSR 311或JAX-RS(用于RESTful Web Services的Java API)的提议开始于2007年,1.0版本到2008年10月定稿。...

    RESTful Web 服务 Jersey使用

    GET用于获取资源,POST用于创建新资源,PUT用于更新资源,DELETE用于删除资源。 3. 路由(Routing):Jersey通过`@Path`注解将HTTP请求映射到相应的处理方法。例如,`@Path("/users")`表示该资源类处理所有与用户...

    Jersey RestFul

    例如,我们可以创建一个`UserResource`类,其中包含`@GET`、`@POST`、`@PUT`和`@DELETE`注解的方法来处理用户数据的CRUD操作。 2. **注解(Annotations)**:Jersey使用Java注解来映射HTTP请求和响应。例如,`@Path...

    jersey web实例

    使用Jersey,开发者可以快速创建符合REST原则的服务,如通过HTTP动词(GET、POST、PUT、DELETE)操作资源,以及使用URI来唯一标识资源。 1. JSON与XML支持:在RESTful服务中,数据通常以JSON或XML格式传输。Jersey...

    Jersey RESTful WebService框架学习(一)

    Jersey提供了丰富的注解来定义资源和方法的行为,如`@Path`、`@GET`、`@POST`、`@PUT`、`@DELETE`、`@PathParam`、`@QueryParam`、`@HeaderParam`等。这些注解使得接口清晰且易于理解。 **6. JSON数据交换** REST...

    java+restful+Jersey+webservice 远程调用

    RESTful服务强调资源的管理和操作,通过URI(Uniform Resource Identifier)来标识资源,并通过HTTP方法(GET、POST、PUT、DELETE等)进行操作。在Java世界中,实现RESTful服务的一个常用框架就是Jersey。 Jersey是...

    jersey所需jar包

    例如,`@Path` 注解用于定义资源路径,`@GET`, `@POST`, `@PUT`, `@DELETE` 用于定义 HTTP 方法,`@PathParam`, `@QueryParam`, `@HeaderParam`, `@CookieParam` 等用于处理请求参数。 5. **过滤器与扩展**: ...

    jersey

    1. **RESTful服务**:REST(Representational State Transfer)是一种网络应用程序的设计风格和开发方式,强调使用HTTP协议中的方法(如GET、POST、PUT、DELETE)来操作资源。Jersey提供了一种优雅的方式,将Java...

    jersey1.18 jar包

    标签"jersey rest"进一步明确了这个压缩包与RESTful服务开发有关,Jersey通过提供一套完整的API,简化了RESTful服务的实现,如支持GET、POST、PUT、DELETE等HTTP方法,以及JSON、XML数据格式的处理。 在压缩包的...

    jersey所有jar包下载

    2. **JAX-RS 注解**:Jersey 支持 JAX-RS 规范中的注解,如 `@Path`、`@GET`、`@POST`、`@PUT`、`@DELETE` 等,这些注解用于定义资源路径和 HTTP 方法映射。 3. **Message Body Workers**:Jersey 提供了一套默认的...

    使用Jersey框架搭建Rest服务

    REST是一种架构风格,它强调通过URI(统一资源标识符)来定位资源,并通过HTTP方法(如GET、POST、PUT、DELETE)进行操作。REST服务通常返回JSON或XML格式的数据,便于客户端处理。 接下来,我们进入核心部分——...

Global site tag (gtag.js) - Google Analytics