CODEWITHSUNDEEP
javadependency-injectionguice
aryaxt
aryaxt

Reputation: 77596

Proper way of injecting dependencies?

Which one is the best way of injecting my dependencies? Why? What is the difference between the two?

public abstract class Service {

    private IConfig config;

    @Inject
    public Service(IConfog config) {
        this.config = config
    }
}

Or

public abstract class Service {

    @Inject private IConfig config;

    @Inject
    public Service() {

    }
}

Upvotes: 1

Views: 3145

Answers (3)

JB Nizet
JB Nizet

Reputation: 691715

The main goal of dependency injection is to make unit testing easy by allowing to do

Service serviceToTest = new Service(mockConfig);

or

Service serviceToTest = new Service();
serviceToTest.setConfig(mockConfig);

The second way of injecting dependencies makes it impossible to do the abover. You can only test it by letting Guice create the service and inject a mock dependency, or by using reflection to set the mock dependency.

Upvotes: 1

omnomnom
omnomnom

Reputation: 9139

First of all, I do not put injection-related annotations in abstract classes - in my opinion there is no sense in deciding how something should be instantiated if it actually cannot be instantiated (of course that's only my opinion with which others may agree or not).

Usually I do it in the following way:

public abstract class AbstractService {

  private IConfig config;

  public AbstractService(IConfog config) {
    this.config = config
  }
}

public class Service extends AbstractService {
  @Inject
  public Service(IConfig config) {
    super(config);
  }
}

Now, you can use both classes with and without dependency injection (construct it by hand, passing all required references). Also you can be sure that Service is instantiated in the appropriate state every time.

Upvotes: 3

Sanjay T. Sharma
Sanjay T. Sharma

Reputation: 23208

Constructor injection (1st) is preferred over setter injection given that it makes it easier to support "immutable" entities or entities whose behaviour is well defined and non-modifiable after construction. Constructor vs Setter inject

For me the rule of thumb is to first prefer constructor injection and jump off to setter injection if constructor inject requires me to bend my back i.e. when working with legacy code with "OOP getter and setter" methods.

EDIT: I'm assuming you are trying to decide between "constructor" and "setter" constructor. But it also seems that you are using abstract classes which can't be instantiated. Maybe you have something else in mind?

Upvotes: 4

Related Questions