Customer Reviews

Advanced J2EE Platform Development: Applying Integration Tier Patterns

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

 

 

Lives up to its title. Ideally suited for those of you already well-versed in UML and refactoring, though not necessarily in J2EE per se. If you have used legacy applications and have done some case studies of abstracting out the business logic with the idea of redeploying into a large multiuser web environment, then the book should have value to you. The patterns described herein may well be germane to your problems. Plus, going through some of the steps in identifying and implementing these patterns may have merit in and of themselves, quite separate from any particular pattern. Because in a complex development environment with participants from quite varied backgrounds, the sheer mass of detail can obscure the essential level of abstraction to usefully tackle the problem.

Think of it like this. Applying the book's methodology to your situation can be like setting an agenda for a meeting. Gives focus and discipline and, hopefully, an endpoint.

There is another cogent reason for the book to have merit to you. It discusses candidly the scaling limitations of using Enterprise Java Beans. This is an official Sun book. Earlier texts from Sun that I have read rarely point out any of the EJBs' problems. Perhaps when EJBs were first introduced, these were unknown. But several soon became apparent to developers. Unfortunately, in other Sun books, little of this is presented. You had to scan the newsgroups on the web to find out. Finally, we have it in "official" form.

This book focuses on integrating J2EE with mainframe applications. The patterns described in the book demonstrate how to encapsulate an integration tier that shields the J2EE elements of an application from the legacy elements, so Java applications can take advantage of existing mainframe code.

The book goes through a real-life example by describing a banking integration project. With this example it describes the common integration patterns, DTO, DAO, Local Transaction Cache, etc. One of the major points the authors make is the benefit from having a common domain model across the enterprise. The common domain model will provide a consistent business data model across an enterprise for all users, so everyone in the organization will have a common vocabulary.

If you are a Java developer who is involved with integrating mainframe application this book is an excellent resource to have on the subject. This book is a concise and practical guide to enterprise integration.

Although Topic and overall structure of this book was not bad, but this book seriously lacks providing context.
Even worse, writers used common words too much without exact definition. (without explanation)

As a result, the story of book came to only writers's.
And maybe also to a member of their team...

Understanding this book is really hard.
Not because of difficulty, but because they dropped too much.

I really don't know how this book pass SUN TE certification.
If that certification process really happened. :-(

This book addresses a topic that faces many mainframe development shops, the integration of J2EE technology with existing mainframe systems. The subtitle "Applying Integration Tier Patterns" gives only a hint of the complexity of issues dealt with in this rather compact book.

The book includes chapters on the following: creating a common domain model for the enterprise, creating a design model, implementing an integration tier, and the actual development process. The process detailed with creating a common domain model could be an rather involved and expensive. The payoff is in the reuse of existing legacy functionality with an integration tier that it can be reused.

Some of the valuable insights for integration that are addressed include managing distributed transactions, achieving rollback using compensating updates, managing the impedance mismatch between objects and legacy, and the pitfalls of caching persistent data. Important considerations and workarounds are explored. One area that could have used more development is addressing the side effects that are embedded in legacy functions.

The book relies heavily on outside material that should be considered prerequisite, such as "Core J2EE Patterns". Additionally, some knowledge of UML modeling is useful (class and sequence diagrams). The concepts presented can be very useful for organizations that are facing such challenges, however due to the dense text and somewhat abstract presentation, it is not as accessible as it could be. Additional explanations of the terms and concepts in the appendices could be helpful. An example that is developed throughout the book could add additional insight. Although, there is a lot of value here for architects coming from primarily a mainframe background.

If you are an J2EE or Application Architect who is involved in J2EE enterprise application integration project (especially mainframe legacy integration), I strongly recommend you to get this book.

Pros:

- this is the only book I am aware of that describes how to implement Common Domain Model pattern in J2EE mainframe integration project using RUP methodology (the pattern itself, as described in Core Patterns and Fowler's book is rather complex beast; practical implementations of this pattern in previous books focused on object/relational mapping and data tier represented in relational DBMS)

- the book is based on real-life banking legacy integration project (you will find here even the templates of actual Cobol copybooks used to design Data Transfer Objects!). How many real-life J2EE books are out there? Not many I assure you, this being one of those few

- it focuses on a combination of the most important J2EE patterns applicable in EAI, data integration in particular: DTO, DAO, Local Transaction Cache, Common Domain, Partial Population, Compensating Transaction, Data Source Adapter, DTO Composite, Unit of Work, Abstract DTO, DTO Extension, Business Rule Object and others

- THIS BOOK SHOWS YOU STEP BY STEP HOW TO ACHIEVE CLASS REUSABILITY ACROSS ENTERPRISE J2EE/EAI APPLICATIONS. Buzzword these days is SOA which stands for Service Oriented Architectures. SOA promotes service (business process component) reusability. But in enterprise level establishments class reusability is even more important. IMHO, on large scale enterprise J2EE/EAI projects, class reusability approach as described in this book can result in DOZENS OF MILLIONS OF DOLLARS IN SAVINGS. Imagine for the moment (and I assure you, in real world there are many similar examples, especially in finance and insurance industry) that there is a corporation XYZ which accumulated hundreds and hundreds of legacy, mainframe based applications over the last 50 years. This corporation now wants to offer their products to customers through different channels including internet, in shortest possible timeframe. What strategy should this corporation adopt? Obviously, they will need an integration J2EE platform like Weblogic, Websphere or similar. But should they first select a subset of products, divide the work amongst projects and build services around these products, pretty much independently in each project, and later offer other subtypes/variations of the same products or other categories of products, starting from scratch in the same fashion? Or should they first invest in developing a common enterprise domain model at analysis and design level and later on build specific domain models on demand and in seamless fashion, by extending, deriving and refining from common domain analysis and design model? This book advocates later approach and it describes thoroughly how this can be achieved.

- this book explains RUP methodology in simple, practical way using UML notation. It shows exactly what is the role of Business Designer, Use Case Specifier, Architect and Designer. Maybe this sounds trivial, but you would be surprised how many organizations misuse RUP buzzword! In my opinion it is better not to use methodology at all instead of using it wrong way

- the book gives you invaluable advices regarding architectural pros and cons in designing J2EE/EAI applications, like pitfalls of caching persistent data, (mis)usage of entity beans and CMP, consequences of legacy system architecture, managing distributed transactions, implementation of Transactional Resource (artificial XA) using JCA, implementation of pending transaction queues, data cleansing/merging and many others

- there is no fluff talk in this book!

Cons:

- some paragraphs could benefit by adding clarifications or explaining concepts in better way. I had to read it twice to understand some nuances

- having 'development' in the book title, I think the book could benefit by offering better organized source code together with modeling artefacts, possibly via download or in appendix; I am envisioning here some kind of legacy/JCA emulator that would help reader deploy and try the code