Friday, February 24, 2017
Coupling
Coupling
Update: a crack team of Googlers who constitute the most powery of our Guice power users have assembled a few times now to hash out the design of more than a half-dozen killer Guice 2.0 features with me & Bob. I will say no more (I dropped some hints at the end of the "Becoming More Guicy" tech talk), but just know that I feel ecstatic about how the plans are coming along, and Bob seems to as well. We will give Guice the power to enable you to do more and better things, but we refuse to let Guice bloat with features it doesnt need, and we are extremely protective of the Guice Philosophy.
In the meantime! Christian Schenk has a swell post comparing Guice, PicoContainer, and Spring. Of course, my favorite part is this:
Spring seems to be harder to use than Guice: without autowiring you have to specify the dependencies between your beans in a very verbose manner, i.e. you have to think about the things you’d like to do and write them down in a configuration file. Ideally you don’t have to specify anything with Guice, except the Inject annotations and Guice will handle everything for you.
Ahh, youve just gotta love that shit. I think Ill set it to music.
But Christians conclusion?
First I opted for Guice because I like experimenting with new, bleeding-egde software. But as I said earlier, all these annotations couple your software tightly to Guice - that’s not very desirable. . . . To draw a conclusion I think choosing between Guice, PicoContainer and Spring, for lack of a hard and fast rule, will be to do what works best for your project.
I want to address this idea of coupling, because Im noticing that this concern crops up again and again, and I think that the issue has more to do with perception than anything else.
Does embedding @Inject in your code tightly couple your code to Guice? It does in one sense: some version of guice.jar is going to have to be present on your classpath whenever you compile your implementation classes. This much is true. Beyond this, though -- its really not that bleak. Your classes have no runtime dependency on Guice. If they run as part of an application that doesnt wish to use Guice, the Guice jar file neednt even be present on the server at all! Now, this changes if you want to use more Guice features, like provider injection and injector injection, but this is the case with Spring as well.
Furthermore, the idea of "coupling" implies that "the one cannot function without the other." But with Guices annotations, this simply isnt the case. Its important to understand that these are only annotations. They are decoration; meta-information. They dont, and cant, actually do anything. They just sit there, innocuously, in case tools will wish to read them, and otherwise have no effect whatsoever. They do absolutely nothing to impede you from testing your code, or from using the classes with Spring.
Perhaps the issue -- and Im not specifically talking about Christian, but about all the many who have had this objection -- perhaps the issue is a more visceral disdain for seeing import com.google anywhere in your code? Maybe you feel the same way about import org.apache, so you eschew the Apache Commons and all that stuff too? Begone, vile dependencies! Or maybe "thats different," after all, Google is a big old corporation, and I think it might have been on Slashdot the other day that weve Turned Evil now.
In any case, Google doesnt intend to stop open-sourcing our awesome Java shit anytime soon, so you may have to confront that particular issue again and again. Oop, I said too much....
Now, I ask you -- is one extra jar file in your javac classpath really all that bad? Or are there some additional problems that I dont yet understand?
Available link for download
