Merge branch 'master' into BAEL-20863-move-spring-boot-ctx-fluent

spring-boot-modules/pom.xml

@@ -15,9 +15,12 @@
 
     <modules>
         <module>spring-boot-admin</module>
+        <module>spring-boot-custom-starter</module>
         <module>spring-boot-artifacts</module>
         <module>spring-boot-ctx-fluent</module>
+        <module>spring-boot-autoconfiguration</module>
         <module>spring-boot-data</module>
+        <!-- <module>spring-boot-gradle</module> --> <!-- Not a maven project -->
         <module>spring-boot-keycloak</module>
         <module>spring-boot-mvc-birt</module>
         <module>spring-boot-performance</module>

spring-boot-modules/spring-boot-autoconfiguration/.gitignore

@@ -0,0 +1,5 @@
+/target/
+.settings/
+.classpath
+.project
+

spring-boot-modules/spring-boot-autoconfiguration/README.md

@@ -0,0 +1,12 @@
+## Spring Boot Auto Configuration
+
+This module contains articles about Spring Boot Auto Configuration
+
+### The Course
+The "REST With Spring" Classes: http://bit.ly/restwithspring
+
+### Relevant Articles:
+
+- [Create a Custom Auto-Configuration with Spring Boot](https://www.baeldung.com/spring-boot-custom-auto-configuration)
+- [Guide to ApplicationContextRunner in Spring Boot](https://www.baeldung.com/spring-boot-context-runner)
+- [A Guide to Spring Boot Configuration Metadata](https://www.baeldung.com/spring-boot-configuration-metadata)

spring-boot-modules/spring-boot-autoconfiguration/pom.xml

@@ -0,0 +1,118 @@
+<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-boot-autoconfiguration</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-boot-autoconfiguration</name>
+    <packaging>war</packaging>
+    <description>This is simple boot application demonstrating a custom auto-configuration</description>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-boot-2</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-boot-2</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-thymeleaf</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <version>2.1.6.RELEASE</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>spring-boot</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-war-plugin</artifactId>
+            </plugin>
+        </plugins>
+
+    </build>
+
+    <profiles>
+        <profile>
+            <id>autoconfiguration</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>integration-test</phase>
+                                <goals>
+                                    <goal>test</goal>
+                                </goals>
+                                <configuration>
+                                    <excludes>
+                                        <exclude>**/*LiveTest.java</exclude>
+                                        <exclude>**/*IntegrationTest.java</exclude>
+                                        <exclude>**/*IntTest.java</exclude>
+                                    </excludes>
+                                    <includes>
+                                        <include>**/AutoconfigurationTest.java</include>
+                                    </includes>
+                                </configuration>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <test.mime>json</test.mime>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
+    <properties>
+        <jquery.version>3.1.1</jquery.version>
+        <bootstrap.version>3.3.7-1</bootstrap.version>
+        <subethasmtp.version>3.1.7</subethasmtp.version>
+        <tomee-servlet-api.version>8.5.11</tomee-servlet-api.version>
+    </properties>
+
+</project>

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/MySQLAutoconfiguration.java

@@ -0,0 +1,118 @@
+package com.baeldung.autoconfiguration;
+
+import java.util.Arrays;
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.AutoConfigureOrder;
+import org.springframework.boot.autoconfigure.condition.ConditionMessage;
+import org.springframework.boot.autoconfigure.condition.ConditionMessage.Style;
+import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnResource;
+import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ConditionContext;
+import org.springframework.context.annotation.Conditional;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.core.Ordered;
+import org.springframework.core.env.Environment;
+import org.springframework.core.type.AnnotatedTypeMetadata;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.util.ClassUtils;
+
+@Configuration
+@ConditionalOnClass(DataSource.class)
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@PropertySource("classpath:mysql.properties")
+public class MySQLAutoconfiguration {
+
+    @Autowired
+    private Environment env;
+
+    @Bean
+    @ConditionalOnProperty(name = "usemysql", havingValue = "local")
+    @ConditionalOnMissingBean
+    public DataSource dataSource() {
+        final DriverManagerDataSource dataSource = new DriverManagerDataSource();
+
+        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
+        dataSource.setUrl("jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true&&serverTimezone=UTC");
+        dataSource.setUsername("mysqluser");
+        dataSource.setPassword("mysqlpass");
+
+        return dataSource;
+    }
+
+    @Bean(name = "dataSource")
+    @ConditionalOnProperty(name = "usemysql", havingValue = "custom")
+    @ConditionalOnMissingBean
+    public DataSource dataSource2() {
+        final DriverManagerDataSource dataSource = new DriverManagerDataSource();
+
+        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
+        dataSource.setUrl(env.getProperty("mysql.url"));
+        dataSource.setUsername(env.getProperty("mysql.user") != null ? env.getProperty("mysql.user") : "");
+        dataSource.setPassword(env.getProperty("mysql.pass") != null ? env.getProperty("mysql.pass") : "");
+
+        return dataSource;
+    }
+
+    @Bean
+    @ConditionalOnBean(name = "dataSource")
+    @ConditionalOnMissingBean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource());
+        em.setPackagesToScan("com.baeldung.autoconfiguration.example");
+        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
+        if (additionalProperties() != null) {
+            em.setJpaProperties(additionalProperties());
+        }
+        return em;
+    }
+
+    @Bean
+    @ConditionalOnMissingBean(type = "JpaTransactionManager")
+    JpaTransactionManager transactionManager(final EntityManagerFactory entityManagerFactory) {
+        final JpaTransactionManager transactionManager = new JpaTransactionManager();
+        transactionManager.setEntityManagerFactory(entityManagerFactory);
+        return transactionManager;
+    }
+
+    @ConditionalOnResource(resources = "classpath:mysql.properties")
+    @Conditional(HibernateCondition.class)
+    final Properties additionalProperties() {
+        final Properties hibernateProperties = new Properties();
+
+        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("mysql-hibernate.hbm2ddl.auto"));
+        hibernateProperties.setProperty("hibernate.dialect", env.getProperty("mysql-hibernate.dialect"));
+        hibernateProperties.setProperty("hibernate.show_sql", env.getProperty("mysql-hibernate.show_sql") != null ? env.getProperty("mysql-hibernate.show_sql") : "false");
+
+        return hibernateProperties;
+    }
+
+    static class HibernateCondition extends SpringBootCondition {
+
+        private static final String[] CLASS_NAMES = { "org.hibernate.ejb.HibernateEntityManager", "org.hibernate.jpa.HibernateEntityManager" };
+
+        @Override
+        public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+            ConditionMessage.Builder message = ConditionMessage.forCondition("Hibernate");
+
+            return Arrays.stream(CLASS_NAMES).filter(className -> ClassUtils.isPresent(className, context.getClassLoader())).map(className -> ConditionOutcome.match(message.found("class").items(Style.NORMAL, className))).findAny()
+                    .orElseGet(() -> ConditionOutcome.noMatch(message.didNotFind("class", "classes").items(Style.NORMAL, Arrays.asList(CLASS_NAMES))));
+        }
+
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/annotationprocessor/AnnotationProcessorApplication.java

@@ -0,0 +1,15 @@
+package com.baeldung.autoconfiguration.annotationprocessor;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.context.annotation.ComponentScan;
+
+import com.baeldung.autoconfiguration.MySQLAutoconfiguration;
+
+@EnableAutoConfiguration(exclude = { MySQLAutoconfiguration.class})
+@ComponentScan(basePackageClasses = {DatabaseProperties.class})
+public class AnnotationProcessorApplication {
+    public static void main(String[] args) {
+        new SpringApplicationBuilder(AnnotationProcessorApplication.class).run();
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/annotationprocessor/DatabaseProperties.java

@@ -0,0 +1,73 @@
+package com.baeldung.autoconfiguration.annotationprocessor;
+
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "database")
+public class DatabaseProperties {
+
+    public static class Server {
+
+        /**
+         * The IP of the database server
+         */
+        private String ip;
+
+        /**
+         * The Port of the database server.
+         * The Default value is 443.
+         * The allowed values are in the range 400-4000.
+         */
+        @Min(400)
+        @Max(800)
+        private int port = 443;
+
+        public String getIp() {
+            return ip;
+        }
+
+        public void setIp(String ip) {
+            this.ip = ip;
+        }
+
+        public int getPort() {
+            return port;
+        }
+
+        public void setPort(int port) {
+            this.port = port;
+        }
+    }
+
+    private String username;
+    private String password;
+    private Server server;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Server getServer() {
+        return server;
+    }
+
+    public void setServer(Server server) {
+        this.server = server;
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/example/AutoconfigurationApplication.java

@@ -0,0 +1,12 @@
+package com.baeldung.autoconfiguration.example;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class AutoconfigurationApplication {
+    
+    public static void main(String[] args) {
+        SpringApplication.run(AutoconfigurationApplication.class, args);
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/example/MyUser.java

@@ -0,0 +1,27 @@
+package com.baeldung.autoconfiguration.example;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class MyUser {
+    @Id
+    private String email;
+
+    public MyUser() {
+    }
+
+    public MyUser(String email) {
+        super();
+        this.email = email;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/example/MyUserRepository.java

@@ -0,0 +1,7 @@
+package com.baeldung.autoconfiguration.example;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MyUserRepository extends JpaRepository<MyUser, String> {
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/service/CustomService.java

@@ -0,0 +1,10 @@
+package com.baeldung.autoconfiguration.service;
+
+public class CustomService implements SimpleService {
+
+    @Override
+    public String serve() {
+        return "Custom Service";
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/service/DefaultService.java

@@ -0,0 +1,10 @@
+package com.baeldung.autoconfiguration.service;
+
+public class DefaultService implements SimpleService {
+
+    @Override
+    public String serve() {
+        return "Default Service";
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/java/com/baeldung/autoconfiguration/service/SimpleService.java

@@ -0,0 +1,7 @@
+package com.baeldung.autoconfiguration.service;
+
+public interface SimpleService {
+
+    public String serve();
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/main/resources/META-INF/spring.factories

@@ -0,0 +1 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.baeldung.autoconfiguration.MySQLAutoconfiguration

spring-boot-modules/spring-boot-autoconfiguration/src/main/resources/application.properties

@@ -0,0 +1,2 @@
+spring.jpa.show-sql=true
+spring.jpa.hibernate.ddl-auto = update

spring-boot-modules/spring-boot-autoconfiguration/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

spring-boot-modules/spring-boot-autoconfiguration/src/main/resources/mysql.properties

@@ -0,0 +1,5 @@
+usemysql=local
+
+mysql-hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
+mysql-hibernate.show_sql=true
+mysql-hibernate.hbm2ddl.auto=create-drop

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/SpringContextLiveTest.java

@@ -0,0 +1,19 @@
+package com.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+
+import com.baeldung.autoconfiguration.MySQLAutoconfiguration;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = MySQLAutoconfiguration.class)
+@WebAppConfiguration
+public class SpringContextLiveTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/AutoconfigurationLiveTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.autoconfiguration;
+
+import com.baeldung.autoconfiguration.example.AutoconfigurationApplication;
+import com.baeldung.autoconfiguration.example.MyUser;
+import com.baeldung.autoconfiguration.example.MyUserRepository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest(classes = AutoconfigurationApplication.class)
+@EnableJpaRepositories(basePackages = { "com.baeldung.autoconfiguration.example" })
+public class AutoconfigurationLiveTest {
+
+    @Autowired
+    private MyUserRepository userRepository;
+
+    @Test
+    public void whenSaveUser_thenOk() {
+        MyUser user = new MyUser("[email protected]");
+        userRepository.save(user);
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnBeanIntegrationTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+public class ConditionalOnBeanIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenDependentBeanIsPresent_thenConditionalBeanCreated() {
+        this.contextRunner.withUserConfiguration(BasicConfiguration.class, ConditionalOnBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("created");
+                assertThat(context).getBean("created")
+                    .isEqualTo("This is always created");
+                assertThat(context).hasBean("createOnBean");
+                assertThat(context).getBean("createOnBean")
+                    .isEqualTo("This is created when bean (name=created) is present");
+            });
+    }
+
+    @Test
+    public void whenDependentBeanIsPresent_thenConditionalMissingBeanIgnored() {
+        this.contextRunner.withUserConfiguration(BasicConfiguration.class, ConditionalOnMissingBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("created");
+                assertThat(context).getBean("created")
+                    .isEqualTo("This is always created");
+                assertThat(context).doesNotHaveBean("createOnMissingBean");
+            });
+    }
+
+    @Test
+    public void whenDependentBeanIsNotPresent_thenConditionalMissingBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingBeanConfiguration.class)
+            .run((context) -> {
+                assertThat(context).hasBean("createOnMissingBean");
+                assertThat(context).getBean("createOnMissingBean")
+                    .isEqualTo("This is created when bean (name=created) is missing");
+                assertThat(context).doesNotHaveBean("created");
+            });
+    }
+
+    @Configuration
+    protected static class BasicConfiguration {
+        @Bean
+        public String created() {
+            return "This is always created";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnBean(name = "created")
+    protected static class ConditionalOnBeanConfiguration {
+        @Bean
+        public String createOnBean() {
+            return "This is created when bean (name=created) is present";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnMissingBean(name = "created")
+    protected static class ConditionalOnMissingBeanConfiguration {
+        @Bean
+        public String createOnMissingBean() {
+            return "This is created when bean (name=created) is missing";
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnClassIntegrationTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
+import org.springframework.boot.test.context.FilteredClassLoader;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+public class ConditionalOnClassIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenDependentClassIsPresent_thenBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnClassConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("created");
+                assertThat(context.getBean("created")).isEqualTo("This is created when ConditionalOnClassIntegrationTest is present on the classpath");
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsPresent_thenBeanMissing() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingClassConfiguration.class)
+            .run(context -> {
+                assertThat(context).doesNotHaveBean("missed");
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsNotPresent_thenBeanMissing() {
+        this.contextRunner.withUserConfiguration(ConditionalOnClassConfiguration.class)
+            .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
+            .run((context) -> {
+                assertThat(context).doesNotHaveBean("created");
+                assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);
+
+            });
+    }
+
+    @Test
+    public void whenDependentClassIsNotPresent_thenBeanCreated() {
+        this.contextRunner.withUserConfiguration(ConditionalOnMissingClassConfiguration.class)
+            .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
+            .run((context) -> {
+                assertThat(context).hasBean("missed");
+                assertThat(context).getBean("missed")
+                    .isEqualTo("This is missed when ConditionalOnClassIntegrationTest is present on the classpath");
+                assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);
+
+            });
+    }
+
+    @Configuration
+    @ConditionalOnClass(ConditionalOnClassIntegrationTest.class)
+    protected static class ConditionalOnClassConfiguration {
+        @Bean
+        public String created() {
+            return "This is created when ConditionalOnClassIntegrationTest is present on the classpath";
+        }
+    }
+
+    @Configuration
+    @ConditionalOnMissingClass("com.baeldung.autoconfiguration.ConditionalOnClassIntegrationTest")
+    protected static class ConditionalOnMissingClassConfiguration {
+        @Bean
+        public String missed() {
+            return "This is missed when ConditionalOnClassIntegrationTest is present on the classpath";
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/ConditionalOnPropertyIntegrationTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.autoconfiguration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.TestPropertySource;
+
+import com.baeldung.autoconfiguration.service.CustomService;
+import com.baeldung.autoconfiguration.service.DefaultService;
+import com.baeldung.autoconfiguration.service.SimpleService;
+
+public class ConditionalOnPropertyIntegrationTest {
+
+    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
+
+    @Test
+    public void whenGivenCustomPropertyValue_thenCustomServiceCreated() {
+        this.contextRunner.withPropertyValues("com.baeldung.service=custom")
+            .withUserConfiguration(SimpleServiceConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("customService");
+                SimpleService simpleService = context.getBean(CustomService.class);
+                assertThat(simpleService.serve()).isEqualTo("Custom Service");
+                assertThat(context).doesNotHaveBean("defaultService");
+            });
+    }
+
+    @Test
+    public void whenGivenDefaultPropertyValue_thenDefaultServiceCreated() {
+        this.contextRunner.withPropertyValues("com.baeldung.service=default")
+            .withUserConfiguration(SimpleServiceConfiguration.class)
+            .run(context -> {
+                assertThat(context).hasBean("defaultService");
+                SimpleService simpleService = context.getBean(DefaultService.class);
+                assertThat(simpleService.serve()).isEqualTo("Default Service");
+                assertThat(context).doesNotHaveBean("customService");
+            });
+    }
+
+    @Configuration
+    @TestPropertySource("classpath:ConditionalOnPropertyTest.properties")
+    protected static class SimpleServiceConfiguration {
+
+        @Bean
+        @ConditionalOnProperty(name = "com.baeldung.service", havingValue = "default")
+        @ConditionalOnMissingBean
+        public DefaultService defaultService() {
+            return new DefaultService();
+        }
+
+        @Bean
+        @ConditionalOnProperty(name = "com.baeldung.service", havingValue = "custom")
+        @ConditionalOnMissingBean
+        public CustomService customService() {
+            return new CustomService();
+        }
+    }
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/SpringContextLiveTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.autoconfiguration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.autoconfiguration.example.AutoconfigurationApplication;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = AutoconfigurationApplication.class)
+@EnableJpaRepositories(basePackages = { "com.baeldung.autoconfiguration.example" })
+public class SpringContextLiveTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/java/com/baeldung/autoconfiguration/annotationprocessor/DatabasePropertiesIntegrationTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.autoconfiguration.annotationprocessor;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = AnnotationProcessorApplication.class)
+@TestPropertySource("classpath:databaseproperties-test.properties")
+public class DatabasePropertiesIntegrationTest {
+
+    @Autowired
+    private DatabaseProperties databaseProperties;
+
+    @Test
+    public void whenSimplePropertyQueriedThenReturnsPropertyValue() throws Exception {
+        Assert.assertEquals("Incorrectly bound Username property", "baeldung", databaseProperties.getUsername());
+        Assert.assertEquals("Incorrectly bound Password property", "password", databaseProperties.getPassword());
+    }
+    
+    @Test
+    public void whenNestedPropertyQueriedThenReturnsPropertyValue() throws Exception {
+    	Assert.assertEquals("Incorrectly bound Server IP nested property", "127.0.0.1", databaseProperties.getServer().getIp());
+        Assert.assertEquals("Incorrectly bound Server Port nested property", 3306, databaseProperties.getServer().getPort());
+    }   
+
+}

spring-boot-modules/spring-boot-autoconfiguration/src/test/resources/ConditionalOnPropertyTest.properties

@@ -0,0 +1 @@
+com.baeldung.service=custom

spring-boot-modules/spring-boot-autoconfiguration/src/test/resources/databaseproperties-test.properties

@@ -0,0 +1,7 @@
+#Simple Properties
+database.username=baeldung
+database.password=password
+
+#Nested Properties
+database.server.ip=127.0.0.1
+database.server.port=3306

spring-boot-modules/spring-boot-custom-starter/README.md

@@ -0,0 +1,16 @@
+## Spring Boot Custom Starter
+
+This module contains articles about writing [Spring Boot Starters](https://www.baeldung.com/spring-boot-starters).
+
+### Relevant Articles: 
+- [Creating a Custom Starter with Spring Boot](https://www.baeldung.com/spring-boot-custom-starter)
+
+- **greeter-library**: The sample library that we're creating the starter for.
+
+- **greeter-spring-boot-autoconfigure**: The project containing the auto-configuration for the library.
+
+- **greeter-spring-boot-starter**: The custom starter for the library.
+
+- **greeter-spring-boot-sample-app**: The sample project that uses the custom starter.
+
+- [Multi-Module Project With Spring Boot](https://www.baeldung.com/spring-boot-multiple-modules)

spring-boot-modules/spring-boot-custom-starter/greeter-library/README.md

@@ -0,0 +1,19 @@
+# Greeter App
+
+This app takes in the user's name and messages for different times of day as configuration parameters and outptus the greeting messge. For example it will take the name **John** and the message for morning time as **Good Morning** and output the message **Hello John, Good Morning**.
+
+## Usage
+
+Create and populate the class `GreetingConfig`, instantiate a `Greeter` using the `GreetingConfig` and use it get greeting messages:
+
+```java
+GreetingConfig greetingConfig = new GreetingConfig();
+greetingConfig.put(USER_NAME, "World");
+greetingConfig.put(MORNING_MESSAGE, "Good Morning");
+greetingConfig.put(AFTERNOON_MESSAGE, "Good Afternoon");
+greetingConfig.put(EVENING_MESSAGE, "Good Evening");
+greetingConfig.put(NIGHT_MESSAGE, "Good Night");
+
+Greeter greeter = new Greeter(greetingConfig);
+greeter.greet();
+```

spring-boot-modules/spring-boot-custom-starter/greeter-library/pom.xml

@@ -0,0 +1,15 @@
+<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>greeter-library</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+	<name>greeter-library</name>
+	
+    <parent>
+        <groupId>com.baeldung.spring-boot-modules</groupId>
+        <artifactId>spring-boot-custom-starter</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+</project>

spring-boot-modules/spring-boot-custom-starter/greeter-library/src/main/java/com/baeldung/greeter/library/Greeter.java

@@ -0,0 +1,35 @@
+package com.baeldung.greeter.library;
+
+import static com.baeldung.greeter.library.GreeterConfigParams.*;
+
+import java.time.LocalDateTime;
+
+public class Greeter {
+
+    private GreetingConfig greetingConfig;
+
+    public Greeter(GreetingConfig greetingConfig) {
+        this.greetingConfig = greetingConfig;
+    }
+
+    public String greet(LocalDateTime localDateTime) {
+
+        String name = greetingConfig.getProperty(USER_NAME);
+        int hourOfDay = localDateTime.getHour();
+
+        if (hourOfDay >= 5 && hourOfDay < 12) {
+            return String.format("Hello %s, %s", name, greetingConfig.get(MORNING_MESSAGE));
+        } else if (hourOfDay >= 12 && hourOfDay < 17) {
+            return String.format("Hello %s, %s", name, greetingConfig.get(AFTERNOON_MESSAGE));
+        } else if (hourOfDay >= 17 && hourOfDay < 20) {
+            return String.format("Hello %s, %s", name, greetingConfig.get(EVENING_MESSAGE));
+        } else {
+            return String.format("Hello %s, %s", name, greetingConfig.get(NIGHT_MESSAGE));
+        }
+    }
+
+    public String greet() {
+        return greet(LocalDateTime.now());
+    }
+
+}