Effective Enterprise Java
- By Ted Neward
- Published Aug 26, 2004 by Addison-Wesley Professional. Part of the Effective Software Development Series series.
- Copyright 2005
- Dimensions: 7x9-1/4
- Pages: 496
- Edition: 1st
- ISBN-10: 0-321-13000-6
- ISBN-13: 978-0-321-13000-6
Register your product to gain access to bonus material or receive a coupon.
Product Author Bios
Ted Neward is a software architect, consultant, author, and presenter who has consulted for such companies as Intuit and Pacific Bell, and UC Davis. He is the author of Server-Based Java Programming (Manning, 2000), and coauthor of C# in a Nutshell (O'Reilly, 2002) and SSCLI Essentials (O'Reilly, 2003). Ted was a member of the JSR 175 Expert Group. He now frequently speaks on the conference circuit and to user groups all over the world. He continues to develop and teach courses on Java and .NET.
"With this book, Ted Neward helps you make the leap from being a good Java enterprise developer to a great developer!"
—John Crupi, Sun Distinguished Engineer coauthor, Core J2EE Patterns
If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to:
- Use in-process or local storage to avoid the network, see item 44
- Set lower isolation levels for better transactional throughput, see item 35
- Use Web services for open integration, see item 22
- Consider your lookup carefully, see item 16
- Pre-generate content to minimize processing, see item 55
- Utilize role-based authorization, see item 63
- Be robust in the face of failure, see item 7
- Employ independent JREs for side-by-side versioning, see item 69
Ted Neward provides you with 75 easily digestible tips that will help you master J2EE development on a systemic and architectural level. His panoramic look at the good, the bad, and the ugly aspects of J2EE development will address your most pressing concerns. Learn how to design your enterprise systems so they adapt to future demands. Improve the efficiency of your code without compromising its correctness. Discover how to implement sophisticated functionality that is not directly supported by the language or platform. After reading Effective Enterprise Java, you will know how to design and implement better, more scalable enterprise-scope Java software systems.
44 of 55 people found the following review helpful
Well written but of little actual value,
This review is from: Effective Enterprise Java (Paperback)I feel kind of lonely here; everyone else seemed to love this book. Looking at the table of contents, I was very excited when I started reading the book. However, while reading it cover to cover I slowly became more and more dis-illusioned with it.
The book is divided up into a number of recommendations, called items, in a manor similar to Effective C++ and Practical Java. The problem is that most of the items appear to fall into one of a few general catagories:
1) Intro level generalities of good design for the web.
- pass data in bulk - multiple asynchronous calls out of process are more expensive than one big call
- make deployment as simple as possible - exactly what it says!
- use [...] sparingly - this is web application design 101
- always validate user input - my personal favorite; who today is not validating user input received from the web?
2) Using a pair of items to represent... Read more
9 of 10 people found the following review helpful
Great book and worthy successor in a wonderful series,
Amazon Verified Purchase(What's this?)
This review is from: Effective Enterprise Java (Paperback)This is an amazing book that does not disappoint in any way. It is full of wonderful well-written content. The book is organized as a series of 75 essays, each running from 1 to 10 pages. Each essay gives advice on what to do or not do in an enterprise Java application.
Since I'm not a fan of Enterprise JavaBeans, before I received the book I was worried that the "enterprise" in the title might mean the book was focused on concerns of EJB developers. That isn't the case at all and the vast majority of the book is absolutely applicable if you avoid EJB in favor of lighter-weight frameworks such as Sping.
Recently I was working with a team whose application was running out of memory and causing their application server to crash, sometimes in as little as an hour. With the help of this book's sections on the garbage collector they were able to identify and resolve the problems within a day, which was much shorter than everyone had expected.
This book is a... Read more
6 of 6 people found the following review helpful
Effective, Efficient and Convenient,
This review is from: Effective Enterprise Java (Paperback)If you have had a chance to see Ted speak, you have a sense of what to expect from this book: insight, amusement and a touch of controversy. Seasoned professionals will find themselves nodding at most of the items in this book. Folks from the trenches knowing this material is good news however; you wouldn't want to be faced with a deluge of maverick advice in something donning the title "Effective". What those types of engineers will find so useful is the convenient collection and organization of advice with which they can efficiently reassess their designs, communicate with peers, etc. Far from being a simple collection of didactic nuggets, however, there is exposition and justification behind the suggestions Ted makes. More junior engineers will find a series of rungs and footholds with which to scale the wall of enterprise Java. Beyond reading techniques that make sense and learning new approaches to solving common Enterprise problems, chances are your conventional wisdom will be... Read more
› See all 18 customer reviews...
Table of Contents
List of Abbreviations.
Chapter 1. Introduction.
The goals of J2EE.
Middleware and J2EE.
The ten fallacies of enterprise computing.
Chapter 2. Architecture.
Item 1: Prefer components as the key element of development, deployment, and reuse.
Item 2: Prefer loose coupling across component boundaries.
Item 3: Differentiate layers from tiers.
Item 4: Keep data and processors close together.
Item 5: Remember that identity breeds contention.
Item 6: Use hook points to inject optimizations, customizations, or new functionality.
Item 7: Be robust in the face of failure.
Item 8: Define your performance and scalability goals.
Item 9: Restrict EJB to transactional processing.
Item 10: Never optimize without profiling first.
Item 11: Recognize the cost of vendor neutrality.
Item 12: Build in monitoring support.
Item 13: Build in administration support.
Item 14: Make deployment as simple as possible.
Chapter 3. Communication.
Item 15: Understand all your communications options.
Item 16: Consider your lookup carefully.
Item 17: Recognize the cost of network access.
Item 18: Prefer context-complete communication styles.
Item 19: Prefer data-driven communication over behavior-driven communication.
Item 20: Avoid waiting for remote service requests to respond.
Item 21: Consider partitioning components to avoid excessive load on any one machine.
Item 22: Consider using Web Services for open integration.
Item 23: Pass data in bulk.
Item 24: Consider rolling your own communication proxies.
Chapter 4. Processing.
Item 25: Keep it simple.
Item 26: Prefer rules engines for complex state evaluation and execution.
Item 27: Prefer transactional processing for implicitly nonatomic failure scenarios.
Item 28: Differentiate user transactions from system transactions.
Item 29: Minimize lock windows.
Item 30: Never cede control outside your component while holding locks.
Item 31: Understand EJB transactional affinity.
Item 32: Prefer local transactions to distributed ones.
Item 33: Consider using optimistic concurrency for better scalability.
Item 34: Consider using pessimistic concurrency for explicit concurrency control.
Item 35: Consider lower isolation levels for better transactional throughput.
Item 36: Use savepoints to keep partial work in the face of rollback.
Item 37: Replicate resources when possible to avoid lock regions.
Item 38: Favor the immutable, for it needs no locks.
Chapter 5. State Management.
Item 39: Use HttpSession sparingly.
Item 40: Use objects-first persistence to preserve your domain model.
Item 41: Use relational-first persistence to expose the power of the relational model.
Item 42: Use procedural-first persistence to create an encapsulation layer.
Item 43: Recognize the object-hierarchical impedance mismatch.
Item 44: Use in-process or local storage to avoid the network.
Item 45: Never assume you own the data or the database.
Item 46: Lazy-load infrequently used data.
Item 47: Eager-load frequently used data.
Item 48: Batch SQL work to avoid round-trips.
Item 49: Know your JDBC provider.
Item 50: Tune your SQL.
Chapter 6. Presentation.
Item 51: Consider rich-client UI technologies.
The UrlClassLoader class.
JNLP and Java Web Start. Item 52: Keep HTML minimal.
Item 53: Separate presentation from processing.
Item 54: Keep style separate from content.
Item 55: Pregenerate content to minimize processing.
Item 56: Validate early, validate everything.
Chapter 7. Security.
Item 57: Security is a process, not a product.
Item 58: Remember that security is not just prevention.
Item 59: Establish a threat model.
Item 60: Assume insecurity.
Item 61: Always validate user input.
Item 62: Turn on platform security.
Item 63: Use role-based authorization.
Item 64: Use SignedObject to provide integrity of Serialized objects.
Item 65: Use SealedObject to provide confidentiality of Serializable objects.
Item 66: Use GuardedObject to provide access control on objects.
Chapter 8. System.
Item 67: Aggressively release resources.
Item 68: Tune the JVM.
Item 69: Use independent JREs for side-by-side versioning.
Item 70: Recognize ClassLoader boundaries.
Versioning. Item 71: Understand Java Object Serialization.
The serialVerUID field.
Customization (writeObject and readObject).
Replacement (writeReplace and readResolve).
Further Details 415Item 72: Don't fight the garbage collector.
Item 73: Prefer container-managed resource management.
Item 74: Use reference objects to augment garbage collection behavior.
PhantomReference objects. Item 75: Don't be afraid of JNI code on the server.
Downloadable Sample Chapter
Download the Sample
Chapter related to this title.
Designing and implementing large-scale enterprise systems is hard. Building
effective enterprise Java deployments is even harder. I see these difficulties
on a daily basis. When consulting on enterprise projects, I see the real-world
issues that developers are facing. I have also seen discussions, frustrations,
and solutions to some of the issues on a daily basis on
TheServerSide.com (Your Enterprise Java Community). TheServerSide.com really grew from the needs of developers faced with the new world of J2EE. It was the water cooler that allowed us to chat about solutions that worked for us, and it saw the growth of enterprise Java patterns.
Developing for the enterprise is a very different beast when compared to building smaller, standalone applications. We have to consider issues that we can safely ignore in the other world. As soon as we have to share data among multiple users, we start down the enterprise path. Then we start facing questions: What is the best solution for allowing concurrency to this data? How coherent and correct does it have to be? How can we scale up from 2 to 50 to 1,000 clients? These are all significant questions, and I don't feel that the average developer has enough help in answering them. Well, simply answering the questions may not be the correct focus. We need to be taught about the various issues involved and shown techniques that can help with the various problems.With Ted Neward's book, we are now armed with the knowledge that will allow us to come up with the right balance in the solution for each particular problem.
No book has attacked these problems quite like Effective Enterprise Java does. The most important part of this book is that it teaches you two things really well.
You will understand the general issues of enterprise computing.
These enterprise problems are far from new. Ted has been around the block, and he understands the core issues at work. A non-Java developer would get a lot out of this book for this very reason. What you learn here will be with you for as long as you develop enterprise solutions. The language and APIs may change, but you will understand the issues in building a good architecture, the options you have for communication, the choices for where to store state, the various security concerns, and so much more.
You will be able to attack the problems by using enterprise Java.
Although the book offers genuine insight into the general enterprise problems,
it also gives you tools to solve them with enterprise Java today. You will understand
more about where the various enterprise Java technologies fit together. When
would you use Web Services? What can messaging do for you? What is EJB good
for? This book provides answers to
It is great to have some answers to these common questions. The style of the book, in which you are given a set of "effective items," gets right to the point. Get stuck in, and enjoy the ride!
Download the Index
file related to this title.
This book includes free shipping!
Get access to thousands of books and training videos about technology, professional development and digital media from more than 40 leading publishers, including Addison-Wesley, Prentice Hall, Cisco Press, IBM Press, O'Reilly Media, Wrox, Apress, and many more. If you continue your subscription after your 30-day trial, you can receive 30% off a monthly subscription to the Safari Library for up to 12 months. That's a total savings of $199.