Customer Reviews

Java Transaction Processing: Design and Implementation

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

 

 

Since many financial institutions have standardized on it, I hear Java is the new COBOL. Whether or not this is true, if Java is to become the business language of choice, transaction support is crucial. (By 'transaction,' I mean 'allowing two or more decisions to me made under ACID constraints: atomically, consistently, (as) in isolation and durably'.) Over the last five ears, the Java platform has grown by leaps and bounds, not least in this area.

Java Transaction Processing by Mark Little, Jon Maron and Greg Pavlik, explores transactions and their relationship with the Java language and libraries. Starting with basic concepts of transactions, both local and distributed, including the roles of participant and coordinator, and the idea of transaction context, the book covers much old but useful ground. Then, by covering the Java Transaction API (JTA) as well as OTS, the OMG's transaction API which is JTA's foundation, this book provides a solid understanding of the complexities of transactions for Java programmers who haven't dealt with anything more complex than a single RDBMS. I'd say these complexities could be summed up simply: failures happen; how can you deal with them reliably and quickly?

The book then goes on to examine transactions and the part they play in major J2EE APIs: Java Database Connectivity (JDBC), Java Message Service (JMS), Enterprise Java Beans (EJB) and J2EE Connector Architecture (JCA). These chapters were interesting overviews of these technologies, and would be sufficient to begin programming in them. However, they are complex, and a single chapter certainly can't do justice to any of the APIs. If you're new to them, expect to buy another book.

In the last section, the authors discuss the future of transactions, especially long running activities (the Java Activity Service) and web services. This was the most interesting section to me, but also is the most likely to age poorly. These technologies are all still under development; the basic concepts, however, seem likely to remain useful for some time. And, if you need to decide on a web service transaction API yesterday, don't build your own, read chapter 10.

There were some things I didn't like about Java Transaction Processing. Some of the editing was sloppy-periods or words missing. This wasn't too big a problem for me, since the publisher provided me a free copy for review, but if I were paying list price ($50) I'd be a bit miffed. A larger annoyance was incorrect UML and Java code snippets. Again, the meaning can be figured out from the text, but it's a bit frustrating. Finally, while the authors raise some very valid points about trusting, or not, the transaction system software provider, I felt the constant trumpeting of HP and Arjuna technologies was a bit tedious. Perhaps these companies are on the forefront of Java transactions (possible); perhaps the authors are most familiar with the products of these companies (looking at the biographies, this is likely). The warnings-find out who is writing the transaction software, which is probably at the heart of your business, and how often they've written such software before-were useful, if a bit repetitive.

That said, this book was still a good read, if a bit long (~360 pages). I think that Java Transaction Processing would be especially useful for an enterprise architect looking to leverage existing (expensive) transactional systems with more modern technology, and trying to see how Java and its myriad APIs fit into the mix. (This is what I imagine, because I'm not an enterprise architect.) I also think this book would be useful to DBAs; knowing about the Java APIs and how they deal with transactions would definitely help a DBA discuss software issues with a typical Java developer.

To me, an average Java developer, the first section of the book was the most useful. While transactions are fairly simple to explain (consider the canonical bank account example), this section illuminated complexities I'd not even thought of-optimizations, heuristic outcomes, failure recovery. These issues occur even in fairly simple setups-I'm working at a client who wants to update two databases with different views of the same information, but make sure that both are updated or neither; this seems to be a typical distributed transaction. The easiest way to deal with this is to pretend that such updates will always be successful, and then accept small discrepancies. That's fine with click-throughs-money is a different matter.

However, if you are a typical web developer, I'm not sure this book is worth the price. I would borrow it from your company's enterprise architect, as reading it will make you a better programmer (as well as giving you a sense of history-transactions have been around for a long time). But, after digesting fundamental distributed transaction concepts, I won't be referencing this book anytime soon, since the scenarios simply don't happen that often (and when they do, they're often ignored, as outlined above).

This is not a book for beginners. It assumes knowledge of Java and as well as a fairly broad knowledge of various other technologies. However, I did find it to be quite readable considering its complex subject matter, with an excellent balance between theory, practice, and illustrative examples. Many J2EE application developers do not understand two phase commit transactions, and hence have little understanding of, for example, the consequences of involving messaging and database operations in the one transction. I would highly recommend this book to all J2EE developers as an excellent way to address this ignorance, and as an eye opener to the possibilities of alternative transaction models.

Much of the book is devoted to two phase commit transactions:
- How they are implemented. Almost enough information to implement one yourself (though they strongly recommend against trying!)
- The Object Transaction Service Architecture on which the Java Transaction API is based: this section has considerable detail made surprisingly readable by numerous sequence diagrams.
- Heuristic Decisions: detailing the meanings of the different heuristic outcomes, such as heurist-rollback, heuristic-commit, heuristic-mixed, and heuristic-hazard.
- Optimizations: presumed-abort; one-phase; read-only; and last-resource-commit.
- The implications for database access and messaging (JMS), and information on the approaches taken by different vendors.
- The implications for EJB and other J2EE programming.
- Optimistic vs pessimistic locking schemes, commit options, isolation levels, and transaction context propagation.
- The J2EE Connector Architecture (JCA): its API's and what's involved in creating a resource adaptor.

Other topics are covered in considerable depth, including:
- The J2EE Activity Service as a framework for supporting alternative transaction models to the standard ACID model. For example, it lets you define a transaction in terms of a sequence of actions and any required compensation actions required upon failures.
- Transactions & Web Services: describing a number of different specificiations that have been defined and implemented for supporting distributed transactions over web services.

"Java Transaction Processing" provides a clear-cut, understandable journey through the nether-world of transaction processing. This information is critical to the development of robust applications and Mr's Little, Maron, and Pavlick have brigdged the gap between the "standard-speak" of XOPEN and the vagueness of the JTA specifications. Highly recommended.

I got a copy of this book during Javaone2004 a week back. I think this book provides an insight to transactions processing concepts and how this is applied in java and j2ee applications

Transactions have become hugely popularized by Java and they're starting to be used in most mainstream deployments. I've been using transaction systems for over a decade and still found this book useful on both the theory and practical sides. I especially liked the Web services section and futures. The entire book gives good practical insights to the use of and design of transaction systems.

Although it's definitely aimed at the Java/J2EE domain, I'd still recommend this as a good general transaction text book. It has a much lower entry level barrier than other books that talk about transactions and is easier to understand from the get go. That's not to say it's a basic text: anything but. It is to say that it keeps things very practically oriented and you're more likely to find information that is immediately useful in this book than elsewhere.

Hey, if Eric Newcomer can recommend it then you know it's got to be good!

BTW, I got this book at JavaOne too and attended the presentation by the authors on the last day. One of the best technical sessions I was at this year and for a session on the last day at the last hour, it was packed! Lots of interest and the authors certainly know what they're talking about.

"Java Transaction Processing" explains how to use different types of transactions in Java and J2EE programs. The authors state the audience is architects and senior developers. I agree and would recommend beginners read a different book first. There isn't any fluff in this book. They even separate the history into an appendix. The transaction coverage is quite thorough.

The introduction leaps right into transaction concepts. They range from the simple (ACID) to the complex (heuristics.) If you don't understand anything in this introduction, read it again. The rest of the book assumes an understanding of all these concepts.

The authors balance the complex concepts with a large number of visuals. The most common are flowcharts and UML class/interaction/state diagrams. In chapter one, there are 31 diagrams (in 60 pages) alone. The authors provide an interaction diagram for most code snippets to give you a visual feel.

For J2EE topics, the authors provide a brief overview of the topic and end with a detailed example. They also cover features of technologies in the JCP. And what book would be complete without a chapter on web services? The authors include the alternatives and an excellent comparison of each.

The authors include many real world issues, best practices and tradeoffs. There is even an appendix on what to consider when buying a transaction implementation and lessons learned. I spotted two minor editing typos, but they don't get in the way of the material. I recommend this book to anyone who uses transactions.

This book is the only text that I know of that addresses the enterprise-level issues of transactioning in the J2EE space. While the authors do not coddle the reader (and thus it would be tough going for newbies) for those with a background in enterprise systems, it is invaluable.
There is little in this book (with the exception of the Web Services aspects) which a developer cannot take and use immediately in enterprise-grade projects. The signal to noise ratio is simply extremely high.
As a whole the text flows well and the book could reasonably be read cover to cover giving the full story of transactions in the Java space. However to my mind its strength is as reference material: it is accessible, concise, and accurate.
In short, if you need J2EE transactions, you need this book.

This book offers a thorough snapshot of transaction concepts in Java. There's no fluff in this book, just solid explanations and examples. Excellent work. That being said, I am pleased also to see the topics in the appendices, including lessons learned and a history of transaction systems; they wrap things up neatly in context.

I got this book and JavaOne and met the authors. A good book from people who really know their stuff. I've gone through it twice already and keep finding nuggets of information that are proving useful in my use of transactions in JMS and JCA. I thought the theory sections were good and practically oriented as well. Over all I think this is the best book on transactions for J2EE and one of the best books on transactions theory/technology overall.

This book gives a high level view of how transactional middleware is built for J2EE App Servers and containers, which I think is just the right amount that any serious J2EE developer should know.

More often than not, we all have heard that the J2EE application developer need not know the internals of of Distributed Transaction Processing. It should all be hidden/transparent. But I am of the opinion that transparent middleware does not translate into ignorant developer.

As a lead developer and architect for years, time and again I have encountered the developers who are cluless about how J2EE application servers manage transactions for them. Consequently I have seen them struggle with what would be a trivial problem had they known how these app servers handle transactions.

This book cannot make you a J2EE developer, but it makes you a better J2EE developer. Having the bigger picture of how things really work behind the scenes is a good thing and will give everybody a broader perspective of things and make people develop transactional applications with that awareness. Now that is what I call as transparency...

This book will make you appreciate the EJBs as you develop them and also code better performing EJBS. The concepts from this book will help you debug transactional, JDBC and EJB problems faster (The other alternative is really shooting in the dark !!).

I have seen developers "google" the newsgroups when they get weird application server exceptions without really understanding the problem or putting effort towards it. That is not the way to solve the problems. This book will make you think what your app server might have done when you got that weird exception, do some poking around and then google the newsgroups, which I personally think is the right way of solving problems arising in transactional middleware.

The book is not a easy read like those other "Head First" books. But the material that this book deals with is complex and I think authors have done a decent job of simplifying.

Couple of suggestions though:

1) The authors could have elaborated the first chapter more. It becomes very tough read at times, which can turn even some serious developers away.

2) The material presentation starts getting better as the authors get into JTA/JTS. JDBC-XA, EJB and JCA coverage is outstanding. Why cant the rest of the material be the same ?

3) I would also have preferred if the authors got down to building a hypothetical J2EE application server in a dozen or so Java classes and show how the connection pooling might have been done in that imaginary app server, how XA connection from a database driver is acquired, wrapped and show interaction of XAResource and Transaction Manager. Right now there is explanation and some code snippets. The reader is left with the task of connecting the dots. It was not difficult for me. But I guess, the authors could have saved me from doing that.

4) Some explanation of middleware data caching, its impact on data visibility and O/R mapping challenges would have been much appreciated.

Inspite of these missing pieces, the book is an excellent read.
I have recommended it to every developer on my team. The last thing I want is a clueless developer, who hides his ignorance behind the so called transparent middleware marketing campaign!!!