Customer Reviews

Pro Spring Dynamic Modules for OSGi Service Platforms

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

 

 

This book came in at just the right time. My company is about to begin utilizing the OSGi model of deployments and I needed something substantial that would give me a good understanding of OSGi.
And I have to say this book delivers.

The first part of the book goes through the OSGi API style of deployments without utilizing Spring. That actually starts making the whole concept of services and references to services more clearer.

In the next chapters the author goes on to show how Spring DM can be utilized to do the deployments. This makes it much easier to do the deployments.

Then there is a whole chapter devoted to versioning. I didn't even know that you could version specific packages.

Gathering from the title, I thought there would be a big push for the Spring DM Server. That wasn't the case. The author only talked about the Spring DM server in one of the chapters and on the specifics of the Spring DM Server packaging systems in another.

The testing chapter in the end is killer though. I wouldn't even know where to look to figure out how to do the testing of OSGi bundles, especially the integration tests.
Using the Spring DM Testing API, it makes it quite easy (at least from the two examples that were presented).

Overall the style of the book is very easy to read and this book provides so much information that I consider it the OSGi Bible.

If you are going to be using OSGi, I highly recommend this book!

In my opinion this is one of the poorer development books I've read in a while (I probably go through 7-8 per year). I wanted to like it, and I wanted to keep giving it a chance, but it continued to let me down. Perhaps it just isn't suited to my reading style; I prefer reading books apart from a computer unless I know that it's an iterative hands on tutorial (a la Agile Web Development with Rails). I've learned languages, frameworks, and algorithms this way. One major consequence in not running the examples with a machine in front of me is that I have to keep everything in my head, which usually isn't a problem. A second consequence is that I will do mental checks whenever something is added or changed to the code or configuration - a sort of 'yea, that makes sense, so does that; okay why did they do that? ah, now I see, that makes sense then' train of thought.

This was my first major problem with this book - the mental checks continuously failed.

I really feel sorry for anyone who hasn't used Spring before and picks up this book. Chapter 2 (Introducing Spring) does a horrible job of it, and I fear that anyone reading through it without thorough knowledge of the platform will swear it off for good as being incredibly complicated. The 'Hello World' example is so full of extraneous junk that I have to guess that the author had a page quota to reach. Extras bolted on that aren't necessary for a introduction include: JPA usage, testing JPA, SpringMVC, AJAX, and finally what blew it for me; Tiles. The whole time I was asking myself 'why are all these pages being dedicated to topic X' when that topic didn't have anything to do with OSGI or Spring DM. I finally lost it when he started using Tiles. Why the f*** would you use Tiles for a Hello World example?! It along with the other aspects mentioned above only serve to complicate the example for no good reason. A much better approach would have been to start with something small and simple - straight Servlets and JSPs and build upon it in later chapters when relevant concepts pop up. Further examples don't build off of this Frankenstein Hello World which is good and bad. Good because it's a terrible starting point (fortunately the other examples in the book drop the use of Tiles - which begs the question - Why was it ever brought up?), bad because you have to learn something different from the ground up.

A second irritating example of this is the Chapter 7 example which introduces a JDBC version of the JPA application from Chapter 5. Why is this done? We're not learning anything interesting here that requires a full example. Anyone with knowledge of Spring knows that you can easily substitute different DAO implementations. What is especially frustrating is that in Chapter 5 (which uses JPA and SpringSource dm Server) the author discusses the complications of running JPA in an OSGI environment, and special things that are built into the SpringSource server to make this easier for you. What I really want to learn in Chapter 7 is how to run JPA without the SpringSource server and its prebuilt magic; instead I get a sidebar saying it can be done with minimal instructions to do so. What I would have preferred in this chapter is an example of what is hard (getting JPA running w/o Spring's server), and a sidebar about what is easy (using a JDBC DAO instead of a JPA implementation).

My second major problem was that I didn't feel that it did a good job of discussing OSGI implementation strategies and covering other issues that would come up in a project with more than a few toy services. In the example provided in Chapter 5 a simple application is broken up into six OSGI bundles. This seems excessive for a small example, but how does it grow when the number of service/model/web components grows? I also don't remember getting a good overview of (in my mind) one of the more interesting aspects of OSGI and Spring DM - being able to deploy new versions of bundles without restarting your server.

There were other areas of the book that felt like filler and really didn't seem to add much to the topic of OSGI. Examples include integration with Apache Ivy, using SSL with Tomcat, and Flex integration. All of these to me seem like loosely related topics that could have been mentioned in much less detail. I would have preferred more discussion of core OSGI topics mentioned in the above paragraph.

Finally the book in general seemed rushed and lacking focus. There are problems with code examples. There are formatting problems (some listings are inexplicably double spaced for example). There is a lot of 'junk' woven in to things that is just unnecessary (XML namespaces that are not needed, multi-page listings of OSGI manifest files, the use of Tiles - it really bugs me, can you tell? :). The whole thing is written like a long blog entry instead of a good book; it's a step by step tutorial that works if you download the code from the book's site, but not if you type it in or try to make sense of it in your head due to some errors. I'm guessing that it was trying to be the first to market on this topic. It succeeded at that, but failed as good coverage of the material. Don't get me wrong - you'll learn about OSGI, Spring DM, and the SpringSource dm Server, but it'll take more effort than it should to make sense of it all.

Personally I'm waiting for the Manning books on the subject. They've split things out across different books which will hopefully give each subject the space that it needs to be covered properly.

You've heard about OSGi but do not know what it is? Or do you think this is too complicated? Then the Daniel Rubio's book is probably a simple way to learn OSGi thanks to Spring Dm.
This book is well written and gives a first approach on the subject. In the first chapters, OSGi is explained very simply and you will learn what are the benefits of this technology face to JEE.

Then Dm Spring will be presented. This brings the simplicity of POJOs in the OSGi world, like all the Spring projects.
You do not know anything of Spring? No worries! A brief but sufficient introduction of the Framework will be made, allowing you to follow the book without difficulty.

Other subjects, always revolving around OSGi and Spring, will be covered. This is the case SpringSource server for example. Thus you will learn the extensions it provides to OSGi to facilitate development, especially for JPA.
The tool 'bnd' is also introduced in summary, to explain you how to make a OSGi-compatible JARs without too much effort.

In short, it is an excellent book to start with OSGi and Spring Dm, but for me it does not go deep enough for a book of the "Pro" collection.

This book is the first and most comprehensive guide to two Spring OSGi(tm) products: Spring Dynamic Modules for OSGi(tm) Service Platforms and SpringSource(tm) Server released till now. It can be thought of as a full featured, professional, step by step tutorial to OSGi(tm) world from Spring's perspective. Each topic is filled with examples and code listings that you are encouraged to go through to better understand the concepts being presented. The complete source code bundle can be downloaded from the publisher's website and contains everything you need to run applications: not only java code, ant scripts, ivy dependencies, server configuration snippets but also OSGi(tm) containers and all required libraries!. I can assure you that having them all put together in one place will save you a lot of time when you decide to play with the samples.



The book consists of 9 chapters, each focused on a different aspect of Spring and OSGi(tm). It starts with an introduction to OSGi(tm) and Spring Framework to help you understand the fundamentals of each technology and how to combine their distinctive features sensibly to create robust, manageable, enterprise-level solutions. In the following chapters you can find details on Spring Dynamic Modules for OSGi(tm) Service Platforms and learn how to simplify the process of creating Spring applications for OSGi(tm) environment and SpringSource(tm) Server which is a full featured Application Server designed to run both enterprise Java and Spring OSGi(tm) applications. Finally, the author explains the design principles of the web and data access layers in a springified OSGi(tm) environment, the OSGi(tm) versioning, and there is also a chapter about integration testing techniques.



Pro Spring Dynamic Modules for OSGi(tm) Service Platforms is indubitably a definitive guide to Spring OSGi(tm) products . It presents Spring development in OSGI(tm) environment in a very practical and well organized manner. The style of the book is very easy to read and it provides so much information that I can highly recommend this book to everyone interested in developing Spring applications on OSGi(tm) platform.

I have been sitting on Pro Spring Dynamic Modules for Osgi(tm) Service Platforms for a while, although I got a fresh copy right after if was released earlier this year.

One reason for this might be, that after reading the first chapter, it felt like I was reading a manual rather than a book. Personally, I like a little bit more subjectiveness, because it improves the reading experience significantly. The author should spice up the dry material, so you won't get bored that easily. Unfortunately, that's what happened to me - I got bored. However, let's turn the spotlight to the content of the book.

The introduction chapter on OSGi is sufficient to get you up to speed. There are about 60 pages of Spring introduction. However, I think you should at least have some practical experiences with Spring, before digging into Spring Dynamic Modules or even Spring DM Server. It's simply not enough to explain the technicalities, to get someone an understanding of what Spring an its concepts is all about.

There's lot's of code in the book, which you can download and play with. If you like to read code, printed in a book, you are probably gonna like "Pro Spring Dynamic Modules for Osgi". For me, a book is not the preffered media to consume code. I have nothing against small code samples, but having pages over pages full of code, is really confusing and hurts readability.

The manual kind of feeling of the book continues the further you keep reading. Let me give you a concrete example: In chapter 4, called "Spring Dynamic Modules for OSGi", the author explains how the scope attribute of a bean declaration works. Unfortunately, the how is all there is to the explanation. I expected a real life example of when to use the scope attribute and where it might not be suitable. I do understand, that the book can't go into details all the time, but especially those powerful Spring DM features like scoping, deserve more spotlight. Most of the time, the book stops when it gets interesting and you are left with your own imagination of how to apply that particular feature.

Despite the criticism, I got some neat tips from the book. The author suggests to split the OSGi dependent and traditional Spring configuration to make life easier for testing and mocking. I also gained a lot of knowledge from chapter 6, called "Versioning with OSGi and Spring". The author explains the concepts and implementation of versioning most of the time in a very understandable manner.

Overall, I think Pro Spring Dynamic Modules for Osgi(tm) Service Platforms is a reasonable reference book, with a nice sample application. If you are new to Spring and OSGi, you might have a hard time understanding the use case for those technologies, so I'd suggest to get this book as an addition to some basic reading material.

At last I could sink my teeth into the long-awaited "Pro Spring Dynamic Modules for OSGi(tm) Service Platforms" and to my great surprise it wasn't very well spent time. I hoped the book was meant to introduce me to OSGi as well as Spring Dynamic Modules for OSGi Service Platforms (Spring-DM in short), but there were a lot of pages about Apache Ant, Apache Ivy and SpringSource dm Server to name a few which all made me wonder if the book title reflects what's really inside. It was as much valuable in my quest for a comprehensive book about OSGi/Spring-DM as it was boring with its too many unnecessary listings of Ant's build.xml's or the additions I wouldn't call OSGi- or Spring-DM-related in any way. If I had to make a choice recommend it or not - I would certainly not, but...there's always "but"...it covered quite enough OSGi-specific topics, esp. in those commentary grey boxes that provided you don't have another book or article to read you can pick the book for some nice yet very short "Aha!" moments. The book is a mixture of very introductory material to everything which one could possibly use in a project and a few pages with a highly sophisticated explanation of the OSGi spec. In other words, you will find many interesting pages, but you will need the patience of a saint to find them.

When I received the book I couldn't hide how happy I was. It was my first book about OSGi and after reading the OSGi spec I really needed a book for more understanding of it. After all those recent books about Groovy and Grails where I could find many real-life examples of their use I thought the book would have been exactly the same. The 1st chapter "Introducing OSGi" was really great. Lots of OSGi coverage with enough details. I did like it a lot. Then, out of the sudden, came out the 2nd chapter about...Spring Framework itself. No OSGi, no Spring-DM. I didn't mean to read a book about Spring itself but Spring-DM at the very least. That is the difference. If the author aimed to fill out the book with some additional pages and to have its readers got bored, that goal was achieved. Why did the 2nd chapter take 60 pages if the 1st took only 40? It remains the mystery. The 3rd chapter was better, but just slightly better. Enough said about OSGi that I was almost convinced I'd find more in the upcoming pages. Then came the 4rd chapter about Spring-DM. But wait, there were only 30 pages about it. How came the book had Pro and Spring-DM in its title?! The chapter 5th "SpringSource dm Server" was the most boring I could find in the entire book. Although I appreciate the efforts to introduce the product to me, I couldn't accept it lasted for almost 60 pages. When you sum up how much content was about OSGi and Spring-DM vs the other stuff you will know why I'm so disappointed. Definitely too much about the other auxiliary tools. The remaining part of the book where OSGi versioning, web application development and testing were discussed was pretty much fine. Don't be fooled by the names themselves though, there're again way too much about how Spring Framework handles it and very little about how OSGi and Spring-DM tackle these tasks. Way too much.

I'd say it could have taken less pages and the book would earn better rating. All in all, if you're looking for a book about OSGi/Spring-DM I'm sure only a few chapters are for you in this book. Don't expect too much to be covered as far as these two technologies go. You'll get disappointed for sure. If only some basic coverage of these topics are acceptable you may get satisfied. I was not. The "Pro" in the title obliges the author to pay more attention to how OSGi/Spring-DM work under the covers. There's far more to be said about OSGi/Spring-DM and "Pro Spring Dynamic Modules for OSGi Service Platforms" only scratched the surface of the topic. You've been warned.