进行 T-SQL 编程时常常会忽略编码标准，但这些标准却是开发小组顺利开展工作的关键工具。这里介绍的编码标准是我多年的开发成果。它们当然还没有得到普遍接受，而且不可否认，有些标准带有主观色彩。我的目的实际上更多的是为了提高大家的意识，而不是吹捧自己是 T-SQL 样式方面的仲裁者：最重要的是要建立某些合理的编码标准并遵循这些标准。您在这篇文章中会发现有关 T-SQL 编程的一系列不同的编码标准、技巧和提示。它们并未以任何特定的优先级或重要性顺序列出。

让我们从格式开始。表面上，T-SQL 代码的格式似乎并不重要，但一致的格式可以使您的同事（不论是同一小组的成员还是更大范围的 T-SQL 开发团队的成员）更轻松地浏览和理解您的代码。T-SQL 语句有一个结构，遵循一目了然的结构使您可以更轻松地查找和确认语句的不同部分。统一的格式还使您可以更轻松地在复杂 T-SQL 语句中增删代码段，使调试工作变得更容易。下面是 SELECT 语句的格式示例：

       SELECT C.Name
, E.NameLast
, E.NameFirst
, E.Number
, ISNULL(I.Description,'NA') AS Description
FROM tblCompany AS C
JOIN tblEmployee AS E
ON C.CompanyID = E.CompanyID
LEFT JOIN tblCoverage AS V
ON E.EmployeeID = V.EmployeeID
LEFT JOIN tblInsurance AS I
ON V.InsuranceID = I.InsuranceID
WHERE C.Name LIKE @Name
AND V.CreateDate > CONVERT(smalldatetime,
'01/01/2000')
ORDER BY C.Name
, E.NameLast
, E.NameFirst
, E.Number
, ISNULL(I.Description,'NA')
SELECT @Retain = @@ERROR, @Rows = @@ROWCOUNT
IF @Status = 0 SET @Status = @Retain

►一个嵌套代码块中的语句使用四个空格的缩进。（上述代码中的多行 SELECT 语句是一个 SQL 语句。）在同一语句中开始新行时，使 SQL 关键字右对齐。将代码编辑器配置为使用空格，而不是使用制表符。这样，不管使用何种程序查看代码，格式都是一致的。

►大写所有的 T-SQL 关键字，包括 T-SQL 函数。变量名称及光标名称使用混和大小写。数据类型使用小写。

►表名别名要简短，但意义要尽量明确。通常，使用大写的表名作为别名，使用 AS 关键字指定表或字段的别名。

►当一个 T-SQL 语句中涉及到多个表时，始终使用表名别名来限定字段名。这使其他人阅读起来更清楚，避免了含义模糊的引用。

►当相关数字出现在连续的代码行中时（例如一系列 SUBSTRING 函数调用），将它们排成列。这样容易浏览数字列表。

►使用一个（而不是两个）空行分隔 T-SQL 代码的逻辑块，只要需要就可以使用。

►声明 T-SQL 局部变量（例如 @lngTableID）时，使用适当的数据类型声明和一致的大写。

►始终指定字符数据类型的长度，并确保允许用户可能需要的最大字符数，因为超出最大长度的字符会丢失。

►始终指定十进制数据类型的精度和范围，否则，将默认为未指定精度和整数范围。

►使用错误处理程序，但要记住行首 (BOL) 中的错误检查示例不会象介绍的那样起作用。用来检查 @@ERROR 系统函数的 T-SQL 语句 (IF) 实际上在进程中清除了 @@ERROR 值，无法再捕获除零之外的任何值。（即使示例起作用，它们也只能捕获最后发生的一个错误，而不是您更想捕获的第一个错误。）必须使用 SET 或 SELECT 立即捕获错误代码，如前面示例所示。如果状态变量仍然为零，应转换到状态变量。

►避免使用“未声明的”功能，例如系统表中未声明的列、T-SQL 语句中未声明的功能或者未声明的系统存储过程或扩展的存储过程。

►不要依赖任何隐式的数据类型转换。例如，不能为数字变量赋予字符值，而假定 T-SQL 会进行必要的转换。相反，在为变量赋值或比较值之前，应使用适当的 CONVERT 函数使数据类型相匹配。另一个示例：虽然 T-SQL 会在进行比较之前对字符表达式进行隐式且自动的 RTRIM，但不能依赖此行为，因为兼容性级别设置非字符表达式会使情况复杂化。

►不要将空的变量值直接与比较运算符（符号）比较。如果变量可能为空，应使用 IS NULL 或 IS NOT NULL 进行比较，或者使用 ISNULL 函数。

►不要使用 STR 函数进行舍入，此函数只能用于整数。如果需要十进制值的字符串形式，应先使用 CONVERT 函数（转至不同的范围）或 ROUND 函数，然后将其转换为字符串。也可以使用 CEILING 和 FLOOR 函数。

►使用数学公式时要小心，因为 T-SQL 可能会将表达式强制理解为一个不需要的数据类型。如果需要十进制结果，应在整数常量后加点和零 (.0)。

►决不要依赖 SELECT 语句会按任何特定顺序返回行，除非在 ORDER BY 子句中指定了顺序。

►通常，应将 ORDER BY 子句与 SELECT 语句一起使用。可预知的顺序（即使不是最方便的）比不可预知的顺序强，尤其是在开发或调试过程中。（部署到生产环境中之前，可能需要删除 ORDER BY 子句。）在返回行的顺序无关紧要的情况下，可以忽略 ORDER BY 的开销。

►不要在 T-SQL 代码中使用双引号。应为字符常量使用单引号。如果没有必要限定对象名称，可以使用（非 ANSI SQL 标准）括号将名称括起来。

►在 SQL Server 2000 中，尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

►先在例程中创建临时表，最后再显式删除临时表。将 DDL 与 DML 语句混合使用有助于处理额外的重新编译活动。

►要认识到临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

►使用表值 UDF 时要小心，因为在变量（而不是常量）中传递某个参数时，如果在 WHERE 子句中使用该参数，会导致表扫描。还要避免在一个查询中多次使用相同的表值 UDF。但是，表值 UDF 确实具有某些非常方便的动态编译功能。[相关资料：参阅 Tom Moreau 在 2003 年 11 月份“生成序列号”专栏中的“使用 UDF 填充表变量”。－编者按］

►几乎所有的存储过程都应在开始时设置 SET NOCOUNT ON，而在结束时设置 SET NOCOUNT OFF。[SET NOCOUNT ON 使 SQL Server 无需在执行存储过程的每个语句后向客户端发送 DONE_IN_PROC 消息。- 编者按] 此标准同样适用于触发器。

►只要在例程中使用多个数据库修改语句，包括在一个循环中多次执行一个语句，就应考虑声明显式事务。

►使用基于光标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题。基于集的方法通常更有效。

►与临时表一样，光标并不是不可使用。对小型数据集使用 FAST_FORWARD 光标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用光标执行的速度快。如果开发时间允许，基于光标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

►使用包含序号（从 1 到 N）的表很方便。

►理解 CROSS JOIN 的工作原理并加以利用。例如，您可以在工作数据表和序号表之间有效地使用 CROSS JOIN，结果集中将包含每个工作数据与序号组合的记录。

►我的结束语是：T-SQL 代码往往很简洁，因此如果某个代码块看起来很难处理或重复内容较多，那么可能存在一种更简单，更好的方法。

结论

如果您对我的建议有任何看法，欢迎随时向我发送电子邮件进行讨论，也可以就其他问题提出您的建议。我希望您将此作为谈话的开场白。

其他信息：摘自 Karen 2000 年 2 月份的社论

在标准开发的前沿阵地上，有一股以 SQL Server 数据库管理员 John Hindmarsh 为首的独立的新生力量。MCT、MCSE 和 MCDBA 都是最值得您花时间去研究的。John 的贡献是撰写了一份详细的白皮书，概述了他对各种 SQL Server 相关标准提出的建议。我所知道的其他唯一提出类似建议的文章是 Andrew Zanevsky 的《Transact-SQL Programming》(ISBN 1-56592-401-0) 中的“Format and Style”一章。Andrew、SQL Server Professional 的投稿人 Tom Moreau 和 Paul Munkenbeck 以及 John 的朋友兼同事 Stephen James 都为 John 的白皮书做出过贡献。下面是 John 为编写存储过程提供的建议示例：

下载 412BRIAN.ZIP

链接至www.microsoft.com/downloads/details.aspx?displayla%20ng=en&familyid=B352EB1F-D3CA-44EE-893E-9E07339C1F22&displaylang=en

有关 SQL Server Professional 和 Pinnacle Publishing 的详细信息，请访问其 Web 站点 http://www.pinpub.com/

注意：这不是 Microsoft Corporation 的 Web 站点。Microsoft 对该 Web 站点上的内容不承担任何责任。

本文转载自 2004 年 12 月份的 SQL Server Professional。除非另行说明，否则版权所有 2004 Pinnacle Publishing, Inc.。保留所有权利。SQL Server Professional 是 Pinnacle Publishing 独立发行的刊物。未经 Pinnacle Publishing, Inc. 事先同意，不得以任何方式使用或复制本文的任何部分（评论文章中的简短引用除外）。如需与 Pinnacle Publishing, Inc. 联系，请拨打 1-800-788-1900。

© 2005 Microsoft Corporation 版权所有。保留所有权利。使用规定。

原文出处:http://www.microsoft.com/china/msdn/library/data/sqlserver/sp04l9.mspx?mfr=true

ORACLE 的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.

（2）      WHERE子句中的连接顺序．：

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

（3）      SELECT子句中避免使用 ‘ * ‘：

ORACLE在解析的过程中, 会将'*' 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间

（4）      减少访问数据库的次数：

ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等；

（5）      在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200

（6）      使用DECODE函数来减少处理时间：

使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.

（7）      整合简单,无关联的数据库访问：

如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)

（8）      删除重复记录：

最高效的删除重复记录方法 ( 因为使用了ROWID)例子：

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)

FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

（9）      用TRUNCATE替代DELETE：

当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短. (译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)

（10） 尽量多使用COMMIT：

只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:

COMMIT所释放的资源:

a. 回滚段上用于恢复数据的信息.

b. 被程序语句获得的锁

c. redo log buffer 中的空间

d. ORACLE为管理上述3种资源中的内部花费

（11） 用Where子句替换HAVING子句：

避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销. (非oracle中)on、where、having这三个都可以加条件的子句中，on是最先执行，where次之，having最后，因为on是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，因为它过滤数据后才进行sum，在两个表联接时才用on的，所以在一个表的时候，就剩下where跟having比较了。在这单表查询统计的情况下，如果要过滤的条件没有涉及到要计算字段，那它们的结果是一样的，只是where可以使用rushmore技术，而having就不能，在速度上后者要慢如果要涉及到计算的字段，就表示在没计算之前，这个字段的值是不确定的，根据上篇写的工作流程，where的作用时间是在计算之前就完成的，而having就是在计算后才起作用的，所以在这种情况下，两者的结果会不同。在多表联接查询时，on比where更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表后，再由where进行过滤，然后再计算，计算完后再由having进行过滤。由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候起作用，然后再决定放在那里

（12） 减少对表的查询：

在含有子查询的SQL语句中,要特别注意减少对表的查询.例子：

     SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT

TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)

（13） 通过内部函数提高SQL效率.：

复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的

（14） 使用表的别名(Alias)：

当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.

（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：

在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.

例子：

（高效）SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')

(低效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')

（16） 识别'低效执行'的SQL语句：

虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法：

SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,

ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,

ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,

SQL_TEXT

FROM V$SQLAREA

WHERE EXECUTIONS>0

AND BUFFER_GETS > 0

AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8

ORDER BY 4 DESC;

（17） 用索引提高效率：

索引是表的一个概念部分,用来提高检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率. 虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.。定期的重构索引是有必要的.：

ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>

（18） 用EXISTS替换DISTINCT：

当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果. 例子：

       (低效):

SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E

WHERE D.DEPT_NO = E.DEPT_NO

(高效):

SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X'

FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

（19） sql语句用大写的；因为oracle总是先解析sql语句，把小写的字母转换成大写的再执行

（20） 在java代码中尽量少用连接符“＋”连接字符串！

（21） 避免在索引列上使用NOT 通常，　

我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就会停止使用索引转而执行全表扫描.

（22） 避免在索引列上使用计算．

WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描．

举例:

低效：

SELECT … FROM DEPT WHERE SAL * 12 > 25000;

高效:

SELECT … FROM DEPT WHERE SAL > 25000/12;

（23） 用>=替代>

高效:

SELECT * FROM EMP WHERE DEPTNO >=4

低效:

SELECT * FROM EMP WHERE DEPTNO >3

两者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录.

（24） 用UNION替换OR (适用于索引列)

通常情况下, 用UNION替换WHERE子句中的OR将会起到较好的效果. 对索引列使用OR将造成全表扫描. 注意, 以上规则只针对多个索引列有效. 如果有column没有被索引, 查询效率可能会因为你没有选择OR而降低. 在下面的例子中, LOC_ID 和REGION上都建有索引.

高效:

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE LOC_ID = 10

UNION

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE REGION = “MELBOURNE”

低效:

SELECT LOC_ID , LOC_DESC , REGION

FROM LOCATION

WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

如果你坚持要用OR, 那就需要返回记录最少的索引列写在最前面.

（25） 用IN来替换OR 

这是一条简单易记的规则，但是实际的执行效果还须检验，在ORACLE8i下，两者的执行路径似乎是相同的．　

低效:

SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30

高效

SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);

（26） 避免在索引列上使用IS NULL和IS NOT NULL

避免在索引中使用任何可以为空的列，ORACLE将无法使用该索引．对于单列索引，如果列包含空值，索引中将不存在此记录. 对于复合索引，如果每个列都为空，索引中同样不存在此记录.　如果至少有一个列不为空，则记录存在于索引中．举例: 如果唯一性索引建立在表的A列和B列上, 并且表中存在一条记录的A,B值为(123,null) , ORACLE将不接受下一条具有相同A,B值（123,null）的记录(插入). 然而如果所有的索引列都为空，ORACLE将认为整个键值为空而空不等于空. 因此你可以插入1000 条具有相同键值的记录,当然它们都是空! 因为空值不存在于索引列中,所以WHERE子句中对索引列进行空值比较将使ORACLE停用该索引.

低效: (索引失效)

SELECT … FROM DEPARTMENT WHERE DEPT_CODE IS NOT NULL;

高效: (索引有效)

SELECT … FROM DEPARTMENT WHERE DEPT_CODE >=0;

（27） 总是使用索引的第一个列：

如果索引是建立在多个列上, 只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引. 这也是一条简单而重要的规则，当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引

（28） 用UNION-ALL 替换UNION ( 如果有可能的话)：

当SQL 语句需要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并, 然后在输出最终结果前进行排序. 如果用UNION ALL替代UNION, 这样排序就不是必要了. 效率就会因此得到提高. 需要注意的是，UNION ALL 将重复输出两个结果集合中相同记录. 因此各位还是要从业务需求分析使用UNION ALL的可行性. UNION 将对结果集合排序,这个操作会使用到SORT_AREA_SIZE这块内存. 对于这块内存的优化也是相当重要的. 下面的SQL可以用来查询排序的消耗量

低效：

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

UNION

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

高效:

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

UNION ALL

SELECT ACCT_NUM, BALANCE_AMT

FROM DEBIT_TRANSACTIONS

WHERE TRAN_DATE = '31-DEC-95'

（29） 用WHERE替代ORDER BY：

ORDER BY 子句只在两种严格的条件下使用索引.

ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序.

ORDER BY中所有的列必须定义为非空.

WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.

例如:

表DEPT包含以下列:

DEPT_CODE PK NOT NULL

DEPT_DESC NOT NULL

DEPT_TYPE NULL

低效: (索引不被使用)

SELECT DEPT_CODE FROM DEPT ORDER BY DEPT_TYPE

高效: (使用索引)

SELECT DEPT_CODE FROM DEPT WHERE DEPT_TYPE > 0

（30） 避免改变索引列的类型.:

当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换.

假设 EMPNO是一个数值类型的索引列.

SELECT … FROM EMP WHERE EMPNO = ‘123'

实际上,经过ORACLE类型转换, 语句转化为:

SELECT … FROM EMP WHERE EMPNO = TO_NUMBER(‘123')

幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变.

现在,假设EMP_TYPE是一个字符类型的索引列.

SELECT … FROM EMP WHERE EMP_TYPE = 123

这个语句被ORACLE转换为:

SELECT … FROM EMP WHERETO_NUMBER(EMP_TYPE)=123

因为内部发生的类型转换, 这个索引将不会被用到! 为了避免ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型

（31） 需要当心的WHERE子句:

某些SELECT 语句中的WHERE子句不使用索引. 这里有一些例子.

在下面的例子里, (1)‘!=' 将不使用索引. 记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中. (2) ‘||'是字符连接函数. 就象其他函数那样, 停用了索引. (3) ‘+'是数学函数. 就象其他数学函数那样, 停用了索引. (4)相同的索引列不能互相比较,这将会启用全表扫描.

（32） a. 如果检索数据量超过30%的表中记录数.使用索引将没有显著的效率提高.

b. 在特定情况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的区别. 而通常情况下,使用索引比全表扫描要块几倍乃至几千倍!

（33） 避免使用耗费资源的操作:

带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎

执行耗费资源的排序(SORT)功能. DISTINCT需要一次排序操作, 而其他的至少需要执行两次排序. 通常, 带有UNION, MINUS , INTERSECT的SQL语句都可以用其他方式重写. 如果你的数据库的SORT_AREA_SIZE调配得好, 使用UNION , MINUS, INTERSECT也是可以考虑的, 毕竟它们的可读性很强

（34） 优化GROUP BY:

提高GROUP BY 语句的效率, 可以通过将不需要的记录在GROUP BY 之前过滤掉.下面两个查询返回相同结果但第二个明显就快了许多.

低效:

SELECT JOB , AVG(SAL)

FROM EMP

GROUP JOB

HAVING JOB = ‘PRESIDENT'

OR JOB = ‘MANAGER'

高效:

SELECT JOB , AVG(SAL)

FROM EMP

WHERE JOB = ‘PRESIDENT'

OR JOB = ‘MANAGER'

GROUP JOB

问题一
如果你家附近有一家餐厅，东西又贵又难吃，桌上还爬着蟑螂，你会因为它很近很方便，就一而再、再而三地光临吗？
回答：你一定会说，这是什么烂问题，谁那么笨，花钱买罪受？
可同样的情况换个场合，自己或许就做类似的蠢事。不少男女都曾经抱怨过他们的情人或配偶品性不端，三心二意，不负责任。明知在一起没什么好的结果，怨恨已经比爱还多，但却“不知道为什么”还是要和他搅和下去，分不了手。说穿了，只是为了不甘，为了习惯，这不也和光临餐厅一样？
――做人，为什么要过于执著？！
问题二
如果你不小心丢掉100块钱，只知道它好像丢在某个你走过的地方，你会花200块钱的车费去把那100块找回来吗？
回答：一个超级愚蠢的问题。
可是，相似的事情却在人生中不断发生。做错了一件事，明知自己有问题，却死也不肯认错，反而花加倍的时间来找藉口，让别人对自己的印象大打折扣。被人骂了一句话，却花了无数时间难过，道理相同。为一件事情发火，不惜损人不利已，不惜血本，不惜时间，只为报复，不也一样无聊？
失去一个人的感情，明知一切已无法挽回，却还是那么伤心，而且一伤心就是好几年，还要借酒浇愁，形销骨立。其实这样一点用也没有，只是损失更多。
――做人，干吗为难自己？！
问题三
你会因为打开报纸发现每天都有车祸，就不敢出门吗？
回答：这是个什么烂问题？当然不会，那叫因噎废食。
然而，有不少人却曾说：现在的离婚率那么高，让我都不敢谈恋爱了。说得还挺理所当然。也有不少女人看到有关的诸多报道，就对自己的另一半忧心忡忡，这不也是类似的反应？
所谓乐观，就是得相信：虽然道路多艰险，我还是那个会平安过马路的人，只要我小心一点，不必害怕过马路。
――做人，先要相信自己。
问题四
你相信每个人随便都可以成功立业吗？
回答：当然不会相信。
但据观察，有人总是在听完成功人士绞尽脑汁的建议，比如说，多读书，多练习之后，问了另一个问题？那不是很难？
我们都想在3分钟内学好英文，在5分钟内解决所有难题，难道成功是那么容易的吗？改变当然是难的。成功只因不怕困难，所以才能出类拔萃。
有一次坐在出租车上，听见司机看到自己前后都是高档车，兀自感叹：“唉，为什么别人那么有钱，我的钱这么难赚？” 我心血来潮，问他：“你认为世上有什么钱是好赚的？”他答不出来，过了半晌才说：好像都是别人的钱比较好赚。
其实任何一个成功者都是艰辛取得。我们实在不该抱怨命运。
――做人，依靠自己！
问题五
你认为完全没有打过篮球的人，可以当很好的篮球教练吗？
回答：当然不可能，外行不可能领导内行。
可是，有许多人，对某个行业完全不了解，只听到那个行业好赚钱，就马上开起业来了。
我看过对穿着没有任何口味、或根本不在乎穿着的人，梦想却是开间服装店；不知道电脑怎么开机的人，却想在网上赚钱，结果道听途说，却不反省自己是否专业能力不足，只抱怨时不我与。
――做人，量力而行。
问题六
相似但不相同的问题：你是否认为，篮球教练不上篮球场，闭着眼睛也可以主导一场完美的利？
回答：有病啊，当然是不可能的。
可是却有不少朋友，自己没有时间打理，却拼命投资去开咖啡馆，开餐厅，开自己根本不懂的公司，火烧一样急着把辛苦积攒的积蓄花掉，去当一个稀里糊涂的投资人。亏的总是比赚的多，却觉得自己是因为运气不好，而不是想法出了问题。
――做人，记得反省自己。
问题七
你宁可永远后悔，也不愿意试一试自己能否转败为胜？
解答：恐怕没有人会说：“对，我就是这样的孬种”吧。
然而，我们却常常在不该打退堂鼓时拼命打退堂鼓，为了恐惧失败而不敢尝试成功。
以关颖珊赢得2000年世界花样滑冰冠军时的精彩表现为例：她一心想赢得第一名，然而在最后一场比赛前，她的总积分只排名第三位，在最后的自选曲项目上，她选择了突破，而不是少出错。在4分钟的长曲中，结合了最高难度的三周跳，并且还大胆地连跳了两次。她也可能会败得很难看，但是她毕竟成功了。
她说：“因为我不想等到失败，才后悔自己还有潜力没发挥。”
一个中国伟人曾说；胜利的希望和有利情况的恢复，往往产生于再坚持一下的努力之中。
――做人，何妨放手一搏。
问题八
你的时间无限，长生不老，所以最想做的事，应该无限延期？
回答：不，傻瓜才会这样认为。
然而我们却常说，等我老了，要去环游世界；等我退休，就要去做想做的事情；等孩子长大了，我就可以……
我们都以为自己有无限的时间与精力。其实我们可以一步一步实现理想，不必在等待中徒耗生命。如果现在就能一步一步努力接近，我们就不会活了半生，却出现自己最不想看到的结局。
――做人，要活在当下。

1.面试经过

　　大约在年前我接到了TW瑞晟(Realtek)苏州公司的面试通知，通知我2月21日到苏州工业园区面试，接到面试后的几天我把一些专业课温习了一遍，特别是C++和数据结构，由于大学几年里，我一直专研这些方面，加上通过了高级程序员的考试，对于一些常用的算法我差不多也达到了烂熟于胸的地步，当时的感觉是如果问了我这些方面的问题我应该是没有问题的！

　　21日那天我被安排在4：30面试，由一位技术人员单独给我面试，在问了一些简单的问题之后他给我出了一道编程题目，题目是这样的：

　　(由于具体面试的题目比较烦琐，我将其核心思想提取出来分解成了两个独立的简单的问题，有可能问题分解的不当，请大家见谅，实际面试了一个的问题但比其复杂很多，而且涉及一些高等数学变换) 

　　1) 写一个函数计算当参数为n(n很大)时的值 1-2+3-4+5-6+7......+n 

　　哼，我的心里冷笑一声！没想到这么简单，我有点紧张的心情顿时放松起来！

　　于是很快我给出我的解法： 

long fn(long n) 
{ 
long temp=0; 
int i,flag=1; 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
for(i=1;i<=n;i++) 
{ 
temp=temp+flag*i; 
flag=(-1)*flag; 
} 
return temp; 
} 

　　搞定！当我用期待的目光看着面试官的时候，他微笑着跟我说，执行结果肯定是没有问题！但当n很大的时候我这个程序执行效率很低， 在嵌入式系统的开发中，程序的运行效率很重要，能让CPU少执行一条指令都是好的，他让我看看这个程序还有什么可以修改的地方，把程序优化一下！听了这些话，我的心情当时变的有点沉重，没想到他的要求很严格，之后我对程序进行了严格的分析，给出了改进了的方案！ 

long fn(long n) 
{ 
long temp=0; 
int j=1,i=1,flag=1; 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
while(j<=n) 
{ 
temp=temp+i; 
i=-i; 
i>0?i++:i--; 
j++; 
} 
return temp; 
} 

　　虽然我不敢保证我这个算法是最优的，但是比起上一个程序，我将所有涉及到乘法指令的语句改为执行加法指令，既达到要题目的要求而且运算时间上缩短了很多！而代价仅仅是增加了一个整型变量！但是我现在的信心已经受了一点打击，我将信将疑的看者面试官，他还是微笑着跟我说：“不错，这个程序确实在效率上有的很大的提高！”我心里一阵暗喜！但他接着说这个程序仍然不能达到他的要求，要我给出更优的方案！天啊！还有优化！我当时真的有点崩溃了，想了一会后，我请求他给出他的方案！然后他很爽快的给出了他的程序！
long fn(long n) 
{ 
if(n<=0) 
{ 
printf("error: n must > 0); 
exit(1); 
} 
if(0==n%2) 
return (n/2)*(-1); 
else 
return (n/2)*(-1)+n; 
} 

　　搞笑，当时我目瞪口呆，没想到他是这个意思，这么简单的代码我真的不会写吗，但是我为什么没有往那方面上想呢！他说的没有错，在n很大很大的时候这三个程序运行时间的差别简直是天壤之别！当我刚想开口说点什么的时候，他却先开口了：“不要认为CPU运算速度快就把所有的问题都推给它去做，程序员应该将代码优化再优化，我们自己能做的决不要让CPU做，因为CPU是为用户服务的，不是为我们程序员服务的！”多么精辟的语言，我已经不想再说什么了！接着是第二个问题： 

　　2),他要求我用一种技巧性的编程方法来用一个函数实现两个函数的功能n为如：

fn1(n)=n/2!+n/3!+n/4!+n/5!+n/6! 

fn2(n)=n/5!+n/6!+n/7!+n/8!+n/9! 

　　现在用一个函数fn(int n,int flag)实现，当flag为0时，实现fn1功能，如果flag为1时实现fn2功能！

　　他的要求还是效率，效率，效率！说实在话，如果我心情好的话我应该能给出一种比较好的算法，但我那时真的没有什么心思再想了，我在纸上胡乱画了一些诸如6!=6*5!的公式后直截了当的跟他说要他给出他的答案！面试官也没有说什么，给出了他的思路：

　　定义一个二维数组 float t[2][5]存入[2!,3!,4!,5!,6!},{5!,6!,7!,8!,9!]然后给出一个循环： 

for(i=0;i<6;i++) 
{ 
temp=temp+n/t[flag]; 
} 

　　最后得到计算值！呵呵，典型的空间换时间的算法！

　　这些总共花了50分钟的时间，还有十分钟我就跟他很随意的聊聊天，聊了一些编程以及生活的问题，那时的我已经很放松了，因为我知道这次面试结果只有一个：失败。5:30的时候面试官要我等通知，于是我离开了他们公司。这就是面试的整个经过！ 

.由面试想到的 

　　真的是很失败啊！我记得那天下好大的雨，气温也很低，我边走边想，从5:30一直走到7:30，全身都湿透了，又冷又饿，但是我只是一直走，脑子里面充满了疑惑，我也想让雨把自己淋醒！看到这里有些朋友可能觉得那些面试题目不算什么如果让自己做的话肯定能全部答对，我肯定相信你，因为我从未怀疑过中国程序员的能力，我认为中国有世界上最好的程序员，我也从未认为自己是高手，所以我做不出来不代表中国程序员比TW或者别的地方的程序员差，所以我就从我的角度，我的所见所想来谈一些感想： 

　　不错全世界都有优秀的程序员，中国也不例外，但是我疑惑的是：到底中国和TW或者国外的优秀的程序员的比例到底是多少？TW我不知道，中国100个程序员里有几个是优秀的呢?我根本算不上，从上面的表现就足以说明一切了！是1个？5个？10个？50个？这个数字我不敢乱猜，恐遭网友一顿痛骂，那么我们国内有多少人学习计算机呢？拿我们学校来说，计算机97级4个班，98级5个班，99级10个班，2000级17个班，人多了，老师怎么办？我们学校的做法是让研究生上课，然后呢？补考一抓一大把，大把大把的补考费落入了学校的口袋，还说现在的学生素质低！真是好笑，我都不知道学校这么做是为了什么，为国内培养大量的程序员吗？学生们能真正学到计算机知识吗？好了，我敢讲，在我们学校学习编程学生和优秀程序员(注意我指的是优秀，只会编几个糟烂程序的人算不上)的比例应该是100:0.1 。在这种比例下虽然我们中国学习编程的人铺天盖地，但是想想有多少个人能真正为中国软件业发展作出贡献，有多少人能真正写出优秀的程序名扬海外！ 

　　我从学习编程以来，不管是自学还是老师指导，从来都是解决问题就好，编出程序来就行，我的疑惑是：我们有真正的强调过程序的效率，程序的质量吗？我们有仔细分析过我们写的东西，看看有没有可以改进的地方，看看有没有简单的方法来达到同样的目的呢？我问心自问，我发现，我从来没有对我写出来的程序进行过优化，最多就是进行详细的测试，然后Debug，但是这就足够了吗？这些天我偶尔发现我曾经写过的一个游戏，那是一年前我刚加入www.vcroad.net做为其中一员时候，感觉应该拿点东西出来，然后花了一个星期的时间写出来的！程序不算复杂，但是用到了不少数据结构的东西，也用到了一些精彩的算法，加上windows的界面和游戏的可玩性，写完后受到了不少好评，我当时真的很佩服自己！但是现在看呢：没有一句注释，好多丑陋的函数名比如：void chushihua()，好多没有必要的变量，可以用简单语句完成工作的我使用华丽的算法，大量使用全局变量.....,说不好听的话，六百多行的程序除了能运行之外就是一陀屎！如果一年前我能听到一些反面意见的话，大概我能早一点觉悟，但是自从原代码在网站发布以来听到的都是赞美之词，没有一个人向我提出程序改进的意见，这又说明了一个什么问题呢？很值得思考啊！

还有一个疑惑是：我们说的和做的真的一样吗？我在学校的时候曾经受学院指派承办过一个计算机大赛，请了一个老师出决赛的题目，主要是一些算法题目，这个老师可能是我上大学以来唯一敬佩的老师了，从程序调试到打分，对于每个程序都仔细分析其时间效率和空间效率，然后综合打分，四十个人的卷子，老师从下午三点一直调试到晚上十点，在有些写的精彩的语句后还加上批注。我真是高兴很遇到这样的老师并且和他做深入的交流，但在事后，却发生了一件不愉快的事，在比赛中获得第二名的学生找到我，说他程序全部调试成功应该给他满分，并且应该得第一，我说不过他，最后调出了他的原程序和第一名的原程序对比，不错，两个程序都运行的很好，这时，那个同学开口了：“我的程序写的十分简捷明了，仅仅数行就完成了题目要求，而他的却写了一大堆，为什么给他的分多过给我的分。”我当时很是气愤，如果不是老师负责的话，那么现在第一名和第二名的位置真的要互调了，拜托，不是程序的行数越少程序的质量就越高，我记得我跟他大谈这方面的道理，最后说服他了！哈哈，但是我，只能说说而已，我不知道还有多少人一样，说起来头头是道，但心里却压根就从未重视过它！ 

.我打算做的！ 
　　其实那天我想到的远不止上面那么多，但是我不想再说了，因为我猜想看这篇文章的网友大概都有一肚子的感想，一肚子的抱怨，借用这篇文章发泄可不是我想达到的目的，在上面我把自己骂的一文不值也不是妄自菲薄，但是在某些方面我真的做错了，或者说是偏离了正确方向，现在是矫正方向和重整旗鼓的时候了，就象我前面说过的，我相信中国有世界上最好的程序员，我也相信我的水平不会一直保持现状，我现在就收拾起牢骚真正的实干起来！ 
真的很巧，就写到这里的时候我在网上偶尔发现了这篇手册，我不知道这预示着什么，但是我想如果我照下面这个基本原则一直踏实做下去，我一定会实现我的理想---一名优秀的软件设计师! 

　　（下面这些文字不是我的原创，是我偶尔在网上发现的，我真的很幸运能看到这些，这篇文章也随着下面的文字而结束，我真心的希望您能从这篇文章中得到启发,这篇文章欢迎大家随意转载，您可以不写作者是谁，但是请您写上www.vcroad.net原创，谢谢您的支持） 

　　作者：金蝶中间件公司CTO袁红岗 

　　不知不觉做软件已经做了十年，有成功的喜悦，也有失败的痛苦，但总不敢称自己是高手，因为和我心目中真正的高手们比起来，还差的太远。世界上并没有成为高手的捷径，但一些基本原则是可以遵循的。 

　　1. 扎实的基础。数据结构、离散数学、编译原理，这些是所有计算机科学的基础，如果不掌握他们，很难写出高水平的程序。据我的观察，学计算机专业的人比学其他专业的人更能写出高质量的软件。程序人人都会写，但当你发现写到一定程度很难再提高的时候，就应该想想是不是要回过头来学学这些最基本的理论。不要一开始就去学OOP，即使你再精通OOP，遇到一些基本算法的时候可能也会束手无策。 

　　2. 丰富的想象力。不要拘泥于固定的思维方式，遇到问题的时候要多想几种解决问题的方案，试试别人从没想过的方法。丰富的想象力是建立在丰富的知识的基础上，除计算机以外，多涉猎其他的学科，比如天文、物理、数学等等。另外，多看科幻电影也是一个很好的途径。 

　　3. 最简单的是最好的。这也许是所有科学都遵循的一条准则，如此复杂的质能互换原理在爱因斯坦眼里不过是一个简单得不能再简单的公式：E=mc2。简单的方法更容易被人理解，更容易实现，也更容易维护。遇到问题时要优先考虑最简单的方案，只有简单方案不能满足要求时再考虑复杂的方案。 

　　4. 不钻牛角尖。当你遇到障碍的时候，不妨暂时远离电脑，看看窗外的风景，听听轻音乐，和朋友聊聊天。当我遇到难题的时候会去玩游戏，而且是那种极暴力的打斗类游戏，当负责游戏的那部分大脑细胞极度亢奋的时候，负责编程的那部分大脑细胞就得到了充分的休息。当重新开始工作的时候，我会发现那些难题现在竟然可以迎刃而解。 

　　5. 对答案的渴求。人类自然科学的发展史就是一个渴求得到答案的过程，即使只能知道答案的一小部分也值得我们去付出。只要你坚定信念，一定要找到问题的答案，你才会付出精力去探索，即使最后没有得到答案，在过程中你也会学到很多东西。 

　　6. 多与别人交流。三人行必有我师，也许在一次和别人不经意的谈话中，就可以迸出灵感的火花。多上上网，看看别人对同一问题的看法，会给你很大的启发。 

　　7. 良好的编程风格。注意养成良好的习惯，代码的缩进编排，变量的命名规则要始终保持一致。大家都知道如何排除代码中错误，却往往忽视了对注释的排错。注释是程序的一个重要组成部分，它可以使你的代码更容易理解，而如果代码已经清楚地表达了你的思想，就不必再加注释了，如果注释和代码不一致，那就更加糟糕。 

　　8. 韧性和毅力。这也许是"高手"和一般程序员最大的区别。A good programming is 99 weat and 1?ffee。高手们并不是天才，他们是在无数个日日夜夜中磨练出来的。成功能给我们带来无比的喜悦，但过程却是无比的枯燥乏味。你不妨做个测试，找个10000以内的素数表，把它们全都抄下来，然后再检查三遍，如果能够不间断地完成这一工作，你就可以满足这一条。

　　Java虚拟机(JVM)的类装载就是指将包含在类文件中的字节码装载到JVM中, 并使其成为JVM一部分的过程。JVM的类动态装载技术能够在运行时刻动态地加载或者替换系统的某些功能模块, 而不影响系统其他功能模块的正常运行。本文将分析JVM中的类装载系统，探讨JVM中类装载的原理、实现以及应用。

　　二、Java虚拟机的类装载实现与应用

　　2.1 装载过程简介

　　所谓装载就是寻找一个类或是一个接口的二进制形式并用该二进制形式来构造代表这个类或是这个接口的class对象的过程，其中类或接口的名称是给定了的。当然名称也可以通过计算得到，但是更常见的是通过搜索源代码经过编译器编译后所得到的二进制形式来构造。

　　在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的，各个步骤的主要工作如下：

　　装载：查找和导入类或接口的二进制数据；
　　链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；
　　校验：检查导入类或接口的二进制数据的正确性；
　　准备：给类的静态变量分配并初始化存储空间；
　　解析：将符号引用转成直接引用；
　　初始化：激活类的静态变量的初始化Java代码和静态Java代码块。

　　至于在类装载和虚拟机启动的过程中的具体细节和可能会抛出的错误，请参看《Java虚拟机规范》以及《深入Java虚拟机》，它们在网络上面的资源地址是：
　　http://java.sun.com/docs/books/vmspec/2nd-edition/html/Preface.doc.html
　　http://www.artima.com/insidejvm/ed2/index.html
　　由于本文的讨论重点不在此就不再多叙述。

　　2.2 装载的实现

　　JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

　　在Java中，ClassLoader是一个抽象类，它在包java.lang中,可以这样说，只要了解了在ClassLoader中的一些重要的方法，再结合上面所介绍的JVM中类装载的具体的过程，对动态装载类这项技术就有了一个比较大概的掌握，这些重要的方法包括以下几个:

　　①loadCass方法 loadClass(String name ,boolean resolve)其中name参数指定了JVM需要的类的名称,该名称以包表示法表示,如Java.lang.Object；resolve参数告诉方法是否需要解析类，在初始化类之前,应考虑类解析，并不是所有的类都需要解析，如果JVM只需要知道该类是否存在或找出该类的超类,那么就不需要解析。这个方法是ClassLoader 的入口点。

　　②defineClass方法 这个方法接受类文件的字节数组并把它转换成Class对象。字节数组可以是从本地文件系统或网络装入的数据。它把字节码分析成运行时数据结构、校验有效性等等。

　　③findSystemClass方法 findSystemClass方法从本地文件系统装入文件。它在本地文件系统中寻找类文件,如果存在,就使用defineClass将字节数组转换成Class对象,以将该文件转换成类。当运行Java应用程序时,这是JVM 正常装入类的缺省机制。

　　④resolveClass方法 resolveClass(Class c)方法解析装入的类,如果该类已经被解析过那么将不做处理。当调用loadClass方法时,通过它的resolve 参数决定是否要进行解析。

　　⑤findLoadedClass方法 当调用loadClass方法装入类时,调用findLoadedClass 方法来查看ClassLoader是否已装入这个类,如果已装入,那么返回Class对象,否则返回NULL。如果强行装载已存在的类,将会抛出链接错误。

　　2.3 装载的应用

　　一般来说，我们使用虚拟机的类装载时需要继承抽象类java.lang.ClassLoader,其中必须实现的方法是loadClass()，对于这个方法需要实现如下操作:(1) 确认类的名称;(2) 检查请求要装载的类是否已经被装载;(3) 检查请求加载的类是否是系统类;(4) 尝试从类装载器的存储区获取所请求的类;(5) 在虚拟机中定义所请求的类;(6) 解析所请求的类;(7) 返回所请求的类。

　　所有的Java 虚拟机都包括一个内置的类装载器，这个内置的类库装载器被称为根装载器(bootstrap ClassLoader)。根装载器的特殊之处是它只能够装载在设计时刻已知的类,因此虚拟机假定由根装载器所装载的类都是安全的、可信任的,可以不经过安全认证而直接运行。当应用程序需要加载并不是设计时就知道的类时,必须使用用户自定义的装载器(user-defined ClassLoader)。下面我们举例说明它的应用。

　　public abstract class MultiClassLoader extends ClassLoader{
　　...
　　public synchronized Class loadClass(String s, boolean flag)
　　throws ClassNotFoundException
　　{
　　/* 检查类s是否已经在本地内存*/
　　Class class1 = (Class)classes.get(s);

　　/* 类s已经在本地内存*/
　　if(class1 != null) return class1;
　　try/*用默认的ClassLoader 装入类*/ {
　　class1 = super.findSystemClass(s);
　　return class1;
　　}
　　catch(ClassNotFoundException _ex) {
　　System.out.println(">> Not a system class.");
　　}

　　/* 取得类s的字节数组*/
　　byte abyte0[] = loadClassBytes(s);
　　if(abyte0 == null) throw new ClassNotFoundException();

　　/* 将类字节数组转换为类*/
　　class1 = defineClass(null, abyte0, 0, abyte0.length);
　　if(class1 == null) throw new ClassFormatError();
　　if(flag) resolveClass(class1); /*解析类*/

　　/* 将新加载的类放入本地内存*/
　　classes.put(s, class1);
　　System.out.println(">> Returning newly loaded class.");

　　/* 返回已装载、解析的类*/
　　return class1;
　　}
　　...
　　}
三、Java虚拟机的类装载原理

　　前面我们已经知道，一个Java应用程序使用两种类型的类装载器：根装载器(bootstrap)和用户定义的装载器(user-defined)。根装载器是Java虚拟机实现的一部分，举个例子来说，如果一个Java虚拟机是在现在已经存在并且正在被使用的操作系统的顶部用C程序来实现的，那么根装载器将是那些C程序的一部分。根装载器以某种默认的方式将类装入，包括那些Java API的类。在运行期间一个Java程序能安装用户自己定义的类装载器。根装载器是虚拟机固有的一部分，而用户定义的类装载器则不是，它是用Java语言写的，被编译成class文件之后然后再被装入到虚拟机，并像其它的任何对象一样可以被实例化。 Java类装载器的体系结构如下所示：
　　
　　Java的类装载模型是一种代理(delegation)模型。当JVM 要求类装载器CL(ClassLoader)装载一个类时,CL首先将这个类装载请求转发给他的父装载器。只有当父装载器没有装载并无法装载这个类时,CL才获得装载这个类的机会。这样, 所有类装载器的代理关系构成了一种树状的关系。树的根是类的根装载器(bootstrap ClassLoader) , 在JVM 中它以"null"表示。除根装载器以外的类装载器有且仅有一个父装载器。在创建一个装载器时, 如果没有显式地给出父装载器, 那么JVM将默认系统装载器为其父装载器。Java的基本类装载器代理结构如图2所示：
下面针对各种类装载器分别进行详细的说明。
根(Bootstrap) 装载器:该装载器没有父装载器，它是JVM实现的一部分，从sun.boot.class.path装载运行时库的核心代码。
扩展(Extension) 装载器:继承的父装载器为根装载器，不像根装载器可能与运行时的操作系统有关，这个类装载器是用纯Java代码实现的，它从java.ext.dirs (扩展目录)中装载代码。
　　系统(System or Application) 装载器:装载器为扩展装载器，我们都知道在安装JDK的时候要设置环境变量(CLASSPATH )，这个类装载器就是从java.class.path(CLASSPATH 环境变量)中装载代码的，它也是用纯Java代码实现的，同时还是用户自定义类装载器的缺省父装载器。

　　小应用程序(Applet) 装载器: 装载器为系统装载器，它从用户指定的网络上的特定目录装载小应用程序代码。

　　在设计一个类装载器的时候，应该满足以下两个条件：

　　对于相同的类名，类装载器所返回的对象应该是同一个类对象

　　如果类装载器CL1将装载类C的请求转给类装载器CL2，那么对于以下的类或接口,CL1和CL2应该返回同一个类对象:a)S为C的直接超类;b)S为C的直接超接口;c)S为C的成员变量的类型;d)S为C的成员方法或构建器的参数类型;e)S为C的成员方法的返回类型。
　　每个已经装载到JVM中的类都隐式含有装载它的类装载器的信息。类方法getClassLoader 可以得到装载这个类的类装载器。一个类装载器认识的类包括它的父装载器认识的类和它自己装载的类，可见类装载器认识的类是它自己装载的类的超集。注意我们可以得到类装载器的有关的信息，但是已经装载到JVM中的类是不能更改它的类装载器的。

　　Java中的类的装载过程也就是代理装载的过程。比如:Web浏览器中的JVM需要装载一个小应用程序TestApplet。JVM调用小应用程序装载器ACL(Applet ClassLoader)来完成装载。ACL首先请求它的父装载器, 即系统装载器装载TestApplet是否装载了这个类, 由于TestApplet不在系统装载器的装载路径中, 所以系统装载器没有找到这个类, 也就没有装载成功。接着ACL自己装载TestApplet。ACL通过网络成功地找到了TestApplet.class 文件并将它导入到了JVM中。在装载过程中, JVM发现TestAppet是从超类java.applet.Applet继承的。所以JVM再次调用ACL来装载java.applet.Applet类。ACL又再次按上面的顺序装载Applet类, 结果ACL发现他的父装载器已经装载了这个类, 所以ACL就直接将这个已经装载的类返回给了JVM , 完成了Applet类的装载。接下来,Applet类的超类也一样处理。最后, TestApplet及所有有关的类都装载到了JVM中。

　　四、结论

　　类的动态装载机制是JVM的一项核心技术, 也是容易被忽视而引起很多误解的地方。本文介绍了JVM中类装载的原理、实现以及应用，尤其分析了ClassLoader的结构、用途以及如何利用自定义的ClassLoader装载并执行Java类，希望能使读者对JVM中的类装载有一个比较深入的理解

 <filter>

<filter-name>Set Character Encoding</filter-name>

<filter-class>filters.SetCharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>GBK</param-value>

</init-param>

</filter>



<filter-mapping>

<filter-name>Set Character Encoding</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<Connector 

port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

enableLookups="false" redirectPort="8443" acceptCount="100"

debug="0" connectionTimeout="20000" 

disableUploadTimeout="true" 

URIEncoding="GBK"

/>

<%@ page contentType="text/html;charset=gb2312"%>

<%@ page import="java.util.*"%>



<% 



String q=request.getParameter("q"); 

q = q == null? "没有值" : q;



%>





<HTML>

<HEAD><TITLE>新闻列表显示</TITLE>

<META http-equiv=Content-Type content="text/html; charset=gb2312">

<META http-equiv=pragma content=no-cache>

<body>

你提交了：

<%=q%>



<br>

<form action="tcnchar.jsp" method="post">

输入中文:<input type="text" name="q"><input type="submit" value="确定">

<br>

<a href="tcnchar.jsp?q=中国">通过get方式提交</a>



</form>

</BODY></HTML>