REST இன் கண்ணோட்டம். பகுதி 3: ஸ்பிரிங் பூட்டில் ஒரு RESTful சேவையை உருவாக்குதல்

இது REST பற்றிய எங்கள் மேலோட்டத்தின் இறுதிப் பகுதி. முந்தைய பகுதிகளில், நாங்கள் விவரித்தோம்:

• REST என்றால் என்ன?
• கிளையன்ட் மற்றும் சர்வர் இடையேயான தொடர்பு

ஒரு திட்டத்தை உருவாக்குதல்

இந்த பிரிவில், ஸ்பிரிங் பூட்டைப் பயன்படுத்தி ஒரு சிறிய RESTful பயன்பாட்டை உருவாக்குவோம். மேலோட்டத்தின் முந்தைய பகுதியில் உள்ள எடுத்துக்காட்டில் இருந்து வாடிக்கையாளர்களுக்கு CRUD (உருவாக்கு, படிக்க, புதுப்பித்தல், நீக்குதல்) செயல்பாடுகளை எங்கள் பயன்பாடு செயல்படுத்தும் . தொடங்குவதற்கு, மெனு மூலம் புதிய ஸ்பிரிங் பூட் பயன்பாட்டை உருவாக்குவோம்: கோப்பு -> புதியது -> திட்டம்... திறக்கும் சாளரத்தில், Spring Initializr ஐத் தேர்ந்தெடுத்து, Project SDK ஐக் குறிப்பிடவும்: "அடுத்து" பொத்தானைக் கிளிக் செய்யவும். அடுத்த சாளரத்தில், திட்ட வகையாக "மேவன் ப்ராஜெக்ட்" என்பதைக் குறிப்பிடவும், "குழு" மற்றும் "கலைப்பொருள்" ஆகியவற்றைக் குறிப்பிடவும்: "அடுத்து" பொத்தானைக் கிளிக் செய்யவும். அடுத்த சாளரத்தில், திட்டத்திற்கு தேவையான ஸ்பிரிங் ஃபிரேம்வொர்க் கூறுகளை நாம் தேர்ந்தெடுக்க வேண்டும். ஸ்பிரிங் வெப் எங்களுக்கு போதுமானதாக இருக்கும்: "அடுத்து" பொத்தானை கிளிக் செய்யவும். இப்போது எஞ்சியிருப்பது திட்டத்தின் பெயர் மற்றும் கோப்பு முறைமையில் அதன் இருப்பிடத்தைக் குறிப்பிடுவதுதான்: "பினிஷ்" பொத்தானைக் கிளிக் செய்யவும். திட்டம் உருவாக்கப்பட்டது, இப்போது அதன் கட்டமைப்பைக் காணலாம்: IDEA ஆனது Maven 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.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>

RestExample Application:

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

அடுத்து, இந்த இடைமுகத்தை செயல்படுத்த வேண்டும். இப்போது a 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இந்த வகுப்பு ஒரு சேவை என்று சிறுகுறிப்பு வசந்த காலத்தில் கூறுகிறது . இது சில வணிக பயன்பாட்டு தர்க்கத்தை செயல்படுத்தும் ஒரு சிறப்பு வகை வகுப்பாகும். பின்னர், இந்த சிறுகுறிப்புக்கு நன்றி, ஸ்பிரிங் சார்பு ஊசியைப் பயன்படுத்தி, தேவைப்படும் எல்லா இடங்களிலும் இந்த வகுப்பின் உதாரணத்தை எங்களுக்கு வழங்கும். இப்போது ஒரு கட்டுப்படுத்தியை உருவாக்க வேண்டிய நேரம் இது. இது ஒரு சிறப்பு வகுப்பாகும், அங்கு இறுதிப்புள்ளிகளுக்கு (URIகள்) அனுப்பப்படும் கிளையன்ட் கோரிக்கைகளை செயலாக்குவதற்கான தர்க்கத்தை நாங்கள் செயல்படுத்துவோம். இதையெல்லாம் தெளிவுபடுத்த, இந்த வகுப்பை படிப்படியாக உருவாக்குவோம். முதலில், வகுப்பை உருவாக்கி, ஒரு சார்புநிலையைச் சேர்க்கவும் 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 கோரிக்கைகளை செயலாக்குகிறது. முறை ஒரு திரும்பும் ResponseEntity<?>. A ResponseEntityஎன்பது பதில்களை வழங்குவதற்கான ஒரு சிறப்பு வகுப்பு. பின்னர், கிளையண்டிற்கு HTTP நிலைக் குறியீட்டை வழங்க அதைப் பயன்படுத்துவோம். முறைக்கு ஒரு @RequestBody Customer customerஅளவுரு உள்ளது. இந்த அளவுருவின் மதிப்பு கோரிக்கை அமைப்பிலிருந்து வருகிறது. சிறுகுறிப்பு @RequestBodyஇதைக் குறிக்கிறது. முறையின் உடலுக்குள், create()முன்னர் உருவாக்கப்பட்ட சேவையின் முறையை நாங்கள் அழைக்கிறோம் மற்றும் அளவுருக்களில் பெற்ற வாடிக்கையாளர் கட்டுப்படுத்திக்கு அனுப்புகிறோம். ஒரு புதிய பொருளை உருவாக்கி அதனுடன் ResponseEntityதொடர்புடைய enum புலத்தை அனுப்புவதன் மூலம் "201 உருவாக்கப்பட்டது" நிலையைத் தருகிறோம் . 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 நிலைக்கு கூடுதலாக, வாடிக்கையாளர்களின் பட்டியலாக இருக்கும் மறுமொழி அமைப்பையும் வழங்குவோம். ஸ்பிரிங்ஸ் ரெஸ்ட் கன்ட்ரோலர்களில், அனைத்தும் 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. Customerபின்னர், பட்டியலுடன் ஒப்பிடுவதன் மூலம், "200 சரி" நிலை மற்றும் பொருளின் நிலை அல்லது கணினியில் வாடிக்கையாளர் இல்லை என்றால் "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 கோரிக்கைகளை நீங்களே செய்யுங்கள்.