Comments on: Setter injection sucks

By: Nicholas Sterling

Nicholas Sterling — Thu, 10 Jun 2010 07:59:40 +0000

The desire for names is understandable, but the fault is not in the concept of constructor injection but rather in the Java language (I assume you’re talking about Java) itself. If you use Scala, then one of the myriad benefits you get is the ability to pass parameters by name when you so desire. So now you can write nice, tight code to invoke constructors and be sure that all of the dependencies are being satisfied, while still seeing the name of every dependency.

By: Nat Harward

Nat Harward — Sat, 10 Oct 2009 20:01:33 +0000

Completely agree in general.

3. It must bind against an exact concrete type. You cant substitute a subclass.

It seems (to me, anyway) that a more appropriate pattern to use for situations where you are likely to have different implementations is the factory pattern. When I run my code in a debugger to find an issue I can actually see what’s happening and what sub-class my code is actually using (and why). When I get a NPE from bad configuration (assuming the factory is configurable) I actually know immediately where to go look. No such luck with Spring

I try to use constructor injection for dependencies that the class cannot function without and setter injection for optional dependencies that the class can do without.

Good point. Seems like a reasonable way to help bridge the differences between the two approaches, but keep code (and particularly intent) sane and understandable.

By: Mark Mansour

Mark Mansour — Mon, 30 Mar 2009 02:38:50 +0000

I couldn’t agree with you more. Constructors put the object in the correct state at the time of construction. If you need to use setters before you’ve used the object then you should be beefing up your constructors.

By: Romilly Cocking

Romilly Cocking — Sat, 28 Feb 2009 15:50:55 +0000

I agree that setter injection is undesirable. It encourages the creation of objects in invalid states, and it often hides intent.

Don’t worry about your preference for configuration in code as opposed to XML. Not everyone will agree with you, but lots of smart people do.

When they want to create objects, they use constructors. That’s what constructors are for.

By: Ben Hutchison

Ben Hutchison — Thu, 19 Feb 2009 04:09:22 +0000

I agree that its better to make an object’s instantiation and configuration appear atomic to clients.

But c’tor injection has problems too:

1. unless you compile with debug symbols on, the names of the injected params get erased to types, so you can’t inject by name. I wish that would change, maybe it has already in practice, cause everyone leaves debug on nowadays.

2. Sometimes its easier to break up _instatiation_ from _configuration_ of an object, because different pieces do each job.

AFAIK, thats how Spring 2.x does DI into domain objects created by foreign frameworks (eg hibernate). It uses an aspect that intercepts after the ‘new’ operation, to apply config via setter injection. Its seems a bit more invasive to completely replace the ‘new’ call using AOP.

3. It must bind against an exact concrete type. You cant substitute a subclass.

PS Got a broken link on your main page, the “more” link on this blog post.

PPS Re: “some new amazing functional language”: Scala absolutely and utterly rocks. Thoughtworks seems conspicuously quiet in the Scala community right now. Come on board!!

By: Chris Johnston

Chris Johnston — Sun, 08 Feb 2009 12:54:31 +0000

Yep, totally agree with your complaints about setter injection. I hadn’t thought about the code smell angle from constructor injection before, but it is definitely something I will keep in the back of my mind from now on.

I started out doing setter injection, but when I finally realized that objects should have everything they need in order to work before you can use them, I never looked back. Constructor injection all the way. Now if I could just get my team from defining every single object in our code base in or applicationContext.xml files. grumble, grumble, grumble.

By: Tomas Varsavsky

Tomas Varsavsky — Thu, 05 Feb 2009 11:20:21 +0000

I try to use constructor injection for dependencies that the class cannot function without and setter injection for optional dependencies that the class can do without.

By: sud

sud — Thu, 05 Feb 2009 01:48:37 +0000

If you use Spring for DI and your Unit Test class extends SpringTestCase, you should be able to have spring inject those dependencies for you from an applicationContext.xml file.

By: Jim McMaster

Jim McMaster — Thu, 05 Feb 2009 01:43:20 +0000

Yes! I agree completely. When people complain about too many constructor arguments’ making the code ugly, I tell them Dependency Injection doesn’t cause ugliness, it only exposes it. The class already had all these dependencies, they were just hidden.

Setter injection is evil.

By: Beans

Beans — Wed, 04 Feb 2009 10:27:23 +0000

A big reason I prefer constructor injection is that I can ensure that when an object is constructed is ready to do it’s job.

How do you feel about ctors throwing exceptions?