Spring Boot RestTemplate

Σε αυτό το άρθρο του Spring Boot, θα ελέγξουμε το Spring Boot RestTemplate ή το Spring RestTemplate. Μας κάνει εύκολη την κατανάλωση και τη δημιουργία μιας υπηρεσίας Web Spring Boot RESTful.

Η κατανάλωση και η δημιουργία μιας υπηρεσίας Web Spring Boot RESTful απαιτεί πολύ κώδικα λέβητα. Το Spring Boot RestTemplate διευκολύνει τη δημιουργία και την κατανάλωση της υπηρεσίας web RESTful. Το RestTemplate είναι ένα πρόγραμμα-πελάτης Spring REST το οποίο μπορούμε να χρησιμοποιήσουμε για να καταναλώσουμε διαφορετικά API REST.

Από Εαρινό πλαίσιο 5παράλληλα με το WebFlux stack, η Spring παρουσίασε έναν νέο πελάτη HTTP που ονομάζεται WebClient.

WebClient είναι ένας σύγχρονος, εναλλακτικός πελάτης HTTP σε σχέση με το RestTemplate. Όχι μόνο παρέχει ένα παραδοσιακό σύγχρονο API, αλλά υποστηρίζει επίσης μια αποτελεσματική προσέγγιση χωρίς αποκλεισμό και ασύγχρονη. η σύστασή μας είναι να χρησιμοποιήσετε τη νέα WebClient. Θα καταργήσουν το RestTemplate σε μελλοντικές εκδόσεις.

1. Εισαγωγή

Οι υπηρεσίες ιστού RESTful αντιπροσωπεύουν κυρίως το Representational State Transfer. Είναι βασικά ένα αρχιτεκτονικό στυλ που χρησιμοποιείται για τον καθορισμό των περιορισμών. Αυτοί οι περιορισμοί περιλαμβάνουν μια ομοιόμορφη διεπαφή που οδηγεί μια υπηρεσία Ιστού να προκαλέσει επιθυμητές ιδιότητες όπως η απόδοση και η επεκτασιμότητα. Εν ολίγοις, οι υπηρεσίες web RESTful βοηθούν στο να γίνει μια εφαρμογή πιο προσιτή στον χρήστη.

Το αρχιτεκτονικό στυλ REST θεωρεί τα δεδομένα και τη λειτουργικότητα ως πόρους και η πρόσβαση σε αυτά γίνεται χρησιμοποιώντας τα Uniform Resource Identifiers, γνωστά και ως URI. Αυτές είναι κυρίως η σύνδεση που το συνδέει με τον Ιστό. Περιλαμβάνει επίσης μια αρχιτεκτονική που έχει σύνδεση πελάτη/διακομιστή και έχει σχεδιαστεί κυρίως για την παροχή πρωτοκόλλου επικοινωνίας χωρίς κατάσταση. Βασικά εκτελούμε την αντιπροσώπευση πόρων ανταλλαγής πελάτη και διακομιστή χρησιμοποιώντας αυτήν την τυποποιημένη διεπαφή και πρωτόκολλα. Μερικά από τα κύρια πρωτόκολλα που χρησιμοποιούνται για την ανταλλαγή/μεταφορά δεδομένων είναι τα GET, POST, PUT, DELETE και άλλα.

1.1. Αρχές εφαρμογής RESTful

Υπάρχουν ορισμένες αρχές των εφαρμογών RESTful που κάνουν την εφαρμογή απλή, ελαφριά και γρήγορη. Αυτές οι αρχές είναι:

Αναγνώριση πόρων μέσω URI: Μπορούμε να εκθέσουμε πόρους χρησιμοποιώντας μια υπηρεσία Web RESTful. Αυτά βοηθούν στην αλληλεπίδραση των στόχων με τους πελάτες. Οι πόροι προσδιορίζονται από URI που παρέχουν έναν παγκόσμιο χώρο διευθύνσεων για την ανακάλυψη υπηρεσιών. Ορισμένοι σχολιασμοί για την έκθεση πόρων είναι @Path@RequestMapping.
Ενιαία διεπαφή: Οι πόροι μπορούν να χειριστούν χρησιμοποιώντας τη λειτουργία CRUD. Αυτές οι λειτουργίες CRUD σημαίνουν Δημιουργία, Ανάγνωση, Ενημέρωση και Διαγραφή, δηλαδή το POST χρησιμοποιείται για την προσθήκη νέου πόρου, χρησιμοποιούμε το GET για την ανάγνωση των ήδη διαθέσιμων πόρων, μπορούμε να ενημερώσουμε έναν πόρο χρησιμοποιώντας το PUT και το DELETE μπορεί να χρησιμοποιηθεί για τη διαγραφή των πόρων. Όλα αυτά είναι μέθοδοι HTTP και χρησιμοποιούν συγκεκριμένα αιτήματα για την εκτέλεση ενεργειών.
Περιγραφή Μηνύματα: Οι πόροι ή το περιεχόμενο μπορούν να προσπελαστούν με διάφορους τρόπους, όπως HTML, XML, απλό κείμενο, PDF, JPEG, JSON και άλλοι. Μπορούμε επίσης να χρησιμοποιήσουμε τα μεταδεδομένα σε αυτές τις υπηρεσίες Ιστού RESTful για την παροχή αποθήκευσης ελέγχου στην κρυφή μνήμη, σφάλματα μετάδοσης, έλεγχο ταυτότητας, στοιχεία ελέγχου εξουσιοδότησης και άλλα.
Παροχή κρατικών αλληλεπιδράσεων με τη βοήθεια υπερσυνδέσμων: Οι αλληλεπιδράσεις που παρέχονται από αυτούς τους πόρους είναι ανιθαγενείς, δηλαδή τα μηνύματα αιτήματος και το σώμα είναι αυτοτελή. Βασίζονται στην έννοια της ρητής μεταβίβασης του κράτους. Μπορούμε επίσης να ενσωματώσουμε αυτές τις καταστάσεις στα μηνύματα απόκρισης για να υποδείξουμε τις έγκυρες μελλοντικές καταστάσεις της αλληλεπίδρασης.

Με τη βοήθεια του Spring Boot RestTemplate, μπορούμε να δημιουργήσουμε εφαρμογές χρησιμοποιώντας τις παραπάνω συναρτήσεις RESTful Web Services. Μπορούμε να χρησιμοποιήσουμε τη μέθοδο exchange() που μπορεί να καταναλώσει αυτές τις υπηρεσίες web για όλες τις μεθόδους HTTP.

2. Maven Dependencies

Πριν προχωρήσουμε στο έργο, θα χρειαστούμε να κατεβάσουμε και να εγκαταστήσουμε στο σύστημα τις ακόλουθες προϋποθέσεις:

Το JDK θα πρέπει να είναι εγκατεστημένο στον υπολογιστή σας.
Χρησιμοποιήστε οποιοδήποτε IDE για ανάπτυξη, όπως IntelliJ, Eclipse, NetBeans.
Ο Ταχυδρόμος θα πρέπει να εγκατασταθεί για τη δοκιμή των κλήσεων API.

Δεν θα χρειαστείτε ειδικές εξαρτήσεις για τη δημιουργία του προτύπου REST. Αυτό θα απαιτήσει τις ίδιες εξαρτήσεις που απαιτούνται για τη δημιουργία οποιωνδήποτε RESTful Web Services. Ακολουθούν οι εξαρτήσεις που απαιτούνται για τη δημιουργία των υπηρεσιών web.

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

3. Ρύθμιση έργου

Θα δημιουργήσουμε ένα έργο πολλαπλών μονάδων ελατηρίου για να δείξουμε πώς αλληλεπιδρούν δύο μικροϋπηρεσίες και πώς μπορούμε να καλέσουμε ένα τελικό σημείο ανάπαυσης μιας υπηρεσίας από μια άλλη υπηρεσία χρησιμοποιώντας το RestTemplate. Για να κάνουμε bootstrap το έργο μας, μπορούμε να χρησιμοποιήσουμε το Spring initializr. Θα δημιουργήσουμε μια γονική λειτουργική μονάδα, η οποία θα περιέχει εξαρτήσεις κοινές και στις δύο ενότητες, όπως Lombokελατήριο-μπότα-εκκίνηση-δοκιμή κ.λπ. pom.xml παρέχεται παρακάτω για αναφορά.

Διαφημίσεις

**Ρύθμιση έργου Spring Boot RestTemplate**

Έτσι θα μοιάζει η δομή του έργου αφού το εισαγάγουμε στο IDE.

Εδώ είναι το πλήρες pom.xml για το παράδειγμα Spring Boot RestTemplate.

Διαφημίσεις

<?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.6.3</version>
      <relativePath />
      <!-- lookup parent from repository -->
   </parent>
   <groupId>com.javadevjournal</groupId>
   <artifactId>spring-boot-resttemplate</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>spring-boot-resttemplate</name>
   <description>Spring Boot project for RestTemplate illustration</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
         <scope>runtime</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>org.apache.httpcomponents</groupId>
         <artifactId>httpclient</artifactId>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
               <excludes>
                  <exclude>
                     <groupId>org.projectlombok</groupId>
                     <artifactId>lombok</artifactId>
                  </exclude>
               </excludes>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

Για να κατανοήσουμε πώς να χρησιμοποιήσετε το Spring Boot RestTemplate, ας δημιουργήσουμε τα διαφορετικά επίπεδα εφαρμογής που θα απαιτηθούν για την εκτέλεση της εφαρμογής. Αυτό το έργο θα περιλαμβάνει τα ακόλουθα επίπεδα: Ελεγκτής, Υπηρεσία, Τομέας και Επίπεδο Εφαρμογής.

3.1. Επίπεδο Εφαρμογής

Στο επίπεδο εφαρμογής, έχουμε SpringbootRestTemplateApplication τάξη, η οποία σχολιάζεται με @SpringBootApplication σχόλιο. Αυτός ο σχολιασμός επισημαίνει την κλάση ως κλάση διαμόρφωσης στην οποία μπορούμε να δηλώσουμε μία ή περισσότερες μεθόδους @Bean. Ενεργοποιεί επίσης την αυτόματη διαμόρφωση και τη σάρωση στοιχείων. Χρησιμοποιούμε @Bean σχολιασμός του Spring Boot για να εισάγουμε το φασόλι RestTemplate στην εφαρμογή μας. Θα το @Autowire στο επίπεδο ελεγκτή μας.

Διαφημίσεις

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class SpringbootRestTemplateApplication {

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

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

3.2. Αντικείμενο τομέα

Στη συνέχεια, θα δημιουργήσουμε το επίπεδο τομέα μας. Θα δημιουργήσουμε μια κλάση POJO που ονομάζεται Employee, η οποία θα είναι το DTO (Data Transfer Object). Περιέχει πεδία όπως το αναγνωριστικό που θα είναι το κύριο κλειδί για τον πίνακα υπαλλήλων μας, το όνομα του υπαλλήλου και τον μισθό του. @Data ο σχολιασμός προέρχεται από το έργο Lombok που παράγει τον κωδικό της πλάκας του λέβητα όπως-getters, setters, toString()κατασκευαστής χωρίς όρισμα.

@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class Employee implements Serializable {

    private static final long serialVersionUID = 1 L;

    int id;
    String name;
    Double salary;
}

@AllArgsConstructor -Αυτός είναι ένας σχολιασμός Lombok που χρησιμοποιείται για τη δημιουργία ενός κατασκευαστή που θα περιλαμβάνει όλες τις μεταβλητές μέλους της κλάσης Employee.
@NoArgsConstructor– Αυτός είναι ένας σχολιασμός Lombok που θα δημιουργήσει έναν κενό κατασκευαστή για την Κατηγορία Υπαλλήλων.
@Data – Αυτός είναι ένας σχολιασμός Lombok που δημιουργεί τους λήπτες και τους ρυθμιστές για όλες τις μεταβλητές μελών της κλάσης Employee.

3.3. Επίπεδο ελεγκτή

Έχουμε δημιουργήσει δύο ελεγκτές σε αυτό το έργο. Ενα είναι EmployeeController που περιέχει τελικά σημεία REST για την εκτέλεση λειτουργιών CRUD σε πόρους Εργαζομένων. Το δεύτερο είναι το RestTemplateController που είναι ο χειριστής όλων των αιτημάτων των χρηστών. Χρησιμοποιεί διαφορετικές μεθόδους που παρέχονται από το RestTemplate bean για να καλέσει τα REST API EmployeeController.

Παρακάτω είναι ο κώδικας για την κατηγορία ελεγκτή μας, τον οποίο θα κατανοήσουμε σε βήματα. Έχουμε χρησιμοποιήσει @Autowired σχολιασμός για την εισαγωγή της εξάρτησης για το RestTemplate στην κατηγορία ελεγκτή μας. Μπορούμε να χρησιμοποιήσουμε <a href="https://www.javadevjournal.com/spring/qualifier-annotation/" target="_blank" data-type="post" data-id="3741" rel="noreferrer noopener">@Qualifier annotation</a> σε περίπτωση που έχουμε RestTemplate με διαφορετικές διαμορφώσεις.

@RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @GetMapping("/employees")
    private List getAllEmployees() {
        return employeeService.getAllEmployees();
    }

    @GetMapping("/employees/{id}")
    private Employee getEmployeeById(@PathVariable("id") int id) {
        return employeeService.getEmployeeById(id);
    }

    @PostMapping("/employees")
    private Employee createEmployee(@RequestBody Employee employee) {
        employeeService.saveOrUpdate(employee);
        return employee;
    }

    @PutMapping("/employees/{id}")
    private Employee updateEmployee(@PathVariable("id") int id, @RequestBody Employee employee) {
        Employee updatedEmployee = employeeService.getEmployeeById(id);
        updatedEmployee.setName(employee.getName());
        updatedEmployee.setSalary(employee.getSalary());
        employeeService.saveOrUpdate(updatedEmployee);
        return updatedEmployee;
    }

    @DeleteMapping("/employees/{id}")
    private Employee deleteById(@PathVariable("id") int id) {
        Employee employeeDeleted = employeeService.getEmployeeById(id);
        employeeService.delete(id);
        return employeeDeleted;
    }
}

@RestController–Αυτός ο σχολιασμός επισημαίνει την κλάση Employee Controller ως α RestController. Μόλις αρχικοποιηθεί αυτός ο σχολιασμός, θα χειριστεί όλα τα εισερχόμενα και εξερχόμενα αιτήματα HTTP.
Έχουμε δημιουργήσει μια ξεχωριστή κλάση για τον ελεγκτή RestTemplate παρακάτω. Αυτή η κλάση θα καλέσει τις μεθόδους HTTP από τον Ελεγκτή υπαλλήλου και θα επιστρέψει το αποτέλεσμα μετά την ανάκτηση της απάντησης από τον Ελεγκτή υπαλλήλου.
@RequestMapping() – Αυτός ο σχολιασμός προσθέτει τη διαδρομή API HTTP από όπου χρειάζεται πρόσβαση στον πόρο.
Έχουμε δημιουργήσει 4 μεθόδους στην παραπάνω κλάση ελεγκτή που βασικά θα επιστρέψουν την επιθυμητή απόκριση.
1. ΠΑΙΡΝΩΔιαφημίσεις
2. ΘΕΣΗ
3. ΒΑΖΩ
4. ΔΙΑΓΡΑΦΩ

#RestTemplateController.java
@RestController
public class RestTemplateController {

    private final String URI_EMPLOYEE = "http://localhost:8081/employees/";
    private final String URI_EMPLOYEE_ID = "http://localhost:8081/employees/{id}";

    @Autowired
    RestTemplate restTemplate;

    @GetMapping("/v1/allEmployees")
    public ResponseEntity getAllV1() {
        Employee[] EmployeesArray = restTemplate.getForObject(URI_EMPLOYEE, Employee[].class);
        return new ResponseEntity < > (Arrays.asList(EmployeesArray), HttpStatus.OK);
    }

    @GetMapping("/v1/employees/{id}")
    public ResponseEntity getByIdV1(@PathVariable final Integer id) {
        Map < String, String > params = new HashMap < > ();
        params.put("id", String.valueOf(id));
        Employee Employee = restTemplate.getForObject(URI_EMPLOYEE_ID, Employee.class, params);
        return new ResponseEntity < > (Employee, HttpStatus.OK);
    }

    @GetMapping("/v2/allEmployees")
    public ResponseEntity getAllV2() {
        ResponseEntity < Employee[] > responseEntity = restTemplate.getForEntity(URI_EMPLOYEE, Employee[].class);
        return responseEntity;
    }

    @GetMapping("/v2/employees/{id}")
    public ResponseEntity getByIdV2(@PathVariable final Integer id) {
        Map < String, String > params = new HashMap < > ();
        params.put("id", String.valueOf(id));
        ResponseEntity < Employee > responseEntity = restTemplate.getForEntity(URI_EMPLOYEE_ID, Employee.class, params);
        return responseEntity;
    }

    @GetMapping("/v3/allEmployees")
    public ResponseEntity getAllV3() {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity < String > entity = new HttpEntity < > (httpHeaders);
        return restTemplate.exchange(URI_EMPLOYEE, HttpMethod.GET, entity, Employee[].class);
    }

    @GetMapping("/v3/employees/{id}")
    public ResponseEntity getByIdV3(@PathVariable final Integer id) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity < String > entity = new HttpEntity < > (httpHeaders);
        return restTemplate.exchange(URI_EMPLOYEE + id, HttpMethod.GET, entity, Employee.class);
    }

    @PostMapping("/v1/employees")
    public ResponseEntity createV1(@RequestBody final Employee newEmployee) {
        Employee createdEmployee = restTemplate.postForObject(URI_EMPLOYEE, newEmployee, Employee.class);
        return new ResponseEntity(createdEmployee, HttpStatus.CREATED);
    }

    @PostMapping("/v2/employees")
    public ResponseEntity createV2(@RequestBody final Employee newEmployee) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity < Employee > entity = new HttpEntity < > (newEmployee, httpHeaders);
        return restTemplate.exchange(URI_EMPLOYEE, HttpMethod.POST, entity, Employee.class);
    }

    @PutMapping("/v1/employees/{id}")
    public ResponseEntity updateEmployeeV1(@PathVariable final Integer id, @RequestBody Employee newEmployee) {
        Map < String, String > params = new HashMap < > ();
        params.put("id", String.valueOf(id));
        restTemplate.put(URI_EMPLOYEE_ID, newEmployee, params);
        return new ResponseEntity("Employee Updated with id " + id, HttpStatus.OK);
    }

    @PutMapping("/v2/employees/{id}")
    public ResponseEntity updateEmployeeV2(@PathVariable final Integer id, @RequestBody Employee newEmployee) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity < Employee > entity = new HttpEntity < > (newEmployee, httpHeaders);
        return restTemplate.exchange(URI_EMPLOYEE + id, HttpMethod.PUT, entity, Employee.class);
    }

    @DeleteMapping("/v1/employees/{id}")
    public ResponseEntity deleteV1(@PathVariable final Integer id) {
        Map < String, String > params = new HashMap < > ();
        params.put("id", String.valueOf(id));
        restTemplate.delete(URI_EMPLOYEE_ID, params);
        return new ResponseEntity < > ("Employee deleted with id " + id, HttpStatus.OK);
    }

    @DeleteMapping("/v2/employees/{id}")
    public ResponseEntity < Employee > deleteV2(@PathVariable final Integer id) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity < Employee > entity = new HttpEntity < > (httpHeaders);
        return restTemplate.exchange(URI_EMPLOYEE + id, HttpMethod.DELETE, entity, Employee.class);
    }
}

4. API μεθόδου

Το Spring Boot RestTemplate παρέχει 3 τύπους μεθόδων για την κλήση ενός GET API.

Διαφημίσεις

4.1. ΛΗΨΗ API

ο getForObject() θα ενεργοποιήσει ένα αίτημα GET και θα επιστρέψει απευθείας το αντικείμενο πόρου. Σε κώδικα, μπορούμε να τυλίξουμε την έξοδο σε α ResponseEntity αντικείμενο ή απλώς επιστρέψτε το αντικείμενο πόρου ως έχει. Το χρησιμοποιούμε όταν θέλουμε να αντιστοιχίσουμε την απόκριση απευθείας στον DTO του πόρου.

@GetMapping("/v1/allEmployees")
public ResponseEntity getAllV1() {
    Employee[] EmployeesArray = restTemplate.getForObject(URI_EMPLOYEE, Employee[].class);
    return new ResponseEntity < > (Arrays.asList(EmployeesArray), HttpStatus.OK);
}

@GetMapping("/v1/employees/{id}")
public ResponseEntity getByIdV1(@PathVariable final Integer id) {
    Map < String, String > params = new HashMap < > ();
    params.put("id", String.valueOf(id));
    Employee Employee = restTemplate.getForObject(URI_EMPLOYEE_ID, Employee.class, params);
    return new ResponseEntity < > (Employee, HttpStatus.OK);
}

ο getForEntity() θα ενεργοποιήσει ένα αίτημα GET και θα επιστρέψει ResponseEntity που περιέχει τόσο τον κωδικό κατάστασης όσο και τον πόρο ως αντικείμενο. Μπορούμε να το χρησιμοποιήσουμε όταν θέλουμε να λάβουμε μια απάντηση όπως JSON.

@GetMapping("/v1/allEmployees")
public ResponseEntity getAllV1() {
    Employee[] EmployeesArray = restTemplate.getForObject(URI_EMPLOYEE, Employee[].class);
    return new ResponseEntity < > (Arrays.asList(EmployeesArray), HttpStatus.OK);
}

@GetMapping("/v1/employees/{id}")
public ResponseEntity getByIdV1(@PathVariable final Integer id) {
    Map < String, String > params = new HashMap < > ();
    params.put("id", String.valueOf(id));
    Employee Employee = restTemplate.getForObject(URI_EMPLOYEE_ID, Employee.class, params);
    return new ResponseEntity < > (Employee, HttpStatus.OK);
}

ο exchange() Η μέθοδος είναι το πιο γενικό API, το οποίο μπορεί να καλέσει ένα αίτημα GET/POST/PUT/DELETE. Η είσοδος στο API είναι το URI, μέθοδος αιτήματος, αίτημα HttpEntity που περιέχει κεφαλίδες και κωδικό οντότητας (εάν υπάρχει) και την κλάση τύπου απάντησης. Η έξοδος είναι α ResponseEntity αντικείμενο που περιέχει τον κωδικό κατάστασης και τον πόρο ως σώμα.

Διαφημίσεις

@GetMapping("/v3/allEmployees")
public ResponseEntity getAllV3() {
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
    HttpEntity < String > entity = new HttpEntity < > (httpHeaders);
    return restTemplate.exchange(URI_EMPLOYEE, HttpMethod.GET, entity, Employee[].class);
}

@GetMapping("/v3/employees/{id}")
public ResponseEntity getByIdV3(@PathVariable final Integer id) {
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
    HttpEntity < String > entity = new HttpEntity < > (httpHeaders);
    return restTemplate.exchange(URI_EMPLOYEE + id, HttpMethod.GET, entity, Employee.class);
}

4.2. POST API

Το Spring Boot RestTemplate παρέχει 4 τύπους μεθόδων για την κλήση ενός POST API. Ας δούμε καθένα από αυτά για σαφήνεια.

postForLocation()–Θα ενεργοποιήσει ένα αίτημα POST το οποίο θα λάβει το URI, το σώμα αιτήματος υπαλλήλου και θα επιστρέψει τη θέση του πόρου που δημιουργήθηκε πρόσφατα.
postForEntity() – Θα ενεργοποιήσει ένα αίτημα POST το οποίο θα λάβει URI, σώμα αιτήματος υπαλλήλου και responseType ως είσοδο και επιστρέψτε τον πόρο ως JSON.Διαφημίσεις
postForObject()–Θα ενεργοποιήσει ένα αίτημα POST το οποίο θα λάβει URI, σώμα αιτήματος υπαλλήλου και responseType ως είσοδο και επιστρέψτε το αντικείμενο πόρου.

@PostMapping("/v1/employees")
public ResponseEntity createV1(@RequestBody final Employee newEmployee) {
    Employee createdEmployee = restTemplate.postForObject(URI_EMPLOYEE, newEmployee, Employee.class);
    return new ResponseEntity(createdEmployee, HttpStatus.CREATED);
}

ο ανταλλαγή() API

@PostMapping("/v2/employees")
public ResponseEntity createV2(@RequestBody final Employee newEmployee) {
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
    HttpEntity < Employee > entity = new HttpEntity < > (newEmployee, httpHeaders);
    return restTemplate.exchange(URI_EMPLOYEE, HttpMethod.POST, entity, Employee.class);
}

4.3. ΔΙΑΓΡΑΦΗ API

Το Spring Boot RestTemplate παρέχει 2 τύπους μεθόδων για την κλήση ενός DELETE API. Η μέθοδος delete() θα ενεργοποιήσει ένα αίτημα διαγραφής. Ας δούμε κάποιο παράδειγμα κώδικα για καλύτερη σαφήνεια.

@DeleteMapping("/v1/employees/{id}")
public ResponseEntity deleteV1(@PathVariable final Integer id) {
    Map < String, String > params = new HashMap < > ();
    params.put("id", String.valueOf(id));
    restTemplate.delete(URI_EMPLOYEE_ID, params);
    return new ResponseEntity < > ("Employee deleted with id " + id, HttpStatus.OK);
}

@DeleteMapping("/v2/employees/{id}")
public ResponseEntity < Employee > deleteV2(@PathVariable final Integer id) {
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
    HttpEntity < Employee > entity = new HttpEntity < > (httpHeaders);
    return restTemplate.exchange(URI_EMPLOYEE + id, HttpMethod.DELETE, entity, Employee.class);
}

5. Εκτέλεση της εφαρμογής

Μπορούμε να εκτελέσουμε την εφαρμογή από την κύρια μέθοδο στην κλάση εφαρμογών μας. Και μετά μπορούμε να χρησιμοποιήσουμε τον Postman για να δοκιμάσουμε τα τελικά σημεία.

Διαφημίσεις

6. Δοκιμή των τελικών σημείων χρησιμοποιώντας Spring Boot RestTemplate

Ας δοκιμάσουμε αυτά τα τελικά σημεία χρησιμοποιώντας το Spring RestTemplate.

**Λάβετε όλους τους υπαλλήλους χρησιμοποιώντας το getForObject()**

**Λάβετε έναν υπάλληλο με αναγνωριστικό χρησιμοποιώντας το getForObject():**

**Λάβετε όλους τους υπαλλήλους χρησιμοποιώντας το exchange()**

**Δημιουργία υπαλλήλου χρησιμοποιώντας το postForObject()**

**Διαγραφή υπαλλήλου χρησιμοποιώντας το delete()**

Διαφημίσεις

7. Διαμόρφωση χρονικού ορίου λήξης με χρήση RestTemplate

Μπορούμε να διαμορφώσουμε το RestTemplate προσθέτοντας ένα timeout στη σύνδεση, χρησιμοποιώντας ClientHttpRequestFactory. Μπορούμε επίσης να προσθέσουμε περισσότερες διαμορφώσεις χρησιμοποιώντας HttpClient. Πρέπει να προσθέσουμε httpclient εξάρτηση για το ίδιο.

<dependency>
   <groupId>org.apache.httpcomponents</groupId>
   <artifactId>httpclient</artifactId>
</dependency>

Θα δημιουργήσουμε άλλο ένα bean του RestTemplate και θα περάσουμε το ClinetHttpRequestFactory αντικείμενο ως εξάρτηση. Μπορούμε να δώσουμε διάρκεια τάιμ άουτ στο ClientHttpRequestFactory φασόλι.

@Bean("restTemplateWithTimeout")
RestTemplate restTemplateWithTimeout() {
    return new RestTemplate(getClientHttpRequestFactory());
}

ClientHttpRequestFactory getClientHttpRequestFactory() {
    int timeout = 5000;
    HttpComponentsClientHttpRequestFactory clientHttpRequestFactory
        = new HttpComponentsClientHttpRequestFactory();
    clientHttpRequestFactory.setConnectTimeout(timeout);
    return clientHttpRequestFactory;
}

ClientHttpRequestFactory getClientHttpRequestFactoryV1() {
    int timeout = 5000;
    RequestConfig config = RequestConfig.custom()
        .setConnectTimeout(timeout)
        .setConnectionRequestTimeout(timeout)
        .setSocketTimeout(timeout)
        .build();
    CloseableHttpClient client = HttpClientBuilder
        .create()
        .setDefaultRequestConfig(config)
        .build();
    return new HttpComponentsClientHttpRequestFactory(client);
}

Περίληψη

Σε αυτό το άρθρο, δημιουργήσαμε μια εφαρμογή Spring Boot από άκρο σε άκρο και καλέσαμε τα τελικά σημεία της χρησιμοποιώντας τον ελεγκτή προτύπου ανάπαυσης Spring Boot που δημιουργήθηκε. Εξετάσαμε τις κύριες μεθόδους HTTP και χρησιμοποιήσαμε το RestTemplate για να ενορχηστρώσουμε τα αιτήματα χρησιμοποιώντας όλες αυτές τις μεθόδους. Η πηγή για αυτό το άρθρο είναι διαθέσιμη στο εξωτερικό Αποθετήριο GitHub.