Customer Reviews

Service Oriented Architecture with Java: Using SOA and web services to build powerful Java applications

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

 

 

The book is about all and nothing. It's not very technical book and the subject of SOA in Java is barely scratched. There's everything you might find useful at your first day in your job as a SOA architect, but SOA Java programmers will likely find it hardly bearable. My interest in reading the book was to find a thorough explanation of what SOA means and how one can build SOA architecture with Java tools and projects. Well, there's a chapter about Java specification - JAX-WS - and projects like Apache Axis, Spring-WS and XFire (Apache CXF), but they're merely introduced and presented with very simple examples. Examples are meant to be simple, but not that much. The first chapter "The Mantra of SOA" is way too long and quite boring. The authors used lots of acronyms that might easily confuse like C/S. I certainly was. The second chapter "Web Services and SOA" makes a cut from the previous one. It's quite an interesting chapter with thought-provoking explanations, but it ends leaving a reader with "What! That's it?!". "The more you have, the more you want" I'd say and after the first chapter I really needed more. No code till the chapter 3. "Web Service Implementations". It was the very first time I could "taste" Spring-WS and XFire. Together with JAX-WS and Apache Axis, the samples of each were so simple that I barely noticed a change. Definitely not much to digest. JBI and OpenESB were mentioned very lightly as well. With other specifications - SDO and SCA - in the chapter 4. the book left a bad taste in my mouth. I could read a lot about different Java specifications for a successful SOA project, but enumerating them only would make no difference. That's not what I expected from a book "for JAVA programmers or architects who are interested in implementing SOA concepts to their applications" as the book's cover announces. I think the book aimed at Java programmers but eventually paved the way to SOA architectures for architects or business people. Too much "theory behind SOA" (quoting the book's cover again). The last 2 chapters are about imaginary projects to compare EAI and SOA approaches. They didn't draw my attention fully again. Although the book was not the one I had read if I'd have known what it was about before I must admit I have no regrets. A slightly over 150 pages are read very nicely and just because I found a few points about hub and spoke vs ESB architectures interesting (see pages 132-133) it was worth my time. Perhaps, yours won't be lost either.

This is the first book that is being given just one star. I had the misfortune of ordering and attempting to read this one. These are some of my gripes:
. If the aim is to learn about JAX-WS, JAXB, WSDL, SOAP etc in more detail than a reading it off a billboard then this book is not for you. This was akin to reading a ppt or off a billboard. Yes, there was some useful information but it was more like a pointer that I had to follow through with the aid of google.com to get comfortable with it. This book will give you a lot of jargon in 175 pages but that is about it. And it will also make your wallet lighter. I could have used the JAXB tutorial on the JAXB net site and that would have covered JAXB and I assure you that is awesome. JAX-WS details someplace else. Similarly for SOA, Mike Hansen's book would do the trick. Unfortunately, I would have to agree that the absence of writers such as E Rusty Harold, Monson-Haefel is being felt in the SOA and Java Web Service arena.
. Overall the quality of writing style is confusing and terminology and acronyms are scattered throughout and in some cases, not explained satisfactorily at all. For instance "3GL", "4GL", "M and A" etc. Repetitions galore in 175 pages - start to finish. It would appear as if the content in the book has not been proof-read and the authors have collaborated albeit still have managed to essentially hash the same stuff again and again. This is a book about SOA but does that imply that some SOA aspects have to be repeated again and again? For instance: "Why SOA" in the first chapter 1 and then the same hashup in the last chapter.

I think I would need to go off PACKT publishing for a while as well just for my sanity - this time that I spent on trying to read this book will never come back - all I can do is to write this review and make some positive contribution off that.

I like this book. Sure, there are some strange English expressions in here that can sometimes annoy but mostly amuse a native English speaker. But look beyond the malaprops. Binildas Christudas knows his stuff, and he knows it deeply. His writing is easy to understand. I would much rather he take the plunge (and his publisher Packt Publishing too) to give us the benefit of his considerable knowledge and experience, than to give up on writing a book with a few English idiosyncrasies.

Chapters 2 3 and 4 give really good examples of how to create different web service message implementations, but the examples are too simplistic. Knowing the commands to type is useful, but does not provide the depth necessary to troubleshoot a problem. For example, what exactly do the annotations implement. Saying that a WSDL is hard to implement is not really a good justification for avoiding how to create web services and clients based on a WSDL. My most common task is to create a client based on the WSDL.
In summary, the main topics really need to explained in greater detail with more than just the usual single simplistic example.
Also the book really neeeds a thorough edit. Missing words and bad grammar make what is good writing hard to read.

The back cover says this of the intended audience: "This book is for Java programmers or architects who are interested in implementing SOA concepts to their applications". This sentence describes the book well, and foreshadows some of the things I liked about the book, and some of the issues.

First the good. If you are a Java developer or architect who is looking for an intro to SOA concepts and some Java web service implementations, I would recommend this book for you. It's not perfect, but it's a decent intro to SOA and it will show you a good amount of detail about various Java WS implementations. Additionally it's a fairly quick read, and I don't know if you're like me the fewer pages a book is the more likely I am to read it.

Finally, there were some things I didn't like it. First, it's not the best intro to SOA concepts I've ever read. Introducing SOA is tough and I've struggled with it myself. Still if you're looking for a pure SOA tome, this is not it.

Second, go back and read the audience sentence above. It's not mistyped. "implementing SOA concepts to their applications" is awkwardly worded, and you can trust that if the cover didn't get proofed well that the rest of the book didn't either. From the bios I can infer that the authors are not native speakers, so I wouldn't expect the text to be perfect prose. I *would* expect, however, that the book be proofed a little better. However this doesn't interfere too much with reading, so I wouldn't let it keep you from purchasing the book.

So, in summary if you fit the above description of the audience, then I would recommend Service Oriented Architecture with Java to you.

The book is divided into three parts:

1) Fundamentals (SOA + Web services)
2) Code examples (web service implementations + emerging standards)
3) Benefits (Case studies + Goals)

I appreciated the first part where the authors cover the fundamentals and the benefits of the Service-Oriented-Architecture together with a clear explanation about the communication protocols used for the web services (SOAP and REST), the differences between the RPC and Document Based-WS approaches, and the existing implementations for web services (JAX-WS 2, Axis 2, Spring-WS, XFire/CXF 2.0).

The second part is certainly the most practical one. It provides representative code examples about each one of the mentioned implementations (the code is available from the publisher's site) and shows the way each of these implementations work.

And the final part makes a comparison between an Enterprise Application Integration (EAI) approach versus a SOA approach (this last one superior to the first one, of course) and a conclusion about the goals that can be achieved with SOA.

What I think needs to be considered:

1) The last chapter (Goals we can achieve with SOA) is misplaced. It should be part of the introduction and not part of the conclusion. In fact, even the header on this chapter indicates Chapter 1 instead of Chapter 6, which may suggest a last minute change (without the appropriate verification).

2) In the case study with the EAI approach, benefits and drawbacks are mentioned. In the SOA case study, there are only benefits. Is there really not a single drawback for this approach?

3) I would also suggest changing the font used on level-1 and level-2 headers. The difference between them is not evident and this makes it a little bit difficult to see the structure of the chapter.

What I missed in the book:

1) A separate section about additional resources (tools, recommended reading, etc).

2) A mention of standards and/or best practices when implementing web services.

3) A more complete explanation about the way to implement "Contract-First versus Contract-Last approach" when defining a web service. When I read: "(...) creating a WSDL is not a trivial process and hence we may not be able to do that easily without some special tool support." ... and there was no tool recommendation or a short example I felt disappointed.

It is certainly a good introductory book on the subject. If you are looking for an overview on SOA and web services, it is a good point to start.

Books on SOA either read like sales pitches end-to-end or get so bogged down in various aspects of web technology that by the end of the book you certainly know how a hammer is made, but have no idea of how to use one to repair a roof. This book gets the roof repaired. It approaches the Service Oriented Architecture from both the technical and business angles and does so in less than two hundred pages. Obviously, you won't be ready to go out and build a SOA, but you'll have an idea why you should and under what circumstances and what technologies you should be investigating. There are even a few lines of code in this book - just a few as part of a case study that is presented, not a ready to use application. The small case study included compares a traditional EAI (Enterprise Application Integration) solution with an SOA-based solution of a simplified business problem. It certainly cleared up a few details for me.

If you are a programmer and you want your SOA-programming understanding to be current, this book is for you. If you are a high-level designer or an architect with little or no Java knowledge, this book is also for you since it will help you understand when and how to apply the SOA-approach. Highly recommended.

I recently read "Service Oriented Architecture with Java" by Binildas CA, Malhar Barai, and Vicenzo Caselli. This book provides a look at some of the tools in the java world that can be applied to support a Service Oriented Architecture.

There are 6 Chapters in all:

Chapter 1: The Mantra of SOA
This chapter reviews basic tiered architecture, EA and the basic points of benefit of SOA including better integration, business agility, asset re-use, increase ROI

Chapter 2: Web Services and SOA
Practically all current SOA implementations now are built upon web services. XML over the Http protocol is covered. Representational State Transfer(REST) is covered. Main java implementations of web services are introduced including JAX-WS 2, Axis2, Spring-WS, and XFire/CXF 2.0.

Chapter 3 : Web Service Implementations
Code is presented for getting a web service up and running in JAX-WS2, Axis2, Spring-WS, and XFire/CXF 2.0 The coded examples are very easy to follow and can get a developer up and running quickly.

Chapter 4: Data and Services - All Roads Lead to Enterprise Service Bus
This chapter reviews JDO(Java Data Objects) as an alternative to JDBC along with sample code and examples. Service Data Objects(SDO) are covered as a way to abstract data within and SOA. Apache Tuscany DSO is covered with an example. Service Component Architecture(SCA) is described along with a Tuscany SCA java example
Benefits of MOM and ESB are also covered. OpenESB is covered as an open source option for implementing an ESB.

Chapter 5 - Traditional Integration Technology
2 Case Studies are presented showing the advantages of an SOA based architecture over that of EAI.

Chapter 6 - Goals We Can Achieve with SOA
Loose Coupling, Reusability, Seamless Integration, Return on Investment(ROI)

All in all this is a pretty good book. It's focus is definitely to provide information on a SOA implementation in a java oriented environment. This book covers the basics of the open source options to getting java based web services and infrastructure. I would strongly recommend this book to those trying to do open source SOA implementations in java.

This book was pretty good for an overview of SOA principles. Good for seeing some well founded reasons why to use SOA. If you had to convince your IT manager that a service oriented approach was where the company needed to go, he should read it. The book should be titled SOA for Java managers really, not for developers. I skimmed it in less than an hour and got all I needed.

An absolute pleasure to read...the best SOA book I've read for Java and SOA for current technology. A book I would recommend to all of my colleagues; it provides much insight to the topics often overlooked by most books in this genre like Data Services and Service Component Architecture...the XML code is fantastic."