REST کا جائزہ۔ حصہ 3: اسپرنگ بوٹ پر ایک آرام دہ سروس کی تعمیر

یہ ہمارے REST کے جائزہ کا آخری حصہ ہے۔ پچھلے حصوں میں، ہم نے احاطہ کیا:

• REST کیا ہے؟
• کلائنٹ اور سرور کے درمیان مواصلت

ایک پروجیکٹ بنانا

اس سیکشن میں، ہم Spring Boot کا استعمال کرتے ہوئے ایک چھوٹی سی RESTful ایپلی کیشن بنائیں گے۔ ہماری ایپلیکیشن مجموعی جائزہ کے پچھلے حصے میں دی گئی مثال سے صارفین پر CRUD (تخلیق کریں، پڑھیں، اپ ڈیٹ کریں، حذف کریں) آپریشنز کو نافذ کرے گی۔ شروع کرنے کے لیے، ہم مینو کے ذریعے ایک نئی اسپرنگ بوٹ ایپلیکیشن بنائیں گے: فائل -> نیا -> پروجیکٹ... کھلنے والی ونڈو میں، Spring Initializr کو منتخب کریں اور پروجیکٹ SDK کی وضاحت کریں: "اگلا" بٹن پر کلک کریں۔ اگلی ونڈو میں، پروجیکٹ کی قسم کے طور پر "Maven Project" کی وضاحت کریں، "Group" اور "artifact" کی وضاحت کریں: "Next" بٹن پر کلک کریں۔ اگلی ونڈو میں، ہمیں پراجیکٹ کے لیے ضروری اسپرنگ فریم ورک کے اجزاء کو منتخب کرنے کی ضرورت ہے۔ اسپرنگ ویب ہمارے لیے کافی ہوگا: "اگلا" بٹن پر کلک کریں۔ اب جو باقی ہے وہ پروجیکٹ کا نام اور فائل سسٹم میں اس کے مقام کی نشاندہی کرنا ہے: "Finish" بٹن پر کلک کریں۔ پروجیکٹ بن گیا ہے، اور اب ہم اس کی ساخت دیکھ سکتے ہیں: 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 (سادہ پرانا جاوا آبجیکٹ) کلاس ہوگا۔ 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>ہمارے گاہکوں کو ذخیرہ کرے گا. نقشے کی کلیدیں گاہک کی ID ہوں گی، اور قدریں خود گاہک ہوں گی۔ ایسا اس لیے کیا جاتا ہے تاکہ اس مثال کو حقیقی ڈیٹا بیس کے ساتھ کام کرنے کی تفصیلات کے ساتھ اوورلوڈ نہ کیا جا سکے۔ تاہم، مستقبل میں ہم انٹرفیس کا ایک اور نفاذ لکھنے کے قابل ہو جائیں گے، جس سے حقیقی ڈیٹا بیس سے جڑنا ممکن ہو جائے گا۔ پیکیج میں 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 کی درخواستوں پر کارروائی کرتا ہے جو ایڈریس "/customers" پر بھیجی جاتی ہے۔ طریقہ ایک لوٹاتا ہے 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 اسٹیٹس کوڈ واپس کرتے ہیں۔ اب ہم کسی صارف کو اس کی 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 idمتغیر کے ذریعے میتھڈ پیرامیٹر میں منتقل کیا جاتا ہے۔ جسم میں، ہم Customerاپنی سروس اور موصول کا استعمال کرتے ہوئے آبجیکٹ حاصل کرتے ہیں id۔ اور پھر، فہرست کے ساتھ مشابہت کے ساتھ، ہم یا تو "200 OK" کی حیثیت اور آبجیکٹ کو واپس کرتے ہیں Customer، یا صرف "404 Not Found" کی حیثیت واپس کرتے ہیں اگر سسٹم کے پاس اس کے ساتھ کوئی صارف نہیں ہے 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. آخر میں، ہم نے Spring Boot کا استعمال کرتے ہوئے اپنی چھوٹی RESTful ایپلی کیشن لکھ کر کچھ عملی تجربہ حاصل کیا۔ اور ہم نے پوسٹ مین کا استعمال کرتے ہوئے اسے جانچنے کا طریقہ بھی سیکھا۔

افف یہ بہت کچھ تھا، لیکن آپ کے لیے ہوم ورک کے طور پر کچھ کرنا باقی ہے۔

گھر کا کام

درج ذیل کو آزمائیں:

1. اوپر دی گئی تفصیل کے بعد، اپنا اسپرنگ بوٹ پروجیکٹ بنائیں اور وہی منطق نافذ کریں جیسا کہ سبق میں ہے۔ ہر چیز کو بالکل دہرائیں۔
2. ایپلیکیشن لانچ کریں۔
3. پوسٹ مین (یا درخواستیں بھیجنے کے لیے کوئی دوسرا ٹول، مثال کے طور پر، curl) ڈاؤن لوڈ اور ترتیب دیں۔
4. POST اور GET درخواستوں کی جانچ اسی طرح کریں جس طرح سبق میں بیان کیا گیا ہے۔
5. PUT اور DELETE درخواستوں کو خود ٹیسٹ کریں۔