Ringkesan REST. Part 3: Nggawe layanan RESTful ing Spring Boot

Iki minangka bagean pungkasan saka ringkesan REST. Ing bagean sadurunge, kita nutupi:

• Apa iku REST?
• Komunikasi antarane klien lan server

Nggawe proyek

Ing bagean iki, kita bakal nggawe aplikasi RESTful cilik nggunakake Spring Boot. Aplikasi kita bakal ngetrapake operasi CRUD (Gawe, Waca, Nganyari, Busak) ing pelanggan saka conto ing bagean ringkesan sadurunge . Kanggo miwiti, kita bakal nggawe aplikasi Spring Boot anyar liwat menu: File -> New -> Project... Ing jendhela sing mbukak, pilih Spring Initializr lan nemtokake Project SDK: Klik tombol "Sabanjure". Ing jendhela sabanjure, nemtokake "Proyek Maven" minangka jinis proyek, nemtokake "Grup" lan "Artifak": Klik tombol "Sabanjure". Ing jendela sabanjure, kita kudu milih komponen Spring Framework sing dibutuhake kanggo proyek kasebut. Spring Web bakal cukup kanggo kita: Klik tombol "Sabanjure". Saiki sing isih ana yaiku nuduhake jeneng proyek lan lokasi ing sistem file: Klik tombol "Rampung". Proyèk iki digawe, lan saiki kita bisa ndeleng struktur sawijining: IDEA kui Maven penyebaran deskriptor (pom.xml) lan aplikasi kelas utama ( RestExampleApplication) kanggo kita. Mangkene rupane:

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>

Aplikasi RestExample:

@SpringBootApplication
public class RestExampleApplication {

   public static void main(String[] args) {
       SpringApplication.run(RestExampleApplication.class, args);
   }

}

Nggawe fungsi REST

Aplikasi kita minangka sistem manajemen pelanggan. Dadi, sepisanan sing kudu ditindakake yaiku nggawe entitas pelanggan. Iku bakal dadi kelas POJO (obyek Jawa lawas kosong). Nggawe modelpaket ing com.codegym.lessons.rest_examplepaket kasebut. Ing njero modelpaket, gawe 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;
   }
}

Layanan kasebut bakal ngetrapake operasi CRUD ing pelanggan. Langkah sabanjure yaiku nggawe layanan sing bakal ngetrapake operasi kasebut. Ing com.codegym.lessons.rest_examplepaket, nggawe servicepaket. Lan ing njero, nggawe CustomerServiceantarmuka. Punika kode antarmuka kanthi komentar:

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

Sabanjure, kita kudu ngleksanakake antarmuka iki. Saiki Map<Integer, Customer>bakal nyimpen pelanggan. Tombol peta bakal dadi ID pelanggan, lan nilai bakal dadi pelanggan dhewe. Iki ditindakake supaya ora kakehan conto iki kanthi spesifik nggarap database nyata. Nanging, ing mangsa ngarep kita bakal bisa nulis implementasine liyane saka antarmuka, kang bakal nggawe iku bisa kanggo nyambung menyang database nyata. Ing servicepaket, nggawe implementasine antarmuka 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;
   }
}

Anotasi @Servicengandhani musim semi yen kelas iki minangka layanan. Iki minangka jinis kelas khusus sing ngetrapake sawetara logika aplikasi bisnis. Salajengipun, thanks kanggo anotasi iki, Spring bakal nggunakake injeksi dependensi kanggo nyedhiyani kita karo conto kelas iki ing kabeh panggonan ngendi iku perlu. Saiki wektu kanggo nggawe controller. Iki minangka kelas khusus ing ngendi kita bakal ngetrapake logika kanggo ngolah panjaluk klien sing dikirim menyang titik pungkasan (URI). Kanggo nggawe kabeh iki luwih jelas, kita bakal nggawe kelas iki kanthi bertahap. Pisanan, gawe kelas dhewe lan tambahake dependensi ing CustomerService:

@RestController
public class CustomerController {

   private final CustomerService customerService;

   @Autowired
   public CustomerController(CustomerService customerService) {
       this.customerService = customerService;
   }
}

Ayo nerangake anotasi: @RestController ngandhani Spring yen kelas iki minangka pengontrol REST. Ing tembung liyane, kelas iki ngetrapake logika kanggo ngolah panjaluk klien. @Autowired ngandhani Spring yen ketergantungan kudu ditambahake ing kene. We pass CustomerServiceantarmuka kanggo konstruktor. Sadurungé, kita nandhani implementasi layanan iki kanthi @Serviceanotasi, lan saiki Spring bakal bisa ngirim conto implementasine iki menyang konstruktor pengontrol. Sabanjure, kita bakal ngetrapake saben metode pengontrol kanggo nangani operasi CRUD. Ayo dadi miwiti karo operasi nggawe. Kanggo nindakake iki, kita nulis createcara:

@PostMapping(value = "/customers")
public ResponseEntity<?> create(@RequestBody Customer customer) {
   customerService.create(customer);
   return new ResponseEntity<>(HttpStatus.CREATED);
}

Ayo analisa cara iki: @PostMapping(value = "/customers")tegese cara iki ngolah panjaluk POST sing dikirim menyang alamat "/ pelanggan". Metode ngasilake a ResponseEntity<?>. A ResponseEntitykelas khusus kanggo bali respon. Mengko, kita bakal nggunakake kanggo ngasilake kode status HTTP menyang klien. Metode kasebut nduweni @RequestBody Customer customerparameter. Nilai saka parameter iki asalé saka awak request. Anotasi @RequestBodynuduhake iki. Ing awak metode kasebut, kita nelpon create()metode kasebut ing layanan sing wis digawe sadurunge lan ngliwati pengontrol pelanggan sing ditampa ing paramèter. Banjur kita bali status "201 Digawe" kanthi nggawe ResponseEntityobyek anyar lan ngliwati HttpStatuslapangan enum sing cocog. Sabanjure, kita bakal ngleksanakakereadoperasi: Kaping pisanan, kita bakal nindakake operasi kanggo entuk dhaptar kabeh pelanggan sing kasedhiya:

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

Ayo nyilem: @GetMapping(value = "/customers")- kabeh ing kene padha karo @PostMappinganotasi, nanging saiki lagi ngolah panjaluk GET. Wektu iki kita bali a ResponseEntity<List<Customer>>, lan saliyane status HTTP, kita uga bakal bali awak respon, kang bakal dhaftar pelanggan. Ing pengontrol REST Spring, kabeh obyek POJO lan koleksi obyek POJO, sing bali minangka badan respon lan kanthi otomatis serialized menyang JSON, kajaba kasebut. Iki cocog karo kita. Ing cara kasebut, kita nggunakake layanan kanggo entuk dhaptar kabeh pelanggan. Sabanjure, yen dhaptar ora null lan ora kosong, banjur kita nggunakakeResponseEntitykelas kanggo bali dhaftar pelanggan lan "200 OK" kode status HTTP. Yen ora, kita mung bali kode status HTTP "404 Not Found". Saiki kita bakal ngetrapake kemampuan kanggo njaluk pelanggan nggunakake 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);
}

Siji bab anyar ing kene yaiku variabel path. Variabel ditetepake ing URI: value = "/customers/{id}". Kita nuduhake ing kurung kriting. Lan kita nampa minangka intparameter metode nggunakake @PathVariable(name = "id")anotasi. Cara iki bakal nampa panjalukan sing dikirim menyang URIs ing wangun /customers/{id}, ngendi {id}nggantosi sembarang nilai numerik. Nilai iki banjur diterusake liwat int idvariabel menyang parameter metode. Ing awak, kita entuk Customerobyek nggunakake layanan kita lan ditampa id. Banjur, kanthi analogi karo dhaptar kasebut, kita bali status "200 OK" lan obyek Customerkasebut, utawa mung status "404 Ora Ditemokake" yen sistem kasebut ora duwe pelanggan id. Kita isih kudu ngetrapake rong operasi: nganyari lan mbusak. Iki kode kanggo metode kasebut:

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

Ora ana sing anyar ing metode kasebut, mula kita bakal nglewati katrangan sing rinci. Siji-sijine sing kudu dicritakake yaiku update()metode kasebut nangani panjaluk PUT ( @PutMappinganotasi), lan delete()metode kasebut nangani panjaluk DELETE ( DeleteMappinganotasi). Punika kode lengkap kanggo controller:

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

Akibaté, struktur proyek kita kaya ing ngisor iki:

Bukak lan testing

Kanggo miwiti aplikasi kita, mung mbukak main()metode ing RestExampleApplicationkelas. Nanging kanggo nyoba layanan web RESTful, kita kudu ndownload piranti lunak tambahan. Kasunyatane manawa panjaluk GET cukup gampang dikirim saka browser biasa, nanging browser biasa ora bisa ngirim panjaluk POST, PUT lan DELETE. Aja kuwatir: sampeyan bisa nggunakake program sing diarani Postman kanggo ngirim panjalukan HTTP. Sampeyan bisa ngundhuh kene . Sawise ndownload lan nginstal Postman, kita miwiti nyoba aplikasi kita. Kanggo nindakake iki, bukak program lan gawe panjalukan anyar: Klik tombol "Anyar" ing pojok kiwa ndhuwur. Sabanjure, pilih "Panjaluk": Sabanjure, wenehi jeneng lan simpen. Saiki ayo nyoba ngirim panjalukan POST menyang server lan nggawe pelanggan pertama: Kita nggawe sawetara pelanggan kanthi cara iki. Banjur kita ngganti jinis panjalukan kanggo GET lan ngirim panjalukan menyang server:

Ringkesan

Sugeng rawuh! Kita wis cukup nutupi REST. Ana volume gedhe saka materi, nanging muga-muga bisa migunani kanggo sampeyan:

1. Kita sinau apa REST.

2. Kita sinau babagan carane REST dumadi.

3. Kita ngomong babagan watesan lan prinsip ing gaya arsitektur iki:

   • arsitektur klien-server
   • stateless
   • caching
   • antarmuka seragam
   • lapisan
   • kode on demand (opsional)

4. Kita njelajah keuntungan sing diwenehake dening REST

5. Kita nliti kanthi rinci babagan carane server lan klien sesambungan karo siji liyane liwat protokol HTTP.

6. We njupuk dipikir nyedhaki panjalukan lan respon. We dissected bagean constituent sing.

7. Pungkasan, kita entuk pengalaman praktis kanthi nulis aplikasi RESTful cilik dhewe nggunakake Spring Boot. Lan kita malah sinau carane nyoba nggunakake Postman.

Phew. Iku akeh banget, nanging isih ana sing kudu ditindakake minangka PR.

Peer

Coba ing ngisor iki:

1. Sawise katrangan ing ndhuwur, gawe proyek Spring Boot dhewe lan tindakake logika sing padha karo pelajaran kasebut. Baleni kabeh persis.
2. Bukak aplikasi kasebut.
3. Ngundhuh lan ngatur Postman (utawa alat liyane kanggo ngirim panjalukan, contone, curl).
4. Tes panjalukan POST lan GET kanthi cara sing padha diterangake ing pawulangan.
5. Tes PUT lan DELETE njaluk dhewe.