SpringParadigm

A peek into Observables. Reactive Approach/Principles has unfurled new dimensions of programming to us. Reactive Manifesto being the key, paved the way to approach things with a different eye and with its multilingual dominion we have Rx's omnipresence. For me it all started with RxJava and RxGroovy and now with ProjectReactor providing Specification to build Reactive Systems, Spring too incorporating Reactive principles in its 5th edition and together with Java 9 flow, it is evident that Reactive is gaining both strength and momentum. Even different tools/api now extend their reactive support, be it JDBC, RabbitMQ, Kafka etc. My interaction with the Reactive Dimension has been limited to Observables, Observers/Subscribers accompanied by several other operators. Thats fairly little I can understand and the justification being I am JUST A BEGINNER HERE. From what I understood till now is Observables are the Data Sources and it is through Observers/Subscribers we

The rationale behind detailing the harmony among indivudual components both at the Server and the Client side, so that readers can get a clear picture of different REACTIVE components and their flows. RECATO is built on RxJava and Vert.x . The principles on which these two entities are based out promises Resilliency, Resposiveness, Elasticity, Event Driven Architecture and Asynchronous behaviour. All of these commits towards a more Scalable Architecture. Service Registry is the component through which we invoke commands. Implementations are: 1) VertxServiceRegistry. 2) LocalServiceRegistry. Let’s examine the control flow with VertxServiceRegistry. The Command Execution feature that VertxServiceRegistry provides is due to the implementation of ServiceRegistry interface which provides necessary methods to execute a given Command. With the given Command as input, alongside with ServiceDiscovery , all the records are fetched which are recently updated and having

Reacto – A Function Reactive Microservices Library. Now, when we talk about any Microservice Library, the first thing that pops up in our mind is the service implementation to meet our business ends and along with that the client support to invoke those services. There exists a lot of features that makes this library pretty awesome and with that it must also be admitted that it is also quite easy to learn and start with. The Design Principles that has been followed while developing has been described well in its GITHUB home page. What we will really try,is to understand the orchestration among different components of this library, which in turn will aid in getting idea about Control Flow while we use this toolkit. There are two modules corresponding to Reacto: 1) reacto --> The Client 2) reacto-vertx --> The Server Counter Part. reacto-vertx uses Vert.x for Service Publishing and Service discovery along with other features corresponding to Vert.x The Hear

What’s new in Spring 5? This is the most anticipated ask for any Spring aspirant and to be honest why it shouldn’t be, because Spring is such a awesome framework that we always ask more from it. This time too Spring came with a bunch of interesting and cool features. Java 8 is now an inevitable part of Spring 5 and so here the magic begins. Out of all the features that Spring 5 provides that most interesting ONES seems to me are: 1) Spring is now FUNCTIONAL – Functions are now First Class Citizens and they can passed anywhere. This is where Lambdas comes in. 2) Spring is now REACTIVE – Spring now supports Reactive Extensions (Rx) and it supports the Reactive Manifesto, the concepts on which the Reactive Programming is based. This post is not about the features that Spring 5 embeds. In this post we are going to discuss about a Microservice framework known as REACTO. The main aspect that distinguishes this framework from others is that its Fully FUNCTIONAL and REACTIVE

1) Index creation or deletion: For Nested Type (Index name is Book) and Parent - Child Relationship (Index name is ParChild) @RequestMapping(value="/addIndex",method = RequestMethod.POST) def addBookIndex(@RequestParam(name = "indexName")String indexName){ logger.info "****** Adding Book Index: $indexName in ELASTIC DB......" def result = elasticsearchTemplate.createIndex(indexName) logger.info "****** Result is: $result " result } @RequestMapping(value="/deleteIndex",method = RequestMethod.POST) def deleteBookIndex(@RequestParam(name = "indexName")String indexName){ logger.info "****** Deleting Book Index: $indexName in ELASTIC DB......" def result = elasticsearchTemplate.deleteIndex(indexName) logger.info "****** Result is: $result " result } 2) Creating Mapping Type Whenever we save a doc

ElasticSearch quite a familiar term. The first question that comes in our mind is: 1) What ElasticSearch is? & 2) Why should we use it? So to answer the first question, I would like to describe ElasticSearch as a wrapper over Apache Lucene (Apache Lucene is a high performance, text search engine library written in Java). So, ElasticSearch in its core is a distributed full-text search engine which is incredibly easy to scale (because of its well designed anatomy), returns results at a lightning speed (because of its analyzers which tokenize the texts and creates a reverse indexing just like the indexing of a book, a variety of analyzers are available), schema free in nature and supports JSON. The best part about elastic search which I experienced is all its functionalities are being exposed as REST services. ElasticSearch is a distributed NO SQL database where every input to it goes in JSON format and it has its very own way of storing data in data file