I think this is a really good question and I think that your concern
centers around the difference between injection and initialization.

In the case of B depending on A initializing something this is my opinion:

Clearly, you have some dependency in the order in which things are
initialized. When I find myself in this situation I tend to implement a
Managed interface (with a start and stop), and then explicitly start all
instances of type A before all instances of type B when that dependency
exists.

When you have many instances of A's then this becomes cumbersome and I
usually use some other class that manages creation and deletion of these
since they've been more organic in my applications. If you can get away
with multi-binding, that's probably reasonable (with a static known number
instances of A). But if there's just one A I tend to actually start it
immediately after creating the injector.

If B ever needs something that A injects, I prefer to inject it into B
(since A changes over time and it's easy to miss the fact that the only
reason a dependency lingers was because it was being passed on down into
B). Even if you need to initialize it in some fashion in A.

If B only needs 'assisted' parameters, then I simply avoid creating the
factory and binding it -- since it all becomes overhead. You've got to draw
the line with some "primitives" and I've found this to work well. If you
ever need it injected in the future, it's a simple change to introduce a
factory (perhaps tedious, but definitely simple).

Others may have other opinions and preferences though, of course! But this
has treated me well in projects large and small.

Nate


On Thu, Aug 21, 2014 at 10:08 AM, Maatary Okouya <[email protected]>
wrote:

> Clarification:
>
> When i say: * I'm saying this because I always thought that, creating
> things somewhere that is unrelated to the class/service that is going to
> use it sounds odd to me.*
>
> *I do not mean that i do not adhere to separating usage from construction,
> but i would rather do it in an enclosing class something like that. Not in
> a place far away completely unrelated.*
>
>
> On Thursday, August 21, 2014 4:48:26 PM UTC+2, Maatary Okouya wrote:
>>
>> Hi,
>>
>> I'd like some advise on the use of assisted injection.
>>
>> Most of the example that i saw about assisted injection, have the
>> following characteristic:
>>
>>
>>    - The class being constructor has a parameter, that comes one or more
>>    parameter that only comes at runtime, that is, that can't be determined at
>>    construction time, and one or many parameters that are known at
>>    construction time. Hence, the create method of the factory only takes, the
>>    parameter provided at runtime.
>>
>>
>> In my case 90% of the time, i just have the runtime parameter. Meaning, I
>> have a class A that needs a class B, but B takes parameters that only A can
>> provide. So there is only @assister Parameter in the constructor of B.
>>
>> I'm wondering if that is the proper usage of assisted injection.
>>
>> One of my last example is the following. A needs to return a class B that
>> is a "dataStructure" (sometimes called DTO, or value object), hence i pass
>> to A the necessary factory, so that after its computation he can return
>> B.Here B, is like a container class.  I have few case like that.
>>
>> The other situation is when service A needs the B Service, but B service
>> depends of a Parameter from A upon creation. Where the parameter from A his
>> himself injected to A, however, A does some initialization on it, before
>> creating B with it.
>>
>> Especially in the last case shall i aim to do the *"internal
>> initialization of A"* outside of A. *The idea is to have specific
>> creation modules in each package, that externalizes the "internal creation
>> of the services" of that package? I'm saying this because I always thought
>> that, creating things somewhere that is unrelated to the class/service that
>> is going to use it sounds odd to me. With my current understanding, each
>> package should provide its creation module, that centralizes the creation
>> of the object that it contains, especially if one use private constructors.*
>>
>> I have used Guice so far for a while, but it is just recently that i red
>> something about separating module, and keeping module with their package. I
>> use to do inheritance between module to chain the creation of object, and
>> ended up having one module that creates everything from start. That is
>> wrong right ?
>>
>> So that is it. I would appreciate some general advice on the right
>> approach in using Guice. I'm not sure that i'm using assisted injection the
>> right way.
>>
>>
>>  --
> You received this message because you are subscribed to the Google Groups
> "google-guice" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to [email protected].
> To post to this group, send email to [email protected].
> Visit this group at http://groups.google.com/group/google-guice.
> To view this discussion on the web visit
> https://groups.google.com/d/msgid/google-guice/ecb0b6e6-0475-42eb-8ef8-8b53df62f109%40googlegroups.com
> <https://groups.google.com/d/msgid/google-guice/ecb0b6e6-0475-42eb-8ef8-8b53df62f109%40googlegroups.com?utm_medium=email&utm_source=footer>
> .
>
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google Groups 
"google-guice" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/google-guice.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/google-guice/CAHNex9_GcC6Fxh%2B00%3DH-89kPEM7w%3Dzcph-425DLaE83%3D6o0qAA%40mail.gmail.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to