Send Multiplex Default with airSlate SignNow

Send multiplex default

and today's installment of spring tips we're gonna go ahead and look at server-sent events service and events or SS er refers to a protocol that allows you to do unidirectional events being pushed from a service down to a client typically a browser-based client a web client it's a useful in that it's done over HTTP a lot of browser supported it's a useful for any kind of unidirectional communication this is different than for example something like WebSockets which requires a separate protocol and awareness of that protocol to both the client and the service I'm not saying one is better or you know more useful together quite the contrary they're both very useful nav they're sort of interesting use cases one thing that's different between WebSockets and service and events is that WebSockets can do bi-directional communication now you may want to use that if you want a more a proper multiplex communication protocol but service sensitive service and events have their uses you can use them in lots of different legacy browsers they work very well in the command line they're easy to set up there HTTP so they require no new protocol and if you're doing anything that is intrinsically status based or event based and you need no replies from the client or if you don't mind those replies coming in via rests and SSE is just fine so imagine your Twitter timeline for example or your Facebook friend graphs of status notifications being updated in the browser these are ideal sort of push only kind of event updates that we can model using sfe I want to use SC in particular in this particular installment of spring tips so that we can compare and contrast their implementation in spring MVC proper versus the the implementation in spring web flex the new reactive web stack instead of spring 5 to this to this summer so let's go ahead and build a regular SC application we'll use the web support and when you spring integration now again spring integration is just what we're using here to produce events we're going to model our we're going to you know build a service and event stream of files arriving in a directory is that all that is that all that real world probably not but again it doesn't really matter what the event source is in this case what we want is to have something that happens asynchronously that we can then bridge and send those and then send back to the to the client as a service end event in both paradigms the reactive paradigm and the default paradigm as you'll see it's well supported in both spring MVC and in the rear spring web blocks but in spring MVC the the implementation feels a little bit different than then the rest of spring and C because spring MVC is based on the servlet API which is intrinsically blocking right where as sending things that may lot last a long time or that may have an infinite duration is just part and parcel of being reactive that's just the everyday programming model your default case is writing code that accommodates that situation so it's much more natural right you're not stepping out of the synchronous you're not stepping out of a particular paradigm that is the paradigm right so let's look at the regular one first we're going to create a rest controller here and the rest controller is going to have an endpoint and let's say SSE emitter okay files and what this is going to be is it's going to be at a Justin a shippi endpoint with a file I'm going to map it to a name give it a unique client name there so I'm going to call it and client if we needed to later and the way to do this is to create an FCM inner we're gonna give it a nice healthy callback here in this case sixty times a thousand seconds or low seconds and we're going to store that as the emitter in a map but we're going to use that map as a sort of staging area a go-between between the weboth front end and they event-driven any synchronous spring integration based back in right so ssese knew concurrent hash map okay and I'm going to say SSE thought put putting in the name as the context with the key and putting that in there and with that done somebody should be able to call this endpoint and a little block the client will block the server side will pass of a try this the this implementation yes is he supported still time served three that one's async support so this is very similar to returning a deferred result or a future or callable in spring and receipt by that that work will be back rounded and handled on the second or separate thread pool which means that the fun and cool one that has handling HTTP requests is still able to carry on right you're not blocking Network so now what we need to do is we need to use the spring integration file inbound adapter here to be aware to be made aware of a changes in a directory and you can see that there are a lot of other supported modules just on my class map here but a lot more besides in the community as well so if you understand how to make this code work and pretty trivial to swap out the inbounded after they filed in that adapter for something what's your liking right so here's our integration flow right if you saw our video on spring integration then you know that this is a pretty common pattern reason the spring integration Java DSL and we're using the integration flows surf entry points into the DSL and in order to make this work we need to provide it a inbound adapter and that inbound adapter is going to point to a directory and the directory it's going to be the result of some configuration so we'll just give it a default value here we'll say that it could be any property called input Deere or it'll be file colon forward slash four slash home directory forward slash desktop for dash in okay so whenever there's a new file in that directory we want sprits print irrigation to publish the message so I'm going to say use the inbound adapter the file inbound adapter pointing it to the in directory helps to create the directory if it doesn't exist and I'm going to create a polar and the polar is going to have a spec and so the spec is going to dictate that requests get processed every 1000 milliseconds there or one second and then once the message comes in we're going to transform it which is going to have a payload it's giving a message with a type of payload and the the paler in this case is going to be file so I want to take the file payload which is a little expecting and call the get absolute path method on that payload so when form it into a string and then we can handle that request that's requests using a service activity or what is called the handle method here right so we use a new generic handler right here and for every message that comes in we're going to visit every single record in the ssese map for each case on SF e SF e dot 10 I'm going to send the path of course this will require try-catch so surround that with try catch throw new run time exception e and there we are that's are fairly simple code all we can do now I think is to remove the lambda or rather to replace the code with a lambda and that should do it that's pretty straightforward so let's go ahead and see what we've got here we've got a rest control endpoint it's going to return an SE sse emitter whenever there's a request for a different name I think it's already there I supposed to just replace it and we're going to publish in a publish a message into each one of these entities whenever a file arrives via the inbound adapter okay so let's go ahead and run this and see it work all right now then we should be able to go to my desktop directory in there we are let's go ahead and start up a test here of client if you will so on the left curl HTP logo localhost 8080 for slash files for slash spring okay so we're going to watch that directory or watch this screen you on the left and now Kristin files touch hi alright there's that touch low touch world etc so each time we create a new file in that directory that appears as an event on the left so that seems do working right and of course this is well supported browser so if you're using Chrome or Safari or whatever it will it'll do the right thing there okay so this is the traditional way of implementing service and events not all that bad and against worth highlighting that the only thing that we need to change on the talks of other system is this bit right here the rest of the code well and presumably this bit if you're not returning a file but the the messaging code is indifferent to the source of the message right of the event so this is the first approach is what we'll call the regular SSE approach now let's look at the same trick the same implementation but done in terms of the reactive web flex stack okay so kill Java okay and we're going to do is we're going to go back to Starbucks fingernail then use spring webflix which is instead of springing the spring spring five which is two later this year so as a result the only support for it in spring boot is in the two data snapshots and we're going to call this the reactive sfe okay and we use reactive web and we use spring integration again I'm going to hit generate and the same is true as last time we're going to use a spring integration inbound file adapter so we need to add that to our class path lest we forget close that out and try some code so this is also a rest controller and here we're using the web support again we're going to say that we want to return all the files for a given name name and when we return a flux of string now fluxes are the type that use interactive support instead of a spring 5 they're based on their from the project's the real active projects via pivotal reactor project they describe a 0 to n valued stream of potentially unlimited data right so they notify you there like a completable future that is more than just one value right that may happen over and over and over and over and over so pass the name variable path variable name whether and what one what we want to do is to respond to an event happening from spring integration so in spring negation see use the new inbound inbound a file and the new event arise we're going to publish that message on a channel and I'm going to have a we're going to have each new client get a new subscriber to that channel and then we'll use that event in the message handler to then write to the to the flux right that's the publisher for the flux so same basic flow for spring integration except that instead of having a handle method we're going to create multiple handle methods a publish subscribe and also let's see curly bracket curly bracket and put here : file colon for slash forward slash home desktop in and I'm going to say files that inbound adapter is equal to in and I'm going to use auto create directory true creates the polar again stick sexpot six rate equals of thousands and here we're going to send the data send the resulting message after transformation on a channel so let's transform it right so get absolute path and then on a channel I'm going to call this files we need to create that channel so beam subscribe local channel files channel and when use a message channels DSL to create a publish/subscribe channel and then use that to connect you know one messaging event based thing to another so I'm going to use any when Sena misses into this channel and whenever somebody makes a request on this we're going to add a new listener to that channel okay so now we say flick thought create sink and the sink is the thing that we're going to write events to but we remember that you reactive since they're active you know handling happens in a an event loop it's not happening in a separate thread pool so we want to make sure that we use a serialized sink because there's a implicitly two different things happening here there's the events happening from Spring innovation which could happen all over multiple threads and there's the event loop happening in the reactor world so want to bridge that with a CLS think I'm going to use that to create a message handler and learn a cause new message handler and whenever a message comes in will take its payload and cast it to a string and that we're going to write that out to the seer life to sink all right like so so I'm going to say call the next method that is to say notify the flux that there's a new value by passing the publisher or the rather the payload now of course this could be a lambda so we can replace that with a lambda that's much easier and in fact we can just do this right becomes pretty clean as well and if we do that when I will do this as well so now we're down to the barest of code right and in fact this could be just a message keep it simple so we want to do now is we want to say files channel but subscribe Handler and that's it Lords turn that as a response now of course you could take care - what if we go strengths right what we what we could take care and we should take care of to disconnect this handler from the channel when the handler is done so we can also say handler or rather here lies but set cancellation whenever though the cancellation on the stream we want to say a Files channel but unsubscribe Hendler okay and then we subscribe it and we return that and that will you know spring web blocks will automatically process that flux it will take that and background it in the same way but this is what you do for everything everything that is multivalued you return the flux in and spring web block so it's really not all that different is the same paradigm we're just used to thinking about it's the default approach as opposed to be a cyclical exceptional poach okay let's go ahead and run this and see what it works now I think that's probably going to fail now that I think of it because I forgot to put the mime type so let's do that here as well okay there we go I'll restart test it we'll go ahead and curl the endpoint HTTP localhost in 84 slash file for - Bob and here we can say touch hi I think that files already there so high ten there we go please 11 12 13 etcetera right but as we do that it's updating on this client ID as well in both cases we achieve the results for sending long-lived IO back to the client it's being back rounded but I think you'll agree that the approach using spring web flux feels more natural and in this case it's possible and a valuable opportunity for us to look at how to bridge a threading based event event-driven sort of code with the sort of event loop based approach for the spring web book web flux project with that thanks very much for watching and we'll see you next time