REST کا جائزہ۔ حصہ 3: بہار کے بوٹ میں ایک آرام دہ سروس بنانا

یہ REST پارسنگ کا آخری حصہ ہے۔ پچھلے حصوں میں:

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

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

اس سیکشن میں، ہم Spring Boot کا استعمال کرتے ہوئے ایک چھوٹی سی RESTful ایپلی کیشن بنائیں گے۔ ہماری ایپلیکیشن تجزیہ کے آخری حصے کی مثال سے کلائنٹس پر CRUD (تخلیق، پڑھیں، اپ ڈیٹ، ڈیلیٹ) آپریشنز کو نافذ کرے گی ۔ سب سے پہلے، مینو فائل -> نیو -> پروجیکٹ کے ذریعے ایک نئی اسپرنگ بوٹ ایپلی کیشن بنائیں... کھلنے والی ونڈو میں، Spring Initializr کو منتخب کریں اور پروجیکٹ SDK کی وضاحت کریں: اگلا بٹن پر کلک کریں۔ اگلی ونڈو میں، Maven پروجیکٹ کی قسم کی وضاحت کریں، گروپ اور آرٹفیکٹ کی وضاحت کریں: اگلا بٹن پر کلک کریں۔ اگلی ونڈو میں، ہمیں اس پراجیکٹ کے لیے درکار اسپرنگ فریم ورک کے اجزاء کو منتخب کرنے کی ضرورت ہے۔ اسپرنگ ویب ہمارے لیے کافی ہوگا: اگلا پر کلک کریں۔ اس کے بعد، جو باقی ہے وہ فائل سسٹم میں پروجیکٹ کا نام اور اس کے مقام کی وضاحت کرنا ہے: Finish بٹن پر کلک کریں۔ پروجیکٹ بن چکا ہے، اب ہم اس کا ڈھانچہ دیکھ سکتے ہیں: IDEA نے ہمارے لیے Maven build system deployment descriptor - 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.javarush.lectures</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.javarush.lectures.rest_example۔ modelآئیے پیکیج کے اندر ایک کلاس بنائیں Client:

public class Client {

   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.javarush.lectures.rest_exampleہم ایک پیکیج بنائیں گے service، جس کے اندر ہم ایک انٹرفیس بنائیں گے ClientService۔ تبصروں کے ساتھ انٹرفیس کوڈ یہ ہے:

public interface ClientService {

   /**
    * Создает нового клиента
    * @param client - клиент для создания
    */
   void create(Client client);

   /**
    * returns список всех имеющихся клиентов
    * @return список клиентов
    */
   List<client> readAll();

   /**
    * returns клиента по его ID
    * @param id - ID клиента
    * @return - an object клиента с заданным ID
    */
   Client read(int id);

   /**
    * Обновляет клиента с заданным ID,
    * в соответствии с переданным клиентом
    * @param client - клиент в соответсвии с которым нужно обновить данные
    * @param id - id клиента которого нужно обновить
    * @return - true если данные были обновлены, иначе false
    */
   boolean update(Client client, int id);

   /**
    * Удаляет клиента с заданным ID
    * @param id - id клиента, которого нужно удалить
    * @return - true если клиент был удален, иначе false
    */
   boolean delete(int id);
}

اگلا ہمیں اس انٹرفیس کا نفاذ بنانے کی ضرورت ہے۔ اب یہ کلائنٹ کے ذخیرے کے طور پر کام کرے گا Map<Integer, Client>۔ کارڈ کی کلید کلائنٹ آئی ڈی ہوگی، اور قدر خود کلائنٹ کی ہوگی۔ یہ ڈیٹا بیس کے ساتھ کام کرنے کی تفصیلات کے ساتھ مثال کو زیادہ بوجھ نہ دینے کے لیے کیا گیا تھا۔ تاہم، مستقبل میں ہم انٹرفیس کا ایک اور نفاذ لکھ سکیں گے جس میں حقیقی ڈیٹا بیس کو جوڑنا ممکن ہوگا۔ پیکیج میں serviceہم انٹرفیس کا نفاذ بنائیں گے ClientService:

@Service
public class ClientServiceImpl implements ClientService {

   // Хранorще клиентов
   private static final Map<Integer, Client> CLIENT_REPOSITORY_MAP = new HashMap<>();

   // Переменная для генерации ID клиента
   private static final AtomicInteger CLIENT_ID_HOLDER = new AtomicInteger();

   @Override
   public void create(Client client) {
       final int clientId = CLIENT_ID_HOLDER.incrementAndGet();
       client.setId(clientId);
       CLIENT_REPOSITORY_MAP.put(clientId, client);
   }

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

   @Override
   public Client read(int id) {
       return CLIENT_REPOSITORY_MAP.get(id);
   }

   @Override
   public boolean update(Client client, int id) {
       if (CLIENT_REPOSITORY_MAP.containsKey(id)) {
           client.setId(id);
           CLIENT_REPOSITORY_MAP.put(id, client);
           return true;
       }

       return false;
   }

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

تشریح @Serviceبہار کو بتاتی ہے کہ یہ کلاس ایک خدمت ہے۔ یہ ایک خاص قسم کی کلاس ہے جس میں ایپلی کیشن کی کچھ کاروباری منطق کو لاگو کیا جاتا ہے۔ اس کے بعد، اس تشریح کی بدولت، بہار ہمیں ان جگہوں پر اس کلاس کی مثال فراہم کرے گا جہاں انحصار انجیکشن کے استعمال کی ضرورت ہے۔ اب کنٹرولر بنانے کا وقت آگیا ہے۔ ایک خاص کلاس جس میں ہم اختتامی پوائنٹس (URIs) کے لیے کلائنٹ کی درخواستوں پر کارروائی کے لیے منطق کو نافذ کرتے ہیں۔ اسے واضح کرنے کے لیے، ہم اس کلاس کو حصوں میں بنائیں گے۔ سب سے پہلے، خود ہی کلاس بنائیں اور اس پر انحصار متعارف کروائیں ClientService:

@RestController
public class ClientController {

   private final ClientService clientService;

   @Autowired
   public ClientController(ClientService clientService) {
       this.clientService = clientService;
   }
}

آئیے تشریحات کو واضح کریں: @RestController - بہار کو بتاتا ہے کہ یہ کلاس ایک REST کنٹرولر ہے۔ وہ. یہ کلاس کلائنٹ کی درخواستوں پر کارروائی کے لیے منطق کو لاگو کرے گی @Autowired - اسپرنگ کو بتاتا ہے کہ اس جگہ پر انحصار لگانے کی ضرورت ہے۔ ہم انٹرفیس کو کنسٹرکٹر کو دیتے ہیں ClientService۔ ہم نے اس سروس کے نفاذ کو @Serviceپہلے ایک تشریح کے ساتھ نشان زد کیا تھا، اور اب اسپرنگ اس عمل درآمد کی مثال کو کنٹرولر کنسٹرکٹر تک پہنچا سکے گا۔ اگلا، ہم CRUD آپریشنز پر کارروائی کرنے کے لیے ہر ایک کنٹرولر طریقہ کو مرحلہ وار نافذ کریں گے۔ آئیے Create آپریشن کے ساتھ شروع کرتے ہیں۔ ایسا کرنے کے لیے، آئیے ایک طریقہ لکھتے ہیں create:

@PostMapping(value = "/clients")
public ResponseEntity<?> create(@RequestBody Client client) {
   clientService.create(client);
   return new ResponseEntity<>(HttpStatus.CREATED);
}

آئیے اس طریقہ کو دیکھتے ہیں: @PostMapping(value = "/clients")- یہاں ہمارا مطلب ہے کہ یہ طریقہ POST درخواستوں کو /کلائنٹس ایڈریس پر کارروائی کرتا ہے۔ طریقہ واپس آتا ہے ResponseEntity<?>۔ ResponseEntity- جوابات واپس کرنے کے لیے ایک خصوصی کلاس۔ اس کا استعمال کرتے ہوئے، ہم بعد میں کلائنٹ کو HTTP اسٹیٹس کوڈ واپس کر سکتے ہیں۔ طریقہ ایک پیرامیٹر لیتا ہے @RequestBody Client client، اس پیرامیٹر کی قدر کو درخواست کے جسم سے بدل دیا جاتا ہے۔ خلاصہ اس کے بارے میں بات کرتا ہے @RequestBody۔ طریقہ کار کے باڈی کے اندر، ہم پہلے سے بنائی گئی سروس پر تخلیق کا طریقہ کہتے ہیں اور اسے پیرامیٹرز میں قبول کردہ کلائنٹ کنٹرولر سے پاس کرتے ہیں۔ پھر ہم اسٹیٹس 201 کو واپس کرتے ہیں جو ایک نیا آبجیکٹ بنا کر ResponseEntityاور مطلوبہ enum ویلیو کو پاس کر کے بنایا گیا ہے HttpStatus۔ اگلا، ہم آپریشن کو نافذ کرتے ہیں Read: سب سے پہلے، ہم تمام دستیاب کلائنٹس کی فہرست حاصل کرنے کے عمل کو نافذ کرتے ہیں:

@GetMapping(value = "/clients")
public ResponseEntity<List<Client>> read() {
   final List<Client> clients = clientService.readAll();

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

آئیے تجزیہ شروع کریں: @GetMapping(value = "/clients")- سب کچھ تشریح سے ملتا جلتا ہے @PostMapping، صرف اب ہم GET درخواستوں پر کارروائی کرتے ہیں۔ اس بار ہم واپس آتے ہیں ResponseEntity<List<Client>>، صرف اس بار، HTTP اسٹیٹس کے علاوہ، ہم ریسپانس باڈی بھی واپس کریں گے، جو کلائنٹس کی فہرست ہوگی۔ Spring REST کنٹرولرز میں، تمام POJO اشیاء کے ساتھ ساتھ POJO اشیاء کے مجموعے جو کہ جوابی باڈی کے طور پر واپس کیے جاتے ہیں، خود بخود JSON کو سیریلائز کر دیا جاتا ہے جب تک کہ واضح طور پر بیان نہ کیا جائے۔ ہم اس سے کافی خوش ہیں۔ طریقہ کار کے اندر، ہماری سروس کا استعمال کرتے ہوئے، ہمیں تمام کلائنٹس کی فہرست ملتی ہے۔ اگلا، اگر فہرست کالعدم یا خالی نہیں ہے، تو ہم ResponseEntityکلاس کا استعمال کرتے ہوئے کلائنٹس کی فہرست اور HTTP اسٹیٹس 200 OK واپس کرتے ہیں۔ بصورت دیگر، ہم صرف HTTP اسٹیٹس 404 Not Found واپس کر دیتے ہیں۔ اگلا، ہم ایک کلائنٹ کو اس کی آئی ڈی کے ذریعے حاصل کرنے کی صلاحیت کو نافذ کریں گے:

@GetMapping(value = "/clients/{id}")
public ResponseEntity<Client> read(@PathVariable(name = "id") int id) {
   final Client client = clientService.read(id);

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

کچھ نیا ہے کہ اب ہمارے پاس پاتھ متغیر ہے۔ ایک متغیر جس کی تعریف URI میں کی گئی ہے۔ value = "/clients/{id}". ہم نے اسے گھوبگھرالی منحنی خطوط وحدانی میں اشارہ کیا۔ اور طریقہ کے پیرامیٹرز میں ہم اسے intتشریح کا استعمال کرتے ہوئے ایک متغیر کے طور پر قبول کرتے ہیں @PathVariable(name = "id")۔ یہ طریقہ فارم کی uri کی درخواستوں کو قبول کرے گا /clients/{id}، جہاں {id}اس کے بجائے کوئی عددی قدر ہو سکتی ہے۔ اس قدر کو بعد میں ایک متغیر int idیعنی میتھڈ پیرامیٹر میں منتقل کیا جاتا ہے۔ جسم میں ہم اپنی خدمت کا استعمال کرتے ہوئے آبجیکٹ وصول کرتے ہیں Clientاور قبول کرتے ہیں id۔ اور پھر، فہرست کے ساتھ مشابہت کے ساتھ، ہم یا تو 200 OK اسٹیٹس اور آبجیکٹ خود واپس کرتے ہیں Client، یا صرف 404 Not Found status، اگر idسسٹم میں اس کے ساتھ کوئی کلائنٹ نہیں ہے۔ یہ دو آپریشنز کو نافذ کرنا باقی ہے - اپ ڈیٹ اور ڈیلیٹ۔ ان طریقوں کا کوڈ یہ ہے:

@PutMapping(value = "/clients/{id}")
public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Client client) {
   final boolean updated = clientService.update(client, id);

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

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

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

ان طریقوں میں بنیادی طور پر کوئی نئی چیز نہیں ہے، لہذا ہم تفصیلی وضاحت کو چھوڑ دیں گے۔ صرف ایک بات قابل ذکر ہے کہ طریقہ updatePUT درخواستوں (تشریح @PutMapping) پر کارروائی کرتا ہے، اور طریقہ deleteDELETE درخواستوں (تشریح DeleteMapping) پر کارروائی کرتا ہے۔ یہاں مکمل کنٹرولر کوڈ ہے:

@RestController
public class ClientController {

   private final ClientService clientService;

   @Autowired
   public ClientController(ClientService clientService) {
       this.clientService = clientService;
   }

   @PostMapping(value = "/clients")
   public ResponseEntity<?> create(@RequestBody Client client) {
       clientService.create(client);
       return new ResponseEntity<>(HttpStatus.CREATED);
   }

   @GetMapping(value = "/clients")
   public ResponseEntity<List<Client>> read() {
       final List<client> clients = clientService.readAll();

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

   @GetMapping(value = "/clients/{id}")
   public ResponseEntity<Client> read(@PathVariable(name = "id") int id) {
       final Client client = clientService.read(id);

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

   @PutMapping(value = "/clients/{id}")
   public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Client client) {
       final boolean updated = clientService.update(client, id);

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

   @DeleteMapping(value = "/clients/{id}")
   public ResponseEntity<?> delete(@PathVariable(name = "id") int id) {
       final boolean deleted = clientService.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. اوپر دی گئی تفصیل کے بعد، اپنا اسپرنگ بوٹ پروجیکٹ بنائیں اور اس میں وہی منطق نافذ کریں جیسا کہ لیکچر میں ہے۔ ہر چیز کو 1 میں 1 دہرائیں۔
2. اسے لانچ کریں۔ درخواست
3. پوسٹ مین (یا درخواستیں بھیجنے کے لیے کوئی دوسرا ٹول، یہاں تک کہ کرل) ڈاؤن لوڈ اور سیٹ اپ کریں۔
4. POST اور GET درخواستوں کی جانچ اسی طرح کریں جیسا کہ لیکچر میں بیان کیا گیا ہے۔
5. PUT اور DELETE درخواستوں کو خود ٹیسٹ کریں۔

حصہ 1: REST کیا ہے حصہ 2: کلائنٹ اور سرور کے درمیان مواصلت