Effective Enterprise Java

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.