6、付钱领奖

上面就是一个骗子网站的常用过程。识别整个过程的关键是：http://www.cdreasm.cn/，与官方cdream有一字之差。现在这社会就是这样，越是做得像就肯定不是，不要怀疑你的感觉。这里贴出来，供大家娱乐，笑一下！~

Windows Firewall, as the name suggests, creates a protective wall between your computer and the external traffic coming on to it. Firewall helps in restricting and monitoring information that is transferred between your computer and external sources such as a network or the Internet. Configuring a firewall helps in preventing unauthorized access to your computer and prevents malicious use of your computer by hackers. On a Windows XP Service Pack 2 PC, the Windows Firewall is enabled and turned on by default. In this article, we will discuss the steps to remove firewall from your computer.

Need to Remove Firewall?

You may need to remove firewall, for one of the following reasons:

• You have installed another third-party firewall on your computer and the two firewalls are conflicting with each other.
• The installation of Windows Firewall is corrupt and you want to remove it completely from your computer to fix the problem and reinstall the Firewall again.
• Your computer is never connected to a network or the Internet and you want to get rid of all services that you do not need on your computer.

Steps to Remove Firewall

Windows Firewall removal is primarily a three-step process:

1. Disable the firewall.
2. Stop the firewall.
3. Remove all the files of the firewall.

To disable and stop the Firewall, perform the following steps:

1. Open Start menu and select ControlPanel.
2. Select the PerformanceandMaintenance link and then select the Administrative Tools link.
3. Next, double-click on the Services option.
4. In the Services management console window, right-click on the Windows Firewall/Internet Connection Sharing (ICS) service and select Properties.
5. In the properties dialog box that is displayed, select the Disabled option from the Startup type list and click on the Stop button.
6. Select Apply to confirm your changes and click OK to exit the properties dialog box.

To remove all files and registry entries related to the Firewall on your computer, perform the following steps:

1. On Start > Run type cmd and press Enter to open the Command Prompt window.
2. In the Command Prompt window, run the following command and press Enter.

sc delete SharedAccess

Running this command removes all files and registry entries related to the firewall service from your computer, and enables you to completely remove firewall from your computer.

Reinstall Windows Firewall

Now, if you wanted to remove firewall only to fix certain errors, or you want to reinstall the firewall later, then run the following commands one after another at Command Prompt.

rundll32 setupapi,InstallHinfSection Ndi-Steelhead 132 %windir%\inf\netrass.inf

netsh firewall reset

Next, exit the Command Prompt window and open the Control Panel. Here, double-click on the Windows Firewall option. Click Yes when a message is prompted asking you if you want to start the Windows Firewall/Internet Connection haring (ICS) service. When you select Yes, the service is started and the Windows Firewall dialog is displayed that you can use to configure your firewall.

If this does not enable you to restore the firewall, you may need to reinstall Windows XP SP2, which includes the installation for the Firewall. You may also opt to perform System Restore and revert your computer back to the time when the Windows Firewall still existed on your computer.

Traceback: http://www.instant-registry-fixes.org/how-to-remove-firewall-included-in-windows-xp/

Dynarch导航栏

• 安装说明 - 如何安装在您的网站上。
• 定制 - 改变外观和感觉。
• 支持 - 如果发生什么错误，请与我们联系。

License许可

请阅读在这里的许可文本。

Navbar的概况

我们的DHTML导航栏是一个多用途的类似Windows XP的资源管理器菜单的DHTML“组件”（见样品）。

特征

• 支持广泛范围的浏览器。
• 此外，外观是可定制的，只需要改动一个CSS文件，而不必须触及JavaScript代码。
• 用户可以根据他的需要折叠/展开菜单的部分。
• 依赖于网页标准。它不依赖于专有的浏览器的功能，同时如果它们可用时，充分利用一些。
• 提供高质量的动画和淡入淡出效果。如果不想要，动画可以禁用，要么完全或限制在某个水平。
• 菜单部分可以嵌入普通HTML代码。
• （菜单）项目在单击时可以执行定制JavaScript代码。
• 当菜单是隐藏的时，它扩大了可用于其他网页的空间。
• 它会在一个cookie中记住它的状态，并在用户的回顾该网页时自动恢复。因此，开发人员并不需要在服务器端这样做了。
• 2个工作模式：一次允许多个（菜单）节点被展开，或只有一个（菜单）节点被展开。
• 某些特征的配置可不需要重新装载和重建菜单（因此，没有一个网页被重新加载）。他们将被保存在Cookie中。
• 允许菜单选项带图标。如果一个图标不存在，将会使用'»'来代替。
• 允许使用带有alpha-opacity的png图标，在IE浏览器中也可以。
• 可以显示工具提示。
• 不使用框架。
• 降低了网页的文件大小，因为创建菜单的代码可以被放进一个JavaScript文件，该文件是将会被浏览器缓存。
• 菜单可以从服务器端脚本动态生成（在网页显示时）。

Browser support浏览器支持

• Windows中的Internet Explorer 6.0 - 出色的支持
• Windows中的Internet Explorer 5.5 - 良好的支持
• Windows中的Internet Explorer 5.0 –能工作，但没有png方式
• Mozilla ， Firefox ，其他Gecko-s（任何平台） - 出色的支持
• Opera7（任何平台） - 很好的支持，没有淡入淡出
• MacOSX的Apple Safari - 出色的支持
• Linux的Konqueror -良好的支持

由于大多数Web浏览器，甚至新的，默认工作在兼容模式（也称为QUIRKS模式），以便能够正确显示旧的网页，Navbar需要您在网页上声明为严格的DOCTYPE。这引导浏览器切换到标准的执行模式，Navbar将在QUIRKS模式不能正常工作。

安装说明

1、从Navbar的发布包中复制“navbar”目录到您的Web服务器，例如使用FTP客户端。 If you copied it directly in your document root then a URL like the one below would be valid and lead to the main JS file:如果您直接复制它到您的文档根目录下，因此像下面一样的一个网址将是有效的，并引导主要的js文件：

http://www.yourdomain.com/navbar/navbar.jss

在这种情况下， Navbar的路径将是“/navbar” （红色段）。因为Navbar使用路径来寻找控制图标，因此要在产生菜单之前指定它。

请注意，有些Web服务器或浏览器可能不认识.jss扩展名（这的确是一个非标准的扩展名），因此将无法传递正确的“content type”。如果您遇到任何问题，请重命名该文件为：“navbar-all.js”，并在<script>标记中替换并载入该文件。

2、创建一个“setupmenu.js”文件。你可以把它放在任何你想存放的地方，没有必要把它放在的/navbar的路径下。此文件将包含初始化和生成菜单的代码，以下是一个标注了的范例，对于一个完整的例子，您应该查看发行包中的“setupmenu.js”源文件，也可看看这个网页的源文件。

_NavBar_url = "/navbar";   // 用于禁用当前页面功能的助手函数 function L(label) {  if (_NavBar_pageID.toLowerCase() == label.toLowerCase())     label = "!" + label;  return label; }   var menu = new NavBar(document.getElementById("content"),                       document.getElementById("beforemenu"),                       document.getElementById("aftermenu"));   // 开始生成（添加顶部控制按钮） menu.openMenu();   // 一个菜单项目 new NavSection(  menu, // 父菜单  "a menu", // 项目标签  [     [ L("Home"), "home.html", "Homepage", "images/home.png" ],     [ L("Products"), "products.html", "Our products", "images/products.png" ],     [ L("Label"), "url", "A tooltip", "images/icon.png" ]  ] );   // 设置一些选项 menu.prefs["animation"] = 3;    // "bloatware" ;-) menu.prefs["auto-hide"] = true; // 自动隐藏   // 结束生成 menu.generate();

一些标注：

• 如果一个到图片的路径是相对（即“images/home.png”），那么它将相对到您的网页，而不是/navbar的路径。
• 您可以使用PNG图标。包括在Internet Explorer，变化的opacity将可以工作。
• 所有定制选项的列表（如menu.prefs[“animation”]）见定制信息。

3、正如您从上述代码所注意到的，我们创建了一个标记为“a menu”名字的单个项目的菜单，并链接到页面“home.html”， “products.html”。每个网页应具有以下结构：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"           "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <!-- DOCTYPE 是很重要的，不要忘记了 -->   <html xmlns="http://www.w3.org/1999/xhtml"       style="padding: 0px; margin: 0px">    <head>     <title>yourwebsite.com homepage</title>       <!-- 包含主要的脚本 -->     <script type="text/javascript" src="/navbar/navbar.jss"></script>       <script type="text/javascript">       _NavBar_pageID = "Home"; /* 当前页的菜单标记*/     </script>       <style type="text/css">       /* 提取导航栏的样式 */       @import url(/navbar/navbar.css);     </style>    </head>    <body>       <div id="beforemenu">       [...] 显示在导航栏中的内容，位于菜单前面 [...]     </div>       <div id="aftermenu">       [...] 显示在导航栏中的内容，位于菜单后面 [...]     </div>       <div id="content">       <div>         [...] 这里放置你包含的页面内容 [...]       </div>     </div>       <!-- 为了能够生成菜单，在这里加载setupmenu -->     <script type="text/javascript" src="setupmenu.js"></script>    </body> </html>

菜单将建立在id“content”的DIV层里面。其他的两个DIV层将被移到导航栏中，并且放在菜单的前面和后面，同时它们也是可选的。

Navbar的定制

外观是完全可通过改变CSS文件而定制的。除此之外，有几个自定义选项，需要一些JavaScript代码。假如您是使用下面的命令创建的菜单：

var menu = new NavBar("content");

您可以修改下列自定义选项：

1.     menu.prefs["animation"] = 0 | 1 | 2 | 3

意思是“0”为没有所有的动画，“1”为仅是项目的动画，“2”为菜单栏的动画，以及“3”为“膨胀”动画（当隐藏菜单时，整个网页将产生动画）。我强烈建议使用“2”（默认值） 。

2.     menu.prefs["mono-section"] = true | false

当mono-section的值为true时，将是一次只有一个项目可见（被展开）。选择另一部分将隐藏当前可见的部分。

3.     menu.prefs["generate-anim"] = true | false

如果这个值是true的话，那么菜单在启动时会显示动画。

4.     menu.prefs["auto-hide"] = true | false

如果这个值是true的话，菜单将会是一个“自动隐藏”的菜单，意思是当鼠标光标鼠标光标离开菜单区域时，菜单将自动隐藏。

5.     menu.prefs["tooltips"] = true | false

如果这个值是true（默认）的话，导航栏将显示工具提示。

6.     menu.prefs["icon-width"] = 20
menu.prefs["icon-height"] = 14

允许您设定图标的尺寸。如果您提供了不同尺寸的图片，它们将被缩小，以满足上面两行配置的要求。

7.     menu.prefs["link-prefix"] = "/foo/bar/"

如果将此选项设置，则各个菜单所指向的链接都将加上特定前缀（例如：“/foot/bar/” ）。

8.     menu.prefs["cookie-path"] = "/bar/foo/"

设定菜单存储的cookie的路径。Cookie用于在紧接后的请求中记住菜单的状态。

9.     menu.prefs["cookie-exp"] = 15

配置Cookie过期时间。如果没有设置（默认），则cookie将直到关闭浏览器（在会议结束时）才过期。上面的例子说明cookie将在15天后过期。

10. menu.prefs["link-target"] = "_blank"

设定在菜单中链接的target属性。这应该是一个frame的名称。如果你想在当前窗口/帧中打开所有链接，就请不要设置。

11. menu.prefs["nb-frames"] = 15
menu.prefs["ns-frames"] = "auto"

导航栏（nb-）或菜单项目动画（ns-）的帧数。这个数字越高，动画的速度就越慢。如果设为“自动” （默认），帧的数目将基于菜单项目的高度来计算。

12. menu.prefs["nb-fps"] = 45
menu.prefs["ns-fps"] = 100

导航栏（nb-）或菜单项目动画（ns-）每秒将会显示的帧数。这个数字越高，动画将会越平滑，但CPU的负载就会越高。其默认值应该对于大部分系统都是不错的。

13. menu.prefs["home-href"] = "http://dynarch.com/mishoo/menubar.epl"
menu.prefs["home-title"] = "NavBar project page"
menu.prefs["home-text"] = "NavBar"

这个首选项可让您定义将会显示在头部/尾部和它的工具栏提示的链接。上面的例子显示了默认选项。

14. menu.prefs["no-controls"] = false

设置为true，为了隐藏“全局菜单控制”，即“+”，“-”按钮操作所有菜单项目，以及左/右箭头可关闭/打开菜单。

15. menu.prefs["no-disable"] = false

如果您设置为true的话，Navbar将不会禁用当前的项目。如果你想当前的项目看上去是激活的，并且没有被禁用，可在这里设置“item-disabled” （或自定义字符串），同时该项目将获得附加的字符串作为类的名称。使用这个（类名称）您可以在它的样式表中定义一个自定义外观。“item-disabled”是在navbar.css中定义的默认的类别名称，用来使得该项目看起来是“激活”的。

Advanced DAO programming

Learn techniques for building better DAOs

Level: Advanced

07 Oct 2003

J2EE developers use the Data Access Object (DAO) design pattern to separate low-level data access logic from high-level business logic. Implementing the DAO pattern involves more than just writing data access code. In this article, Java developer Sean C. Sullivan discusses three often overlooked aspects of DAO programming: transaction demarcation, exception handling, and logging.

During the past 18 months I worked with a team of talented software engineers to build custom Web-based supply chain management applications. Our applications accessed a broad range of persistent data, including shipment status, supply chain metrics, warehouse inventory, carrier invoices, project management data, and user profiles. We used the JDBC API to connect to our company's various database platforms and applied the DAO design pattern throughout the applications.

Figure 1 shows the relation between the applications and data sources:

Applying the Data Access Object (DAO) pattern throughout the applications enabled us to separate low-level data access logic from business logic. We built DAO classes that provide CRUD (create, read, update, delete) operations for each data source.

In this article, I'll introduce you to DAO implementation strategies and techniques for building better DAO classes. Specifically, I'll cover logging, exception handling, and transaction demarcation. You will learn how to incorporate all three in your DAO classes. This article assumes that you are familiar with the JDBC API, SQL, and relational database programming.

We'll start with a review of the DAO design pattern and data access objects.

DAO fundamentals

The DAO pattern is one of the standard J2EE design patterns. Developers use this pattern to separate low-level data access operations from high-level business logic. A typical DAO implementation has the following components:

• A DAO factory class
• A DAO interface
• A concrete class that implements the DAO interface
• Data transfer objects (sometimes called value objects)

The concrete DAO class contains logic for accessing data from a specific data source. In the sections that follow you'll learn techniques for designing and implementing data access objects. See Resources to learn more about the DAO design pattern.

Back to top

Transaction demarcation

The important thing to remember about DAOs is that they are transactional objects. Each operation performed by a DAO -- such as creating, updating, or deleting data -- is associated with a transaction. As such, the concept of transaction demarcation is extremely important.

Transaction demarcation is the manner in which transaction boundaries are defined. The J2EE specification describes two models for transaction demarcation: programmatic and declarative. Table 1 breaks down the two models:

Table 1. Two models of transaction demarcation

We'll focus on programmatic transaction demarcation.

Design considerations

As stated previously, DAOs are transactional objects. A typical DAO performs transactional operations such as create, update, and delete. When designing a DAO, start by asking yourself the following questions:

• How will transactions start?
• How will transactions end?
• Which object will be responsible for starting a transaction?
• Which object will be responsible for ending a transaction?
• Should the DAO be responsible for starting and ending transactions?
• Will the application need to access data across multiple DAOs?
• Will a transaction involve one DAO or multiple DAOs?
• Will a DAO invoke methods on another DAO?

Knowing the answers to these questions will help you choose the transaction demarcation strategy that is best for your DAOs. There are two main strategies for transaction demarcation in DAOs. One approach makes the DAO responsible for demarcating transactions; the other defers transaction demarcation to the object that is calling the DAO's methods. If you choose the former approach, you will embed transaction code inside the DAO class. If you choose the latter approach, transaction demarcation code will be external to the DAO class. We'll use simple code examples to better understand how each of these approaches works.

Listing 1 shows a DAO with two data operations: create and update:

  public void createWarehouseProfile(WHProfile profile);
  public void updateWarehouseStatus(WHIdentifier id, 
    StatusInfo status);

Listing 2 shows a simple transaction. The transaction demarcation code is external to the DAO class. Notice how the caller in this example combines multiple DAO operations within the transaction.

      tx.begin();    // start the transaction
      dao.createWarehouseProfile(profile);
      dao.updateWarehouseStatus(id1, status1);
      dao.updateWarehouseStatus(id2, status2);
      tx.commit();   // end the transaction

This transaction demarcation strategy is especially valuable for applications that need to access multiple DAOs in a single transaction.

You can implement transaction demarcation using either the JDBC API or the Java Transaction API (JTA). JDBC transaction demarcation is simpler than JTA transaction demarcation, but JTA provides greater flexibility. In the sections that follow we'll take a closer look at the mechanics of transaction demarcation.

Back to top

Transaction demarcation with JDBC

JDBC transactions are controlled using the Connection object. The JDBC Connection interface (java.sql.Connection) provides two transaction modes: auto-commit and manual commit. The java.sql.Connection offers the following methods for controlling transactions:

• public void setAutoCommit(boolean)
• public boolean getAutoCommit()
• public void commit()
• public void rollback()

Listing 3 shows how to demarcate a transaction using the JDBC API:

import java.sql.*;
import javax.sql.*;

// ...
DataSource ds = obtainDataSource();
Connection conn = ds.getConnection();
conn.setAutoCommit(false);
// ...
pstmt = conn.prepareStatement("UPDATE MOVIES ...");
pstmt.setString(1, "The Great Escape");
pstmt.executeUpdate();
// ...
conn.commit();
// ...

With JDBC transaction demarcation, you can combine multiple SQL statements into a single transaction. One of the drawbacks of JDBC transactions is that the transaction's scope is limited to a single database connection. A JDBC transaction cannot span multiple databases. Next, we'll see how transaction demarcation is done using JTA. Because JTA is not as widely known as JDBC, we'll start with an overview.

Back to top

Overview of JTA

The Java Transaction API (JTA) and its sibling, the Java Transaction Service (JTS), provide distributed transaction services for the J2EE platform. A distributed transaction involves a transaction manager and one or more resource managers. A resource manager is any kind of persistent datastore. The transaction manager is responsible for coordinating communication between all transaction participants. The relationship between the transaction manager and resource managers is shown in Figure 2:

JTA transactions are more powerful than JDBC transactions. While a JDBC transaction is limited to a single database connection, a JTA transaction can have multiple participants. Any one of the following Java platform components can participate in a JTA transaction:

• JDBC connections
• JDO PersistenceManager objects
• JMS queues
• JMS topics
• Enterprise JavaBeans
• A resource adapter that complies with the J2EE Connector Architecture specification

Back to top

Transaction demarcation with JTA

To demarcate a transaction with JTA, the application invokes methods on the javax.transaction.UserTransaction interface. Listing 4 shows a typical JNDI lookup for the UserTransaction object:

import javax.transaction.*;
import javax.naming.*;
// ...
InitialContext ctx = new InitialContext();
Object txObj = 
  ctx.lookup("java:comp/UserTransaction");
UserTransaction utx = (UserTransaction) txObj;

After the application has a reference to the UserTransaction object it may start the transaction, as shown in Listing 5:

utx.begin();
// ...
DataSource ds = obtainXADataSource();
Connection conn = ds.getConnection();
pstmt = conn.prepareStatement("UPDATE MOVIES ...");
pstmt.setString(1, "Spinal Tap");
pstmt.executeUpdate();
// ...
utx.commit();
// ...

When the application invokes commit(), the transaction manager uses a two-phase commit protocol to end the transaction.

JTA methods for transaction control

The javax.transaction.UserTransaction interface provides the following transaction control methods:

• public void begin()
• public void commit()
• public void rollback()
• public int getStatus()
• public void setRollbackOnly()
• public void setTransactionTimeout(int)

To start a transaction the application calls begin(). To end a transaction the application calls either commit() or rollback(). See Resources to learn more about transaction management with JTA.

Back to top

Using JTA and JDBC

Developers often use JDBC for low-level data operations in DAO classes. If you plan to demarcate transactions with JTA, you will need a JDBC driver that implements the javax.sql.XADataSource, javax.sql.XAConnection, and javax.sql.XAResource interfaces. A driver that implements these interfaces will be able to participate in JTA transactions. An XADataSource object is a factory for XAConnection objects. XAConnections are JDBC connections that participate in JTA transactions.

You will be required to set up the XADataSource using your application server's administrative tools. Consult the application server documentation and the JDBC driver documentation for specific instructions.

J2EE applications look up the data source using JNDI. Once the application has a reference to the data source object, it will call javax.sql.DataSource.getConnection() to obtain a connection to the database.

XA connections are different from non-XA connections. Always remember that XA connections are participating in a JTA transaction. This means that XA connections do not support JDBC's auto-commit feature. Also, the application must not invoke java.sql.Connection.commit() or java.sql.Connection.rollback() on an XA connection. Instead, the application should use UserTransaction.begin(), UserTransaction.commit(), and UserTransaction.rollback().

Back to top

Choosing the best approach

We've discussed how to demarcate transactions with both JDBC and JTA. Each approach has its advantages and you will need to decide which one is most appropriate for your application.

On many recent projects our team has built DAO classes using the JDBC API for transaction demarcation. These DAO classes can be summarized as follows:

• Transaction demarcation code is embedded inside the DAO class.
• The DAO class uses the JDBC API for transaction demarcation.
• The caller has no way to demarcate the transaction.
• Transaction scope is limited to a single JDBC Connection.

JDBC transactions are not always suitable for complex enterprise applications. If your transactions will span multiple DAOs or multiple databases the following implementation strategy may be more appropriate:

• Transactions are demarcated with JTA.
• Transaction demarcation code is separated from the DAO.
• The caller is responsible for demarcating the transaction.
• The DAO participates in a global transaction.

The JDBC approach is attractive due to its simplicity; the JTA approach offers greater flexibility. The implementation you choose will depend on the specific needs of your application.

Back to top

Logging and DAOs

A well-implemented DAO class will use logging to capture details about its run-time behavior. You may choose to log exceptions, configuration information, connection status, JDBC driver metadata, or query parameters. Logs are useful in all phases of development. I often examine application logs during development, during testing, and in production.

In this section, I'll present a code example that shows how to incorporate Jakarta Commons Logging into a DAO. Before we get to that, let's review a couple of basics.

Choosing a logging library

Many developers use a primitive form of logging: System.out.println and System.err.println. Println statements are quick and convenient but they do not offer the power of a full-featured logging system. Table 2 lists logging libraries for the Java platform:

Table 2. Logging libraries for the Java platform

java.util.logging is the standard API for the J2SE 1.4 platform. Most developers would agree, however, that Jakarta Log4j delivers greater functionality and more flexibility. One of the advantages of Log4j over java.util.logging is that it supports both the J2SE 1.3 and J2SE 1.4 platforms.

Jakarta Commons Logging can be used in conjunction with java.util.logging or Jakarta Log4j. Commons Logging is a logging abstraction layer that isolates your application from the underlying logging implementation. With Commons Logging, you can swap the underlying logging implementation by changing a configuration file. Commons Logging is used in Jakarta Struts 1.1 and Jakarta HttpClient 2.0.

A logging example

Listing 7 shows how to use Jakarta Commons Logging in a DAO class:

import org.apache.commons.logging.*;

class DocumentDAOImpl implements DocumentDAO
{
      static private final Log log = 
        LogFactory.getLog(DocumentDAOImpl.class);

      public void deleteDocument(String id)
      {
          // ...
          log.debug("deleting document: " + id);
          // ...
          try
          {
              // ... data operations ...
          }
          catch (SomeException ex)
          {
              log.error("Unable to 
                delete document", ex);
              // ... handle the exception ...
	}
      }
}

Logging is an essential part of any mission-critical application. If you encounter a failure in a DAO, logs often provide the best information for understanding what went wrong. Incorporating logging into your DAOs ensures you will be equipped for debugging and troubleshooting.

Back to top

Exception handling in DAOs

We've looked at transaction demarcation and logging and you now have a deeper understanding of how each applies to data access objects. Our third and final discussion point is exception handling. Following a few simple exception handling guidelines will make your DAOs easier to use, more robust, and more maintainable.

When implementing the DAO pattern, consider the following questions:

• Will methods in the DAO's public interface throw checked exceptions?
• If yes, what checked exceptions will be thrown?
• How will exceptions be handled within the DAO implementation class?

In the process of working with the DAO pattern, our team developed a set of guidelines for exception handling. Follow these guidelines to greatly improve your DAOs:

• DAO methods should throw meaningful exceptions.
  
  
• DAO methods should not throw java.lang.Exception. A java.lang.Exception is too generic. It does not convey any information about the underlying problem.
  
  
• DAO methods should not throw java.sql.SQLException. SQLException is a low-level JDBC exception. A DAO should strive to encapsulate JDBC rather than expose JDBC to the rest of the application.
  
  
• Methods in the DAO interface should throw checked exceptions only if the caller can reasonably be expected to handle the exception. If the caller won't be able to handle the exception in a meaningful way, consider throwing an unchecked (run-time) exception.
  
  
• If your data access code catches an exception, do not ignore it. DAOs that ignore caught exceptions are difficult to troubleshoot.
  
  
• Use chained exceptions to translate low-level exceptions into high-level ones.
  
  
• Consider defining standard DAO exception classes. The Spring Framework (see Resources) provides an excellent set of predefined DAO exception classes.

See Resources for more detailed information about exceptions and exception handling techniques.

Back to top

Implementation example: MovieDAO

MovieDAO is a DAO that demonstrates all of the techniques discussed in this article: transaction demarcation, logging, and exception handling. You will find the MovieDAO source in the Resources section. The code is divided into three packages:

• daoexamples.exception
• daoexamples.movie
• daoexamples.moviedemo

This implementation of the DAO pattern consists of the classes and interfaces shown below:

• daoexamples.movie.MovieDAOFactory
• daoexamples.movie.MovieDAO
• daoexamples.movie.MovieDAOImpl
• daoexamples.movie.MovieDAOImplJTA
• daoexamples.movie.Movie
• daoexamples.movie.MovieImpl
• daoexamples.movie.MovieNotFoundException
• daoexamples.movie.MovieUtil

The MovieDAO interface defines the DAO's data operations. The interface has five methods, as shown here:

• public Movie findMovieById(String id)
• public java.util.Collection findMoviesByYear(String year)
• public void deleteMovie(String id)
• public Movie createMovie(String rating, String year, String, title)
• public void updateMovie(String id, String rating, String year, String title)

The daoexamples.movie package contains two implementations of the MovieDAO interface. Each implementation uses a different approach to transaction demarcation, as shown in Table 3:

Table 3. MovieDAO implementations

MovieDAO demo application

The demo application is a servlet class called daoexamples.moviedemo.DemoServlet. DemoServlet uses both of the Movie DAOs to query and update movie data in a table.

The servlet demonstrates how to combine the JTA-aware MovieDAO and the Java Message Service in a single transaction, as shown in Listing 8.

UserTransaction utx = MovieUtil.getUserTransaction();
utx.begin();
batman = dao.createMovie("R",
  "2008",
  "Batman Reloaded");
publisher = new MessagePublisher();
publisher.publishTextMessage("I'll be back");
dao.updateMovie(topgun.getId(),
  "PG-13",
  topgun.getReleaseYear(),
  topgun.getTitle());
dao.deleteMovie(legallyblonde.getId());
utx.commit();

To run the demo application, configure an XA datasource and a non-XA datasource in your application server. Then, deploy the daoexamples.ear file. The application will run in any J2EE 1.3-compliant application server. See Resources to obtain the EAR file and source code.

Back to top

Conclusion

As this article has shown, implementing the DAO pattern entails more than just writing low-level data access code. You can start building better DAOs today by choosing a transaction demarcation strategy that is appropriate for your application, by incorporating logging in your DAO classes, and by following a few simple guidelines for exception handling.

Resources

• Download the MovieDAO source code at daoexamples.sourceforge.net
  
  
• Want to learn more about the Data Access Object pattern? Start with the Core J2EE Patterns home page.
  
  
• Kyle Brown's "A stepped approach to J2EE testing with SDAO" (developerWorks, March 2003) provides a short introduction to data access objects and the DAO design pattern.
  
  
• The Dragonslayer tutorial "Create persistent application data with Java Data Objects" (developerWorks, July 2003) shows you how to combine Struts and the DAO pattern for low-impact enterprise data persistence.
  
  
• Srikanth Shenoy's "Best practices in EJB exception handling" (developerWorks, May 2002) introduces both exception handling basics and logging with Log4j.
  
  
  
  
• The Java theory and practice series offers a three-part introduction to the Java Transaction API, starting with "Understanding JTS -- An introduction to transactions" (developerWorks, March 2002).
  
  
• The Java Transaction API is a key part of the J2EE platform.
  
  
• Jakarta Log4j is a world-class logging library for Java applications.
  
  
  
  
• Jakarta Commons Logging provides an easy-to-use logging abstraction layer.
  
  
• The Spring Framework provides abstraction layers for JDBC and transaction management. Additionally, the framework contains standardized DAO exception classes and JNDI helper classes.
  
  
• Rod Johnson's J2EE Design and Development (Wrox Press, 2002) belongs on every J2EE developer's bookshelf. The book is full of application design strategies, practical programming techniques, and real-world examples.
  
  
• Josh Bloch's Effective Java Programming Language Guide (Addison Wesley, 2001) presents best practices for exception handling and class library design.
  
  
• See the Java technology zone tutorials page for a complete listing of free Java technology tutorials from developerWorks.
  
  
• You'll find hundreds of articles about every aspect of Java programming in the developerWorks Java technology zone.
  

About the author

		Sean C. Sullivan is a software engineer working in Portland, Oregon. His most recent projects include building supply chain management applications and an Internet e-commerce payment system. He has also worked on operating system and CAD software projects at IBM and Image Systems Technology. Sean is an Apache Jakarta developer, having contributed code to the Jakarta HttpClient project. He has been developing applications with Java since 1996 and is the author of Programming with the Java Media Framework, published by John Wiley & Sons. Sean holds a BS in Computer Science from Rensselaer. He can be reached at dao-article@seansullivan.com.

Traceback: http://www.ibm.com/developerworks/library/j-dao/

Figure 1: The PORT command and parameters are visible in Sniffer's summary column.

Figure 2: Hex value 040F is equivalent to decimal value 1039.

About the Author:
Laura Chappell is the Sr. Protocol Analyst for the Protocol Analysis Institute. Laura focuses on researching, writing and lecturing on network analysis and security. In 2003, over 60 of Laura's courses become available via internet/CD and a series of "White Hat Toolbox: Security Tools, Tricks and Traces" are releasing at http://www.packet-level.com. Laura can be reached at lchappell@packet-level.com.

Traceback: http://www.securitypronews.com/it/networksystems/spn-21-20030917UnderstandingtheFTPPORTCommand.html

 1 ……
 2 <!--  filter 配置  -->
 3 < filter >
 4      <!--  filter 别名  -->
 5          < filter-name > encodingfilter </ filter-name >
 6          <!--  类文件位置  -->
 7          < filter-class > login3.EncodingFilter </ filter-class >
 8         
 9          <!--  定义属性encoding="gb2312" 即指定编码类型  -->
10          < init-param >
11              < desription > encode to gb2312 </ desription >
12              < param-name > encoding </ param-name >
13              < param-value > gb2312 </ param-value >
14          </ init-param >
15 </ filter >
16
17 <!--  filter 映射配置  -->
18 < filter-mapping >
19      <!--  定义该filter 处理所有格式的请求  -->
20      < filter-name > encodingfilter </ filter-name >
21      < url-pattern > /* </ url-pattern >
22 </ filter-mapping >
23 ……

         EncodingFilter.java

 1 import  java.io.IOException;
 2
 3 import  javax.servlet. * ;
 4 import  javax.servlet.http.HttpServlet;
 5
 6 public   class  EncodingFilter  extends  HttpServlet 
 7      implements  Filter  {
 8     
 9      private  FilterConfig filterConfig;
10     
11      private  String targetEncoding  =   null ;
12     
13      public   void  init(FilterConfig filterConfig)  throws  ServletException  {
14          this .filterConfig  =  filterConfig;
15          this .targetEncoding  =   this .filterConfig.getInitParameter( " encoding " );
16     }
17
18      public   void  doFilter(ServletRequest request, ServletResponse response,
19             FilterChain chain)  throws  IOException, ServletException  {
20          try   {
21             System.out.println( " targetEncoding : "   +  targetEncoding  +   " \n " );
22             request.setCharacterEncoding(targetEncoding);
23             chain.doFilter(request, response);
24         }   catch  (ServletException sx)  {
25             filterConfig.getServletContext().log(sx.getMessage());
26         }   catch  (IOException iox)  {
27             filterConfig.getServletContext().log(iox.getMessage());
28         }
29     }
30     
31      public   void  destroy()  {
32          this .filterConfig  =   null ;
33          this .targetEncoding  =   null ;
34     }     
35 }
36

2、Web容器编码
      在Tomcat的的源代码中的getParameter()方法，用户调用request.getParameter()方法时，首先调用parsetParameters()方法，在这里面将编码进行转换。如：
      String s_target = new String (s_source.getBytes("iso-8859-1"), "gb2312);

3、数据库
      MySQL中文问题的主要原因是：它对数据进行编码时，采用了和底层的操作系统所不同的编码。通常MySQL在中文Windows平台上正确的编码方式是GBK。因此只要将MySQL安装目录下的my.ini文件中的default-character-set选项设为GBK即可。

4、响应结果
      对于Servlet的代码处理，可以使用：
         ……
         respsonse.setContentType("text/html;charset=GB2312");
         ……
      对于JSP文件，可以在开头部分添加如下声明：
         ……
         <%@ page contentType="text/html;charset=GB2312" %>
         ……
      对于HTML页面文件，则在开头部分添加声明如下：
         ……
         <head>
            <META HTTP-EQUIV="Content-Type" CONTENT="text/html;charset=GB2312">
         </head>
         ……
5、XML文件
      在采用"UTF-8"方式编码的情况下，使用XML文件存储中文数据常常会出现乱码的问题，建议使用"GB2312"：
      <?xml version='1.0' encoding="GB2312"

Handler functions for single commands normally take no parameters. With the exception of update handler functions, handler functions for message-map ranges require an extra parameter, nID, of type UINT. This parameter is the first parameter. The extra parameter accommodates the extra command ID needed to specify which command the user actually chose. 

为了帮助和我一样不太懂英文的朋友，顶着头皮翻译了下：
单个命令（消息）的处理函数通常不带参数。但是更新处理函数、针对消息映射范围的处理函数需要一个额外的参数，一个UINT类型的nID。此参数是第一个参数，这个额外的参数收集了用来指定用户真正选择命令的命令ID。

Update handler functions for single commands normally take a single parameter, pCmdUI, of type CCmdUI*. Unlike handler functions, update handler functions for message-map ranges do not require an extra parameter, nID, of type UINT. The command ID, which is needed to specify which command the user actually chose, is found in the CCmdUI object.

Traceback: http://www.core.org.cn/OcwWeb/Writing-and-Humanistic-Studies/21W-783Science-and-Engineering-Writing-for-Phase-IIFall2002/StudyMaterials/detail/graphics.htm

System Requirements

Effective file hiding : Bypassing Raw File System I/O Rootkit Detector @ :: worthy ::     Apr 06 2007, 08:51 (UTC+0)

cardmagic writes: 0. Something else : After reading Hoglund's post, I finally decide to write this article. Actually in China, many smart rootkit/antirootkit writers have their own interesting materials,but unfortunately they are unable to publiish them becuase of various reasons(business contract,language barrier or even related to some secret organization). The main idea of this post comes to me when I designed DarkSpy, but after I finishing coding of the bus level file hider, it was discarded. Hopefully it will still be useful for some guys here:) Okay, now lets discuss the main topic : 1. Raw I/O based hidden file detection: This kind of file detection is used very commonly in modern detetors. such as DarkSpy/Icesword. The main idea for this detection method is to directly send I/O request packet to file system , so that detector will get the real view of system files. this is effective for hiding by native routine call hooking and file system filter driver. In addition, DarkSpy has added two great points into this(The second one makes DarkSpy's file detecion better than Icesword ^_^ ) a) Implement IofCallDriver itself,and directly call the original file system dispach routines, this will bypass hiding by the file system dispath routing hooking. b) Recover the whole file system file image in the memory before each I/O, this is against the hiding by inline code patching of file system dispatch routines. 2. The Bypassing theory: Here we will only discuss the real hider ( not file stream stuff),and we will describe the the bypassing theory with DarkSpy, because DarkSpy is very typical in raw I/O based file detectors.Let's look at basic flow of DarkSpy file detection first.    -----------------                   ---------------------    |   DarkSpy     |  <1> ---->recover | FILE SYSTEM IMAGE |    -----------------  <2>----->call--->|  dispatch code    |                       <2><-----return--|-------------------| From the figure above, we can see it's almost impossible to do something in file system, because DarkSpy has recoverred the whole image, even directly call the dispatch code without system routine's help. Now start changing our point of view and brainstorm, can we intercept the I/O processing besides file system? The answer is true, because file system will call many system routines. But we must pick an appropriate call that has the chance to reach the I/O content,which one will be the best? IofCallDriver maybe first come to your mind...but unfortunately DarkSpy has implemented it inside,because IofCallDriver is very easy to implement :) So we have to pick another choice which is a) hard to implement b) will be called by file system c) able to touch the I/O content which one will be the best ? Oh,yes, you got it, it's IofCompleteRequest. Okay... this is our idea... Through IofCompleteRequest code patching , check if we are called by file system,if yes, we will filter the I/O content. Thus,we will be sure to bypass all modern raw I/O based file detector. 3. The Main Code: Please check -- http://www.rootkit.com/vault/cardmagic/hidefile.c

(c) www.rootkit.com / http://www.rootkit.com/

TraceBack: http://rootkit.com/newsread_print.php?newsid=689

注：好牛的一篇文章哦！~  呵呵，真的需要调整自己的视角了：在计算机里面，不是所看到的东西就一定是真实的。

• In the partition table (MBR, sometimes referred to as a legacy-style partition) or in the LDM database (when dynamic disks are used).
• In the volume boot sector.

Three significantly different combinations are thus possible.

• Both partition table and volume boot sector provide consistent information about the filesystem type. This is how the things are supposed to be when the volume is online and operational.
• Only one of these places contains proper information, or the information is contradictory (e.g. partition table lists the volume as NTFS, while the boot sector indicates it is the FAT32).
• Neither partition table nor volume boot sector contain filesystem type information (the partition table will in this case indicate the special filesystem type of zero, i.e. unused volume). This can happen during normal operation and is pretty legal configuration state. It appears when you create a volume (e.g. using Disk Management applet) but do not format it at the same time. You can even assign a drive letter to this unformatted volume, as illustrated below (notice the underlined "H:" drive which has no filesystem type defined).

If the volume filesystem type information is unavailable, attempting CHKDSK against the volume will result in the following message:

The type of the filesystem is RAW.
CHKDSK is not available for RAW drives.

Sometimes, the volume fails in such a way that it becomes RAW. In most cases the failure will be associated with a sudden reboot (per power failure or the STOP error). Several causes are possible: partition table, LDM database, or the volume boot sector corruption, or (on the NTFS volume) when certain records in both MFT and MFT mirror are damaged beyond easy recognition.

	"RAW filesystem" recovery expectations
	The data recovery should not be complicated because the volume location info is still available. Be advised that some arbitrary filesystem type may be associated with the volume when you attempt to identify it amongst the list of the available volumes. Notice the highlighted volume - it is the same H: volume featured in the earlier screenshot. It has the correct size (128MB) and the correct on-disk location (starting at 200+40+40 = 280MB from the start of disk), but the filesystem type of "Large FAT16" is not a good bet because the volume is in fact NTFS - the filesystem type information in the LDM database got corrupt (yeah, I know because I did it in purpose). This fact will be later discovered by ZAR and the appropriate decision will be made to treat the volume as NTFS, and in this test case an exact recovery is ultimately achieved. In a real world case, the recovery expectations vary depending on the damage profile and locality. Overall, I'd expect a good yield. Exact recovery is possible if the damage is confined to the boot sector(s) and/or partition table (however there is no easy way to tell if it is). Suggested course of action is thus as usual: to download our data recovery tool (click here for a download page) and try it. Be sure to check this page as well. TraceBack: http://www.z-a-recovery.com/art-raw-filesystem.htm

注：今天本来想查点RAW FileSystem的资料，无意中找到这篇关于RAW FileSystem恢复的，还算得上是一篇资料文章哦，所以就转贴过来了！~

这里工具的版本是很重要的，呆会一点一点把它讲来，所以把全部环境都列出来了！~

1、data too long for column问题
问题描述：在MySQL下面输入select, insert等SQL语句，对于汉字均出现此种情况
    字段为char或varchar型，长度为255，绝对不会是真的字段长度不够的问题。请大家查看这篇贴子：http://blog.sina.com.cn/u/53b0d5dc0100097v，有此问题的详解。我后来的问题也基本上是在此篇基本上解决的。重要的是：--default-character-set=utf8参数

2、语句在MySQL CMD下面输入正确，但是在Java中执行同样的SQL语句，却无法工作。
问题描述：如果SQL语句中带中文的话，就会出现下面的异常，

下面是JOEL在规格说明书中都要给出的一些内容：

1、事先声明。这纯粹是出于自我保护目的。通常可以说：“该规格说明书还没有完成”。

2、作者。人们应该拥有他们说明的事物的责任权与所有权。如果规格说明书出了错，那么就应该有一个专门指派的规格说明书所有人，他的名字就印在规格说明书上，由他负责对规格说明书进行修订。

3、情节。反映你心目中设想的人们将如何使用产品的真实生活情节。这就是要放内容的地方。情节越生动越真实，那么你在为实际的或者虚构的用户设计产品时会做得越好。

4、非构建目标。其实就是不打算去做的事情，很可能就是产品将来没有的特性，确认“我们不打算去做”。

5、概观。规格说明书目录，使阅读者形成大体印象，让细节变得有意义。

6、细节，细节，细节。每一条细节都应该有处理细节的决定，规格明书需要以文档的形式描述出决定。

7、未尽事宜。对于规格说明书的第一个版本留下一些未尽事宜是允许的，这些需要描述出来以让程序员知道并在实现代码时进行考虑。

8、旁注。对于规格说明书，可能会有各种不同类型的读者，考虑那些仅仅对团体中的某一类人带来帮助的有用仿真陈述。

9、规格说明书需要保持时时更新的状态。随着产品的开发与新决定的做出，规格说明书的更新应该是不断地持续下去的。规格说明书总是反映我们大家针对产品将如何工作而纪念品出的最佳理解。

JOEL通常在服备器的某个位置保存一份当前版本，一般而言是用带有修订标记的规格说明书副本，而非是重新的规格说明书版本来让各位成员进行参考。

在这一节中例出了JOEL测试的12个步骤，个人觉得确实把一些标准软件测试的精华吸取进去了，却又抛弃了各类标准测试中的过于严格、限制灵活性的部分。当然这也如书中所说的，“Joel测试的不足之处，处是，确实不应该用它来保证核动力工厂软件是安全的”。作为个人来讲，应该把这些测试作为一种软件开发的习惯（当然，只是有些部分哦！~）。

在这里把比较精要的地方记录一下：
1、不使用源控制，程序员没有办法知道其他人员做了什么，所以不容易进行错误回滚。源控制系统的另外一个巧妙之处在于，可保证源代码在每个程序员的硬盘上都是经过自动确认了的。

2、从最新的源快照进行一次可分发的连编，需要多少个步骤？在一个优秀的团队通常会维护一个脚本，通过运行它，可以从头至尾地进行一次检查；重新编译每一个代码行；并按其不同的版本、语言以及条件编译语句#ifdef来生成EXE文件；创建安装包；并且生成最终的表现介质——CD-ROM、下载页面等。如果这样的过程需要多步才能完成，那么就很可能出错，并且越接近产品分发时刻，就越希望修复“最后故障”、形成最终EXE文件等操作所经历的周期会更短一些。JOEL指出不应该有20步。

3、无论谁中断了连编，都要负责修复连编操作，直到有别人中断连编过程为止。这是JOEL在Excel开发团队采用一种激励不要中断连编过程的机制，同时也让大家弄清楚连编是如何进行的。

4、故障信息数据库。一个可用的故障信息数据库必须至少为每个故障包含如下数据：重现故障的完整步骤、预期功能、观察到的（故障）行为、要分配谁、是否已修复。

5、发现故障到准备修复故障之间等待的时间越长，付出的代价（时间与金钱上）就越大。微软普遍采取了一种称之为零缺陷法（zero defects methodology）的措施。零缺陷意味着在任意给定时间点，最需要优先去做的事情是在写任何新的代码之前消除故障。这也可以是一个衡量进度表的标准：如果你已经修复了所有已经知道的故障，并且剩下的就是编写新代码，那么进度表就是极其准确的。

6、拥有一个好的进度表的优点：保证它始终反映最新的项目情况；迫使你做出将要实现什么功能的决定，然后强迫你拣出最不重要的功能，并加以剪除而不是陷入功能沼泽地带（也就是功能范围蔓延开来）。

7、“没有规格说明书就没有代码”。不是根据规格说明书开发出来的软件通常会因设计欠佳而停滞不前，从而使进度失去控制。

8、JOEL举了一个比较好的例子：Mutt记不住Unicode版本的strcpy函数的名字。他可以查询该函数，这要花费30秒钟的时间；他也可以询问Jeff，这得用去15秒钟的时间。既然紧靠Jeff坐着，他选择询问Jeff。不过，Jeff因此显得心烦意乱而丢掉了15分钟的产出（仅仅为了节省Mutt 15秒钟）。然而如果当Mutt去询问Jeff需要45秒钟的时间时，Mutt就会去选择自己去查询了。

9、可以显著地提高开发效率，同时程序员是容易通过给他们提供最棒最新的东西而得到满足的，这是一种远比通过支付极富竞争力的薪力来促使他们为你工作好得多的途径。

10、没有专门的测试人员，意味着要么分发充满故障的产品，要么通过让价值$100/小时的程序员去做那些能够让价值$30/小时的测试人员完成的工作。

11、一定要让应聘者编写一些代码。

12、走廊可用性测试指的是，在走廊里随便抓一个从身边走过的人，要他试着使用你所编写的代码。如果对5个人进行了这类测试，那么就可以了解隐藏在代码中的95%的可用性问题。

【内容简介】

【目录信息】

关联规则（association rule）挖掘技术用于发现数据库中属性之间的有趣联系。和传统的产生式规则不同，关联规则可以有一个或多个输出，同时一个规则的输出属性可以是另一个规则的输入属性。关联规则分析有时也叫购物篮分析，是因为它可以找寻出潜在的令人感兴趣的所有的产品组合。由此，有限数目的属性可能生成上百条规则。

关联规则的置信度、支持度和兴趣度：

缺点：
·当问题变大时，计算量增长得厉害。
·难以决定正确的数据。
·容易忽略稀有的数据。

【内容简介】

本书详细介绍了如何应用Lucene进行搜索引擎开发，通过学习本书，读者可以完成构建一个企业级的搜索引擎网站。.
全书共分为14章，内容包括搜索引擎与信息检索基础，Lucene入门实例，Lucene索引的建立，使用Lucene构建搜索，Lucene的排序，Lucene的分析器，对Word、Excel和PDF格式文档的解析，Compass搜索引擎框架，Lucene分布式和Google Search API，爬虫Heritrix，综合实例之准备篇，综合实例之HTMLParser篇，综合实例之DWR篇，综合实例之Web编。..
本书是国内第一本使用Lucene和Heritrix来讲解搜索引擎构建的书，通过详细的对API和源代码的分析，力求使读者在应用的基础上，能够深入其核心，自行扩展和开发相应组件，发挥想象力，开发出更具有创意的搜索引擎产品。本书适合Java程序员和从事计算机软件开发的其他编程人员阅读，同时也可以作为搜索引擎爱好者的入门书籍。
由于目前市面上从技术层面介绍搜索引擎的书并不多，即使有，也大多停留在理论阶段，而非搜索引擎的开发过程。因此，可以说本书是国内第一本详细介绍搜索引擎开发过程的图书。
（1）采用最新的Lucene 2.0。以前大家用的1.4.3版本，而最新的Lucene 2.0重写了很多API，内部的实现方法也有了很大优化。本书的代码都是在2.0版本下调试通过的，这样可以帮助读者了解Lucene的更多新功能。
（2）配有一个完整的搜索引擎案例。这个案例有很强的实用价值，只需稍加修改，就能应用于实际项目，市场价值在30000元以上！
（3）着重解决开发人员头痛的问题。本书的目的是指导项目实践，因此没有罗列各个API的用法，而是对常见的开发问题进行深入探讨，比如本书的第7章，是专门为解决“Word，Excel和PDF文件如何解析”这个问题而设置的。
（4）内容新颖，前卫实用。本书介绍了Compass、Heritrix、DWR和HTMLParser等内容。在搜索引擎开发的过程中，这些均为相当重要且实用的技术，笔者经过自身实践将它们展现给读者，希望能让读者在学习Lucene的同时开拓视野。
光盘特色：
配有一个完整的搜索引擎案例。这个案例有很强的实用价值，只需稍加修改，就能应用于实际项目，市场价值在30000元以上！...

[后注]：
   一直以来都对搜索引擎很有兴趣的，最近在学习JAVA，看到了Lucene，所以就找了一下，觉得这本书应该还可以的。只是苦于一直没有可靠的经济来源，所以再等一会，看能不能等到电子版哦。唉，这样子偷偷摸摸地好苦啊！

【内容简介】

本书由浅入深、循序渐进地介绍了JSP技术的知识体系、开发技巧以及相关的技术整合。全书共分31章，内容涵盖了JSP技术基础、JSP技术的相关开发技术（包括JavaBeans、文件操作、数据库操作、自定义标签库等技术）、JSP技术与其他技术的整合开发（如Web测试、Log4j、J2EE、Hibernate 等）。本书一个最大的特点就是它一切以JSP技术为中心，涉及面广，对使用JSP进行Web开发过程中涉及的技术都有介绍，对每项技术都做了比较详细的介绍并配有实例程序供读者理解，每个例子都具有很强的针对性，力求让读者通过自己动手做而掌握每项技术的要点，从而学习更多的知识。.
本书适合JSP/Java编程的初中级读者、JSP编程爱好者、Java开发人员以及高校相关专业师生学习使用。...

China-Pub网上书店：http://www.china-pub.com/computers/common/info.asp?id=353947

2、JSP应用开发详解

【内容简介】

本书结合JSP和Servlet的最新规范，从基本的语法和规范入手，以经验为后盾、以实用为目标，以实例为导向，以实践为指导，深入浅出地讲解了JSP开发中的种种问题。以精简的内容介绍了JSP的语法、Servlet技术、JDBC技术、标签库技术、表达式语言、Struts、JavaServer Face等技术；对于JSP开发中常遇到的典型的难点，专门设置了专题进行集中讨论。本书的最后一篇围绕一个电子商务网站，使用最新的表达式语言，创造性地以零Java代码介绍了各个模块的开发实现，并且提供完整的、可运行的实例。在讨论标签语言、表达式语言和Struts技术方面，本书具有独到之处。本书介绍的零Java代码电子商务网站的实现，可以作为非Java语言的JSP开发者最佳参考。随书附赠光盘内容为书中范例源代码。

China-Pub网上书店：http://www.china-pub.com/computers/common/info.asp?id=16176


[注]：
   虽然刚考完英语四级，而且可能也考得不怎么样，但是对于专业还是那么有兴趣哦。想早一点把这两本书看完，熟悉Servlet+JSP编程。

入门书似乎是技术含量低的代名词，实则不然，要写一本好的入门书其实是非常难的。比如说吧，笔者惊奇地发现，国内的作者居然近乎完全口口相传、人云亦云似地还在大讲特讲AWT图形组件，而对Swing要么根本不提，要么介绍非常简略，最后完全弄成喧宾夺主，对于这样的书，我们挑选时坚决枪毙之。毕竟，Swing在图形界面方面替代AWT，已经是1998年1.2发布时的陈年旧事了，7年过去了，我们的作者、老师还在教授读者使用实际项目中根本不可能使用的AWT图形组件，简直是可怕而又可悲的事情。要知道，国外讲AWT的书早已绝版多日了。

缘起 搞技术的人中，像笔者这样喜欢买书看书的，很有不少：同行朋友里家中技术书成山的大有人在。听说，国内互动出版网的五星级会员超过了一万，也可为此佐证。其中原因大部分应该拜我们从事的行业变化太快所赐——不读书，就有朽掉的危险。想来《中华读书报》中《电脑书城》这样的专刊，读者中除了出版界、图书发行界、图书馆界的朋友外，应该还有众多此道同人吧。

算起来，接触电脑，买电脑书，也有20来年历史了。从当年一书难求，到现在屡屡被书店中琳琅满目之势所眩晕，真是恍如隔世。从某种意义上来说，如今买书想要买对，也可以算是一种学问。这种情况下，别人的阅读经验和评论，就非常有意义了。不然，何以Amazon的书评模式会如此引人注目呢。

中国的评论传统，古已有之。月旦评、人物志在前，《文心》、《诗品》于后。而历代诗话、画论云云，可谓浩如烟海。书话之滥觞则始自近代阿英，此后成了非常流行的一种文体，近年来国内书业勃兴（有数字说每年新书就十数万种），更是为此推波助澜。

计算机图书方面的评论介绍性文字，在我们印象中，国外已有多年，比如赫赫有名的《Dr.Dobb sJournal》网上书评ERCB，1990年开始的ACCU书评，当然还有起自1995年的Amazon自由书评，如今已经成为图书方面最具影响力的一种媒体形式。国内早期得到广泛注意的书评性文字，应该是侯捷的《Windows程序设计好书》、《MFC4大天王》、《C /OOP大系》等“无责任书评”系列，陆续使不少原来国内知之甚少的好书开始为众人所瞩目，有许多人都由此开始重视技术图书的品牌与质量。此后，国内相关的网站、杂志都开始出现，书多，有价值的信息也越来越多，荣耀、孟岩等总结的《C程序设计之四书五经》、《C 程序设计之四书五经》等等是其中的代表。但大多数门类上还是徒叹阙如，许多普通读者面对书海，仍然无所适从。

说起这个专栏的缘起，完全是一种机会巧合。近年来移居海外后，能够比较没有障碍地接触到最新的图书资讯，视界迅速扩大，业余时间却增加了不少。偶然开始受人之邀帮忙选书、评书，又进而审书、译书，渐渐结识若干国内出版社的朋友，因此得以获悉不少出版界的行内故事，自己也慢慢生出些半个行内人的感觉。此后在网上再遇到初学者因为选书而手足无措时，开始忍不住好为人师，代为指点迷津一番。网上书店或者相关的技术论坛更逐渐成为笔得痛快臧否的良所。久而久之，小圈子里都知道我好发议论，朋友们开始送我一个外号——“嗜评狂”。

今年伊始，收到一位出版界朋友的建议，说《中华读书报》想开一个专栏，从中立的角度，按类别总结方式为读者和发行渠道推荐国内出版的好书，以促进技术书界优胜劣汰，形成良性循环。这无疑是一件有功的事业。作为行外人兼海外人，蹙而为此，心里本来颇为踌躇，但是得多位业界朋友鼓励，并惠允全面专业知识的协助，于是也就斗胆得令，小兵先行了。

名闻国内外读书界的“董氏二兄弟”中董鼎山先生有一本文集叫做《书·人·事》，本专栏名称即效此而来。笔者的意思，是不完全限于书本身，而是涉及书人、书事。但愿能够不辱使命。知我者，罪我者，欢迎发邮件到jch_liu@sohu.com交流沟通。

专栏开山第一篇，我挑当今最热门的语言Java作为主题，大概是最四平八稳，最无可争议的选择了吧。虽然Java的实际使用率应该还在C/C 之下，但是舆论似乎已经达成共识，Java才是明天的主宰。这不，Readex调查公司最近所做的一份开发人员调查显示，C/C 和Java在开发语言使用比例上的优势已经牢不可破，而且未来期望一项，Java占据了极大比例，C/C 以及VB都在明显下降。C 专家ThomasPlum也做过一个有趣的实验，使用正则表达式筛选网上招聘中的编程语言要求，结果Java以43%左右的比例仅略低于老资格的C ，排名第二，远超过了C、VB、.NET类语言。《SoftwareDevelopment》杂志最新的读者调查结果来看，Java和J2EE等相关技术人员的薪水已经稳稳高出同侪。

在学界，海外的大专院校几乎都已经清一色地以Java为默认教学语言，数据结构、操作系统乃至编译、图形学等等科目通通采用Java实现。连美国院校委员会（CollegeBoard）针对高中生的AP考试也用Java替换了原来的C 。也难怪高德纳（Knuth）的徒孙同时也是该委员开发主席的MarkWeiss（就是多本数据结构教材的那位作者）居然要写一本《C forJavaProgrammer》了。

Java的热门，也集中体现在出书上。与Java相关的图书所占比例，可能早已大过了技术本身的市场份额。近年来尤其如此。而且，从业内朋友提供的国内图书销售数据来看，Java图书的销售也早已经与VB、C/C 相较而有过之无不及了。

需要指出的是，Java本身与其他语言最大的不同，在于它既是一门语言，更是一个平台，相当于C ，C /CLI，VB.NET…… .NET平台。而且Java平台又分为J2SE（即所谓Core/DestopJava）、J2EE（Enterprise/ServerJava）和J2ME（Mobile/Wireless）三层，其实此外还有Jini，JXTA，JavaWebServices等无法因此归入以上类别的平台技术。加上Apache、JBoss等大旗下的开源Java技术和轻量企业级Java技术已成燎原之势，许多互相竞争的框架、产品、技术甚至开始与Sun公司官方方案争胜，笼统意义上的Java实际上已经成为一个大迷宫，发展方向也非常不确定，即使是许多专业Java开发人员也无法了解全豹了。

在这样的大背景下评价Java图书，其实是并不讨好的差事。因此，我们将内容分为三部分，本期仅讨论Java语言层次的综合类和入门图书。

综合/巨著

在国内，Stroustrup的《C 程序设计语言（特别版）》和《C Primer中文版》经常被人并称为C 两大巨著，记得当时出版社宣传中有“倚天屠龙”语，确为妙喻。其实，《C 编程思想》也处在同一等级别，尤其是加上后来出版的第二卷之后。

无独有偶，在Java世界里，同样也有并驾齐驱的巨著双璧：《Java编程思想》（第二版）BruceEckel著侯捷译机械工业出版社定价：99元

本书似乎毋需多言了，它在国内名气之大我早有耳闻：以99元的高价销售已经超过了50000册（侯捷网站数据），远远甩开了竞争对手，其盛势甚至超过了海外———其实在国外，本书与《Java核心技术》、Horton、Deitel的《Java程序设计教程》、vanLinden的《Java2教程》（英文名JustJava）都在伯仲之间，仅仅是略占优势而已。除Deitel的面向教材市场，售价超过90美元之外，其余的连定价都咬得很紧，无论篇幅多大，均在35美元上下，可见竞争之激烈。

本书的优点是对象优先，强调概念的理解，开放的模式带来了类似开源软件的群聚效果，有更多人帮助提高图书质量。第三版中对当代软件工程实践和工具（Ant、XP、Designbycontract）的融入，便于读者进入职业角色，也是大大高出一般编程书的地方，体现了Eckel仍身处开发社区中央的优势。当然，这些特点同时也带来了一些负面影响，那就是有些初学者尤其是缺乏基本编程知识的人由此入门可能会有困难。我的建议是，可以先选择一本纯粹的入门书，比如《Java语言导学》，再回头来通过本书打通任督二脉，增进功力。《Java2核心技术卷I：基础知识》（第6版）CayS.Horstmann,GaryCornell著程峰等译机械工业出版社定价：75元

听出版社的朋友说，这本书渐渐在国内有了追赶前书的势头。其实这一点并不奇怪。本书的作者均是从业界转入教职、有着丰富经验的大学教授，而且除本书外，均另有多部技术名著面世，写作经验也非常老辣：Horstmann写有直接与Deitel竞争的Java教材以及其他多部畅销的计算机科学教材，在Wiley出版；而Cornell是著名的VB、C 技术作家，同时还是近年来发展飞速并且收购了大量Wrox版权的技术图书出版社Apress的创始人。图书的技术审校有包括Java传奇人物JoshuaBloch等数十人，这样的阵容，威力可想而知。

由于叙述详细，编排方式近似于国内教材，本书已经逐渐成为许多读者受挫于《Java编程思想》之后的替代方案，而且颇有成效。但是作者的原意却是面向“有坚实编程语言基础的程序员”的，所以我建议完全不具备编程知识的读者还是需要另找一块敲门砖比较理想。本书更准确的定位Eckel自己在《Java编程思想》后面的资源清单中已经为我们说明了：“篇幅巨大，内容全面，我在寻找答案的时候第一个就会想到它。”当然，Eckel指的是本书的上下两卷。说到原书的卷II，作者和出版社显然有所失误，因为卷II的第6版从来就没有出版过。如今，两卷已经统一更新到了第七版。《Java程序设计教程》（第5版）H.M.Deitel著，施平安等译清华大学出版社定价：98元《Java编程语言》（第三版）KenArnold,JamesGosling著虞万融等译中国电力出版社定价：45元

国内图书中能够与前两巨著相提并论的，恐怕应该还是这两本了。Deitel的程序设计语言教材影响极大，类似于国内的谭浩强，综合而言至今仍然无人能敌。当然Deitel技术上绝无问题，业界实践也并不缺，只不过他完全用一个模板方便地不断重用于各个语言，多年不变，显得有些不思进取，而且套路性文字在正文中越来越多，有一厢情愿之嫌。这些与前两本书相比，都是有差距的。不过，如果忽略篇幅和定价因素外，Deitel倒是很好的入门书。我当年就是用他的C真正入门的，相比一些同事采用国内教材的痛苦回忆和后患无穷，高下立见。Gosling的这本书篇幅是四本中最小的，它容易让我们联想到Kernighan&Ritchie的《C程序设计语言》和Stroustrup的《C 程序设计语言（特别版）》。平心而论，此书的地位不如前二者，但是语言之父的凝练文字、严谨定义和书中不经意流露出来的思想，仍然弥足珍贵。本书不适合初学者入门，对于理清概念绝对是最佳读物。

入 门

入门书似乎是技术含量低的代名词，实则不然。要写一本好的入门书其实是非常难的，否则，当年Dryden出版社何以给哈佛的Mankiw（就是当今美国总统的经济顾问）彻头彻尾的一本入门书《经济学原理》拍出100万美元预付金？写入门书，你不仅需要具有高出所写内容层次许多的技术深度（这样才能在选择、把握材料时游刃有余），还要研究对象的学习心理，通常这意味着一定的教学经验。此外，对语言和叙述方式的要求也是最高的———高端技术书的读者大多能够宽容你文笔的干涩，而对于初学者，只要他读得费劲，你的其他优点将荡然无存。最后，你还将面临激烈的竞争，市场上可能有几十个形形色色的对手已经严阵以待。

同样，推荐入门书其实也是最难的。原因之一还是同类书太多，几乎每个参与竞争的相关出版社都不会轻易放过这一角逐，市场上此类书占总品种比例大概接近了40%。原因之二则是涉及面太广：初学者是金字塔之根基，而且今日之高手同样有初学记忆，你要是推荐得不中意，他们也会发表意见的，众口既然难调，难免不会众口铄金。

以上原因，促使得我们不得不谨慎从事。我们的解决办法，是设立如下评判标准：

1．内容选取须反映当前实际。这里并没有严格限定必须遵守最新标准。实际上也没有必要，至今尚没有见到国内有哪本书反映J2SE5.0（请读者注意，Ja鄄va平台的新版本已经从原来的1.5统一到5.0）的———本人正在翻译中的《Java核心技术》（第7版）可能会是比较早遵循5.0标准的作品。

2．内容选取应该基本符合J2SE范畴。记得TimO Reilly（出技术书非常出名的O Reilly公司的老板）曾经讥讽当时流行的Java傻瓜书和“21天/24小时/10分钟自学Java”一类的图书说，Java本身并不是那么简单的编程语言，纯粹为了炒作而做出多快好省的美妙承诺，这样的书、作者和出版商都是极不负责任的。的确，Java技术本身的复杂（虽然简单是Sun公司为其下的第一个修饰词），想用一本书讲清楚基本的入门内容：语言要素、面向对象概念、图形界面开发、事件处理、I/O、applet、异常与调试等等，控制篇幅都已经非常困难，哪里还能再奢谈其他？

3．翻译书的译校质量应该达到起码的要求。

4．市场上容易买到。这条标准其实很难完全量化，一个指标是调查公司所统计的实际销售数据（由出版界朋友提供），一个指标是国内主要技术图书网上书店的销售排名以及点击次数。综合起来，只要缺货并不严重即可。

有趣的是，这几条简单而明显的标准，衡量起当下的图书时，却成了巍巍其阿的分水岭：几乎所有国内的入门图书都被毫无借口好讲地直接淘汰出局了。第1条标准最具杀伤力，我惊奇地发现，国内的作者居然近乎完全口口相传、人云亦云似地还在大讲特讲AWT图形组件，而对Swing要么根本不提，要么介绍非常简略，最后完全弄成喧宾夺主，对于这样的书，则是坚决枪毙之。毕竟，Swing在图形界面方面替代AWT，已经是1998年1.2发布时的陈年旧事了，7年过去了，我们的作者、老师还在教授读者使用实际项目中根本不可能使用的AWT图形组件，简直是可怕而又可悲的事情。要知道，国外讲AWT的书早已绝版多日了。

第2条上出现的问题有的非常可笑，有几本书（销售成绩好像还很不错）居然在煞有其事地讨论JavaScript！而不少书本来篇幅就少得可怜，许多该讲到的远未讲透，却乐滋滋地干起了副业，在最后用几页篇幅讲JSP、Servlet或者EJB，让人哭笑不得。

而第3条上折损的也颇有不少，IvorHorton极富盛名的《BeginningJava2》先后几个版本《Java2入门经典》（1.2）（中国电力出版社）、《Java2编程指南》（1.3,1.4）（电子工业出版社）就都毁在翻译上。奇怪的是，最早的版本前几章还流畅可读，此外就完全有些乱来了。后面的版本居然将nativeAPI翻译成“自然API”，真不知道译者学的是什么专业。

那么，最后的幸存者有哪些呢？《Java语言导学》MaryCampione等著，马朝晖译机械工业出版社定价：39元

Sun公司官方推荐的Java语言初学教程，作者都是Sun公司内部的文档写作人员，所以文字和技术是绝对有保障的，中文翻译通顺可读。编排上，将ap鄄plet和集合等内容放入附录，也是避重就轻的合理之举，其实applet在实际项目中很少有使用的机会。常见问题也是一个很有特色的环节。不足的地方是图形组件部分太省，当然，这正好可以用《Java核心技术》等书进行弥补。《Java就业培训教程》张孝祥著清华大学出版社定价：39元

张孝祥此书颇有国人特色（比如字符乱码问题）、局部也很见功力（比如一些穿插在正文中的小经验、小难点解疑），能够看出作者下了不少功夫，有所积累。国内读者由此应该比较容易入门。问题出在图形组件部分，先讲述AWT事件处理模型本来很好，但是继而用两节篇幅讲述AWT，Swing却只有一节，就有些令人遗憾了。《21天学通Java2》 第三版 RogersCadenhead等著，袁国忠译人民邮电出版社定价：54元

本书属于许多人痛批的“21天学通系列”，其实内容不错，翻译也算中规中矩。所不足的地方，是作为敲门砖篇幅稍大，定价较高。如果删去RMI、联网、Servlet和JSP内容，也许更加合理。《Java2实用教程》HerbertSchildt著，马海军等译清华大学出版社定价：48元

实不相瞒，此书原版在国外是一本入门畅销书，作者名气很大，写书多年了，是Osborne的王牌作者。原文讲Swing很少，而且例子比较小儿科。中文译本还没有读过，不知如何，需要读者自己判断。

下次专栏，我们将继续谈谈国内出版的Java好书。

本文的上半部分发表以后，引起了一些读者的兴趣。有读者对我所说的“许多普通读者面对书海，仍然无所适从”大有同感，并且询问到具体如何选书买书的问题。其实，同样的问题在各种场合包括论坛、技术讲座上，我曾经无数次被问到，所以在继续介绍Java好书之前，我先花一点篇 幅说明一下。

关于选书的经验之谈

以我个人的经验来看，选中适用图书的关键，在于“知己知彼”。知己，当然就是对自己有正确的定位。拿Java来说，你在购买第一本Java图书之前，需要确定自己处于什么层次。如果编程经验较少，对基本的程序设计语言概念都知之甚少的话，《Java核心技术》或者《Java编程思想》就不太合适了，这一层次的巨著都在书的最前面明确说明读者需要“一定的编程经验”，而《Java语言导学》、《21天学通Java2》可能是你的正确选择。如果你学习过其他程序设计语言，了解“关键字”、“函数”、“数据类型”等等基本概念，但是对面向对象完全是门外汉，那么《Java编程思想》是一个很好的起点，它是典型的对象优先（ObjectFirst）教学法的代表。如果你已经是有一定经验的C/C 程序员，《Ja鄄va核心技术》显然最适合你，因为书中有许多专门针对C/C 程序员的提示，而且循着“环境·语言结构·面向对象”顺序讲解。其余类别的图书也可以按照这种思路选择。

此外，我有一个特别的建议：如果你的英文不错，建议入门的时候以英文版为主，辅以一本中文基础教材，尤其是面向对象的概念方面，英文直接阅读理解，往往比中文更加容易。因为面向对象概念其实涉及语言和知识表示中较深层次，恰恰是不同语言区别较大，不容易移译的地方。加之国内早期翻译不够审慎，而且统一性不足，使用中文术语体系理解，有时候反而事倍功半。就以“面向对象”一词来说，新手对此是很难望文而生义的，这是典型的不良翻译范例。曾经有一个比较夸张的笑话，说有人将《面向对象方法》当成谈恋爱技巧书买了回去，其实正说中了此译的弊病。相对而言，海外译为“物件导向”，要更接近原意。这里的对象＝object，就是中文的物体、事物乃至事情，所以《Ja鄄va编程思想》有“万事万物皆对象”（ev鄄erthingisanobject）的说法。而这里的面向＝oriented，其实是“以……为重点/中心”、“（此方法/领域中）……很重要”的意思。所以面向对象＝object oriented的英文原意，其实是“以事物表示为中心”之义。时至今日，专业人士当然不再可能有出上述笑话的可能，大家反而已经习惯这一术语体系，并且母语化了。但是学习面向对象技术的新手呢，他们仍然免不了在“类”、“类型”、“接口”、“实例”、“成员”、“方法”、“实现”、“协定”、“字段”、“属性”、“服务”、“消息”……构成的语词森林中筚路蓝缕。从这一点来说，国内高等院校开始双语教学，是有其益处的。

正确选书的第二个重要环节就是知彼了，也即尽量多地了解相关图书信息。遗憾的是，目前国内客观而且有内容的书评类资料非常缺乏，出版社提供的信息又往往公信力不够。本专栏的目的之一，就是尝试对此情况有所补益。当然，普通读者的获知手段并非没有。第一手的信息，包括出版社、作译者的情况，出版前言、作译序、图书外装帧的介绍文字和设计水平都能透露制作者在此书上花费的功夫几何。前言和序纯属八股文字的图书，作译者用心程度就非常值得怀疑。此外，国内各主要专业网上书店（china pub.com，第二书店，华储等等）都有类似Amazon的自由书评以及各种销售排行榜（不少实体书店也会提供销售排行榜），虽然成色远较Amazon为逊色，但还是很值得参考的，毕竟这些都反映着客观因素。尤其是china pub上外版书有直接到Amazon该书原文版的链接，可以很方便地了解原版的评价，然后考虑翻译质量，即可八九不离十了。本报定期刊登的各出版社“销售热点”、“书店经理荐书榜”等等栏目也是图书情况的重要参考。至少，你可以了解到某种、某类书市场上哪些销售良好，哪些是出版社的重点产品。

老实说，目前选书买书的确不是易事。撰写本文过程中，我所查询到的Java图书不下六七百种，但是真正值得评论的却在30种以内。看来，国内出版界离正确的方向还有不小的差距。

继续我们的Java图书盛宴。在综合和入门层次图书之后，我们已经更上一层楼，可以看到更广阔的Java世界图景。首先进入我们视野的是语言编程经验和深入层次图书，面向中级读者。正如著名程序设计专家Sun公司杰出工程师GuySteele所说：“对于一门程序设计语言，你需要了解三样东西：一是语言核心，即语法结构；二是语言的词汇，包括所提供的数据结构和功能设施；三是语言的习惯用法。”一般的程序设计图书只会涉及到前面两点，而要讨论第三点，往往需要作者有大量的代码开发和阅读经验，难度极大，所以，这一层次目前国内市场上所见图书，基本上都是国外翻译作品。

曾几何时，国外的Java图书出现过三大系列鼎足而立的态势。这就是Pearson集团旗下的Prentice Hall和Addison Wesley与Sun公司合作推出的Sun Press Java系列，Wrox公司的Java系列和O'Reilly公司的Java系列。比较而言，前者虽然来自技术本原，又汇集原来两个系列的实力，权威性毋庸置疑，但是总体

上技术文档气息比较重，各书之间就写作水平和易读性来看很不均衡，既有《Java核心技术》、《Effective Java》、《Java编程语言》这样的超级经典，又有大量平平之作。后者的规划最为严密，丛书的平均水平也最整齐，经过多年积累，已经出版了70多种，几乎囊括了Java技术的方方面面：语言学习（以《Head First Java》和《Java in a Nutshell》为代表）、技术专题（以《Java网络编程》、《Java与XML》、《Java Swing》、《Java Server Pages》为代表）、工具（《Eclipse》、《Ant权威指南》为代表）、企业级开发（以《Enterprise JavaBeans》为代表）和实例（《Java经典实例》为代表）。而Wrox则是盛极后衰的典型，2001年前后，印着作者头像大多名为“Beginning”和“Professional”的红皮书与O Reilly一一针锋相对，不但出手奇快，而且内容涵盖全面扎实，博得好评一片，声势一度压过了后者，这其中以Ivar Horton的《Java入门经典》、《J2EE高级编程》、《Expert One-on-One J2EE Design and Development》为代表。可遗憾的是，此后不久Wrox就由于整个集团在.NET和Java乃至图形图像、网站设计等等多面作战，战线过长，管理又失控，终于以被收购而告终。其品牌和大部分图书归入John Wiley所有，也就是说，现在新的红皮书都是这家有近200年历史的公司旗下出品。另外有部分图书则被开发类图书的新锐Apress购买，改用该出版社的封面。两家目前同时出版“Beginning”冠名的图书，但是原“Professional”系列Apress改用“Pro”以示区分。

　　这三大主流系列之外，还有小型的Manning出版社不可不提。Manning本来也覆盖各种开发语言和工具，甚至包括其他出版社很少涉及的PowerBuilder，但是2003年后，几乎完全转向了Java平台，与Java开发社区的结合度大概是最紧的———theServerSide网站上就频繁出现该出版社的图书预览评论。为了避免与大中型竞争对手正面冲突，Manning选择了更加专业和前沿的小众领域，并精益求精，取得了极佳的口碑。在Struts、Hibernate、JUnit、Ant等方面都有最具竞争力的图书。

　　虽然本文已经进入最后部分，但是从所涉及的Java领域来看，只能说是刚刚开了一个头———仅仅评完了语言层面的图书而已。不难发现，目前国内市场上值得关注的引进图书，几乎都不出以上四家，当然，近来国产图书也开始有了一些佳作。接下来，让我们一起尽览Java图书大观园秀色。

工具书

　　Java是一种简单但是又复杂的语言。说它简单，是指相对C 等前辈而言，许多功能语言能够直接提供支持，大大减少了开发工作量；说它复杂，是指Java语言和平台提供的功能极为丰富，短时间很难掌握。时至今日，发展到5.0的Java，光是API的数量就已经是一个惊人的数字，就更不用说其中细节了。Sun公司的API文档当然帮得上忙，但是对于经验不够以及英文不好的人，无法完全解决问题。这种情况下，可供查阅的工具书就非常必要了。

　　JAVA技术手册（第4版）（影印版）
　　David Flanagan／著
　　清华大学出版社　定价：99元

　　说起Java工具书，首屈一指的当然是Flanagan的传奇大作了。此书与《Unix技术手册》、《Linux技术手册》并称O'Reilly Nutshell（坚果）系列的三大手册，是该公司早期得以称雄技术出版领域的大功臣，与Java的版本保持同步。言简意赅的叙述和丰富的索引是其招牌特征。此书中没有涉及AWT、Swing以及J2EE的内容，系列中另有两本书专门讲述。需要警告大家的是，第4版是此书最不好的一个版本，最明显的缺点就是书中切口处没有印上类似于字典的曾经是Nutshell手册特色的分隔标签。每章开始处的包关系图也没了。国内中国电力出版社还出版过此书第三版的中文版，但是翻译颇受诟病。国外此书的第五版已经出版，又迅速攀升到畅销榜前列。

　　JAVA Developers ALMANAC 中文版：实例与快速参考（第1.4版　第1卷）
　　Patrick Chan／著　王卫星等／译
　　机械工业出版社　定价：99元

　　作者作为Java创始小组的主力成员，曾是负责可移植性和Windows平台的架构师，也是AWT的设计者之一。显然，在版式设计方面，他也颇有天赋。本书在形式和体例设计上花费的心思比《Java技术手册》可以说是有过之而无不及，因此多年来极受Java程序员青睐。其结果，是一本非常实用参考书，除按字母逐一讲解API之外，还有极为丰富的实例，实例有网络版，查询更加方便。本书有些网上书店有特价销售，30元左右，可谓大大的物超所值。此书本还有第2卷，讨论applet和Swing，但是没有中文版。清华大学出版社影印了两卷，可以参考。

以下我们真正超越基本语言的层面，进入更广阔的天地。迎面而来的是开发客户端程序必不可少的GUI技术，也就是Swing。由于Java在桌面方面的开发还没有成为主流，我们在这里只是浅尝辄止。

　　Java Swing（第二版）
　　Marc Loy,Robert　Eckstein等／著　R&W组／译
　　清华大学出版社　定价：128.00元

　　Swing方面的书目前只能推荐这一本了。很抱歉，书很厚，价钱也是个问题。但是权威性还是有口碑的，翻译也不错。而如此篇幅却仍然会漏掉一些重要内容，Swing的琐细可以想见了。比较多被人提到的明显遗漏包括AWT事件模型和一些布局管理器。

　　国外共有三本比较重要的Swing图书，除本书外，还有Manning所出的一本，也是近900页的巨著，在我印象中似乎没有中文版本。SunPressJava系列中也有一本《JFCSWING标准教材（第二版）》，略薄一些，有中文译本（电子工业出版社），但是翻译不能令人满意，就不予推荐了。

　　接下来我们进入企业级Java的技术迷宫。这是目前炙手可热的领域。然而奇怪得很，如此复杂、内涵丰富、大有文章可做的宝库，国内值得推荐图书的数量和质量却难以与之相符。

J2EE综述： __________________________________________________________________________

　　The J2EE Tutorial中文版
　　Stephanie Bodoff等／著　颜承等／译
　　中国铁道出版社　定价：47元

　　网站上常常有读者询问J2EE该如何入门，从哪一本书入门的问题，令人遗憾的是，目前这个问题并没有直截了当的答案。因为在J2EE 1.5（估计Sun会统一为5.0）尤其是EJB3.0定案之前，J2EE的整个发展方向都并不明确。至少目前，放弃EJB的重量级方案而选用Hibernate、Spring之类的轻型框架正在成为热点。

　　本书的好处在于，它直接来自Sun公司，是对J2EE最四平八稳的介绍。书中的主干还是对EJB的介绍，对其他方面包括Web层技术的介绍都比较简略。由于篇幅所限，通过本书，你只能对J2EE有一个大概的初步印象，真正能够达到实战水平，道路还很漫长。顺带提及，本书的新版本（针对1.4）《J2EE1.4标准教材》已经由电子工业出版社出版，其中增加的部分大多与XML、Web服务和JSP方面的更新以及JSF相关，这正是J2EE1.3到1.4的主要更新。不过新版本已经厚达1000页以上，定价100元，就性价比而言似乎不是那么尽如人愿。

Web层： __________________________________________________________________________

　　Servlet与JSP核心编程，卷1（第2版）
　　Marty Hall，Larry Brown／著　赵学良／译
　　清华大学出版社　定价：59元

　　按照一般的学习地图，从语言到企业级Java最好的路径就是JSP和Servlet。事实上，如果你没有机会参与大型软件系统的开发，J2EE中最常用也最实用的也就是Web层技术，开发动态网站等等应用，即使中小企业也都用得上。历史上，Servlet和JSP大多是分别讲述的，O'Reilly和Wrox等等出版社都是如此。然而，这两项技术不仅本质相同（最终都要转换为Servlet，再进行编译），而且在应用中关系极为密切。因此，MartyHall将两者结合讲解看似独辟蹊径，实则更加贴近开发实践。从我个人的经验来看，这样做是绝对正确的，也正是这样的处理，使本书得以鹤立鸡群。

　　本书原著和译笔都非常流畅，讲述技术细节体贴周到。作者在阐释概念方面有独到之处，常常三言两语就能说清其他书中长篇大论也说不清的东西。书中对Servlet和JSP两项技术区别和如何集成的叙述就极精彩。Amazon上本书的读者评论就达到200多条，受欢迎程度可见一斑。

　　本书的第2卷尚未出版，从内容上看应该是在机械工业出版社已经出版的《Servlet与JSP权威指南》（即《More Servlet sand JSP》中文版）一书基础上的更新和扩充，将涵盖Struts、JSTL、JSF等内容。

　　JSP设计（第三版）
　　Hans Bergsten／著　林琪　朱涛江／译
　　中国电力出版社　定价：79元

　　由于不断保持更新，在单独讲JSP的引进图书中本书已经稳坐头把交椅。值得称道的是，这一版的翻译工作有较大提高。作者的专家身份（JSP和Servlet规范专家组成员）自然保证了内容的权威性。为了覆盖更广的读者群，尤其是网页设计人员，书中不少内容起点很低，比如在讲解中可能很详细地解释一些编程基础知识。这种处理显然是一把双刃剑，有经验的程序员对此很容易不耐烦，事实上网上对此书不利的评价大多也是由此而引起的。在我看来，想让一本JSP技术书籍既满足网页设计人员，又满足软件开发人员几乎是不可能完成的任务，还是“分而治之”符合计算机科学原理。

　　精通Struts：基于MVC的Java Web设计与开发
　　孙卫琴／著
　　电子工业出版社　定价：49元

　　Tomcat与Java Web开发技术详解
　　孙卫琴　李洪成／著
　　电子工业出版社　定价：45元

　　这两本书是2004年国内原创图书中的惊喜。以如此专业的图书而获得一致好评和空前的市场成功（《精通Struts》一书2004年8月出版，到2005年2月已经是第5次印刷，而且仍然印刷了5000册，出版界的朋友告诉我，由此判断此书销售应该已经超过25000册，在今日的市场中如此销量，确属惊人），其含义是非常丰富的：一方面说明技术图书市场其实并没有大多数人眼中的那么悲观，一方面说明Java技术目前在国内的热度确实非常。

　　关于这两本书，一位读者的评价非常中肯：“优点并不在于它提出了多少有突破性、发明性的思想，但它作为技术传播工具，能够把技术分析得非常清晰细致，举的各种Web应用实例循序渐进，恰到好处。”也许恰到好处，贴切符合国人需要，才是原创图书成功的必由之路。

EJB层：__________________________________________________________________________

　　精通EJB（第二版）
　　Ed Roman／著　刘晓华／译
　　电子工业出版社　定价：59元

　　精通EJB（第二版）
　　Ed Roman／著　刘晓华／译
　　电子工业出版社　定价：59元

　　毫无疑问，按Sun公司的本意，EJB应该是J2EE架构中真正的核心。然而，令人尴尬的是，国内已经出版的讲述E鄄JB的图书中，居然挑不出一本完全合格的教程类图书可以推荐。本书原版非常有名，问题又出在翻译上：后半部分许多地方质量差得惊人。好在原作者公开了原版电子文件，读者能够一边看，一边改，一边骂了。

　　此书手稿中的一部分最后演变成了另一本书《EJB设计模式》，已由机械工业出版社出版，属于经验总结性的读物，应该配合阅读。

经验T深入T模式：

__________________________________________________________________________

　　J2EE设计开发编程指南
　　Rod Johnson／著　魏海萍／译
　　电子工业出版社　定价：64元

__________________________________________________________________________

　　J2EE设计开发编程指南
　　Rod Johnson／著　魏海萍／译
　　电子工业出版社　定价：64元

　　如果J2EE方面只允许推荐一本书的话，此书的英文版会是很多人的选择。Johnson所提出的EJB并不是万灵丹药，以及对何时使用EJB，不使用EJB时的替代方案等等，在当时可以说是振聋发聩，惊醒了许多人。从书中发展出来的Spring框架如今已经成为J2EE轻量级运动的重要一员。让人痛心的是，这本书中文版翻译得惨不忍睹。就凭将Johnson著作无情糟蹋掉这一点，这位译者已经得罪了整个J2EE社区。电子工业出版社在Java技术方面，尤其是J2EE方面出书很多，但是在某些方面（比如说翻译）常常很难令人满意，也许应该好好总结一下了。至少，本书的价值到今天仍然不减，Amazon上的排名保持在3000左右，仍然是最畅销的Java类图书之一，为什么不考虑一下重新翻译，利人利己呢？

　　J2EE核心模式
　　Deepak Alur等／著　牛志奇等／译
　　机械工业出版社　定价：35元

　　J2EE领域本书与上一本齐名，汇集了Sun公司和客户大量经验，是J2EE架构师必读书。糟糕的是，本书的翻译也是问题多多，只能说比上一本稍好一些。科学出版社出版了影印版，可以参考。

　　不过也有好消息，此书已经有了第二版，而且中文版由长期担任本报特约记者的青年才俊担纲翻译，不日就将由机械工业出版社出版。想来这次该有满意的结果。

其　他

　　最后是几本没有归入前面的类别，然而我本人认为比较重要的好书。

　　JAVA与模式
　　阎宏
　　电子工业出版社　定价：88元 　　

　　本书显然也创造了一个奇迹，高定价仍然畅销并且常销，为原创图书树立了很好的榜样。讲述模式的好书已经很多，但是专门结合Java讲述的，目前应该还是以此本最佳。

　　JAVA实用系统开发指南
　　彭晨阳
　　机械工业出版社　定价：42元

　　本书是一本实例驱动的教程，虽然有些设计和代码不够成熟，但以原创标准衡量，已经难能可贵。书中比较详细地介绍了设计思路，并兼顾地介绍相关模式和技术，是一种很好的写作模式。

　　Java与XML（第二版）
　　Brett McLaugblin／著　刘基诚／译
　　中国电力出版社　定价：59元

　　举贤不避亲。此书正是本人所译。由于J2EE1.4中增加了大量处理XML以及Web服务的内容，此书的重要性大大提升。翻译中在语言的平顺上下了不少功夫，总体还算满意。不过编辑校对上的小失误较多，有一些遗憾。

　　我们的Java图书之旅已经到站。虽然已经尽力，但是限于篇幅、眼力和阅历，肯定无法反映全貌，批评与意见，请给我们发邮件：jch-liu@sohu.com。

[后注]：
本文中推荐的书籍：
赫赫有名的《Dr.Dobb sJournal》网上书评ERCB
1990年开始的ACCU书评
起自1995年的Amazon自由书评

侯捷的《Windows程序设计好书》、《MFC4大天王》、《C /OOP大系》等“无责任书评”系列

Stroustrup的《C 程序设计语言（特别版）》和《C Primer中文版》

《Java编程思想》（第二版）BruceEckel著侯捷译机械工业出版社定价：99元
《Java核心技术》 35美元上下
Horton、Deitel的《Java程序设计教程》 90美元
vanLinden的《Java2教程》（英文名JustJava） 35美元上下
《Java2核心技术卷I：基础知识》（第6版）CayS.Horstmann,GaryCornell著 程峰等译 机械工业出版社定价：75元
《Java编程语言》（第三版）KenArnold,JamesGosling著 虞万融等译 中国电力出版社定价：45元

入门：
《Java语言导学》MaryCampione等著 马朝晖译 机械工业出版社定价：39元
《Java就业培训教程》张孝祥著 清华大学出版社定价：39元

《Java核心技术》、《Effective Java》、《Java编程语言》 超级经典

工具书：
　　JAVA Developers ALMANAC 中文版：实例与快速参考（第1.4版　第1卷）
　　Patrick Chan／著　王卫星等／译
　　机械工业出版社　定价：99元

J2EE：
　　Servlet与JSP核心编程，卷1（第2版）
　　Marty Hall，Larry Brown／著　赵学良／译
　　清华大学出版社　定价：59元

　　Servlet与JSP核心编程，卷1（第2版）
　　Marty Hall，Larry Brown／著　赵学良／译
　　清华大学出版社　定价：59元

　　精通Struts：基于MVC的Java Web设计与开发
　　孙卫琴／著
　　电子工业出版社　定价：49元

　　Tomcat与Java Web开发技术详解
　　孙卫琴　李洪成／著
　　电子工业出版社　定价：45元

　　精通EJB（第二版）
　　Ed Roman／著　刘晓华／译
　　电子工业出版社　定价：59元

　　J2EE设计开发编程指南
　　Rod Johnson／著　魏海萍／译
　　电子工业出版社　定价：64元

　　J2EE核心模式
　　Deepak Alur等／著　牛志奇等／译
　　机械工业出版社　定价：35元 
　　J2EE架构师必读书

　　JAVA与模式
　　阎宏
　　电子工业出版社　定价：88元 　　

　　JAVA实用系统开发指南
　　彭晨阳
　　机械工业出版社　定价：42元

据我自己的实践，这种说法确实成立。然而，我也发现许多关于速度的怀疑都来自一些早期的实现方式。由于这些方式并非特别有效，所以没有一个模型可供参考，不能解释Java速度快的原因。

我之所以想到速度，部分原因是由于C++模型。C++将自己的主要精力放在编译期间“静态”发生的所有事情上，所以程序的运行期版本非常短小和快速。C++也直接建立在C模型的基础上（主要为了向后兼容），但有时仅仅由于它在C中能按特定的方式工作，所以也是C++中最方便的一种方法。最重要的一种情况是C和C++对内存的管理方式，它是某些人觉得Java速度肯定慢的重要依据：在Java中，所有对象都必须在内存“堆”里创建。

而在C++中，对象是在堆栈中创建的。这样可达到更快的速度，因为当我们进入一个特定的作用域时，堆栈指针会向下移动一个单位，为那个作用域内创建的、以堆栈为基础的所有对象分配存储空间。而当我们离开作用域的时候（调用完毕所有局部构建器后），堆栈指针会向上移动一个单位。然而，在C++里创建“内存堆”（Heap）对象通常会慢得多，因为它建立在C的内存堆基础上。这种内存堆实际是一个大的内存池，要求必须进行再循环（再生）。在C++里调用delete以后，释放的内存会在堆里留下一个洞，所以再调用new的时候，存储分配机制必须进行某种形式的搜索，使对象的存储与堆内任何现成的洞相配，否则就会很快用光堆的存储空间。之所以内存堆的分配会在C++里对性能造成如此重大的性能影响，对可用内存的搜索正是一个重要的原因。所以创建基于堆栈的对象要快得多。

同样地，由于C++如此多的工作都在编译期间进行，所以必须考虑这方面的因素。但在Java的某些地方，事情的发生却要显得“动态”得多，它会改变模型。创建对象的时候，垃圾收集器的使用对于提高对象创建的速度产生了显著的影响。从表面上看，这种说法似乎有些奇怪——存储空间的释放会对存储空间的分配造成影响，但它正是JVM采取的重要手段之一，这意味着在Java中为堆对象分配存储空间几乎能达到与C++中在堆栈里创建存储空间一样快的速度。

可将C++的堆（以及更慢的Java堆）想象成一个庭院，每个对象都拥有自己的一块地皮。在以后的某个时间，这种“不动产”会被抛弃，而且必须再生。但在某些JVM里，Java堆的工作方式却是颇有不同的。它更象一条传送带：每次分配了一个新对象后，都会朝前移动。这意味着对象存储空间的分配可以达到非常快的速度。“堆指针”简单地向前移至处女地，所以它与C++的堆栈分配方式几乎是完全相同的（当然，在数据记录上会多花一些开销，但要比搜索存储空间快多了）。

现在，大家可能注意到了堆事实并非一条传送带。如按那种方式对待它，最终就要求进行大量的页交换（这对性能的发挥会产生巨大干扰），这样终究会用光内存，出现内存分页错误。所以这儿必须采取一个技巧，那就是著名的“垃圾收集器”。它在收集“垃圾”的同时，也负责压缩堆里的所有对象，将“堆指针”移至尽可能靠近传送带开头的地方，远离发生（内存）分页错误的地点。垃圾收集器会重新安排所有东西，使其成为一个高速、无限自由的堆模型，同时游刃有余地分配存储空间。

为真正掌握它的工作原理，我们首先需要理解不同垃圾收集器（GC）采取的工作方案。一种简单、但速度较慢的GC技术是引用计数。这意味着每个对象都包含了一个引用计数器。每当一个句柄同一个对象连接起来时，引用计数器就会增值。每当一个句柄超出自己的作用域，或者设为null时，引用计数就会减值。这样一来，只要程序处于运行状态，就需要连续进行引用计数管理——尽管这种管理本身的开销比较少。垃圾收集器会在整个对象列表中移动巡视，一旦它发现其中一个引用计数成为0，就释放它占据的存储空间。但这样做也有一个缺点：若对象相互之间进行循环引用，那么即使引用计数不是0，仍有可能属于应收掉的“垃圾”。为了找出这种自引用的组，要求垃圾收集器进行大量额外的工作。引用计数属于垃圾收集的一种类型，但它看起来并不适合在所有JVM方案中采用。

在速度更快的方案里，垃圾收集并不建立在引用计数的基础上。相反，它们基于这样一个原理：所有非死锁的对象最终都肯定能回溯至一个句柄，该句柄要么存在于堆栈中，要么存在于静态存储空间。这个回溯链可能经历了几层对象。所以，如果从堆栈和静态存储区域开始，并经历所有句柄，就能找出所有活动的对象。对于自己找到的每个句柄，都必须跟踪到它指向的那个对象，然后跟随那个对象中的所有句柄，“跟踪追击”到它们指向的对象……等等，直到遍历了从堆栈或静态存储区域中的句柄发起的整个链接网路为止。中途移经的每个对象都必须仍处于活动状态。注意对于那些特殊的自引用组，并不会出现前述的问题。由于它们根本找不到，所以会自动当作垃圾处理。

在这里阐述的方法中，JVM采用一种“自适应”的垃圾收集方案。对于它找到的那些活动对象，具体采取的操作取决于当前正在使用的是什么变体。其中一个变体是“停止和复制”。这意味着由于一些不久之后就会非常明显的原因，程序首先会停止运行（并非一种后台收集方案）。随后，已找到的每个活动对象都会从一个内存堆复制到另一个，留下所有的垃圾。除此以外，随着对象复制到新堆，它们会一个接一个地聚焦在一起。这样可使新堆显得更加紧凑（并使新的存储区域可以简单地抽离末尾，就象前面讲述的那样）。

当然，将一个对象从一处挪到另一处时，指向那个对象的所有句柄（引用）都必须改变。对于那些通过跟踪内存堆的对象而获得的句柄，以及那些静态存储区域，都可以立即改变。但在“遍历”过程中，还有可能遇到指向这个对象的其他句柄。一旦发现这个问题，就当即进行修正（可想象一个散列表将老地址映射成新地址）。

有两方面的问题使复制收集器显得效率低下。第一个问题是我们拥有两个堆，所有内存都在这两个独立的堆内来回移动，要求付出的管理量是实际需要的两倍。为解决这个问题，有些JVM根据需要分配内存堆，并将一个堆简单地复制到另一个。

第二个问题是复制。随着程序变得越来越“健壮”，它几乎不产生或产生很少的垃圾。尽管如此，一个副本收集器仍会将所有内存从一处复制到另一处，这显得非常浪费。为避免这个问题，有些JVM能侦测是否没有产生新的垃圾，并随即改换另一种方案（这便是“自适应”的缘由）。另一种方案叫作“标记和清除”，Sun公司的JVM一直采用的都是这种方案。对于常规性的应用，标记和清除显得非常慢，但一旦知道自己不产生垃圾，或者只产生很少的垃圾，它的速度就会非常快。

标记和清除采用相同的逻辑：从堆栈和静态存储区域开始，并跟踪所有句柄，寻找活动对象。然而，每次发现一个活动对象的时候，就会设置一个标记，为那个对象作上“记号”。但此时尚不收集那个对象。只有在标记过程结束，清除过程才正式开始。在清除过程中，死锁的对象会被释放然而，不会进行任何形式的复制，所以假若收集器决定压缩一个断续的内存堆，它通过移动周围的对象来实现。

“停止和复制”向我们表明这种类型的垃圾收集并不是在后台进行的；相反，一旦发生垃圾收集，程序就会停止运行。在Sun公司的文档库中，可发现许多地方都将垃圾收集定义成一种低优先级的后台进程，但它只是一种理论上的实验，实际根本不能工作。在实际应用中，Sun的垃圾收集器会在内存减少时运行。除此以外，“标记和清除”也要求程序停止运行。

正如早先指出的那样，在这里介绍的JVM中，内存是按大块分配的。若分配一个大块头对象，它会获得自己的内存块。严格的“停止和复制”要求在释放旧堆之前，将每个活动的对象从源堆复制到一个新堆，此时会涉及大量的内存转换工作。通过内存块，垃圾收集器通常可利用死块复制对象，就象它进行收集时那样。每个块都有一个生成计数，用于跟踪它是否依然“存活”。通常，只有自上次垃圾收集以来创建的块才会得到压缩；对于其他所有块，如果已从其他某些地方进行了引用，那么生成计数都会溢出。这是许多短期的、临时的对象经常遇到的情况。会周期性地进行一次完整清除工作——大块头的对象仍未复制（只是让它们的生成计数溢出），而那些包含了小对象的块会进行复制和压缩。JVM会监视垃圾收集器的效率，如果由于所有对象都属于长期对象，造成垃圾收集成为浪费时间的一个过程，就会切换到“标记和清除”方案。类似地，JVM会跟踪监视成功的“标记与清除”工作，若内存堆变得越来越“散乱”，就会换回“停止和复制”方案。“自定义”的说法就是从这种行为来的，我们将其最后总结为：“根据情况，自动转换停止和复制／标记和清除这两种模式”。

JVM还采用了其他许多加速方案。其中一个特别重要的涉及装载器以及JIT编译器。若必须装载一个类（通常是我们首次想创建那个类的一个对象时），会找到.class文件，并将那个类的字节码送入内存。此时，一个方法是用JIT编译所有代码，但这样做有两方面的缺点：它会花更多的时间，若与程序的运行时间综合考虑，编译时间还有可能更长；而且它增大了执行文件的长度（字节码比扩展过的JIT代码精简得多），这有可能造成内存页交换，从而显著放慢一个程序的执行速度。另一种替代办法是：除非确有必要，否则不经JIT编译。这样一来，那些根本不会执行的代码就可能永远得不到JIT的编译。

由于JVM对浏览器来说是外置的，大家可能希望在使用浏览器的时候从一些JVM的速度提高中获得好处。但非常不幸，JVM目前不能与不同的浏览器进行沟通。为发挥一种特定JVM的潜力，要么使用内建了那种JVM的浏览器，要么只有运行独立的Java应用程序。

英文版主页 | 中文版主页 | 详细目录 |

    下面是影响晋升和阻碍事业发展的十大因素：

    1. 不了解公司为什么雇佣你
    各级管理人员之所以能够存在，只有一个原因：维持老板的形象。你要是不相信，可以问问你的上司。如果你是老板，那么，去问问你的股东们。

    2. 不能迅速贯彻老板的意图
    如果事情与你的上司有关时，犹豫不决会对你的事业产生影响。你若对上司的命令不能及时反应，他总会记住你，而且会影响你的声誉。

    比如老板说：“史密斯干活不行，把他辞了。”你可能会见义勇为地为他辩解。但专横的老板并不认为这是一种美德，相反他会看作是反抗。假设你迟迟不执行上司的命令，也许不久以后被扫地出门的不仅仅是史密斯了。

    3. 忽视彼得原则
    彼得原则是说：在等级制度中，每个人都有可能被提升到他所不能胜任的位置。几乎人人都知道这条定律，但很少有人认为此定律对自己也适用。水平低下的经理则会很快达到这个极限。员工们经常习惯对一个晋升的机会进行争夺。但并不是每个晋升都符合你的利益。不符合你专长的晋升，只会加速你职业生涯中的彼得原则。我多次看到不少超级销售人员经历过类似情况。他们非常能干，于是公司觉得应该提拔他们担任销售经理。令我吃惊的是很多销售人员不管自己对管理别人多么没兴趣，都欣然接受了新的职务。到头来这种安排使每个人都受到了伤害。

    4. 对企业文化的忽视
    “企业文化”一词已经被用滥了，不过这是公司内的实际生活。当大家都穿白衬衫时，很明显，你不会去穿高领毛衣。

    如果大家习惯合作，你自然不会去出风头；如果大家每天都工作12小时，你也不会早9晚5的工作；如果你一定要与大家不一样，那么，就应该处处超过别人。

    5. 希望得到所有人的好感
    最好的主管当然受到别人的尊敬，也可能受到别人的爱戴。但如果你打算继续做出坚定而有正确的决策，就不能太关注人们对你的看法。决策应该根据实际情况来确定，而不是你的同情心和个人感情。千万不要为了得到大家的好感而使决策产生偏差。一个人不可能会使所有人满意。

    6. 实施有效的自我保护
    组织机构的最高领导人变化的目的是打算进一步改善这个组织结构，而不是与个人有什么恩怨。

    许多经理人不相信这一点。他们总从个人的角度来看待这一变化。于是，他们对于到来的新领导抱有抵触情绪；这样以来新领导也会产生抵触情绪。结果谁失败呢？

    7. 在公共场合随便说话
    许多人之所以不成功，是因为过于轻信别人。如果你必须倾吐对某个同事或某个上级的看法，最好是留着回家去说。尖刻的话会很快传到你老板的耳朵里，结果倒霉的只能是你。

    8. 行动自相矛盾反复无常
    在绝大部分日常问题解决中，最需要的是扎实的、稳妥的判断，而不是创造性。

    对你的上司和下属来讲，你的反复无常是最令人恼火的。今天对受到的挫折大发脾气，明天对同样的问题又从容对待，会让人觉得你这人不可靠。

    9. 将错误推到别人身上
    犯了错误要勇于承认，这没有什么不妥。出了错既不要埋怨别人，也不要迁怒于别人。当然，也不要养成不断犯错误，不断承认的坏习惯。

    10. 让部下干你自己不愿干的事情
    如果你不能身体力行，只让别人加班就不合适。同样，你不是时时注意指导你的部下，你就别指望他们按照你所要求的方式工作。（完）
 
[Traceback]: http://psyche.netbig.com/p1/p12/1913/20010622/105200.htm

    今天主要是想谈一下我对这个组合的看法。

    在我的观念里，我会崇尚于“守中有攻”。
    守势乃大势，为保全自己而做的一些措施；而攻乃出势，意为与别人进行交涉的措施。
    我所认为“守中有攻”是在防护好自己的前提下，然后再发出攻势，这样子发出的攻势才能思考周全，发而有力，因此才能即达到目的，也可以让自己不受伤害。而“攻中有守”则是在攻击中夹带防守，在这种方式中，我觉得进攻不能发全力，则总要思考着还要保护自己，以使自己免受伤害，然而往往是动一毛而牵全身，致使造成自己不想的结果，反而会让自己受到伤害。
    当然可能也会有人说“全身攻击”的，然而往往来讲，这是一种武夫的表现，能够有成功的机会，但绝不应该是一个思考者所为的。

    战术上还有两个东西是讲在时间上来战胜的：“先发制人”和“后发制人”。先发的优势在于时间上的先前，在敌人还没有准备好时，突然进行攻击，力挫敌人；后发的优势则也是在于时间上的落后，往往是在当敌人进行攻击时，稳住自己和思考敌人的进攻方式，攻击后，则不给敌人以喘息的机会，攻击必能取胜。这就是后发的优势，所以我还是喜欢后者，这更具有战术性。

    对于如今信息发达的IT时代来讲，我个人觉得这些战术对于企业都有很多用处的。在IT信息领域中，一个企业先发的优势已经失去了，在这个行业中有着大多的事业单位介入，都在啃这块喷香的大面包。然而由于一点点啃，也就会一点点少，而且还会带着更多的人来分。所以，对于一个企业，在考虑先发优势，思考产品的独特创新设计方面外，后发优势则是要多考的，对于也就是要更多地思考敌人以及周围的情况，能够在瞬息万变的信息时代中抓住机遇，迎接挑战。

    以上为个人的一点拙见，欢迎讨论哦！