คุณสร้างไคลเอ็นต์ REST สำหรับ Java ได้อย่างไร [ปิด]

ด้วย JSR 311 และการใช้งานเรามีมาตรฐานที่มีประสิทธิภาพสำหรับการเปิดเผยวัตถุ Java ผ่าน REST อย่างไรก็ตามในฝั่งไคลเอ็นต์ดูเหมือนว่าจะมีบางอย่างที่ขาดหายไปซึ่งเทียบได้กับ Apache Axis for SOAP ซึ่งเป็นสิ่งที่ซ่อนบริการเว็บและรวบรวมข้อมูลกลับไปที่วัตถุ Java อย่างโปร่งใส

คุณสร้างไคลเอนต์ Java RESTful ได้อย่างไร การใช้การเชื่อมต่อ HTTPC และการแยกวิเคราะห์ผลลัพธ์ด้วยตนเองหรือไม่ หรือลูกค้าเฉพาะทางเช่น Jersey หรือ Apache CXR?

นี่เป็นคำถามเก่า (2008) ดังนั้นตอนนี้มีตัวเลือกมากมายกว่าที่เคยมี:

• Apache CXFมีตัวเลือก REST Clientสามแบบ
• เจอร์ซีย์ (ดังกล่าวข้างต้น)
• Spring RestTemplate ทับด้วย Spring WebClient
• Commons HTTP Clientสร้างของคุณเองสำหรับโปรเจ็กต์ Java รุ่นเก่า

การอัปเดต (โครงการยังคงเปิดใช้งานในปี 2020):

• Apache HTTP Components (4.2) Fluent adapter - การเปลี่ยนพื้นฐานสำหรับ JDK ซึ่งใช้โดยผู้สมัครอื่น ๆ ในรายการนี้ ดีกว่า Commons HTTP Client 3 แบบเก่าและใช้งานง่ายกว่าในการสร้างไคลเอ็นต์ REST ของคุณเอง คุณจะต้องใช้บางอย่างเช่น Jackson สำหรับการสนับสนุนการแยกวิเคราะห์ JSONและคุณสามารถใช้ URIBuilder คอมโพเนนต์ HTTP เพื่อสร้าง URI ของทรัพยากรที่คล้ายกับไคลเอนต์ Jersey / JAX-RS Rest ส่วนประกอบ HTTP ยังรองรับ NIO แต่ฉันสงสัยว่าคุณจะได้รับประสิทธิภาพที่ดีกว่า BIO เนื่องจากคำขอสั้น ๆ ของ REST Apache HttpComponents 5รองรับ HTTP / 2
• OkHttp - การแทนที่ขั้นพื้นฐานสำหรับ JDK ซึ่งคล้ายกับส่วนประกอบ http ซึ่งใช้โดยผู้สมัครอื่น ๆ ในรายการนี้ รองรับโปรโตคอล HTTP รุ่นใหม่ (SPDY และ HTTP2) ทำงานบน Android น่าเสียดายที่ไม่มีตัวเลือก async แบบวนรอบเครื่องปฏิกรณ์ที่แท้จริง (ดูส่วนประกอบ Ning และ HTTP ด้านบน) อย่างไรก็ตามหากคุณใช้โปรโตคอล HTTP2 ที่ใหม่กว่านี่จะเป็นปัญหาน้อยกว่า (สมมติว่าจำนวนการเชื่อมต่อเป็นปัญหา)
• Ning Async-http-client - ให้การสนับสนุน NIO ที่รู้จักกันก่อนหน้านี้เป็น Async-http ลูกค้าโดย Sonatype
• Feign wrapper สำหรับไคลเอนต์ http ระดับล่าง (okhttp, apache httpcomponents) สร้างไคลเอนต์อัตโนมัติตามส่วนต่อประสานที่คล้ายกับส่วนขยาย Jersey และ CXF บางตัว การรวมสปริงที่แข็งแกร่ง
• Retrofit - เสื้อคลุมสำหรับไคลเอนต์ http ระดับล่าง (okhttp) สร้างไคลเอนต์อัตโนมัติตามส่วนต่อประสานที่คล้ายกับส่วนขยาย Jersey และ CXF บางตัว
• Volley wrapper สำหรับลูกค้า jdk http โดย Google
• google-http wrapper สำหรับไคลเอ็นต์ jdk http หรือ apache httpcomponents โดย Google
• Unirest wrapper สำหรับไคลเอนต์ jdk http โดย kong
• Resteasy JakartaEE wrapper สำหรับลูกค้า jdk http โดย jboss เป็นส่วนหนึ่งของ jboss framework
• jcabi-http wrapper สำหรับ apache httpcomponents ซึ่งเป็นส่วนหนึ่งของคอลเลกชัน jcabi
• restlet wrapper สำหรับ apache httpcomponents ซึ่งเป็นส่วนหนึ่งของ restlet framework
• เสื้อคลุมที่มั่นใจได้พร้อมคำยืนยันสำหรับการทดสอบที่ง่าย

ข้อแม้ในการเลือกไคลเอ็นต์ HTTP / REST อย่าลืมตรวจสอบว่าเฟรมเวิร์กสแต็กของคุณใช้สำหรับไคลเอ็นต์ HTTP อย่างไรมันทำเธรดอย่างไรและควรใช้ไคลเอ็นต์เดียวกันหากมี นั่นคือถ้าคุณใช้บางอย่างเช่น Vert.x หรือ Play คุณอาจต้องการลองใช้ไคลเอนต์สำรองเพื่อเข้าร่วมในบัสหรือเครื่องปฏิกรณ์ใด ๆ ก็ตามที่เฟรมเวิร์กจัดเตรียมไว้ ... มิฉะนั้นให้เตรียมพร้อมสำหรับปัญหาเธรดที่น่าสนใจ

ดังที่ฉันได้กล่าวไว้ในหัวข้อนี้ฉันมักจะใช้Jerseyซึ่งใช้ JAX-RS และมาพร้อมกับไคลเอนต์ REST ที่ดี สิ่งที่ดีคือถ้าคุณใช้ทรัพยากร RESTful โดยใช้ JAX-RS ไคลเอนต์ Jersey สามารถนำผู้ให้บริการเอนทิตีกลับมาใช้ใหม่เช่น JAXB / XML / JSON / Atom เป็นต้นเพื่อให้คุณสามารถนำอ็อบเจ็กต์เดียวกันกลับมาใช้ใหม่บนฝั่งเซิร์ฟเวอร์ได้เช่นเดียวกับคุณ ใช้ในการทดสอบหน่วยฝั่งไคลเอ็นต์

ตัวอย่างเช่นนี่คือกรณีทดสอบหน่วยจากโปรเจ็กต์ Apache Camelซึ่งค้นหาเพย์โหลด XML จากรีซอร์ส RESTful (โดยใช้ปลายทางวัตถุ JAXB) เมธอด resource (uri) ถูกกำหนดไว้ในคลาสพื้นฐานนี้ซึ่งใช้เพียง Jersey ไคลเอ็นต์ API

เช่น

    clientConfig = new DefaultClientConfig();
    client = Client.create(clientConfig);

    resource = client.resource("http://localhost:8080");
    // lets get the XML as a String
    String text = resource("foo").accept("application/xml").get(String.class);        

BTW ฉันหวังว่า JAX-RS เวอร์ชันในอนาคตจะเพิ่ม API ฝั่งไคลเอ็นต์ที่ดีตามบรรทัดในเจอร์ซีย์

คุณสามารถใช้ Java SE API มาตรฐาน:

private void updateCustomer(Customer customer) { 
    try { 
        URL url = new URL("http://www.example.com/customers"); 
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
        connection.setDoOutput(true); 
        connection.setInstanceFollowRedirects(false); 
        connection.setRequestMethod("PUT"); 
        connection.setRequestProperty("Content-Type", "application/xml"); 

        OutputStream os = connection.getOutputStream(); 
        jaxbContext.createMarshaller().marshal(customer, os); 
        os.flush(); 

        connection.getResponseCode(); 
        connection.disconnect(); 
    } catch(Exception e) { 
        throw new RuntimeException(e); 
    } 
} 

หรือคุณสามารถใช้ API ไคลเอ็นต์ REST ที่จัดเตรียมโดยการใช้งาน JAX-RS เช่น Jersey API เหล่านี้ใช้งานง่ายกว่า แต่ต้องใช้ไหเพิ่มเติมในเส้นทางชั้นเรียนของคุณ

WebResource resource = client.resource("http://www.example.com/customers"); 
ClientResponse response = resource.type("application/xml");).put(ClientResponse.class, "<customer>...</customer."); 
System.out.println(response); 

สำหรับข้อมูลเพิ่มเติมโปรดดู:

• http://bdoughan.blogspot.com/2010/08/creating-restful-web-service-part-55.html

หากคุณต้องการเรียกใช้บริการ REST และแยกวิเคราะห์คำตอบคุณสามารถลองใช้Rest Assured

// Make a GET request to "/lotto"
String json = get("/lotto").asString()
// Parse the JSON response
List<String> winnderIds = with(json).get("lotto.winners.winnerId");

// Make a POST request to "/shopping"
String xml = post("/shopping").andReturn().body().asString()
// Parse the XML
Node category = with(xml).get("shopping.category[0]");

นอกจากนี้คุณยังสามารถตรวจสอบRestletซึ่งมีความสามารถฝั่งไคลเอ็นต์เต็มรูปแบบโดย REST มุ่งเน้นไปที่ไลบรารีระดับล่างเช่น HttpURLConnection หรือ Apache HTTP Client (ซึ่งเราสามารถใช้ประโยชน์จากตัวเชื่อมต่อได้)

ขอแสดงความนับถือเจอโรมลูเวล

คุณอาจจะลองRapa แจ้งให้เราทราบความคิดเห็นของคุณเกี่ยวกับเรื่องเดียวกันนี้ และอย่าลังเลที่จะบันทึกปัญหาหรือคุณสมบัติที่คาดหวัง

ฉันต้องการชี้ให้เห็นอีก 2 ตัวเลือก:

• Restfulieซึ่งใช้เว็บเฟรมเวิร์ก VRaptor มีทั้งการใช้งานเซิร์ฟเวอร์และฝั่งไคลเอ็นต์พร้อมการสนับสนุน Hypermedia ที่ดีมาก
• RESTEasyมีการใช้งานไคลเอ็นต์ที่ใช้พร็อกซี JAX-RS

ลองJdkRequestจากjcabi-http (ฉันเป็นผู้พัฒนา) นี่คือวิธีการทำงาน:

String body = new JdkRequest("http://www.google.com")
  .header("User-Agent", "it's me")
  .fetch()
  .body()

ตรวจสอบโพสต์บล็อกนี้สำหรับรายละเอียดเพิ่มเติม: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

ฉันเพิ่งลองใช้Retrofit Library จากสี่เหลี่ยมมันเยี่ยมมากและคุณสามารถเรียก API ที่เหลือได้อย่างง่ายดาย การกำหนดค่าตามคำอธิบายประกอบช่วยให้เราสามารถกำจัดการเข้ารหัสแผ่นหม้อไอน้ำจำนวนมากได้

ฉันใช้ Apache HTTPClient เพื่อจัดการด้าน HTTP ทั้งหมด

ฉันเขียนตัวแยกวิเคราะห์ XML SAX สำหรับเนื้อหา XML ที่แยกวิเคราะห์ XML ลงในโมเดลอ็อบเจ็กต์ของคุณ ฉันเชื่อว่า Axis2 ยังแสดง XML -> Model method (แกน 1 ซ่อนส่วนนี้อย่างน่ารำคาญ) เครื่องกำเนิด XML นั้นเรียบง่ายเล็กน้อย

ใช้เวลาไม่นานในการเขียนโค้ดและค่อนข้างมีประสิทธิภาพในความคิดของฉัน

OkHttp มีน้ำหนักเบาและทรงพลังเมื่อรวมกับ Retrofit ด้วย ใช้งานได้ดีสำหรับการใช้งาน Java ทั่วไปและบน Android

OkHttp : http://square.github.io/okhttp/

public static final MediaType JSON
    = MediaType.parse("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  Response response = client.newCall(request).execute();
  return response.body().string();
}

ชุดติดตั้งเพิ่มเติม : http://square.github.io/retrofit/

public interface GitHubService {
  @GET("/users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

เนื่องจากไม่มีใครกล่าวถึงที่นี่เป็นอีกที่หนึ่ง: ประดิษฐ์ซึ่งถูกใช้โดยฤดูใบไม้ผลิเมฆ

แม้ว่าจะสร้างไคลเอนต์ HTTP และทำการรียูสซ้ำได้ง่าย แต่ถ้าคุณต้องการใช้ไคลเอนต์ที่สร้างขึ้นโดยอัตโนมัติคุณสามารถใช้ WADL เพื่ออธิบายและสร้างโค้ดได้

คุณสามารถใช้RestDescribeเพื่อสร้างและรวบรวม WSDL คุณสามารถสร้างไคลเอนต์ใน php, ruby, python, java และ C # โดยใช้สิ่งนี้ สร้างรหัสที่สะอาดและมีการเปลี่ยนแปลงที่ดีที่คุณต้องปรับแต่งเล็กน้อยหลังจากการสร้างรหัสคุณสามารถค้นหาเอกสารที่ดีและความคิดพื้นฐานที่อยู่เบื้องหลังเครื่องมือได้ที่นี่ที่นี่

มีเครื่องมือ WADL ที่น่าสนใจและมีประโยชน์บางอย่างที่กล่าวถึงใน wintermute

ฉันเขียนไลบรารีที่แมปอินเทอร์เฟซ java กับบริการ JSON REST ระยะไกล:

https://github.com/ggeorgovassilis/spring-rest-invoker

public interface BookService {
   @RequestMapping("/volumes")
   QueryResult findBooksByTitle(@RequestParam("q") String q);

   @RequestMapping("/volumes/{id}")
   Item findBookById(@PathVariable("id") String id);
}

ฉันใช้RestAssuredเกือบตลอดเวลาเพื่อแยกวิเคราะห์การตอบสนองของบริการส่วนที่เหลือและทดสอบบริการ นอกเหนือจาก Rest Assured ฉันยังใช้ไลบรารีด้านล่างเพื่อสื่อสารกับบริการ Resful

ก. ลูกค้า Jersey Rest

ข. สปริง RestTemplate

ค. ไคลเอ็นต์ Apache HTTP

ลองดูที่ http-rest-client

https://github.com/g00dnatur3/http-rest-client

นี่คือตัวอย่างง่ายๆ:

RestClient client = RestClient.builder().build();
String geocoderUrl = "http://maps.googleapis.com/maps/api/geocode/json"
Map<String, String> params = Maps.newHashMap();
params.put("address", "beverly hills 90210");
params.put("sensor", "false");
JsonNode node = client.get(geocoderUrl, params, JsonNode.class);

ไลบรารีจะดูแลการทำให้เป็นอนุกรม json และการเชื่อมโยงสำหรับคุณ

นี่คืออีกตัวอย่างหนึ่ง

RestClient client = RestClient.builder().build();
String url = ...
Person person = ...
Header header = client.create(url, person);
if (header != null) System.out.println("Location header is:" + header.value());

และตัวอย่างสุดท้าย

RestClient client = RestClient.builder().build();
String url = ...
Person person = client.get(url, null, Person.class); //no queryParams

ไชโย!

ตัวอย่างของ Jersey Rest Client: การ
เพิ่มการอ้างอิง:

         <!-- jersey -->
    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-json</artifactId>
        <version>1.8</version>
    </dependency>
   <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-server</artifactId>
        <version>1.8</version>
    </dependency>

<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-client</artifactId>
    <version>1.8</version>
</dependency>

    <dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20090211</version>
</dependency>

ForGetMethod และส่งผ่านพารามิเตอร์สองตัว:

          Client client = Client.create();
           WebResource webResource1 = client
                        .resource("http://localhost:10102/NewsTickerServices/AddGroup/"
                                + userN + "/" + groupName);

                ClientResponse response1 = webResource1.get(ClientResponse.class);
                System.out.println("responser is" + response1);

GetMethod ผ่านหนึ่งพารามิเตอร์และรับการตอบสนองของรายการ:

       Client client = Client.create();

        WebResource webResource1 = client
                    .resource("http://localhost:10102/NewsTickerServices/GetAssignedUser/"+grpName);    
    //value changed
    String response1 = webResource1.type(MediaType.APPLICATION_JSON).get(String.class);

    List <String > Assignedlist =new ArrayList<String>();
     JSONArray jsonArr2 =new JSONArray(response1);
    for (int i =0;i<jsonArr2.length();i++){

        Assignedlist.add(jsonArr2.getString(i));    
    }

ในด้านบนจะส่งคืนรายการที่เรายอมรับเป็นรายการจากนั้นแปลงเป็น Json Array จากนั้น Json Array เป็น List

หาก Post Request ผ่าน Json Object เป็นพารามิเตอร์:

   Client client = Client.create();
    WebResource webResource = client
            .resource("http://localhost:10102/NewsTickerServices/CreateJUser");
    // value added

    ClientResponse response = webResource.type(MediaType.APPLICATION_JSON).post(ClientResponse.class,mapper.writeValueAsString(user));

    if (response.getStatus() == 500) {

        context.addMessage(null, new FacesMessage("User already exist "));
    }

ฉันกำลังใช้https://github.com/kevinsawicki/http-requestฉันชอบความเรียบง่ายและวิธีแสดงตัวอย่าง แต่ส่วนใหญ่ฉันขายเมื่อฉันอ่าน:

การพึ่งพาคืออะไร?

ไม่มี. เป้าหมายของไลบรารีนี้คือเป็นคลาสคลาสเดียวที่มีคลาสคงที่ภายใน โครงการทดสอบต้องใช้ Jetty เพื่อทดสอบคำขอกับการใช้งานเซิร์ฟเวอร์ HTTP จริง

ซึ่งจัดการปัญหาบางอย่างในโครงการ java 1.6 สำหรับการถอดรหัส json เป็นวัตถุgsonนั้นอยู่ยงคงกระพัน :)