CODEWITHSUNDEEP
springspring-aop
Faraz
Faraz

Reputation: 6265

Spring Proxy Creation of Classes annotated with @Configuration or @Component

Spring uses either JDK dynamic proxies or CGLIB to create the proxy for a given target object. If a class is annotated with @Configuration, then CGLIB is used.

However, one limitation of Spring AOP is that once the call has finally reached the target object, any method calls that it may make on itself are going to be invoked against the this reference, and not the proxy. This piece of information is important to remember when using @Transactional and in other places as well.

So having that knowledge, in the code below, is Spring injecting the actual instance or the proxy of SimpleBean?

@Configuration
public class Config {

@Bean
public SimpleBean simpleBean() {
    return new SimpleBean();
}

@Bean
public SimpleBeanConsumer simpleBeanConsumer() {
    return new SimpleBeanConsumer(simpleBean()); //<---
}
}

And what is the behavior if a class is annotation with @Component?

Upvotes: 3

Views: 3023

Answers (1)

Mark Bramnik
Mark Bramnik

Reputation: 42441

Let me give you another perspective.

Say there is an another bean AnotherBeanConsumer that also needs a simpleBean. Simple Bean has a Singleton scope:

 @Configuration
 public class Config {
    @Bean
    public SimpleBean simpleBean() {
       return new SimpleBean();
    }

    @Bean
    public SimpleBeanConsumer simpleBeanConsumer() {
       return new SimpleBeanConsumer(simpleBean());
    }

    @Bean
    public AnotherBeanConsumer anotherBeanConsumer() {
       return new AnotherBeanConsumer(simpleBean());
    }        
 }

Now the question is, how its possible that two calls to simpleBean() made from different methods simpleBeanConsumer and anotherBeanConsumer return the same instance of the simple bean (since its a singleton obviously)?

IMO (and disclaimer, I'm not affiliated with spring or something), This is the main reason of creating proxies that wrap Configurations.

Now indeed Spring AOP has a limitation of calling methods just as you've stated, however who said that spring under-the-hood uses spring AOP? The bytecode instrumentation done on much lower levels doesn't have a limitation like this. After all creating a proxy means: "create a proxy object that will have the same interface but will alter the behavior", right?

For example if you use CGLIB that uses inheritance you could create a proxy out of configuration that looks like this (schematically):

class CGLIB_GENERATED_PROXY extends Config {

     private Map<String, Object> singletonBeans;

     public SimpleBean simpleBean() {
         String name = getNameFromMethodNameMaybePrecached();
         if(singletonBeans.get(name) != null) {
            return singletonBeans.get(name);
         }  
         else {
            SimpleBean bean = super.simpleBean(); 
            singletonBeans.put(name, bean);
            return bean;    
         }
     }
     ....
}

Of course its only a schematic picture, in real life there is an application context that basically provides the access to the map like this, but you get the point.

If its not enough, then there are some even more sophisticated frameworks that spring must make use of in order to load a configuration (like ASM)...

Here is an example: If you use @ConditionalOnClass(A.class) and the class doesn't really exist in runtime, how spring can load the bytecode of the configuration that uses this configuration and not fail on something like NoClassDefFoundException?

My point is that it goes far beyond the spring AOP, and has its quirks :)

Having said that, nothing that I've describe above requires the real components to be always wrapped in Proxies of any kind. So in the most trivial case, when SimpleBean does not by itself have some annotations that require proxy generation (stuff like @Cached, @Transactional and so forth), Spring won't wrap the object of that type and you'll get a plain SimpleBean object.

Upvotes: 1

Related Questions