REST'e genel bakış. Bölüm 3: Spring Boot'ta RESTful bir hizmet oluşturma

Bu, REST'e genel bakışımızın son kısmıdır. Önceki bölümlerde şunları ele aldık:

• DİNLENME nedir?
• İstemci ve sunucu arasındaki iletişim

proje oluşturma

Bu bölümde Spring Boot kullanarak küçük bir RESTful uygulaması oluşturacağız. Uygulamamız , genel bakışın önceki bölümündeki örnekten müşteriler üzerinde CRUD (Oluştur, Oku, Güncelle, Sil) işlemlerini uygulayacaktır . Başlamak için, menü aracılığıyla yeni bir Spring Boot uygulaması oluşturacağız: Dosya -> Yeni -> Proje... Açılan pencerede Spring Initializr'ı seçin ve Proje SDK'sını belirtin: "İleri" düğmesini tıklayın. Bir sonraki pencerede, proje türü olarak "Maven Projesi"ni, "Grup" ve "Yapı"yı belirtin: "İleri" düğmesini tıklayın. Bir sonraki pencerede proje için gerekli olan Spring Framework bileşenlerini seçmemiz gerekiyor. Spring Web bizim için yeterli olacaktır: "İleri" düğmesini tıklayın. Şimdi geriye kalan tek şey, projenin adını ve dosya sistemindeki konumunu belirtmek: "Bitir" düğmesini tıklayın. Proje oluşturuldu ve artık yapısını görebiliyoruz: IDEA bizim için bir Maven dağıtım tanımlayıcısı (pom.xml) ve uygulamanın ana sınıfını ( ) oluşturdu . RestExampleApplicationİşte nasıl göründükleri:

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>

RestÖrnekAplikasyonu:

@SpringBootApplication
public class RestExampleApplication {

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

}

REST işlevi oluşturma

Uygulamamız bir müşteri yönetim sistemidir. Yani, yapmamız gereken ilk şey bir müşteri varlığı oluşturmak. Bir POJO (düz eski Java nesnesi) sınıfı olacaktır. modelPaketin içinde bir paket oluşturun com.codegym.lessons.rest_example. Paketin içinde modelşunu oluşturun 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;
   }
}

Hizmet, müşteriler üzerinde CRUD işlemlerini uygulayacaktır. Bir sonraki adım, bu işlemleri gerçekleştirecek bir hizmet oluşturmaktır. Pakette com.codegym.lessons.rest_examplebir paket oluşturun service. Ve bunun içinde bir CustomerServicearayüz oluşturun. İşte yorumlarla arayüz kodu:

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

Ardından, bu arayüzü uygulamamız gerekiyor. Şimdi bir Map<Integer, Customer>müşterilerimizi saklayacak. Haritanın anahtarları müşteri kimlikleri olacak ve değerler müşterilerin kendileri olacaktır. Bu, bu örneği gerçek bir veritabanıyla çalışmanın özellikleriyle aşırı yüklememek için yapılır. Ancak gelecekte, gerçek bir veritabanına bağlanmayı mümkün kılacak başka bir arayüz uygulaması yazabileceğiz. Pakette service, arabirimin bir uygulamasını oluşturun 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;
   }
}

Ek @Serviceaçıklama, bahara bu sınıfın bir hizmet olduğunu söyler. Bu, bazı iş uygulaması mantığını uygulayan özel bir sınıf türüdür. Daha sonra, bu ek açıklama sayesinde, Spring, ihtiyaç duyulan her yerde bu sınıfın bir örneğini bize sağlamak için bağımlılık enjeksiyonunu kullanacaktır. Şimdi bir denetleyici oluşturma zamanı. Bu, uç noktalara (URI'ler) gönderilen istemci isteklerini işlemek için mantığı uygulayacağımız özel bir sınıftır. Tüm bunları daha net hale getirmek için, bu sınıfı aşamalı olarak oluşturacağız. İlk olarak, sınıfın kendisini oluşturun ve şuna bir bağımlılık ekleyin CustomerService:

@RestController
public class CustomerController {

   private final CustomerService customerService;

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

Ek açıklamaları açıklayalım: @RestController, Spring'e bu sınıfın bir REST denetleyicisi olduğunu söyler. Başka bir deyişle, bu sınıf, istemci isteklerini işlemek için mantığı uygular. @Autowired, Spring'e buraya bir bağımlılığın eklenmesi gerektiğini söyler. CustomerServiceArayüzü yapıcıya iletiyoruz . Daha önce, bu hizmetin uygulanmasını ek açıklama ile işaretledik @Serviceve şimdi Spring, bu uygulamanın bir örneğini denetleyicinin yapıcısına iletebilecek. Ardından, CRUD işlemlerini gerçekleştirmek için her denetleyici yöntemini uygulayacağız. Oluşturma işlemiyle başlayalım. Bunu yapmak için bir yöntem yazıyoruz create:

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

Bu yöntemi inceleyelim: @PostMapping(value = "/customers")Bu yöntemin "/müşteriler" adresine gönderilen POST isteklerini işlediği anlamına gelir. Yöntem bir döndürür ResponseEntity<?>. A, ResponseEntityyanıtları döndürmek için özel bir sınıftır. Daha sonra istemciye bir HTTP durum kodu döndürmek için kullanacağız. Yöntemin bir @RequestBody Customer customerparametresi vardır. Bu parametrenin değeri istek gövdesinden gelir. Açıklama @RequestBodybunu gösteriyor. Metodun gövdesi içerisinde create()daha önce oluşturulan servis üzerindeki metodu çağırıp parametrelerde alınan müşteri denetleyicisine iletiyoruz. ResponseEntityArdından yeni bir nesne oluşturarak ve HttpStatusona karşılık gelen enum alanını geçirerek "201 Oluşturuldu" durumunu döndürürüz . Sonra, uygulayacağızreadişlem: İlk olarak, mevcut tüm müşterilerin bir listesini almak için işlemi uygulayacağız:

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

Başlayalım: @GetMapping(value = "/customers")— buradaki her şey ek açıklamaya benzer @PostMapping, ancak şimdi GET isteklerini işliyoruz. Bu sefer bir ResponseEntity<List<Customer>>, HTTP durumuna ek olarak, müşterilerin listesi olacak bir yanıt gövdesi de döndüreceğiz. Spring'in REST denetleyicilerinde, her şey, aksi belirtilmedikçe, yanıt gövdeleri olarak döndürülen ve otomatik olarak JSON'a serileştirilen POJO nesneleri ve POJO nesneleri koleksiyonlarıdır. Bu bize çok yakışıyor. Yöntemin içinde, tüm müşterilerin bir listesini almak için hizmetimizi kullanırız. Ardından, liste boş değilse ve boş değilse, o zamanResponseEntitymüşteri listesini ve "200 OK" HTTP durum kodunu döndürmek için sınıf. Aksi takdirde, "404 Bulunamadı" HTTP durum kodunu döndürürüz. Şimdi, kimliğini kullanarak bir müşteri elde etme yeteneğini uygulayacağız:

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

Buradaki yeni bir şey yol değişkenidir. Değişken URI'de tanımlanır: value = "/customers/{id}". Kıvrımlı parantez içinde belirtiyoruz. intVe ek açıklamayı kullanarak bir yöntem parametresi olarak alıyoruz @PathVariable(name = "id"). /customers/{id}Bu yöntem, herhangi bir sayısal değeri temsil eden formdaki URI'lere gönderilen istekleri kabul edecektir {id}. int idBu değer daha sonra değişken aracılığıyla yöntem parametresine iletilir . Vücutta, Customerhizmetimizi kullanarak nesneyi alırız ve alınan id. Ve sonra, listeye benzeterek, ya "200 Tamam" durumunu ve nesnenin Customerkendisini ya da sistemde buna sahip bir müşteri yoksa basitçe "404 Bulunamadı" durumunu döndürürüz id. Hala iki işlem uygulamamız gerekiyor: güncelleme ve silme. İşte bu yöntemlerin kodu:

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

Bu yöntemlerde temelde yeni olan hiçbir şey yoktur, bu nedenle ayrıntılı açıklamayı atlayacağız. Bahsetmeye değer tek şey, yöntemin update()PUT isteklerini ( @PutMappingek açıklama) ve delete()yöntemin DELETE isteklerini ( DeleteMappingek açıklama) işlemesidir. İşte denetleyici için tam kod:

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

Sonuç olarak, projemizin yapısı aşağıdaki gibidir:

Başlatma ve test etme

Uygulamamızı başlatmak için, sınıfın main()içindeki yöntemi çalıştırmanız yeterlidir RestExampleApplication. Ancak RESTful web hizmetlerini test etmek için ek yazılım indirmemiz gerekiyor. Gerçek şu ki, sıradan bir tarayıcıdan GET isteklerini göndermek oldukça basittir, ancak sıradan bir tarayıcı POST, PUT ve DELETE isteklerini gönderemez. Endişelenmeyin: Herhangi bir HTTP isteği göndermek için Postman adlı bir program kullanabilirsiniz. Buradan indirebilirsiniz . Postman'ı indirip kurduktan sonra uygulamamızı test etmeye başlıyoruz. Bunu yapmak için programı açın ve yeni bir istek oluşturun: Sol üst köşedeki "Yeni" düğmesini tıklayın. Ardından, "İstek" seçeneğini seçin: Ardından, ona bir ad verin ve kaydedin. Şimdi sunucuya bir POST isteği gönderip ilk müşteriyi oluşturmaya çalışalım: Bu şekilde birkaç müşteri oluşturuyoruz. Ardından istek türünü GET olarak değiştirip isteği sunucuya gönderiyoruz:

Özet

Tebrikler! REST'i yeterince inceledik. Çok miktarda malzeme vardı, ama umarım sizin için yararlı olmuştur:

1. REST'in ne olduğunu öğrendik.

2. REST'in nasıl ortaya çıktığını öğrendik.

3. Bu mimari tarzın sınırlamaları ve ilkelerinden bahsettik:

   • istemci-sunucu mimarisi
   • vatansız
   • Önbelleğe almak
   • tek tip arayüz
   • katmanlar
   • isteğe bağlı kod (isteğe bağlı)

4. REST'in sağladığı avantajları araştırdık

5. Sunucu ve istemcinin HTTP protokolü aracılığıyla birbirleriyle nasıl etkileşime girdiğini ayrıntılı olarak inceledik.

6. İsteklere ve yanıtlara daha yakından baktık. Onları oluşturan parçaları inceledik.

7. Son olarak, Spring Boot kullanarak kendi küçük RESTful uygulamamızı yazarak biraz pratik deneyim kazandık. Hatta Postman kullanarak nasıl test edeceğimizi bile öğrendik.

Vay. Bu çok fazlaydı, ama yine de ev ödevi olarak yapman gereken bir şey var.

Ev ödevi

Takip etmeyi dene:

1. Yukarıdaki açıklamayı takiben, kendi Spring Boot projenizi oluşturun ve dersteki mantığın aynısını uygulayın. Her şeyi aynen tekrarlayın.
2. Uygulamayı başlat.
3. Postman'ı (veya istekleri göndermek için başka herhangi bir aracı, örneğin curl) indirin ve yapılandırın.
4. POST ve GET isteklerini derste açıklanan şekilde test edin.
5. PUT ve DELETE isteklerini kendiniz test edin.