Customer Reviews

Dependency Injection

5 star:		(9)
4 star:		(0)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

The information contained in this book is great. The author is very knowledgeable and enthusiastic. Don't let me dissuade you from buying this book, the information it contains is very valuable.

I have read several Manning books before and I didn't feel this book met their standards prior to publication. Another 10% of effort and this book would have gone from good to excellent. This is the reason I only give it 3 stars.

I have some issues with this book. First I don't feel that it has been edited tightly enough. Occasionally the informal language used by the author seemed awkward and I found a couple of grammatical errors.

I take issue that not all of the code snip-its are taken from working examples. (Download the sourcecode for corroborating evidence of this.) This is a bad idea given the size and amount of code snip-its. It is hard for the author to ensure there are no mistakes. There is at least one irritating one on pg. 88 in setting up the creation of a DelivererFactory.

And this is the only book that I can recall re-reading a section because I didn't quite follow it the first time through. I think this had to do with how sections of code changed as an idea evolved and how it was presented. It would have been very helpful to have an upfront sentence or three indicating where we are going when ideas evolve. For example, section 3.3.3 could have benefited from this. I found this particularly irritating at times.

Sometimes illustrations were used pointlessly, such as 7.4. Maybe I didn't see the humor in it. This is a dry subject after all.

I didn't like the flow of which dependency injection frameworks were chosen in any given section. Most of the time Guice would be presented first, but that wasn't always the case. There needs to be more consistency in the order of presentation! And for some reason not a peep was mentioned about Guice in section 7.5. Maybe Guice offers nothing in customizing the lifecycle of an object?

I also felt that chapter 4 needed help. I kept asking myself who this chapter benefited. The concepts of good object oriented design and testability take quite a bit of exposition. Books solely dedicated to this area have been written. And yet because of how dependency injection was presented along with it, I felt it muddied the waters in some ways. The information is good, it just needs more editing to make it more focused.

Chapter 11 is pretty useless until Google releases sitebricks. The whole chapter is a small web demonstration that happens to use this library. Who writes an extended example in a book which has a dependency on something not yet released to the public?? Again, Manning should not have let this problem go to press. Yes, the author also wrote sitebricks.. so I can imagine the conversation. "... it will be released a week after we start printing..."

I'd still recommend buying this book since I'm not aware of a better one on the subject of dependency injection.

Dependency Injection by Dhanji Prasanna is essential reading for anyone wanting to understand how to organise and structure modern Java codebases using Dependency Injection (DI) techniques.

Now that JSR-330 (Dependency Injection for Java) is part of the JDK, DI will become an important design technique for modularising and organising code, one that isn't taught in standard Java or OO texts. Up to now coverage on DI has been limited to online documentation, blog posts about testing, and sections here and there in books, so it's good to see sound engineering practice captured in one place. Dependency Injection covers two frameworks in detail - Spring and Guice and the coverage is balanced. As the author is a Guice contributor, this is to his credit - an easy out would be to write a book on just Guice.

I like that the book explains the principles behind DI and not just how certain frameworks work. I didn't think DI could justify a whole book and expected a lot of filler, but the title doesn't do justice to the material covered. Dependency Injection also has a wealth of practices and techniques for organising and programing Java systems. I don't think there's another book in print that provides the kind of information you can find here. Most DI material focuses on testing, which is important but just one aspect of why DI matters - this book goes beyond that and covers practical modular software architecture in some detail. Highly recommended.

Over the last few days, I have been reading Dependency Injection by Dhanji Prasanna published by Manning.
Summary first: very easy to read, a gold mine of knowledge and tips on a subject that is essential to the life of today's Java developers. Go buy it and keep it around your desk.

Let's quickly talk about the book structure. The book walks you gently through the DI (Dependency Injection) subject:

why do you need DI, what does it solves concretely in application developments
what is injection, what are the main concepts
using DI to improve application modularity
object scoping and how to approach that with DI solutions
best practices learnt with tears and blood
and a small concrete application showing how to use Guice as your DI container
If you are a beginner, this book will explain to you how and why using DI. If you are an expert and use DI on a daily basis, this book will help you rethink what you have taken for granted in DI-land and learn a handful of new tricks and design patterns.

I consider DI and the notion of scope (aka context) to be an essential knowledge to any Java developers. This will become even more pressing with the soon arrival of JSR-330 (Dependency Injection for Java) and JSR-299 (Context and Dependency Injection for the EE platform aka Web Beans) and their inclusion in Java EE 6.

Just like you had to learn polymorphism, you need to learn DI and context management as this is an essential tool for proper component design and application modularization.

The only gotcha is that this book comes right before the finalization of the two JSRs and hence does not cover them. Don't be too afraid though, all the core concepts covered by these specifications are thoroughly explained in this book. The problem / solution approach used by Dhanji will perfectly complement your knowledge of the DI JSRs.

My advice is to keep this book on your desk when you develop, you will save yourself the burden of learning the best design approaches the hard way.

[...]

As of today, no one has been able to convince me that the number one quality attribute, of every project with any amount of complexity, should not be Modifiability.

To be modifiable, an architecture must be modular. This book provides the tools needed to accomplish modularity.

This is hands down the best material on dependency injection available.

The beginning of the book is perfect for the beginner, but then gets into more advanced topics.

I can't speak to the usability of the code download because I am not a java guy.

You do actually get a free ebook that is downloadable. Not a 45 day temporary membership granting you access to it.

From the perspective of a C# developer, I found plenty of great advice throughout the entire book. The book covers some of the most important patterns and principles and I thought it did so well. The code samples were easy to understand.

If you want to build software that is modifiable, this book is a great place to start.

I highly recommend this book to all developers and architects.

Reading Dependency In Action was an eye opener in the sense that it articulated what I instinctively knew, but what never quite crystalized in my mind. Also, there are interesting tips throughout the book about some of the common pitfalls when implementing DI, and even a chapter with tips for framework developers!

I think more people can learn from this book than they realize. In my experience, a lot of people use frameworks like Spring because everyone else does, without really understanding the core problems they solve. This book will give you that background.

I quite enjoyed the quirky funny writing style, though humor is something that is very subjective, so you may or may not be attracted to his writing style.

I really enjoy reading a book that can show me a new approach to what I have already considered well understood and barely surprising. I'm currently learning Java EE 6 and has begun my journey to the area of the Contexts and Dependency Injection for the Java EE platform and the Java EE 6 Managed Beans specifications. I can't really explain why I picked up these specs, but they made me wonder about the current state of dependency injection containers. It looks to me that JEE6 application servers are not that much explored and quite often loaded with applications that are in turn managed by Spring Framework and its kind of kitchen-sink stack. Many developers put their faith in Spring Framework and look no further. It is as though a sole Java EE application server were less important and the only trusted solution were Spring Framework itself which eventually became the Java EE application server. Too bad.

The book "Dependency Injection, Design patterns using Spring and Guice" by Dhanji R. Prasanna from Manning has showed me that there's a hope for such a thinking and Guice comes to our rescue - to those passionate enterprise Java developers who once thought a Java EE application server has been too much burden on their shoulders and Spring Framework + Apache Tomcat combo has been enough. My take on it is that Spring Framework requires now so much time to understand how it works that one can hardly find a few spare cycles to look for and afterwards evaluate alternatives. The initial attempts of Spring Framework to lend a helping hand to us and ease development of Java enterprise applications had certainly been achieved, no doubt about that, period, but the development of Spring Framework didn't stop that led to create another 100-pound gorilla. It's now something bigger than a mere DI container and as much complicated as its origins once were. With that gut feelings, one day I noticed this book begging for my reading and without much excitement yet wondering what I could learn about dependency injection I grabbed it and started the reading. Before it I had no clue whatsoever about Guice, and noticed the subtitle right at the moment I write the first sentence of the review.

The book is written by "a Google software engineer who works on Google Wave and represents Google on several Java expert groups. He contributes to Guice" (from the ABOUT THE AUTHOR section of the book's home page at Manning). I found it out once I'd finished reading the book and spent quite a few moments to think whether or not there were places where I could've figured out the origins of the author myself earlier. I can honestly say that if there had been such I could have spotted none. Be rest assured, the author handled the subject of dependency injection and supportive design patterns like adapter, provider and proxy with a great care and covered the way Spring Framework does the DI job as often as Guice (with some coverage of PicoContainer too). The book presented code snippets that were mostly Guice-oriented though, which I found very informatory and valuable. Mind the aim of the book - the concept of dependency injection, and it was not an easy task to do it in detail keeping the fair balance between Spring Framework and Guice (the book would've otherwise been twice long). The topic was described in 11 chapters and the samples ensured the book was by no means boring and served their purpose very well. I think it would have been even better if it'd devoted itself completely to Guice leaving Spring Framework aside for which there're many books available.

As you might've guessed by now, for me the most valuable pages of the book were those with Guice covered. I read them with a great passion and found striking similarities to these two Java EE 6 specifications - CDI and Managed Beans. It was as if I'd been reading the specs again. Having read the book helped me understand them better. Their goal is much clearer now once I realized their origins and what design issues influenced their development. It was in the chapter 2. "Time for injection" when I finally found the answer to the question I was struggling with for some time - "Are annotations a correct way to convey additional configuration?" They certainly are. Coverage of JSR-303 Bean Validation in the chapter 10. "Integration with third-party frameworks" as a case study of a well-designed framework with DI in mind wasn't something exceptional in this book. There were some sentences and an example about CGLib (which I'm about to learn), but I wished it'd been more. The book was filled out with many fine explanations of the entire dependency injection ecosystem, and was a complete no-brainer to find something worthy. With many refreshing angles of looking at dependency injection one can barely be left with a bad taste in mouth.

Not only did the author take a great care to explain the concepts around dependency injection, but the language itself was very professional and with a great sense of humour. I definitely learnt a lot - dependency injection, design patterns around it, Spring Framework and finally Guice as well as a bunch of new words and phrases in English. The reading was worth its time and I'm certainly going to refer to the book's chapters every now and then. In a blink of an eye, "Dependency Injection, Design patterns using Spring and Guice" by Dhanji R. Prasanna from Manning turned me into a Guice passionate. It's not clear if it's Guice itself or the book, but I have no doubts about a DI container when one's requested. The book presented quite a few examples of Guice for web development so you should find it a viable alternative to Spring Framework stack if you run across such a need. It urged me on to try out Guice and its extensions. I've got some ideas for more developments too and whenever designing a solution I'll look back to the book as a definitive source for thought-provoking advices. Thanks Dhanji!

This books goes thru the concept of dependency injection from the very beginning (good for beginners) to the very depth (good for advanced programmers). Explanations are very clear, examples are easy to understand. Author used code samples in many IoC containers, mostly Guice and Spring. In fact, Spring examples made this book a level better, since it's the most popular IoC container today.

I loved how author managed to explain principles (not frameworks!) in very agnostic way and showed best features of each IoC container and illustrated best practices and pitfalls of each. Book contained also quite a lot of advanced topics for more experienced readers that were also surprisingly interesting.

The only drawback (which still won't make me to change 5/5 rating) was the chapter with Google Bricks - too immature technology for this kind of book.

I used this book to help me really understand dependency injection. The concept itself is generally simple, but to really apply it takes skill. The majority of my questions about "how" and "why" were answered in a way that allowed me to apply DI to Python (my native language).

I never thought the subject of Dependency Injection needed a book of its own. I have used Spring for years and it became quite natural to use DI overtime although I don't have much experience with Guice. I decided to buy this book based on a recommendation of one of my co-workers. I read this book from cover to cover and it turned to be quite worth a read. Instead of merely showing how to use DI in practice, he explains the principles behind DI and why DI is needed in the first place. Also pointed out in this book are different types of DI and when each is more appropriate. Guice and Spring are two primary DI frameworks that are explored in detail and as another reviewer mentioned, the coverage is balanced pretty well between the two. The author explores some of the architectural principles and makes recommendations accordingly. I tried out all the code samples in the book and with the exception of one or two (such as creating a custom scope in Guice), all examples work as expected. This book also covers pitfalls, corner cases, memory leaks and other potential things to watch out for in addition to indentifying anti-patterns as well as lessons for framework designers. Even if you have used DI before, chances are that you will still find this book to be very helpful. Highly recommended.

There's a clear preference towards Guice throughout this book. I cannot explain why the author chose to bother with other IoC frameworks. Spring gets the best alternative treatment, but that might be to its detriment (see below). Pico is barely covered. The rest of the contenders, like Hivemind, are simply mentioned.

By page 40 or so, the author is really more or less picking on Spring's default XML string wiring. Strings are prone to typos. Strings aren't classes, and inheritance cannot be confirmed until injection time. That's cool. I agree in fact. But what's the deal? Why bother even covering the short-comings of Spring except to push Guice? And if pushing Guice is the objective, which it is and that's fair, why not label the book correctly?

I'm guessing the fence walking is an attempt for a wider audience. But I think it backfired. The multiple half-butt coverage just muddies the book.