前言
今天看了一个关于基于Rest的开源框架介绍的文章,其中对Jersey极力推荐,没用过,打算尝试一下,对基础功能进行测试。
仅仅是入门试用。
了解了这个东西在是sun下的一个项目。
打算测试几种情况
1:Get无参数
2:Get有参数
3:Get通过路径传递参数
4:Post通过Form传递参数
5:Get返回一个对象
建立maven工程
pom.xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-core</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-client</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-json</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-server</artifactId>
<version>9.4.0.v20161208</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-servlet</artifactId>
<version>9.4.0.v20161208</version>
</dependency>
</dependencies>
Person.java
基础的Person类,需要关注一下注解。这个类是为第五个目标定义的
import javax.ws.rs.FormParam;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "person")
public class Person
{
@FormParam(value="name")
private String name;
@FormParam(value="id")
private int id;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String toString()
{
return "name="+name+",id="+id;
}
}
HelloJersey.java
处理请求的类,完全是一个POJO通过注解来进行路由,由于要符合REST的规范,因此客户端所有的请求都是无状态的。这个还是很关键的,根据客户端的请求可以直接进行必要的响应。
import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
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;
/**
*
*/
@Path("/hello")
public class HelloJersey
{
@GET
@Produces("text/plain")
public String hello()
{
return "Jersey Get!";
}
/**
* 参数是以URL?param=value的形式传递
* @param name
* @return
*/
@GET
@Path("hello_get")
@Produces("text/plain")
public String hello(@QueryParam("name") String name)
{
return "Jersey Get! param="+name;
}
/**
* 参数是以Form表单的形式传递的
* @param name
* @return
*/
@POST
@Path("hello_post")
@Consumes("application/x-www-form-urlencoded")
public String helloPost(@FormParam("name") String name)
{
return "Jersey Post! "+name;
}
/**
* 参数以路径的形式进行传递的
* @param id
* @return
*/
@GET
@Path("show/{id}")
@Produces("text/plain")
public String showName(@PathParam("id") int id)
{
return "Hello jersey!"+id;
}
@GET
@Path("getPerson")
@Produces(MediaType.APPLICATION_JSON)
public Person showPerson()
{
Person p=new Person();
p.setName("pName");
p.setId(11212);
return p;
}
}
JerseyApp .java
这个类是Jersey的服务器端部分,这里服务器用的是Jetty。
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import com.sun.jersey.api.core.PackagesResourceConfig;
import com.sun.jersey.spi.container.servlet.ServletContainer;
/**
*
*/
public class JerseyApp {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception
{
final Server server = new Server(8090);
ServletHolder sh = new ServletHolder(ServletContainer.class);
sh.setInitParameter(ServletContainer.RESOURCE_CONFIG_CLASS, PackagesResourceConfig.class.getCanonicalName());
sh.setInitParameter(PackagesResourceConfig.PROPERTY_PACKAGES, "cn.test.jersey.sample1");
ServletContextHandler context = new ServletContextHandler(server, null);
context.addServlet(sh, "/*");
server.start();
server.join();
Runtime.getRuntime().addShutdownHook(new Thread(){
public void run()
{
try
{
server.stop();
}
catch (Exception e)
{
e.printStackTrace();
}
}
});
}
}
JerseyClient.java
客户端的代码,通过这个代码就可以访问,刚才我们定义的服务器端部分。
import javax.ws.rs.core.MultivaluedMap;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.core.util.MultivaluedMapImpl;
public class JerseyClient
{
public static void main(String[] args)
{
//简单的请求直接请求URL
Client client = Client.create();
WebResource webResource = client.resource("http://127.0.0.1:8090/hello");
String s = webResource.get(String.class);
System.out.println("-------Normal Get------>"+s);
//通过路径传递参数
WebResource pathParam = client.resource("http://127.0.0.1:8090/hello/show/1212");
String pathValue = pathParam.get(String.class);
System.out.println("-------Path Value------>"+pathValue);
//Get,通过?的形式传递参数的形式
MultivaluedMap<String,String> queryParams = new MultivaluedMapImpl();
queryParams.add("name", "get_param");
WebResource getParam = client.resource("http://127.0.0.1:8090/hello/hello_get");
String getS=getParam.queryParams(queryParams).get(String.class);
System.out.println("-----Get Has Param---->"+getS);
//Post,通过Form提交参数的形式
MultivaluedMap<String,String> formData = new MultivaluedMapImpl();
formData.add("name", "formValue");
WebResource postParam = client.resource("http://127.0.0.1:8090/hello/hello_post");
String response = postParam.type("application/x-www-form-urlencoded").post(String.class, formData);
System.out.println("----------Post Form Value-----"+response);
//Get,获取一个对象底层是封装成Json进行传输的,但是client根据类型进行了转换,可以直接使用的对象
WebResource person = client.resource("http://127.0.0.1:8090/hello/getPerson");
Person p=person.get(Person.class);
System.out.println(p);
}
}
输出内容
-------Normal Get------>Jersey Get!
-------Path Value------>Hello jersey!1212
-----Get Has Param---->Jersey Get! param=get_param
----------Post Form Value-----Jersey Post! formValue
name=pName,id=11212
总结
例子很简单,只是抛砖引玉,通过这几种情况,可以大致的了解了Jersey的工作机制。
没有实现底层通信,用第三方实现的,如Jetty,grizzly2。
深层次的机制,等有时间再进行扩展吧!