बाकी का अवलोकन। भाग 3: स्प्रिंग बूट पर एक विश्वसनीय सेवा का निर्माण

यह REST के हमारे अवलोकन का अंतिम भाग है। पिछले भागों में, हमने कवर किया:

• आराम क्या है?
• क्लाइंट और सर्वर के बीच संचार

प्रोजेक्ट बनाना

इस खंड में, हम स्प्रिंग बूट का उपयोग करके एक छोटा सा रेस्टफुल एप्लिकेशन बनाएंगे। हमारा एप्लिकेशन अवलोकन के पिछले भाग में उदाहरण से ग्राहकों पर CRUD (क्रिएट, रीड, अपडेट, डिलीट) संचालन को लागू करेगा। शुरू करने के लिए, हम मेनू के माध्यम से एक नया स्प्रिंग बूट एप्लिकेशन बनाएंगे: फ़ाइल -> नया -> प्रोजेक्ट ... खुलने वाली विंडो में, स्प्रिंग इनिशियलाइज़र का चयन करें और प्रोजेक्ट एसडीके निर्दिष्ट करें: "अगला" बटन पर क्लिक करें। अगली विंडो में, "मावेन प्रोजेक्ट" को प्रोजेक्ट प्रकार के रूप में निर्दिष्ट करें, "समूह" और "विरूपण साक्ष्य" निर्दिष्ट करें: "अगला" बटन पर क्लिक करें। अगली विंडो में, हमें प्रोजेक्ट के लिए आवश्यक स्प्रिंग फ्रेमवर्क घटकों का चयन करना होगा। स्प्रिंग वेब हमारे लिए पर्याप्त होगा: "अगला" बटन पर क्लिक करें। अब केवल प्रोजेक्ट का नाम और फ़ाइल सिस्टम में उसका स्थान इंगित करना बाकी है: "फिनिश" बटन पर क्लिक करें। प्रोजेक्ट बनाया गया है, और अब हम इसकी संरचना देख सकते हैं: IDEA ने हमारे लिए मावेन परिनियोजन डिस्क्रिप्टर (pom.xml) और एप्लिकेशन का मुख्य वर्ग ( ) तैयार किया। RestExampleApplicationयहाँ वे कैसे दिखते हैं:

pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.2.2.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.codegym.lessons/groupId>
   <artifactId>rest_example</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>rest_example</name>
   <description>REST example project</description>

   <properties>
       <java.version>1.8</java.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>

       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
           <exclusions>
               <exclusion>
                   <groupId>org.junit.vintage</groupId>
                   <artifactId>junit-vintage-engine</artifactId>
               </exclusion>
           </exclusions>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

</project>

बाकी उदाहरण आवेदन:

@SpringBootApplication
public class RestExampleApplication {

   public static void main(String[] args) {
       SpringApplication.run(RestExampleApplication.class, args);
   }

}

REST कार्यक्षमता बनाना

हमारा आवेदन एक ग्राहक प्रबंधन प्रणाली है। इसलिए, पहली चीज जो हमें करने की ज़रूरत है वह ग्राहक इकाई बनाना है। यह एक POJO (प्लेन ओल्ड जावा ऑब्जेक्ट) क्लास होगा। पैकेज modelके अंदर एक पैकेज बनाएं । com.codegym.lessons.rest_exampleपैकेज के अंदर model, बनाएँ Customer:

public class Customer {

   private Integer id;
   private String name;
   private String email;
   private String phone;

   public Integer getId() {
       return id;
   }

   public void setId(Integer id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public String getPhone() {
       return phone;
   }

   public void setPhone(String phone) {
       this.phone = phone;
   }
}

सेवा ग्राहकों पर CRUD संचालन लागू करेगी। अगला कदम एक सेवा बनाना है जो इन परिचालनों को लागू करेगी। पैकेज में , एक पैकेज com.codegym.lessons.rest_exampleबनाएँ । serviceऔर उसके अंदर, एक CustomerServiceइंटरफ़ेस बनाएँ। यहाँ टिप्पणियों के साथ इंटरफ़ेस कोड है:

public interface CustomerService {

   /**
    * Creates a new customer
    * @param customer - Customer to be created
    */
   void create(Customer customer);

   /**
    * Returns a list of all existing customers
    * @return List of customers
    */
   List<Customer> readAll();

   /**
    * Returns a customer based on its ID
    * @param id - Customer ID
    * @return - Customer object with the given ID
    */
   Customer read(int id);

   /**
    * Updates the customer with the given ID,
    * according to the passed customer
    * @param customer - Customer to use to update the data
    * @param id - ID of the customer you want to update
    * @return - true if the data has been updated, otherwise false
    */
   boolean update(Customer customer, int id);

   /**
    * Deletes the customer with the given ID
    * @param id - ID of the customer to be deleted
    * @return - true if the customer was deleted, otherwise false
    */
   boolean delete(int id);
}

अगला, हमें इस इंटरफ़ेस को लागू करने की आवश्यकता है। अब a Map<Integer, Customer>हमारे ग्राहकों को स्टोर करेगा। मानचित्र की कुंजियाँ ग्राहक आईडी होंगी, और मान स्वयं ग्राहक होंगे। ऐसा इसलिए किया जाता है ताकि वास्तविक डेटाबेस के साथ काम करने की बारीकियों के साथ इस उदाहरण को अधिभारित न किया जा सके। हालाँकि, भविष्य में हम इंटरफ़ेस का एक और कार्यान्वयन लिखने में सक्षम होंगे, जिससे वास्तविक डेटाबेस से जुड़ना संभव हो जाएगा। पैकेज में service, इंटरफ़ेस का कार्यान्वयन बनाएं CustomerService:

@Service
public class CustomerServiceImpl implements CustomerService {

   // Customer repository
   private static final Map<Integer, Customer> CUSTOMER_REPOSITORY_MAP = new HashMap<>();
  
   // Variable for generating a customer ID
   private static final AtomicInteger CUSTOMER_ID_HOLDER = new AtomicInteger();

   @Override
   public void create(Customer customer) {
       final int customerId = CUSTOMER_ID_HOLDER.incrementAndGet();
       customer.setId(customerId);
       CUSTOMER_REPOSITORY_MAP.put(customerId, customer);
   }

   @Override
   public List<Customer> readAll() {
       return new ArrayList<>(CUSTOMER_REPOSITORY_MAP.values());
   }

   @Override
   public Customer read(int id) {
       return CUSTOMER_REPOSITORY_MAP.get(id);
   }

   @Override
   public boolean update(Customer customer, int id) {
       if (CUSTOMER_REPOSITORY_MAP.containsKey(id)) {
           customer.setId(id);
           CUSTOMER_REPOSITORY_MAP.put(id, customer);
           return true;
       }

       return false;
   }

   @Override
   public boolean delete(int id) {
       return CUSTOMER_REPOSITORY_MAP.remove(id) != null;
   }
}

एनोटेशन @Serviceवसंत को बताता है कि यह वर्ग एक सेवा है। यह एक विशेष प्रकार का वर्ग है जो कुछ व्यावसायिक अनुप्रयोग तर्कों को लागू करता है। इसके बाद, इस एनोटेशन के लिए धन्यवाद, स्प्रिंग हमें उन सभी जगहों पर इस वर्ग का एक उदाहरण प्रदान करने के लिए निर्भरता इंजेक्शन का उपयोग करेगा जहां इसकी आवश्यकता है। अब नियंत्रक बनाने का समय आ गया है। यह एक विशेष वर्ग है जहां हम एंडपॉइंट्स (यूआरआई) को भेजे गए क्लाइंट अनुरोधों को संसाधित करने के लिए तर्क लागू करेंगे। यह सब स्पष्ट करने के लिए, हम इस वर्ग को वृद्धिशील रूप से बनाएंगे। सबसे पहले, कक्षा स्वयं बनाएं और इस पर निर्भरता जोड़ें CustomerService:

@RestController
public class CustomerController {

   private final CustomerService customerService;

   @Autowired
   public CustomerController(CustomerService customerService) {
       this.customerService = customerService;
   }
}

आइए एनोटेशन की व्याख्या करें: @RestController स्प्रिंग को बताता है कि यह वर्ग एक REST नियंत्रक है। दूसरे शब्दों में, यह वर्ग क्लाइंट अनुरोधों को संसाधित करने के तर्क को लागू करता है। @Autowired स्प्रिंग को बताता है कि यहां एक निर्भरता जोड़ने की आवश्यकता है। हम CustomerServiceकंस्ट्रक्टर को इंटरफ़ेस पास करते हैं। पहले, हमने इस सेवा के कार्यान्वयन को @Serviceएनोटेशन के साथ चिह्नित किया था, और अब स्प्रिंग इस कार्यान्वयन का एक उदाहरण नियंत्रक के निर्माता को पारित करने में सक्षम होगा। अगला, हम CRUD संचालन को संभालने के लिए प्रत्येक नियंत्रक विधि को लागू करेंगे। चलिए क्रिएट ऑपरेशन से शुरू करते हैं। ऐसा करने के लिए, हम एक createविधि लिखते हैं:

@PostMapping(value = "/customers")
public ResponseEntity<?> create(@RequestBody Customer customer) {
   customerService.create(customer);
   return new ResponseEntity<>(HttpStatus.CREATED);
}

आइए इस विधि का विश्लेषण करें: @PostMapping(value = "/customers")इसका मतलब है कि यह विधि "/ग्राहक" पते पर भेजे गए POST अनुरोधों को संसाधित करती है। विधि एक देता है ResponseEntity<?>। ए ResponseEntityप्रतिक्रियाओं को वापस करने के लिए एक विशेष वर्ग है। बाद में, हम क्लाइंट को HTTP स्टेटस कोड वापस करने के लिए इसका इस्तेमाल करेंगे। विधि में एक @RequestBody Customer customerपैरामीटर है। इस पैरामीटर का मान अनुरोध निकाय से आता है। एनोटेशन @RequestBodyयह इंगित करता है। विधि के मुख्य भाग के अंदर, हम create()पहले बनाई गई सेवा पर विधि को कॉल करते हैं और इसे मापदंडों में प्राप्त ग्राहक नियंत्रक को पास करते हैं। फिर हम एक नई वस्तु बनाकर ResponseEntityऔर संबंधित HttpStatusएनम फ़ील्ड को पास करके "201 निर्मित" स्थिति वापस कर देते हैं। अगला, हम लागू करेंगेreadऑपरेशन: सबसे पहले, हम सभी उपलब्ध ग्राहकों की सूची प्राप्त करने के लिए ऑपरेशन लागू करेंगे:

@GetMapping(value = "/customers")
public ResponseEntity<List<Customer>> read() {
   final List<Customer> customers = customerService.readAll();

   return customers != null &&  !customers.isEmpty()
           ? new ResponseEntity<>(customers, HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

आइए इसमें गोता लगाएँ: @GetMapping(value = "/customers")— यहाँ सब कुछ एनोटेशन के समान है @PostMapping, लेकिन अब हम GET अनुरोधों को संसाधित कर रहे हैं। इस बार हम एक वापसी करते हैं ResponseEntity<List<Customer>>, और एक HTTP स्थिति के अलावा, हम एक प्रतिक्रिया निकाय भी लौटाएंगे, जो ग्राहकों की सूची होगी। स्प्रिंग के REST नियंत्रकों में, सब कुछ POJO ऑब्जेक्ट्स और POJO ऑब्जेक्ट्स का संग्रह है, जो प्रतिक्रिया निकायों के रूप में लौटाए जाते हैं और स्वचालित रूप से JSON में क्रमबद्ध होते हैं, जब तक कि अन्यथा निर्दिष्ट न हो। यह हमें बिल्कुल सूट करता है। विधि के अंदर, हम सभी ग्राहकों की सूची प्राप्त करने के लिए अपनी सेवा का उपयोग करते हैं। अगला, यदि सूची शून्य नहीं है और खाली नहीं है, तो हम इसका उपयोग करते हैंResponseEntityक्लास ग्राहकों की सूची और "200 ओके" HTTP स्थिति कोड वापस करने के लिए। अन्यथा, हम केवल "404 नहीं मिला" HTTP स्थिति कोड लौटाते हैं। अब हम इसकी आईडी का उपयोग करके ग्राहक प्राप्त करने की क्षमता को लागू करेंगे:

@GetMapping(value = "/customers/{id}")
public ResponseEntity<Customer> read(@PathVariable(name = "id") int id) {
   final Customer customer = customerService.read(id);

   return customer != null
           ? new ResponseEntity<>(customer, HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

यहां एक नई चीज पाथ वेरिएबल है। चर को URI में परिभाषित किया गया है: value = "/customers/{id}". हम इसे घुंघराले ब्रेसिज़ में इंगित करते हैं। और हम इसे एनोटेशन intका उपयोग करके एक विधि पैरामीटर के रूप में प्राप्त करते हैं @PathVariable(name = "id")। यह विधि यूआरआई को फॉर्म में भेजे गए अनुरोधों को स्वीकार करेगी /customers/{id}, जहां {id}किसी भी संख्यात्मक मान का प्रतिनिधित्व करता है। यह मान बाद में int idचर के माध्यम से विधि पैरामीटर में पारित किया जाता है। शरीर में हम Customerअपनी सेवा से वस्तु को प्राप्त करते हैं और प्राप्त होते हैं id। और फिर, सूची के अनुरूप, हम या तो "200 ओके" स्थिति और Customerस्वयं वस्तु, या केवल "404 नहीं मिला" स्थिति लौटाते हैं यदि सिस्टम के पास कोई ग्राहक नहीं है id। हमें अभी भी दो ऑपरेशनों को लागू करने की आवश्यकता है: अपडेट और डिलीट। यहाँ इन विधियों के लिए कोड है:

@PutMapping(value = "/customers/{id}")
public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Customer customer) {
   final boolean updated = customerService.update(customer, id);

   return updated
           ? new ResponseEntity<>(HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
}

@DeleteMapping(value = "/customers/{id}")
public ResponseEntity<?> delete(@PathVariable(name = "id") int id) {
   final boolean deleted = customerService.delete(id);

   return deleted
           ? new ResponseEntity<>(HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
}

इन विधियों में अनिवार्य रूप से कुछ भी नया नहीं है, इसलिए हम विस्तृत विवरण को छोड़ देंगे। केवल ध्यान देने योग्य बात यह है कि update()विधि PUT अनुरोधों ( @PutMappingएनोटेशन) को संभालती है, और delete()विधि DELETE अनुरोधों ( DeleteMappingएनोटेशन) को संभालती है। यहाँ नियंत्रक के लिए पूरा कोड है:

@RestController
public class CustomerController {

   private final CustomerService customerService;

   @Autowired
   public CustomerController(CustomerService customerService) {
       this.customerService = customerService;
   }

   @PostMapping(value = "/customers")
   public ResponseEntity<?> create(@RequestBody Customer customer) {
       customerService.create(customer);
       return new ResponseEntity<>(HttpStatus.CREATED);
   }

   @GetMapping(value = "/customers")
   public ResponseEntity<List<Customer>> read() {
       final List<Customer> customers = customerService.readAll();

       return customers != null &&  !customers.isEmpty()
               ? new ResponseEntity<>(customers, HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_FOUND);
   }

   @GetMapping(value = "/customers/{id}")
   public ResponseEntity<Customer> read(@PathVariable(name = "id") int id) {
       final Customer customer = customerService.read(id);

       return customer != null
               ? new ResponseEntity<>(customer, HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_FOUND);
   }

   @PutMapping(value = "/customers/{id}")
   public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Customer customer) {
       final boolean updated = customerService.update(customer, id);

       return updated
               ? new ResponseEntity<>(HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
   }

   @DeleteMapping(value = "/customers/{id}")
   public ResponseEntity<?> delete(@PathVariable(name = "id") int id) {
       final boolean deleted = customerService.delete(id);

       return deleted
               ? new ResponseEntity<>(HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
   }
}

नतीजतन, हमारी परियोजना की संरचना इस प्रकार है:

लॉन्चिंग और परीक्षण

हमारे आवेदन को शुरू करने के लिए, बस कक्षा main()में विधि चलाएँ । RestExampleApplicationलेकिन रेस्टफुल वेब सेवाओं का परीक्षण करने के लिए, हमें अतिरिक्त सॉफ्टवेयर डाउनलोड करने की आवश्यकता है। तथ्य यह है कि एक सामान्य ब्राउज़र से GET अनुरोध भेजना काफी सरल है, लेकिन एक सामान्य ब्राउज़र POST, PUT और DELETE अनुरोध नहीं भेज सकता है। चिंता न करें: आप कोई HTTP अनुरोध भेजने के लिए पोस्टमैन नामक प्रोग्राम का उपयोग कर सकते हैं। आप इसे यहाँ डाउनलोड कर सकते हैं । पोस्टमैन को डाउनलोड और इंस्टॉल करने के बाद, हम अपने एप्लिकेशन का परीक्षण शुरू करते हैं। ऐसा करने के लिए, प्रोग्राम खोलें और एक नया अनुरोध बनाएँ: ऊपरी बाएँ कोने में "नया" बटन पर क्लिक करें। अगला, "अनुरोध" चुनें: अगला, इसे एक नाम दें और इसे सहेजें। अब सर्वर को एक POST रिक्वेस्ट भेजने की कोशिश करते हैं और पहला ग्राहक बनाते हैं: हम इस तरह कई ग्राहक बनाते हैं। फिर हम अनुरोध प्रकार को GET में बदलते हैं और सर्वर को अनुरोध भेजते हैं:

सारांश

बधाई हो! हमने पर्याप्त रूप से REST को कवर कर लिया है। बड़ी मात्रा में सामग्री थी, लेकिन उम्मीद है कि यह आपके लिए उपयोगी थी:

1. हमने सीखा कि REST क्या है।

2. हमने सीखा कि REST कैसे अस्तित्व में आया।

3. हमने इस स्थापत्य शैली की सीमाओं और सिद्धांतों के बारे में बात की:

   • क्लाइंट-सर्वर आर्किटेक्चर
   • राज्यविहीन
   • कैशिंग
   • वर्दी इंटरफ़ेस
   • परतें
   • कोड ऑन डिमांड (वैकल्पिक)

4. हमने REST द्वारा प्रदान किए जाने वाले लाभों की खोज की

5. हमने विस्तार से जांच की कि कैसे सर्वर और क्लाइंट HTTP प्रोटोकॉल के माध्यम से एक दूसरे के साथ बातचीत करते हैं।

6. हमने अनुरोधों और प्रतिक्रियाओं पर करीब से नज़र डाली। हमने उनके घटक भागों को विच्छेदित कर दिया।

7. अंत में, हमें स्प्रिंग बूट का उपयोग करके अपना छोटा रेस्टफुल एप्लिकेशन लिखकर कुछ व्यावहारिक अनुभव प्राप्त हुआ। और हमने पोस्टमैन का उपयोग करके इसका परीक्षण करना भी सीखा।

काहे। वह बहुत कुछ था, लेकिन अभी भी आपके लिए होमवर्क के रूप में कुछ करना बाकी है।

गृहकार्य

निम्नलिखित का प्रयास करें:

1. उपरोक्त विवरण के बाद, अपना स्वयं का स्प्रिंग बूट प्रोजेक्ट बनाएं और उसी तर्क को लागू करें जैसा कि पाठ में है। सब कुछ बिल्कुल दोहराएं।
2. एप्लिकेशन लॉन्च करें।
3. पोस्टमैन (या अनुरोध भेजने के लिए कोई अन्य उपकरण, उदाहरण के लिए, कर्ल) को डाउनलोड और कॉन्फ़िगर करें।
4. पाठ में बताए गए तरीके से POST और GET अनुरोधों का परीक्षण करें।
5. टेस्ट पुट और डिलीट अपने आप से अनुरोध करता है।