spring: @bean CommandlineRunner. How it returns an object of type CommandlineRunner

user_2897115 0
Viewed 869

I have seen in many places

@SpringBootApplication
public class Application {

    private static final Logger log =
            LoggerFactory.getLogger(Application.class);

    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner demo(UserRepository repo) {
        return (args) -> {
        };
    }
}

how does

    @Bean
    public CommandLineRunner demo(UserRepository repo) {
        return (args) -> {
        };
    }

return an object of type CommandLineRunner

it return a function

(args) -> {
        };

I am not able to understand the syntax also.

Can someone help me to understand

spring-boot
3 Answers

CommandLineRunner is an interface used to indicate that a bean should run when it is contained within a SpringApplication. A Spring Boot application can have multiple beans implementing CommandLineRunner. These can be ordered with @Order.

It has one abstract method :

    void run(String... args) throws Exception

Consider below example:

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    private final Logger logger = LoggerFactory.getLogger(MyCommandLineRunner.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("Loading data..." + args.toString());

    }
}

Since CommandLineRunner contains only only abstract method which return nothing so it automatically becomes the functional interface i.e. we can write lambda expression for it.

Above class can be written as :

(args) -> { 
    logger.info("Loading data..." + args.toString()) 
};

Coming to Your example :

@Bean
public CommandLineRunner demo(String... args) {
    return (args) -> {
    };
}

You are expecting to register a bean in Spring Container which implements CommandLineRunner interface so it can converted to lambda expression.

(args) -> {};

Hope this would clarify it enough.

user_129436270

CommandLineRunner is a functional interface with one method that return void.

That is why when you write: { }; everything is OK.

user_91227190

you should check functional interfaces of Java,

https://www.geeksforgeeks.org/functional-interfaces-java/

In syntheses,

A functional interface is a Java interface with only one abstract method (i.e., a method which has no instructions, only a name).

Functional interfaces are used together with lambda functions.

Suppose we have a functional interface

public interface JustAFunctionalInterface {
      void execute() {};
}

Notice we have only an abstract method, which does not do anything (no instructions).

This functional interface can be implemented like in your code above:

public class Main {
      public static void main(String[] args) {
            JustAFunctionalInterface variable = justAFunctionalInterface();
            variable.execute() // This will print "Hi"
      };

      public static JustAFunctionalInterface justAFunctionalInterface() {
          return (args) -> {System.out.println('Hi')} 
      }; // This chunk of code says that this method will return an interface of type 
         // JustAFunctionalInterface already implemented, where the abstract method "execute" is assigned the lambda function returned in here
}
user_134709120
Related