Enterprise Java Performance

While there are a number of titles on Java performance, this one stands out because of its enterprise-level perspective. Of course, you'll find some hints for writing better Java code at the micro level (which the authors call "low-hanging fruit") with instructions for optimizing string and loop performance. But this is just the beginning.

The heart of the book is its thorough discussion of performance and design issues for using remote objects, which allow distributed applications to do their work on multiple servers. The authors delve first into the issues of object design, including the correct granularity of objects. (Having a lot of small objects can cause too many round trips on the servers, but big ones can be clumsy for programmers.) Examples drawn from the authors' experience designing IBM's SanFrancisco application framework (a robust set of classes designed to automate entire businesses, like inventory and manufacturing) lend more credence to the discussion. The performance issues surrounding the crossvendor Enterprise JavaBean (EJB) standard are also examined.

Besides describing performance issues in enterprise applications, the book also gives you a number of tools to measure performance in your own code, including custom classes for performance monitoring, as well as the authors' enterprise-level benchmark--Business Object Benchmark (BOB). (They also survey existing Java benchmarks.) Later chapters include a succinct taxonomy of application styles for Java, like Web-based clients or applications that wrap legacy systems; performance hints are offered for each. There is also an excellent guide to running CORBA on Java and plenty of hints for optimizing servers, including memory configuration. A final chapter glances at performance issues with clustered servers.

In all, Enterprise Java Performance offers a valuable perspective on issues that all Java developers will likely face when creating distributed applications. This book will help you avoid many of the gotchas in deploying Java code on the enterprise, and it gives you the tools and techniques you'll need to write faster applications, even for very large systems. --Richard Dragan

Topics covered:

• Performance and optimization primer
• The performance life cycle
• Types of performance problems ("low-hanging fruit," application model problems, "physics")
• The Sun Java profiler and third-party tools
• A custom performance monitor class
• Using the Windows NT Performance Monitor
• Hints for writing faster Java code
• Using the String and StringBuffer classes correctly
• Loop optimizations
• Hints for synchronization and garbage collection
• Local vs. remote application partitioning
• Remote Method Invocation (RMI)
• Object granularity and object affinity
• Enterprise JavaBeans
• The IBM SanFrancisco application frameworks
• Performance issues for remote objects
• Performance bottlenecks (synchronization, avoiding deadlocks, distributed garbage collection)
• Survey of third-party benchmarks
• Custom distributed business object benchmark (BOB)
• Performance issues with the SanFrancisco architecture for objects
• Performance issues with Enterprise JavaBeans (EJBs)
• Types of EJBs
• Tutorial for Java and CORBA
• Performance issues for Jini
• Overview of today's Java application architectures (Web Out, Web In, Application Glue, Database Up, Application Wrapper, and Objects Down) and performance issues with each
• Hints for tuning EJB and SanFrancisco application servers (including memory, system, and disk configuration)
• Performance issues for clustered and "large-scale" systems