2

In my spring-based project I have a core module ('core') with a class 

@Component public class Superclass { // stuff }

instances of which are injected by type throughout the code like this:

public class AService { @Autowired private Superclass superclass; // service stuff }

I also have two other modules that depend on the core module and one of which (let's call it 'module1') extends Superclass:

@component public class Subclass extends Superclass { // overridden stuff }

The other module ('module2') uses Superclass as is.

Now I want that when I compile and run 'child1' an instance of Subclass is used everywhere an instance of Superclass is expected. So I write a configuration class:

@Configuration public class Module2Configuration { @Bean public Superclass superclass(){ return new Subclass(); } }

When I run this I see both Superclass and Subclass instantiated which is definitely not what I want. How do specify in 'module1' which type Spring should instantiate?

Improve this question

3 Answers 3

Reset to default
3

You can use @Qualifier("some name") annotation. There is more information about that: http://blogs.sourceallies.com/2011/08/spring-injection-with-resource-and-autowired/

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

Spring eagerly instantiates singleton beans as stated in the documentation:

By default, ApplicationContext implementations eagerly create and configure all singleton beans as part of the initialization process.

which might explain why both @Components are created.

To specifiy which implementation is provided as a dependency you might want to check on Qualifiers that enable to choose between different implementations. In combination with lazy loading this should do the trick.

Depending on your personal taste you could also use delegation instead of inheritance using a separated interface:

public interface MyService { public String foobar(int baz); } public static class CommonBehavior { // whatever is used by Superclass and Subclass } @Component @Lazy public class FormerSuperClass implements MyService { private final CommonBehavior ...; ... } @Component @Lazy public class FormerSubClass implements MyService { private final CommonBehavior ...; ... }

Good luck!

Improve this answer

4 Comments

thanks, I thought of that, but the 'core' module doesn't know anything about 'module1's Subclass, and I want to use it everywhere 'core's code expects Superclass. I can't figure, how should I qualify AService's field so it would know more than without a qualifier. Or should I somehow qualify Subclass? Or both? Could you elaborate on that?
hey, I'm not sure if I got your application structure and intentions right, so please be forgiving :-). Do both implementations have to be active in the same application/application context? Maybe you can remove the @Component annotation because using @Bean you are creating a new instance anyway? My usual strategy is to create a separate interface (from SuperClass), put it into 'core' and create the required implementations separately (maybe in module1 and module2). I hope I'm coming closer to your needs...
I think I will stick with the separate interface in the core and implementation in the modules as you suggested. But the original idea was that the 'core' module would be a full-blown app with its own spring configuration, not knowing about other modules, and 'module1' would extend one of the core's beans (Superclass) changing its behavior slightly (in Subclass) and then tell spring to use that instead creating a slightly different version of the app. I believe I failed to make it clear from the question. My bad.
I'd like to give you more hints but it's hard to tell without more context if other options would be more suitable. If you can invest another hour have a look at the Spring documentation. It has lots of little examples.
1

There are 2 methods: Use @Qualifier("SubclassName") Or Mark your subclass as @Component and declare the subclass when @Autowired

In your case:

  1. Use @Qualifier("SubclassName")

    @Component public class Superclass { // stuff } @component public class Subclass extends Superclass { // overridden stuff } public class AService { @Autowired @Qualifier("Subclass") private Superclass superclass; // service stuff }

2.Mark your subclass as @Component and declare the subclass when @Autowired

 public class Superclass { // stuff } @component public class Subclass extends Superclass { // overridden stuff } public class AService { @Autowired private Subclass subclass; // service stuff }
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.