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

Java

Pitfalls

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

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

《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中文版

Pitfalls and Tradeoffs in Simultaneous, On-Chip FPGA Delay Measurement

Please summarize the main argument of the book <the culture of connectivity》

有没有好的c++语言编程书籍推荐？

sql数据库设计参考文献

磁共振APT序列的相关文献

推荐几个不错的uni-app专栏，并给出链接

std::shared_ptr

C语言难度最高的书籍有哪些

Using Hidden Markov Models for the accurate linguistic analysis of process model activity labels

All the 5 fits failed. It is very likely that your model is misconfigured. You can try to debug the ...

有关国外学者库存管理研究现状参考文献原理

推荐经典c++100本书籍

C语言相关书籍有哪些

QYR2024-2030全球及中国机载光电吊舱行业研究及十五五规划分析报告 wugege.pdf

KLite 是嵌入式操作系统内核，并以MIT协议开放源代码

Avatar_Utils-1.4.0-py3-none-any.whl.zip

全球与中国合同餐饮市场现状及未来发展趋势（2024版）.docx

qt框架的概要介绍与分析

最新资源