Spring Boot @ConditionalOnMissingClass Annotation Example
In this section we will learn about @ConditionalOnMissingClass Annotation.
For example, when providing library/framework classes to other developers, this annotation can be used to active certain beans only based on the absence of specific classes.
The @ConditionalOnMissingClass annotation may be used on any class annotated with @Configuration, @Component, @Service & @Repository or on methods annotated with @Bean.
1. Using @ConditionalOnMissingClass on @Bean method
To illustrate the use of @ConditionalOnMissingClass, we will create one simple service classe, SMSNotificationService class.
public class SMSNotificationService {
public SMSNotificationService() {
System.out.println("Inside SMSNotificationService Constructor");
}
public void sendSmsNotification()
{
System.out.println("Sending SMS Notification");
}
}
Next, we will create a Spring Config class and use annotation @ConditionalOnMissingClass.
@Configuration
public class AppConfig {
@Bean
@ConditionalOnMissingClass(value =
"com.knf.dev.demo.provider.NotificationProvider")
public SMSNotificationService smsNotificationService()
{
return new SMSNotificationService();
}
}
Here, SMSNotificationService bean will register to the application context if NotificationProvider class is not found in the classpath.
2. Using @ConditionalOnMissingClass on @Service class
@Service
@ConditionalOnMissingClass(value=
"com.knf.dev.demo.provider.NotificationProvider")
public class TwitterNotificationService {
public TwitterNotificationService() {
System.out.println("Inside TwitterNotificationService Constructor");
}
public void sendTwitterNotification()
{
System.out.println("Sending Twitter Notification");
}
}
@Service
@ConditionalOnMissingClass(value=
"com.knf.dev.demo.provider.NotificationProvider")
public class TwitterNotificationService {
public TwitterNotificationService() {
System.out.println("Inside TwitterNotificationService Constructor");
}
public void sendTwitterNotification()
{
System.out.println("Sending Twitter Notification");
}
}
Here TwitterNotificationService bean will register to the application context if NotificationProvider class is not found in the classpath.
The following example creates a Spring Boot web application which uses @ConditionalOnMissingClass annotation.
Project Directory
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.0.1</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.knf.dev.demo</groupId>
<artifactId>spring-boot-conditionalonmissingclass-annotation-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-conditionalonmissingclass-annotation-example</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
SMSNotificationService.java
package com.knf.dev.demo.service;
public class SMSNotificationService {
public SMSNotificationService() {
System.out.println("Inside SMSNotificationService Constructor");
}
public void sendSmsNotification()
{
System.out.println("Sending SMS Notification");
}
}
package com.knf.dev.demo.service;
public class SMSNotificationService {
public SMSNotificationService() {
System.out.println("Inside SMSNotificationService Constructor");
}
public void sendSmsNotification()
{
System.out.println("Sending SMS Notification");
}
}
AppConfig.java
package com.knf.dev.demo.config;
import com.knf.dev.demo.service.SMSNotificationService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
@ConditionalOnMissingClass(value =
"com.knf.dev.demo.provider.NotificationProvider")
public SMSNotificationService smsNotificationService()
{
return new SMSNotificationService();
}
}
package com.knf.dev.demo.config;
import com.knf.dev.demo.service.SMSNotificationService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
@ConditionalOnMissingClass(value =
"com.knf.dev.demo.provider.NotificationProvider")
public SMSNotificationService smsNotificationService()
{
return new SMSNotificationService();
}
}
TwitterNotificationService.java
package com.knf.dev.demo.service;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.stereotype.Service;
@Service
@ConditionalOnMissingClass(value=
"com.knf.dev.demo.provider.NotificationProvider")
public class TwitterNotificationService {
public TwitterNotificationService() {
System.out.println("Inside TwitterNotificationService Constructor");
}
public void sendTwitterNotification()
{
System.out.println("Sending Twitter Notification");
}
}
package com.knf.dev.demo.service;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.stereotype.Service;
@Service
@ConditionalOnMissingClass(value=
"com.knf.dev.demo.provider.NotificationProvider")
public class TwitterNotificationService {
public TwitterNotificationService() {
System.out.println("Inside TwitterNotificationService Constructor");
}
public void sendTwitterNotification()
{
System.out.println("Sending Twitter Notification");
}
}
Run the application - Application.java
package com.knf.dev.demo;
import com.knf.dev.demo.service.SMSNotificationService;
import com.knf.dev.demo.service.TwitterNotificationService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ConfigurableApplicationContext context =
SpringApplication.run(Application.class, args);
SMSNotificationService smsNotificationService =
context.getBean(SMSNotificationService.class);
smsNotificationService.sendSmsNotification();
TwitterNotificationService twitterNotificationService =
context.getBean(TwitterNotificationService.class);
twitterNotificationService.sendTwitterNotification();
context.close();
}
}
Application is the entry point that sets up the Spring Boot application. The @SpringBootApplication annotation enables auto-configuration and component scanning.
Let's run this Spring boot application from either IntelliJ IDEA IDE by right click - Run 'Application.main()'
Or you can use the below maven command to run:
mvn spring-boot:runConsole Output:
Inside TwitterNotificationService Constructor
Inside SMSNotificationService Constructor
Sending SMS Notification
Sending Twitter Notification
Download Source Code
More related topics,
