माइक्रोनॉट या डार्लिंग की कोशिश करो, मैंने रूपरेखा को कम कर दिया

माइक्रोनॉट या डार्लिंग की कोशिश करो, मैंने रूपरेखा को कम कर दिया

माइक्रोनॉट फ्रेमवर्क के बारे में, मैंने न्यूजलेटर डाइजेस्ट की एक झलक पकड़ी। वह सोचता था कि वह कैसा जानवर था। रूपरेखा को सभी आवश्यक उपकरणों के साथ भरवां वसंत के विपरीत रखा गया है।

डेवलपरों के लिए आगामी सम्मेलन को देखते हुए, जहां वे सिर्फ यह बताएंगे कि आपके माइक्रोसर्विस में माइक्रोनॉट का उपयोग कैसे करना है, मैंने बताया कि मैंने कम से कम एक बार तैयारी करने का फैसला किया है और मेरे सिर में कम से कम कुछ संदर्भ, समस्याओं और प्रश्नों का एक निश्चित सेट के साथ आया है। बोलने के लिए होमवर्क करें। मैंने शाम के एक जोड़े के लिए कुछ छोटे पालतू-प्रोजेक्ट करने का फैसला किया (जैसा कि यह जाता है)। लेख के अंत में सभी परियोजना स्रोतों के भंडार का एक लिंक होगा।

माइक्रोनॉट एक जेवीएम फ्रेमवर्क है जो तीन विकास भाषाओं का समर्थन करता है: जावा, कोटलिन, ग्रूवी। यह OCI द्वारा विकसित किया गया था, वही कंपनी जो ग्रिल्स ने हमें दी थी। इसमें एक cli एप्लिकेशन और अनुशंसित पुस्तकालयों (विभिन्न प्रतिक्रियाशील-http और डेटाबेस क्लाइंट) के सेट के रूप में ट्यूनिंग है।

एक DI है जो स्प्रिंग के विचारों को लागू करता है और दोहराता है, इसके चिप्स को जोड़ रहा है - अतुल्यकालिकता, AWS लैम्ब्डा के लिए समर्थन, क्लाइंट साइड लोड बैलेंसिंग।

सेवा का विचार: मूर्ख के साथ एक समय में मेरे एक दोस्त ने अलग-अलग क्रिप्टोकरेंसी के सभी प्रकार के आधा दर्जन खरीदे, उनमें एक निवेशित अवकाश और एक शीतकालीन जैकेट से एक टकराव। हम सभी जानते हैं कि इस सभी क्रिप्टोक्यूरेंसी पदार्थ की अस्थिरता जंगली है, और यह विषय आम तौर पर अप्रत्याशित है, एक दोस्त ने अंततः अपनी नसों की देखभाल करने का फैसला किया और बस अपनी "संपत्ति" के साथ क्या हो रहा है, इस पर डूब गया। लेकिन कभी-कभी आप अभी भी देखना चाहते हैं, लेकिन इस सब के साथ क्या है, अचानक यह पहले से ही समृद्ध है। तो एक साधारण पैनल (एक डैशबोर्ड, जैसे ग्राफाना या कुछ सरल) का विचार, शुष्क जानकारी के साथ एक निश्चित वेब पेज, यह कितना कुछ फिएट मुद्रा (यूएसडी, आरयूआर) में खर्च होता है।

अस्वीकरण

1. हम अपने स्वयं के समाधान को ओवरबोर्ड लिखने की शीघ्रता को छोड़ देंगे, हमें बस हैलोवर्ल्ड की तुलना में कुछ अधिक चालाक पर नए ढांचे को आज़माने की आवश्यकता है।
2. गणना एल्गोरिथ्म, अपेक्षित त्रुटियां, त्रुटियां, आदि। (कम से कम उत्पाद के पहले चरण के लिए), जानकारी खींचने के लिए क्रिप्टो एक्सचेंजों की पसंद की वैधता, एक दोस्त का "निवेश" क्रिप्टो पोर्टफोलियो भी सवाल से बाहर होगा और चर्चा या किसी तरह के गहन विश्लेषण के अधीन नहीं होगा।

तो, आवश्यकताओं का एक छोटा सा सेट:

1. वेब सेवा (http के माध्यम से बाहर से पहुंच)
2. क्रिप्टोक्यूरेंसी पोर्टफोलियो के कुल मूल्य के सारांश के साथ एक ब्राउज़र में एक पृष्ठ प्रदर्शित करना
3. पोर्टफोलियो को कॉन्फ़िगर करने की क्षमता (पोर्टफोलियो संरचना को लोड करने और उतारने के लिए JSON प्रारूप चुनें)। पोर्टफोलियो को अपडेट करने और उसे लोड करने के लिए एक निश्चित REST API, अर्थात 2 API: सेविंग / अपडेट करने के लिए - POST, अनलोडिंग के लिए - GET। पोर्टफोलियो संरचना अनिवार्य रूप से एक सरल प्रकार की प्लेट है
   

   BTC –  0.00005 . XEM –  4.5 . ... 

4. हम क्रिप्टोकरंसी और मुद्रा विनिमय स्रोतों से डेटा लेते हैं (फिएट मुद्राओं के लिए)
5. पोर्टफोलियो के कुल मूल्य की गणना के लिए नियम:
   
   

बेशक, सब कुछ जो अनुच्छेद 5 में लिखा गया है, अलग-अलग विवादों और संदेह का विषय है, लेकिन यह बताएं कि व्यवसाय ऐसा ही चाहता था।

प्रोजेक्ट शुरू

इसलिए, हम ढांचे की आधिकारिक वेबसाइट पर जाते हैं और देखते हैं कि हम कैसे विकसित करना शुरू कर सकते हैं। आधिकारिक साइट sdkman टूल को स्थापित करने की पेशकश करती है। एक टुकड़ा जो अंतरिक्ष यात्री ढांचे पर परियोजनाओं के विकास और प्रबंधन की सुविधा प्रदान करता है (और उदाहरण के लिए, ग्रेल्स सहित अन्य)।

एक छोटी सी टिप्पणी: यदि आप बिना किसी कुंजी के सिर्फ प्रोजेक्ट इनिशियलाइज़ेशन शुरू करते हैं, तो ग्रेडल कलेक्टर को डिफ़ॉल्ट रूप से चुना जाता है। फ़ोल्डर हटाएं, फिर से प्रयास करें, इस बार कुंजी के साथ:

 mn create-app com.room606.cryptonaut -b=maven 

एक दिलचस्प बिंदु यह है कि sdkman, स्प्रिंग टूल सूट की तरह, आपको एक प्रोजेक्ट बनाने के चरण में पेश करता है, जिसे आप "cubes" शुरू में उपयोग करना चाहते हैं। मैंने इसके साथ अधिक प्रयोग नहीं किया, मैंने इसे डिफ़ॉल्ट प्रीसेट के साथ भी बनाया।

अंत में, हम इंटेलीज आइडिया में प्रोजेक्ट को खोलते हैं और स्रोतों और संसाधनों के सेट की प्रशंसा करते हैं और डिस्क को माइक्रोप्रोट्ट प्रोजेक्ट बनाने के लिए हमें प्रदान किया गया।

डॉकरीफाइल के लिए आंखें

 FROM openjdk:8u171-alpine3.7 RUN apk --no-cache add curl COPY target/cryptonaut*.jar cryptonaut.jar CMD java ${JAVA_OPTS} -jar cryptonaut.jar 

खैर, यह मजेदार और सराहनीय है। हमें तुरंत उत्पादन / INT / QA / जो भी पर्यावरण के लिए एप्लिकेशन को आउटपुट करने के लिए एक उपकरण प्रदान किया गया था। इसके लिए, परियोजना के लिए एक मानसिक प्लस संकेत।

यह मावेन द्वारा परियोजना को इकट्ठा करने के लिए पर्याप्त है, फिर डॉकर छवि को इकट्ठा करें और इसे अपनी डॉकर रजिस्ट्री में प्रकाशित करें, या बस छवि को अपने सीआई सिस्टम के विकल्प के रूप में बाइनरी निर्यात करें, यही आप चाहते हैं।

संसाधन फ़ोल्डर में, हमने एप्लिकेशन कॉन्फ़िगरेशन पैरामीटर (वसंत में आवेदन के अनुरूप) के साथ एक रिक्त भी तैयार किया, साथ ही लॉगबैक लाइब्रेरी के लिए एक कॉन्फ़िगरेशन फ़ाइल भी। कूल!

हम आवेदन के प्रवेश बिंदु पर जाते हैं और कक्षा का अध्ययन करते हैं। हम स्प्रिंग बूट से दर्द से परिचित एक तस्वीर देखते हैं। इधर, ढांचे के डेवलपर्स ने भी कुछ भी आविष्कार और आविष्कार करना शुरू नहीं किया।

 public static void main(String[] args) throws IOException { Micronaut.run(Application.class); } 

परिचित स्प्रिंग कोड के साथ तुलना करें।

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

यानी हम उन सभी फलियों के साथ IoC कंटेनर भी उठाते हैं जो काम में आवश्यक रूप से शामिल हैं। आधिकारिक दस्तावेज के अनुसार थोड़ा चलने के बाद, हम धीरे-धीरे विकास शुरू करते हैं।

हमें आवश्यकता होगी:

1. डोमेन मॉडल
2. REST API को कार्यान्वित करने के लिए नियंत्रक।
3. डेटा संग्रहण परत (डेटाबेस क्लाइंट या ORM या कुछ और)
4. क्रिप्टोक्यूरेंसी एक्सचेंजों से डेटा के उपभोक्ताओं का एक कोड, साथ ही साथ फिएट मुद्रा विनिमय से डेटा। यानी हमें 3rd पार्टी सेवाओं के लिए सबसे सरल क्लाइंट लिखने की आवश्यकता है। वसंत में, प्रसिद्ध रेस्टेमप्लेट ने इस भूमिका को अच्छी तरह से अनुकूल किया।
5. लचीले प्रबंधन और अनुप्रयोग प्रारंभ के लिए न्यूनतम कॉन्फ़िगरेशन (आइए विचार करें कि हम क्या और कैसे कॉन्फ़िगरेशन करेंगे)
6. टेस्ट! हां, आत्मविश्वास से और सुरक्षित रूप से कोड को रीचार्ज करने और नई कार्यक्षमता को लागू करने के लिए, हमें पुराने की स्थिरता के बारे में सुनिश्चित होना चाहिए
7. भंडारित करता है। यह एक बुनियादी आवश्यकता नहीं है, लेकिन ऐसा कुछ है जो अच्छे प्रदर्शन के लिए अच्छा होगा, और हमारे परिदृश्य में ऐसे स्थान हैं जहां कैशिंग निश्चित रूप से एक अच्छा उपकरण है।
   Spoiler: यहां सब कुछ बहुत खराब हो जाएगा।

डोमेन मॉडल

हमारे उद्देश्यों के लिए, निम्नलिखित मॉडल पर्याप्त होंगे: एक क्रिप्टोक्यूरेंसी पोर्टफोलियो के मॉडल, एक जोड़ी मुद्रा विनिमय दर, क्रिप्टोक्यूरेंसी की कीमतों में फ़िएट मुद्रा में, और पोर्टफोलियो का कुल मूल्य।

नीचे केवल कुछ मॉडलों का कोड है, बाकी को रिपॉजिटरी में देखा जा सकता है । और हां, मैं इस परियोजना में लोम्बोक को पेंच करने के लिए बहुत आलसी था।

 Portfolio.java package com.room606.cryptonaut.domain; import java.math.BigDecimal; import java.util.Collections; import java.util.Map; import java.util.TreeMap; public class Portfolio { private Map<String, BigDecimal> coins = Collections.emptyMap(); public Map<String, BigDecimal> getCoins() { return new TreeMap<>(coins); } public void setCoins(Map<String, BigDecimal> coins) { this.coins = coins; } 

 FiatRate.java package com.room606.cryptonaut.domain; import java.math.BigDecimal; public class FiatRate { private String base; private String counter; private BigDecimal value; public FiatRate(String base, String counter, BigDecimal value) { this.base = base; this.counter = counter; this.value = value; } public String getBase() { return base; } public void setBase(String base) { this.base = base; } public String getCounter() { return counter; } public void setCounter(String counter) { this.counter = counter; } public BigDecimal getValue() { return value; } public void setValue(BigDecimal value) { this.value = value; } } 

 Price.java ... Prices.java () ... Total.java ... 

नियंत्रकों

हम एक नियंत्रक लिखने की कोशिश कर रहे हैं जो सरलतम एपीआई को लागू करता है, सिक्कों के दिए गए पत्र कोड के अनुसार क्रिप्टोकरेंसी का मूल्य जारी करता है।
यानी

 GET /cryptonaut/restapi/prices.json?coins=BTC&coins=ETH&fiatCurrency=RUR 

कुछ का उत्पादन करना चाहिए:

 {"prices":[{"coin":"BTC","value":407924.043300000000},{"coin":"ETH","value":13040.638266000000}],"fiatCurrency":"RUR"} 

प्रलेखन के अनुसार, कुछ भी जटिल नहीं है और एक ही Spring दृष्टिकोण और सम्मेलनों की याद दिलाता है:

 package com.room606.cryptonaut.rest; import com.room606.cryptonaut.domain.Price; import com.room606.cryptonaut.domain.Prices; import com.room606.cryptonaut.markets.FiatExchangeRatesService; import com.room606.cryptonaut.markets.CryptoMarketDataService; import io.micronaut.http.MediaType; import io.micronaut.http.annotation.*; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; @Controller("/cryptonaut/restapi/") public class MarketDataController { private final CryptoMarketDataService cryptoMarketDataService; private final FiatExchangeRatesService fiatExchangeRatesService; public MarketDataController(CryptoMarketDataService cryptoMarketDataService, FiatExchangeRatesService fiatExchangeRatesService) { this.cryptoMarketDataService = cryptoMarketDataService; this.fiatExchangeRatesService = fiatExchangeRatesService; } @Get("/prices.json") @Produces(MediaType.APPLICATION_JSON) public Prices pricesAsJson(@QueryValue("coins") String[] coins, @QueryValue("fiatCurrency") String fiatCurrency) { return getPrices(coins, fiatCurrency); } private Prices getPrices(String[] coins, String fiatCurrency) { List<Price> prices = Stream.of(coins) .map(coin -> new Price(coin, cryptoMarketDataService.getPrice(coin, fiatCurrency))) .collect(Collectors.toList()); return new Prices(prices, fiatCurrency); } } 

यानी हम शांति से अपने POJO को लौटाए गए प्रकार के रूप में निर्दिष्ट करते हैं, और बिना किसी क्रमिक / deserializers को कॉन्फ़िगर किए बिना, यहां तक ​​कि अतिरिक्त एनोटेशन को लटकाए बिना भी बॉक्स से डेटा के साथ सही http बॉडी बनाएंगे। चलो Spring रास्ते से तुलना करें:

 @RequestMapping(value = "/prices.json", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE) public ResponseEntity<Prices> pricesAsJson(@RequestParam("userId") final String[] coins, @RequestParam("fiatCurrency") String fiatCurrency) { 

प्रलेखन के अनुसार, सामान्य तौर पर, मुझे नियंत्रकों के साथ कोई समस्या नहीं थी, उन्होंने सिर्फ उनसे अपेक्षा के अनुरूप काम किया। उनकी वर्तनी सहज और सरल थी। हम आगे बढ़ते हैं।

डेटा भंडारण परत

एप्लिकेशन के पहले संस्करण के लिए, हम केवल उपयोगकर्ता के पोर्टफोलियो को संग्रहीत करेंगे। सामान्य तौर पर, हम एक उपयोगकर्ता का केवल एक ही पोर्टफोलियो रखेंगे। सीधे शब्दों में कहें, तो हमारे पास अभी भी कई उपयोगकर्ताओं का समर्थन नहीं है, केवल एक मुख्य उपयोगकर्ता क्रिप्टोकरेंसी के अपने पोर्टफोलियो के साथ है। यह कमाल है!

डेटा दृढ़ता को लागू करने के लिए, प्रलेखन जेपीए कनेक्शन के साथ-साथ डेटाबेस से पढ़ने के लिए विभिन्न ग्राहकों का उपयोग करने के खंडित उदाहरण (अनुभाग "12.1.5 कॉन्फ़िगर पोस्टग्रेज") के विकल्प प्रदान करता है। JPA निर्णायक रूप से खारिज कर दिया गया था और प्रश्नों को लिखने और हेरफेर करने को प्राथमिकता दी गई थी। दस्तावेज़ीकरण के अनुसार डेटाबेस कॉन्फ़िगरेशन को application.yml में जोड़ा गया था, ( Postgres को RDBMS के रूप में चुना गया था):

 postgres: reactive: client: port: 5432 host: localhost database: cryptonaut user: crypto password: r1ch13r1ch maxSize: 5 

postgres-reactive लाइब्रेरी के आधार पर जोड़ा गया था। यह एक अतुल्यकालिक तरीके से और एक तुल्यकालिक में डेटाबेस के साथ काम करने के लिए एक ग्राहक है।

 <dependency> <groupId>io.micronaut.configuration</groupId> <artifactId>postgres-reactive</artifactId> <version>1.0.0.M4</version> <scope>compile</scope> </dependency> 

और अंत में, हमारे आवेदन के भविष्य के वातावरण को तैनात करने के लिए docker-compose.yml फ़ाइल docker-compose.yml फ़ोल्डर में जोड़ा गया था, जहां डेटाबेस घटक जोड़ा गया था:

 db: image: postgres:9.6 restart: always environment: POSTGRES_USER: crypto POSTGRES_PASSWORD: r1ch13r1ch POSTGRES_DB: cryptonaut ports: - 5432:5432 volumes: - ${PWD}/../db/init_tables.sql:/docker-entrypoint-initdb.d/1.0.0_init_tables.sql 

नीचे एक बहुत ही सरल टेबल संरचना के साथ डेटाबेस के लिए आरंभीकरण स्क्रिप्ट है:

 CREATE TABLE portfolio ( id serial CONSTRAINT coin_amt_primary_key PRIMARY KEY, coin varchar(16) NOT NULL UNIQUE, amount NUMERIC NOT NULL ); 

अब उपयोगकर्ता के पोर्टफोलियो को अपडेट करने वाले कोड को फेंकने का प्रयास करते हैं। हमारे पोर्टफोलियो घटक इस तरह दिखेगा:

 package com.room606.cryptonaut; import com.room606.cryptonaut.domain.Portfolio; import java.math.BigDecimal; import java.util.Optional; public interface PortfolioService { Portfolio savePortfolio(Portfolio portfolio); Portfolio loadPortfolio(); Optional<BigDecimal> calculateTotalValue(Portfolio portfolio, String fiatCurrency); } 

Postgres reactive client विधियों के सेट को देखते हुए, हम इस वर्ग को फेंक रहे हैं:

 package com.room606.cryptonaut; import com.room606.cryptonaut.domain.Portfolio; import com.room606.cryptonaut.markets.CryptoMarketDataService; import io.micronaut.context.annotation.Requires; import io.reactiverse.pgclient.Numeric; import io.reactiverse.reactivex.pgclient.*; import javax.inject.Inject; import java.math.BigDecimal; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; public class PortfolioServiceImpl implements PortfolioService { private final PgPool pgPool; ... private static final String UPDATE_COIN_AMT = "INSERT INTO portfolio (coin, amount) VALUES (?, ?) ON CONFLICT (coin) " + "DO UPDATE SET amount = ?"; ... public Portfolio savePortfolio(Portfolio portfolio) { List<Tuple> records = portfolio.getCoins() .entrySet() .stream() .map(entry -> Tuple.of(entry.getKey(), Numeric.create(entry.getValue()), Numeric.create(entry.getValue()))) .collect(Collectors.toList()); pgPool.preparedBatch(UPDATE_COIN_AMT, records, pgRowSetAsyncResult -> { //   pgRowSetAsyncResult.cause().printStackTrace(); }); return portfolio; } ... } 

एक पर्यावरण शुरू करता है, हम अपने पोर्टफोलियो को पहले से समझदारी से लागू एपीआई के माध्यम से अपडेट करने की कोशिश करते हैं:

 package com.room606.cryptonaut.rest; import com.room606.cryptonaut.PortfolioService; import com.room606.cryptonaut.domain.Portfolio; import io.micronaut.http.MediaType; import io.micronaut.http.annotation.*; import javax.inject.Inject; @Controller("/cryptonaut/restapi/") public class ConfigController { @Inject private PortfolioService portfolioService; @Post("/portfolio") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public Portfolio savePortfolio(@Body Portfolio portfolio) { return portfolioService.savePortfolio(portfolio); } 

curl अनुरोध करें:

 curl http://localhost:8080/cryptonaut/restapi/portfolio -X POST -H "Content-Type: application/json" --data '{"coins": {"XRP": "35.5", "LSK": "5.03", "XEM": "16.23"}}' -v 

और ... लॉग में त्रुटि पकड़:

 io.reactiverse.pgclient.PgException: syntax error at or near "," at io.reactiverse.pgclient.impl.PrepareStatementCommand.handleErrorResponse(PrepareStatementCommand.java:74) at io.reactiverse.pgclient.impl.codec.decoder.MessageDecoder.decodeError(MessageDecoder.java:250) at io.reactiverse.pgclient.impl.codec.decoder.MessageDecoder.decodeMessage(MessageDecoder.java:139) ... 

हमारे शलजम को खंगालने के बाद, हमें आधिकारिक गोदी में कोई समाधान नहीं मिलता है, हम postgres-reactive लाइब्रेरी पर डॉक को गूगल करने का प्रयास करते हैं, और यह सही समाधान है, उदाहरण के लिए और सही क्वेरी सिंटैक्स को विस्तार से दिया गया है। यह प्लेसहोल्डर-मापदंडों का मामला था, यह पता चला है, आपको फॉर्म के गिने हुए लेबल का उपयोग करने की आवश्यकता है $x ($1, $2, etc.) । तो, लक्ष्य अनुरोध को फिर से लिखना है:

 private static final String UPDATE_COIN_AMT = "INSERT INTO portfolio (coin, amount) VALUES ($1, $2) ON CONFLICT (coin) " + "DO UPDATE SET amount = $3"; 

हम एप्लिकेशन को पुनः आरंभ करते हैं, उसी REST अनुरोध ... चीयर्स का प्रयास करें। डेटा को जोड़ा जाता है। चलिए पढ़ते हैं।

हमें डेटाबेस से किसी उपयोगकर्ता की क्रिप्टोकरेंसी के पोर्टफोलियो को पढ़ने और पीओजेओ ऑब्जेक्ट पर मैप करने के सबसे सरल कार्य के साथ सामना करना पड़ता है। इन उद्देश्यों के लिए, हम pgPool.query विधि (SELECT_COINS_AMTS, pgRowSetAsyncResult) का उपयोग करते हैं:

 public Portfolio loadPortfolio() { Map<String, BigDecimal> coins = new HashMap<>(); pgPool.query(SELECT_COINS_AMTS, pgRowSetAsyncResult -> { if (pgRowSetAsyncResult.succeeded()) { PgRowSet rows = pgRowSetAsyncResult.result(); PgIterator pgIterator = rows.iterator(); while (pgIterator.hasNext()) { Row row = pgIterator.next(); coins.put(row.getString("coin"), new BigDecimal(row.getFloat("amount"))); } } else { System.out.println("Failure: " + pgRowSetAsyncResult.cause().getMessage()); } }); Portfolio portfolio = new Portfolio(); portfolio.setCoins(coins); return portfolio; } 

हम क्रिप्टोक्यूरेंसी पोर्टफोलियो के लिए जिम्मेदार नियंत्रक के साथ यह सब एक साथ जोड़ते हैं:

 @Controller("/cryptonaut/restapi/") public class ConfigController { ... @Get("/portfolio") @Produces(MediaType.APPLICATION_JSON) public Portfolio loadPortfolio() { return portfolioService.loadPortfolio(); } ... 

सेवा को पुनरारंभ करें। परीक्षण के लिए, हम पहले इस पोर्टफोलियो को कम से कम कुछ डेटा के साथ भरते हैं:

 curl http://localhost:8080/cryptonaut/restapi/portfolio -X POST -H "Content-Type: application/json" --data '{"coins": {"XRP": "35.5", "LSK": "5.03", "XEM": "16.23"}}' -v 

अब अंत में डेटाबेस से हमारे कोड रीडिंग का परीक्षण करें:

 curl http://localhost:8080/cryptonaut/restapi/portfolio -v 

और ... हमें मिलता है ... कुछ अजीब:

 {"coins":{}} 

बहुत अजीब है ना? हम अनुरोध को दस बार curl हैं, curl अनुरोध को फिर से करने का प्रयास करें, यहां तक ​​कि हमारी सेवा को फिर से शुरू करें। परिणाम अभी भी वही जंगली है ... विधि के हस्ताक्षर को फिर से पढ़ने के बाद, और यह भी याद रखना कि हमारे पास एक Reactive Pg client , हम इस निष्कर्ष पर आते हैं कि हम एसिंक्रनाइज़ेशन के साथ काम कर रहे हैं। विचारशील बहस ने इसकी पुष्टि की! यह थोड़ा इत्मीनान से डे-कोड के लायक था, जैसे कि वॉइला, हमें गैर-खाली डेटा मिला!

लाइब्रेरी डॉक की ओर फिर से मुड़ते हुए, हमारी आस्तीन को ऊपर उठाते हुए, हम एक सच्चे अवरोधक कोड के साथ कोड को फिर से लिखते हैं, लेकिन पूरी तरह से भविष्यवाणी करते हैं:

 Map<String, BigDecimal> coins = new HashMap<>(); PgIterator pgIterator = pgPool.rxPreparedQuery(SELECT_COINS_AMTS).blockingGet().iterator(); while (pgIterator.hasNext()) { Row row = pgIterator.next(); coins.put(row.getString("coin"), new BigDecimal(row.getValue("amount").toString())); } 

अब हमें वह मिलता है जिसकी हम अपेक्षा करते हैं। हमने इस समस्या का फैसला किया, आगे बढ़ें।

हम बाजार डेटा प्राप्त करने के लिए क्लाइंट लिखते हैं

यहां, निश्चित रूप से, मैं कम से कम बाइक के साथ समस्या को हल करना चाहूंगा। परिणाम दो समाधान हैं:

• विशिष्ट क्रिप्टो एक्सचेंजों तक पहुंचने के लिए तैयार ग्राहक पुस्तकालय
• विनिमय दर के लिए आवेदन करने के लिए एक छोटे ग्राहक का अपना कोड। क्या बॉक्स से बाहर आ गया है।

तैयार पुस्तकालयों के साथ, सब कुछ इतना दिलचस्प नहीं है। मैं केवल ध्यान देता हूं कि एक त्वरित खोज के दौरान, परियोजना https://github.com/knowm/XChange का चयन किया गया था।

सिद्धांत रूप में, लाइब्रेरी आर्किटेक्चर तीन पेनी के रूप में सरल है - डेटा प्राप्त करने के लिए इंटरफेस का एक सेट है, Ticker जैसे मुख्य इंटरफेस और मॉडल कक्षाएं (आप bid सकते हैं, ask सकते हैं, सभी प्रकार की खुली कीमत, करीबी मूल्य आदि), CurrencyPair , Currency । इसके अलावा, आप कोड में खुद को इनिशियलाइज़ेशन इनिशियलाइज़ करते हैं, पहले से डिपेंडेंसी को इम्प्लीमेंटेशन से जोड़ते हैं जो एक विशिष्ट क्रिप्टोकरंसी को संदर्भित करता है। और हमारे द्वारा संचालित मुख्य वर्ग MarketDataService.java

उदाहरण के लिए, हमारे प्रयोगों के लिए, शुरुआत के लिए, हम ऐसे "कॉन्फ़िगरेशन" से संतुष्ट हैं:

 <dependency> <groupId>org.knowm.xchange</groupId> <artifactId>xchange-core</artifactId> <version>4.3.10</version> </dependency> <dependency> <groupId>org.knowm.xchange</groupId> <artifactId>xchange-bittrex</artifactId> <version>4.3.10</version> </dependency> 

नीचे एक महत्वपूर्ण कार्य करने वाला कोड है - विशेष शब्दों में किसी विशेष क्रिप्टोकरेंसी की लागत की गणना करना (आवश्यकताओं ब्लॉक में लेख की शुरुआत में वर्णित सूत्र देखें):

 package com.room606.cryptonaut.markets; import com.room606.cryptonaut.exceptions.CryptonautException; import org.knowm.xchange.currency.Currency; import org.knowm.xchange.currency.CurrencyPair; import org.knowm.xchange.dto.marketdata.Ticker; import org.knowm.xchange.exceptions.CurrencyPairNotValidException; import org.knowm.xchange.service.marketdata.MarketDataService; import javax.inject.Inject; import javax.inject.Singleton; import java.io.IOException; import java.math.BigDecimal; @Singleton public class CryptoMarketDataService { private final FiatExchangeRatesService fiatExchangeRatesService; private final MarketDataService marketDataService; @Inject public CryptoMarketDataService(FiatExchangeRatesService fiatExchangeRatesService, MarketDataServiceFactory marketDataServiceFactory) { this.fiatExchangeRatesService = fiatExchangeRatesService; this.marketDataService = marketDataServiceFactory.getMarketDataService(); } public BigDecimal getPrice(String coinCode, String fiatCurrencyCode) throws CryptonautException { BigDecimal price = getPriceForBasicCurrency(coinCode, Currency.USD.getCurrencyCode()); if (Currency.USD.equals(new Currency(fiatCurrencyCode))) { return price; } else { return price.multiply(fiatExchangeRatesService.getFiatPrice(Currency.USD.getCurrencyCode(), fiatCurrencyCode)); } } private BigDecimal getPriceForBasicCurrency(String coinCode, String fiatCurrencyCode) throws CryptonautException { Ticker ticker = null; try { ticker = marketDataService.getTicker(new CurrencyPair(new Currency(coinCode), new Currency(fiatCurrencyCode))); return ticker.getBid(); } catch (CurrencyPairNotValidException e) { ticker = getTicker(new Currency(coinCode), Currency.BTC); Ticker ticker2 = getTicker(Currency.BTC, new Currency(fiatCurrencyCode)); return ticker.getBid().multiply(ticker2.getBid()); } catch (IOException e) { throw new CryptonautException("Failed to get price for Pair " + coinCode + "/" + fiatCurrencyCode + ": " + e.getMessage(), e); } } private Ticker getTicker(Currency base, Currency counter) throws CryptonautException { try { return marketDataService.getTicker(new CurrencyPair(base, counter)); } catch (CurrencyPairNotValidException | IOException e) { throw new CryptonautException("Failed to get price for Pair " + base.getCurrencyCode() + "/" + counter.getCurrencyCode() + ": " + e.getMessage(), e); } } } 

प्रोजेक्ट https://github.com/knowm/XChange द्वारा प्रदान किए गए विशिष्ट कार्यान्वयनों को थोड़ा अनदेखा करने के लिए हमारे स्वयं के इंटरफेस का उपयोग करके संभव हो गया है।

इस तथ्य के मद्देनजर कि कई पर, यदि सभी क्रिप्टोक्यूरेंसी एक्सचेंज नहीं करते हैं, तो प्रचलन में केवल fiat मुद्राओं का एक सीमित सेट है (उपयोगकर्ता के प्रश्न के अंतिम उत्तर के लिए, USD (, EUR, शायद यह सब ..), एक अन्य डेटा स्रोत को जोड़ने के लिए आवश्यक है - fiat मुद्रा दरें, और एक वैकल्पिक कनवर्टर भी। यानी इस सवाल का जवाब देने के लिए, आरटीआर (लक्ष्य मुद्रा, लक्ष्य मुद्रा) में डब्ल्यूटीएफ क्रिप्टोक्यूरेंसी की लागत अब कितनी है, आपको दो उप-प्रश्नों का उत्तर देना होगा: डब्ल्यूटीएफ / बेससीरिएशन (हम यूएसडी को इस तरह मानते हैं), बेसकेंप्रि / न्यूरल, फिर इन दो मूल्यों को गुणा करें और परिणामस्वरूप उत्पन्न करें।

सेवा के हमारे पहले संस्करण के लिए, हम केवल लक्षित मुद्राओं के रूप में यूएसडी और आरयूआर का समर्थन करेंगे।
इसलिए, आरयूआर का समर्थन करने के लिए, उन स्रोतों को लेना उचित होगा जो सेवा की भौगोलिक स्थिति के लिए प्रासंगिक हैं (हम रूस में इसे विशेष रूप से होस्ट और उपयोग करेंगे)। संक्षेप में, सेंट्रल बैंक की दर हमारे अनुरूप होगी। इस तरह के डेटा का एक खुला स्रोत इंटरनेट पर पाया गया, जिसे JSON के रूप में सेवन किया जा सकता है। ठीक।

नीचे वर्तमान विनिमय दर अनुरोध के लिए सेवा की प्रतिक्रिया है:

 { "Date": "2018-10-16T11:30:00+03:00", "PreviousDate": "2018-10-13T11:30:00+03:00", "PreviousURL": "\/\/www.cbr-xml-daily.ru\/archive\/2018\/10\/13\/daily_json.js", "Timestamp": "2018-10-15T23:00:00+03:00", "Valute": { "AUD": { "ID": "R01010", "NumCode": "036", "CharCode": "AUD", "Nominal": 1, "Name": "ђІЃ‚Ђ°»№Ѓє№ ґѕ»»°Ђ", "Value": 46.8672, "Previous": 46.9677 }, "AZN": { "ID": "R01020A", "NumCode": "944", "CharCode": "AZN", "Nominal": 1, "Name": "ђ·µЂ±°№ґ¶°ЅЃє№ ј°Ѕ°‚", "Value": 38.7567, "Previous": 38.8889 }, "GBP": { "ID": "R01035", "NumCode": "826", "CharCode": "GBP", "Nominal": 1, "Name": "¤ѓЅ‚ Ѓ‚µЂ»ЅіѕІ ЎѕµґЅµЅЅѕіѕ єѕЂѕ»µІЃ‚І°", "Value": 86.2716, "Previous": 87.2059 }, ... 

दरअसल, नीचे CbrExchangeRatesClient क्लाइंट CbrExchangeRatesClient :

 package com.room606.cryptonaut.markets.clients; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectReader; import com.room606.cryptonaut.exceptions.CryptonautException; import io.micronaut.http.HttpRequest; import io.micronaut.http.client.Client; import io.micronaut.http.client.RxHttpClient; import javax.inject.Inject; import javax.inject.Singleton; import java.io.IOException; import java.math.BigDecimal; import java.util.*; @Singleton public class CbrExchangeRatesClient { private static final String CBR_DATA_URI = "https://www.cbr-xml-daily.ru/daily_json.js"; @Client(CBR_DATA_URI) @Inject private RxHttpClient httpClient; private final ObjectReader objectReader = new ObjectMapper().reader(); public Map<String, BigDecimal> getRates() { try { //return ratesCache.get("fiatRates"); HttpRequest<?> req = HttpRequest.GET(""); String response = httpClient.retrieve(req, String.class).blockingSingle(); JsonNode json = objectReader.readTree(response); String usdPrice = json.get("Valute").get("USD").get("Value").asText(); String eurPrice = json.get("Valute").get("EUR").get("Value").asText(); String gbpPrice = json.get("Valute").get("GBP").get("Value").asText(); Map<String, BigDecimal> prices = new HashMap<>(); prices.put("USD", new BigDecimal(usdPrice)); prices.put("GBP", new BigDecimal(gbpPrice)); prices.put("EUR", new BigDecimal(eurPrice)); return prices; } catch (IOException e) { throw new CryptonautException("Failed to obtain exchange rates: " + e.getMessage(), e); } } } 

यहाँ हम RxHttpClient इंजेक्षन RxHttpClient , जो कि RxHttpClient Micronaut एक घटक है। यह हमें अतुल्यकालिक अनुरोध प्रसंस्करण या अवरुद्ध करने का विकल्प भी देता है। हम क्लासिक ब्लॉकिंग का चयन करते हैं:

 httpClient.retrieve(req, String.class).blockingSingle(); 

विन्यास

किसी प्रोजेक्ट में, आप व्यावसायिक तर्क या कुछ विशिष्ट पहलुओं को बदलने और प्रभावित करने वाली चीजों को उजागर कर सकते हैं। आइए एक संपत्ति के रूप में समर्थित फिएट मुद्राओं की एक सूची बनाएं और आवेदन की शुरुआत में इसे इंजेक्ट करें।

निम्नलिखित कोड मुद्रा कोड को छोड़ देगा जिसके लिए हम अभी तक पोर्टफोलियो मूल्य की गणना करने में सक्षम नहीं हैं:

 public BigDecimal getFiatPrice(String baseCurrency, String counterCurrency) throws NotSupportedFiatException { if (!supportedCounterCurrencies.contains(counterCurrency)) { throw new NotSupportedFiatException("Counter currency not supported: " + counterCurrency); } Map<String, BigDecimal> rates = cbrExchangeRatesClient.getRates(); return rates.get(baseCurrency); } 

तदनुसार, हमारा इरादा किसी भी तरह से application.yml से मान को इंजेक्ट करने के लिए है।

पहले संस्करण में, इस तरह के कोड को FiatExchangeRatesService.java वर्ग के क्षेत्र के नीचे लिखा गया था:

 @Value("${cryptonaut.currencies:RUR}") private String supportedCurrencies; private final List<String> supportedCounterCurrencies = Arrays.asList(supportedCurrencies.split("[,]", -1)); 

यहाँ, placeholder application.yml की निम्न संरचना से मेल खाता है। placeholder दस्तावेज:

 micronaut: application: name: cryptonaut #Uncomment to set server port server: port: 8080 postgres: reactive: client: port: 5432 host: localhost database: cryptonaut user: crypto password: r1ch13r1ch maxSize: 5 # app / business logic specific properties cryptonaut: currencies: "RUR" 

एप्लिकेशन लॉन्च, त्वरित धूम्रपान परीक्षण ... त्रुटि!

 Caused by: io.micronaut.context.exceptions.BeanInstantiationException: Error instantiating bean of type [com.room606.cryptonaut.markets.CryptoMarketDataService] Path Taken: new MarketDataController([CryptoMarketDataService cryptoMarketDataService],FiatExchangeRatesService fiatExchangeRatesService) --> new CryptoMarketDataService([FiatExchangeRatesService fiatExchangeRatesService],MarketDataServiceFactory marketDataServiceFactory) at io.micronaut.context.DefaultBeanContext.doCreateBean(DefaultBeanContext.java:1266) at io.micronaut.context.DefaultBeanContext.createAndRegisterSingleton(DefaultBeanContext.java:1677) at io.micronaut.context.DefaultBeanContext.getBeanForDefinition(DefaultBeanContext.java:1447) at io.micronaut.context.DefaultBeanContext.getBeanInternal(DefaultBeanContext.java:1427) at io.micronaut.context.DefaultBeanContext.getBean(DefaultBeanContext.java:852) at io.micronaut.context.AbstractBeanDefinition.getBeanForConstructorArgument(AbstractBeanDefinition.java:943) ... 36 common frames omitted Caused by: java.lang.NullPointerException: null at com.room606.cryptonaut.markets.FiatExchangeRatesService.<init>(FiatExchangeRatesService.java:20) at com.room606.cryptonaut.markets.$FiatExchangeRatesServiceDefinition.build(Unknown Source) at io.micronaut.context.DefaultBeanContext.doCreateBean(DefaultBeanContext.java:1252) ... 41 common frames omitted 

Micronaut Spring , compile time . , :

 @Value("${cryptonaut.currencies:RUR}") private String supportedCurrencies; private List<String> supportedCounterCurrencies; @PostConstruct void init() { supportedCounterCurrencies = Arrays.asList(supportedCurrencies.split("[,]", -1)); } 

, – javax.annotation.PostConstruct , , , , . .

, , Spring. micronaut @Property Map<String, String> , @Configuration , Random Properties (, ID , , - ) PropertySourceLoader , .. . Spring – ApplicationContext ( xml , web , groovy , ClassPath etc.) , .

, micronaut. Embedded Server feature, Groovy Spock . Java , groovy- . , EmbeddedServer + HttpClient Micronaut API —

 GET /cryptonaut/restapi/portfolio/total.json?fiatCurrency={x} 

API, .

:

 public class PortfolioReportsControllerTest { private static EmbeddedServer server; private static HttpClient client; @Inject private PortfolioService portfolioService; @BeforeClass public static void setupServer() { server = ApplicationContext.run(EmbeddedServer.class); client = server .getApplicationContext() .createBean(HttpClient.class, server.getURL()); } @AfterClass public static void stopServer() { if(server != null) { server.stop(); } if(client != null) { client.stop(); } } @Test public void total() { //TODO: Seems like code smell. I don't like it.. portfolioService = server.getApplicationContext().getBean(PortfolioService.class); Portfolio portfolio = new Portfolio(); Map<String, BigDecimal> coins = new HashMap<>(); BigDecimal amt1 = new BigDecimal("570.05"); BigDecimal amt2 = new BigDecimal("2.5"); coins.put("XRP", amt1); coins.put("QTUM", amt2); portfolio.setCoins(coins); portfolioService.savePortfolio(portfolio); HttpRequest request = HttpRequest.GET("/cryptonaut/restapi/portfolio/total.json?fiatCurrency=USD"); HttpResponse<Total> rsp = client.toBlocking().exchange(request, Total.class); assertEquals(200, rsp.status().getCode()); assertEquals(MediaType.APPLICATION_JSON_TYPE, rsp.getContentType().get()); Total val = rsp.body(); assertEquals("USD", val.getFiatCurrency()); assertEquals(TEST_VALUE.toString(), val.getValue().toString()); assertEquals(amt1.toString(), val.getPortfolio().getCoins().get("XRP").toString()); assertEquals(amt2.toString(), val.getPortfolio().getCoins().get("QTUM").toString()); } } 

, mock PortfolioService.java :

 package com.room606.cryptonaut; import com.room606.cryptonaut.domain.Portfolio; import io.micronaut.context.annotation.Requires; import javax.inject.Singleton; import java.math.BigDecimal; import java.util.Optional; @Singleton @Requires(env="test") public class MockPortfolioService implements PortfolioService { private Portfolio portfolio; public static final BigDecimal TEST_VALUE = new BigDecimal("56.65"); @Override public Portfolio savePortfolio(Portfolio portfolio) { this.portfolio = portfolio; return portfolio; } @Override public Portfolio loadPortfolio() { return portfolio; } @Override public Optional<BigDecimal> calculateTotalValue(Portfolio portfolio, String fiatCurrency) { return Optional.of(TEST_VALUE); } } 

@Requires(env="test") , Application Context . -, micronaut test, , . , , PortfolioServiceImpl @Requires(notEnv="test") . – . Micronaut .

, – , , – mockito . :

 @Test public void priceForUsdDirectRate() throws IOException { when(marketDataServiceFactory.getMarketDataService()).thenReturn(marketDataService); String coinCode = "ETH"; String fiatCurrencyCode = "USD"; BigDecimal priceA = new BigDecimal("218.58"); Ticker targetTicker = new Ticker.Builder().bid(priceA).build(); when(marketDataService.getTicker(new CurrencyPair(new Currency(coinCode), new Currency(fiatCurrencyCode)))).thenReturn(targetTicker); CryptoMarketDataService cryptoMarketDataService = new CryptoMarketDataService(fiatExchangeRatesService, marketDataServiceFactory); assertEquals(priceA, cryptoMarketDataService.getPrice(coinCode, fiatCurrencyCode)); } 

, . . , . , , - IP. , @Cacheable .

, . , ( appliction.yml ). redis, Docker- . :

 redis: image: 'bitnami/redis:latest' environment: - ALLOW_EMPTY_PASSWORD=yes ports: - '6379:6379' 

@Cacheable:

 @Cacheable("fiatRates") public Map<String, BigDecimal> getRates() { HttpRequest<?> req = HttpRequest.GET(""); String response = httpClient.retrieve(req, String.class).blockingSingle(); try { JsonNode json = objectReader.readTree(response); String usdPrice = json.get("Valute").get("USD").get("Value").asText(); String eurPrice = json.get("Valute").get("EUR").get("Value").asText(); String gbpPrice = json.get("Valute").get("GBP").get("Value").asText(); Map<String, BigDecimal> prices = new HashMap<>(); prices.put("USD", new BigDecimal(usdPrice)); prices.put("GBP", new BigDecimal(gbpPrice)); prices.put("EUR", new BigDecimal(eurPrice)); return prices; } catch (IOException e) { throw new RuntimeException(e); } } 

application.yml . . :

 caches: fiatrates: expireAfterWrite: "1h" redis: caches: fiatRates: expireAfterWrite: "1h" port: 6379 server: localhost 

:

 #cache redis: uri: localhost:6379 caches: fiatRates: expireAfterWrite: "1h" 

. — “Unexpected error occurred: No cache configured for name: fiatRates”:

 ERROR imhsnetty.RoutingInBoundHandler - Unexpected error occurred: No cache configured for name: fiatRates io.micronaut.context.exceptions.ConfigurationException: No cache configured for name: fiatRates at io.micronaut.cache.DefaultCacheManager.getCache(DefaultCacheManager.java:67) at io.micronaut.cache.interceptor.CacheInterceptor.interceptSync(CacheInterceptor.java:176) at io.micronaut.cache.interceptor.CacheInterceptor.intercept(CacheInterceptor.java:128) at io.micronaut.aop.MethodInterceptor.intercept(MethodInterceptor.java:41) at io.micronaut.aop.chain.InterceptorChain.proceed(InterceptorChain.java:147) at com.room606.cryptonaut.markets.clients.$CbrExchangeRatesClientDefinition$Intercepted.getRates(Unknown Source) at com.room606.cryptonaut.markets.FiatExchangeRatesService.getFiatPrice(FiatExchangeRatesService.java:30) at com.room606.cryptonaut.rest.MarketDataController.index(MarketDataController.java:34) at com.room606.cryptonaut.rest.$MarketDataControllerDefinition$$exec2.invokeInternal(Unknown ... 

GitHub - SO . . , . , . boilerplate-, - Redis - , , Spring Boot , .

, Micronaut – , Spring-.

Disclaimer-: , -, , ( , , , ).

, :

OS: 16.04.1-Ubuntu x86_64 x86_64 x86_64 GNU/Linux
CPU: Intel® Core(TM) i7-7700HQ CPU @ 2.80GHz
Mem: 2 8 Gb DDR4, Speed: 2400 MHz
SSD Disk: PCIe NVMe M.2, 256

:

4. API,
5. API – “” .

– Rest Controller – IoC-, .

“ ” :

	Micronaut	Spring Boot
Avg.(ms)	2708.4	2735.2
cryptonaut (ms)	1082	-

, – 27 Micronaut . , .

?

. , , , – . . Groovy-, , . SO Spring. , , . — . Spring.

:

• Micronaut – service-discovery, AWS
• Java. Kotlin Groovy.

.