Any software developer knows Murphy's Law all too well: if anything can go wrong, it will. When it comes to today's enterprise-level, multitiered applications written in Java, there's a lot more that can go wrong in regard to performance. Written by two experts in enterprise Java (both veterans of IBM's SanFrancisco Java class frameworks), Enterprise Java Performance examines performance from beyond a single workstation. Filled with useful insights for designing Java applications on multiple servers, this book offers a timely and very useful guide suitable for any intermediate to advanced Java programmer.
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
Product Description
*Java performance for real business success
*Practical, large-scale programming
*Illustrates common Java pitfalls
*Includes coverage of CORBA and JINI
Technical Editors: Peter van der Linden, best-selling author of Just Java and Stephen R. Pietrowicz, National Center for Supercomputing Applications, University of Illinois, Urbana-Champaign
"This is the sort of book that I look for as an advanced programmer. There just aren't enough of these types of books out there." -Stephen R. Pietrowicz, National Center for Supercomputing Applications, University of Illinois, Urbana-Champaign
When your enterprise solutions are written in Java, system performance equals organizational productivity.
As Java is exploding into business environments, programmers require a new approach to encompass enterprise-wide thinking. With today's distributed computing environments magnifying even minor performance pitfalls, large-scale tuning can make the difference between success and just getting by. Steven L. Halter and Steven J. Munroe, who have been working with Java from its very beginning, bring their experiences from the IBM SanFrancisco Project to this unique book.
Their expertise provides a brilliant guide to the complexity of running business code on a massive system with a large, heterogeneous user population. By exploring performance issues from the ground up, they show you how to design a framework to withstand the changing demands of a growing business. Right from the start, you'll get general concepts and specific tips on improving enterprise Java performance, illustrated with actual Java code that you can put to work for you. Just some of the technologies included are: JVM/JIT, SanFrancisco, Enterprise JavaBeans, CORBA, and Jini.
Real Java code examples illustrate:
*Performance theory
*Performance obstacles
*Local/remote issues
*Granularity
*Benchmarking
*System tuning
*Effects of scale
*SanFrancisco
*Enterprise JavaBeans
*CORBA
See all Editorial Reviews
