REST चे विहंगावलोकन. भाग 3: स्प्रिंग बूटवर आरामदायी सेवा तयार करणे

हा आमच्या REST च्या विहंगावलोकनाचा अंतिम भाग आहे. मागील भागांमध्ये, आम्ही कव्हर केले:

• REST म्हणजे काय?
• क्लायंट आणि सर्व्हर दरम्यान संप्रेषण

एक प्रकल्प तयार करणे

या विभागात, आम्ही स्प्रिंग बूट वापरून एक लहान RESTful ऍप्लिकेशन तयार करू. आमचा अनुप्रयोग विहंगावलोकनाच्या मागील भागात दिलेल्या उदाहरणावरून ग्राहकांवर CRUD (तयार करा, वाचा, अपडेट करा, हटवा) ऑपरेशन्स लागू करेल . सुरू करण्यासाठी, आम्ही मेनूद्वारे नवीन स्प्रिंग बूट ऍप्लिकेशन तयार करू: फाइल -> नवीन -> प्रोजेक्ट... उघडणाऱ्या विंडोमध्ये, स्प्रिंग इनिशियलाइजर निवडा आणि प्रोजेक्ट SDK निर्दिष्ट करा: "पुढील" बटणावर क्लिक करा. पुढील विंडोमध्ये, प्रोजेक्ट प्रकार म्हणून "Maven Project" निर्दिष्ट करा, "Group" आणि "artifact" निर्दिष्ट करा: "Next" बटणावर क्लिक करा. पुढील विंडोमध्ये, प्रकल्पासाठी आवश्यक असलेले स्प्रिंग फ्रेमवर्क घटक निवडणे आवश्यक आहे. स्प्रिंग वेब आमच्यासाठी पुरेसे असेल: "पुढील" बटणावर क्लिक करा. आता फक्त प्रकल्पाचे नाव आणि फाइल सिस्टममध्ये त्याचे स्थान सूचित करणे बाकी आहे: "समाप्त" बटणावर क्लिक करा. प्रकल्प तयार झाला आहे, आणि आता आपण त्याची रचना पाहू शकतो: IDEA ने आमच्यासाठी एक Maven उपयोजन वर्णनकर्ता (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>

RestExampleApplication:

@SpringBootApplication
public class RestExampleApplication {

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

}

REST कार्यक्षमता तयार करणे

आमचा अर्ज ग्राहक व्यवस्थापन प्रणाली आहे. म्हणून, सर्वप्रथम आपल्याला ग्राहक घटक तयार करण्याची आवश्यकता आहे. हा POJO (साधा जुना Java ऑब्जेक्ट) वर्ग असेल. 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);
}

पुढे, आपल्याला हा इंटरफेस लागू करणे आवश्यक आहे. आता एक 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वसंत ऋतूला सांगते की हा वर्ग एक सेवा आहे. हा एक विशेष प्रकारचा वर्ग आहे जो काही व्यावसायिक अनुप्रयोग तर्क लागू करतो. त्यानंतर, या भाष्याबद्दल धन्यवाद, स्प्रिंग आम्हाला आवश्यक असलेल्या सर्व ठिकाणी या वर्गाचे उदाहरण देण्यासाठी अवलंबित्व इंजेक्शन वापरेल. आता कंट्रोलर तयार करण्याची वेळ आली आहे. हा एक विशेष वर्ग आहे जिथे आम्ही एंडपॉइंट्स (URIs) वर पाठवलेल्या क्लायंट विनंत्यांच्या प्रक्रियेसाठी तर्क लागू करू. हे सर्व स्पष्ट करण्यासाठी, आम्ही हा वर्ग वाढत्या प्रमाणात तयार करू. प्रथम, स्वतः वर्ग तयार करा आणि यावर अवलंबित्व जोडा 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 विनंतीवर प्रक्रिया करते. पद्धत a परत करते ResponseEntity<?>. A ResponseEntityहा प्रतिसाद देणारा विशेष वर्ग आहे. नंतर, आम्ही क्लायंटला HTTP स्थिती कोड परत करण्यासाठी त्याचा वापर करू. पद्धतीमध्ये एक @RequestBody Customer customerपॅरामीटर आहे. या पॅरामीटरचे मूल्य विनंती मुख्य भागातून येते. भाष्य @RequestBodyहे सूचित करते. पद्धतीच्या मुख्य भागामध्ये, आम्ही create()पूर्वी तयार केलेल्या सेवेवर पद्धत कॉल करतो आणि पॅरामीटर्समध्ये प्राप्त झालेल्या ग्राहक नियंत्रकास पास करतो. मग आम्ही नवीन ResponseEntityऑब्जेक्ट तयार करून आणि संबंधित HttpStatusenum फील्ड पास करून "201 Created" स्थिती परत करतो. पुढे, आम्ही अंमलबजावणी करू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"). ही पद्धत URI ला पाठवलेल्या विनंत्या फॉर्ममध्ये स्वीकारेल /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. परंतु RESTful वेब सेवांची चाचणी घेण्यासाठी, आम्हाला अतिरिक्त सॉफ्टवेअर डाउनलोड करावे लागेल. वस्तुस्थिती अशी आहे की सामान्य ब्राउझरवरून GET विनंत्या पाठवणे अगदी सोपे आहे, परंतु सामान्य ब्राउझर POST, PUT आणि DELETE विनंत्या पाठवू शकत नाही. काळजी करू नका: तुम्ही कोणत्याही HTTP विनंत्या पाठवण्यासाठी पोस्टमन नावाचा प्रोग्राम वापरू शकता. तुम्ही ते येथे डाउनलोड करू शकता . पोस्टमन डाउनलोड आणि स्थापित केल्यानंतर, आम्ही आमच्या अनुप्रयोगाची चाचणी सुरू करतो. हे करण्यासाठी, प्रोग्राम उघडा आणि एक नवीन विनंती तयार करा: वरच्या डाव्या कोपर्यात "नवीन" बटणावर क्लिक करा. पुढे, "विनंती" निवडा: पुढे, त्याला एक नाव द्या आणि ते जतन करा. आता सर्व्हरला POST विनंती पाठवण्याचा आणि पहिला ग्राहक तयार करण्याचा प्रयत्न करूया: आम्ही अशा प्रकारे अनेक ग्राहक तयार करतो. मग आम्ही विनंती प्रकार GET मध्ये बदलतो आणि सर्व्हरला विनंती पाठवतो:

सारांश

अभिनंदन! आम्ही पुरेशी REST कव्हर केले आहे. तेथे मोठ्या प्रमाणात सामग्री होती, परंतु आशा आहे की ती आपल्यासाठी उपयुक्त होती:

1. REST म्हणजे काय हे आम्ही शिकलो.

2. REST कसे अस्तित्वात आले याबद्दल आम्ही शिकलो.

3. आम्ही या स्थापत्य शैलीच्या मर्यादा आणि तत्त्वांबद्दल बोललो:

   • क्लायंट-सर्व्हर आर्किटेक्चर
   • राज्यहीन
   • कॅशिंग
   • एकसमान इंटरफेस
   • स्तर
   • मागणीनुसार कोड (पर्यायी)

4. आम्ही REST द्वारे प्रदान केलेले फायदे शोधले

5. HTTP प्रोटोकॉलद्वारे सर्व्हर आणि क्लायंट एकमेकांशी कसा संवाद साधतात याचे आम्ही तपशीलवार परीक्षण केले.

6. आम्ही विनंत्या आणि प्रतिसाद जवळून पाहिले. आम्ही त्यांचे घटक भाग विच्छेदित केले.

7. शेवटी, स्प्रिंग बूट वापरून आमचे स्वतःचे छोटे RESTful ऍप्लिकेशन लिहून आम्हाला काही व्यावहारिक अनुभव मिळाला. आणि आम्ही पोस्टमन वापरून त्याची चाचणी कशी करायची हे देखील शिकलो.

ओफ. ते खूप होते, पण तरीही तुमच्यासाठी गृहपाठ म्हणून काहीतरी करायचे आहे.

गृहपाठ

पुढील गोष्टी करून पहा:

1. वरील वर्णनाचे अनुसरण करून, तुमचा स्वतःचा स्प्रिंग बूट प्रकल्प तयार करा आणि धड्यातील समान तर्क लागू करा. सर्वकाही अचूकपणे पुन्हा करा.
2. अनुप्रयोग लाँच करा.
3. पोस्टमन (किंवा विनंत्या पाठवण्यासाठी इतर कोणतेही साधन, उदाहरणार्थ, कर्ल) डाउनलोड आणि कॉन्फिगर करा.
4. पाठात वर्णन केल्याप्रमाणे POST आणि GET विनंत्या तपासा.
5. PUT आणि DELETE विनंतीची स्वतः चाचणी करा.