J2EE Technology Practice

Author: Rick Cattell, Jim Inscore (Enterprise)
Publisher:
Publish Date: 2002-01-01
Features: J2EE can be said to be the hottest topic recently, with JSP, Java Servlet, JDBC, and seemingly any term with the letter "J" becoming popular overnight. Naturally, various references and textbooks emerged in the market. This can also be attributed to the "market economy." The "J2EE Technology Practice" published by China Machine Press is one of these books. At first glance, it didn't seem extraordinary—thin and small compared to the hefty professional books that often run to hundreds or even thousands of pages. Initially, I didn't expect it to contain much content. After reading several chapters, I realized it truly had "its strengths and weaknesses."
Typically, computer-related professional books begin with a historical overview, explaining the origins and evolution of the technology, language, or tool, followed by comparisons with similar works. Such chapters often take up dozens of pages and require significant mental effort to read carefully. Of course, one could skip these sections, but for beginners, it’s risky to read them out of context, leading to confusion. The main body of the book then tends to follow the principle of "broad-mindedness," covering every aspect in great detail. If it discusses systems, it explains every command and setting with numerous examples and additional techniques and programming interfaces. If it covers languages, it delves into variables, functions, and even function parameters, further dividing them into database programming, network programming, and graphical interface programming. If more is needed, it includes sample code. Yet, even then, hundreds of pages might not suffice. Even "lightweight" books aim to be comprehensive, which can leave readers overwhelmed.
In reality, whether it’s systems, tools, or languages, there are official reference books for each. For technical specifications like commands, variables, and functions, these official references are likely unmatched. Combined with a few well-crafted books that analyze them in depth, shouldn’t that be enough? Computer technology is fundamentally an "applied technology," and all techniques ultimately serve application needs. So, shouldn’t other books focus more on practicality? After all, the most useful reference books in the workplace are those that directly guide and assist in work. Such books are better off being specialized and practical rather than overly broad yet shallow.
This "J2EE Technology Practice" embodies this philosophy. It gets straight to the point in just a few pages, avoiding lengthy historical discussions and thus reducing unnecessary complications. The explanation of the J2EE architecture is concise and clear. Since developers working in this field should already have a solid understanding of J2EE through Sun Microsystems and the Java Software Organization’s websites and publications, there’s no need to repeat lengthy explanations here. Doing so would be redundant, tedious, and increase the book’s production costs. Despite its brevity, the book covers all essential points, serving as a good reference for subsequent content.
The latter part of the book, which can be considered its core, is a detailed exploration of ten successful case studies. Most developers can attest that having a successful example to reference when developing a project can save considerable time, especially for new technologies, which can greatly broaden a developer’s perspective and highlight issues they might not have considered. J2EE is a new architecture, and its primary purpose is to solve real-world problems. Practical developers need help with this most of all. In this regard, the book addresses many urgent needs.
While many books have used real-world cases to explain technologies and architectures, most only mention vague statements like "after adopting this technology, a company reduced its expenses by X% and increased profits by Y%." They provide little detail on specific solutions or explain why such solutions were chosen. Such analyses are ultimately limited. In contrast, this book offers thorough explanations for each case, starting with the client’s operational background, clarifying why J2EE was chosen, and explaining how the planners decided to use it. It also analyzes potential challenges and benefits of the solutions. Such content will undoubtedly be a great help to anyone just starting to use J2EE for project development.
The descriptions of the project plans include detailed analyses of user scenarios and clear explanations of the layered architecture and transaction processing. The selection of the ten cases is both comprehensive and targeted, with explanations that are well-organized and easily applicable to real-world work. While not a massive classic, this book is highly practical. Its concise length allows readers to quickly grasp how to use J2EE to develop application service architectures. "Concise yet powerful" perfectly describes it.
Speaking of which, another book published by China Machine Press—"Java Efficient Programming Guide"—is worth mentioning. Part of the same series as "J2EE Technology Practice," it shares a similar style. This book doesn’t focus on compatibility packages. Instead, it explores Java programming topics like classes and interfaces, methods, exception handling, and thread control, all centered on the language itself. It completely ignores popular topics such as database programming, graphical user interface programming, and network programming. At first glance, it seemed like a rehash of Sun’s official manual. However, the table of contents revealed that while the scope is narrow, each section contains valuable insights.
As programmers, most of us understand that good coding habits and a deep understanding of the language are crucial for writing excellent code. Many colleagues often overlook these issues, mistakenly blaming the system or claiming Java is immature or unstable when problems arise. This book starts from this premise, discussing overlooked yet important aspects of programming, such as minimizing class and member accessibility, reducing the scope of local variables, and avoiding excessive synchronization. Paying attention to these details can significantly improve code robustness and reusability, especially since Java itself emphasizes these qualities.
Additionally, the book acknowledges that many Java programmers transition from C or C++ backgrounds. It dedicates a chapter to explaining the replacement of C-style structures, which is a significant help to these developers.
In summary, both books are highly practical. For developers already familiar with Java or working on Java/J2EE projects, they can serve as excellent reference guides. Many problems encountered in real-world work can likely be solved using the knowledge in these books.