Editorial Review

Centering on Sun's Enterprise JavaBeans (EJBs) 1.1 specification, Mastering Enterprise JavaBeans surveys the range of technologies and APIs needed to use EJBs successfully. Mixing a high-level perspective on EJBs with plenty of practical programming advice, this title makes a good choice for the IS manager or developer planning to use EJBs in future projects.

This book succeeds in two notable ways. First, it presents a fine high-level overview describing EJBs and how they fit into today's multitiered, server-side enterprise architectures. The author makes connections between EJBs and other component architectures (such as Microsoft DNA and CORBA). Illustrated with numerous diagrams, these chapters will be useful to anyone seeking to understand the basics of Sun's powerful component model.

This title also serves as a programming primer for serious EJB development. In later sections, the author introduces practical advice for creating both session and entity beans, with plenty of nuts-and-bolts advice, including how to work with actual EJB products. (This book also shows you what to look for when purchasing an EJB application server to deploy your bean components.)

Later chapters delve into transaction management and show how to use Java with CORBA and IIOP. The text culminates in an impressive case study using EJBs and Java servlets to power an e-commerce Web site (complete with an online catalog and a shopping cart). This example is a standout, and it's all you will likely need to get started with EJBs in custom projects. Final appendices cover several APIs and standards in more detail, including RMI, JNDI, and XML.

In all, this title succeeds at bringing the EJB standard home to the practicalreader. It demystifies EJBs and gives both managers and developers what they need to start solving business problems using this powerful new component model. --Richard Dragan

Editorial Review

As many Java developers and IS managers already know, Sun's powerful Enterprise JavaBean (EJB) technology offers an attractive option for developing server-side components. A suitable read for both managers and Java programmers, Enterprise JavaBeans provides a surprisingly clear and engaging introduction to designing and programming with EJBs.

The tour of the EJB component model presented here centers on several beans created and tested for a travel reservation system in a fictitious cruise ship company. The samples are just right in scale, large enough to test out key concepts in design and deployment, but small enough to be comprehensible, even to those who are not Java experts. The author pays close attention to the real-world issues of deployment with EJBs (as well as the differences among the vendor application servers that run them).

While there are enough details in Java syntax for designing both entity and session beans for the developer, sections on design here will please those who manage projects without delving much into code. Later, the author shows various ways to design entity and session beans. (For instance, entity beans can allow their bean containers to handle the details of connecting to a database, or they can do it themselves. This book demonstrates both approaches.) When it comes to session beans (which "wire" together entity beans to do real work), the author's introduction to managing state and transactions is also a standout. Tips for performance and reusability close out the book.

In all, Enterprise JavaBeans provides an engaging tour of one of the most promising component technologies. It's technically astute, but thoroughly approachable too, and can serve the needs of any manager or Java developer considering EJBs for future projects. --Richard Dragan

Editorial Review

As an authoritative resource for using Enterprise JavaBeans (EJB) effectively to build and integrate even the largest systems, Applying Enterprise JavaBeans provides what IT managers and developers need to adopt this powerful component standard successfully in new Java projects.

Most books about EJB are strong on theory, but tend to leave out many details of how to implement components in real projects. That's where this text steps in, providing real code (and real design decisions) for implementing different kinds of JavaBeans, like session and entity Beans. Better yet, it contains a case study of a human resources benefits enrollment system that integrates data from different vendors and uses EJB to hold the data together. (Using fictitious vendor names like "Star Enterprise," "Wombat," and "Providence," the book shows how EJB can lead to successful enterprise integration.)

Subsequent chapters look at different aspects of this system, from session Beans (including stateful Beans used to manage sessions) to detailed examples of entity Beans in action. There are plenty of state transition diagrams (that show the inner workings of EJB in a variety of scenarios) and source code (useful for Java developers). Without actually anchoring this material in an actual application server (which would make the book even more practical), it does a good job of fleshing out the EJB standard for real projects, exposing what really goes on between application server "containers" and the Beans they manage, including activation and passivation states.

Final sections examine transactions and security options for components, including the use of declarative statements in XML descriptors to simplify these aspects of EJB design. Finally, there's a reference for built-in EJB classes and APIs.

Overall, this book can help put EJB within reach for programmers and managers. Its mix of practical expert advice and sample source code will help demystify EJB components and how to use them to create successful, state-of-the-art enterprise systems. --Richard Dragan

Topics covered:

• Two-tiered vs. J2EE application architectures
• Advantages of EJB
• Business rules
• The structure of EJB
• Roles for EJB users (including developers, system administrators, and deployers)
• Session Beans (stateful and stateless session Beans)
• Session Beans and containers (including passivation and activation)
• Entity Bean basics (the Bean life cycle, storing and loading Beans)
• Case study for a health benefits enrollment system (including application integration through EJB)
• Transactions in EJB (including declarative and programmatic transaction management)
• Managing security with Beans (including security roles and declarative security mechanisms)
• EJB API reference

Editorial Review

Ideal for IT managers and developers working on e-commerce projects, Professional Java E-Commerce shows off how to design and program working e-stores and other enterprise Web applications powered by Java. This book is a guide to the nuts and bolts of Java used for e-commerce sites, and it also surveys the management and design issues that any organization will face when doing business online.

The first sections give an IT manager's perspective on integrating e-commerce initiatives into your organization, whether they're B2B, B2C, or m-commerce initiatives. The coverage achieves considerable depth. As well as terms you've already heard about, the team authors also look at B2B2C and C2B2C scenarios. They cover project planning for successful e-commerce software development and today's n-tiered architectures for scalability, and provide a quite thorough discussion of the security issues surrounding e-commerce.

The book then delves into actual sample source code for a variety of e-commerce applications, beginning with a traditional online store (for selling computers) with a product catalog and a shopping basket. Written with simple JSP, this site gets enhanced later using state-of-the-art Enterprise JavaBeans (EJB) for better scalability and performance. Hands-on advice for using tools like BEA WebLogic Application Server (something of an industry standard) will help you apply your knowledge to real projects. Further examples look at real-world instances of corporate e-commerce in action, including working code for a portal Web site, a supply chain application (using XML), and a workflow Web application. The book closes with newer technologies like m-commerce (in which business is conducted through wireless devices) and smart cards.

The working source code and real-world perspective help distinguish this text in its presentation of some emerging Java enterprise-level technologies. For many working Java developers or managers, Professional Java E-Commerce can help shift the odds in your favor for that next big e-commerce project with its mix of canny advice and very practical sample source code that shows the right ways to use Java to write several high-end enterprise e-commerce solutions. --Richard Dragan

Topics covered:

• E-commerce business strategy and planning
• Types and business impact of e-commerce (including B2C, B2B, B2B2C, C2C, C2B2C, and m-commerce)
• Business requirements for e-commerce applications (including technological and business considerations)
• E-commerce project planning (software project management and process)
• Guide to architecting e-commerce applications (technical requirements and architecture)
• Overview of the Java 2 Enterprise Edition (J2EE) and its support for e-commerce
• Design approaches and components for e-commerce
• Introduction to XML and XSLT
• Security issues for online business (including Java security, authentication, and authorization)
• Sample B2C online computer store
• Usability issues (searching, feedback, and membership and internationalization)
• Data validation techniques for user input (client-side and server-side options)
• Adding Enterprise JavaBeans to the e-commerce site
• Using BEA WebLogic
• Case study for a custom portal
• Case study for a B2B solution using XML/XSLT to share data between systems in the supply chain
• Mass integration with the Java Message Service (JMS)
• Introduction to application service providers (ASPs)
• Case studies for a workflow application and a corporate purchasing Web site
• Introduction to m-commerce
• WAP and WML
• Smart cards
• XML and XSLT primer

Reviews (22)

Excellent Book for OO Analysis
This book takes you through the development of an application from proposal to implementation.In alternating chapters the authors explain the use of UML for a particular step in the development lifecycle and then demonstrate what they just explained to develop a sample timecard system. The best part of the book, which is not significantly different than the first edition, is the first half in which the authors discuss requirements gathering and object oriented analysis. The book is worth the price for this first part alone.

The second half of the book has been expanded to discuss new J2EE technologies.The chapters on evaluating technologies are good as far as discussing how to evaluate technologies but the actual analysis is weak as they ignore candidate technologies such as Struts in favor of their own homegrown HTML production framework.They also fail to explain why EJBs are a better choice for their sample application than simply using Servlets/JSPs/JDBC.The final section on design gets bogged down with too many pages of code listings and not enough explanations for the code.

Arrington and Rayhan have done a very good job explaining UML although some familiarity with UML notation (or at least a handy manual) would be helpful.If you already own the first edition then you can ignore this edition.If you don't own it then you will definitely want to read this book.This is a must have book for any Java architect/developer doing OOAD.

Great first UML book for a Java developer
This is a very good book for someone who has a worked with java at the developer level and is thinking about making the jump to the architect level. Arrington is an experienced teacher and his teaching proficiency shows all along the book. His style is very clear and sometimes repetitive, but that makes sure you get the idea through.
Being a "hands on type of guy" I like the fact that the book explains the theory in the context of developing and example application.
The UML & Object Oriented Analysis section of the book is truly outstanding, while the implementation part leaves a bit to be desired. It is also outdated as it still uses HTML production classes inside Servlets and not JSP. The second edition should fix this.
Overall the best book on UML for a Java developer I have read so far.

Editorial Review

Sun's Java 2 Platform, Enterprise Edition (J2EE), provides all of theAPIs that are needed to build world-class enterprise applications. Written byover a dozen experts, this new edition of Professional Java ServerProgramming provides a truly massive and authoritative guide to the lateststandards and APIs that are available in J2EE. This title is a must-have for anyone who'sserious about enterprise development in Java.

Weighing in at over 1,400 pages, Professional Java Server Programmingprovides a wide-reaching resource of all of the APIs that are required for J2EEdevelopment that centers on servlets and JSPs for creating UIs and EnterpriseJavaBeans (EJBs), XML, and JDBC for getting to data on the server. Besides beinga practical guide to how to combine these standards (with plenty of usefulexamples of these APIs in action), it also delivers a healthy dose of the designphilosophy that's recommended by Sun for building scalable and robust enterpriseWeb applications.

Throughout, this text does a good job of merging theory with practice. Almostevery chapter has a useful working example that shows how APIs work, with samplecode for such Web applications as an e-commerce shopping cart, tech supportpages, and a front end for a manufacturing database. The core of this volume isits treatment of servlets and JSPs for building Web-based front ends in Java.This new edition also highlights EJBs in excellent detail, with a thorough tourof designing, programming, and deploying EJBs effectively. (There's also notablecoverage of the emerging EJB 2.0 standard, which adds several importantfeatures, like a query language for more powerful database access.)

The practical focus here is reflected also in chapters that are devoted todebugging, testing, and deploying J2EE applications--critical issues for anyaspiring enterprise developer. While no single book can make you an expert, thisone can get you started with a superb tour of the APIs and technologies thatyou'll need to tackle large-scale development in Java. --RichardDragan

Topics covered:

• Introduction to enterprise computing with theJava 2 Enterprise Edition (J2EE) platform (technologies, APIs, architectures;development roles)
• Introduction to RMI (including security, parameterpassing, and distributed garbage collection)
• JDBC tutorial (includingprepared statements, updateable result sets, batch updates, connection pooling,and distributed transactions)
• JNDI and LDAP
• XML basics (including XMLparsers, XSLT, and CSS)
• Servlet tutorial (servlet APIs, the servlet lifecycle, requests and responses, and maintaining session information)
• Shoppingcart servlet example
• JavaServer Pages (JSPs) tutorial (directives, scriptingelements, custom tags, and tag libraries)
• JSP coding standards
• Using JSPand XML together
• JavaMail
• Enterprise JavaBeans (EJBs) tutorial
• EJBcontainers
• Design guidelines for EJBs
• Session and entity beans
• Container vs. bean-managed persistence
• New EJB 2.0 features (includingthe EJB 2 0 Query Language)
• Sun's Model-View-Controller architecture fordesigning enterprise-level applications
• Performance and scalability hints
• Debugging and testing techniques
• The Java Message Service (JMS) andmessage queuing
• Integrating J2EE with CORBA
• Deploying J2EEapplications

Editorial Review

After you've learned some basic Java, what comes next? Brett Spell's Professional Java Programming can bring your skills to a new level with this tutorial on an appealing range of advanced topics that will extend the reach of your applications. This topic-based text offers something for every intermediate-to-advanced Java developer.

By focusing on individual advanced topics, you can use this book to solve real-world problems while generally improving your understanding of Java. A valuable early section examines what methods you should implement for your Java classes. (By implementing these method, your classes can be as robust and flexible as those that are built into Java.) A section on multithreading shows you the right way to create threads that run reliably in the background.

If you use a Java IDE for designing user interfaces, you probably won't find much use for sections on event handling and layouts, which are covered here in considerable depth. (The reason is that today's Java tools automate this aspect of UI design.) However, two chapters on advanced Swing controls--the JTable and JTree components--are simply indispensable. (You learn how to perform custom rendering, as well as edit the contents of these controls. The controls are powerful, but in general it's hard to find any information on customizing them.)

If you want your Java application to mimic the functionality of traditional applications, you'll benefit from the chapters on adding cut and paste and drag-and-drop functionality, as well as printing. A group of chapters will extend the range of Java when working with data, whether through JDBC, standard streams, XML or sockets, CORBA, or Remote Method Invocation (RMI). (The author uses a chat server to illustrate basic distributed computing.) The book closes with some valuable tips on Java security, help systems, performance tuning, and internationalization.

All in all, Professional Java offers a mixed bag of tips and tricks for extending the range of your Java applications, whether on a single desktop or across the enterprise. Even if you don't read it cover to cover, this text offers plenty of invaluable tips and solutions that will benefit any working Java developer. --Richard Dragan

Topics covered:

• Java Virtual Machine (JVM) details
• Best practices for designing Java classes (recommended methods)
• Using Java threads effectively (including synchronization techniques and thread APIs)
• Java event handling (comprehensive guide to Java events)
• Layout managers (including custom layout managers)
• Advanced techniques for using Swing JTable and JTree (including customer rendering and editing)
• Advanced JFC desktop functionality (adding cut and paste and drag-and-drop support)
• Printing with Java 2
• Creating custom user interface components
• JDBC 2.0 database programming (including new 2.0 features, transactions, and connection pooling)
• Persisting data to I/O streams, files, and databases (including basic object relational mappings)
• XML basics in Java
• Guide to using JavaSoft's Java API for XML Parsing (JAXP)
• Transforming XML documents
• Basics of socket programming, CORBA, and Remote Method Invocation (RMI)
• The Java security model (understanding permissions and digital signatures)
• Profiling for improved Java performance, the HotSpot compiler, garbage collection, and creating Javadoc help and context-sensitive help with JavaHelp
• Internationalizaton support in Java
• Native code and the Java Native Interface (JNI)
• Reference for coding standards

Editorial Review

Although Learning XML covers XML rather broadly, it nevertheless presents the key elements of the technology with enough detail to familiarize the reader with this crucial markup language. This guide is brief enough to tackle in a weekend.

Author Erik T. Ray begins with an excellent summary of XML's history as an outgrowth of SGML and HTML. He outlines very clearly the elements of markup, demystifying concepts such as attributes, entities, and namespaces with numerous clear examples. To illustrate a real-world XML application, he gives the reader a look at a document written in DocBook--a publicly available XML document type for publishing technical writings--and explains the sections of the document step by step. A more simplified version of DocBook is used later in the book to illustrate transformation--a powerful benefit of XML.

The all-important Document Type Definition (DTD) is covered in depth, but the still-unofficial alternative, XML Schema, is only briefly addressed. The author makes liberal use of graphics, tables, and code to demonstrate concepts along the way, keeping the reader engaged and on track. Ray also goes deep into some discussion of programming XML utilities with Perl.

Learning XML is a very readable introduction to XML for readers with existing knowledge of markup and Web technologies. It meets its goals very well--to deliver a broad perspective of XML and its potential. --Stephen W. Plain

Topics covered:

• XML overview
• XPointer
• XLink
• XHTML
• Presentation with Cascading Style Sheets (CSS)
• Document Type Definitions (DTDs)
• XML Schemas
• Transformation with XSLT
• Internationalization
• Simple API for XML (SAX)

Editorial Review

Inside XML is an intelligent and easy-to-follow guide to today's proliferating XML standards. Aside from being a road map to the latest and greatest in what's on the horizon with XML, this book gives you what you need to know to be productive with existing XML tools right now.

The tour begins with an introduction to the XML used in real-world applications (like the Chemical Markup Language, CML, and the Vector Markup Language, VML [for graphics]). While many books give you the basics, this one excels at explaining the conventions of designing robust XML document types in detail. With dozens of short examples, you'll learn XML conventions thoroughly, including some of the best practices for creating readable, maintainable content. The author highlights certain lines of XML code, so it's easier to see what's important.

After 200 pages of in-depth material on how to design XML documents, the book turns to using XML in actual browsers (both in Netscape and Internet Explorer). This practical focus means that you get to explore available Microsoft tools and how they sometimes differ from official W3C standards.

Subsequent sections turn to related XML standards, like XLinks and XPointers. Each section lists Web links to the latest online documents, but the emphasis isn't on theory so much as on what you can do right now. You'll learn how to use Java with XML, including navigating the XML Document Object Model (DOM) using IBM's XML for Java (XML4J) package. The tutorial explaining the Simple API for XML (SAX) does a great job of explaining the advantages of this popular tool.

Final chapters delve into displaying XML with several existing standards, including XHTML (for Web browser content), VML (for drawing shapes), and the Resource Description Framework (RDF) for allowing XML-based content searching. Final sections look at combining XML with Perl and Java (through servlets and JSPs) and give a glimpse at wireless content created with the Wireless Markup Language (WML).

Suitable for any developer or IT manager who needs to understand and use XML, Inside XML provides an authoritative yet approachable source of information on a fast-changing set of standards that are almost sure to revolutionize computing over the next few years. --Richard Dragan

Topics covered:

• Comprehensive introduction to XML basics and tools
• Designing XML documents (including "well-formed" XML, tags and elements, and attributes and namespaces)
• Document Type Definitions (DTDs)
• Entities and attributes (including design documents)
• XML Schemas (using Internet Explorer)
• Introduction to JavaScript
• Using JavaScript with the XML Document Object Model (DOM)
• Cascading style sheets (CSS)
• Overview of basic Java programming
• Parsing XML with IBM's XML for Java (XML4J)
• Java and the Simple API for XML (SAX)
• XSL transformations (XSL style sheets and XSL formatting objects)
• XLinks and XPointers
• Introduction to XHTML
• The Resource Description Framework (RDF)
• The Microsoft Channel Definition Format (CDF)
• The Vector Markup Language (VML)
• Using XML with Java
• Perl and ASP on the server
• Quick introduciton to the Wireless Markup Language (WML)
• Reference to the XML 1.0 Specification

Editorial Review

Aimed at the Java developer who wants to learn XSLT quickly,Java and XSLT provides an in-depth guide to using XML totransform data in a variety of Web applications. With a no-nonsensepresentation style and plenty of expert tips, this tutorial will letexperienced developers master XSLT (and related standards) to createmore flexible Web applications.

This text distinguishes itself with afast-moving tutorial that covers XSLT from the ground up withoutgetting bogged down in fast-changing XML standards, as is the casesometimes with other similar books. Combined with XML parsers(available in Sun's JAXP 1.1 APIs), Java is ready to go to solvereal-world problems with XSLT. The author shows you how to apply XSLTto real problems, as well as integrating XSLT into your Webarchitecture. Early sections of the book show how XSLT can be used toseparate presentation logic from business logic.

The first sectionsprovide the basics of XSLT syntax, then the book moves on to moreadvanced searching and looping techniques. (Without traditional "state"or variables, XSLT requires a different way of thinking. This book doesa good job of showing what's different in XSLT and techniques that cando more within real applications.)

This text's developer focus showsup early on, with a sample of XSLT used with Apache's Ant buildutility. Later samples are more applicable to general Web development.A sample online discussion board built with servlets and XSLT stylesheets shows off the fundamentals at work. With good coverage of Sun'sJAXP 1.1 APIs for working with XML in Java, this book anchors itssamples in real Java tools. A final section on wireless interfacesintroduces the advantages of XSLT for transforming online content intoWML for mobile devices.

Now that XSLT is a mainstream technology,more and more Java programmers will want to use it in real projects.Beyond syntax, this title shows you how to use XSLT to transformserver-side data into client-side interfaces more flexibly. Thepractical focus of Java and XSLT is all you need to combinethese two powerful technologies to create more maintainable Webapplications that can reach both desktop and mobile browsers.--Richard Dragan

Editorial Review

Written for the working programmer who wants to get more speed out ofJava, Java Performance and Scalability, Volume 1 bundles several dozentips for faster and smaller Java code. Backed up by benchmarks of what works andwhat doesn't, this book provides essential wisdom for eliminating some commonbottlenecks to Java performance.

The 48 optimizations for various aspects of the Java API make up the heart ofthis text. Early sections look at a particularly tricky subject--stringprocessing--giving you several techniques for increasing speed and reducingobject creation. The in-depth examination of the costs and benefits of stringconcatenation and the immutability of Java String objects will help youuncover possible hot spots that cause lagging performance with strings.

Subsequent sections look at more general strategies for faster programs, likepurging obsolete code, and the well-known 80-20 rule (optimizing the 20 percentof your code that consumes 80 percent of processing time, allowing you to createfaster software; this book shows you how). Short tips on such APIs as Javacollections and the Java Native Interface (JNI) come next.

The second half of the book zeros in on better server-side performance with tipson caching and file I/O. The guide to multithreading and synchronization is astandout here. You'll get several smart tips for speeding up servlets, such asprecomputing your standard strings for headers and other boilerplate HTML. Thebook closes with a valuable custom class for JDBC database connection poolingand a custom HTTP server. Both samples make use of the techniques presentedearlier in the text. Even if you don't adopt every suggestion, the ideas herecan get you thinking about performance in new ways. (One of the main points ofthis book is that you can write faster custom code, instead of always relying onbuilt-in Java classes and APIs.)

Clearly, Java performance is not something that happens by accident; it must beengineered into your code. This compilation of useful techniques and tipsdeserves a close look by anyone who wants to squeeze more performance out ofJava. --Richard Dragan

Topics covered:

• Introduction to Java performance
• Moreefficient Java string handling (optimizing String, StringBuffer,and StringTokenizer objects)
• Reducing Java overhead
• Fasterinitialization
• The 80-20 rule for optimization
• Getting rid of obsoletecode
• Speeding up the JDK 1.1 Vector and Hashtable collectionclasses
• Caching techniques
• Optimizing file I/O and buffering
• Objectrecycling and object pools
• Techniques for multithreading and synchronization
• Amdahl's law and scalability basics
• Pros and cons of using the JavaNative Interface (JNI)
• Hints for optimizing Remote Invocation Method (RIM)calls
• Performance hints for servlets and JavaServer Pages (JSPs)
• Customsample code for JDBC database connection pooling and a Java HTTP server

Reviews (38)

Disagree with an earlier review
I'll state up front I'm a friend of the author, so this is partisan. I completely disagree on a point of fact with the earlier "culturally interresting but professionnally almost useless" review by an anonymous reader. He states that he resumes the book with 'could resume this book by..."don't code in Java, do it directly in C"'. But that is the exact opposite of what is in the book. At no point does Jack ever suggest that
you would be better off doing it in C. Quite the opposite, Jack even shows that you can get your application in Java to be faster than the equivalent C program. How you could have read the book and come away saying the exact opposite of what it says is beyond me!

a good book, but do you really need it?
Java Performance Tuning would be a good book to have if you have a seriously performance intensive application or for someone who just really dug performance issues. But it wouldn't be of interest to most people. Most programmers should be able to do all the performance tuning they need to do with a program like Optomizeit.

culturally interresting but professionnally almost useless
I could resume this book by..."don't code in Java, do it directly in C"..it remembers me when I was a young C programmer I read a book on performance in C the shortcut was "Don't code in C do it directly in Assembler".

Editorial Review

With its excellent cross-platform capabilities and rich enterprise-levelAPIs, today's Java 2, Enterprise Edition (J2EE), stands ready to build the nextgeneration of multitiered Web applications--but architecting these solutions canbe a daunting task. Written by the experts at Sun, Designing EnterpriseApplications with the Java 2 Platform, Enterprise Edition provides theofficial "blueprint" for building scalable, server-centric applications by usingJava. This title is perfect for any manager or developer seeking to get a handleon the "right" way to design distributed applications by using Java.

This text bundles together separate chapters written by various members of theSun "Enterprise Team." The prominent methodology here is the consistent use ofthe model-view-controller (MVC) paradigm for designing the server-side tiers. InMVC, data (model) is kept separate from its presentation (view), and the twoare coordinated through a controller class. The book uses quite a few usefularchitectural diagrams, which show how to combine Enterprise Java Beans (EJBs),servlets, and JavaServer Pages (JSPs) effectively. Managers or project leaderswho might not code with Java everyday might learn from these diagrams how Javacomponents work together within Web applications. Also, the authors explain theSun "vision" for Java for a variety of e-commerce scenarios (including severalbusiness-to-business systems).

Separate chapters dig into the client, Web, EJB, and "enterprise informationsystems" tiers, and where to use various J2EE APIs for the best scalability andmaintainability. Later sections look at deploying EJBs, as well as options fortransaction management and security for the enterprise. The authors close with acomplete Web application created with EJBs and servlets for an online pet store --a useful illustration of J2EE at work. All in all, this text is a valuabletour of Sun's official "vision" for enterprise-level computing with Java. Itdemystifies how various Java APIs can work together to create robust andscalable Web applications. Any IS manager or developer designing with J2EE willwant a look at this book to learn how to take full advantage of the latestfeatures for Java-based Web applications. --Richard Dragan

Editorial Review

Most Java developers rely on application servers and other tools to simplify working with Enterprise JavaBeans (EJBs) and servlets. But how do you build a Java 2 Enterprise Edition (J2EE) EJB server from scratch? Based on the latest standards from Sun, Java 2 Platform, Enterprise Edition: Platform and Component Specifications provides a valuable roadmap for understanding the design philosophy and required features that go into J2EE. This book will also be of interest to the Java expert who wants to see how today's application servers work under the hood.

This title concentrates on the "Enterprise Edition" of Java 2, meaning that "core" features are left out. Instead, the team authors focus on two major areas of Java on the enterprise: servlets (including JavaServer Pages, or JSPs) and Enterprise JavaBeans (EJBs). This text is really two books in one, as both topics get full treatment, from basic features to design goals, required APIs, and the evolution of relevant J2EE standards.

XML is used extensively in J2EE for deployment and configuration, and this book provides XML DTDs (for understanding the tags used to defined particular options) and sample XML files for various aspects of deployment. A highlight here is a DTD for defining JSPs using XML--clearly a promising idea that will add great flexibility to JSP-based Web applications.

Excellent diagrams explain the architecture behind servlets and EJBs. One standout section provides "object interaction" diagrams for EJBs--diagrams that show the life cycle and operation of these components. This material will be useful to anyone who really wants to understand how EJBs work, and it will help readers solve problems running JavaBeans in the real world. Like being an expert on CORBA or COM+, knowing the inner workings of servlets and EJBs will pay off--even if you don't need to write your own application server.

Aimed at the more advanced Java developer, Java 2 Platform, Enterprise Edition delivers an authoritative and detailed guide to what it takes to build an EJB or servlet platform. Read it if you are planning to design such software, or if you want to understand the inner workings of today's powerful J2EE platform. --Richard Dragan

Topics covered:

• Overview of the Java 2 Enterprise Edition (J2EE) platform
• Required APIs and specifications
• Security issues
• The Java Naming and Directory Interface (JNDI)
• Servlet basics
• J2EE features and APIs
• JavaServer Pages (JSPs): elements, directives and syntax
• Using XML to define JSPs
• Overview of Enterprise Java Beans (EJBs)
• Specifications for EJB application server vendors
• Session and entity beans, bean-managed and container-managed persistence, bean passivation and activation, and EJB deployment with XML
• Transactions, security, and object-interaction diagrams
• Responsibilities for component builders, application-server vendors, deployers, and administrators
• Revision history and future directions for the J2EE standard

Editorial Review

Written for the working Java developer, Joshua Bloch'sEffective Java Programming Language Guide provides a trulyuseful set of over 50 best practices and tips for writing better Javacode. With plenty of advice from an indisputable expert in the field,this title is sure to be an indispensable resource for anyone who wantsto get more out of their code.

As a veteran developer at Sun, theauthor shares his considerable insight into the design choices madeover the years in Sun's own Java libraries (which the authoracknowledges haven't always been perfect). Based on his experienceworking with Sun's best minds, the author provides a compilation of 57tips for better Java code organized by category. Many of these ideaswill let you write more robust classes that better cooperate withbuilt-in Java APIs. Many of the tips make use of software patterns anddemonstrate an up-to-the-minute sense of what works best in today'sdesign. Each tip is clearly introduced and explained with code snippetsused to demonstrate each programming principle.

Early sections oncreating and destroying objects show you ways to make better use ofresources, including how to avoid duplicate objects. Next comes anabsolutely indispensable guide to implementing "required" methods forcustom classes. This material will help you write new classes thatcooperate with old ones (with advice on implementing essentialrequirements like the equals() and hashCode()methods).

The author has a lot to say about class design, whetherusing inheritance or composition. Tips on designing methods show youhow to create understandable, maintainable, and robust classes that canbe easily reused by others on your team. Sections on mapping C code(like structures, unions, and enumerated types) onto Java will help Cprogrammers bring their existing skills to Sun's new language. Latersections delve into some general programming tips, like usingexceptions effectively. The book closes with advice on using threadsand synchronization techniques, plus some worthwhile advice on objectserialization.

Whatever your level of Java knowledge, this title canmake you a more effective programmer. Wisely written, yet never pompousor doctrinaire, the author has succeeded in packaging some reallyvaluable nuggets of advice into a concise and very accessible guidebookthat arguably deserves a place on most any developer's bookshelf.--Richard Dragan

Topics covered:

• Best practices and tips for Java
• Creating and destroying objects (static factory methods,singletons, avoiding duplicate objects and finalizers)
• Required methods for custom classes (overriding equals(),hashCode(), toString(), clone(), andcompareTo() properly)
• Hints for class and interface design (minimizing class and memberaccessibility, immutability, composition versus inheritance, interfacesversus abstract classes, preventing subclassing, static versusnonstatic classes)
• C constructs in Java (structures, unions, enumerated types, andfunction pointers in Java)
• Tips for designing methods (parameter validation, defensive copies,method signatures, method overloading, zero-length arrays, hints forJavadoc comments)
• General programming advice (local variable scope, using Java APIlibraries, avoiding float and double for exactcomparisons, when to avoid strings, string concatenation, interfacesand reflection, avoid native methods, optimizing hints, namingconventions)
• Programming with exceptions (checked versus run-time exceptions,standard exceptions, documenting exceptions, failure-captureinformation, failure atomicity)
• Threading and multitasking (synchronization and scheduling hints,thread safety, avoiding thread groups)
• Serialization (when to implement Serializable, thereadObject(), and readResolve() methods)

Editorial Review

Patterns are basically design solutions for recurring problems, so Core J2EE Patterns contains recurring design solutions for persons using J2EE. The authors break these solutions down into presentation, business, and integration patterns.

As is usual with pattern books, you won't find much code here. The book majors on problem discussions, analysis of the factors you should consider in your design, and strategies for the solution implementation. The authors constantly encourage abstraction, code modularity, non-duplication of code, network efficiency, code maintainability, and solution reusability.

While these are the aims we've been encouraged to pursue for years, too many pattern books operate at such a high theoretical level they fail to appeal to working programmers. In practice, you could use the patterns discussed with any language, but by concentrating on using Java, Core J2EE Patterns is able to take a more hands-on approach.

Okay, so you won't find detail at the level of APIs, but you will find discussion of where to implement functionality to best leverage Java's architecture and which Java mechanisms to use: for example, implementing entity beans as coarse-grained--rather than fine-grained--objects to reduce the transaction overhead. Not the sort of implementation advice you'll find in language-agnostic pattern books.

Editorial Review

Aimed at the more experienced Java Web developer, Advanced JavaServer Pages covers leading-edge techniques for writing more maintainable Web applications in Java. Stressing custom tag libraries and other reusable components, this book is all you need to take your programming skills to the next level.

There are any number of good introductory texts on JavaServer Pages. This title distinguishes itself with techniques recommended by Sun for building better Web applications. Backed up by the author's own collection of custom tag libraries, which allow ordinary Web designers to program with tags instead of Java code, this text covers all the bases from getting started with tags to more advanced techniques. Early examples of tag libraries include a variety of ways to validate data in HTML forms. Throughout, the book deftly describes installing tag libraries, and shows how HTML designers can use custom tags after Java developers have created them.

Readers also get best practices for JSP and Beans, which is a big plus. Author David Geary presents both Model 1 and Model 2 architectures. (In Model 1, JavaBeans are used to present data to front-end JSPs. In Model 2, a more sophisticated set of Java classes using the Model-View-Controller design pattern allows even greater flexibility.) Sample code for using JSP and JavaBeans for internationalized code (including French, German, and Chinese) will show you how to take your Web application to worldwide markets. The book concludes with a working case study of an online fruit stand (using several languages) and applies the techniques presented earlier on.

All in all, with its mix of practical advice and some very useful techniques for getting the most out of JSP and Java for Web applications, Advanced JavaServer Pages fills a valuable niche for any serious Java developer who wants to see some of the best ways to create Web applications today. --Richard Dragan

Topics covered:

• Custom tag tutorial (including JSP and TLD files)
• The tag life cycle
• Tag attributes
• Tag classes
• Body tag handlers
• Scripting variables
• Nested tags
• HTML forms and JavaBeans
• Validating form data with Beans and custom tags
• Templates and custom tags for defining regions within Web pages
• Model 1 and Model 2 basics
• Sample classes and tags for Model 2 framework (including samples for managing logins)
• Event handling
• Sensitive form resubmissions
• Internationalization techniques (including resource bundles and locales)
• Security issues (including basic, digest, form-based, and SSL authentication)
• Custom tags for JDBC database programming
• Database connection pooling, XML, and JavaBeans
• The Simple API for XML (SAX)
• The Document Object Model (DOM) and custom tags for these APIs
• XSLT and XML
• Case study for an internationalized online fruit stand
• Appendix on Servlet filte