Effective Enterprise Java

Effective Enterprise Java

Chapter 1. Introduction
   - The goals of J2EE
   - Middleware and J2EE
   - J2EE implementation The ten fallacies of enterprise computing

Chapter 2. Architecture
Section 1: Prefer components as the key element of development, deployment, and reuse
Section 2: Prefer loose coupling across component boundaries
Section 3: Differentiate layers from tiers
Section 4: Keep data and processors close together
Section 5: Remember that identity breeds contention
Section 6: Use hook points to inject optimizations, customizations, or new functionality
Section 7: Be robust in the face of failure
Section 8: Define your performance and scalability goals
Section 9: Restrict EJB to transactional processing
Section 10: Never optimize without profiling first
Section 11: Recognize the cost of vendor neutrality
Section 12: Build in monitoring support
Section 13: Build in administration support
Section 14: Make deployment as simple as possible

Chapter 3. Communication
Section 15: Understand all your communications options
Section 16: Consider your lookup carefully
Section 17: Recognize the cost of network access
Section 18: Prefer context-complete communication styles
Section 19: Prefer data-driven communication over behavior-driven communication
Section 20: Avoid waiting for remote service requests to respond
Section 21: Consider partitioning components to avoid excessive load on any one machine
Section 22: Consider using Web Services for open integration
Section 23: Pass data in bulk
Section 24: Consider rolling your own communication proxies

Chapter 4. Processing
Section 25: Keep it simple
Section 26: Prefer rules engines for complex state evaluation and execution
Section 27: Prefer transactional processing for implicitly nonatomic failure scenarios
Section 28: Differentiate user transactions from system transactions
Section 29: Minimize lock windows
Section 30: Never cede control outside your component while holding locks
Section 31: Understand EJB transactional affinity
Section 32: Prefer local transactions to distributed ones
Section 33: Consider using optimistic concurrency for better scalability
Section 34: Consider using pessimistic concurrency for explicit concurrency control
Section 35: Consider lower isolation levels for better transactional throughput
Section 36: Use savepoints to keep partial work in the face of rollback
Section 37: Replicate resources when possible to avoid lock regions
Section 38: Favor the immutable, for it needs no locks

Chapter 5. State Management
Section 39: Use HttpSession sparingly
Section 40: Use objects-first persistence to preserve your domain model
Section 41: Use relational-first persistence to expose the power of the relational model
Section 42: Use procedural-first persistence to create an encapsulation layer
Section 43: Recognize the object-hierarchical impedance mismatch
Section 44: Use in-process or local storage to avoid the network
Section 45: Never assume you own the data or the database
Section 46: Lazy-load infrequently used data
Section 47: Eager-load frequently used data
Section 48: Batch SQL work to avoid round-trips
Section 49: Know your JDBC provider
Section 50: Tune your SQL

Chapter 6. Presentation
Section 51: Consider rich-client UI technologies
Section 52: Keep HTML minimal
Section 53: Separate presentation from processing
Section 54: Keep style separate from content
Section 55: Pregenerate content to minimize processing
Section 56: Validate early, validate everything

Chapter 7. Security
Section 57: Security is a process, not a product
Section 58: Remember that security is not just prevention
Section 59: Establish a threat model
Section 60: Assume insecurity
Section 61: Always validate user input
Section 62: Turn on platform security
Section 63: Use role-based authorization
Section 64: Use SignedObject to provide integrity of Serialized objects
Section 65: Use SealedObject to provide confidentiality of Serializable objects
Section 66: Use GuardedObject to provide access control on objects

Chapter 8. System
Section 67: Aggressively release resources
Section 68: Tune the JVM
Section 69: Use independent JREs for side-by-side versioning
Section 70: Recognize ClassLoader boundaries
Section 71: Understand Java Object Serialization
Section 72: Don't fight the garbage collector
Section 73: Prefer container-managed resource management
Section 74: Use reference objects to augment garbage collection behavior
Section 75: Don't be afraid of JNI code on the server