亚洲第一页中文字幕,亚洲va无码va在线va天堂,亚洲色大18成人网站WWW在线播放

Design and performance improvements with JDBC 4.0(�?

Leo — Tue, 09 May 2006 03:17:00 GMT

昨天��M��一��关于JDBC4.0设计与性能提高的文章，�׃��弟��p��译水准实在有限�Q�就不在�q�里献丑了，��把原文�l�大家�{载出来供大家阅读:

转蝲自：http://www.javaworld.com/javaworld/jw-05-2006/jw- 0501-jdbc .html

Design and performance improvements with JDBC 4.0

Effectively utilize JDBC'S features to get desired results with less code

Summary
Java Database Connectivity (JDBC) 4.0 is ready for release by mid 2006 as a part of Java Standard Edition 6.0. How can you leverage the new specification to improve the design and performance of database access and interactions in Java applications? This article discusses the new features of JDBC 4.0, illustrates its solutions to some existing problems, and presents its improvements in design and performance through examples. (2,100 words; May 1, 2006)

By Shashank Tiwari

ava Database Connectivity (JDBC), which has existed from the first public version of the core Java language, has evolved significantly over the last 10 years. In its current version, 4.0, which will be packaged with Java Standard Edition 6.0 (Java SE is Sun's new name for J2SE), it shows significant improvements in design and provides a richer API, with focus on ease of development and improvement in productivity.

This article discusses some of the important changes in the JDBC specification that either improve the design or facilitate better performance. The article does not enlist or survey every single change incorporated as a part of Java Specification Request 221, the JDBC 4.0 initiative.

After reading this article, you should be ready to leverage the new features in your next set of applications.

Annotations and the generic DataSet
I assume you are already aware of annotations and generics, which were introduced in Java with J2SE 5.0. JDBC 4.0 introduces annotations and the generic DataSet. This change aims to simplify execution of SQL queries (in scenarios that return a single result set) and SQL DML (data manipulation language) statements (that return either a row count or nothing).

The new API defines a set of Query and DataSet interfaces. The Query interface defines a set of methods decorated with the JDBC annotations. These decorated methods describe the SQL select and update statements, and specify how the result set should be bound to a DataSet. The DataSet interface is a parameterized type, as defined by generics. The DataSet interface provides a type-safe definition for the result set data.

All Query interfaces inherit from the BaseQuery interface. A concrete implementation of the interface can be instantiated using either the Connection.createQueryObject() or DataSource.createQueryObject() methods and passing a Query interface type as its parameter.

A DataSet interface inherits from java.util.List. A data class describing the columns of the result set data, returned by an annotated method of the Query interface, is its parameter type. A DataSet can be manipulated and operated upon both in a connected and disconnected mode. Thus, the DataSet is implemented either as a ResultSet or a CachedRowSet, depending on its operating mode: connected or disconnected. DataSet, being a sub-interface of the java.util.List, allows access of its data rows with the Iterator pattern, using the java.util.Iterator interface.

The data class or the user-defined class, which is a parameter type of the DataSet interface, can be specified in two ways: as a structure or as a JavaBeans object. Either method achieves the goal of binding result set data columns to user-defined class definitions, but the JavaBeans component model is more elegant and facilitates object definition reuse within other frameworks that support the JavaBeans model.

Listing 1 illustrates code snippets for a simple example to show how the new API is used to create and run SQL queries, define result set data using a user-defined class, and bind the returned result set to the user-defined specifications.

Listing 1. Employee user-defined type and employeeQueries

pubic class Employee { private int employeeId; private String firstName; private String lastName; public int getEmployeeId() { return employeeId; } public setEmployeeId(int employeeId) { this.employeeId = employeeId; } public String getFirstName() { return firstName; } public setFirstName(String firstName) { this.firstName = firstName; } pubic String lastName() { return lastName; } public setLastName(String lastName) { this.lastName = lastName; } } interface EmployeeQueries extends BaseQuery { @Select (sql="SELECT employeeId, firstName, lastName FROM employee") DataSet getAllEmployees (); @Update (sql="delete from employee") int deleteAllEmployees (); } Connection con = ... EmployeeQueries empQueries = con.createQueryObject (EmployeeQueries.class); DataSet empData = empQueries.getAllEmployees ();

Exception-handling enhancements
The exception-handling functionality in the JDBC API prior to version 4.0 is limited and often insufficient. SQLException is thrown for all types of errors. There is no classification of exceptions, and no hierarchy defines them. The only way to get some meaningful information is to retrieve and analyze the SQLState value. SQLState values and their corresponding meanings change from datasource to datasource; hence, getting to the root of the problem and efficiently handling exceptions proves to be a tedious task.

JDBC 4.0 has enhanced exception-handling capability and alleviates some of the mentioned problems. The key changes are as follows:

Classification of SQLException into transient and non-transient types

Support for chained exceptions

Implementation of the Iterable interface

The SQLTransientException is thrown where a previously failed operation may succeed on retrial. The SQLNonTransientException is thrown where retrial will not lead to a successful operation unless the cause of the SQLException is corrected.

Figure 1 illustrates the subclasses of SQLTransientException and SQLNonTransientException.

Figure 1. SQL exception classes: Transient and non-transient

Support for chained exceptions are now included. New constructors add extra parameters to capture possible causes for the exception. Multiple SQLExceptions could be iterated over in a loop, and getCause() could be called to determine the exception's possible cause. The getCause() method can return non-SQLExceptions if they are the underlying cause of the exceptions.

The SQLException class now implements the Iterable interface and supports the J2SE 5.0 for each loop for easier and more elegant looping.

Listing 2 depicts the usage of the new for-each-loop construct:

Listing 2. For each loop

catch(SQLException ex) { for(Throwable t : ex) { System.out.println("exception:" + t); } }

SQL/XML
A large amount of data now exists in the XML format. Databases have extended support for the XML data type by defining a standard XML type in the SQL 2003 specification. Most database vendors have an implementation of the XML data type in their new releases. With the inclusion of such a type, an XML dataset or document could be one of the fields or column values in a row of a database table. Prior to JDBC 4.0, perhaps the best way to manipulate such data within the JDBC framework is to use proprietary extensions from the driver vendors or access it as a CLOB type.

JDBC 4.0 now defines SQLXML as the Java data type that maps the database SQL XML type. The API supports processing of an XML type as a string or as a StAX stream. Streaming API for XML, which for Java has been adopted via JSR 173, is based on the Iterator pattern, as opposed to the Simple API for XML Processing (SAX), which is based on the Observer pattern.

Invoking the Connection object's createSQLXML() method can create a SQLXML object. This is an empty object, so the data can be attached to it by either using the setString() method or by associating an XML stream using the createXMLStreamWriter() method with the object. Similarly, XML data can be retrieved from a SQLXML object using getString() or associating an XML stream using createXMLStreamReader() with the object.

The ResultSet, the PreparedStatement, and the CallableStatement interfaces have getSQLXML() methods for retrieving a SQLXML data type. PreparedStatement and CallableStatement also have setSQLXML() methods to add SQLXML objects as parameters.

The SQLXML resources can be released by calling their free() methods, which might prove pertinent where the objects are valid in long-running transactions. DatabaseMetaData's getTypeInfo() method can be called on a datasource to check if the database supports the SQLXML data type, since this method returns all the data types it supports.

Connections and Statements
The Connection interface definitions have been enhanced to analyze connection state and usage to facilitate efficiency.

Sometimes database connections are unusable though they may not necessarily be closed and garbage collected. In such situations, the database appears slow and unresponsive. In most of these circumstances, reinitializing the connections is perhaps the only way to resolve the problem. When using the JDBC API prior to version 4.0, there is no way to distinguish between a stale connection and a closed connection. The new API adds an isValid() method to the Connection interface to query if the connection is still valid.

Also, database connections are often shared among clients, and sometimes some clients tend to use more resources than others, which can lead to starvation-like situations. The Connection interface defines a setClientInfo() method to define client-specific properties, which could be utilized to analyze and monitor resource utilization by the clients.

RowId
The RowId in many databases is a unique way to identify a row in a table. Queries using RowId in the search criteria are often the fastest way to retrieve data, especially true in the case of the Oracle and DB2 databases. Since java.sql.RowId is now a built-in type in Java, you could utilize the performance benefits associated with its usage. RowIds are most useful in identifying unique and specific rows when duplicate data exists and some rows are identical. However, it is important to understand that RowIds often are unique only for a table and not for the entire database; they may change and are not supported by all databases. RowIds are typically not portable across datasources and thus should be used with caution when working with multiple datasources.

A RowId is valid for the lifetime defined by the datasource and as long as the row is not deleted. The DatabaseMetadata.getRowIdLifetime() method is called to determine the RowId's lifetime. The return type is an enumeration type as summarized in the table below.

`RowIdLifetime` enum type	Definition
`ROWID_UNSUPPORTED`	Datasource does not support `RowId` type
`ROWID_VALID_OTHER`	Implementation-dependent lifetime
`ROWID_VALID_TRANSACTION`	Lifetime is at least the containing transaction
`ROWID_VALID_SESSION`	Lifetime is at least the containing session
`ROWID_VALID_FOREVER`	Unlimited lifetime

The ROWID_VALID_TRANSACTION, ROWID_VALID_SESSION, and ROWID_VALID_FOREVER definitions are true as long as the row is not deleted. It is important to understand that a new RowId is assigned if a row is deleted and reinserted, which sometimes could happen transparently at the datasource. As an example, in Oracle, if the "enable row movement" clause is set on a partitioned table and an update of the partition key causes the row to move from one partition to another, the RowId will change. Even without the "enable row movement" flag with the "alter table table_name" move, the RowId could change.

Both the ResultSet and CallableStatement interfaces have been updated to include a method called getRowID(), which returns a javax.sql.RowId type.

Listing 3 shows how RowId could be retrieved from a ResultSet and from a CallableStatement.

Listing 3. Get RowId

//The method signatures to retrieve RowId from a ResultSet is as follows: RowId getRowId (int columnIndex) RowId getRowId (String columnName) ... Statement stmt = con.createStatement (); ResultSet rs = stmt. ExecuteQuery (�?; while (rs.next ()) { ... java.sql.RowId rid = rs.getRowId (1); ... } //The method signatures to retrieve RowId from a CallableStatement is as follows: RowId getRowId (int parameterIndex) RowId getRowId (String parameterName) Connection con; ... CallableStatement cstmt = con.prepareCall (�?; ... cstmt.registerOutParameter (2, Types.ROWID); ... cstmt.executeUpdate (); ... java.sql.RowId rid = cstmt.getRowId (2);

The RowId can be used to refer uniquely to a row and thus can be used to retrieve the rows or update the row data. When fetching or updating using RowId references, it is important to know the validity of the RowId's lifetime to assure consistent results. It is also advisable to simultaneously use another reference, such as the primary key, to avoid inconsistent results in circumstances where the RowId could change transparently.

The RowId values can also be set or updated. In the case of an updateable ResultSet, the updateRowId() method could be used to update the RowId for a particular row in a table.

Both the PreparedStatement and the CallableStatement interfaces support a setRowId() method, with different signatures, to set the RowId as a parameter value. This value could be used to refer to data rows or to update the RowId value for a particular row in a table.

The facility to set or update the RowId provides the flexibility to control the unique row identifiers and could be used to make such identifiers unique across the tables used. Perhaps, portability of RowId across supporting datasources could also be achieved by explicitly setting consistent values across them. However, because system-generated RowIds are often efficient, and transparent tasks could alter RowIds, they are best used by an application as a read-only attribute.

Leverage nonstandard vendor implemented resources
The new JDBC API defines a java.sql.Wrapper interface. This interface provides the ability to access datasource-vendor-specific resources by retrieving the delegate instance using the corresponding wrapped proxy instance.

This Wrapper interface has 17 sub-interfaces as per the current specification and includes Connection, ResultSet, Statement, CallableStatement, PreparedStatement, DataSource, DatabaseMetaData, and ResultSetMetaData, among others in the list. This is an excellent design as it facilitates datasource-vedor-specific resource implementation at almost all stages of the query-creation and result-set-retrieval lifecycles.

The unwrap() method returns the object that implements the given interface to allow access to vendor-specific methods. The isWrapperFor() method returns a Boolean value. It returns true if it implements the interface, or if it directly or indirectly is a wrapper for the object.

As an example, when using Oracle, Oracle JDBC drivers provide update batching extensions that are better performing and more efficient as compared to the standard JDBC batch-updating mechanisms. For earlier JDBC versions, this implies using the Oracle-specific definitions, such as OraclePreparedStatement, in the code. This compromises code portability. With the new API, many such efficient implementations can be wrapped and exposed within the standard JDBC definitions.

Service provider mechanism for driver loading
In a nonmanaged or standalone program scenario, prior to JDBC 4.0, you would have to load the JDBC driver class explicitly by invoking the Class.forName method, as shown in Listing 4:

Listing 4. Class.forName

Class.forName ("com.driverprovider.jdbc.jdbcDriverImpl");

With JDBC 4.0, if the JDBC driver vendors package their drivers as services, defined under the server provider mechanism definitions as per the JAR specification, the DriverManager code would implicitly load the driver by searching for it in the classpath. The benefit of this mechanism is that the developer does not need to know about the specific driver class and can write a little less code when using JDBC. Also, since the driver class name is no longer in the code, a name change would not require recompilations. If multiple drivers are specified in the classpath, then DriverManger will try and establish a connection using the first driver it encounters in the classpath and iterate further if required.

Conclusion
In this article, I have discussed some of the new and improved features of JDBC 4.0. Many of these new features enhance a developer's productivity and facilitate development. Also, the specification does not eradicate the possible use of extra JDBC frameworks to provide templating facilities and advanced exception-handling capabilities. However, there is some criticism as well. Some believe that annotations effectively lead to hard-coding in code, which causes problems in code maintainability.

Leo 2006-05-09 11:17 发表评论

ANT安装、配�|?(�?

Leo — Mon, 08 May 2006 02:54:00 GMT

ANT安装、配�|?/span>

内容摘要�Q?br />ant是一个基于JAVA的自动化脚本引擎�Q�脚本格式�ؓXML。除了做JAVA�~�译相关��d��外，ANT�q�可以通过插�g实现很多应用的调用�?/p>

ANT的基本概念：
ANT的安装：解包�Q�设�|��\�?
ANT的��用：最好的学习只不�q�是一个简单实用的例子��h��…�?
ANT的基本概念：Java的Makefile
当一个代码项目大了以后，每次重新�~�译�Q�打包，��试�{�都会变得非常复杂而且重复�Q�因此c语言中有make脚本来帮助这些工作的扚w��完成。在Java 中应用是�q�_��无关性的�Q�当然不会用�q�_��相关的make脚本来完成这些批处理��d��了，ANT本��n��是�q�样一个流�E�脚本引擎，用于自动化调用程序完成项目的�~�译�Q�打包，��试�{�。除了基于JAVA是��^台无关的外，脚本的格式是��Z��XML的，比make脚本来说�q�要好维护一些�?/p>

每个ant脚本�Q�缺省叫build.xml�Q�中讄��了一�p�d��d��(target)�Q�比如对于一个一般的��目可能需要有以下��d��?/p>

��d��1�Q�usage 打印本脚本的帮助信息�Q�缺省）
��d��2�Q�clean <-- init 清空初始化环�?
��d��3�Q�javadoc <-- build <-- init 生成JAVADOC
��d��4�Q�jar <-- build <-- init 生成JAR
��d��5�Q�all <-- jar + javadoc <-- build <-- init 完成以上所有�Q务：jar javadoc
而多个�Q务之间往往又包含了一定了依赖关系�Q�比如把整个应用打包��d��(jar)的这个依赖于�~�译��d��(build)�Q�而编译�Q务又依赖于整个环境初始化��d��(init)�{��?/p>

注：我看到很多项目的ant脚本中的命名基本上都是一致的�Q�比如：�~�译一般叫build或者compile�Q�打包一般叫jar或war�Q�生成文档一般命名�ؓjavadoc或javadocs�Q�执行全部�Q务all。在每个��d��的中�Q�ANT会根据配�|�调用一些外部应用�ƈ配以相应参数执行。虽然ANT可调用的外部应用�U�类非常丰富�Q�但其实最常用的就2�Q?个：比如javac javadoc jar�{��?
ANT的安�?br />解包后在�pȝ��可执行�\径中加入指向ant的bin的�\径就可以了，比如可以在GNU/Linux上把以下配置加入/etc/profile中：
export ANT_HOME=/home/ant
export JAVA_HOME=/usr/java/j2sdk1.4.1
export PATH=$PATH:$JAVA_HOME/bin:$ANT_HOME/bin

�q�样执行ant 后，如果不指定配�|�文件ant会缺省找build.xml�q�个配置文�g�Q��ƈ�Ҏ��配置文�g执行��d��Q�缺省的��d��讄��可以指向最常用的�Q务，比如�Q? build�Q�或指向打印帮助信息�Q�usage�Q�告诉用��h��那些脚本选项可以使用�?/p>

ANT的��?/p>

最好的学习�q�程��是看懂那些open source��目中的build.xml脚本�Q�然后根据自��q��需要简化成一个更��单的�Q�ANT和APACHE上很多非常工�E�派的项目：��单易用，而且适应性非常强�Q�因��些项目的建立往往来源于开发�h员日常最直接的需求�?br />以下是的一个WebLucene应用的例子：修改自JDOM的build.xml�Q?/p>

destdir="${build.dest}"
debug="${debug}"
optimize="${optimize}">

basedir="${build.dest}"
includes="**"/>

sourcepath="${build.src}"
destdir="${build.javadocs}"
author="true"
version="true"
use="true"
splitindex="true"
windowtitle="${Name} API"
doctitle="${Name}">

�~�省��d��Q�usage 打印帮助文档�Q�告诉有那些��d��选项�Q�可用的有build, jar, javadoc和clean.

初始化环境变量：init
所有�Q务都��Z��一些基本环境变量的讄��初始化完成，是后�l�其他�Q务的基础�Q�在环境初始化过�E�中�Q�有2�Ҏ��较可以方便设�|�：

1 除了使用却缺省的property讄��了JAVA源�\径和输出路径外，引用了一个外部的build.properties文�g中的讄��Q?br />
�q�样大部分简单配�|�用户只要会看懂build.properties��可以了�Q�毕竟XML比�vkey value的属性文件还是要可读性差一些。用build.properties也可以方便其他用户从�~�译的细节中解放出来�?/p>

2 CLASSPATH讄��Q��用了其中的：

则相当于讄��了：CLASSPATH=/path/to/resin/lib/jsdk23.jar; /path/to/project/lib/*.jar;

文�g复制�Q�prepare-src
创徏临时SRC存放目录和输出目录�?br />

�~�译��d��Q�build
�~�译时的CLASSPATH环境通过一下方式找到引用一个path对象

打包��d��Q�jar
对应用打包生成项目所写名�?jar文�g

basedir="${build.dest}"
includes="**"/>

生成JAVADOC文档��d��: javadoc

sourcepath="${build.src}"
destdir="${build.javadocs}"
author="true"
version="true"
use="true"
splitindex="true"
windowtitle="${Name} API"
doctitle="${Name}">

清空临时�~�译文�g�Q�clean

TODO�Q?br />更多��d��/扩展�Q�（样例�Q?/p>

��试��d��Q�JUnit��试
代码风格��查�Q务：CheckStyle�Q�Jalopy�{?
邮�g警报��d��Q�可以把以上�q�些��d��的输��告发送到制定的用户列表中�Q�这个�Q务可以设�|�每天自动运行�?

参考资料：

Jakarta ANT:
http://ant.apache.org

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=707995

Leo 2006-05-08 10:54 发表评论

JDBC2/3.0的特征点�?

Leo — Mon, 08 May 2006 02:49:00 GMT

最�q�写�E�序已经很少直接用JDBC了，一直都是用ibaits, Hibernate�{�来招呼�Q�因为现在的集成框架已经很稳定了。不�q�对JDBC的直接��用还是不可以忽略的，JDBC3.0提供的n多的新特征还是要熟悉了解的，以前学jdbc的时候就是上�|�找些demo和介�l�来学，使用很单一�Q�对JDBC3.0的好多新的特征都忽略了，比如下面一个例子：

Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM user WHERE username='aa'");
stmt.executeUpdate("UPDATE user SET lastdatetime=now() where username='aa'");

�q�是一个用��L��录时�Q�经常用到的代码�Q�先是根据用户名aa查找该用��L��详细信息�Q�然后再更新该用��L��最后登录时��_��lastdatetime�Q�。这�q�个里面�Q�我们用了两个sql语句�Q�这个是我一直用的方法，但是如果用JDBC2.0�l�我们提供的便利�Q�我们只要写一条sql��够了，其他的都交给jdbc�Q�看下面的代码：

Statement stmt2 = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs2 = stmt.executeQuery("SELECT * FROM user WHERE username='aa'");
rs2.next();
rs2.updateDate("lastdatetime", new Date(Calendar.getInstance().getTimeInMillis()));
rs2.updateRow();

�q�里面最主要的特征就是ResultSet.TYPE_FORWARD_ONLY和ResultSet.CONCUR_UPDATABLE�Q�通过初始化Statement时传不同的参敎ͼ�可以对ResultSet�q�行不用的错作限制。con.createStatement的时候，有三�U�可以掉用的函数�Q?/font>

1、createStatement();
2、createStatement(int resultSetType, int resultSetConcurrency)
3、createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)

其中resultSetType可选值是�Q?br /> 1、ResultSet.TYPE_FORWARD_ONLY 在ResultSet中只能先前移动游标，
2、ResultSet.TYPE_SCROLL_INSENSITIVE 在ResultSet中可以随心所�Ʋ的先前向后�U�d��游标�Q?br /> 3、ResultSet.TYPE_SCROLL_SENSITIVE 在ResultSet中可以随心所�Ʋ的先前向后�U�d��游标�Q�同时ResultSet的值有所改变的时候，他可以得到改变后的最新的�?br />其中resultSetConcurrency可选值是�Q?br /> 1、ResultSet.CONCUR_READ_ONLY 在ResultSet中的数据记录是只�ȝ��Q�可以修�?br /> 2、ResultSet.CONCUR_UPDATABLE 在ResultSet中的数据记录可以��L��修改�Q�然后更��C��数据�?br />其中resultSetHoldability可选值是�Q?br /> 1、ResultSet.HOLD_CURSORS_OVER_COMMIT 表示修改提交�?不关闭ResultSet的游�?br /> 2、ResultSet.CLOSE_CURSORS_AT_COMMIT 表示修改提交�?关闭ResultSet的游�?/font>

对于查询操作�W�一�U�初始化�Ҏ��createStatement()�Q�相当于�W�二�U�方法的createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)�Q�第三种�Ҏ��的createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.CLOSE_CURSORS_AT_COMMIT)

下面写一�D�demo的代码，我把一些特征函数都用出来，但是只是用来查考和说明名灵�z�L��的�?/font>

Statement stmt2 = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs2 = stmt.executeQuery("SELECT * FROM user");
rs2.next();
rs2.updateDate("lastdatetime", new Date(Calendar.getInstance().getTimeInMillis()));
rs2.updateRow();
rs2.afterLast();
while(rs2.previous()){ /**....*/ }
rs.beforeFirst();
while(rs2.next()){ /**....*/ }
rs.last();
rs.first();
rs.absolute(5); //游标�U�d��到第5�?br /> rs.absolute(-1); //游标�U�d��到最后一�?br /> rs.relative(-5); //游标向上�U�d��5�?br /> rs.relative(2); //游标向下�U�d��2�?br /> rs.deleteRow(); //删除当前�?br /> rs.last(); //游标�U�d��到最�?br /> rs.updateString("summary", "This is ..."); //讄��更新的字�D��?br /> rs.cancelRowUpdates(); //取消刚才输入的更�?br /> rs.getRow(); //得到当前行号
rs.moveToInsertRow(); //游标�U�d��到要新增的那条记录上
rs.updateInt("id", 1);
rs.updateString(2, "my name");
rs.insertRow(); //插入新记�?/font>

JDBC2.0提供的还有一个功能就是数据库的批量操�?/font>�Q?/font>

  con.setAutoCommit(false);
  Statement stmt3 = con.createStatement();
  stmt3.addBatch("insert .....");
  stmt3.addBatch("insert .....");
  int[] rows = stmt3.executeBatch();
  con.commit();

但是有一点要注意�Q�stmt3.executeBatch()他不会自动给你回滚数据操作，当你�?条update语句的时候，如果�W�三条发生错误，那么��无法自动回滚前两条update语句的媄响，所以一定要自己手工�q�行事务��理�?/font>

在您的事务中使用 Savepoint
JDBC3.0中最令�h兴奋的附加特点就�?Savepoint 了。有时候需要的是对事务多一点的控制�Q�而不是在当前的事务中��单地�Ҏ��一个改变进行回滚。在JDBC3.0下，您就可以通过 Savepoint 获得�q�种控制。Savepoint 接口允许您将事务分割为各个逻辑断点�Q�以控制有多��事务需要回滚。看下面的代码：

conn.setAutoCommit(false);
conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
Statement stmt = conn.createStatement();
int rows = stmt.executeUpdate( "INSERT INTO authors (first_name, last_name) valueS(′Lewis�? ′Carroll�?");
Savepoint svpt = conn.setSavepoint("NewAuthor");
try{
rows = stmt.executeUpdate( "UPDATE authors set type = ′fiction�?WHERE last_name = ′Carroll�?);
}catch(Exception e){
conn.rollback(svpt);
rows = stmt.executeUpdate( " update .......... other sql ");
}
conn.commit();

上面代码昄��Q�当UPDATE authors��p�|的时候，�pȝ��事务回滚UPDATE authors的sql的媄响，而INSERT INTO authors的sql仍然有效

��索自动��生的关键�?/font>
��Z��解决对获取自动��生的或自动增加的关键字的值的需求，JDBC 3.0现在��获取这�U�值变得很��L��。要��定��M��所产生的关键字的��|��只要��单地在语句的 execute() �Ҏ��中指定一个可选的标记�Q�Statement.RETURN_GENERATED_KEYS和Statement.NO_GENERATED_KEYS。在执行�q�条语句后，所产生的关键字的值就会通过�? Statement 的实例方�?getGeneratedKeys() 来检�?ResultSet 而获得。ResultSet 包含了每个所产生的关键字的列。看下面代码�Q?/font>

Statement stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO authors (first_name, last_name) valueS (′George�? ′Orwell�?", Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
if ( rs.next() ) {
int key = rs.getInt();
}

参考资料： http://java.sun.com/j2se/1.5.0/docs/api/java/sql/package-summary.html

Leo 2006-05-08 10:49 发表评论

Leo — Sat, 29 Apr 2006 12:59:00 GMT

< script language = " javascript " type = " text/javascript " >

function Hashtable()
{
     this ._hash         = new Object();
     this .add         = function(key,value){
                         if (typeof(key) != " undefined " ){
                             if ( this .contains(key) == false ){
                                 this ._hash[key] = typeof(value) == " undefined " ? null :value;
                                 return true ;
                            } else {
                                 return false ;
                            }
                        } else {
                             return false ;
                        }
                    }
     this .remove         = function(key){delete this ._hash[key];}
     this .count         = function(){var i = 0 ; for (var k in this ._hash){i ++ ;} return i;}
     this .items         = function(key){ return this ._hash[key];}
     this .contains     = function(key){ return typeof( this ._hash[key]) != " undefined " ;}
     this .clear         = function(){ for (var k in this ._hash){delete this ._hash[k];}}

}

var a = new Hashtable();

a.add( " aa " );
a.add( " bb " , 2342 );
a.add( " bb " , 2342 );

a.remove( " aa " );

alert(a.count());

alert(a.contains( " bb " ));

alert(a.contains( " aa " ));

alert(a.items( " bb " ));

script >

Leo 2006-04-29 20:59 发表评论

WEB打印分页�c?JS)(�?

Leo — Sat, 29 Apr 2006 12:57:00 GMT

摘要: < HTML > < HEAD > < TITLE > print < meta http-equiv =... 阅读全文

Leo 2006-04-29 20:57 发表评论

javascript��技巧[转]

Leo — Sat, 29 Apr 2006 12:50:00 GMT

摘要: 事�g源对�? event.srcElement.tagName event.srcElement.type 捕获释放 event.srcElement.setCapture(); event.srcElement.releaseCapture(); 事�g按键 ... 阅读全文

Leo 2006-04-29 20:50 发表评论

Leo — Sun, 02 Apr 2006 18:22:00 GMT

摘要: �?我们的项目写的一个轻量的分页API。目的在于将分页与数据查询的逻辑完全剥离。我以前看过robbin发的通过detachedCriteria实现�?分页那片贴子�Q�里面把分页和数据查询结合在一起了。而我觉得分开更轻量，而且替换也比较容易。但是这个实��C��有一个反模式�Q�在逻辑中生成了代码�Q�无奈之选，��Z��ѝ��其中字�W�生成可以自己扩展i18n实现�Q�应该非常容易。分��实现的接口�Q�package c... 阅读全文

Leo 2006-04-03 02:22 发表评论

面向Web的JMS应用�pȝ��

Leo — Thu, 23 Feb 2006 11:07:00 GMT

作者：朱骐

作者简�?/h4>

朱骐�Q�男�Q�江苏南京�h�Q�讲师，主要研究方向�Q�信息系�l�与集成技术。您可以通过qizhu003@msn.com和作者取得联�p�R�?/p>

内容摘要

JMS面向Web的应用与面向桌面的应用相比，有特�D�的用户环境要求�Q�同一个消息必��能被若�q�未知的用户消费�Q�因此在消息接收方必��L��"接收而不��认"的提交机�Ӟ��本文以CWNF校务�pȝ��为实现案例，讨论面向Web的JMS应用�pȝ��消息提交原理及采用的关键技术�?/p>

消息传递是一�U�在软�g�l��g或应用之间进行分布式通信的松散耦合�Ҏ��Q�与各种紧密耦合通信技术（如CORBA、Java RMI、COM/DCOM�Q�相比，不同之处在于�Q�①消息�pȝ��是一�U�对�{�实施，通信双方��x��息的发送者和接受者都是该�pȝ��中的客户端，彼此不呈C/S关系�Q? ②通信双方的工作是异步的；③基于消息格式一��_��通信双方只需一个中介来存储�q�管理消息就可以实现通信�Q�而紧密耦合技术则需要知道远�E�方法在本地的接口�? 因自�w�特点，消息传递技术在企业中和企业间有较广泛的应用需求�?/p>

JMS�Q�Java Message Service�Q�是J2EE企业�q�_��的Java消息服务�Q�目前主��J2EE产品的JMS都实��C��存储功能�Q�JMS客户端通过JMS API创徏�Q�彼此间通过目的圎ͼ�Destination�Q�对象进行通信�Q�可是JMS消息�pȝ��多见于桌面应用，而Web应用鲜见�Q�本文以�W�者开发的CWNF 校务�pȝ��为案例，讨论面向Web的JMS应用�pȝ��的实现原理及采用的关键技术�?/p>

1 面向Web的JMS应用�pȝ��实现原理

1.1 JMS应用�pȝ��消息传递原�?/h4>

JMS应用�pȝ��?个部分：①JMS提供者（JMS Provider�Q�，是一个逻辑数据存储体，�q�提供管理工具和控制�Ҏ��；②JMS客户端，是用Java语言�~�写的发送或接收消息的组件或应用�Q�③消息�Q�是 JMS客户端间被传递的承蝲信息的对象；④被��理对象�Q�是�pȝ��理员�ؓ客户端预�|�的JMS对象�Q�包括目的地对象和连接工厂对象，其中目的地对象是客户端间的消息中介。这4个部分通过JNDI相关联：��理员通过��理工具把目的地对象和连接工厂对象绑定到一个JNDI API命名�I�间中，JMS客户端就可以在命名空间中查找�q�些对象�Q��ƈ通过JMS提供者徏立与�q�些对象的逻辑�q�接�Q�从而彼此之间实现通信�Q�图1�Q�。JMS�? �?�U�消息传递域�Q�点到点、发�?订阅�Q�与之相对应的消息目的地对象也有2�U�：队列、主题�?/p>

1.2 Web应用的消息提交机�?/h4>

通常�Q�无论是消息发送方�q�是接收方，桌面应用都不容许消息丢失或重复，JMS消息提交机制是基于这个要求的�Q�它们从不同斚w��保证该要求的实现�Q�①�? 接收�Ҏ��制消息的��认。通过��认保证一个接收者对一个消息只消费一�ơ，在非事务性的会话中，消息��认方式取决于create×××Session�Ҏ��W�二个参数的��|��在事务性会话中�Q�无论由Bean��理事务�q�是由Bean容器��理事务�Q�消息确认都由Bean容器自动完成。②在发送方指定消息的提交模式和�? 存期。提交模式有两种�Q�PERSISTENT(�E�_��存储)和NON_PERSISTENT(非稳定存�?�Q�稳定存储保证在故障情况下消息不会丢失；生存�? 军_��一个消息在存储中介中的存在寿命�Q�JMS提供者会自动摧毁到期的消息。③创徏持久定阅的接收方。在发布/订阅�pȝ��中，持久订阅者可以接收到在订阅者关闭阶�D�|��息发送方发布的消息�?/p>
但是Web应用�pȝ��在消息接收方有Web�Ҏ��的用��L��境要求：①若�q�个用户��q��一个JMS客户端组�Ӟ��因此消息��应向一个消息接收者提交而不需��? 认，��h��容器自动��认功能的Bean是无法实现这一要求的；在一个组件内如果把会话设�|�成事务性的�Q�而这个组件的容器又不��h��事务��理能力�Q�则�q�个�l��g��? 能做�?接收而不��认"�Q�在Web应用�pȝ��中只有Servlet�l��g�W�合�q�一要求。②JMS客户端的消息接收者经常关闭，��Z��接收在关闭期间发送来的消息，消息接收者必定是��Z��主题的持久定阅者，所以面向Web的JMS应用�pȝ��必定采用发布/订阅消息传递域�?/p>

2 CWNF校务�pȝ��模型

CWNF是一个面向Web的JMS校务�pȝ��Q�用于校园发布通知及征求意见等校务工作�Q�通知分�ؓ2�c�：普通通知和征求意见性通知�?/p>

该系�l�用户分�?�c�，用户不同�Q�处理模型也不同�Q�基本情况如下：①发布用��P��拥有通知发布权，向主题发布通知�Q�②�|�名用户�Q�查阅通知�Q�也可发表对征求意见性通知的反馈意见；③匿名用��P��只查阅通知�?/p>

2.1 数据与数据流模型

�pȝ��中的数据因此�?�c�：通知、反馈。接收方接收的数据将形成一个XML文档对象�Q�以便发往Web��览器显�C�；��Z��q�样的要求，考察下面2个问题：①系�l�中各方之间的数据关�p�，②各�Ҏ��据的形式�?/p>

主要的数据关�p�L��3个：①通知发送方与通知接收方的数据关系�Q�②反馈发送方与反馈接收方的数据关�p�，③通知接收方与反馈接收方的数据关系。（如图 2�Q�在发送方�Q�数据（通知或反馈）是一件一件的发送，在接收方�Q�数据（通知或反馈）则是�Ҏ��Ӟ��是对应发送方数据的集合，因此在发送方没有必要把数据直�? 加工成XML文档对象形式�Q�只要生成能构成XML文档对象的元素对象即可；而通知接收方与反馈接收方的数据关系则是�Q�每一条征求意见性通知都有相关的一�? 反馈集合�?/p>

�pȝ��的数据流模型如下�Q?br> ①通知发送方�Q�表单数据→XML元素�Q�通知�Q�→主题(存储)
②通知接收方：主题(存储)→XML元素�Q�通知�Q�→XML文档�Q�通知�Q�→XSL昄��Q�含表单�Q?br> ③通知接收方到反馈接收�? XSL昄��Q�含表单�Q�→主题�Q�存储）
④反馈接收方�Q�主�?存储)→XML元素�Q�反馈）→XML文档�Q�反馈）→XSL昄��Q�含表单�Q?br> ⑤反馈发送方�Q�表单数据→XML元素�Q�反馈）→主�?存储)

2.2 �l��g模型

�pȝ��l��g模型如图3�Q�主题CWNFTopic是消息传递中介，NoticerServlet�l��g向发布用户发送表单，�q�从表单接收数据�Q�然后生�? XML元素对象�Q�该元素对象和其它一些数据被作�ؓ参数调用PublisherBean�l��g�Ҏ��Q�向主题发送以该元素对象�ؓ消息体的消息�Q? ReaderServlet�l��g处理�|�名用户和匿名用��h��阅通知的业务，它从表单获得用户��查阅什么方面通知的有关信息后�Q�便使用receive�Ҏ��限时 ��d��C��主题接收消息�q�对消息�q�行�{�选，把筛选出的若�q�消息的消息体取出，然后加工成XML文档对象�Q�根元素是通知集）�Q�最后输出�? FeedbackerPubServlet用于反馈发送方的业务处理，功能与NoticerServlet�怼��Q? FeedbackerSubServlet用于反馈接收方的业务处理�Q�功能与ReaderServlet�怼��Q�PublisherBean�l��g�? NoticerServlet�l��g和FeedbackerPubServlet�l��g调用�Q�用于发送消息，容器��理发送事务，��h��很高的可靠性�?/p>

3 关键的实现技�?/h4>

3.1 JDOM建立、输出XML文档

JDOM是一个开放源代码的纯Java树式API�Q�用于分析、徏立、处理和序列化XML文档。在数据��模型中�Q�XML元素和XML文档都由JDOM API建立�Q�在发送方�Q�通过用户提交的表单取得名/值对若干�Q�这些数据经�q�JDOM�Ҏ��处理生成XML元素对象�Q�元素对象被作�ؓ消息的消息体发往主题�? 储；在接收方�Q�持久订阅者接收到若干XML元素对象后，�l�箋通过JDOM�Ҏ��建立XML文档对象。且XML文档向Web��览器输��Z��依赖于JDOM�? XMLOutputte对象�Ҏ��Q?/p>

XMLOutputter serializer=new XMLOutputter();

PrintWriter out=response.getWriter(); // out 是ServletResponse的输出流对象
serializer.output(xmldoc,out); //通过out把XML文档输出到页�?/span>

3.2 XSL定义XML文档昄��样式

XSL是可扩展的样式单语言�Q�通知集的XML文档和反馈集的XML文档都有相关的XSL文档军_��光��面显�C�，如通知集XML文档的XSL样式定义如下�Q?/p>

xml version="1.0" encoding="GBK"?>
<xsl:stylesheet>
<xsl:template match="/">

<HTML>
<BODY>

<DIV><xsl:apply-templates select="通知�?/>DIV>
BODY>
HTML>

xsl:template>
<xsl:template match="通知�?>
<xsl:for-each select="通知">

xsl:for-each>
xsl:template>
xsl:stylesheet>

3.3 Servlet间数据的传�?/h4>

3.3.1 注册/��d��

用户的一些处理工作需要注�?��d��后才能进行，因此注册/��d��的获准信息必��能在有关Servlet�l��g之间传递。ServletContext 对象可设�|�和��d��属性，使不同Servlet之间�怺�通信�Q�在�pȝ��中被用于有关�l��g对用戯��n份的验证�?/p>

3.3.2 通知与反馈的数据兌��

每一条征求意见性通知都有一个相兌��的反馈集合，兌��可通过讄��消息属性实现。JMS消息�Q�包括通知�c�L��息）都有�pȝ��U�JMSMessageID�? 性，其值是唯一的，可用于表征每一条征求意见性通知�Q�因此对��M��反馈消息也可以设�|�一个应用��属性（CWNF中是FeedbackSN�Q�，让它取与之相�? 联的征求意见性通知的JMSMessageID属性倹{��这样就建立了两者间的数据关联�?/p>

因此数据��模�?③通知接收方到反馈接收�? XSL昄��Q�含表单�Q�→主题�Q�存储）"的实现流�E�如下：用户在页面上选择一条征求意见性通知后，该通知的JMSMessageID属性值将被传递给 FeedbackerSubServlet�l��g�Q�该�l��g��用这个属性值去匚w��从主题取出的反馈消息的FeedbackSN属性，从而筛选出相关联的反馈消息�?/p>

那么一条征求意见性通知的JMSMessageID属性值又如何传递给FeedbackerSubServlet�l��g呢？通过 ServletContext对象只能传递可预知信息�Q�CWNF的做法是�Q�由XSL为每一条征求意见性通知讄��一个独立的表单�Q��ƈ把该通知�? JMSMessageID属性值写在表单的TEXTAREA元素框内�Q�这��L��户在表单上选择一条征求意见性通知后，该通知的JMSMessageID属�? 值就随表单一��h��交给FeedbackerSubServlet�l��g。XSL有关代码如下�Q?/p>

<xsl:if test="string(意见反馈)='on'">
<FORM method="post" action="http://localhost:6888/Feedbacker/servlet
/FeedbackerSubServlet">
<BUTTON type="submit">意见反馈BUTTON>
<TEXTAREA name="序列�? rows="1" cols="40">
<xsl:value-of select="序列�?/>
TEXTAREA>
FORM>
xsl:if>

4 �l�束�?/h4>

JMS应用�pȝ��与数据库�pȝ��有相似性，从数据方面看�Q�JMS消息体的数据�c�d��支持文本和对象，所以JMS更灵�z�，与XML集成应用的空间更大；但从 ��理上看�Q�JMS Provider向管理员提供的管理功能远�q�低于DBMS提供的管理功能，因此在面向Web的应用中�Q�JMS宜作��Z��流量、管理员参与度较低的信息�pȝ�� 解决�Ҏ��?br>

转蝲自：http://gceclub.sun.com.cn/yuanchuang/2004_Q4/jms.html

Leo 2006-02-23 19:07 发表评论

Java虚拟机的深入研究

Leo — Thu, 23 Feb 2006 11:00:00 GMT

作者：刘学��?

1 Java技术与Java虚拟�?/b>

说�vJava�Q��h们首先想到的是Java�~�程语言�Q�然而事实上�Q�Java是一�U�技术，它由四方面组�? Java�~�程语言、Java�c�L��件格式、Java虚拟机和Java应用�E�序接口(Java API)。它们的关系如下图所�C�：

�?  Java四个斚w��的关�p?/p>
�q�行期环境代表着Java�q�_��Q�开发�h员编写Java代码(.java文�g)�Q�然后将之编译成字节�?.class 文�g)。最后字节码被装入内存，一旦字节码�q�入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的�{换成机器码执行。从上图也可以看�? Java�q�_��由Java虚拟机和Java应用�E�序接口搭徏�Q�Java语言则是�q�入�q�个�q�_��的通道�Q�用Java语言�~�写�q�编译的�E�序可以�q�行在这个��^��C��? �q�个�q�_��的结构如下图所�C�：

在Java�q�_��的结构中, 可以看出�Q�Java虚拟�?JVM) 处在核心的位�|�，是程序与底层操作�pȝ��和硬件无关的关键。它的下�Ҏ��U�L��接口�Q�移植接口由两部分组成：适配器和Java操作�pȝ��, 其中依赖于��^台的部分�U�Cؓ适配器；JVM 通过�U�L��接口在具体的�q�_��和操作系�l�上实现�Q�在JVM 的上�Ҏ��Java的基本类库和扩展�c�d��以及它们的API�Q?利用Java API�~�写的应用程�?application) 和小�E�序(Java applet) 可以在�Q何Java�q�_��上运行而无需考虑底层�q�_��, ��是因�ؓ有Java虚拟�?JVM)实现了程序与操作�pȝ��的分��，从而实��C��Java 的��^台无��x��?
那么到底什么是Java虚拟�?JVM)呢？通常我们谈论JVM�Ӟ��我们的意思可能是�Q?
对JVM规范的的比较抽象的说明；
对JVM的具体实玎ͼ�
在程序运行期间所生成的一个JVM实例�?

对JVM规范的的抽象说明是一些概�늚�集合�Q�它们已�l�在书《The Java Virtual Machine Specification》（《Java虚拟��范》）中被详细地描�q�C��Q�对JVM的具体实现要么是软�g�Q�要么是软�g和硬件的�l�合�Q�它已经被许多生产厂商所实现�Q��ƈ存在于多�U��^��C��上；�q�行Java�E�序的�Q务由JVM的运行期实例单个承担。在本文中我们所讨论的Java虚拟�?JVM)主要针对�W�三�U�情况而言。它可以被看成一个想象中的机器，在实际的计算��Z��通过软�g模拟来实玎ͼ�有自己想象中的硬�Ӟ��如处理器、堆栈、寄存器�{�，�q�有自己相应的指令系�l��?/p>
JVM在它的生存周期中有一个明��的��d��Q�那��是�q�行Java�E�序�Q�因此当Java�E�序启动的时候，��׃�生JVM的一个实例；当程序运行结束的时候，该实例也跟着消失了。下面我们从JVM的体�pȝ��构和它的�q�行�q�程�q�两个方面来对它�q�行比较深入的研�I��?
2  Java虚拟机的体系�l�构

刚才已经提到�Q�JVM可以�׃��同的厂商来实现。由于厂商的不同必然��D��JVM在实��C��的一些不同，然而JVM�q�是可以实现跨��^台的�Ҏ��，�q�就要归功于设计JVM时的体系�l�构了�?/p>
我们知道�Q�一个JVM实例的行��Z��光是它自��q��事，�q�涉及到它的子系�l�、存储区域、数据类型和指��o�q�些部分�Q�它们描 �q�C��JVM的一个抽象的内部体系�l�构�Q�其目的不光规定实现JVM时它内部的体�pȝ��构，更重要的是提供了一�U�方式，用于严格定义实现时的外部行�ؓ。每�? JVM都有两种机制�Q�一个是装蝲��h��合适名�U�的�c?�c�L��是接�?�Q�叫做类装蝲子系�l�；另外的一个负责执行包含在已装载的�c�L��接口中的指��o�Q�叫做运行引擎�? 每个JVM又包括方法区、堆、Java栈、程序计数器和本地方法栈�q�五个部分，�q�几个部分和�c�装载机制与�q�行引擎机制一��L��成的体系�l�构图�ؓ�Q?/p>

�?  JVM的体�pȝ��?/p>
JVM的每个实例都有一个它自己的方法域和一个堆�Q�运行于JVM内的所有的�U�程都共享这些区域；当虚拟机装蝲�c�L��? 的时候，它解析其中的二进制数据所包含的类信息�Q��ƈ把它们放到方法域中；当程序运行的时候，JVM把程序初始化的所有对象置于堆上；而每个线�E�创建的�? 候，都会拥有自己的程序计数器和Java栈，其中�E�序计数器中的值指向下一条即��被执行的指令，�U�程的Java栈则存储��U�程调用Java�Ҏ��的状态；本地�Ҏ��调用的状态被存储在本地方法栈�Q�该�Ҏ��栈依赖于具体的实现�?/p>
下面分别对这几个部分�q�行说明�?/p>
执行引擎处于JVM的核心位�|�，在Java虚拟��范中�Q�它的行为是由指令集所军_��的。尽��对于每条指令，规范很详 �l�地说明了当JVM执行字节码遇到指令时�Q�它的实现应该做什么，但对于怎么做却�a�之甚��。Java虚拟机支持大�U?48个字节码。每个字节码执行一�U�基�? 的CPU�q�算,例如,把一个整数加到寄存器,子程序�{�Uȝ��。Java指��o集相当于Java�E�序的汇�~�语�a��?/p>
Java指��o集中的指令包含一个单字节的操作符,用于指定要执行的操作,�q�有0个或多个操作�?提供操作所需的参数或数据。许多指令没有操作数,仅由一个单字节的操作符构成�?/p>
虚拟机的内层循环的执行过�E�如�?
do{
取一个操作符字节;
�Ҏ��操作�W�的值执行一个动�?
}while(�E�序未结�?

�׃��指��o�pȝ��的简单�?使得虚拟机执行的�q�程十分��?从而有利于提高执行的效率。指令中操作数的数量和大��是由操作符军_��的。如果操作数比一个字节大,那么它存储的��序是高位字节优先。例�?一�?6位的参数存放时占用两个字�?其��gؓ:
�W�一个字�?256+�W�二个字节字节码�?
指��o��一般只是字节对齐的。指令tableswitch和lookup是例�?在这两条指��o内部要求强制�?字节边界寚w��?
对于本地�Ҏ��接口�Q�实现JVM�q�不要求一定要有它的支持，甚至可以完全没有。Sun公司实现Java本地�? �?JNI)是出于可�U�L��性的考虑�Q�当然我们也可以设计出其它的本地接口来代替Sun公司的JNI。但是这些设计与实现是比较复杂的事情�Q�需要确保垃圑֛� 收器不会��那些正在被本地�Ҏ��调用的对象释放掉�?
Java的堆是一个运行时数据�?�cȝ��实例(对象)从中分配�I�间�Q�它的管理是由垃圑֛�收来负责�?不给�E�序员显式释攑֯�象的能力。Java不规定具体��用的垃圾回收��法,可以�Ҏ��pȝ��的需求��用各�U�各��L��法�?
Java�Ҏ��Z��传统语言中的�~�译后代码或是Unix�q�程中的正文�D늱�伹{��它保存�Ҏ��代码(�~�译后的 java代码)和符可��。在当前的Java实现�?�Ҏ��代码不包括在垃圾回收堆中,但计划在��来的版本中实现。每个类文�g包含了一个Java�c�L��一�? Java界面的编译后的代码。可以说�c�L��件是Java语言的执行代码文件。�ؓ了保证类文�g的��^台无��x�?Java虚拟��范中对类文�g的格式也作了详细�? 说明。其具体�l�节请参考Sun公司的Java虚拟��范�?
Java虚拟机的寄存器用于保存机器的�q�行状�?与微处理器中的某些专用寄存器�c�M��。Java虚拟机的寄存器有四种:

pc: Java�E�序计数器；
optop: 指向操作数栈��端的指针；
frame: 指向当前执行�Ҏ��的执行环境的指针�Q��?
vars: 指向当前执行�Ҏ��的局部变量区�W�一个变量的指针�?

在上�q�C��pȝ��构图中，我们所说的是第一�U�，即程序计数器�Q�每个线�E�一旦被创徏��拥有了自己的程序计数器。当�U�程执行Java�Ҏ��的时候，它包含该�U�程正在被执行的指��o的地址。但是若�U�程执行的是一个本地的�Ҏ��Q�那么程序计数器的值就不会被定义�?
Java虚拟机的栈有三个区域:局部变量区、运行环境区、操作数区�?/p>
局部变量区

每个Java�Ҏ��使用一个固定大��的局部变量集。它们按照与vars寄存器的字偏�U�量来寻址。局部变量都�?2�? 的。长整数和双�_�ֺ��点数占据了两个局部变量的�I�间,却按照第一个局部变量的索引来寻址�?例如,一个具有烦引n的局部变�?如果是一个双�_�ֺ��点�?�? 么它实际占据了烦引n和n+1所代表的存储空�?虚拟��范�ƈ不要求在局部变量中�?4位的值是64位对齐的。虚拟机提供了把局部变量中的��D��载到操作�? 栈的指��o,也提供了把操作数栈中的值写入局部变量的指��o�?/p>
�q�行环境�?/b>

在运行环境中包含的信息用于动态链�?正常的方法返回以及异常捕捉�?
动态链�?/b>
�q�行环境包括�Ҏ��向当前类和当前方法的解释器符可��的指�?用于支持�Ҏ��代码的动态链接。方法的class 文�g代码在引用要调用的方法和要访问的变量时��用符受��动态链接把�W�号形式的方法调用翻译成实际�Ҏ��调用,装蝲必要的类以解释还没有定义的符�?�q�把变量讉K��译成与�q�些变量�q�行时的存储�l�构相应的偏�U�d��址。动态链接方法和变量使得�Ҏ��中��用的其它�cȝ��变化不会影响到本�E�序的代码�?
正常的方法返�?/b>
如果当前�Ҏ��正常地结束了,在执行了一条具有正��类型的�q�回指��o�?调用的方法会得到一个返回倹{��执行环境在正常�q�回的情况下用于恢复调用者的寄存�?�q�把调用者的�E�序计数器增加一个恰当的数�?以蟩�q�已执行�q�的�Ҏ��调用指��o,然后在调用者的执行环境中��l�执行下厅R�?
异常捕捉
异常情况在Java中被�U�C��Error(错误)或Exception(异常),是Throwable�cȝ��子类,在程序中的原因是:①动态链接错,如无法找到所需的class文�g。②�q�行旉��,如对一个空指针的引用。程序��用了throw语句�?
当异常发生时,Java虚拟机采取如下措�?
��查与当前�Ҏ��相联�pȝ��catch子句表。每个catch子句包含其有效指令范�?能够处理的异常类�?以及处理异常的代码块地址�?
与异常相匚w��的catch子句应该�W�合下面的条�?造成异常的指令在其指令范围之�?发生的异常类型是其能处理的异常类型的子类型。如果找��C��匚w��的catch子句,那么�pȝ��转移到指定的异常处理块处执行;如果没有扑ֈ�异常处理�?重复��L��匚w��的catch子句的过�E?直到当前�Ҏ��的所有嵌套的catch子句都被��查过�?
�׃��虚拟��Z��W�一个匹配的catch子句处��l�执�?所以catch子句表中的顺序是很重要的。因为Java代码是结构化�?因此�? 可以把某个方法的所有的异常处理器都按序排列��C��个表�?对�Q意可能的�E�序计数器的�?都可以用�U�性的��序扑ֈ�合适的异常处理�?以处理在该程序计数器�? 下发生的异常情况�?
如果找不到匹配的catch子句,那么当前�Ҏ��得到一�?未截获异�?的结果�ƈ�q�回到当前方法的调用�?好像异常刚刚在其调用者中�? 生一栗��如果在调用者中仍然没有扑ֈ�相应的异常处理块,那么�q�种错误��被传播下去。如果错误被传播到最��层,那么�pȝ��调用一个缺省的异常处理块�?

操作数栈�?/b>

机器指��o只从操作数栈中取操作�?对它们进行操�?�q�把�l�果�q�回到栈中。选择栈结构的原因�?在只有少量寄存器或非通用寄存器的机器(如Intel486)�?也能够高效地模拟虚拟机的行�ؓ。操作数栈是32位的。它用于�l�方法传递参�?�q�从�Ҏ��接收�l�果,也用于支持操作的参数,�q�保存操作的�l�果。例�?iadd指��o��两个整数相加。相加的两个整数应该是操作数栈顶的两个字。这两个字是由先前的指��o压进堆栈的。这两个�? 数将从堆栈弹出、相�?�q�把�l�果压回到操作数栈中�?
每个原始数据�c�d��都有专门的指令对它们�q�行必须的操作。每个操作数在栈中需要一个存储位�|?除了long 和double�?它们需要两个位�|�。操作数只能被适用于其�c�d��的操作符所操作。例�?压入两个int�c�d��的数,如果把它们当作是一个long�c�d��的数�? 是非法的。在Sun的虚拟机实现�?�q�个限制由字节码验证器强制实行。但�?有少数操�?操作�W�dupe和swap),用于对运行时数据��行操作时是不考虑�c�d��的�?
本地�Ҏ��栈，当一个线�E�调用本地方法时�Q�它��׃��再受到虚拟机关于�l�构和安全限制方面的�U�束�Q�它既可以访�? 虚拟机的�q�行期数据区�Q�也可以使用本地处理器以及�Q何类型的栈。例如，本地栈是一个C语言的栈�Q�那么当C�E�序调用C函数�Ӟ��函数的参��C��某种��序被压�? 栈，�l�果则返回给调用函数。在实现Java虚拟机时�Q�本地方法接口��用的是C语言的模型栈�Q�那么它的本地方法栈的调度与使用则完全与C语言的栈相同�?/p>
3  Java虚拟机的�q�行�q�程

上面对虚拟机的各个部分进行了比较详细的说明，下面通过一个具体的例子来分析它的运行过�E��?/p>
虚拟机通过调用某个指定�cȝ��Ҏ��main启动�Q�传递给main一个字�W�串数组参数�Q��指定的类被装载，同时链接该类所使用的其它的�c�d��Q��ƈ且初始化它们。例如对于程序：
class HelloApp
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
        for (int i = 0; i < args.length; i++ )
        {
            System.out.println(args[i]);
        }
    }
}

�~�译后在命��o行模式下键入�Q?java HelloApp run virtual machine
��通过调用HelloApp的方法main来启动java虚拟机，传递给main一个包含三个字�W�串"run"�?virtual"�?machine"的数�l�。现在我们略�q�虚拟机在执行HelloApp时可能采取的步骤�?
开始试图执行类HelloApp的main�Ҏ��Q�发现该�c�dƈ没有被装载，也就是说虚拟机当前不包含该类的二 �q�制代表�Q�于是虚拟机使用ClassLoader试图��L��q�样的二�q�制代表。如果这个进�E�失败，则抛��Z��个异常。类被装载后同时在main�Ҏ��被调用之前，必须对类HelloApp与其它类型进行链接然后初始化。链接包含三个阶�D�：��验，准备和解析。检验检查被装蝲的主�cȝ��W�号和语义，准备则创建类或接口的静态域以及把这些域初始化�ؓ标准的默认��|��解析负责��查主�c�d��其它�c�L��接口的符号引用，在这一步它是可选的。类的初始化是对�c�M��声明的静态初始化函数和静态域的初始化构造方法的执行。一个类在初始化之前它的父类必须被初始化。整个过�E�如下：

�?�Q�虚拟机的运行过�E?/p>
4  �l�束�?/b>

本文通过对JVM的体�pȝ��构的深入研究以及一个Java�E�序执行时虚拟机的运行过�E�的详细分析�Q�意在剖析清楚Java虚拟机的机理�?br>

转蝲自：http://gceclub.sun.com.cn/staticcontent/html/2004-04-09/jvm.html

Leo 2006-02-23 19:00 发表评论

Leo — Thu, 23 Feb 2006 10:43:00 GMT

作者：盛戈�?/a>

作者简�?/b>

盛戈歆，软�g工程师，你可以通过shenggexin@topwaver.com与他联系�?/p>
正文

Java中类的查找与装蝲出现的问题��L��会时不时出现在Java�E�序员面前，�q��ƈ不是什么丢脸的事情�Q�相信没有一�? Java�E�序员没遇到�q�ClassNotException,因此不要��人瞅见自�׃��犯这��L��错误而觉得不自然�Q�但是在如果出现�? ClassNotFoundException后异常后一脸的茫然�Q�那我想你该了解一下java的类装蝲的体制了�Q�同时�ؓ了进行下面的关于�c�装载器之间�? 隔离性的讨论�Q�我们先��单介�l�一下类装蝲的体�pȝ��构�?/p>
1. Java�c�装载体�pȝ��?/b>

装蝲�cȝ��q�程非常��单：查找�c�L��在位�|�，�q�将扑ֈ�的Java�cȝ��字节码装入内存，生成对应的Class对象�? Java的类装蝲器专门用来实现这��L��q�程�Q�JVM�q�不止有一个类装蝲器，事实上，如果你愿意的话，你可以让JVM拥有无数个类装蝲器，当然�q�除了测�? JVM外，我想不出�q�有其他的用途。你应该已经发现��C��q�样一个问题，�c�装载器自��n也是一个类�Q�它也需要被装蝲到内存中来，那么�q�些�c�装载器��p��来装�? 呢，��d��有个根吧�Q�没错，��实存在�q�样的根�Q�它��是��龙见首不见��Bootstrap ClassLoader. ��Z��么说它神龙见首不见尾呢，因�ؓ你根本无法在Java代码中抓住哪怕是它的一点点的尾��_��管你能时时��d��体会到它的存在，因�ؓjava的运行环境所需要的所有类库，都由它来装蝲�Q�而它本��n是C++写的�E�序�Q�可以独立运�?可以说是JVM的运行�v�?伟大吧。在Bootstrap完成它的��d��后，会生�? 一个AppClassLoader(实际上之前系�l�还会��用扩展类装蝲器ExtClassLoader�Q�它用于装蝲Java�q�行环境扩展包中的类),�q�个 �c�装载器才是我们�l�常使用的，可以调用ClassLoader.getSystemClassLoader() 来获得，我们假定�E�序中没有��用类装蝲器相��x��作设定或者自定义新的�c�装载器�Q�那么我们编写的所有java�c�通通会由它来装载，值得��敬吧�? AppClassLoader查找�cȝ��区域��是耳熟能详的Classpath�Q�也是初学者必��跨�q�的门槛�Q�有没有灵光一闪的感觉�Q�我们按照它的类查找范围 �l�它取名为类路径�c�装载器。还是先前假定的情况�Q�当Java中出现新的类�Q�AppClassLoader首先在类传递给它的父类�c�装载器�Q�也��是 Extion ClassLoader�Q�询问它是否能够装蝲该类�Q�如果能�Q�那AppClassLoader��׃��q�这�z�M��Q�同样Extion ClassLoader在装载时�Q�也会先问问它的父类装蝲器。我们可以看出类装蝲器实际上是一个树状的�l�构图，每个�c�装载器有自��q��父亲�Q�类装蝲器在装蝲 �c�L��Q��L��先让自己的父�c�装载器装蝲(多么��敬长辈),如果父类装蝲器无法装载该�c�L��Q�自己就会动手装载，如果它也装蝲不了�Q�那么对不�v�Q�它会大喊一壎ͼ� Exception�Q�class not found。有必要提一句，当由直接使用�c��\径装载器装蝲�c�d��败抛出的是NoClassDefFoundException异常。如果��用自定义的类装蝲器loadClass�Ҏ��或者ClassLoader的findSystemClass�Ҏ��装蝲�c�，如果你不��d��意改变，那么抛出的是 ClassNotFoundException�?/p>
我们��短�ȝ��一下上面的讨论�Q?/p>
1.JVM�c�装载器的体�pȝ��构可以看作是树状�l�构�?/p>
2.父类装蝲器优先装载。在父类装蝲器装载失败的情况下再装蝲�Q�如果都装蝲��p�|则抛出ClassNotFoundException或者NoClassDefFoundError异常�?/p>
那么我们的类在什么情况下被装载的呢？
2. �c�d��何被装蝲
在java2中，JVM是如何装载类的呢�Q�可以分��Z��U�类型，一�U�是隐式的类装蝲�Q�一�U�式昑ּ�的类装蝲�?/p> 2.1 隐式的类装蝲
隐式的类装蝲是编码中最常用得方式：

A b = new A();

如果�E�序�q�行到这�D�代码时�q�没有A�c�，那么JVM会请求装载当前类的类装器来装载类�? 问题来了�Q�我把代码弄得复杂一点点�Q�但依旧没有��M��隑ֺ��Q�请思考JVM得装载次序：

1 package test;
2 Public class A{
3     public void static main(String args[]){
4         B b �Q?nbsp;new B();
5     }
6 }
7
8 class B{C c;}
9
10 class C{}

揭晓�{�案�Q�类装蝲的次序�ؓA->B�Q�而类C�Ҏ��不会被JVM理会,先不要惊�Ӟ��仔细��x��Q�这不正是我们最需�? 得到的结果。我们仔�l�了解一下JVM装蝲��序。当使用Java A命��o�q�行A�c�L��Q�JVM会首先要求类路径�c�装载器(AppClassLoader)装蝲A�c�，但是�q�时只装载A�Q�不会装载A中出现的其他�c?B�c?�Q�接着它会调用A中的main函数�Q�直到运行语句b �Q?new B()�Ӟ��JVM发现必须装蝲B�cȝ��序才能��l�运行，于是�c��\径类装蝲器会去装载B�c�，虽然我们可以看到B中有有C�cȝ��声明�Q�但是�ƈ不是实际的执行语句，所以�ƈ不去装蝲C�c�，也就是说JVM按照�q�行时的有效执行语句�Q�来军_��是否需要装载新�c�，从而装载尽可能��的�c�，�q�一点和�~�译�c�L��不相同的�?/p>
2.2 昑ּ�的类装蝲

使用昄��的类装蝲�Ҏ��很多�Q�我们都装蝲�c�test.A��Z��?/p>
使用Class�cȝ��forName�Ҏ��。它可以指定装蝲器，也可以��用装载当前类的装载器。例如：

Class.forName("test.A");

它的效果�?br>
Class.forName("test.A",true,this.getClass().getClassLoader());

是一��L��?br>

使用�c��\径类装蝲装蝲.

ClassLoader.getSystemClassLoader().loadClass("test.A");

使用当前�q�程上下文的使用的类装蝲器进行装载，�q�种装蝲�cȝ��Ҏ��常常被有着复杂�c�装载体�pȝ��构的�pȝ��所使用�?/p>
Thread.currentThread().getContextClassLoader().loadClass("test.A")

使用自定义的�c�装载器装蝲�c?/p>
1 public class MyClassLoader extends URLClassLoader{
2 public MyClassLoader() {
3         super(new URL[0]);
4     }
5 }
6 MyClassLoader myClassLoader = new MyClassLoader();
7 myClassLoader.loadClass("test.A");

MyClassLoader�l�承了URLClassLoader�c�，�q�是JDK核心包中的类装蝲器，在没有指定父�c�装载器的情况下�Q�类路径�c�装载器��是它的父类装蝲器，MyClassLoader�q�没有增加类的查找范��_��因此它和�c��\径装载器有相同的效果�?/p>
我们已经知道Java的类装蝲器体�pȝ��构�ؓ树状�Q�多个类装蝲器可以指定同一个类装蝲器作��q��父类�Q�每个子�c�装�? 器就是树状结构的一个分支，当然它们又可以个有子�c�装载器�c�装载器�Q�类装蝲器也可以没有父类装蝲器，�q�时Bootstrap�c�装载器��作为它的隐含父�c�，实际上Bootstrap�c�装载器是所有类装蝲器的��先�Q�也是树状结构的栏V��这�U�树状体�pȝ��构，以及父类装蝲器优先的机制�Q��ؓ我们�~�写自定义的�c�装载器�? 供了便利�Q�同时可以让�E�序按照我们希望的方式进行类的装载。例如某个程序的�c�装载器体系�l�构囑֦�下：

�?�Q�某个程序的�c�装载器的结�?/p>
解释一下上面的图，ClassLoaderA��定义的类装蝲器，它的父类装蝲器�ؓ�c��\径装载器�Q�它有两个子�c�装�? 器ClassLoaderAA和ClassLaderAB�Q�ClassLoaderB为程序��用的另外一个类装蝲器，它没有父�c�装载器�Q�但有一个子�c�装�? 器ClassLoaderBB。你可能会说�Q�见��|��我的�E�序怎么会��用这么复杂的�c�装载器�l�构。�ؓ了进行下面的讨论�Q�暂且委屈一下�?/p>
3. 奇怪的隔离�?/b>

我们不难发现�Q�图2中的�c�装载器AA和AB�Q? AB和BB�Q�AA和B�{�等位于不同分支下，他们之间没有父子关系�Q�我不知道如何定义这�U�关�p�，姑且�U�C��们位于不同分支下。两个位于不同分支的�c�装载器��h�� 隔离性，�q�种隔离性��得在分别使用它们装蝲同一个类�Q�也会在内存中出��C��个Class�cȝ��实例。因��h��隔离性的�c�装载器装蝲的类不会�׃�n内存�I�间�Q�� 得��用一个类装蝲器不可能完成的�Q务变得可以轻而易举，例如�cȝ��静态变量可能同时拥有多个��|��虽然好像作用不大�Q�，因�ؓ��q��是被装蝲�cȝ��同一静态变量，�? 们也��被保存不同的内存空��_��又例如程序需要��用某些包�Q�但又不希望被程序另外一些包所使用�Q�很��单，�~�写自定义的�c�装载器。类装蝲器的�q�种隔离性在许多大型的��Y件应用和服务�E�序得到了很好的应用。下面是同一个类静态变量�ؓ不同值的例子�?/p>
1 package test;
2 public class A {
3   public static void main( String[] args ) {
4     try {
5       //定义两个�c�装载器
6       MyClassLoader aa= new MyClassLoader();
7       MyClassLoader bb = new MyClassLoader();
8
9       //用类装蝲器aa装蝲testb.B�c?/span>
10       Class clazz=aa.loadClass("testb. B");
11       Constructor constructor=
12         clazz.getConstructor(new Class[]{Integer.class});
13       Object object =
14         constructor.newInstance(new Object[]{new Integer(1)});
15       Method method =
16         clazz.getDeclaredMethod("printB",new Class[0]);
17
18       //用类装蝲器bb装蝲testb.B�c?/span>
19       Class clazz2=bb.loadClass("testb. B");
20       Constructor constructor2 =
21         clazz2.getConstructor(new Class[]{Integer.class});
22       Object object2 =
23         constructor2.newInstance(new Object[]{new Integer(2)});
24       Method method2 =
25         clazz2.getDeclaredMethod("printB",new Class[0]);
26
27       //昄��test.B中的静态变量的�?nbsp;
28       method.invoke( object,new Object[0]);
29       method2.invoke( object2,new Object[0]);
30     } catch ( Exception e ) {
31       e.printStackTrace();
32     }
33   }
34 }
35
36
37 //Class B 必须位于MyClassLoader的查找范围内�Q?br>38 //而不应该在MyClassLoader的父�c�装载器的查找范围内�?/span>
39 package testb;
40 public class B {
41     static int b ;
42
43     public B(Integer testb) {
44         b = testb.intValue();
45     }
46
47     public void printB() {
48         System.out.print("my static field b is ", b);
49     }
50 }
51
52
53 public class MyClassLoader extends URLClassLoader{
54   private static File file = new File("c:\\classes ");
55   //该�\径存攄��class B�Q�但是没有class A
56
57   public MyClassLoader() {
58     super(getUrl());
59   }
60
61   public static URL[] getUrl() {
62     try {
63       return new URL[]{file.toURL()};
64     } catch ( MalformedURLException e ) {
65       return new URL[0];
66     }
67   }
68 }

�E�序的运行结果�ؓ�Q?
my static field b is 1
my static field b is 2

�E�序的结果非常有意思，从编�E�者的角度�Q�我们甚臛_��以把不在同一个分支的�c�装载器看作不同的java虚拟机，因�ؓ�? 们彼此觉察不到对方的存在。程序在使用��h��分支的类装蝲的体�pȝ��构时要非常小心，弄清楚每个类装蝲器的�c�L��找范��_��量避免父类装蝲器和子类装蝲器的�c�L�� 找范围中有相同类名的�c�（包括包名和类名）�Q�下面这个例子就是用来说明这�U�情况可能带来的问题�?/p>
假设有相同名字却不同版本的接�?A�Q?/p>
版本 1�Q?br>
package test;
Intefer Same{ public String getVersion(); }

版本 2�Q?br>
Package test;
Intefer Same{ public String getName(); }

接口A两个版本的实玎ͼ�

版本1的实�?br>
package test;
public class Same1Impl implements Same {
public String getVersion(){ return "A version 1";}
}

版本2的实�?br>
public class Same 2Impl implements Same {
public String getName(){ return "A version 2";}
}

我们依然使用�?的类装蝲器结构，首先��版�?的Same和Same的实现类Same1Impl打成�? same1.jar�Q�将版本2的Same和Same的实现类Same1Impl打成包same2.jar。现在，做这��L��事情�Q�把same1.jar攑օ� �c�装载器ClassLoaderA的类查找范围中，把same2.jar攑օ��c�装器ClassLoaderAB的类查找范围中。当你兴冲冲的运行下面这�? 看似正确的程序�?/p>
实际上这个错误的是由父类载器优先装蝲的机刉��成�Q�当�c�装载器ClassLoaderAB在装载Same2Impl �c�L��发现必须装蝲接口test.Same�Q�于是按规定��h��父类装蝲器装载，父类装蝲器发��C��版本1的test.Same接口�q�兴冲冲的装载，但是却想不到 Same2Impl所希望的是版本2 的test.Same�Q�后面的事情可想而知了，异常被抛出�?/p>
我们很难责怪Java中暂时�ƈ没有提供区分版本的机�Ӟ��如果使用了比较复杂的�c�装载器体系�l�构�Q�在出现了某个包或者类的多个版本时�Q�应特别注意�?/p> 掌握和灵�z�运用Java的类装蝲器的体系�l�构�Q�对�E�序的系�l�设计，�E�序的实玎ͼ�已经�E�序的调试，都有相当大的帮助。希望以上的内容能够�Ҏ��有所帮助.

转蝲自：http://gceclub.sun.com.cn/yuanchuang/week-9/classloader.html

Leo 2006-02-23 18:43 发表评论