#Spring webflux

[codeonedigest]

Spring Boot Multithreading using Async in Hindi | Complete Tutorial of Multithreading in Spring Boot in HINDI

Full Video Link: https://youtu.be/SSwhctye9jA Hi, a new #video on #springboot #multithreading using #async #annotation is published on #codeonedigest #youtube channel. The complete tutorial guide of multithreading in #spring #boot #project using async

Multithreading in spring boot is achieved using Async annotation and using Task Executor Service class. Multithreading in spring boot is similar to multitasking, except that it allows numerous threads to run concurrently rather than processes. A thread in Java is a sequence of programmed instructions that are managed by the operating system’s scheduler. Threads can be utilized in the background…

[codeline24]

Two paradigms rule programming: imperative and declarative.

Declarative emerged to address imperative's drawbacks. The imperative paradigm, also known as the procedural, is the oldest and most widely used approach to programming. It's like giving step-by-step instructions to a computer, telling it what to do and how to do it, one command at a time. It's called "imperative" because as programmers we dictate exactly what the computer has to do, in a very specific way. Declarative programming is the direct opposite of imperative programming in the sense that the programmer doesn't give instructions about how the computer should execute the task, but rather on what result is needed. Two main subcategories are functional and reactive programming. Functional programming is all about functions (procedures with a specific set of functionalities) and they can be assigned to variables, passed as arguments, and returned from other functions. Java offers libraries and frameworks that introduce functional programming concepts like lambda expressions and streams. Reactive programming is a programming paradigm where the focus is on developing asynchronous and non-blocking components. Back in the year 2013, a team of developers, lead by Jonas Boner, came together to define a set of core principles in a document known as the Reactive Manifesto. With reactive streams initiatives that are incorporated in Java specifications there are frameworks (RxJava, Akka Streams, Spring WebFlux..) that provide reactive paradigm implementation to Java.

[ericvanderburg]

Spring Boot Gateway With Spring Cloud and WebFlux

http://securitytc.com/TJgVTK

[mtsuhail]

How to Build Scalable Web Applications with Java Full Stack Development

Scalability is one of the most crucial aspects of building modern web applications. As the number of users and data grows, it’s important to ensure that the application can handle the increased load efficiently. Java full-stack development with its robust set of tools and frameworks, is ideal for building scalable web applications. In this blog, we’ll explore how you can leverage Java Full Stack technologies to build applications that scale effectively.

What is Scalability in Web Applications?

Scalability refers to the ability of a web application to handle an increasing amount of workload or users without compromising performance. A scalable application can grow as the demand for its services increases, either by upgrading existing infrastructure (vertical scaling) or by adding more resources (horizontal scaling).

In the context of Java full-stack development, scalability involves both the back-end (server-side) and the front-end (client-side) of the application. Let’s explore how you can achieve scalability using Java technologies.

1. Building a Scalable Back-End with Spring Boot

The back-end of your application is responsible for handling requests, processing data, and interacting with databases. Spring Boot is an excellent choice for building a scalable back-end due to its simplicity, flexibility, and integration with various cloud-based tools. Here’s how you can ensure scalability with Spring Boot:

- Microservices Architecture

To build a scalable back-end, consider using a microservices architecture. Microservices allow you to break down a monolithic application into smaller, independent services that can be developed, deployed, and scaled independently. Spring Boot, combined with Spring Cloud, provides powerful tools for building and managing microservices.

Using microservices, each service can be scaled individually based on demand. For instance, if one service experiences high traffic, it can be scaled up without affecting the other services.

- Asynchronous Processing

Scalable applications often need to handle a large number of concurrent requests without slowing down. By leveraging asynchronous processing in Spring Boot, you can ensure that tasks like database queries or external API calls do not block the main thread, allowing the application to handle more requests efficiently. Technologies like Spring WebFlux provide asynchronous processing out of the box.

- Load Balancing

In a scalable system, it's essential to distribute incoming traffic across multiple instances of your application. Spring Cloud Netflix Ribbon and Eureka offer client-side load balancing and service discovery features, which enable you to route requests to the best-performing server instance, ensuring that your application can handle more traffic efficiently.

2. Front-End Scalability with React or Angular

The front-end of your application also needs to be scalable. React and Angular are two popular JavaScript frameworks that can help you build highly scalable user interfaces.

- Component-Based Architecture

Both React and Angular follow a component-based architecture, where the application is divided into smaller, reusable components. This modular approach makes it easier to scale the front-end by adding new features and components without affecting the entire application.

Additionally, React’s virtual DOM ensures that only the necessary components are re-rendered when data changes, improving performance even as the application grows in size.

- Single-Page Applications (SPA)

Modern web applications often use a Single-Page Application (SPA) approach, where the entire application is loaded once, and subsequent interactions with the server are handled asynchronously. SPAs reduce the number of full-page reloads, leading to a faster and more scalable user experience. Both React and Angular excel in building SPAs.

- Efficient State Management

As your application scales, managing the state (i.e., the data used by the components) becomes increasingly complex. Both React (with Redux) and Angular (with NgRx) offer state management solutions that allow you to handle large amounts of data more efficiently. These tools help maintain consistency across the application and improve performance.

3. Database Scalability

Databases are central to the scalability of a web application. Java Full Stack development provides several options for managing databases in a scalable manner.

- NoSQL Databases

For applications that need to handle unstructured or semi-structured data at scale, NoSQL databases (like MongoDB or Cassandra) can be a better choice than traditional relational databases. Java has strong support for NoSQL databases through libraries like Spring Data MongoDB, making it easy to interact with and scale these databases.

- Sharding and Replication

For relational databases, you can achieve scalability through sharding and replication. Sharding involves splitting the database into smaller chunks, which can be distributed across multiple servers, while replication ensures that data is copied across multiple databases for high availability and fault tolerance. Java frameworks like Spring Data JPA and Hibernate can be configured to support these features, allowing you to scale your database as needed.

- Caching

To further improve the scalability of your application, you can implement caching mechanisms that reduce the load on the database. Redis and Memcached are popular caching solutions that can store frequently accessed data in memory, reducing database queries and improving response times. Java has excellent support for integrating caching systems like Redis using Spring Cache.

4. Cloud Deployment for Scalability

One of the best ways to achieve scalability for your Java full-stack development application is by deploying it in the cloud. Cloud platforms like AWS, Azure, and Google Cloud offer flexible, on-demand resources that make it easy to scale your application as needed.

- Auto-Scaling

Cloud platforms provide auto-scaling features that automatically increase or decrease the number of instances based on traffic. This allows you to scale your application up during peak times and scale it down when traffic decreases, ensuring efficient resource usage and cost management.

- Containers and Kubernetes

Containers (such as Docker) and container orchestration systems (like Kubernetes) are widely used in scalable applications. Containers provide a lightweight, consistent environment for running microservices, while Kubernetes automates the deployment, scaling, and management of containerized applications. Spring Boot applications can be easily containerized and deployed to Kubernetes clusters, providing a robust solution for scaling.

5. Monitoring and Optimizing Performance

Finally, it’s essential to continuously monitor and optimize the performance of your scalable web application. Tools like Spring Boot Actuator and Prometheus can help you track performance metrics, identify bottlenecks, and ensure that your application is operating efficiently.

You can also implement load testing using tools like Apache JMeter to simulate high traffic and ensure that your application can handle the desired number of concurrent users. Regular performance testing and optimization are key to maintaining a scalable application.

Conclusion

Building a scalable web application requires careful consideration of both the front-end and back-end components. With Java full-stack development, you can leverage powerful frameworks and tools like Spring Boot, React, Angular, and cloud technologies to create applications that can scale efficiently with increasing demand.

By embracing microservices, optimizing databases, implementing caching, and utilizing cloud-based solutions, you can ensure that your Java Full Stack application remains performant, reliable, and scalable as it grows.

This concludes the blog on "How to Build Scalable Web Applications with Java full-stack development". Let me know if you’d like to proceed with another topic!

[anusha-g]

Key points to learn the Spring Framework

key points to learn the Spring Framework:

Java Basics: Ensure solid understanding of Java fundamentals.

Spring Basics: Read official Spring documentation for an overview.

Core Concepts: Learn Inversion of Control (IoC) and Dependency Injection (DI).

Spring Boot: Explore Spring Boot for quick setup and configuration.

Dependency Injection: Understand IoC containers, XML, and annotation-based configurations.

Spring MVC: Grasp Model-View-Controller architecture for web applications.

Data Access: Explore data access using JDBC, ORM (like Hibernate), and Spring Data.

Security: Learn Spring Security for authentication and authorization.

RESTful Web Services: Build RESTful APIs using Spring MVC or WebFlux.

Aspect-Oriented Programming (AOP): Understand AOP for handling cross-cutting concerns.

Testing: Write unit and integration tests using tools like JUnit.

Real-World Projects: Apply knowledge through practical projects.

Community Engagement: Join Spring community discussions and forums.

Advanced Topics: Explore Spring Cloud, Spring Batch, and other advanced features.

Continuous Learning: Stay updated with the latest releases and features.

[inextures]

Guide to Spring Reactive Programming using WebFlux

Reactive programming is a programming paradigm that promotes an asynchronous, non-blocking, event driven approach to data processing. Reactive programming involves modelling data and events as observable data streams and implementing data processing routines to react to the changes in those streams. 

In the reactive style of programming, we make a request for the resource and start performing other things. When the data is available, we get the notification along with the data in the form of call back function. In the callback function, we handle the response as per application /user needs. 

Features of Reactive Programming 

Asynchronous & Non-blocking 

Functional style of coding 

Data flow as event driven stream 

Backpressure on data streams 

When considering whether to use Spring MVC or Spring WebFlux, there are various factors you must consider.  

Spring MVC: It’s based on a servlet API and follows an imperative programming model. This means you write code in a step-by-step manner, which is generally easier to follow.   

Spring WebFlux: It offers a reactive programming model. Reactive programming is about handling asynchronous streams of data. This requires a change in thinking and can be more challenging than the traditional imperative model.   

Spring MVC: If you are familiar with traditional web application development, Spring MVC’s imperative model might seem more straightforward. It’s easier to read, write, and understand for developers accustomed to this approach.   

Spring WebFlux: Writing reactive code can initially seem complex because of the shift in mindset. However, for some use cases, like streaming data, it can simplify your code.   

Spring MVC: Debugging is typically more straightforward with an imperative model because the call stacks are more predictable and easier to trace.   

Spring WebFlux: Debugging reactive streams can be tricky, especially for developers new to the reactive paradigm. However, tools and practices are evolving to better support this.   

Spring MVC: Works naturally with blocking resources like traditional RDBMS using JDBC or JPA (Java Persistence API). 

Spring WebFlux: If you have blocking dependencies like traditional databases, you might not get the full benefits of the reactive model. However, reactive databases like MongoDB Reactive, Cassandra Reactive, etc., can be integrated natively with WebFlux.   

Spring MVC: Uses a thread-per-request model. For a high number of simultaneous connections, this can lead to a large number of threads, which may not be efficient. 

Spring WebFlux: Uses an event-loop concurrency model, which can handle a vast number of simultaneous connections with a smaller number of threads. It’s designed for high concurrency. 

Spring MVC: Typically runs on servlet containers like Tomcat, Jetty, etc. 

Spring WebFlux: Runs on reactive runtimes like Netty. This provides non-blocking and highly scalable operations, suitable for high-performance systems. 

Spring MVC: Typically uses annotated controllers. 

Spring WebFlux: In addition to annotated controllers, WebFlux supports functional endpoints which allow for programmatic route definitions. 

Spring WebFlux: 

As we know, Spring provides Web MVC framework to handle the HTTP requests, but it is Blocking & Non-Reactive in nature, so to support reactive programming Spring provides one more web framework in Spring 5 (includes in Spring Boot 2.0) called WebFlux. 

It is a reactive-stack web framework that is fully non-blocking, supports reactive streams back pressure. It uses project Reactor as a reactive library. The Reactor is a Reactive Streams Library and therefore, all of its operators support non-blocking back pressure. 

It uses two publishers: 

Mono 

Flux 

MONO: 

A mono is a specialized Publisher that emits at most one item and then optionally terminates with an onComplete signal or an onError signal. In short, it returns 0 or 1 element. 

Mono is another implementation of Publisher. 

It emits at most one item and then (optionally) terminates with an onComplete signal or an onError signal. 

Like Flux, Mono is also asynchronous in nature. 

Mono noData = Mono.empty(); 

Mono data = Mono.just(“rishi”); 

FLUX: 

A flux is a standard Publisher representing an asynchronous sequence of 0 to N emitted items, optionally terminated by either a completion signal or an error. These three types of signals translate to calls to a downstream subscriber’s onNext, onComplete, or onError methods. 

Flux is an implementation of Publisher. 

It will emit 0 to N elements and/or a complete or an error call. 

Stream pipeline is synchronous whereas Flux pipeline is completely asynchronous. It will emit values only when there is a downstream subscriber. 

To subscribe, we need to call the subscribe method on Flux. There are different variants of the subscribe method available, which we need to use as per the need: 

Flux flux1 = Flux.just(“foo”, “bar”, “foobar”); 

Flux flux2 = Flux.fromIterable(Arrays.asList(“A”, “B”, “C”)); 

Flux flux3 = Flux.range(5, 3); 

// subscribe 

flux.subscribe(); 

Frequently used operations on Mono/Flux 

just(-): Create a new Mono that emits the specified item, which is captured at instantiation time. 

fromArray(-): Create a Flux that emits the items contained in the provided array. 

fromIterable(-): Create a Flux that emits the items contained in the provided iterable. The Iterable.iterator() method will be invoked at least once and at most twice for each subscriber. 

fromStream(-): Create a Flux that emits the items contained in a Stream created by the provided Supplier for each subscription. The Stream is closed automatically by the operator on cancellation, error, or completion. 

empty(): Create a Flux that completes without emitting any item. 

doOnNext(-): Add behaviour (side-effect) triggered when the Flux emits an item. 

doOnComplete(-): Add behaviour (side-effect) triggered when the Flux completes successfully. 

doOnError(-): Add behaviour (side-effect) triggered when the Flux completes with an error. 

map(-): Transform the items emitted by this Flux by applying a synchronous function to each item. 

flatMap(-): Transform the item emitted by this Mono asynchronously, returning the value emitted by another Mono (possibly changing the value type). 

subscribe(-, -, -): Subscribe a Consumer to this Flux that will consume all the elements in the sequence. It will request an unbounded demand. 

log(): Observe all Reactive Streams signals and trace them using Logger support. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead. 

delayElements(-): Delay each of this Flux elements (Subscriber.onNext signals) by a given Duration. Signals are delayed and continue the parallel default Scheduler, but empty sequences or immediate error signals are not delayed. 

block(): Subscribe to this Mono and block indefinitely until a next signal is received. Returns that value, or null if the Mono completes empty. In case the Mono errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception) 

Working with Spring Web Flux – Understanding the Reactive nature 

Requirement: Send Promos to all the customers of an e-Commerce website 

Step-1: Create a Spring Boot project using Maven (Choose Spring Boot version 2.0 or later) 

Step-2: Add the below spring-boot-starter-webflux dependency in pom.xml 

 <dependency> 

                             <groupId>org.springframework.boot</groupId> 

                             <artifactId>spring-boot-starter-webflux</artifactId> 

</dependency> 

 This dependency includes the below dependencies 

spring-webflux framework 

reactor-core that we need for reactive streams 

reactor-netty (the default server that supports reactive streams). Any other servlet 3.1+ containers like Tomcat, Jetty or non-servlet containers like Undertow can be used as well 

Version will be picked from spring-boot-starter-parent dependency version  

Step-3: Create a Customer DTO class with the fields Id, Name & Email Id 

Step-4: Create a Customer Repo with 2 functions loadCustomers(), loadCustomerStream() as in the below snapshot.

Step-5: Create a Customer Service with 2 functions, one is to send promos to list of customers, another is to send promos to customer stream

Step-6: Create a Customer REST Controller with 2 end points as in the below screenshot

Summary:

Spring introduced a Multi-Event Loop model to enable a reactive stack known as WebFlux. It is a fully non-blocking and annotation-based web framework built on Project Reactor which allows building reactive web applications on the HTTP layer. It provides support for popular inbuilt severs like Netty, Undertow, and Servlet 3.1 containers.

Spring WebFlux or Reactive non-blocking applications usually do not make the applications run faster. The essential benefit it serves is the ability to scale an application with a small, fixed number of threads and lesser memory requirements while at the same time making the best use of the available processing power. It often makes a service more resilient under load as they can scale predictably.

WebFlux is also relevant for applications that need scalability or to stream request data in real time. While implementing a micro-service in WebFlux we must consider that the entire flow uses reactive and asynchronous programming and none of the operations are blocking in nature.

Originally published by: Guide to Spring Reactive Programming using WebFlux

[onurdesk]

Video Streaming using Spring Webflux by onurdesk

In this tutorial, Ill like to show you how to use Spring WebFlux to accomplish video streaming. Spring will do all of the heavy work for us, so it will be a lot easier than you think.

This Articles Contents Video Streaming

Sample Application:

Project Setup

Spring WebFlux Video Steaming:

Spring WebFlux Video Steaming – Demo:

Functional Endpoint:

Summary

#Video Streaming

The browser client does NOT download the complete video content when you watch a movie via Amazon Prime or a video tutorial via YouTube or Udemy. It initially receives some material. It obtains the next few pieces in a streaming way while playing the material so that the consumer is engaged with the video as soon as he clicks on it, rather than having to wait for the entire material to download.

For a more detailed tutorial Please visit: https://onurdesk.com/video-streaming-using-spring-webflux/

[smarttechie]

Build Reactive REST APIs with Spring WebFlux - Part3

Build Reactive REST APIs with Spring WebFlux – Part3

Photo by Chris Ried on Unsplash

In continuation of the last article, we will see an application to expose reactive REST APIs. In this application, we used,

Spring Boot with WebFlux

Spring Data for Cassandra with Reactive Support

Cassandra Database

Below is the high-level architecture of the application.

Let us look at the build.gradle file to see what dependencies are included to work with…

[iamcodegeek]

Build a reactive Microservices Architecture using Spring Cloud Gateway, Spring Boot and Spring WebFlux ☞ https://morioh.com/p/0f35d4bf423b #Microservices #Spring #Cloud #WebFlux #Morioh

[iamprogrammerz]

Guide to Spring WebFlux ☞ https://morioh.com/p/a19c4bf24941 #Spring #WebFlux #Morioh

[ericvanderburg]

High-Severity Access Control Vulnerability Found in Spring WebFlux

http://i.securitythinkingcap.com/StQN9m

[joo-yoon]

spring webflux를 사용하려고 관련 자료를 찾다보니 reactive를 알게 되었고 flux, mono 등을 보게 되었다. flux는 다수의 요청을 넌블러킹으로 처리하는 방법에 대한 것이고 mono는 하나의 요청을 처리하는 방법으로 보인다.

webflux는 다수의 웹요청을 flux처럼 처리하는 것을 말하는 것으로 보인다. (이걸 보기 전까진 그냥 routing하는 방법인 줄 알았다)

이름만 들었을 때는 되게 어렵고 대단한 건 줄 알았는데 별거 아니었다. java쪽은 뭔가 이름을 너무 거창하게 붙인다. nodejs에서는 흔히 사용하는 방식이라 아무런 용어가 없다. 물론 java니까 좀 더 빠르고 익숙한 개발자도 많고... 여러가지 좋은 점이 있겠지. 찬찬히 알아봐야겠다.