{"id":83969,"date":"2018-11-28T10:00:20","date_gmt":"2018-11-28T08:00:20","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=83969"},"modified":"2018-11-27T12:10:39","modified_gmt":"2018-11-27T10:10:39","slug":"running-code-spring-boot-startup","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/11\/running-code-spring-boot-startup.html","title":{"rendered":"Running code on Spring Boot startup"},"content":{"rendered":"

Spring Boot does a lot of configuration automatically for us but sooner or later you\u2019ll have to do some custom work. In this post, you will learn how to hook into the application bootstrap lifecycle and execute code on Spring Boot startup<\/b>.<\/p>\n

So let\u2019s see what the framework has to offer.<\/ins><\/p>\n

1. Execute method on bean initialization<\/h2>\n

The simplest way to run some logic once the Spring starts your application is to execute the code as part of a chosen bean bootstrapping process.<\/p>\n

What you have to do?<\/p>\n

Just create a class, mark it as a Spring component, and put the app initialization code in a method with the @PostConstruct<\/i> annotation. In theory, you could use a constructor instead of a separate method but it\u2019s a good practice to separate the object\u2019s construction from its real responsibility.<\/p>\n

@Component\r\nclass AppInitializator {\r\n\r\n    private static final Logger log = LoggerFactory.getLogger(AppInitializator.class);\r\n\r\n    @PostConstruct\r\n    private void init() {\r\n        log.info(\"AppInitializator initialization logic ...\");\r\n        \/\/ ...\r\n    }\r\n\r\n}<\/pre>\n
If you use the lazy initialization of the application context (e.g. to speed up Spring Boot startup<\/a>), the bean with initialization logic should be excluded from this mechanism. I\u2019ve described how to create a bean eagerly with the @Lazy annotation when whole Spring context uses lazy loading<\/a>.<\/p>\n
You can also create a method with the @PostConstruct<\/i> annotation inside your main Spring Boot application class. Don\u2019t forget that the main class is also a component managed by the framework.<\/p>\n
@SpringBootApplication\r\npublic class InitDemoApplication {\r\n\r\n    \/\/ ...\r\n\r\n    @PostConstruct\r\n    private void init() {\r\n        log.info(\"InitDemoApplication initialization logic ...\");\r\n        \/\/ ...\r\n    }\r\n\r\n}<\/pre>\n
But this solution feels like a workaround rather than a real solution. You can control the order in which the Spring framework creates application beans in a very limited way. If we want to run the initialization logic before all beans are created or even before the framework starts, we need to find something better.<\/p>\n
2. Spring Boot startup hooks<\/h2>\n
The beauty of applications created with Spring Boot is that the only thing you need to run them is Java Runtime Environment and the command line interface. No external tools or application required. It runs just like a regular Java SE program.
 
<\/div> <\/div><\/p>\n
As every Java program, you start execution of such application in the static main method of your entry application class. That\u2019s the point in which you can hook into Spring Boot initialization process.<\/p>\n
2.1. Creating Spring Boot hook<\/h3>\n
Start by changing the code in your main method to extract appending of startup hooks to a separate method. You should add Spring Boot hooks before the application is started.<\/p>\n
public static void main(String[] args) {\r\n    SpringApplication application = new SpringApplication(InitDemoApplication.class);\r\n    addInitHooks(application);\r\n    application.run(args);\r\n}\r\n\r\nstatic void addInitHooks(SpringApplication application) {\r\n    \/\/ TBD \u2026\r\n}<\/pre>\n
When a Spring Boot application starts, it publishes several events on individual steps of the bootstrap process. The API of the SpringApplication class exposes a method which we can use to add listeners for those events.<\/p>\n
Here\u2019s an example which runs a startup method on the event published before the Spring context starts creating your beans:<\/p>\n
static void addInitHooks(SpringApplication application) {\r\n   application.addListeners((ApplicationListener<ApplicationEnvironmentPreparedEvent>) event -> {\r\n       String version = event.getEnvironment().getProperty(\"java.runtime.version\");\r\n       log.info(\"Running with Java {}\", version);\r\n   });\r\n}<\/pre>\n
2.2. Event types<\/h3>\n
Depending on the event type<\/a>, the object which Spring passes to the listener may give you access to several useful operations. In the previous example, we read some environment property but we could also modify it if needed.<\/p>\n
Here\u2019s the list of possible events sorted by the order in which events are published by Spring Boot on the startup:<\/p>\n