Effective Enterprise Java (Paperback)
暫譯: 有效的企業 Java

Table of Contents:

Foreword.

Preface.

List of Abbreviations.

Chapter 1. Introduction.

The goals of J2EE.
Middleware and J2EE.
J2EE implementation.
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.
Dynamic HTML.
Macromedia Flash.
Applets.
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.
Isolation.
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.
SoftReference objects.
WeakReference objects.
PhantomReference objects. Item 75: Don't be afraid of JNI code on the server.

Bibliography.

Index.