Add final Configuration class without cglib proxy

As part of performance start-up time improvement, Spring 5.2 brings the option to disable the cglib proxy, allowing henceforth configuration classes to be final.

Mind that inner-class bean method call are no longer possible since no proxy will ensure the unique instance (if bean scope defaulted to singleton).

Reference: spring-projects/spring-boot#9068

Author: tejada7

readme.md

@@ -27,4 +27,5 @@ configuration updates.
 [This video](https://www.youtube.com/watch?time_continue=367&v=GlV5sXdXPu4&feature=emb_logo&themeRefresh=1) helped me discover this great library. 
 
 ### Other useful notes
-* [Bean post processor](src/main/java/com/ftm/vcp/beanpostprocessor/notes_bean_post_processor.md)
+* [Bean post processor](src/main/java/com/ftm/vcp/beanpostprocessor/notes_bean_post_processor.md) 
+* [Bean configuration full vs lite mode](src/main/java/com/ftm/vcp/beanmode/notes_full_vs_line_mode.md)

src/main/java/com/ftm/vcp/beanmode/config/BeanFullModeConfig.java

@@ -5,6 +5,9 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+/**
+ * @see org.springframework.context.annotation.ConfigurationClassUtils
+ */
 @Configuration
 public class BeanFullModeConfig {
 

src/main/java/com/ftm/vcp/beanmode/config/BeanLiteModeConfig.java

@@ -4,6 +4,9 @@
 import com.ftm.vcp.beanmode.model.Person;
 import org.springframework.context.annotation.Bean;
 
+/**
+ * @see org.springframework.context.annotation.ConfigurationClassUtils
+ */
 public class BeanLiteModeConfig {
 
     @Bean("john")

src/main/java/com/ftm/vcp/beanmode/config/BeanWithoutProxyConfig.java

@@ -0,0 +1,24 @@
+package com.ftm.vcp.beanmode.config;
+
+import com.ftm.vcp.beanmode.model.Name;
+import com.ftm.vcp.beanmode.model.Person;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+
+/**
+ * @see org.springframework.context.annotation.ConfigurationClassUtils
+ */
+@Configuration(proxyBeanMethods = false) // This could easily be replaced by @Component
+public final class BeanWithoutProxyConfig {
+
+    @Bean("john")
+    Person getPerson(Name name) {
+        return new Person(name);
+    }
+
+    @Bean
+    Name getName() {
+        return new Name("John");
+    }
+}

src/main/java/com/ftm/vcp/beanmode/notes_full_vs_line_mode.md

@@ -0,0 +1,49 @@
+## Bean configuration's lite vs full mode
+
+`@Configuration` leverages cglib's proxy to ensure that the underlying beans declared in the annotated class are unique
+(if theis scope is defaulted to singleton). That is the reason why classes stereotyped with `@Configuration` aren't allowed
+to be `final`.
+
+That said, **full mode** is when `@Configuration` along with `cglib proxy` are used.
+
+Conversely, beans in **lite mode** can be defined in any other stereotype (including none and `@Configuration(proxyBeanMethods = false)`)
+that can incidentally be a final class.
+
+⚠️ Mind that bean method calls inside the declaring class do will create as many new instances as calls.
+
+```java
+import org.springframework.context.annotation.Bean;
+
+class LiteModeConfig {
+
+    @Bean
+    Foo foo() {
+        return new Foo(foo1()); // This will create a new instance of foo1
+    }
+
+    @Bean
+    Foo foo1() {
+        return new Foo1();
+    }
+}
+```
+
+thus, the correct way yo handle with this would be to leverage parameter injection:
+
+```java
+import org.springframework.context.annotation.Configuration;
+
+@Configuration(proxyBeanMethods = false)
+final class LiteModeConfig {
+
+    @Bean
+    Foo foo(Foo1 foo1) {
+        return new Foo(foo1); // using unique instance of foo1
+    }
+
+    @Bean
+    Foo foo1() {
+        return new Foo1();
+    }
+}
+```

src/test/java/com/ftm/vcp/beanmode/BeanModeTest.java

@@ -1,6 +1,7 @@
 package com.ftm.vcp.beanmode;
 
 import com.ftm.vcp.beanmode.config.BeanFullModeConfig;
+import com.ftm.vcp.beanmode.config.BeanWithoutProxyConfig;
 import com.ftm.vcp.beanmode.config.BeanLiteModeConfig;
 import com.ftm.vcp.beanmode.model.Name;
 import com.ftm.vcp.beanmode.model.Person;
@@ -15,7 +16,7 @@
 class BeanModeTest {
 
     @Test
-    void should_load_new_instances_when_not_using_proper_configuration_annotation() {
+    void should_load_new_instances_when_using_lite_mode() {
         // Given
         final var applicationContext = new AnnotationConfigApplicationContext(BeanLiteModeConfig.class);
 
@@ -28,7 +29,7 @@ void should_load_new_instances_when_not_using_proper_configuration_annotation()
     }
 
     @Test
-    void should_let_spring_create_singleton_beans() {
+    void should_let_spring_create_singleton_beans_when_using_full_mode() {
         // Given
         final var applicationContext = new AnnotationConfigApplicationContext(BeanFullModeConfig.class);
 
@@ -39,4 +40,18 @@ void should_let_spring_create_singleton_beans() {
         // Then
         then(person.name()).isSameAs(name);
     }
+
+    @Test
+    void should_still_let_spring_create_singleton_beans_when_using_full_mode_without_cglib_proxy() {
+        // Given
+        final var applicationContext = new AnnotationConfigApplicationContext(BeanWithoutProxyConfig.class);
+
+        // When
+        final var person = applicationContext.getBean(Person.class);
+        final var name = applicationContext.getBean(Name.class);
+
+        // Then
+        then(person.name()).isSameAs(name);
+    }
+
 }