How google guice works internally

I was going through the google guice and then i thought about how it might be working.

So This is my theory on how property injector might be working.

Guice first wants us to create a injector and pass all the binding information to it.

Injector injector = Guice.createInjector(new BillingModule());

*code snippets from google guice page

OK at this point i can think that there is a class with all the information of binding.

and when we do

injector.getInstance(RealBillingService.class);

Here we do the trick.

injector will return a proxy instance for the real RealBillingService object and when we call a

method of RealBillingService object, proxy instance invocation handler uses reflection to

figure out the properties to inject and fullfill it based on the information passed during the creation of injector.

QUESTION

This is the way i suppose, the guice works. If i am wrong, what would be the actual way by which 'Guice' achieve it ?

If this is the way guice work then Guice always returns the proxy object and the user code always makes call on the proxy objects. is this true ?

---

Pictorial representation on my explaination

Your understanding is a little off. Think of it this way: when you do Guice.createInjector(...), that's when Guice does all the reflection to figure out what depends on what and what needs to get injected where. When you do injector.getInstance(...), Guice doesn't need to do any reflection. It creates the RealBillingService right then, injecting all its (transitive) dependencies, and returns that (not a proxy).

If you use Guice's AOP functionality then those objects will be proxies, but otherwise Guice doesn't return proxies. It simply invokes the @Inject constructor, sets the @Inject-annotated fields, calls the @Inject-annotated methods, and returns that object.

EDIT: See also MiniGuice, a single-class implementation of a Guice-like injector.