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

هي آخري حصو آهي REST parsing جو. پوئين حصن ۾:

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

پروجيڪٽ ٺاهڻ

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

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

@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")- هتي اسان جو مطلب آهي ته هي طريقو پوسٽ جي درخواستن کي /ڪلائنٽ ايڊريس تي عمل ڪري ٿو، طريقو واپس اچي ٿو ResponseEntity<?>. ResponseEntity- جوابن جي موٽڻ لاءِ هڪ خاص ڪلاس. ان کي استعمال ڪندي، اسان بعد ۾ واپس ڪري سگھون ٿا HTTP اسٽيٽس ڪوڊ ڪلائنٽ ڏانهن. طريقو هڪ پيٽرولر وٺندو آهي @RequestBody Client client، هن پيٽرولر جي قيمت درخواست جي جسم مان متبادل آهي. خلاصو هن بابت ڳالهائيندو آهي @RequestBody. طريقي جي جسم جي اندر، اسان اڳوڻي ٺاهيل خدمت تي ٺاھڻ جو طريقو سڏين ٿا ۽ ان کي ڪلائنٽ سنڀاليندڙ کي منظور ڪيو ويو آھي پيراگراف ۾. ان کان پوء اسان اسٽيٽس 201 کي واپس ڪريون ٿا جيڪو هڪ نئين شئي ٺاهي ٺاهي ResponseEntity۽ ان کي گهربل اينم ويليو پاس ڪري ٿو 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 جي حيثيت کان علاوه، اسان به جوابي جسم واپس ڪنداسين، جيڪو ڪلائنٽ جي هڪ فهرست هوندو. اسپرنگ REST ڪنٽرولرز ۾، سڀ POJO شيون، گڏوگڏ POJO شيون جا مجموعا جيڪي جوابي جسم طور واپس ڪيا ويا آهن، خودڪار طور تي JSON ڏانهن سيريل ڪيو ويندو جيستائين واضح طور تي ٻي صورت ۾ بيان نه ڪيو وڃي. اسان ان سان ڪافي خوش آهيون. طريقي جي اندر، اسان جي خدمت کي استعمال ڪندي، اسان سڀني گراهڪن جي هڪ فهرست حاصل ڪندا آهيون. اڳيون، جيڪڏهن فهرست خالي يا خالي نه آهي، اسان ResponseEntityڪلاس استعمال ڪندي ڪلائنٽ جي فهرست ۽ HTTP اسٽيٽس 200 OK واپس ڪريون ٿا. ٻي صورت ۾، اسان صرف واپس HTTP جي حيثيت 404 نه مليو. اڳيون، اسان هن جي سڃاڻپ ذريعي ڪلائنٽ حاصل ڪرڻ جي صلاحيت تي عمل ڪنداسين:

@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}". اسان ان کي ڳوڙها braces ۾ اشارو ڪيو. ۽ طريقي جي پيرا ميٽرن ۾ اسان ان کي قبول ڪندا آهيون 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)، ۽ طريقو deleteپروسيس ڪري ٿو DELETE درخواستون ( تشريح 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 درخواستون موڪلڻ لاءِ. توھان ان کي ڊائون لوڊ ڪري سگھوٿا ھتان . ڊائون لوڊ ۽ انسٽال ڪرڻ کان پوء، اسان اسان جي ايپليڪيشن کي جانچڻ شروع ڪندا آهيون. هن کي ڪرڻ لاء، پروگرام کوليو ۽ هڪ نئين درخواست ٺاهي: ڪلڪ ڪريو نئون بٽڻ مٿي کاٻي ڪنڊ ۾. اڳيون، چونڊيو درخواست: اڳيون، ان کي نالو ڏيو ۽ ان کي بچايو. اچو ته ھاڻي ڪوشش ڪريون سرور ڏانھن پوسٽ درخواست موڪلڻ ۽ پھريون ڪلائنٽ ٺاھيو: اسان ھن طريقي سان ڪيترائي ڪلائنٽ ٺاھيون ٿا. پوءِ اسان GET ۾ درخواست جي قسم کي تبديل ڪريون ۽ ان کي سرور ڏانھن موڪليو:

عام نتيجا

مبارڪون: اسان REST جي ڪافي موضوع کي ڍڪي ڇڏيو آهي. سڀ مواد تمام وڏو ٿي ويو، پر اسان کي اميد آهي ته اهو توهان لاء مفيد ٿيندو:

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

2. اسان REST جي تاريخ کان واقف ٿياسين.

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

   • فن تعمير کي ڪلائنٽ-سرور ماڊل تي آڻڻ؛
   • حالت جي کوٽ؛
   • ڪيشنگ؛
   • انٽرفيس جي هڪجهڙائي؛
   • پرت
   • مطالبو تي ڪوڊ (اختياري پابندي).

4. اسان انهن فائدن جي جانچ ڪئي جيڪا REST مهيا ڪري ٿي

5. اسان تفصيل سان جانچيو ته ڪيئن سرور ۽ ڪلائنٽ هڪ ٻئي سان رابطو ڪندا آهن HTTP پروٽوڪول استعمال ڪندي.

6. اچو ته درخواستن ۽ جوابن تي هڪ ويجهي نظر رکون. انهن جا حصا جدا ڪيا ويا.

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

ڦوهه. اهو وڏو ٿي ويو، پر ان جي باوجود گهر جي ڪم وانگر ڪجهه ڪرڻو آهي.

گهر جو ڪم

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

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

حصو 1: REST ڇا آھي حصو 2: ڪلائنٽ ۽ سرور جي وچ ۾ ڪميونيڪيشن