This book gives a good introduction to the Spring Framework, Aspect-Oriented Programming, and Inversion of Control on a whole. However, for a framework that many people will be using for web development, this book has only one chapter on Spring MVC; much of the implementation details are left up to the reader to discover on his/her own.

If you are looking for an overview of the Spring Framework and some of its basic implementations, this book is a good start. If you are looking for a "cookbook" with detailed examples, you would be better off searching the forums and newsgroups online.

I'm sure this book does an excellent job of reviewing all the possible uses of each component of Spring. Unfortunately, I couldn't stay awake long enough to find out. I love reading technical manuals, but this thing is a real snooze-fest. The repetition is high, especially in the early chapters. This book also suffers from what I call Full Spec Syndrome. Rather than learning the concepts involved, the author goes to great lengths to show all the options. Later he says one is used a vast majority of the time. Then why waste my time with the other options at this point? List them, yes, but full definitions of everything makes for an unreadable guide.
It is obvious that the authors know the material. However, in my opinion, they are not effective at imparting that knowledge to the reader.

Post script: I've had this book now for several months since I wrote the review above. Although I stand by my original review that this is not a book to LEARN Spring, it has been an excellent REFERENCE on Spring once you have the basics down.

This book covers all aspects of Spring framework. I like it. It serves me as a quick reference guide. It is good for starter. But if you want to dig deeper and already have experience with Spring then you should look elsewhere.

This is a really great book on Spring, and very easy to read. However, the buyer should be aware that it is based on prior versions of Spring (and Hibernate). The book covers Spring v1.1, and Hibernate v2. The current releases (as of Jan 2007) are Spring v2, and Hibernate v3.

There have been many interesting improvements in Spring v2 work noting. You can read about them online here at the Spring Framework site:

[...]

I also wrote a blog-entry on what I had to do in order to get the SpringBlog sample-app from the book to work with the latest versions of Spring/Hibernate here. If you are in the same boat as me, take a look at this..it may save you some headaches...

[...]

If/When "Pro spring 2" gets published - I would buy it all over again!

I was new to Spring when I got this book, but it bootstrapped me into the basics very quickly - I found its explanations provided insight above and beyond the material available in the online documentation (important to know because that's already pretty good).

I liked this book a great deal; it is intelligently laid out, with somewhat self-contained chapters on the various technologies incorporated into Spring. Even with a couple of fairly intensive Spring-related projects under my belt I'm still using it as an occasional reference and to get new team members up to speed.

Chapters on a few topics are a little light, but I think that's inevitable - the book's already 800+ pages long, and some briefly-covered products for which Spring provides wrappers have justified books in their own right.

Definitely recommended.

Pro Spring is, for the most part, an easy book to absorb. I picked it up with only a middling understanding of Spring, and I feel comfortable with almost all of the topics. However, since my background in servlets and jsp is also quite shallow, I found the chapter on Spring MVC to be the exception. The material here was incomplete, as if the authors had not actually written their own Spring-based webapps. I've been forced to supplement it with web documentation and forum posts (a poor substitute).

Despite this criticism, I heartily recommend Pro Spring to anyone who is either already very proficient in writing servlet-based webapps or has absolutely no interest in doing so. If you're interested in web development and you have some money to spare, this is still a good Spring book as long as its not your only Spring book.

This book is not for programmer who needs more exlanation
They tried to explain everything in shot...

I've heard that this is the best Spring book out thus far. That may be true, but that doesn't mean that it is an excellent book. For starters, the authors rely on textual descriptions far too much. Although their descriptions are good, a picture sometimes would really supplement the concept well. There is also some organizational problems. I want to get moving in Spring, but they often show me Spring concepts that hardly anyone is using. It would have been better if they would have saved some of the esoteric Spring features for a separate chapter instead of intermingling it so much with real-world Spring. Although these authors know their stuff, some parts of the book I have to struggle and re-read over to grasp what they are explaining. Finally, I've found a few errors in this book. However there is no published errata on-line that I could easily find, and after being on the market for over a year, I find that lazy. (Note, I did find a place to submit errors but there was no listed errors.) In closing, this book has helped me with Spring, and I feel that the book could be excellent if the authors fine tune the book.

This book is full of code samples - unfortunately, none of them actually work, because they're all missing a lot of detail. For example, in chapter 8, on Spring JDBC, all of the examples use a database schema... whose details aren't presented. If you're already very familiar with JDBC, you can figure this out from the code samples; but if you're not an expert on a given topic (for example, AOP), you won't be able to make heads or tails of the examples; you won't even understand what they're trying to do (the book doesn't bother to try to clarify).

All in all, I found this book extremely frustrating - it seems as if the authors understand the how, but not the why. If they do understand the why, they certainly do a good job of hiding it. Take it from me - skip this one.

What is Spring? How good is "Pro Spring"? I will attempt to answer these questions based on my experiences with both.

Spring is a light-weight container and framework for building java applications, both J2SE and J2EE.

1. This means that, unlike other web frameworks, like struts, spring is not only limited to web applications.
2. "light-weight" does not mean that it is a tiny framework; rather it means that it is not an intrusive framework like EJB.

To support these claims, we can say that spring provides container and/or framework features for
1. Presentation Layer: Spring MVC, Spring Web flow, support for struts(and various other MVC frameworks)
2. Business Logic Layer: Transaction Management, Remoting, J2EE support(support for JMS, EJB, Mail etc), Job Scheduling support
3. Data Access Layer: JDBC support, ORM Support(Hibernate, JDO, iBatis etc), Database Exception Translation etc.
4. Common Features for all layers: Inversion of Control, Aspect Oriented Programming, Bean Factory, Application Context

By providing the above features (and more) in a light-weight fashion, spring introduces the following traits into your application
1. Ease of development
2. Non-Intrusive Source code
3. Good Design Patterns and Practices
4. Testable Design and Code... and much more

Both the above lists are by no means exhaustive, but is a good starting point on how you look at spring.

"Pro Spring" does a very good job of explaining all these features in very organized and easy to understand fashion. The best thing that I liked about this book was that, it was able to portray the bigger picture accurately and then zoom-in on individual items in a very orderly fashion. This helped me understand the individual parts of this extensive framework in the context of the bigger picture. BTW, version 1.2 of spring is covered in this book.

Now the "not-so-good" news: This book has 2 authors, Rob Harrop and Jan Machacek. They are both highly skilled spring developers, but I am afraid, one among them is not so great writer. I found that the chapters written by Rob Harrop were extremely clear. The chapters written by Jan Machacek were not very easy to read at least during my first pass. The silver lining here is that, the fundamentals of spring are written by Rob Harrop, which puts us in a better position to read Jan Machacek's work. Also, during my second and third passes, I was able to get a better value out of Jan Machacek's work, which means that we don't need to worry about this con if you are fine with reading a few chapters twice or thrice.

Overall, "Pro Spring" truly makes you a Spring Pro. I highly recommend this book, if you are seriously interested in learning and using spring.

This book is missing some details such as the OpenSessionInView pattern that is absolutely essential when integrating Spring and Hibernate.

If you really want to understand Spring rather than go through a contrived sample application, buy Professional Java Development with the Spring framework by Rod Johnson, creator of the Spring framework.

The book starts with a simple hello world example which gives you an idea on the whole dependency injection and injection control buzzwords. Once through this one can advance to other areas where spring adds value. JDBC templates, AOP and such. Spring is not panacea and is needs to be used only to the extent to where your actual code does'nt become complex. When you find yourself jumping around hoops to include Spring into the design thats the time to stop and rethink if you really need spring.
Bottomline: This book provides you with enough ammo to get a kick start on Spring. I was wanting to move my webapp to use the Spring DI container. The book had enough code samples to help me rewrite parts of my enterprise webapp to use AOP and JDBC templates.

I had never used Spring before reading this book, and this book gave me the knowledge I needed to start. It's very well organized with lots of code examples and a great example project. If you want to know Spring, you need this book.

For a new web project I've been learning the Spring Framework. Based on a few recommendations I'd read around the blogsphere I ordered a copy of Pro Spring and I've gotta say I've been hugely impressed.

I've been reading/implementing for around two weeks. When it arrived I was sure it was a lemon (how could it cover MVC in a measly 45 pages?). What I didn't count on was how *good* the examples are. Sure, you don't get the total coverage of a dedicated MVC book, but you get *excellent* coverage of more areas of the framework than you could possibly imagine.

The database-driven web app I'm building is using Velocity, iBatis, Postgres and Spring, and, even though I've used iBatis before, I've learned heaps of tricks while reading the Spring/iBatis integration chapter (like using inheritance in resultmaps). I've got parent/child selects and inserts going on, I've got my auditing going to the database (using a Spring HandlerInterceptor to check page access), I've got connection pooling and all sorts of cool stuff. And I've been having a ball all the way through.

Even the mail integration chapter is awesome! Gives great examples of generating rich html emails using Velocity with embedded images (exactly the thing I've always wanted to do with mail!).

The appendix on unit testing is also full of gems! What a great idea to have a transactional unit test that you can roll back when your test is done without touching your test db!

What has really surprised me about this book is the rich quality of the examples. There have really picked stuff that you want to do in the real world. In fact, the more I get into this book, the more battle tested it feels. It definitely has the feel of "we've built a dozen production apps in this framework, and here's the dirt on what we've learned along the way". I *love* that in a book!

I've had a scan through Spring in Action and at first glance it doesn't seem to have either the breadth or depth of Pro Spring. Matt Raible's Spring Live looks very cool, though (particularly since he has stuff in there about Spring WebFlow). Be good if SourceBeat provided a detailed table of contents, though, where you could see the details of what's covered before buying a copy (rather than just see the title of each chapter).

Anyways, Pro Spring gets a huge tick from me! Great job, Rob & Jan! And great stuff apress! Highly recommended!

I recommend this book and also "Java Development with the Spring Framework" by Wrox (Wiley).

Every chapter is written very well and the book has extensive coverage of all of Spring's features as well as beefy examples that really help one to grasp the concepts. The JDBC chapter is a bit weaker than the rest of the chapters, but all in all it's a great book and I highly recommend it.

Provides concrete examples about all the features covered.

Much easier to follow for a Spring novice than Professional Java Development with the Spring Framework.

Perhaps after reading this book the material in Professional Java Development with the Spring Framework will make more sense. Like I said in the review of Professional Java Development with the Spring Framework, that book is not an introduction to Spring and assumes the reader has some knowledge about the framework.

This book assumes no such knowledge and can turn a complete Spring neophite into a pretty knowledgeable Spring developer.

While describing all the features of the Spring Framework would take a 3-volume set, Rob and Jan did a great job packing a ton of information into the space they had, and it has become the Spring reference of choice for our entire department. The book takes you through construction of a typical application, showing all the configuration details and explaining the interaction between the various components. It also explains special functions through additional one-off examples. Having also read Spring in Action, Spring Live and the Spring Developers Notebook, this is the one to choose.

One of my friends bought both "Spring in Action" and this book, he recommended this book. I ordered and received the book one week ago, I spent all my spare time to read it and could not stop.

Rob Harrop really exaplained Spring very well.
I started to try Spring since some time, I read the online document and
"Expert One-on-One J2EE Design and Development", and "Expert One-on-One J2EE Development without EJB", but none of them is as clear as this book.

This books gives a very nice explanation to Dependency Injection and AOP, which Spring is based on. It first explains the programmtic way to use DI and AOP, then the declarative way in Spring framework, which helps readers to really understand the framework.

I also like a lot the part for data access (Hibernate and iBatis), middle tier (transaction, remoting, etc) and the web application part. I now start to understand
use of spring framework rather than try to remember it.

"Spring live" may be another good book
for spring web applications, but it's weak on other parts in spring framework.

I bought this book having had virtually no exposure to Spring. I was looking for an introduction to the Spring framework, and this book does not disappoint. At the same time, the framework is covered in great depth. It's rare to find a book that has comparable depth and scope of coverage.

A fantastic book!

The depth of this book is matched only by it's heft. For a book this big you would expect something with a ton of screenshots and page after page of code, but such is not the case. In fact, this book has better exposition than a lot of APress book's I've read.

The authors do a very good job at not only explaining the technology but in providing some perspective on it's use as well. Between this book and Manning's "Spring Into Action" I would take this book.

The first book I read on Spring was Spring: A Developer's Notebook, which was, to put it mildly, a dud. Pro Spring is so much better I hardly know where to start. The authors do a great job of introducing you to the concepts of IoC and Dependency Injection with many clear and easy to understand examples. I'm only on chapter 4 but I'm already very happy I'm reading such a great book.

Pro Spring is a big, thick book that covers a big, thick topic--not thick as in obtuse, nor even dense and hard to comprehend, but thick as in many layers piled atop each other. Spring comprises many layers of technology that solve different problems, but work together under the Spring moniker. When I cracked this book, I knew nothing about Spring except that it was an IoC container. I knew enough about IoC to recognize its power, so the hype swirling about Spring led me to Pro Spring.

Both the concepts behind and the practice of using the various technologies wrapped into Spring unfold gradually through the pages of this book. At times, I felt they unfolded too slowly; I felt impatient as I absorbed, bite by bite, the behemoth of Spring. The authors don't skimp, however, when they cover a topic, but take the time and pages to explain a concept, then illustrate it through code and configuration. Proper understanding of Spring defies a mad dash through its usage, as I quickly learned. Still, I felt somewhat betrayed when I didn't learn about ApplicationContext until page 141. This likely reflects a matter of taste: I think I'd prefer a presentation of the big picture, then a breakdown of its constituent parts, rather than a presentation of the pieces, building up to a whole.

Although I felt a little impatient as I read, I'm astounded by how well this book covers each topic. I found myself thinking, "Well, I may not get this all in the first pass, but I'll dive into this book again and again as I tackle new facets of Spring." That, perhaps, is the strength of this book, and they way it can best be used: skim through it to get a handle on what Spring is and what it can do, and then zero in on those sections that interest you at a particular moment. The explanations and examples are fully fleshed out without becoming belabored, and I will continue to lean on this book as I learn to implement all the technologies in Spring. Well done, and well worth the investment.

If you're reading this, you probably don't need to be convinced about learning Spring. The question you're really asking yourself is, which book should I buy? Or should I just stick with the online docs and save some money? Or should I just download the code and start playing with it? I'm going to try to answer those questions.

First, Spring was born out of the thinking by Rod Johnson in "Expert One-on-One J2EE Design and Development", and later with this followup book co-authored with Juergen Hoeller in "Expert One-on-One J2EE Development without EJB". These books are excellent books in general and I highly recommend them. However, the first book is not really about Spring and is more about general enterprise application development strategies (and very good at that). The second is sort a essay on why EJB has failed, and also a short introduction to Spring along with the philosophy behind the design decision in Spring. However, it's too sparse to be a full-fledged Spring manual or tutorial. It's more a well-argued anti-EJB book with a short tour guide to Spring.

In contrast, Rob Harrop (who is also a Spring developer) has written the first truly comprehensive introduction and tutorial to Spring. It covers the whole gamut, from a clear introduction to why Dependency Injection makes a lot of sense, on Aspect Oriented Programming and how it applies to Spring, then on to a detailed coverage of how to use Spring for persistence, transactions, remoting, messaging, scheduling, email, and MVC web applications. He shows how to integrate with Hibernate, iBATIS, JDBC, JTA, JMS, Quarts, Struts, Velocity, etc.

What's amazing is that it covers Spring 1.2, which is still in release candidate stage, and gives you updates on the current stage of various supporting software, what to watch for in the near future and what the changes will most likely be. Just as one example, the Spring IDE plugin to Eclipse has really no online documentation to speak of since it's still relatively new, but this book shows you how to get it, install it, use it. The book has better documentation than the canonical website. That's just one example of many.

So how does this compare with the online docs for Spring? The online docs are good in most places, but there are still some big gaps in the documentation, whereas this book is nothing but exhaustive in its coverage and clearly superior in most places compared to the online-docs.

I've read both of Rod Johnson's books, the online docs and Rob Harrop's book, and this book is probably the best out there right now for its coverage of Spring, and it's also a one-stop shop. You don't really need anything else, unless you're looking to expand your knowledge with the other books into areas outside of Spring.

The only other book that might come close is the (as yet) unpublished book by Rod Johnson titled "Professional Java Development with the Spring Framework". However, that book is not out yet, so unless you can stall your Spring development for many months (hah, hah), I highly recommend Rob Harrop's book. Be productive and just get it.

This book provides an excellent explanation of the Spring framework. Unlike many other books of comparable size I read earlier, I can't identify a single page that could or should have been left out. Of course the authors are helped a little by the fact that the subject is by nature very broad, involving practically all layers of Java application design.
To be honest, I have not read any other Spring book (except for Rod Johnson's book that was the precursor for Spring) so I can not compare. But this one rocks, both for beginning Springers and those who would like to learn more.

Spring Framework is a revolution in the Java world. And it is hard to capture it in one book.

But I really liked this one. It is extremely well-written. Examples are concise and up to the point. It does have a bit of hand-holding but the writing style is so elegant that it didn't bother me at all. I read it almost like a novel. Humor is definitely there. Core Framework and AOP chapters are just great. Authors expertise is obvious.

All-in-all highly recommended for experienced J2EE practitioners. The book will be well worth your time.

The book makes striking claims in favour of the new Spring framework. It is presented as revolving around what the authors term Dependancy Injection (DI). Which can be used in place of a Lookup approach, which makes a class by calling a Factory or container with a key that labels that class. Hopefully, the Lookup will return an instance of the class. The book points out that this common approach is possibly more complex than DI. The Lookup registry might be unavailable, or the key for that class might have changed.

The DI can lead to shorter and simpler code, which might also be easier to test. The book goes on to show cases of how Spring can permit simpler JDBC writing, with less explicit exception handling. As you may know, standard JDBC usages often lead to ugly sections of try/catch statements littering your code. So the brevity offered by Spring might enable easier maintenance.

Likewise, Spring is said to give an easier alternative to a heavyweight EJB usage, in terms of less code to maintain.

But the authors do indulge in some overblown rhetoric. Like calling a Factory and Singleton "false patterns". Certainly, for Singletons, there are times when it is natural in your code for a class to really have only one instantiation at a time, which is the gist of a Singleton. While Factory classes can encapsulate and hide a lot of complexity from you. While it means that, yes, if a Factory call fails, the reason can be obscure. But when it works, which should be most of the time, you have a nice partitioning of your code. The authors are overreaching, and adversely impacting the strength of their arguments.

The book is excellent - especially in the breadth of the topics covered. It provides a through overview of the IoC/DI concepts, implementation of these concepts in Spring, and typical usages of DI ("why and when" as Rod Johnson puts it in the foreword).

My reservation is that this book is truly excellent if...you are new to the Spring world. For me after reading first two books by Rod Johnson ('J2EE Design and Development' and 'J2EE Development Without EJB'), reading online docs, and following Spring's mail lists for more than a year, it was difficult to find anything new.

Also, because it tries to cover every single feature of the Spring framework, not all topics covered with the same depth. For example, Spring's web MVC coverage is very brief - online docs on the www.springframework.org do a better job here. The chapter on iBatis is again excellent if you don't know what iBatis is and how it can be integrated with Spring. Because Spring essentially becomes a complete developer's replacement of the official J2EE, future books might benefit from narrowing down the topics to be discussed.

Quality of the text is good to excellent, especially compared to thousands of useless "printouts" of the official J2EE blueprints. It follows a good tradition established by Rod's books to give valuable and very practical advice and examples for typical situations, which are applicable in any application - with or without Spring, inside or outside of Java.

I'm about 1/2 way through my second reading (no small task - this is a big book) and I can't say enough good about it. If you're a J2EE architect without any exposure to IoC/DI, this title will open up a whole new way of thinking about application architecture for you. If you already have Spring experience or are already working with Hibernate, iBatis, JDO, JMS or the other staples of enterprise development, you'll still learn a lot from the book (I had a year of intensive prior experience and I'm gaining a lot from each chapter).

When I cracked open the first book dedicated solely to the Spring framework, I expected a rush job. After all, the book covers Spring 1.2, which hasn't been out there all that long. I was pleasantly surprised. It's tough for a book this fat to be this timely. But it is.

Let me start with what I liked the most about the book.

- The authors start with examples that don't use dependency injection at all. They refactor those exmaples, so you can see the value of the core design pattern supported by Spring. This, in my view, was nicely done. It's critical.

- The authors treat each topic completely before moving on to the next. For example, for the base container, they walk through the edge cases, like method injection and introduction, and explain the core problem that they solve. As early contributors of Spring, the authors were well positioned to do this.

- The example is simple. I think that there's been too much of a movement to building real business applications in books. These treatments quickly bog down into details, and distract from the topics that they're trying to cover.

- The sense of humor is there, and it's not overdone. I like having the obscenity filters as an AOP example. (I just wish that the book found some way to include a logging example...or not.)

- The book is comprehensive. It covers the core subjects of DI, AOP, persistence, messaging and remoting, but also some edge scenarios like mail, scheduling, and the like.

It's tough to find a down side, but if I had to pick, I'd say that the language bogs down at some points. This, in my opinion, falls on the editors, and not the authors. I do think that the order of the topics was a bit strange, like introducing AOP before establishing a need.

But I'm picking here. This book is very well done, and I'm glad I got it. I would definitely buy it again.

After reading way too many docs about way too many web view technologies, I found Spring which was exactly what I was looking for to help me with the middle and back-end tiers. The only problem is that even though everyone says it's so well documented, the documents tend to be either in-depth reference manuals or really simple tutorials that only show one aspect of the framework.

I was very pleased to find this book, and after reading it, I feel very excited about starting a large spring adventure.

This book covers just about everything you need to know about Spring to build a full blown app, but more importantly it also shows you where/how to start (which is not so easy to figure out sometimes) and how to implement things in a very reusable way.

The organization of the book seems strange sometimes... having the huge sometimes confusing section about AOP in the beginning (chapters 6 & 7) really makes your brain spin, but by the time you get to chapter 11 (designing and implementing Spring applications) you can easily put things together and the previous sections make more sense.

The book takes you through building a blog application as it's main sample app, but all along the way there are many many tiny little code examples that are self-contained and demonstrate how a single concept works. This *does* work well to make sense of things, but I wish there was a section that only delt with building the sample app from start to finish all in one place.

Also, after downloading the sample app, I had a few problems running it.... there aren't any configuration instructions, even though you can choose any of 3 data layers, and once I built and deployed it, I found it was missing some jar dependencies. Once I put them in place, it did run as expected.

I think that the best thing about this book is probably the way in which it promotes good software design and reuse, even if you're not going to use Spring through the use of the DOM pattern, designing to interfaces, and testing.

All in all, this is a great book. If you're looking to build an application using Spring, read this book. It's the best resource for getting started, and will also make a great reference.