Ini adalah bagian ketiga dari serangkaian artikel tentang dasar-dasar arsitektur layanan-mikro, di mana Anda akan belajar cara membuat layanan-mikro untuk konversi mata uang.
Dalam seri artikel ini, Anda akan menjadi terbiasa dengan konsep layanan microser dan belajar bagaimana membuat layanan microser menggunakan Spring Boot dan Spring Cloud.
Panduan ini akan membantu Anda mempelajari dasar-dasar arsitektur layanan mikro. Kami juga akan mulai melihat implementasi microservice dasar dengan Spring Boot.
Kami akan membuat sepasang layanan microser dan membuatnya berkomunikasi satu sama lain menggunakan Eureka (Server Penamaan Eureka) dan server nama Ribbon untuk menyeimbangkan beban di sisi klien.
Artikel ini adalah bagian dari seri Spring Boot Microservices:
Kamu akan belajar
- Cara membuat microservice menggunakan Spring Boot.
- Cara menggunakan RestTemplate untuk membuat layanan REST.
- Cara menggunakan Feign untuk membuat layanan REST.
- Manfaat Feign dibandingkan RestTemplate.
Tinjauan Sumberdaya
Layanan Konversi Mata Uang (CCS) dapat mengkonversi banyak mata uang ke mata uang lain. Ini menggunakan layanan Forex untuk mendapatkan nilai tukar mata uang saat ini. CCS adalah konsumen layanan.
Contoh permintaan dan respons ditunjukkan di bawah ini:
GET to http://localhost:8100/currency-converter/from/EUR/to/INR/quantity/10000
{ id: 10002, from: "EUR", to: "INR", conversionMultiple: 75, quantity: 10000, totalCalculatedAmount: 750000, port: 8000, }
Permintaan di atas memungkinkan Anda untuk menentukan nilai 10.000 euro dalam rupee India.
TotalCalculatedAmount adalah 750.000 INR. Diagram di bawah ini menunjukkan hubungan antara CCS dan FS.
Struktur Kode Proyek
Tangkapan layar berikut menunjukkan struktur proyek yang akan kita buat.
Beberapa elemen proyek:
- SpringBootMicroserviceCurrencyConversionApplication.java adalah kelas aplikasi Spring Boot yang dibuat menggunakan Spring Initializer. Kelas ini bertindak sebagai titik peluncuran aplikasi.
- pom.xml - berisi semua dependensi yang diperlukan untuk membuat proyek ini. Kami akan menggunakan Spring Boot Starter Web.
- CurrencyConversionBean.java - Kacang untuk menyimpan respons yang ingin kami kirim.
- CurrencyExchangeServiceProxy.java - ini akan menjadi Proksi Feign untuk menelepon layanan Forex.
- CurrencyConversionController.java - Kontroler Spring REST yang menyediakan layanan konversi mata uang. Ini akan menggunakan CurrencyExchangeServiceProxy untuk memanggil layanan Forex.
Alat yang Anda butuhkan
- Maven 3.0+ - alat bangun
- IDE favorit Anda. Kami menggunakan Eclipse.
- JDK 1.8+
Proyek Maven Siap dengan Sampel Kode
Repositori Github memiliki semua contoh kode.
Membuat proyek menggunakan Spring Initializr
Membuat microservice dengan Spring Initializr mudah dilakukan.
Spring Initializr adalah alat yang hebat untuk membuat proyek Boot Musim Semi Anda dengan cepat.
Dengan bantuan
Spring Initializr, Anda dapat membuat berbagai proyek.
Langkah-langkah berikut harus diambil untuk membuat proyek pengembangan layanan web:
1. Luncurkan Spring Initializr dan ketikkan yang berikut:
- Ketik com.in28minutes.springboot.microservice.example.currencyconversion sebagai grup.
- Ketik spring-boot-microservice-currency-conversion sebagai artefak.
- Pilih dependensi berikut: Web , DevTools , Feign
2. Klik
Hasilkan Proyek .
3. Impor proyek ke Eclipse: File -> Impor -> Proyek Maven yang Ada.
Ingatlah untuk mencantumkan
Feign dalam dependensi.
Membuat CurrencyConversionBean
Ini adalah kacang sederhana untuk membuat jawaban.
public class CurrencyConversionBean { private Long id; private String from; private String to; private BigDecimal conversionMultiple; private BigDecimal quantity; private BigDecimal totalCalculatedAmount; private int port; public CurrencyConversionBean() { } public CurrencyConversionBean(Long id, String from, String to, BigDecimal conversionMultiple, BigDecimal quantity, BigDecimal totalCalculatedAmount, int port) { super(); this.id = id; this.from = from; this.to = to; this.conversionMultiple = conversionMultiple; this.quantity = quantity; this.totalCalculatedAmount = totalCalculatedAmount; this.port = port; }
Menerapkan Klien REST dengan RestTemplate
Kode di bawah ini menunjukkan implementasi klien REST untuk memanggil layanan Forex dan memproses respons. Seperti yang Anda lihat, untuk membuat panggilan layanan sederhana, Anda perlu menulis banyak kode.
@RestController public class CurrencyConversionController { private Logger logger = LoggerFactory.getLogger(this.getClass()); @GetMapping("/currency-converter/from/{from}/to/{to}/quantity/{quantity}") public CurrencyConversionBean convertCurrency(@PathVariable String from, @PathVariable String to, @PathVariable BigDecimal quantity) { Map<String, String> uriVariables = new HashMap<>(); uriVariables.put("from", from); uriVariables.put("to", to); ResponseEntity<CurrencyConversionBean> responseEntity = new RestTemplate().getForEntity( "http://localhost:8000/currency-exchange/from/{from}/to/{to}", CurrencyConversionBean.class, uriVariables); CurrencyConversionBean response = responseEntity.getBody(); return new CurrencyConversionBean(response.getId(), from, to, response.getConversionMultiple(), quantity, quantity.multiply(response.getConversionMultiple()), response.getPort()); }
Konfigurasikan nama aplikasi dan porta
/spring-boot-microservice-currency-conversion-service/src/main/resources/application.properties spring.application.name=currency-conversion-service server.port=8100
Pengujian layanan mikro
Luncurkan aplikasi Spring Boot dengan menjalankan SpringBootMicroserviceCurrencyConversionApplication.java
GET to http://localhost:8100/currency-converter/from/EUR/to/INR/quantity/10000
{ id: 10002, from: "EUR", to: "INR", conversionMultiple: 75, quantity: 10000, totalCalculatedAmount: 750000, port: 8000, }
Membuat Feign Proxy
Feign memberikan alternatif terbaik untuk RestTemplate untuk memanggil REST API.
/spring-boot-microservice-currency-conversion-service/src/main/java/com/in28minutes/springboot/microservice/example/currencyconversion/CurrencyExchangeServiceProxy.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import org.springframework.cloud.netflix.feign.FeignClient; import org.springframework.cloud.netflix.ribbon.RibbonClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @FeignClient(name="forex-service" url="localhost:8000") public interface CurrencyExchangeServiceProxy { @GetMapping("/currency-exchange/from/{from}/to/{to}") public CurrencyConversionBean retrieveExchangeValue (@PathVariable("from") String from, @PathVariable("to") String to); }
Pertama-tama kita mendefinisikan proxy sederhana:
- @FeignClient (name = "forex-service" url = "localhost: 8100") - menyatakan bahwa ini adalah klien Feign, dan URL tempat layanan Forex berada adalah localhost: 8100
- @GetMapping ("/ pertukaran mata uang / dari / {dari} / ke / {ke}") - URI layanan yang ingin kami gunakan
Menggunakan Feign Proxy dalam Kontroler Layanan Microsoft
Melakukan panggilan melalui proxy sangat sederhana. Anda akan melihat ini beraksi dalam kode di bawah ini. Yang harus kami lakukan adalah menghubungkan proxy secara otomatis dan menggunakannya untuk memanggil metode.
@Autowired private CurrencyExchangeServiceProxy proxy; @GetMapping("/currency-converter-feign/from/{from}/to/{to}/quantity/{quantity}") public CurrencyConversionBean convertCurrencyFeign(@PathVariable String from, @PathVariable String to, @PathVariable BigDecimal quantity) { CurrencyConversionBean response = proxy.retrieveExchangeValue(from, to); logger.info("{}", response); return new CurrencyConversionBean(response.getId(), from, to, response.getConversionMultiple(), quantity, quantity.multiply(response.getConversionMultiple()), response.getPort()); }
Mengaktifkan Klien Feign
Sebelum kita dapat menggunakan Feign, kita harus mengaktifkannya menggunakan anotasi @EnableFeignClients dalam paket yang sesuai di mana proxy klien didefinisikan.
@SpringBootApplication @EnableFeignClients("com.in28minutes.springboot.microservice.example.currencyconversion") @EnableDiscoveryClient public class SpringBootMicroserviceCurrencyConversionApplication { public static void main(String[] args) { SpringApplication.run(SpringBootMicroserviceCurrencyConversionApplication.class, args); } }
Menguji Layanan Microsoft Menggunakan Feign
GET to http://localhost:8100/currency-converter-feign/from/EUR/to/INR/quantity/10000
{ id: 10002, from: "EUR", to: "INR", conversionMultiple: 75, quantity: 10000, totalCalculatedAmount: 750000, port: 8000, }
Ringkasan
Kami menciptakan dua layanan microser dan membangun koneksi di antara mereka.
Namun, kami mengkodekan URL untuk FS ke CCS. Ini berarti bahwa ketika instance FS baru diluncurkan, kami tidak memiliki cara untuk mendistribusikan beban di antara mereka. Pada bagian selanjutnya, kami akan mengaktifkan penyetelan beban sisi klien menggunakan Ribbon.
Kode contoh lengkap/spring-boot-microservice-currency-conversion-service/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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.in28minutes.springboot.microservice.example.currency-conversion</groupId> <artifactId>spring-boot-microservice-currency-conversion</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>spring-boot-microservice-currency-conversion</name> <description>Microservices with Spring Boot and Spring Cloud - Currency Conversion Service</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.0.M3</version> <relativePath /> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring-cloud.version>Finchley.M2</spring-cloud.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-feign</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </repository> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> </pluginRepositories> </project>
/spring-boot-microservice-currency-conversion-service/src/main/java/com/in28minutes/springboot/microservice/example/currencyconversion/CurrencyConversionBean.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import java.math.BigDecimal; public class CurrencyConversionBean { private Long id; private String from; private String to; private BigDecimal conversionMultiple; private BigDecimal quantity; private BigDecimal totalCalculatedAmount; private int port; public CurrencyConversionBean() { } public CurrencyConversionBean(Long id, String from, String to, BigDecimal conversionMultiple, BigDecimal quantity, BigDecimal totalCalculatedAmount, int port) { super(); this.id = id; this.from = from; this.to = to; this.conversionMultiple = conversionMultiple; this.quantity = quantity; this.totalCalculatedAmount = totalCalculatedAmount; this.port = port; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getFrom() { return from; } public void setFrom(String from) { this.from = from; } public String getTo() { return to; } public void setTo(String to) { this.to = to; } public BigDecimal getConversionMultiple() { return conversionMultiple; } public void setConversionMultiple(BigDecimal conversionMultiple) { this.conversionMultiple = conversionMultiple; } public BigDecimal getQuantity() { return quantity; } public void setQuantity(BigDecimal quantity) { this.quantity = quantity; } public BigDecimal getTotalCalculatedAmount() { return totalCalculatedAmount; } public void setTotalCalculatedAmount(BigDecimal totalCalculatedAmount) { this.totalCalculatedAmount = totalCalculatedAmount; } public int getPort() { return port; } public void setPort(int port) { this.port = port; } }
/spring-boot-microservice-currency-conversion-service/src/main/java/com/in28minutes/springboot/microservice/example/currencyconversion/CurrencyConversionController.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import java.math.BigDecimal; import java.util.HashMap; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; @RestController public class CurrencyConversionController { private Logger logger = LoggerFactory.getLogger(this.getClass()); @Autowired private CurrencyExchangeServiceProxy proxy; @GetMapping("/currency-converter/from/{from}/to/{to}/quantity/{quantity}") public CurrencyConversionBean convertCurrency(@PathVariable String from, @PathVariable String to, @PathVariable BigDecimal quantity) { Map<String, String> uriVariables = new HashMap<>(); uriVariables.put("from", from); uriVariables.put("to", to); ResponseEntity<CurrencyConversionBean> responseEntity = new RestTemplate().getForEntity( "http://localhost:8000/currency-exchange/from/{from}/to/{to}", CurrencyConversionBean.class, uriVariables); CurrencyConversionBean response = responseEntity.getBody(); return new CurrencyConversionBean(response.getId(), from, to, response.getConversionMultiple(), quantity, quantity.multiply(response.getConversionMultiple()), response.getPort()); } @GetMapping("/currency-converter-feign/from/{from}/to/{to}/quantity/{quantity}") public CurrencyConversionBean convertCurrencyFeign(@PathVariable String from, @PathVariable String to, @PathVariable BigDecimal quantity) { CurrencyConversionBean response = proxy.retrieveExchangeValue(from, to); logger.info("{}", response); return new CurrencyConversionBean(response.getId(), from, to, response.getConversionMultiple(), quantity, quantity.multiply(response.getConversionMultiple()), response.getPort()); } }
/spring-boot-microservice-currency-conversion-service/src/main/java/com/in28minutes/springboot/microservice/example/currencyconversion/CurrencyExchangeServiceProxy.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import org.springframework.cloud.netflix.feign.FeignClient; import org.springframework.cloud.netflix.ribbon.RibbonClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @FeignClient(name="forex-service" url="localhost:8000") public interface CurrencyExchangeServiceProxy { @GetMapping("/currency-exchange/from/{from}/to/{to}") public CurrencyConversionBean retrieveExchangeValue (@PathVariable("from") String from, @PathVariable("to") String to); }
/spring-boot-microservice-currency-conversion-service/src/main/java/com/in28minutes/springboot/microservice/example/currencyconversion/SpringBootMicroserviceCurrencyConversionApplication.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; import org.springframework.cloud.netflix.feign.EnableFeignClients; @SpringBootApplication @EnableFeignClients("com.in28minutes.springboot.microservice.example.currencyconversion") public class SpringBootMicroserviceCurrencyConversionApplication { public static void main(String[] args) { SpringApplication.run(SpringBootMicroserviceCurrencyConversionApplication.class, args); } }
/spring-boot-microservice-currency-conversion-service/src/main/resources/application.properties
spring.application.name=currency-conversion-service server.port=8100
/spring-boot-microservice-currency-conversion-service/src/test/java/com/in28minutes/springboot/microservice/example/currencyconversion/SpringBootMicroserviceCurrencyConversionApplicationTests.java
package com.in28minutes.springboot.microservice.example.currencyconversion; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; @RunWith(SpringRunner.class) @SpringBootTest public class SpringBootMicroserviceCurrencyConversionApplicationTests { @Test public void contextLoads() { } }