Java编程陷阱指南：50实用解决方案与绕行策略

需积分: 10 136 浏览量更新于2024-07-19 收藏 4.9MB PDF 举报

《More Java Pitfalls: 50 New Time-Saving Solutions and Workarounds》是一本面向经验丰富的Java开发者的指南，由Wiley Publishing出版。该书在当前高度竞争且快速变化的IT行业中，致力于帮助忙碌的专业人士解决技术问题和学习新技能，以适应不断演进的Java语言和J2EE技术。作者通过提供50个实用的解决方案和工作方法，帮助读者避免那些隐藏在Java语言中的陷阱，节省时间并提升工作效率。书中涵盖的主题包括但不限于： 1. **语言陷阱**：深入解析Java语言中可能遇到的复杂性，如内存管理、异常处理、多线程并发控制等方面，指导开发者如何识别和避免常见的编程错误。 2. **J2EE技术陷阱**：针对企业级Java应用（Enterprise Java Enterprise Edition）中的挑战，如EJB（Enterprise JavaBeans）、Servlets、JSP（JavaServer Pages）以及JDBC（Java Database Connectivity）的潜在问题，提供解决方案以确保系统的稳定性和性能。 3. **设计模式与最佳实践**：书中可能还会介绍如何运用设计模式来避免常见的架构问题，以及遵循最佳实践以提高代码质量和可维护性。 4. **性能优化**：针对Java应用程序的性能瓶颈，作者会分享如何通过合理调优和编码技巧来提升程序的运行效率。 5. **工具和技术选型**：对于正在寻找新工具或技术的学习者，书中可能会包含对最新Java开发工具和框架的简要介绍，帮助开发者选择最适合自己的工具。 6. **实践经验分享**：每个陷阱及其解决方案都基于作者的实际工作经验，确保了理论知识与实战案例的紧密结合，便于读者理解和应用。这本书不仅适合希望进一步提升Java技能的专业人士，也对新手程序员具有参考价值，因为它可以帮助他们在早期阶段就避开潜在的问题，避免重复踩坑，从而节省时间和精力。无论是想要学习新技术还是解决现有项目难题，这本书都是一个不可或缺的参考资料。

Language Complexity. The Java language has many improvements over its predeces-

sors yet also struggles with its own set of tradeoffs and idiosyncrasies. The cleanest

language features are its strict object orientation, automatic memory management,

and interfaces; while some overly complex areas are threading and synchronization,

the tension between primitives and objects, and the effective use of exceptions.

Weak Implementation of Platform Areas. The most oft-cited example is poor per-

formance. An example of this is the rewrite of the input/output facilities in the

NIO package for performance reasons. Besides performance, there are thin APIs

that ruin the Write Once, Run Anywhere (WORA) guarantee like the

File.renameTo() (Item 20) method and the Runtime.exec() method (Item 1).

There are also incomplete APIs where the programmer assumes complete func-

tionality exists. These problems are fixable and often are resolved with each new

release of the Java Development Kit (JDK).

The categories of pitfalls associated with the programmer are as follows:

Shallow Knowledge. Experience increases the depth of one’s knowledge. It takes

time to learn the underlying concepts, interactions, and nuances of a system.

This is often manifest in choosing a weak implementation when a better alterna-

tive exists (like applets versus Web Start, Item 26), misunderstanding the inter-

nal workings of an API (like the consequence of instance variables in servlets,

Item 31), and shock when implementations fail to meet your expectations of

behavior (characterized as an impedance mismatch in Figure i-1). Such an

impedance mismatch can occur with multiple concurrent result sets (Item 41).

Bias. Without many years of experience, a programmer can weigh previous experi-

ence too heavily to the point where it unfavorably biases him or her in a particu-

lar direction. Examples of this are to not take advantage of tools to automate the

development process like Ant (Item 11) and JUnit (Item 12). Another example is

to stick with legacy APIs over new ones for collections (Item 21) and regular

expressions (Item 30). Lastly, one more effect of bias is to bring past habits into a

new context like J2ME programming (Item 22).

Invalid Assumptions. A programmer can incorrectly base decisions on invalid

assumptions—for example, assuming the most direct path to the solution is the

best path. This often arises in designing larger systems with JSP (Item 24) and

J2EE (Item 37).

Pitfalls can be extremely frustrating to programmers. We’ve experienced first hand

this frustration. Our goal is to help you to avoid some situations we struggled through.

So now that we understand pitfalls, let’s see our method for exploring them.

Dissecting a Pitfall

There are three distinct parts of a pitfall:

The Symptom or Problem. The medium by which the pitfall manifests itself. We

demonstrate this with a program entitled “BadXXX.java,” where “XXX” refers to

the type of pitfall in question.

Introduction xiii

The Root cause of the Problem. By far, this is the most important part of revealing

the pitfall. Here, we go under the hood and explain the detailed internal work-

ings, invalid assumptions, or API deficiencies that cause programmers to stum-

ble into the trap. Usually this explanation is supported with a diagram.

The Solution or Workaround. The final part of the pitfall is to demonstrate a fix

for the problem. This is done with a program entitled “GoodXXX.java” that is

the reciprocal of the “BadXXX.java” program. The solution program will often

be accompanied with a run of the results, or a table or graph, which proves the

problem was indeed solved.

This method of dissecting a pitfall has proven an effective way to present these pro-

gramming hazards.

How This Book Differs from Java Pitfalls

This book borrows all the good features from the first book and improves upon it in

three ways:

Broader Coverage. The first book focused on the lang, util, io, and GUI packages,

whereas this book covers the J2ME, J2SE, and J2EE platforms.

New Features. This book covers the majority of new features like regular expres-

sions, NIO, assertions, JAXR, JAXM, JAX-RPC, and many more.

Better Coverage. The authors followed the “pitfall dissection” model more consis-

tently and thoroughly, producing pitfalls with more detail and analysis.

In general, the authors strove to outdo the first book in every regard. We sincerely

hope that we succeeded and encourage your feedback.

Organization of the Book

Like the first one, this book has 50 items. Unlike the first book, in this one they are

divided into three parts corresponding to the three-tiered architecture:

Part One: The Client Tier. This part covers both J2ME and J2SE and explores pit-

falls in developing both networked and standalone clients. Topics covered

include preferences, application deployment, logging, IO performance, and

many more. This part has 22 pitfalls.

Part Two: The Web Tier. This part examines pitfalls in components that run inside

the Web container, like servlets and JavaServer Pages (JSPs). These applications

generate dynamic Web pages or communicate with applets, JNLP, or standalone

clients. This parts covers topics like JSP design, caching, servlet filters, database

connections, form validation, and many others. This part includes 14 pitfalls.

Part Three: The Enterprise Tier. Here we look at components that are part of the

J2EE platform or execute inside an Enterprise Java Beans (EJB) container, like

session, entity, and message-driven beans. These components interact with other

enterprise systems, legacy systems, the Web tier, or directly to clients. Because

xiv Introduction

Web services play a key role in the enterprise tier, pitfalls related to some of the

Web services APIs (JAXR and JAX-RPC) are in this section. Some other topics in

this part are J2EE design errors, session beans, Java Data Objects (JDO), security,

transactions, and many more. This part includes 14 pitfalls.

How to Use the Book

This book can be used in three primary ways: as a reference manual on specific prob-

lems, as a tutorial on the topics exposed by the problems, or as a catalyst to your orga-

nization’s technical mentoring program. Let’s discuss each in detail:

As a Reference Manual. You can use the table of contents to examine a specific

solution to a problem you are facing. The majority of readers use this book in

this manner. Some readers reported using the first book as a corporate resource

in the technical library.

As a Tutorial. You can read the book cover–to-cover to learn about the underlying

cause of each pitfall. Another way to approach the book this way is to browse

the contents or pages and then read the pitfalls that interest you. Lastly, another

use is to treat each pitfall as a bite-sized tutorial to present at a “brown-bag

lunch” internal training session or technical exchange meeting.

As Part of a Mentoring Program. You can use the book as a starting point for a

technical mentoring program in your organization. This book is founded on the

principle of peer mentoring. The dictionary definition of a mentor is a “wise and

trusted counselor.” This often miscasts a mentor as having great age or experi-

ence. I disagree with this definition because it leads to an extreme scarcity of

good mentors. At its essence, mentoring is one aspect in the search for truth. Thus,

the key quality for being a mentor is a deep understanding of at least one

domain that you are willing to share with others. Anyone can participate in this

process, and I encourage you to be involved in peer mentoring. Working

together, I believe we can solve the software quality crisis.

What’s on the Companion Web Site?

The companion Web site will contain four key elements:

Source Code. The source code for all listings in the book will be available in a

compressed archive.

Errata. Any errors discovered by readers or the authors will be listed with the

corresponding corrected text.

Examples. Sample chapters, the table of contents and index will be posted for

people who have not yet purchased the book to get a feel for its style and content.

Contact Addresses. The email addresses of the authors will be available as well

as answers to any frequently asked questions.

Introduction xv

This book has been a difficult journey. It survived through three co-author changes,

several delays, and a move to a new state. Along the way, the vision of the book never

faded, and in some way it willed itself into existence. All the authors believe that

uncovering pitfalls helps programmers produce better programs with less frustration.

I would like to thank those people who helped me through this challenge: my family—

Lynne, CJ, Greg, and Samantha; my editors at Wiley Publishing, Inc.—Bob Elliott and

Emilie Herman; my co-authors—Kevin, Clay, and Donnie; Al Saganich for contribut-

ing two pitfalls; my supervisors, customer and coworkers on the Virtual Knowledge

Base project—Ted Wiatrak, Danny Proko, Joe Broussard, Joe Rajkumar, Joe Vitale,

Maurita Soltis, and Becky Smith; my editor at Javaworld—Jennifer Orr; my friends at

Oberon—Jodi Johnson and Dave Young; and finally, I would like to thank our readers

who share our goal of producing great programs. Thanks and best wishes!

Michael C. Daconta

First of all, I would like to thank my co-authors—Mike, Clay, and Don. Your hard work

on this project, and our many brainstorming sessions together at Cracker Barrel,

helped create a good book full of our Java experiences and lessons learned. Second, I

would like to thank my other new friends at McDonald Bradley and our entire VKB

team. What a team of incredible folks.

I would like to give special thanks to a few people who suggested pitfalls and ideas

for this book—John Sublett from Tridium, Inc. in Richmond, Virginia, Kevin Moran

from McDonald Bradley, and Jeff Walawender from Titan Systems. Lois G. Schermer-

horn and Helen G. Smith once again served as readability editors for some of my mate-

rial. Special thanks to Stan and Nicole Schermerhorn for allowing me to use their

company’s name, Lavender Fields Farm, in a fictional scenario in this book. Also,

thanks to Al Alexander, who granted me permission to use DevDaily’s DDConnec-

tionBroker to demonstrate a solution to a common programming pitfall.

Acknowledgments

xvii

剩余477页未读，继续阅读

mamaodenghu

粉丝: 3
资源: 104

Java编程陷阱指南：50实用解决方案与绕行策略

More Java Pitfalls中文版

More.Java.Pitfalls中文版

Java pitfalls图书

java pitfalls.chm

More.Java.Pitfalls中文版2

More.Java.Pitfalls中文版.pdf

More.Java.Pitfalls中文版3.pdf

More.Java.Pitfalls中文版part2.pdf

Java™ Puzzlers: Traps, Pitfalls, and Corner Cases.chm

Bitter Java

最新资源