首次涉水Maven+Jersey，入門筆記

介紹一下項目中可能需要用到的jersey的jar包：

核心服務器：jersey-core.jar，jersey-server.jar，jsr311-api.jar，asm.jar
核心客戶端：（用於測試）jersey-client.jar
JAXB 支持：（在高級樣例中使用）jaxb-impl.jar，jaxb-api.jar，activation.jar，stax-api.jar，wstx-asl.jar
JSON 支持：（在高級樣例中使用）jersey-json.jar

使用Jersey可大致分爲以下步驟：

搭建Jersey環境
編寫服務器端業務邏輯，發佈rest接口
客戶端調用

那麼，我們按照步驟一步一步來：

1、使用Maven搭建環境（請確定所用的IDE已經裝好了Maven的插件）

選擇Maven Project

點擊Next進入下一步：選擇模板

最後，填寫相關信息，完成

Group Id：所在組織的名稱或ID；

Artifact Id：項目ID，簡單理解爲項目名稱就可以了；

Version：項目的版本號；

Package：項目的主目錄，一般會自動生成。

建立完項目後，我們能看到這樣的目錄結構，但是這並不是Maven的標準，我們需要做一下修改：

很簡單，刪除webapp下的index.jsp，並創建src/main/java、test/java兩個目錄。完成後，目錄結構如下：

修改pom文件，導入需要的jar包，一些相關的註釋也寫在裏面了。

pom.xml：

<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 >com.ezfen</ groupId>
    <artifactId >jerseyTest</ artifactId>
    <packaging >war</ packaging>
    <version >0.0.1-SNAPSHOT</ version>
    <name >jerseyTest Maven Webapp</ name>
    <url >http://maven.apache.org</ url>

    <!-- 定義Maven倉庫地址 -->
    <repositories >
         <repository>
             <id> maven2-repository.java.net</id >
             <name> Java.net Repository for Maven</ name>
             <url> http://download.java.net/maven/2/</url >
             <layout> default</layout >
         </repository>
    </repositories >

    <!-- 設置參數，在本xml中可以用EL表達式調用，方便管理和更換jar版本 -->
    <properties >
         <project.build.sourceEncoding> UTF-8</project.build.sourceEncoding >
         <spring.version> 3.0.5.RELEASE</spring.version >
         <jersey.version> 1.8</jersey.version >
    </properties >

    <dependencies >
        
         <!-- Jersey -->
         <dependency>
             <groupId> com.sun.jersey</groupId >
             <artifactId> jersey-core</artifactId >
             <version> ${jersey.version}</version >
         </dependency>
         <dependency>
             <groupId> com.sun.jersey</groupId >
             <artifactId> jersey-server</artifactId >
             <version> ${jersey.version}</version >
         </dependency>
         <dependency>
             <groupId> com.sun.jersey</groupId >
             <artifactId> jersey-client</artifactId >
             <version> ${jersey.version}</version >
         </dependency>
         <dependency>
             <groupId> com.sun.jersey</groupId >
             <artifactId> jersey-json </artifactId>
             <version> ${jersey.version}</version >
             <exclusions>
                 <exclusion>
                     <groupId> org.codehaus.jackson</groupId >
                     <artifactId> jackson-core-asl</artifactId>
                 </exclusion>
                 <exclusion>
                     <groupId> org.codehaus.jackson</groupId >
                     <artifactId> jackson-mapper-asl</artifactId >
                 </exclusion>
                 <exclusion>
                     <groupId> org.codehaus.jackson</groupId >
                     <artifactId> jackson-jaxrs</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
         <dependency>            
             <groupId> asm</groupId >
             <artifactId> asm</artifactId >
            <version> 3.2</version >
         </dependency>
         <!-- Jersey End -->
         <!-- 導入其他一些包：日誌、JSON -->
         <dependency>
             <groupId> log4j</groupId >
             <artifactId> log4j</artifactId >
             <version> 1.2.16</version >
         </dependency>
         <dependency>
             <groupId> com.google.code.gson</groupId >
             <artifactId> gson</artifactId >
             <version> 2.3.1</version >
         </dependency>
    </dependencies >
    
    <build >
         <finalName> jerseyTest</finalName >
         <!-- 項目需要Maven編譯器的支持 -->
         <plugins>
             <plugin>
                 <artifactId> maven-compiler-plugin</artifactId>
                 <configuration>
                     <source> 1.6</source >
                     <target> 1.6</target >
                 </configuration>
             </plugin>
         </plugins>
    </build >
</project>

可能會有人有疑問，pom文件的依賴（dependency）應該怎麼寫：

可以去到Maven的官方庫那裏找到自己需要的jar包，自然就會有相關的dependency代碼提供：

訪問網址：http://mvnrepository.com/

2、編寫服務器端業務邏輯，發佈rest接口

先實現rest接口：

package com.ezfen.service;

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

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
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 org.apache.log4j.Logger;

import com.ezfen.domain.User;

@Path("/users" )
public class RestWS {
    
    //定義靜態變量，服務器每接收一個請求都會重新加載類，因此如果需要計數，必須將相關變量設置爲static
    private static Logger logger = Logger.getLogger(RestWS.class);
    private static Integer index = 0;   
    private static Map<Integer, User> users = new HashMap<Integer, User>();
    
    public RestWS() {
         if(users .size() == 0) {
             users.put(index , new User(index++, "Ezfen", "123456" ));
             users.put(index , new User(index++, "Jersey", "654321" ));
        }
    }
    
    @GET
    @Path("{userid}")
    @Produces({MediaType. APPLICATION_JSON,MediaType.APPLICATION_XML})
    public User getUser( @PathParam("userid" ) Integer userID) {
         if(users .containsKey(userID)){
             logger.info("瀏覽器獲取了ID爲" + userID + "的用戶信息" );
             return users .get(userID);
        } else return null;
    }
    
    @GET
    @Path("list")
    @Produces(MediaType. APPLICATION_JSON)
    public List<User> getAllUsers(){
         logger.info("瀏覽器獲取了所有用戶信息" );
        List<User> userList = new ArrayList<User>();
         userList.addAll(users.values());
         return userList ;
    }
    
    @POST
    @Path("addition")
    @Consumes(MediaType. APPLICATION_FORM_URLENCODED )
    @Produces(MediaType. TEXT_PLAIN)
    public String addUser( @FormParam("userName" ) String userName, @FormParam ("passWord" ) String passWord) {
         users.put(index , new User(index++, userName, passWord ));
         logger.info("添加新的用戶信息，該用戶ID爲：" + (index-1));
         return String.valueOf( index-1);
    }
    
    @PUT
    @Path("update")
    @Produces(MediaType. TEXT_PLAIN)
    public String updateUser(@QueryParam("userName" ) String userName, @QueryParam ("passWord" ) String passWord, @QueryParam ("userID" ) Integer userID){
         if(!users .containsKey(userID)) {
             logger.info("瀏覽器訪問了不存在的用戶" );
             return "不存在該用戶" ;
        } else {
            User user = users .get(userID);
             user.setUserName(userName );
             user.setPassWord(passWord );
             logger.info("瀏覽器修改了用戶ID爲：" + userID + "的信息" );
             return "修改成功" ;
        }
    }
    
    @DELETE
    @Path("delete/{userID}")
    @Produces(MediaType. TEXT_PLAIN)
    public String deleteUser(@PathParam("userID" ) Integer userID) {
         if(users .containsKey(userID)) {
             users.remove(userID );
             logger.info("瀏覽器刪除了ID爲：" + userID +"的用戶" );
             return "刪除成功" ;
        } else {
             logger.info("瀏覽器訪問了不存在的用戶" );
             return "用戶不存在，刪除失敗" ;
        }
    }
}

編寫完成後，我們需要在web.xml中配置該webservice：

web.xml：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name >Archetype Created Web Application</display-name>
    <servlet >
         <servlet-name> jerseyws</servlet-name >
         <servlet-class> com.sun.jersey.spi.container.servlet.ServletContainer </servlet-class>
         <init-param>
             <param-name> com.sun.jersey.config.property.resourceConfigClass</param-name >
             <param-value> com.sun.jersey.api.core.PackagesResourceConfig</param-value >
         </init-param>
         <init-param>
             <param-name> com.sun.jersey.config.property.packages</param-name >
             <param-value> com.ezfen.service</param-value >
         </init-param>
         <load-on-startup> 1</ load-on-startup>
    </servlet >
    
    <servlet-mapping >
         <servlet-name> jerseyws</servlet-name >
         <url-pattern> /rest/*</url-pattern >
    </servlet-mapping >
</web-app>

3、客戶端調用

完成後，我們可以啓動服務器，看看我們的webservice：

(1) tomcat提示：

(2)手動訪問：對於GET方法的測試，直接瀏覽器訪問即可：

對於POST方法的測試，我們需要再編寫多一個jsp文件：

<%@ page language= "java" contentType ="text/html; charset=UTF-8"
    pageEncoding="UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" >
<title> Insert title here</title >
</head>
<body>
    添加用戶： <br/>
    <form action="rest/users/addition" method="POST" >
        USERNAME : <input name="userName" type="text" /><br />
        PASSWORD : <input name="passWord" type="password" /><br />
         <input name="submit" type="submit" value="submit" >
    </form >
</body>
</html>

訪問該資源，通過表單提交即可：

可以看到添加進去了。

(3)PUT和DELETE方法，這兩個方法比較特殊，通過表單那我們無法指定這兩個方法的使用，因此需要重新寫測試方法。

這也是我爲什麼在pom文件裏面引入jersey-client的原因。

測試類：

package jerseyTest;

import java.io.BufferedReader;
import java.io.InputStreamReader;

import javax.ws.rs.core.MultivaluedMap;

import org.junit.Test;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.core.util.MultivaluedMapImpl;

public class JerseyTest {

    private String url = "http://localhost:8080/jerseyTest/rest/users" ;
    
    @Test
    public void testDelete() {
        Client client = Client.create();
        WebResource webResource = client.resource(url + "/delete/2");
        ClientResponse response = webResource.delete(ClientResponse.class);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null ;
        String line = null ;
         try {
             bufferedReader = new BufferedReader(new InputStreamReader(response .getEntityInputStream(),"UTF-8"));
             while((line = bufferedReader.readLine()) != null) {
                 stringBuilder.append(line );
            }
        } catch (Exception e ) {
             e.printStackTrace();
        }
        System. out.println("Jersey服務器端返回的消息爲：" + stringBuilder.toString());
    }

    @Test
    public void testUpdate(){
        Client client = Client.create();
        WebResource webResource = client.resource(url + "/update");
        MultivaluedMap<String, String> queryMap = new MultivaluedMapImpl();
         queryMap.add("userID" , "1" );
         queryMap.add("userName" , "aaa" );
         queryMap.add("passWord" , "bbb" );
        ClientResponse clientResponse = webResource.queryParams(queryMap ).put(ClientResponse.class);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null ;
        String line = null ;
         try {
             bufferedReader = new BufferedReader(new InputStreamReader(clientResponse .getEntityInputStream(),"UTF-8"));
             while((line = bufferedReader.readLine()) != null) {
                 stringBuilder.append(line );
            }
        } catch (Exception e ) {
             e.printStackTrace();
        }
        System. out.println("Jersey服務器端返回的消息爲：" + stringBuilder.toString());
    }
    
}

借鑑很多前輩的作品，這裏列出，大家可以參考參考：

http://www.cnblogs.com/bluesfeng/archive/2010/10/28/1863816.html

http://www.tuicool.com/articles/67vyIbv

http://www.ibm.com/developerworks/cn/web/wa-aj-tomcat/#ibm-pcon

首次涉水Maven+Jersey，入門筆記

首次涉水Maven+Jersey，入門筆記

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結