DEV Community: Prabu Subra

Spring Beans Lifecycle

Prabu Subra — Sat, 26 Nov 2022 19:20:11 +0000

Spring IoC container create the beans and perform few post process activities based on the configurations like implementing Aware interfaces and annotations.

In a nutshell, Spring IoC Container first check for dependency then calls its constructor. After creation of bean, it first injects the dependencies auto wired 0n constructor, Field and setters. Then Aware interfaces(BeanNameAware, BeanClassLoaderAware, ApplicationContextAware…) and annotated method like PostConstruct is invoked. At last init-method is invoked.

Main Method:-

public class Solution1 {
 public static void main(String[] args) {
  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SolutionConfig.class);
  Post post1 = context.getBean(Post.class);
  context.close();
 }
}

Configuration file:-

@Configuration
public class SolutionConfig {

 @Bean
 public Author author() {
  return new Author("Aplha, Engineer", "alphaengineer@gmail.com");
 }

 @Bean
 public Post post() {
  return new Post("Spring Bean Lifecycle hooks", author());
 }
}

Post class:-

@Getter
@Setter
@NoArgsConstructor
public class Post {

 private UUID id;
 private String content;
 private Author author;

 @Autowired
 public Post(String content, Author author) {
  System.out.println(" Author from Post constructor : "+author.toString());
  this.id = UUID.randomUUID();
  this.content = content;
  this.author = author;
 }
 public void setAuthor(Author author) {
  System.out.println(" setAuthor : "+author.toString());
  this.author = author;
 }
 @Override
 public String toString() {
  return "Post [id=" + id + ", content=" + content + ", author=" + author.toString() + "]";
 }
}

Author Class:-

@Getter
@Setter
@NoArgsConstructor
public class Author {

 private UUID id;
 private String fullName;
 private String email;

 public Author(String fullName, String email) {
  System.out.println("Author constructor");
  this.id = UUID.randomUUID();
  this.fullName = fullName;
  this.email = email;
 }

 @Override
 public String toString() {
  return "Author [id=" + id + ", fullName=" + fullName + ", email=" + email + "]";
 }
}

Sample Output:-

Author constructor
Author from Post constructor : Author [id=0b6afb4d-02d8-4f17-adfd-57aeafb8f206, fullName=Aplha, Engineer, email=alphaengineer@gmail.com]
Post : Post [id=4d5e403f-a75b-43f0-bf8f-d596a0e5814d, content=Spring Bean Lifecycle hooks, author=Author [id=0b6afb4d-02d8-4f17-adfd-57aeafb8f206, fullName=Aplha, Engineer, email=alphaengineer@gmail.com]]

Dependencies are instantiated and injected based on Auto wiring configuration. if we use setter auto wiring then respective setter will called and add dependency.

Configuration:-

@Configuration
public class SolutionConfig {

 @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
 public Author author() {
  return new Author("Aplha, Engineer", "alphaengineer@gmail.com");
 }

 @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
 public Post post() {
  return new Post("Spring Bean Lifecycle hooks", author());
 }
}

Aware Interfaces:-

Aware interfaces are used to check and configure information about bean name, class loader and Application Context details.

@Getter
@Setter
@NoArgsConstructor
public class Post implements BeanNameAware, BeanClassLoaderAware, ApplicationContextAware, InitializingBean, DisposableBean {

 private UUID id;
 private String content;
 private Author author;

 public Post(String content, Author author) {
  System.out.println("Author from Post constructor : "+author.toString());
  this.id = UUID.randomUUID();
  this.content = content;
  this.author = author;
 }

 @PostConstruct
 public void init() {
  System.out.println("Post, @PostConstruct annotated method");
 }

 @PreDestroy
 public void predestroy() {
  System.out.println("Post, @PreDestroy annotated method");
 }

 public void initMethod() {
  System.out.println("Post, initMethod method");
 }
 public void destroyMethod() {
  System.out.println("Post, destroyMethod method");
 }

 public void destroy() {
  System.out.println("Post, destroy method from Disposable interface");
 }

 @Autowired
 public void setAuthor(Author author) {
  System.out.println("setAuthor : "+author.toString());
  this.author = author;
 }
 @Override
 public String toString() {
  return "Post [id=" + id + ", content=" + content + ", author=" + author.toString() + "]";
 }

 public void setBeanName(String name) {
  System.out.println("Post, setBeanName method from BeanNameAware interface : "+name);
 }

 public void setBeanClassLoader(ClassLoader classLoader) {
  System.out.println("Post, setBeanClassLoader method BeanClassLoaderAware interface : "+classLoader.getName());
 }

 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  System.out.println("Post, setApplicationContext method ApplicationContextAware interface : "+applicationContext.getApplicationName());
 }

 public void afterPropertiesSet() throws Exception {
  System.out.println("Post, afterPropertiesSet method InitializingBean interface  ");
 }
}

@Getter
@Setter
@NoArgsConstructor
public class Author implements BeanNameAware, BeanClassLoaderAware, ApplicationContextAware, InitializingBean, DisposableBean {

 private UUID id;
 private String fullName;
 private String email;

 public Author(String fullName, String email) {
  System.out.println("Author constructor");
  this.id = UUID.randomUUID();
  this.fullName = fullName;
  this.email = email;
 }
 @PostConstruct
 public void init() {
  System.out.println("Author, @PostConstruct annotated method");
 }
 @PreDestroy
 public void predestroy() {
  System.out.println("Author, @PreDestroy annotated method");
 }
 public void destroy() {
  System.out.println("Author, destroy method from DisposableBean interface");
 }
 public void initMethod() {
  System.out.println("Author, initMethod method");
 }
 public void destroyMethod() {
  System.out.println("Author, destroyMethod method");
 }
 @Override
 public String toString() {
  return "Author [id=" + id + ", fullName=" + fullName + ", email=" + email + "]";
 }
 public void setBeanName(String name) {
  System.out.println("Author, setBeanName method from BeanNameAware interface : "+name);
 }

 public void setBeanClassLoader(ClassLoader classLoader) {
  System.out.println("Author, setBeanClassLoader method BeanClassLoaderAware interface : "+classLoader.getName());
 }

 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  System.out.println("Author, setApplicationContext method ApplicationContextAware interface : "+applicationContext.getApplicationName());
 }
 public void afterPropertiesSet() throws Exception {
  System.out.println("Author, afterPropertiesSet method InitializingBean interface  ");
 }
}

Sample Output:-

Author, setBeanClassLoader method BeanClassLoaderAware interface : app
Author, setApplicationContext method ApplicationContextAware interface : 
Author, @PostConstruct annotated method
Author, afterPropertiesSet method InitializingBean interface  
Author, initMethod method
Author from Post constructor : Author [id=1e360880-50eb-4bdf-a230-1e825ed67b39, fullName=Aplha, Engineer, email=alphaengineer@gmail.com]
setAuthor : Author [id=1e360880-50eb-4bdf-a230-1e825ed67b39, fullName=Aplha, Engineer, email=alphaengineer@gmail.com]
Post, setBeanName method from BeanNameAware interface : post
Post, setBeanClassLoader method BeanClassLoaderAware interface : app
Post, setApplicationContext method ApplicationContextAware interface : 
Post, @PostConstruct annotated method
Post, afterPropertiesSet method InitializingBean interface  
Post, initMethod method
Post : Post [id=ff29cc5a-b05c-448b-aa7d-05fbe17709ca, content=Spring Bean Lifecycle hooks, author=Author [id=1e360880-50eb-4bdf-a230-1e825ed67b39, fullName=Aplha, Engineer, email=alphaengineer@gmail.com]]
Post, @PreDestroy annotated method
Post, destroy method from Disposable interface
Post, destroyMethod method
Author, @PreDestroy annotated method
Author, destroy method from DisposableBean interface
Author, destroyMethod method

Spring Bean Lifecycle Flow:-

Spring IoC container first creates the depend beans, inject and then create the bean for usage, then delete the bean and its depend beans. if any runtime exceptions happen in any of these lifecycle hook methods. it breaks the bean instantiation. on successful execution of all these hooks spring bean is ready to use.

Thanks for spending your valuable time, Think blog is based on my understanding ony, if you feel anything is wrong please feel free to comment.

Reference:-
https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/BeanFactory.html

ES2019/ES10 Features

Prabu Subra — Sat, 06 Apr 2019 14:32:33 +0000

Recently, TC39 committee has approved and added few bunch of feature to ECMAScript 2019 Standard, which are ported to major JavaScript engine like V8,SpiderMonkey…

Completed Features:-

Array.prototype.{flat, flatmap}
String.prototype.{trimStart,trimEnd, matchAll*}
Object.fromEntries
Function.prototype.toString
Sysmbol.prototype.description
Optional catch binding
JSON superset
well-formed JSON.stringify
BigInt*
globalThis*

* - at stage 3

Arrays.prototype.{flat, flatmap}

Two methods has added.

Array.prototype.flat
Array.prototype.flatMap

Array.prototype.flat:-

It is originally proposed as Array.prototype.flatten, flattens arrays recursively up to the specified depth, which defaults to 1.

  let data = [
    "alpha",
    "beta",
    ["gamma", "delta", ["epsilon", "zeta", ["eta", "theta", "iota", "kappa"]]]
  ];
  console.log(data.flat());
  //(5) ["alpha", "beta", "gamma", "delta", Array(3)]
  console.log(data.flat(2));
  //(7) ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", Array(4)]
  console.log(data.flat(3));
  //(10) ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota", "kappa"]
  console.log(data.flat(Infinity));
  //(10) ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota", "kappa"]

Array.prototype.flatMap:-

Combined flatten and map behaviour for arrays. Flatten the result in to single array.

[1, 2, 3, 4, 5].map(data => [data * 2, data * 3]);
//[[2, 3], [4, 6], [6, 9], [8, 12], [10, 15]]

[1, 2, 3, 4, 5].map(data => [data * 2, data * 3]).flat();
//[2, 3, 4, 6, 6, 9, 8, 12, 10, 15];

[1, 2, 3, 4, 5].flatMap(data => [data * 2, data * 3]);
//[2, 3, 4, 6, 6, 9, 8, 12, 10, 15]

String.prototype.{trimStart,trimEnd, matchAll*}:-

String.prototype.trimStart()
String.prototype.trimEnd()
String.prototype.matchAll()

  let data = " Hacker Rank  ";
  console.log(data.trimStart()); //Hacker Rank
  console.log(data.trimEnd()); //Hacker Rank
  console.log(data.match("a")); //["a", index: 2, input: " Hacker Rank  ", groups: undefined]
  let iterator = data.matchAll("a");
  for (let i of iterator) console.log(i); 
  /*let result;
  do {
    result = iterator.next();
    console.log(result);
  } while (!result.done); */

//["a", index: 2, input: " Hacker Rank  ", groups: undefined]
//["a", index: 9, input: " Hacker Rank  ", groups: undefined]

Function.prototype.toString:-

If function is written ECMAScript code, then toString should return source code.

  function multiply(a, b) {
    return a * b;
  }
  multiply.toString();
  /*"function multiply(a, b) {
    return a * b;
  }"*/
  let add = new Function("a", "b", "return a+b");
  add.toString();
  /*"function anonymous(a,b
  ) {
  return a+b
  }"*/

For built-in and binding function, it returns NativeFunction string.

  JSON.stringify.toString();
  //"function stringify() { [native code] }"

Object:-

A new static method Object.fromEntries is added to Object.
To be specific, it converts array of arrays(Array which has nested arrays in it) in to Object, Let’s see, how is it working.

Object.fromEntries([["one", "alpha"], ["two", "beta"], ["three", "gamma"]]);
//{one: "alpha", two: "beta", three: "gamma"}

Few Questions:-

What if, Nested arrays have more than 2 elements in it?

    Object.fromEntries([
      ["one", "alpha", "two", "beta"],
      ["three", "gamma", "delta"]
    ]);
    //{one: "alpha", three: "gamma"}

What if, Array inside arrays contains objects?

    Object.fromEntries([
      [{ one: "alpha" }, { two: "beta" }],
      [{ three: "gamma" }, { four: "delta" }]
    ]);
    //{[object Object]: {four: "delta"}}

Symbol:-

As we know, Symbol is built in datatype for unique identifiers, we can create hidden properties for an object.
A new property Symbol.prototype.description is added to get description from symbol.

const connectionUrl = Symbol("CONNECTION_URL");
console.log(onnectionUrl.description); //"CONNECTION_URL"

Examples:- Symbol.iterator, Symbol.asyncIterator,Symbol.match,Symbol.matchAll...

Catch binding:-

If there is no use of exceptions details in catch block, developer can remove catch binding happily. This will remove unused and boilerplate code.

function add(a, b) {
  let result;
  try {
    if (typeof a === "number" && typeof b === "number") result = a + b;
    else result = "Not a valid number!";
  } catch {}
  return result;
}

BigInt:-

A BigInt is created by appending n to the end of the integer or by calling the constructor.

let bnum1 = 10n;
let bnum2 = BigInt(10); //10n
let bnum3 = BigInt(10.5);
//(d8):1: RangeError: The number 10.5 cannot be converted to a BigInt because it is not an integer.
let bnum4 = BigInt("10.5");
//(d8):1: SyntaxError: Cannot convert 10.5 to a BigInt.

BigInt can’t mix with numbers, but can concat with strings.
Can’t use decimals.
parseInt returns number.
JSON.stringify doesn't support.
TypedArray BigInt64Array (-263 to 263-1) BigUint64Array (0 to 264-1)

globalThis:

Accessing global object from browser(window), node(global)...
globalThis will infer the enviroment and return the global object .

var getGlobal = function() {
  if (typeof self !== "undefined") {
    return self;
  }
  if (typeof window !== "undefined") {
    return window;
  }
  if (typeof global !== "undefined") {
    return global;
  }
  throw new Error("unable to locate global object");
};

Conclusion:-

As we know, ECMAScript standards are used in various programming languages like Microsoft’s JScript, Oracle Nashorn Engine, it is strictly based on the language engine to choose which standard to support. let’s keep an eye on TC39 proposal for latest updates.

Thanks for reading!!!

Please feel free to comment your suggestions.

Local Variables Type Inference in Java

Prabu Subra — Tue, 01 Jan 2019 09:46:24 +0000

To be short, This post is about a type called var, which is introduced in java 10. Before started using var type, i have analysed and summarised about where to use and not to use var type like as an argument for methods, constructors, Exceptions, lambdas, Streams, etc...

var - Type Inference for local variables.

Before start using var, we need to understand few questions.

What is var ? what is the use of it ?

It is used to declare local variables and reduces the boilerplate code.

Is it a new keyword introduced in java ?

The answer is big No, it is not a keyword, a new type called var has created to improve type inference.

Is java becoming dynamic type language like JavaScript ?

No, Added an intelligent for compiler to understand the type of the local variable using its initializer without specifying explicitly.

How are the possible ways to declare local variables?

Examples:-

List<String> list = new ArrayList<String>(); // level 1
List<String> list = new ArrayList<>(); // level 2
var list = new ArrayList<String>(); // level 3

There are the places to use and not to use. Lets see few of that.

Scenario	Example
Cannot use var without initializer.	`jshell> var a;` `\| Error:` `\| cannot infer type for local variable a` `\| (cannot use 'var' on variable without initializer)` `\| var a;`
Cannot initialize with null.	`jshell> var a=null` `\| Error:` `\| cannot infer type for local variable a` `\| (variable initializer is 'null')` `\| var a=null;` `\| ^---------^`
Cannot use with arrays	`jshell> var[] a = new int[]{1,2,3}` `\| Error:` `\| 'var' is not allowed as an element type of an array`
Cannot use Multi variable declarations	`jshell> var a = "Alpha",b="Beta",c="Gamma";` `\| Error:` `\| 'var' is not allowed in a compound declaration` `\| var a = "Alpha",b="Beta",c="Gamma";` `\| ^` `\| Error:` `\| 'var' is not allowed in a compound declaration` `\| var a = "Alpha",b="Beta",c="Gamma";`
Variables, methods can be named var.	`jshell> var var = "Hello World!!!"` `var ==> "Hello World!!!"` `jshell> /l var` `1 : var var = "Hello World!!!";` `jshell> public void var() { System.out.println("Hello world!!!");}` `\| created method var()` `jshell> var()` `Hello world!!!`
Classes and Interfaces can't be named var	`jshell> class var {}` `\| Error:` `\| 'var' not allowed here` `\| as of release 10, 'var' is a restricted local variable type and cannot be used for type declarations` `\| class var {}` `\| ^` `jshell> interface var {}` `\| Error:` `\| 'var' not allowed here` `\| as of release 10, 'var' is a restricted local variable type and cannot be used for type declarations` `\| interface var {}` `\| ^`
Can be used with collections	`jshell> var list = List.of("alpha","beta","gamma");` `list ==> [alpha, beta, gamma]` `jshell> /v list` `\| List list = [alpha, beta, gamma]` `jshell> var set = Set.of("alpha","beta","gamma");` `set ==> [beta, gamma, alpha]` `jshell> /v set` `\| Set set = [beta, gamma, alpha]` `jshell> var map = Map.of(Map.entry("name","PrabuSubra"),Map.entry("city","Bangalore"))` `map ==> {name=PrabuSubra=city=Bangalore}` `jshell> /v map` `\| Map,Map.Entry> map = {name=PrabuSubra=city=Bangalore}`
Cannot use in method/Constructor arguments	`jshell> public void displayError(var errorMessage) { System.out.println(" Error due to : "+errorMessage);}` `\| Error:` `\| 'var' is not allowed here` `\| public void displayError(var errorMessage) { System.out.println(" Error due to : "+errorMessage);}` `\| ^-^`
Cannot used as return type in method signature.	`jshell> public var displayError(String errorMessage) { return "Error due to : "+errorMessage;}` `\| Error:` `\| 'var' is not allowed here` `\| public var displayError(String errorMessage) { return "Error due to : "+errorMessage;}` `\| ^-^`
Can be used in loops.	`jshell> for(var templist : list){ System.out.println(templist);` `}` `for(var i = 0;i` `}`
Can be used with Streams	`shell> var streams = Stream.of("alpha","Beta","Gamme","delta","Epsilon");` `streams ==> java.util.stream.ReferencePipeline$Head@1bce4f0a` `jshell> /v streams` `\| Stream streams = java.util.stream.ReferencePipeline$Head@1bce4f0a`
Cannot assigned Functional interfaces to it.	`jshell> var function = (data)->data` `\| Error:` `\| cannot infer type for local variable function` `\| (lambda expression needs an explicit target-type)` `\| var function = (data)->data;` `\| ^--------------------------^` `jshell> var consumer = (data)->{}` `\| Error:` `\| cannot infer type for local variable consumer` `\| (lambda expression needs an explicit target-type)` `\| var consumer = (data)->{};` `\| ^------------------------^` `jshell> var supplier = ()->{return new String("Hello world!!!");}` `\| Error:` `\| cannot infer type for local variable supplier` `\| (lambda expression needs an explicit target-type)` `\| var supplier = ()->{return new String("Hello world!!!");};` `\| ^--------------------------------------------------------^` `jshell> var runnable = ()->{}` `\| Error:` `\| cannot infer type for local variable runnable` `\| (lambda expression needs an explicit target-type)` `\| var runnable = ()->{};` `\| ^--------------------^`
Cannot use with Exception handlers	`jshell> try { } catch (var e){}` `\| Error:` `\| 'var' is not allowed here` `\| try { } catch (var e){}` `\| ^-^`
Cannot assign to interface, it always reference to initializer type.	`jshell> var list = new ArrayList()` `list ==> []` `jshell> /v list` `\| ArrayList list = []` `jshell>`
Cannot used with type inference.	`jshell> class Alpha { var t;}` `\| Error:` `\| 'var' not allowed here` `\| as of release 10, 'var' is a restricted local variable type and cannot be used for type declarations` `\| class Alpha { var t;}` `\| ^` `\| Error:` `\| 'var' is not allowed here` `\| class Alpha { var t;}` `\| ^-^`

Law of var:-
Properly initialised, Non-array variables can use the luxury of var type inference.

Summary:-
Eventually, Java has added few spoon of sugar to existing Type Inference feature. it is not completely freed developers hands to use var in code, it comes with its own laws. Type inference is not completely new feature in java, it has improved a step to use for local variables,mostly to avoid boilerplate code with less upgrade hurdles. The target source code base shouldn't contains class or interface, which was named as var and possibility also rare, nearly nothing. It is one of the way(not only way) to declare local variables.

Reference:-

http://openjdk.java.net/jeps/286

https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html

https://github.com/prabusubra/Learning/blob/master/Java/JShell/jshell.txt

Note:- if you feel something has to be added or wrong, feel free to comment below. Thanks for reading!!!

Understanding docker Containers and images

Prabu Subra — Sat, 24 Nov 2018 19:11:28 +0000

Containers — A technology to run one or more than one process on an independent and isolated environment.

What are process here?
Execution of programs(set of instructions). It could be applications, databases, message queues, etc…

What are resources needed to execute a process standalone?

Memory
CPU
I/O devices
Files Systems

In our day to day life, we use the containers without knowing. For example Parallel Space/Secondary space and Dual apps features in Android mobiles are using Linux Container technology.

In Linux kernel, we have options to create more than one parallel space and run a process inside of it, like jail, These are called as containers.

Linux kernel features behind containers:-

Using linux Kernel features like Namespace, Cgroup, chroot and UnionFS, host Linux kernel can split it's resources to run a process on isolated environment.

Namespaces → This feature isolates below terms from host and other containers.

Mount — isolate filesystem mount points.
UTS — isolate hostname and domain name.
IPC — isolate interprocess communication (IPC) resources.
PID — isolate the PID number space.
Network — isolate network interfaces.
User — isolate UID/GID number spaces.

Cgroups → limits resources like CPU, memory, network...

Chroot → change the root directory for specified process and its child processes.

UnionFS → layered File system.
1. Immutable layers
docker images are build as immutable layers.
2. Mutable layers
Data are persisted on this layer. it can be mounted to

local storage or external cloud store.
it helps for effective reuse of docker image and data management.

If containers share host operating systems, then

Why do we have operating system images(Container OS) on docker registries?
Containers are running on Host kernel, but OS utilities and libraries are not available, because of isolation(Namespace). Containers cannot access softwares installed on Host OS. so we have to configure required software for each docker container as docker image in Dockerfile.

What is actually is operating systems image(Container OS)?
These images are not full fledged Operating systems, just a bunch of utilities/libraries.

Therefore, To run a container, we just need to load few utilities not full operating systems.

Docker Container CLIs:-

Images — A blueprint or template, from which one or more than one containers can be created.

Most of the images are build based on Scratch image. It is like super parent image. Scratch doesn’t have any utility, it is empty image with zero size. image size is depends on its utilities, libraries and apps.

Docker image CLIs:-

Dockerfile:-

Docker image is created from Dockerfile. it has a set of vocabularies to execute processes with its dependencies independently.

Eventually, using container technology software can be created/changed, packed, tested and shipped quicker with less hurdles than traditional ways. It simplifies software business. programmable Platform (PaaS) accelerate software development and deployment(SaaS).

Thanks for reading… This is my understanding after using docker for few months. Feel free to comment your suggestions !!!

Reactive Sprint Boot application using WebFlux

Prabu Subra — Wed, 05 Sep 2018 13:04:43 +0000

A Reactive Spring Boot application can be written in
- Imperative style(Spring WebMVC) or
- Declarative Style(Spring WebFlux).

What is Reactive Spring Boot application?

it is a implementation of reactive streams(i.e sequence of data pushed from source to subscribers with back pressure), which are non-blocking, asynchronous and event-driven by nature. Spring Reactive libraries are build as part of Project Reactor projectreactor.io.

What is imperative style?

it is not imperative programming just a imperative programming style. it means Reactive Spring boot application can be written using sprint mvc annotations, so with minimum modifications, the old, legacy, big applications can also be converted to reactive nature and can use its features and benefits.

What is declarative style?

it is the latest functional lambda style of programming, this would be the better for new applications which are starting from scratch. let move further.

i recently converted my code base from Spring web-mvc to web-flux model. Initially, i faced few difficulties to understand and use Routers, Handlers and lambda functions, so i thought, writing a flat and simple controllers and equivalent Routers for same use cases will simplify the understanding.

As of now, spring boot apps can be developed in Spring WebMVC or WebFlux model, it is like... this or that, not a mix of both in a single application. so you shouldn’t have RestController annotation or spring-boot-starter-web dependency in pom.xml, if you are using spring web-flux routers.

REST endpoint should be defined on Configuration annotated class as a Bean of RouerFunction, Neither as a RestController nor Controller annotations.

Spring webflux is a programming paradigm used to compose Spring Boot applications on functional style(declarative style) using lambda functions.

lets see some code on each model. i have used below bean and written few GET/POST/DELETE Rest endpoints.

Bean:-

REST end points in Spring Web-MVC:-

Here everything is defined using annotations.

REST endpoints in Spring WebFlux:-

Few bunch of annotations are replaced with lambda functions, Not all the annotations. it is working with combination of annotations and lambda functions.

For better re usability/structure of code, we can have a dedicated handler and utility classes as Spring Component or Service.

Conclusion:-

Eventually, Controller becomes Router. Request and Response related annotations become lambda functions, it may look like Spring framework is moving towards lambda function based configurations (XML → Annotations → lambda functions). but still annotations are playing huge role, even RouterFunction itself configured with Configuration and Bean annotations.

Refer the below git hub repository for code.

prabusubra / microservicelearning

microservicelearning

This repo is to learn about microservice architecture and related technologies.

REST endpoints for WebMVC:-

GET - http://localhost:7070/api/blogs
GET - http://localhost:7070/api/blogs/id/{id}
POST - http://localhost:7070/api/blogs
Request body :-
[ { "topicid": "webflux", "name": "webflux", "content": "Intro and operators", "author": "Josh Long", "category": null }, { "topicid": "react", "name": "React", "content": "Intro and operators", "author": "Josh Long", "category": null }, { "topicid": "projectreactor", "name": "projectreactor", "content": "Intro and operators", "author": "Josh Long", "category": null }, { "topicid": "restmvc", "name": "restmvc", "content": "Intro and annotations", "author": "Josh Long", "category": null } ]
DELETE - http://localhost:7070/api/blogs/id/{id}
REST endpoints for WebFlux:-
GET - http://localhost:6060/api/blogs
GET - http://localhost:6060/api/blogs/id/{id}
POST - http://localhost:6060/api/blogs
DELETE - http://localhost:7070/api/blogs/id/{id}

View on GitHub

Medium Post

Thanks for spending your valuable time!!! please feel free to comment your views or suggestions…