REST యొక్క అవలోకనం. పార్ట్ 3: స్ప్రింగ్ బూట్‌లో RESTful సర్వీస్‌ను రూపొందించడం

ఇది REST యొక్క మా అవలోకనం యొక్క చివరి భాగం. మునుపటి భాగాలలో, మేము కవర్ చేసాము:

• REST అంటే ఏమిటి?
• క్లయింట్ మరియు సర్వర్ మధ్య కమ్యూనికేషన్

ప్రాజెక్ట్ సృష్టిస్తోంది

ఈ విభాగంలో, మేము స్ప్రింగ్ బూట్ ఉపయోగించి చిన్న RESTful అప్లికేషన్‌ను సృష్టిస్తాము. మా అప్లికేషన్ ఓవర్‌వ్యూ యొక్క మునుపటి భాగంలోని ఉదాహరణ నుండి కస్టమర్‌లపై CRUD (సృష్టించండి, చదవండి, నవీకరించండి, తొలగించండి) కార్యకలాపాలను అమలు చేస్తుంది . ప్రారంభించడానికి, మేము మెను ద్వారా కొత్త స్ప్రింగ్ బూట్ అప్లికేషన్‌ను సృష్టిస్తాము: ఫైల్ -> కొత్తది -> ప్రాజెక్ట్... తెరుచుకునే విండోలో, స్ప్రింగ్ ఇనిషియలైజర్‌ని ఎంచుకుని, ప్రాజెక్ట్ SDKని పేర్కొనండి: "తదుపరి" బటన్‌ను క్లిక్ చేయండి. తదుపరి విండోలో, ప్రాజెక్ట్ రకంగా "మావెన్ ప్రాజెక్ట్" ను పేర్కొనండి, "గ్రూప్" మరియు "ఆర్టిఫ్యాక్ట్" ను పేర్కొనండి: "తదుపరి" బటన్ క్లిక్ చేయండి. తదుపరి విండోలో, మేము ప్రాజెక్ట్ కోసం అవసరమైన స్ప్రింగ్ ఫ్రేమ్‌వర్క్ భాగాలను ఎంచుకోవాలి. స్ప్రింగ్ వెబ్ మాకు సరిపోతుంది: "తదుపరి" బటన్ క్లిక్ చేయండి. ఇప్పుడు ఫైల్ సిస్టమ్‌లో ప్రాజెక్ట్ పేరు మరియు దాని స్థానాన్ని సూచించడం మాత్రమే మిగిలి ఉంది: "ముగించు" బటన్‌ను క్లిక్ చేయండి. ప్రాజెక్ట్ సృష్టించబడింది మరియు ఇప్పుడు మనం దాని నిర్మాణాన్ని చూడవచ్చు: IDEA మావెన్ డిప్లాయ్‌మెంట్ డిస్క్రిప్టర్ (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 అప్లికేషన్:

@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>మా కస్టమర్లను నిల్వ చేస్తుంది. మ్యాప్ యొక్క కీలు కస్టమర్ 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ఈ తరగతి ఒక సేవ అని వసంత చెబుతుంది. ఇది కొన్ని వ్యాపార అనువర్తన తర్కాన్ని అమలు చేసే ప్రత్యేక తరగతి రకం. తదనంతరం, ఈ ఉల్లేఖనానికి ధన్యవాదాలు, అవసరమైన అన్ని ప్రదేశాలలో ఈ తరగతికి సంబంధించిన ఉదాహరణను అందించడానికి స్ప్రింగ్ డిపెండెన్సీ ఇంజెక్షన్‌ని ఉపయోగిస్తుంది. ఇప్పుడు నియంత్రికను సృష్టించే సమయం వచ్చింది. ఇది ఒక ప్రత్యేక తరగతి, ఇక్కడ మేము ఎండ్‌పాయింట్‌లకు (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 అభ్యర్థనలను ఈ పద్ధతి ప్రాసెస్ చేస్తుంది. పద్ధతి a 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 స్టేటస్‌తో పాటుగా, కస్టమర్‌ల జాబితా అయిన ప్రతిస్పందన బాడీని కూడా అందిస్తాము. స్ప్రింగ్ యొక్క 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"). /customers/{id}ఈ పద్ధతి ఏదైనా సంఖ్యా విలువను సూచించే ఫారమ్‌లో URIలకు పంపిన అభ్యర్థనలను అంగీకరిస్తుంది {id}. int idఈ విలువ తదనంతరం వేరియబుల్ ద్వారా పద్ధతి పరామితికి పంపబడుతుంది . శరీరంలో, 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 అభ్యర్థనలు సాధారణ బ్రౌజర్ నుండి పంపడం చాలా సులభం, కానీ సాధారణ బ్రౌజర్ 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. పుట్ మరియు డిలీట్ రిక్వెస్ట్‌లను మీరే పరీక్షించుకోండి.