Autowire Interfaces

[tbraje]

I have what seems like a simple problem, but I am unable to solve it in the manner I would like. I am moving away from by-name autowiring, towards the more explicit use of by-type with @Autowire (Spring 2.5.1). However, I have a problem when I have multiple beans of the same type. I understand how to use @Qualifier, but this doesn't work for me. Here is the problem:

We have a pretty standard DAO layer. Each DAO object implements an interface, and we currently have implementations for JPA. We have one implementation (and interface) which implements the CRUD stuff, and all of the other DAOs inherit that implementation and interface. It just so happens that we occasionally want to inject the CRUD Dao. So, I tried this (we classpath scan for our daos):

@Resource
@Qualifier("crudDao")
public class JpaCrudDao implements CrudDao {
}

public class SomeOtherClass {
   public final CrudDao crudDao;
   public SomeOtherClass(@Qualifier CrudDao dao) {
      this.crudDao = crudDao;
   }
}

Of course, this doesn't work, because I 'qualified' the implementation class rather than the interface. I know that Guice has an @ImplementedBy annotation that you put on interfaces to mark a default implementation (and I think that is essentially what I want in this case). Is there any way to do this in Spring?

My current workaround is to add a definition for JpaCrudDao in xml and mark 'primary=true'. This doesn't feel right for two reasons:
1) it forces me to configure this bean in xml
2) there is no explicit qualifier. It is a bit confusing to have:

public class SomeOtherClass {
   public final CrudDao crudDao;
   public SomeOtherClass(CrudDao dao) {
      this.crudDao = crudDao;
   }
}

because you know that every DAO in the system is a CrudDao. There has to be a better way!

Suggestions would be greatly appreciated!

[Marten Deinum]

The @Qualifier is to be used with a name not simply @Qualifier...

public SomeOtherClass(@Qualifier("crudDao") CrudDao dao) {
  this.crudDao = crudDao;
}

If you don't spring reverts to by-type and since you have multiple implementations that isn't going to work...

[tbraje]

I am sorry. There was an error in my earlier post. What you said I should do, I did in fact do and it didn't work. I interpreted the failure as being because the name "crudDao" was attached to the implementation class, and not the interface (note that I annotated JpaCrudDao and gave it the "crudDao" name).

[Marten Deinum]

If you are using those annotations @Qualifier and @Resource I suggest you switch to @Repository("crudDao") on your dao and the @Qualifier in your setmethod.

[tbraje]

Thanks for the reply. I had thought of doing this, but I was hoping to move away from setter injection towards constructor injection. Since I can't mark a constructor parameter with @Resource, I can't use it in this way. Perhaps that is my best bet, though.

[Marten Deinum]

You are using the @Qualifier so why not use the @Autowired that is possible to use on a constructor.

[tbraje]

That is precisely what I am trying to do. The problem as far as I can tell is that the implementation class, JpaCrudDao, is getting the @Qualifier name attached to it, while I am injecting the Interface, CrudDao. In short:

@Repository
@Qualifier("crudDao")
public class JpaCrudDao implements CrudDao {
}

public class SomeClass {
  final CrudDao crudDao;
  @Autowired
  public SomeClass(@Qualifier("crudDao") CrudDao c) {
    this.crudDao = c;
  }
}

complains upon container startup because many classes implement CrudDao. On a whim, I tried this:

@Repository("crudDao")
public class JpaCrudDao implements CrudDao {
}

public class SomeClass {
  final CrudDao crudDao;
  @Autowired
  public SomeClass(@Qualifier("crudDao") CrudDao c) {
    this.crudDao = c;
  }
}

This works fine. Note, the only difference is that I pulled the @Qualifier from the JpaCrudDao, and named it using the @Repository annotation. I thought that @Qualifier was supposed to be used for this in the context of @Autowire.

Is this a bug?

[gehel]

No, this is the expected behaviour. @Resource (or the related @Repository, ...) are used to name a bean. @Qualifier is used to tell which bean you want to inject. Your final example looks just like it should look ...

[tbraje]

Great! Thanks for the response. The docs aren't very clear on this:

3.12.6. Providing qualifier metadata with annotations

The above section indicates the former, at least by my reading...

[tbraje]

Sorry. I was a bit unclear in the last post. My reading of the docs indicate that you should use @Qualifier in this case:

http://static.springframework.org/sp...ing-qualifiers