A Short Example of Real-Time Event Streaming Using Spring WebFlux

Darío Carrasquel — Fri, 19 Feb 2021 05:06:09 +0000

Spring WebFlux is a framework for Java that provides support for reactive programming. This framework was created by PIVOTAL, the company behind the development of Spring, and it is based on the Reactor project.

Reactive programming is a paradigm that consists of seeing almost everything as a flow of elements (Stream). Currently, web applications require a lot of dynamism, which means that these applications execute operations in real-time.

Those who have dealt with AJAX in the past, surely remember when the time of the computer was periodically updated. This gave the appearance that everything happened online, it was not necessary to reload the whole page.

Reactive programming follows the Publisher/Subscriber scheme, similar to the Observer design pattern. Consequently, the client doesn't need to make so many requests to the server.

Example

We're going to start by doing a simple but very clear example to show the most basic features of Spring WebFlux. For this, we will use Spring Boot 2 which uses Spring Framework 5.

We can create a starting project in https://start.spring.io

Creation of a RestController

The first thing we're going to do is create a Controller with the @RestController annotation. This Controller will generate random integer numbers every second and then will return them using the Flux object.

The Mono and the Flux objects are the main building blocks of Spring WebFlux. If a particular operation returns a single entity, then the system returns a Mono object. If the operation returns multiple elements, a Flux type represents these elements.

@RestController
public class EventController {

    Logger logger = LoggerFactory.getLogger(EventController.class);

    @GetMapping(value = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<Integer> getNumbers() {
        Random r = new Random();
        int min = 0;
        int max = 32767;
        return Flux.fromStream(Stream.generate(() -> r.nextInt(max - min) + min)
            .map(s -> String.valueOf(s))
            .peek((msg) -> {
                logger.info(msg);
            }))
            .map(s -> Integer.valueOf(s))
            .delayElements(Duration.ofSeconds(1));
    }
}

Note that the getNumbers() method produces a TEXT_EVENT_STREAM_VALUE. This indicates that the system sends data as Server Sent Events or SSE.

Creation of the Reactive EventClient

For the next step, we're going to create a Reactive EventClient:

public class EventClient {

    Logger logger = LoggerFactory.getLogger(EventClient.class);

    @Bean
    WebClient getWebClient() {
        return WebClient.create("http://localhost:8081");
    }

    @Bean
    CommandLineRunner demo(WebClient client) {
        return args -> {
            client.get()
                .uri("/events")
                .accept(MediaType.TEXT_EVENT_STREAM)
                .retrieve()
                .bodyToFlux(Integer.class)
                .map(s -> String.valueOf(s))
                .subscribe(msg -> {
                    logger.info(msg);
                });
        };
    }
}

As we're expecting a flux of events we need to use the bodyToFlux() method in order to return a proper response.

Now we run the Spring Boot application. Every second, the system will generate and print random numbers on the console.

Conclusion

With this simple example, we can observe the most basic features of real-time event streaming using Spring WebFlux.

In conclusion, reactive programming consists of seeing everything as a flow of elements, hence, it allows the execution of operations on that flow and being able to transmit it to a client in such a way that it has an asynchronous experience and Spring WebFlux is a great option to consider if our tasks require these capabilities.

Face recognition of celebrities in Java with Amazon Rekognition

Darío Carrasquel — Sun, 31 Jan 2021 17:52:18 +0000

As stated on the Amazon Web Services website, Amazon Rekognition is a service that enables you to add image analysis to your applications. With Rekognition, you can detect objects, scenes, and faces in images.

Among the most important features offered by Amazon Rekognition are:

Objects and Scene Detection
Moderation of Images
Facial Analysis
Facial Recognition
Celebrity Recognition

In this technical example, we’re going to use Java SDK to show how to develop a simple and useful application that recognizes celebrities' faces in order to demonstrate the capabilities of the service.

We picked various pictures of recognized celebrities like Cristiano Ronaldo, Celine Dion, and Sting, obtaining favorable results as shown in the infographic:

For the technical side, we will focus on the most important steps and will omit the less-specific parts (you can get all the code at Github). In this example, we will use the Java SDK.

Steps

1) Create an Amazon Rekognition client using the AmazonRekognitionClientBuilder including the Region to be used and a RecognizeCelebritiesRequest containing the representation in bytes of the picture.

AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder
  .standard().withRegion(Regions.US_WEST_2).build();   

RecognizeCelebritiesRequest request = new RecognizeCelebritiesRequest()
    .withImage(new Image().withBytes(imageBytes));

2) Create a RecognizeCelebritiesResult object that will contain the obtained results:

RecognizeCelebritiesResult result = amazonRekognition.recognizeCelebrities(request);

3) Display the recognized celebrity information:

List celebs = result.getCelebrityFaces();    
System.out.println(celebs.size() + " celebrity(s) were recognized.\n");    
List metadata = new ArrayList();      

for (Celebrity celebrity: celebs) {  
  // Name        
  System.out.println("Celebrity recognized: " + celebrity.getName());
  metadata.add("Celebrity recognized: " + celebrity.getName());

  // Id        
  System.out.println("Celebrity ID: " + celebrity.getId());        
  metadata.add("Celebrity ID: " + celebrity.getId());               

  // Extra info        
  System.out.println("Further information (if available):");       
  metadata.add("Further information (if available):"); 

  for (String url : celebrity.getUrls()) {           
    System.out.println(url);          
    metadata.add(url);        
  }
}

Currently, Amazon Rekognition only supports JPG and PNG formats, which is a disadvantage compared to Google Cloud Vision that provides support for a wide range of formats such as GIF, BMP, and RAW among others.

However, it should be noted that during the tests performed there were no performance issues due to the type of format, and better effectiveness of the tool could be observed when the faces were clearly visible or at a frontal angle when the contrast with the background was notorious.

Another feature to note is that the API was designed to include as many celebrities as possible based on feedback from AWS clients, so new names are constantly being added to the list after some analysis. Taking this into consideration, we did some extra testing using celebrity images from countries like Panama and Colombia to diversify the evidence based on a wider cultural spectrum. The results we obtained were as follows:

In the first two tests, satisfactory results were observed, the tool was able to recognize Panamanian boxing legend Roberto Durán and the well-known Colombian footballer, James Rodriguez. We did a third test, using a lower resolution image to test the limits of the tool, and did not get favorable results when trying to recognize the great martial artist of all time, Bruce Lee.

Taking these results into account, it can be affirmed that the quality and resolution of the image are an aspect to consider when using the tool. If it is desired to obtain favorable results, it is important to ensure the use of images of considerable quality, taking into account that the service still seems to be developing improvements as the Deep Learning models are fed.

Amazon Rekognition it's been in the market since 2016, offering great capabilities like scalability, high availability, and competitive pricing. There’s a great potential for Rekognition to become a standard for image analysis based on Deep Learning algorithms, along with competing services like Clarifai, Microsoft Cognitive Services, and Google’s Vision API.

The near future looks very promising for software development focused on Artificial Intelligence, a market that will definitely open new horizons for the creation of impressive tools that could have a beneficial impact on our society.