WebService框架jersey的使用

最新推荐文章于 2024-05-14 15:14:27 发布

原创最新推荐文章于 2024-05-14 15:14:27 发布 · 852 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#WebService

分布式专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了如何使用Jersey框架在服务端创建并配置WebService，包括web.xml的配置、实体类的注解使用，以及自定义资源加载器。在客户端，讲解了如何调用服务接口，并提到了通过CXF调用WebService的可能性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

服务端：

1、新建一个web项目，将下载解压的jaxrs里的全部jar包导入项目中

2、在web.xml中添加配置，引入jersey，同时配置资源加载器

注意：jersey 1.x版本的jersey主拦截器是：com.sun.jersey.spi.container.servlet.ServletContainer

jersey 2.x版本主拦截器是：org.glassfish.jersey.servlet.ServletContainer

根据你jersey引入框架的不同来配置<servlet-class></servlet-class>

<?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_2_5.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>MyJersey</display-name>
	
	<servlet>
	    <servlet-name>jersey-servlet</servlet-name>
	    <servlet-class>
			org.glassfish.jersey.servlet.ServletContainer
		</servlet-class>
		<!-- 配置自己的资源加载类去加载资源 -->
		<init-param>
			<param-name>javax.ws.rs.Application</param-name>
			<param-value>
				com.jersey.service.MyServiceRegister
			</param-value>
		</init-param>
	    <load-on-startup>1</load-on-startup>
  	</servlet>
  	<servlet-mapping>
	    <servlet-name>jersey-servlet</servlet-name>
	    <url-pattern>/rest/*</url-pattern>
  	</servlet-mapping>

	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

3、创建要发布的实体类

package com.jersey.service;

import javax.ws.rs.BeanParam;
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 javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

import com.jersey.service.model.User;

@Path("HelloWorld")
public class HelloWorld {

	@GET
	/*
	 * 这里如果是Post请求，在浏览器中直接使用路径检测接口 就会报405错误：不允许访问该方法，因为浏览器路径访问是属于Get请求
	 */
	@Path("/sayHello/{name}")
	@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
	@Produces(MediaType.APPLICATION_JSON)
	public String sayHello(@PathParam("name") String name) {
		return "Hello " + name;
	}

	
	 //网页版本用这个才能接收到参数，正确解析，可以用ajax请求，也可以用浏览器测试工具
	@PUT
	@Produces(MediaType.APPLICATION_XML)
	public User newUser(@BeanParam User user) {
		return user;
	}

	// 如果用jersey客户端的只能用这个，直接传递实体类和相应实体类
	@PUT
	@Path("Client")
	@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
	public User newUser1(User user) {
		return user;
	}
	
	
	//网页版本用这个才能接收到参数，正确解析，可以用ajax请求，也可以用浏览器测试工具
    @POST
    //参数说明 @Consumes  可以接收客户端什么样的形式过来，
    //网页过来的post请求的内容形式一般是application/x-www-form-urlencoded,一般如果不确定注释即可
    //@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Consumes({MediaType.APPLICATION_FORM_URLENCODED})
    //@Produces，返回给客户端的的类型MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON
    //如果请求段没指定就会返回xml优先
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public User createUser(@BeanParam User user){
        return user;
    }
    //如果用jersey客户端的只能用这个，直接传递实体类和相应实体类
    //上面和下面代码的区别 @BeanParam Book book，Book book 注意传入的实体类,返回json
    @POST
    @Path("createUser2")
   // @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public User createUser2(User user) {
        return user;
    }
    
    //返回对象
    @POST
    @Path("createUser3")
   // @Consumes(MediaType.APPLICATION_JSON)
   // @Produces(MediaType.APPLICATION_JSON)
    public User createUser3(User user) {
        return user;
    }

    @DELETE
    @Produces(MediaType.APPLICATION_JSON)
    public String delete(@QueryParam("userId") final int userId){
        System.out.println(userId);
        return userId + "";
    }
    
    @GET
    @Path("getUserJson")
    @Produces(MediaType.APPLICATION_JSON)
    public User getUserJson(){
       User user = new User();
       user.setName("xinwei");
       user.setAge(1);
       return user;
    }
    
    @GET
    @Path("getUser")
    public User getUser(){
       User user = new User();
       user.setName("root");
       user.setAge(1);
       return user;
    }

}

其中：

@Path，标注资源类或者方法的相对路径　　

@GET，@PUT，@POST，@DELETE，标注方法是HTTP请求的类型。　　

@Produces，标注返回的MIME媒体类型　　

@Consumes，标注可接受请求的MIME媒体类型

@PathParam，@QueryParam，@HeaderParam，@CookieParam，@MatrixParam，@FormParam,分别标注方法的参数来自于HTTP请求的不同位置，例如@PathParam来自于URL的路径，@QueryParam来自于URL的查询参数，@HeaderParam来自于HTTP请求的头信息，@CookieParam来自于HTTP请求的Cookie。

网上资源对jersey常用注解解释：

Annotation	作用	说明
@GET	查询请求	相当于数据库的查询数据操作
@POST	插入请求	相当于数据库的插入数据操作
@PUT	更新请求	相当于数据库的更新数据操作
@DELETE	删除请求	相当于数据的删除数据操作
@Path	uri路径	定义资源的访问路径，client通过这个路径访问资源。比如：@Path("user")
@Produces	指定返回MIME格式	资源按照那种数据格式返回，可取的值有：MediaType.APPLICATION_XXX。比如： @Produces(MediaType.APPLICATION_XML)
@Consumes	接受指定的MIME格式	只有符合这个参数设置的请求再能访问到这个资源。比如 @Consumes("application/x-www-form-urlencoded")
@PathParam	uri路径参数	写在方法的参数中，获得请求路径参数。比如：@PathParam("username") String userName
@QueryParam	uri路径请求参数	写在方法的参数中，获得请求路径附带的参数。比如： @QueryParam("desc") String desc
@DefaultValue	设置@QueryParam参数的默认值	如果@QueryParam没有接收到值，就使用默认值。比如：@DefaultValue("description") @QueryParam("desc") String desc
@FormParam	form传递的参数	接受form传递过来的参数。比如： @FormParam("name") String userName
@BeanParam	通过Bena的形式传递参数	接受client传递的bean类型的参数，同时这个bean可以在属性上配置@FormParam用以解决client的属性名称和bean的属性名称不一致的问题。比如： @BeanParam User user
@Context	获得一些系统环境信息	通过@Context可以获得以下信息：UriInfo、ServletConfig、ServletContext、HttpServletRequest、HttpServletResponse和HttpHeaders等
@XmlRootElement	将bean转换为xml	如果要讲bean以xml或json的格式返回，必须要这个注解。比如： @XmlRootElement public class User｛...｝
@XmlElements
@XmlElement

4、编写资源加载器，将各种资源加载进来，暴露给client。

有两种加载资源的方式，一种是使用自己的资源加载器去加载资源，需要给出自己资源加载器的位置。另一种是使用默认的资源加载器加载，需要给出资源所在的package。个人主张第一种，写一个自己的资源加载器去加载想要加载的资源，这样感觉可控性强一点，可以加载业务资源以外，还可以加载日子和其他的需要一些工具资源等等。或者package下的某个资源不想被暴露，就不要加载进来就可以了。

资源加载器类：

package com.jersey.service;


import org.codehaus.jackson.jaxrs.JacksonJsonProvider;
import org.glassfish.jersey.server.ResourceConfig;

public class MyServiceRegister extends ResourceConfig {
	
	public MyServiceRegister() { 
		register(HelloWorld.class);
		//register(JacksonJsonProvider.class);
	}
}

5.运行项目，在浏览器中输入访问地址：

http://localhost:8080/MyJersey/rest/HelloWorld/sayHello/admin

你也可以访问：http://localhost:8080/MyJersey/rest/application.wadl 得到wadl的接口说明文档。

注意：这里浏览器路径访问的到的前提是该接口中配置为Get请求

客户端的调用：

1.新建一个项目，导入jaxrs里的全部jar包(可将上个Project里的的jar全部导入，避免漏包)

2.然后在src下新建一个客户端测试类，调用web service接口

package com.jersey.client;

import java.security.SecureRandom;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.ws.rs.core.MediaType;

import com.jersey.client.model.User;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.client.urlconnection.HTTPSProperties;




public class TestClient {

	public static void main(String[] args) throws Exception {
		String url = "https://172.31.5.43/MyJersey/rest/HelloWorld";
		/*Client client = ClientBuilder.newClient();
		WebTarget webTarget = client.target(url).path("HelloWorld").path("sayHello/admin");
		Builder builder = webTarget.request(MediaType.APPLICATION_JSON);
		String result = builder.get(String.class);
		System.out.println(result);
		*/
		//WebResource webResource = creatWebResource(url);
		getTest(url);
		//getUserTest(url); //register(JacksonJsonProvider.class);需要注释掉
		//getUserJSONTest(url);
		//postTest(url);
		//putTest(url);
		//deleteTest(url);
		//postJSONTest(url);
		
	}
	
	
	public static void getTest(String url){
		String path = url + "/sayHello/admin";
		WebResource webResource = creatWebResource(path);
		webResource.path("sayHello/admin");
		
		//指定响应的MIME类型
		webResource.accept(MediaType.APPLICATION_JSON_TYPE);  
		String result = webResource.get(String.class);  
		System.out.println(result);
	}
	
	//获得User对象
	public static void getUserTest(String url){
		String path = url + "/getUser";
		WebResource webResource = creatWebResource(path);
		User result = webResource.get(User.class);
		System.out.println(result);
	}
	
	//获得user对象的json
	public static void getUserJSONTest(String url){
		String path = url + "/getUserJson";
		WebResource webResource = creatWebResource(path);
		String result = webResource.get(String.class);
		System.out.println(result);
	}
	
	public static void postTest(String url){
		String path = url + "/createUser3";
		WebResource webResource = creatWebResource(path);
		//webResource.path("Client");
		User user = new User();
		user.setName("jersey_post"); 
		user.setAge(2);
		User user2 = webResource.post(User.class, user);
		//User user2 = response.getEntity(User.class);
		System.out.println("name = " + user2.getName() +","+ "age = " + user2.getAge());
	}
	
	public static void postJSONTest(String url){
		String path = url + "/createUser2";
		WebResource webResource = creatWebResource(path);
		//webResource.path("Client");
		/* JSONObject param = new JSONObject();
		 param.put("name", "Alice");
		 param.put("age", "1");*/
		User user = new User();
		user.setName("jersey_post");
		user.setAge(2);
		String result = webResource.post(String.class, user);
		//User user2 = response.getEntity(User.class);
		System.out.println(result);
	}
	
	public static void putTest(String url){
		String path = url + "/Client";
		WebResource webResource = creatWebResource(path); 
		//webResource.path("Client");
		User user = new User();
		user.setName("jersey_put");
		user.setAge(1);
		User user2 = webResource.type(MediaType.APPLICATION_XML).put(User.class, user);
		System.out.println("name = " + user2.getName() +","+ "age = " + user2.getAge());
	}
	
	public static void deleteTest(String url){
		WebResource webResource = creatWebResource(url);
		//webResource.accept(MediaType.APPLICATION_JSON_TYPE);  
		String result = webResource.queryParam("userId", "20").delete(String.class); 
		//String result = response.getEntity(String.class);
		System.out.println(result);
	}
	
	public static WebResource creatWebResource(String url){
		WebResource webResource = null;
		try {
			TrustManager[] trustAllCerts = new TrustManager[] {   
	                new X509TrustManager() {  
	                    public X509Certificate[] getAcceptedIssuers() {  
	                        return null;  
	                    }  
	                    @Override  
	                    public void checkClientTrusted(X509Certificate[] certs, String authType) {}  
	                    @Override  
	                    public void checkServerTrusted(X509Certificate[] certs, String authType) {}  
	                }  
	        };  
			
			SSLContext context = SSLContext.getInstance("TLS");
			context.init(null, trustAllCerts, new SecureRandom());
			HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());  
			  
			ClientConfig config = new DefaultClientConfig();  
			//config.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);  
	        config.getProperties().put(  
	            HTTPSProperties.PROPERTY_HTTPS_PROPERTIES,  
	            new HTTPSProperties(new HostnameVerifier() {  
	                public boolean verify(String s, SSLSession sslSession) {  
	                    return true;  
	                }  
	            }, context)  
	        );  
			
			
			Client client = Client.create(config);  
			client.setFollowRedirects(true);
			webResource = client.resource(url);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return webResource;
	}
	
}

参照文章： jersey实现web service接口+客户端调用

使用CXF和Jersey框架来进行Java的WebService编程