mostraligabue
» » Java Transaction Processing: Design and Implementation

ePub Java Transaction Processing: Design and Implementation download

by Mark Little,Jon Maron,Greg Pavlik

ePub Java Transaction Processing: Design and Implementation download
Author:
Mark Little,Jon Maron,Greg Pavlik
ISBN13:
978-0130352903
ISBN:
013035290X
Language:
Publisher:
Prentice Hall; 1 edition (July 5, 2004)
Category:
Subcategory:
Programming Languages
ePub file:
1897 kb
Fb2 file:
1476 kb
Other formats:
txt doc mbr lit
Rating:
4.2
Votes:
176

oceedings{Little2004JavaTP, title {Java Transaction Processing: Design and Implementation}, author {Mark Cameron Little and J Maron and Greg Pavlik}, year {2004} }.

oceedings{Little2004JavaTP, title {Java Transaction Processing: Design and Implementation}, author {Mark Cameron Little and J Maron and Greg Pavlik}, year {2004} }. Mark Cameron Little, J Maron, Greg Pavlik. Foreword by Steven G. Harris.

a transaction implementation and lessons learned.

The authors state the audience is architects and senior developers. I agree and would recommend beginners read a different book first.

Transaction processing is at the heart of modern enterprise systems. This book explains in depth transaction processing technology and how it can be leveraged in the Java platform

Transaction processing is at the heart of modern enterprise systems. This book explains in depth transaction processing technology and how it can be leveraged in the Java platform. It provides a comprehensive explanation of the underlying concepts in transactions that are needed to understand and exploit the technology correctly. All technical information delivered in the book corresponds directly to the latest revision of Java.

Mark Little, Jon Maron, Greg Pavlik. The natural match between Java classes and abstract data type (ADT) implementations makes the code more broadly useful and relevant for the modern object-oriented programming environment. Published by Prentice Hall. ISBN 10: 013035290X ISBN 13: 9780130352903.

By Mark Little, Jon Maron, Greg Pavlik. Published Jun 25, 2004 by Prentice Hall. Sorry, this book is no longer in print. Working code downloads for examples in the book.

Greg Pavlik Java Transaction Processing: Design and Implementation.

The purpose of a session is to allow multiple individual Web Services to enter a relationship by sharing certain common attributes as an externally modeled entity. In the context of Web services, explicit building blocks for session-oriented protocols and services have been proposed in two specifications, WS-Addressing and WS- Context. Java Transaction Processing: Design and Implementation.

Java Transaction Processing book. I already read this book 3 years ago and I consider it really nice

Java Transaction Processing book. Addresses transactions related issues faced by java developers. I already read this book 3 years ago and I consider it really nice. These days it could be perceived as a little outdated (which is partly true) but info contained is really valuable and good to understand if you work with transactions.

Java Transaction Processing: Design and Implementation. by Mark Little, Jon Maron, Greg Pavlik. ISBN 9780130352903 (978-0-13-035290-3) Softcover, Prentice Hall, 2004. Find signed collectible books: 'Java Transaction Processing: Design and Implementation'. Coauthors & Alternates.

Little, Mark, Jon Maron, and Greg Pavlik. Upper Saddle River, . Prentice Hall PTR, 2004. 4. Alur et a. Core J2EE Patterns.

Addresses transactions related issues faced by java developers.
  • This book will get you started working with JTP... however, it's not going to get you through a professional application.

    If you're new to a lot of transaction processing or just transaction processing in Java, this is something you've got to breeze through at least once. Once you start getting deeply into the nitty-gritty of your application, it's complexities, etc. you're going to find that the book starts to fall short.

    It's not to say that the book lacks examples, it just won't contain what **YOUR** application is going to need. The book does not nearly do justice nor spend nearly enough time talking about the complexities you are going to run across when working with enterprise-grade transactional processing in Java.

    Beginners: go for it
    Intermediates: there's better resources, but it may be worth it for you
    Advanced: ignore it

  • I liked it - helps to understand the core of transactions, and I find this helpful and important. Very!

  • The best and most thorough treatment of transaction management I have seen. I've bought copies for myself and my engineers.

  • I could not get through it... I was reading the book for months and I really really tried! But about half way through I decided I'm done with this author. Never again!

    Pros:
    - covers a LOT of transaction-related topics

    Cons:
    - author's ego issues
    - watery content not typical for a scientific book
    - mostly discusses outdated technologies

  • 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).

  • "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.