REST جو جائزو. حصو 3: اسپرنگ بوٽ تي آرام واري خدمت جي تعمير

هي اسان جي REST جي نظرثاني جو آخري حصو آهي. پوئين حصن ۾، اسان ڍڪي ڇڏيو آهي:

• REST ڇا آهي؟
• ڪلائنٽ ۽ سرور جي وچ ۾ رابطي

هڪ پروجيڪٽ ٺاهڻ

هن حصي ۾، اسان اسپرنگ بوٽ استعمال ڪندي هڪ ننڍڙي آرام واري ايپليڪيشن ٺاهينداسين. اسان جي ايپليڪيشن CRUD (ٺاهي، پڙهو، تازه ڪاري، حذف) عملن تي عمل ڪندي گراهڪن تي مثال جي نظرثاني جي پوئين حصي ۾. شروع ڪرڻ لاءِ، اسان مينيو ذريعي نئين اسپرنگ بوٽ ايپليڪيشن ٺاهينداسين: فائل -> نئون -> پروجيڪٽ... جيڪا ونڊو کلي ٿي، ان ۾ Spring Initializr چونڊيو ۽ پروجيڪٽ SDK بيان ڪريو: "Next" بٽڻ تي ڪلڪ ڪريو. ايندڙ ونڊو ۾، "Maven پروجيڪٽ" کي منصوبي جي قسم جي طور تي بيان ڪريو، "گروپ" ۽ "آرٽيفڪٽ" جي وضاحت ڪريو: "اڳيون" بٽڻ تي ڪلڪ ڪريو. ايندڙ ونڊو ۾، اسان کي چونڊڻ جي ضرورت آهي بهار جي فريم ورڪ جي اجزاء کي منصوبي لاء ضروري. بهار جي ويب اسان لاءِ ڪافي هوندي: "اڳيون" بٽڻ تي ڪلڪ ڪريو. ھاڻي باقي رھيو آھي پروجيڪٽ جو نالو ۽ فائل سسٽم ۾ ان جي جڳھ کي ظاھر ڪرڻ: "ختم" بٽڻ تي ڪلڪ ڪريو. پروجيڪٽ ٺاهي وئي آهي، ۽ هاڻي اسان ان جي جوڙجڪ کي ڏسي سگهون ٿا: 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>

باقي مثال ايپليڪيشن:

@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);
}

اڳيون، اسان کي هن انٽرفيس کي لاڳو ڪرڻ جي ضرورت آهي. هاڻي هڪ Map<Integer, Customer>اسان جي گراهڪن کي ذخيرو ڪندو. نقشي جي ڪنجيون ھونديون ڪسٽمر IDs، ۽ قدر ھوندا پاڻ گراهڪ. اهو ڪيو ويو آهي ته جيئن هن مثال کي اوورلوڊ نه ڪيو وڃي حقيقي ڊيٽابيس سان ڪم ڪرڻ جي خاصيتن سان. بهرحال، مستقبل ۾ اسان انٽرفيس جي هڪ ٻي پليپشن کي لکڻ جي قابل ٿي سگهنداسين، جيڪو اهو ممڪن بڻائي سگهندو حقيقي ڊيٽابيس سان ڳنڍڻ. پيڪيج ۾ 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")مطلب ته هي طريقو پوسٽ جي درخواستن تي عمل ڪري ٿو جيڪو ايڊريس "/customers" ڏانهن موڪليو ويو آهي. طريقو واپس اچي ٿو a ResponseEntity<?>. A ResponseEntityهڪ خاص ڪلاس آهي جواب ڏيڻ لاءِ. بعد ۾، اسان ان کي ڪلائنٽ ڏانهن HTTP اسٽيٽس ڪوڊ واپس ڪرڻ لاءِ استعمال ڪنداسين. طريقو ھڪڙو @RequestBody Customer customerپيٽرولر آھي. هن پيٽرولر جو قدر اچي ٿو درخواست واري جسم مان. تشريح @RequestBodyهن ڏانهن اشارو ڪري ٿي. طريقي جي جسم جي اندر، اسان create()اڳوڻي ٺاهيل خدمت تي طريقو سڏين ٿا ۽ ان کي پيٽرولن ۾ حاصل ڪيل ڪسٽمر ڪنٽرولر کي منظور ڪيو. ان کان پوء اسان "201 ٺاهيل" اسٽيٽس کي واپس ڪريون ٿا هڪ نئون اعتراض ٺاهي ResponseEntity۽ ان سان لاڳاپيل HttpStatusاينيم فيلڊ کي منتقل ڪندي. اڳيون، اسان آپريشن کي لاڳو ڪنداسين 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 OK" HTTP اسٽيٽس ڪوڊ. ٻي صورت ۾، اسان صرف "404 نه مليو" HTTP اسٽيٽس ڪوڊ واپس ڪريون ٿا. هاڻي اسان ان جي ID استعمال ڪندي هڪ گراهڪ حاصل ڪرڻ جي صلاحيت لاڳو ڪنداسين:

@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")تشريح استعمال ڪندي. هي طريقو URIs ڏانهن موڪليل درخواستن کي فارم ۾ قبول ڪندو /customers/{id}، جتي {id}ڪنهن به عددي قدر جي نمائندگي ڪندو. هي قدر بعد ۾ int idvariable ذريعي طريقي جي پيٽرولر ڏانهن منتقل ڪيو ويو آهي. جسم ۾، اسان Customerاسان جي خدمت استعمال ڪندي اعتراض حاصل ڪريون ٿا ۽ حاصل ڪيل id. ۽ پوءِ، فهرست سان قياس ڪندي، اسان يا ته "200 OK" اسٽيٽس ۽ شئي 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 درخواستون هڪ عام برائوزر کان موڪلڻ لاءِ بلڪل ساديون آهن، پر هڪ عام برائوزر پوسٽ، پوٽ ۽ ڊيليٽي درخواستون نه ٿو موڪلي سگهي. پريشان نه ڪريو: توهان پوسٽمن نالي هڪ پروگرام استعمال ڪري سگهو ٿا ڪنهن به HTTP درخواستون موڪلڻ لاءِ. توھان ان کي ڊائون لوڊ ڪري سگھو ٿا هتي . پوسٽمن کي ڊائون لوڊ ۽ انسٽال ڪرڻ کان پوء، اسان اسان جي ايپليڪيشن کي جانچڻ شروع ڪندا آهيون. هن کي ڪرڻ لاء، پروگرام کوليو ۽ هڪ نئين درخواست ٺاهي: مٿي کاٻي ڪنڊ ۾ "نئون" بٽڻ تي ڪلڪ ڪريو. اڳيون، "درخواست" چونڊيو: اڳيون، ان کي نالو ڏيو ۽ ان کي بچايو. ھاڻي اچو ته ڪوشش ڪريون پوسٽ جي درخواست موڪلي سرور ڏانھن ۽ پھريون گراهڪ ٺاھيو: اسان ھن طريقي سان ڪيترائي گراهڪ ٺاھيون ٿا. پوء اسان GET ۾ درخواست جي قسم کي تبديل ڪريون ٿا ۽ سرور ڏانهن درخواست موڪليو:

خلاصو

مبارڪون هجن! اسان REST کي ڪافي ڍڪيو آھي. اتي مواد جو هڪ وڏو مقدار هو، پر اميد آهي ته اهو توهان لاء مفيد هو:

1. اسان سکيو ته REST ڇا آهي.

2. اسان سکيو ته REST ڪيئن وجود ۾ آيو.

3. اسان هن تعميراتي انداز جي پويان حدن ۽ اصولن بابت ڳالهايو:

   • ڪلائنٽ-سرور فن تعمير
   • بي رياست
   • ڪيش ڪرڻ
   • يونيفارم انٽرفيس
   • پرت
   • گهربل ڪوڊ (اختياري)

4. اسان REST پاران مهيا ڪيل فائدن جي ڳولا ڪئي

5. اسان تفصيل سان جانچيو ته ڪيئن سرور ۽ ڪلائنٽ هڪ ٻئي سان HTTP پروٽوڪول ذريعي لهه وچڙ ۾.

6. اسان درخواستن ۽ جوابن تي ويجھو نظر رکيو. اسان انهن جي جزن کي جدا ڪيو.

7. آخر ۾، اسان ڪجھ عملي تجربو حاصل ڪيو پنھنجي پنھنجي ننڍڙي RESTful ايپليڪيشن کي اسپرنگ بوٽ استعمال ڪندي لکي. ۽ اسان اهو پڻ سکيو ته پوسٽمين کي استعمال ڪندي ان کي ڪيئن آزمايو.

ڦوهه. اهو تمام گهڻو هو، پر اڃا به ڪجهه آهي ته توهان لاءِ هوم ورڪ ڪرڻ لاءِ.

گهر جو ڪم

ھيٺيون ڪوشش ڪريو:

1. مٿي ڏنل بيان تي عمل ڪندي، پنهنجو اسپرنگ بوٽ پروجيڪٽ ٺاهيو ۽ ساڳيو منطق لاڳو ڪريو جيئن سبق ۾ آهي. هر شي کي صحيح طور تي ورجايو.
2. ايپليڪيشن کي لانچ ڪريو.
3. پوسٽ مين ڊائون لوڊ ۽ ترتيب ڏيو (يا درخواست موڪلڻ لاءِ ڪو ٻيو اوزار، مثال طور، curl).
4. ٽيسٽ پوسٽ ڪريو ۽ درخواستن کي حاصل ڪريو ساڳئي طريقي سان سبق ۾ بيان ڪيو ويو آهي.
5. ٽيسٽ PUT ۽ DELETE درخواستون پاڻ کي.