( चित्रण )

99.9% डेवलपर्स के सामने आने वाली चुनौतियों में से एक तीसरे पक्ष के समापन बिंदु तक पहुंच रहा है। यह बाहरी API और "आपके अपने" दोनों प्रकार के माइक्रोसोर्सेज हो सकते हैं। अब हर कोई microservices मार रहा है, हाँ। डेटा को पुनः प्राप्त करना या भेजना सरल है, लेकिन कभी-कभी वे पहिया को सुदृढ़ करते हैं। क्या आप जावा में प्रश्नों को लागू करने के 5 तरीके (पुस्तकालयों और बिना उपयोग कर सकते हैं) का नाम दे सकते हैं? नहीं - बिल्ली में आपका स्वागत है। हाँ? आओ और तुलना करो;)

0. परिचय

जो कार्य हम हल करेंगे वह बेहद सरल है: हमें GET / POST अनुरोध भेजने और JSON प्रारूप में आने वाली प्रतिक्रिया प्राप्त करने की आवश्यकता है। अन्य मूल माइक्रोसर्विस को न लिखने के लिए, मैं एक उदाहरण का उपयोग करूंगा जो कुछ डेटा के साथ समापन बिंदु का एक सेट प्रदान करता है। सभी कोड उदाहरणों को अधिकतम सरलीकृत किया जाता है, यहां पर टोकन और हेडर के साथ कोई मुश्किल मामला नहीं होगा। केवल POST और GET, GET और POST, और इसी तरह 5 बार या तो।
तो चलिए चलते हैं।

1. अंतर्निहित जावा समाधान

यह अजीब होगा अगर तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना कार्य को हल नहीं किया जा सकता है। बेशक आप कर सकते हैं! लेकिन दुख की बात है। Java.net पैकेज, जिसका नाम HttpURLConnection, URL और URLEconconder है।

एक अनुरोध भेजने के लिए कि GST, कि POST, आपको एक URL ऑब्जेक्ट बनाने और इसके आधार पर एक कनेक्शन खोलने की आवश्यकता है:

final URL url = new URL("http://jsonplaceholder.typicode.com/posts?_limit=10"); final HttpURLConnection con = (HttpURLConnection) url.openConnection(); 

अगला, आपको सभी मापदंडों के साथ कनेक्शन को मसाला देना होगा:

 con.setRequestMethod("GET"); con.setRequestProperty("Content-Type", "application/json"); con.setConnectTimeout(CONNECTION_TIMEOUT); con.setReadTimeout(CONNECTION_TIMEOUT); 

और एक InputStream प्राप्त करें, जहाँ से प्राप्त सभी डेटा को पढ़ना है।

  try (final BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) { String inputLine; final StringBuilder content = new StringBuilder(); while ((inputLine = in.readLine()) != null) { content.append(inputLine); } return content.toString(); } catch (final Exception ex) { ex.printStackTrace(); return ""; } 

और, वास्तव में, यहां हमें ऐसा उत्तर मिलता है (यह बाद के सभी उदाहरणों के लिए समान होगा, क्योंकि हम एक ही समापन बिंदु के साथ काम करते हैं):

 [ { "userId": 1, "id": 1, "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit", "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto" }, { "userId": 1, "id": 2, "title": "qui est esse", "body": "est rerum tempore vitae\nsequi sint nihil reprehenderit dolor beatae ea dolores neque\nfugiat blanditiis voluptate porro vel nihil molestiae ut reiciendis\nqui aperiam non debitis possimus qui neque nisi nulla" }, ... { "userId": 1, "id": 9, "title": "nesciunt iure omnis dolorem tempora et accusantium", "body": "consectetur animi nesciunt iure dolore\nenim quia ad\nveniam autem ut quam aut nobis\net est aut quod aut provident voluptas autem voluptas" }, { "userId": 1, "id": 10, "title": "optio molestias id quia eum", "body": "quo et expedita modi cum officia vel magni\ndoloribus qui repudiandae\nvero nisi sit\nquos veniam quod sed accusamus veritatis error" } ] 

POST अनुरोध के मामले में, सब कुछ थोड़ा और अधिक जटिल है। हम न केवल एक उत्तर प्राप्त करना चाहते हैं, बल्कि डेटा प्रसारित करना भी चाहते हैं। इसके लिए हमें उन्हें वहां लगाने की जरूरत है। प्रलेखन हमें बताता है कि यह निम्नानुसार काम कर सकता है:

 final Map<String, String> parameters = new HashMap<>(); parameters.put("title", "foo"); parameters.put("body", "bar"); parameters.put("userId", "1"); con.setDoOutput(true); final DataOutputStream out = new DataOutputStream(con.getOutputStream()); out.writeBytes(getParamsString(parameters)); out.flush(); out.close(); 

GetParamsString एक सरल विधि है जो मानचित्र को स्ट्रिंग पर ले जाती है जिसमें कुंजी-मूल्य जोड़े होते हैं:

 public static String getParamsString(final Map<String, String> params) { final StringBuilder result = new StringBuilder(); params.forEach((name, value) -> { try { result.append(URLEncoder.encode(name, "UTF-8")); result.append('='); result.append(URLEncoder.encode(value, "UTF-8")); result.append('&'); } catch (final UnsupportedEncodingException e) { e.printStackTrace(); } }); final String resultString = result.toString(); return !resultString.isEmpty() ? resultString.substring(0, resultString.length() - 1) : resultString; } 

सफल निर्माण पर, हमें वस्तु वापस मिलती है:

 { "title": "foo", "body": "bar", "userId": "1", "id": 101} 

स्रोत का संदर्भ जिसे आप चला सकते हैं।

2. अपाचे HttpClient

यदि हम बिल्ट-इन समाधानों से दूर हो जाते हैं, तो सबसे पहले हम आ रहे हैं अपाचे के HttpClient। पहुँच के लिए, हमें JAR फ़ाइल की आवश्यकता है। या, जब से मैं मावेन का उपयोग कर रहा हूं, इसी निर्भरता है:

  <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.6</version> </dependency> 

और जिस तरह से प्रश्न HttpClient का उपयोग कर रहे हैं वह पहले से ही बेहतर है ( स्रोत ):

  final CloseableHttpClient httpclient = HttpClients.createDefault(); final HttpUriRequest httpGet = new HttpGet("http://jsonplaceholder.typicode.com/posts?_limit=10"); try ( CloseableHttpResponse response1 = httpclient.execute(httpGet) ){ final HttpEntity entity1 = response1.getEntity(); System.out.println(EntityUtils.toString(entity1)); } final HttpPost httpPost = new HttpPost("http://jsonplaceholder.typicode.com/posts"); final List<NameValuePair> params = new ArrayList<>(); params.add(new BasicNameValuePair("title", "foo")); params.add(new BasicNameValuePair("body", "bar")); params.add(new BasicNameValuePair("userId", "1")); httpPost.setEntity(new UrlEncodedFormEntity(params)); try ( CloseableHttpResponse response2 = httpclient.execute(httpPost) ){ final HttpEntity entity2 = response2.getEntity(); System.out.println(EntityUtils.toString(entity2)); } httpclient.close(); 

हमें एक ही डेटा मिला है, लेकिन आधा जितना कोड लिखा है। मुझे आश्चर्य है कि इस तरह के एक बुनियादी मुद्दे में वे और कहाँ खोज कर सकते हैं? लेकिन अपाचे में एक और मॉड्यूल है जो हमारी समस्या को हल करता है।

3. अपाचे धाराप्रवाह एपीआई

  <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>fluent-hc</artifactId> <version>4.5.6</version> </dependency> 

और पहले से ही धाराप्रवाह का उपयोग करते हुए, हमारे कॉल अधिक पठनीय ( स्रोत ) बन जाते हैं:

  final Content getResult = Request.Get("http://jsonplaceholder.typicode.com/posts?_limit=10") .execute().returnContent(); System.out.println(getResult.asString()); final Collection<NameValuePair> params = new ArrayList<>(); params.add(new BasicNameValuePair("title", "foo")); params.add(new BasicNameValuePair("body", "bar")); params.add(new BasicNameValuePair("userId", "1")); final Content postResultForm = Request.Post("http://jsonplaceholder.typicode.com/posts") .bodyForm(params, Charset.defaultCharset()) .execute().returnContent(); System.out.println(postResultForm.asString()); 

और एक बोनस के रूप में - एक उदाहरण। यदि हम प्रपत्र के रूप में नहीं, बल्कि सभी के पसंदीदा JSON के रूप में डेटा को शरीर में स्थानांतरित करना चाहते हैं:

  final Content postResult = Request.Post("http://jsonplaceholder.typicode.com/posts") .bodyString("{\"title\": \"foo\",\"body\":\"bar\",\"userId\": 1}", ContentType.APPLICATION_JSON) .execute().returnContent(); System.out.println(postResult.asString()); 

वास्तव में, कॉल कोड की एक पंक्ति में ढह गई। मेरे लिए, यह बहुत पहले विधि की तुलना में डेवलपर्स के लिए बहुत अधिक अनुकूल है।

4. स्प्रिंग रेस्टेमप्लेट

आगे क्या? आगे के अनुभव ने मुझे वसंत की दुनिया में ला दिया। और, आश्चर्य की बात नहीं, वसंत में भी हमारे सरल कार्य (अजीब, सही? एक काम, हल करने के लिए उपकरण नहीं हैं - यह भी एक जरूरत है! - एक बुनियादी स्तर पर, लेकिन किसी कारण से एक से अधिक समाधान हैं)। और पहला सॉल्यूशन (बेसिक) जो आपको स्प्रिंग इकोसिस्टम में मिलेगा वो है रेस्टेमप्लेट। और इसके लिए हमें पूरे चिड़ियाघर का काफी हिस्सा खींचने की जरूरत है। इसलिए यदि आपको एक गैर-आवेदन आवेदन में एक अनुरोध भेजने की आवश्यकता है, तो इसके लिए बेहतर है कि पूरे रसोईघर को न खींचें। और अगर पहले से ही एक वसंत है, तो क्यों नहीं? इसके लिए आपको अपनी जरूरत की सभी चीजों को कैसे खींचना है, आप यहां देख सकते हैं। ठीक है, वास्तव में जीईटी अनुरोध रिस्टेमप्लेट का उपयोग इस तरह दिखता है:

  final RestTemplate restTemplate = new RestTemplate(); final String stringPosts = restTemplate.getForObject("http://jsonplaceholder.typicode.com/posts?_limit=10", String.class); System.out.println(stringPosts); 

हूड। लेकिन! मैं अब एक तार के साथ काम नहीं करना चाहता, इसलिए सभी को तार नहीं प्राप्त करने का अवसर है, लेकिन तैयार वस्तुओं को जो हम प्राप्त करने की उम्मीद करते हैं! पोस्ट ऑब्जेक्ट बनाएं:

 import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import lombok.Builder; import lombok.Getter; import lombok.Setter; @Builder @Getter @Setter @JsonIgnoreProperties(ignoreUnknown = true) public class Post { private int id; private String title; private String body; private int userId; public String toString() { return String.format("\n id: %s \n title: %s \n body: %s \n userId: %s \n", id, title, body, userId); } } 

यहां:
बिल्डर, गेट्टर, सेटर - लोम्बोक से चीनी, हाथ से सब कुछ लिखने के लिए नहीं। हाँ, यहाँ वह है, आलस्य माँ।
JsonIgnoreProperties - ताकि अज्ञात फ़ील्ड प्राप्त करने के मामले में, त्रुटि में दुर्घटना न हो, लेकिन उन फ़ील्ड का उपयोग करें जो हम जानते हैं।
हमारी वस्तुओं को कंसोल पर आउटपुट करने के लिए, अच्छी तरह से, और यह पढ़ा जा सकता है। खैर, वास्तव में हमारे GET और POST अनुरोध ( स्रोत ) में तब्दील हो गए हैं:

  // Map it to list of objects final Post[] posts = restTemplate.getForObject("http://jsonplaceholder.typicode.com/posts?_limit=10", Post[].class); for (final Post post : posts) { System.out.println(post); } final Post postToInsert = Post.builder() .body("bar") .title("foo") .userId(1) .build(); final Post insertedPost = restTemplate.postForObject("http://jsonplaceholder.typicode.com/posts", postToInsert, Post.class); System.out.println(insertedPost); 

और हमारे पास पहले से ही हमारे हाथों में वस्तुएं हैं, न कि एक स्ट्रिंग जिसे हमें खुद को पार्स करने की आवश्यकता है।

कूल। अब हम RestTemplate के आसपास कुछ आवरण लिख सकते हैं ताकि क्वेरी सही तरीके से बनाई गई हो। यह इतना बुरा नहीं लगता, लेकिन, जैसा कि मेरे लिए है, फिर भी इसमें सुधार किया जा सकता है। कम कोड लिखा है, त्रुटि की संभावना कम है। हर कोई जानता है कि मुख्य समस्या अक्सर PEBCAK (चेयर और कीबोर्ड के बीच समस्या होती है) ...

5. स्प्रिंग फ़ाइन

और यहां चरण Feign आता है, जो स्प्रिंग क्लाउड का हिस्सा है। सबसे पहले, पहले से ही जोड़ा गया वसंत वातावरण में Feign निर्भरता जोड़ें:

  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-feign</artifactId> <version>1.4.5.RELEASE</version> </dependency> 

वास्तव में, सभी की जरूरत है कि इंटरफ़ेस की घोषणा करें और इसे एक अच्छा सा एनोटेशन के साथ मसाला दें। विशेष रूप से यह दृष्टिकोण उन लोगों के लिए आकर्षक होगा जो वसंत का उपयोग करके नियंत्रक लिखते हैं।

यहां हमें Feign ( स्रोत ) के माध्यम से अनुरोध भेजने की आवश्यकता है।

 @FeignClient(name = "jsonplaceholder", url = "http://jsonplaceholder.typicode.com", path = "/posts") public interface ApiClient { @RequestMapping(method = GET, value = "/", consumes = APPLICATION_JSON_VALUE) List<Post> getPosts(@RequestParam("_limit") final int postLimit); @RequestMapping(method = POST, value = "/", consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE) Post savePost(@RequestBody Post post); } 

सौंदर्य, है ना? और हां, रेस्टेमप्लेट के लिए हमने जो डेटा मॉडल लिखे थे, वे यहां फिर से उपयोग किए गए हैं।

6. निष्कर्ष

प्रस्तुत पांच के अलावा कार्यान्वयन का एक और तरीका नहीं है। यह संग्रह केवल लेखक के अनुभव का प्रतिबिंब है, जिसमें मैंने उनसे मुलाकात की और परियोजनाओं में उनका उपयोग करना शुरू किया। अब मैं सक्रिय रूप से Feign का उपयोग करता हूं, जीवन का आनंद लेता हूं और कुछ और सुविधाजनक होने की प्रतीक्षा करता हूं ताकि आप मॉनिटर में चिल्ला सकें "<पुस्तकालय का नाम>, मैं आपको चुनता हूं!" - उपयोग और एकीकरण के लिए सब कुछ तैयार था। इस बीच, Feign।

PS "आलसी" तरीकों में से एक के रूप में आप उत्पन्न ग्राहक स्वैगर पर विचार कर सकते हैं। लेकिन, जैसा कि वे कहते हैं, एक अति सूक्ष्म अंतर है। सभी डेवलपर्स अपने एपीआई का दस्तावेजीकरण करने के लिए स्वैगर का उपयोग नहीं करते हैं, और यहां तक ​​कि इसे इतनी उच्च गुणवत्ता में भी करते हैं कि वे आसानी से उत्पन्न कर सकते हैं और ग्राहक का उपयोग कर सकते हैं, और इसके बजाय एक एंटोमोलॉजिकल संग्रह प्राप्त नहीं कर सकते हैं, जो अच्छे से अधिक नुकसान पहुंचाएगा।