Jersey 简单试用

前言

今天看了一个关于基于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。
深层次的机制，等有时间再进行扩展吧！