Effective Enterprise Java pptx

Effective Enterprise Java
Table of Contents
Copyright
Effective Software
Development Series Scott
Meyers, Consulting Editor
Titles in the Series
Foreword
Preface
About the items
Acknowledgments
Reporting bugs, making
suggestions, and getting book
updates
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
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
Item 71: Understand Java
Object Serialization
Item 72: Don't fight the garbage
collector
Item 73: Prefer container-
managed resource management
Item 74: Use reference objects
to augment garbage collection
behavior
Item 75: Don't be afraid of JNI
code on the server
Bibliography
Books
Web Sites
Index
index_SYMBOL
index_A
index_B
index_C
index_D
index_E
index_F
index_G
index_H

index_I
index_J
index_K
index_L
index_M
index_N
index_O
index_P
index_Q
index_R
index_S
index_T
index_U
index_V
index_W
index_X
index_Y
index_Z

• Table of Contents
• Index
Effective Enterprise Java
By Ted Neward

Publisher : Addison Wesley Professional
Pub Date : August 26, 2004
ISBN : 0-321-13000-6
Pages : 496
"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
Set lower isolation levels for
better transactional
throughput
Use Web services for open
integration
Consider your lookup
carefully
Pre-generate content to
minimize processing
Utilize role-based
authorization
Be robust in the face of
failure
Employ independent JREs

for side-by-side versioning
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.

• Table of Contents
• Index
Effective Enterprise Java
By Ted Neward

Publisher : Addison Wesley Professional
Pub Date : August 26, 2004
ISBN : 0-321-13000-6
Pages : 496