端模式（Endian）的这个词出自Jonathan Swift书写的《格列佛游记》。这本书根据将鸡蛋敲开的方法不同将所有的人分为两类，从圆头开始将鸡蛋敲开的人被归为Big Endian，从尖头开始将鸡蛋敲开的人被归为Littile Endian。小人国的内战就源于吃鸡蛋时是究竟从大头（Big-Endian）敲开还是从小头（Little-Endian）敲开。在计算机业Big Endian和Little Endian也几乎引起一场战争。在计算机业界，Endian表示数据在存储器中的存放顺序。下文举例说明在计算机中大小端模式的区别。

如果将一个32位的整数0x12345678存放到一个整型变量（int）中，这个整型变量采用大端或者小端模式在内存中的存储由下表所示。为简单起见，本书使用OP0表示一个32位数据的最高字节MSB（Most Significant Byte），使用OP3表示一个32位数据最低字节LSB（Least Significant Byte）。

如果将一个16位的整数0x1234存放到一个短整型变量（short）中。这个短整型变量在内存中的存储在大小端模式由下表所示。

由上表所知，采用大小模式对数据进行存放的主要区别在于在存放的字节顺序，大端方式将高位存放在低地址，小端方式将 高位存放在高地址。采用大端方式进行数据存放符合人类的正常思维，而采用小端方式进行数据存放利于计算机处理。到目前为止，采用大端或者小端进行数据存 放，其孰优孰劣也没有定论。

有的处理器系统采用了小端方式进行数据存放，如Intel的奔腾。有的处理器系统采用了大端方式进行数据存放，如IBM半导体和Freescale的PowerPC处理器。不仅对于处理器，一些外设的设计中也存在着使用大端或者小端进行数据存放的选择。

因此在一个处理器系统中，有可能存在大端和小端模式同时存在的现象。这一现象为系统的软硬件设计带来了不小的麻烦，这要求系统设计工程师，必须深入理解大端和小端模式的差别。大端与小端模式的差别体现在一个处理器的寄存器，指令集，系统总线等各个层次中。

一、同余

    我们来了解一下什么是“同余”。简单来说就是，如果两个数都除以某个数能够有相同的余数，那么我们就说这两个数“同余”。不过这次我们用严谨的数学概念来表述：

    两个整数 a，b，若它们除以整数 m 所得的余数相等，则称 a，b 对于模 m 同余

    记作

    读作 a 同余于 b 模 m ，或读作 a 与 b 关于模 m 同余。

    比如

    我们再来了解一下相关的性质：

1. 如果 ，那么 m | (a − b) ，这里 m | (a − b) 表示 (a − b) 能被 m 整除
2. 如果 ，, 那么
3. 如果 ，, 那么，，，
4. 如果 ， 那么  

    有了这些性质，判断两个数是否同余就可以用更简单的方法了。根据性质一，原来我们需要判断 (a mod m) == (b mod m) 是否为真，现在就可以直接判断 (a - b) mod m == 0 是否为真了。这样就把其中一次求余运算变为减法运算了。一般来说减法要比除法更容易在计算机上实现，运算速度也更快。

二、求余 (a * b * c * d) mod m = ?

    由于计算机表示一个整数通常用 32bit 。而大量连乘运算则可能会导致整数溢出，这时我们就要利用求余一些性质来进行处理了。把以上式子转换为：

    已知： (a * b) mod m == ((a mod m) * b) mod m

    所以： (a * b * c * d) mod m = ((((((a mod m) * b) mod m) * c) mod m) * d) mod m

    这样就把连乘运算分解了，每次可以先进行求余运算然后再进行乘法运算。

使用的是Ubuntu 9.10发行版，找了好半天中文输入法，发现目前最好/最新的是ibus（前身是鼎鼎大名的scim-python，对于我这个linux小白来说，并不是鼎鼎大名的...），严格来说它不是一个输入法，而是一个输入法框架，9.10自带的ibus里有N多国家的输入法（基于ibus框架）。ubuntu9.10里面ibus自带的中文PinYin输入法好像一开始不能用...（拿不准...），必须去Preferences里面的IBus Preferences里面的Input Method中自己添加“汉语-PinYin”输入法，如果开始没有，需要安装ibus-pinyin，见下面的第4步。

在网上找了点资料，在ibus已经加入到Ubuntu的源了，如果需要，使用下面的命令进行安装：

1. sudo apt-get update                                   更新软件包列表
2. sudo apt-get install ibus                            安装ibus框架
3. sudo apt-get install ibus ibus-table        安装某些输入法引擎基础，如果仅仅想使用拼音输入法，可以跳过此步，拼音输入法不需要依赖ibus-table。某些输入法，如五笔，依赖ibus-table。
4. sudo apt-get install ibus ibus-pinyin       安装拼音输入法引擎，发现很好用啊，哈哈

由于安装和卸载软件是使用的必须前提，所以这里对apt命令进行一些总结。在总结之前，还得对ubuntu的软件源的地址进行说明，为了达到好的下载源的速度，最好选一个最快的软件源，目前来说http://ubuntu.srt.cn是最快的，ubuntu自己提供了检测的功能，可以自动检测（choose a download server -> select best server）。

关于apt-get命令的详细而简单的说明，是《AptGetHowTo》。注意，使用apt-get命令必须要用root权限。这里，摘抄了最常用的命令....如下

Installation commands

• apt-get install <package_name> 

  This command installs a new package.

• apt-get build-dep <package_name> 

  This command searches the repositories and installs the build dependencies for <package_name>. If the package is not in the repositories it will return an error.

• aptitude install <package_name>

  Aptitude is a [http://en.wikipedia.org/wiki/Ncurses Ncurses] viewer of packages installed or available. Aptitude can be used from the command line in a similar way to apt-get. See man aptitude for more information.

• APT and aptitude will accept multiple package names as a space delimited list. For example:

  apt-get install <package1_name> <package2_name> <package3_nam
  
  
  

Search commands

• apt-cache search <search_term>

  This command will find packages that include <search_term>.

• dpkg -l *<search_term>*

  This will find packages whose names contain <search_term>. Similar to apt-cache search, but also shows whether a package is installed on your system by marking it with ii (installed) and un (not installed).

• apt-cache show <package_name>

  This command shows the description of package <package_name> and other relevant information including version, size, dependencies and conflicts.

Typical usage example

I want to feel the wind in my hair, I want the adrenaline of speed. So lets install a racing game. But what racing games are available?

apt-cache search racing game

It gives me a lot of answers. I see a game named "torcs". Lets get some more information on this game.

apt-cache show torcs

Hmmm... it seems interesting. But is this game not already installed on my computer? And what is the available version? Is it from Universe or main?

apt-cache policy torcs

Ok, so now, let's install it!

apt-get install torcs

What is the command I must type in the console to launch this game? In this example, it's straightforward ("torcs"), but that's not always the case. One way of finding the name of the binary is to look at what files the package has installed in "/usr/bin". For games, the binary will be in "/usr/games". For administrative programs, it's in "/usr/sbin".

dpkg -L torcs | grep /usr/games/

The first part of the command display all files installed by the package "torcs" (try it). With the second part, we ask to only display lines containing "/usr/games/".

Hmmm, that game is cool. Maybe there are some extra tracks?

apt-cache search torcs

But I'm running out of space. I will delete the apt cache!

apt-get clean

Oh no, my mother asked me to remove all games from this computer. But I want to keep the configuration files so I can simply re-install it later.

apt-get remove torcs

If I want to also remove config files :

apt-get purge torcs

由于宿舍网络情况比较复杂，想为tattoo搭建一个proxy，没想到在android中没有找到设置proxy的地方。上网查了一篇文章，可以解决这个问题。

转自 http://alexmogurenko.com/blog/programming/android-how-to-set-proxy-for-android-browser/

下面是原文

There are many reasons to make browser serf pages through proxy server:

• someone wanna catch http requests/responses
• someone wanna hide his IP
• so on

What to do if you want set proxy for android browser? there some ways:

• add record to database: /data/data/com.android.providers.settings/databases/settings.db

1. pull database to pc add record (using for example sdk tool sqlite3) and replace existing db
2. make changes in database directly on device

but as for me there exist simplier way, do it by your Java application using Settings provider:

Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "proxy_ip:proxy_port");

where proxy_ip/proxy_port = IP/port of proxy that you going to use.

there left one problem, it will not work if we will not add one string to manifest file, here it is:

<uses-permission android:name=”android.permission.WRITE_SETTINGS” />

Thats all, now it works, here is code:

package com.BrowserSettings;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.provider.Settings;

public class BrowserSettingsUI extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

final Button button = (Button) findViewById(R.id.Button01);
button.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {
try
{
Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "127.0.0.1:100");//enable proxy
}catch (Exception ex){
}
}
});

final Button button2 = (Button) findViewById(R.id.Button02);
button2.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {

try
{
Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "");//disable proxy
}catch (Exception ex){
}
}
});

}
}

manifest file:

<?xml version=”1.0″ encoding=”utf-8″?>
<manifest xmlns:android=”http://schemas.android.com/apk/res/android”
package=”com.BrowserSettings”
android:versionCode=”1″
android:versionName=”1.0.0″>
<application android:icon=”@drawable/icon” android:label=”@string/app_name”>
<activity android:name=”.BrowserSettingsUI”
android:label=”@string/app_name”>
<intent-filter>
<action android:name=”android.intent.action.MAIN” />
<category android:name=”android.intent.category.LAUNCHER” />
</intent-filter>
</activity>
</application>
<uses-permission android:name=”android.permission.WRITE_SETTINGS” />
</manifest>

最近在学习《算法导论》时，发现很多证明都用到了数学归纳法，这里查了点资料，把数学归纳法复习一下：

数学归纳法用来在数学上证明与自然数N有关的命题的一种特殊方法，它主要用来研究与正整数有关的数学问题，在高中数学中常用来证明等式成立和数列通项公式成立。

用的最多的是第一数学归纳法和第二数学归纳法，下面详细说明。

第一数学归纳法

1. 证明当n（n为自然数）取第一个值时命题成立
2. 假设当n=k（k为自然数）时命题成立，证明当n=k+1时命题也成立

由1，2步，可证明命题成立。

第二数学归纳法

对第一数学归纳法进行了扩充

1. 证明当n=0时命题成立
2. 假设当n<=k（k为自然数）时命题成立，证明当n=k+1时命题也成立

有1，2步，可证明命题成立。

在算法时间复杂度的证明上，由于n取值是一个自然数，所以多用数学归纳法原理进行证明。其实，证明循环正确性的循环不变式就是直接利用的第一数学归纳法。

参考：

百度百科，数学归纳法

如题，经典问题，记录于此...

递归实现

思路：如果只有一个节点，则什么都不做。否则，将当前链表（a1,a2...a3）的子链表（a2,...an）进行逆转，返回逆转后的第一个节点的指针，再将a1节点加到a2节点后面。

代码：(这里没有使用头节点)

node * reverse(node * p){
    if(p->next == null){
        return p;
    }
    node * q = p->next;
    node * head = reverse(q);
    p->next = null;
    q->next = p;
    return head;
}

非递归实现

思路：一个指针进行链表的遍历，一个指针指向逆转后的链表的第一个节点，在遍历的过程中，将当前节点加入逆转后的链表第一个元素即可。返回逆转后的链表的第一个节点的指针。

代码：（这里没有使用头节点）

node * reverse(node * p){
    node * p_reverse;
    if(p != null){    
        p_reverse = p;
        node * q = p->next;
        p->next = null;    
    }
    while(q != null){
        p = q->next;
        q->next = p_reverse;
        p_reverse = q;
        q = p;
    }
}

对C语言用的太少，上面的代码实现可能有点恶心，不过可以实现功能....

对eclipse是用的多，学的少，用了都半年了，连插件都不知道怎么装，搜索了一篇文章《Eclipse 3.4插件安装方式》作为参考吧...

以前安装Eclipse插件无非两种方式, 直接copy插件到features/plugins目录或者在links目录下创建链接文件. 刚刚发布的Eclipse 3.4又推出另一种新的安装途径, 更加灵活。Eclipse 3.4下有个dropins目录, 只要把插件放到该目录下就可以加载, 有几种格式可以选择。

1. 最简单的，直接将jar包放到dropins目录:

    eclipse/
          dropins/
               com.essiembre.eclipse.i18n.resourcebundle_0.7.7

2. 传统格式，统一放到一个eclipse目录下:
      eclipse/ 
          dropins/ 
               eclipse/ 
                    features/ 
                    plugins/

3. 按照插件名称区分:
    eclipse/
          dropins/
               resourcebundleeditor/
                    features/
                    plugins/               
               m2eclipse/
                    features/
                    plugins/

4. 类似links方式添加链接:

    eclipse/
          dropins/ 
               xfire.link

如果只安装一个Eclipse的话建议采用第三种，否则采用第四种。

如果发现安装了没有效果，可以删除eclipse主目录下的\configuration\org.eclipse.update后，再执行eclipse -clean试试。

     Oracle支持的数据类型可以分为三个基本种类：字符数据类型、数字数据类型以及表示其它数据的数据类型。

    字符数据类型

    CHAR数据类型存储固定长度的字符值。一个CHAR数据类型可以包括1到2000个字符。如果对CHAR没有明确地说明长度，它的默认长度则设置为1.如果对某个CHAR类型变量赋值，其长度小于规定的长度，那么Oracle自动用空格填充。

    VARCHAR2存储可变长度的字符串。虽然也必须指定一个VARCHAR2数据变量的长度，但是这个长度是指对该变量赋值的的最大长度而非实际赋值长度。不需要用空格填充。最多可设置为4000个字节。所以如果存储中文的时候，就不能存储到4000个字符了，因为一个汉字会占有多个字节。

    因为VARCHAR2数据类型只存储为该列所赋的字符（不加空格），所以VARCHAR2需要的存储空间比CHAR数据类型要小。

    Oracle推荐使用VARCHAR2

    NCHAR和NVARCHAR2数据类型分别存储固定长度与可变长度的字符数据，但是它们使用的是和数据库其他类型不同的字符集。在创建数据库时，需要指定所使用的字符集，以便对数据库中数据进行编码。还可以指定一个辅助的字符集［即本地语言集（National Language Set，简称NLS）］。NCHAR和NVARCHAR2类型的列使用辅助字符集。

    在Oracle9i中，可以以字符而不是字节为单位来表示NCHAR和NVARCHAR2列的长度。

    LONG数据类型可以存放2GB的字符数据，它是从早期版本中继承来的。现在如果想存储大容量的数据，Oracle推荐使用CLOB和NCLOB数据类型。在表和SQL语句中使用LONG类型有许多限制。

    CLOB和NCLOB数据类型可以存储多达4GB的字符数据。NCLOB数据类型可存储NLS数据。

    数字数据类型

    Oracle使用标准、可变长度的内部格式来存储数字。这个内部格式精度可以高达38位。

    NUMBER数据类型可以有两个限定符，如：

    column NUMBER （ precision， scale）

    precision表示数字中的有效位。如果没有指定precision的话，Oracle将使用38作为精度。

    scale表示数字小数点右边的位数，scale默认设置为0。如果把scale设成负数，Oracle将把该数字取舍到小数点左边的指定位数。

    日期数据类型

    Oracle标准日期格式为：DD-MON-YY  HH：MI：SS

    通过修改实例的参数NLS_DATE_FORMAT，可以改变实例中插入日期的格式。在一个会话期间，可以通过ALTER SESSION SQL命令来修改日期，或者通过使用SQL语句的TO_DATE表达式中的参数来更新一个特定值。

    其它的数据类型

    RAW和LONG RAW数据类型主要用于对数据库进行解释。指定这两种类型时，Oracle以位的形式来存储数据。RAW数据类型一般用于存储有特定格式的对象，如位图。 RAW数据类型可占用2KB的空间，而LONG RAW数据类型则可以占用2GB大小。

    ROWID ROWID是一种特殊的列类型，称之为伪列（pseudocolumn）。ROWID伪列在SQL SELECT语句中可以像普通列那样被访问。Oracle数据库中每行都有一个伪列。ROWID表示行的地址，ROWID伪列用ROWID数据类型定义。

    ROWID与磁盘驱动的特定位置有关，因此，ROWID是获得行的最快方法。但是，行的ROWID会随着卸载和重载数据库而发生变化，因此建议不要在事务 中使用ROWID伪列的值。例如，一旦当前应用已经使用完记录，就没有理由保存行的ROWID.不能通过任何SQL语句来设置标准的ROWID伪列的值。

    列或变量可以定义成ROWID数据类型，但是Oracle不能保证该列或变量的值是一个有效的ROWID.

    LOB

    LOB（大型对象）数据类型，可以保存4GB的信息。LOB有以下3种类型：

    。CLOB，只能存储字符数据

    。NCLOB，保存本地语言字符集数据

    。BLOB，以二进制信息保存数据

    可以指定将一个LOB数据保存在Oracle数据库内，还是指向一个包含次数据的外部文件。

    LOB可以参与事务。管理LOB中的数据必须通过DBMS_LOB PL/SQL内置软件包或者OCI接口。

    为了便于将LONG数据类型转换成LOB，Oracle9i包含许多同时支持LOB和LONG的函数，还包括一个ALTER TABLE语句的的新选择，它允许将LONG数据类型自动转换成LOB.

    BFILE

    BFILE数据类型用做指向存储在Oracle数据库以外的文件的指针。

    XMLType

    作为对XML支持的一部分，Oracle9i包含了一个新的数据类型XMLType.定义为XMLType的列将存储一个在字符LOB列中的XML文档。有许多内置的功能可以使你从文当中抽取单个节点，还可以在XMLType文档中对任何节点创建索引。

    用户自定义数据

    从Oracle8以后，用户可以定义自己的复杂数据类型，它们由Oracle基本数据类型组合而成。

    AnyType、AnyData和AnyDataSet

    Oracle包括3个新的数据类型，用于定义在现有数据类型之外的数据结构。其中每种数据类型必须用程序单元来定义，以便让Oracle9i知道如何处理这些类型的特定实现。

    额外的：

    类型转换

    Oracle会自动将某些数据类型转换成其他的数据类型，转换取决于包括该值的SQL语句。

    数据转换还可以通过Oracle的类型转换函数显示地进行。

    连接与比较

    在大多数平台上Oracle SQL中的连接操作符用两条竖线（||）表示。连接是将两个字符值连接。Oracle的自动类型转换功能使得两个数字值也可以进行连接。

    NULL

    NULL值是关系数据库的重要特征之一。实际上，NULL不代表任何值，它表示没有值。如果要创建表的一个列，而这个列必须有值，那么应将它指定为NOT NULL，这表示该列不能包含NULL值。

    任何数据类型都可以赋予NULL值。NULL值引入了SQL运算的三态逻辑。如果比较的一方是NULL值，那么会出现3种状态：TURE、FALSE以及两者都不是。

    因为NULL值不等于0或其他任何值，所以测试某个数据是否为NULL值只能通过关系运算符IS NULL来进行。

    NULL值特别适合以下情况：当一个列还未赋值时。如果选择不使用NULL值，那么必须对行的所有列都要赋值。这实际上也取消了某列不需要值的可能性，同时对它赋的值也很容易产生误解。这种情况则可能误导终端用户，并且导致累计操作的错误结果。

参考：

《Oracle数据类型》，http://www.cnblogs.com/cxd4321/archive/2008/04/14/1153201.html

1. 这是“需要时间”的方法
2. 这是“可以取消”的方法

1. java.lang.Object类（及其子类）实例的wait方法
2. java.lang.Object类（及其子类）实例的sleep方法
3. java.lang.Thread类（及其子类）实例的join方法

前面的Guarded Suspension Pattern和Balking Pattern都比较极端。一个是“不让？爷不玩了”，另一个是“不行！我一定要玩！”。而，Guarded Timeout Patter就中庸的多了，是“现在不让玩？那我等等吧。如果超过我等待的时间了，我就不玩了”。 还是以代码说话：

class A{     
    private long timeout; //等待的最长时间 
    public synchronized void changeState(){ 
        改变状态 通知等待的线程不同再等了(notify/notifyAll) 
    } 
    public synchronized void guardedMethod() throws InterruptedException{ 
        long start = System.currentTimeMillis(); //开始时刻 
        while(条件成立不成立){ 
            long now = System.currentTimeMillis(); //现在时刻 
            long rest = timeout - (now -start); //还需要等待的时间 
            if(rest <= 0){throw new InterruptedException("...");} //如果为等待时间为0或者为负数，就不等了。 
            等着一段时间吧，如果超过我等待的最长时间了，我就不玩了（wait（rest）） //当wait的时间超过rest时，也会抛出InteruptedException。 
        } 
        进行处理 
    } 
} 

在通常情况下，会对if(rest<=0){...}中抛出的异常进行一下包装，即继承InterruptedException异常，是得调用者知道是超时了（wait(rest)，interrupt方法都可能会抛出InterruptedException，所以必须包装一下，让上层程序识别）。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

Balking Pattern重在“balking”，balking的意思是“退缩不前”，在棒球运动的意思是“当跑垒员在垒时，投手在投手板但’中途放弃‘投球的动作”（呵呵，对棒球不懂...）。另外，这种模式和Guarded Suspension Pattern有点类似，也是有要检测警戒条件是否成立，不过，如果不成立，就不用等待了，直接就放弃了。呵呵，这种模式还是想的比较开啊（不行？那爷不赔你玩了:)），相比之下，Guarded Suspension Pattern就执着的多了:)。 从代码的角度看，如下： class A{ public synchronized void guardedMethod(){ if(警戒条件不成立){ return; } 进行处理 改变状态 } } 下面给出参考书中列出的一个使用Balking Pattern的实例：即文本编辑器的自动保存功能。当在编辑文件的时候，后台有个线程会定期的对文件进行保存，防止程序崩溃时文件内容的丢失。那么，文件是否被修改就是这里的警戒条件。当然，还得有另外一个字段，就是当前的数据。编辑程序会调用synchronized的方法对文件数据进行修改，并设置警戒条件（为什么用synchronized?是因为防止更改操作和保存的冲突，否则，可能保存的不是最新的数据）。那么，后台的定时保存线程，会定时调用保存文件这个guardedMethod()，如果文件已经被（编辑程序）保存了，那么就balking了，否则，就保存。下面是代码：

class Data{ 
    public synchronized void changeData(String content){ 
        this.content = content; changed = true; 
    }   
    public synchronized void guardedMethod(){ 
        if(!changed){ return; } 
            doSave(); 
            changed = false; 
    } 
    private vodi doSave(){} 
}

注意上面的doSave方法不是synchronized。 Balking Patter的适用场合：

1. 不需要可以去执行的时候。如上面说的自动保存的例子。
2. 不想等待警戒条件成立时。
3. 警戒条件只有一次成立时。比如仅仅需要进行一次初始化（不是在构造函数中）的共享资源类。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

Guarded Suspension Pattern就是“当访问的共享资源被保护（防卫）时，那么线程就挂起”，生活中的例子就是当你和女朋友准备出去玩，你给女朋友打电话说该走了，女朋友说还没准备好，那你只能等在那里知道你女朋友收拾好了才能出去:)。 相对Single Threaded Pattern的任何线程对共享资源的访问仅仅是多个线程不能同时访问unsafeMethod，Guared Suspension Pattern就稍微复杂点了，它有个概念就是“条件”。当共享资源的条件准备好时，才能让其他线程进行访问，如果条件没有准备好，对不起，先等着吧。所以，这个模式里面还必须有一个改变“条件”使其成立的方法，还得有一个通知等待的线程不用再等的方法，否则，那些线程就在那里死等了...。 Guarded Suspension Pattern中对共享资源叫做Guarded Object（被防卫的对象），unsafeMethod方法称之为guardedMethod。当线程执行guardedMethod方法时，只要满足警戒条件，就会马上执行。当警戒条件不成立时，就要开始等待。警戒条件的成立与否，会随着Guarded Object状态的变化而变化。 从代码的角度看，如下：

class A{ 
    public synchronized void changeState(){ 
        改变状态 通知等待的线程不同再等了(notify/notifyAll) 
    } 
    public synchronized void guardedMethod(){ 
        while(条件成立不成立){ 
            //这里不能是if，至于原因就好好想想吧:)（需要重点理解wait/notify/notifyAll的处理过程） 
            等着吧（wait） 
        } 进行处理 
    } 
} 

这种模式有一些变形： busy wait，即忙碌的等待。即在while循环中不用wait，而用yield；在changeState中不用notify/notifyAll。但是，这种变形的缺点是等待的线程仍然在运行，只不过一直在检测运行时间是否满足。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

Immutable Pattern的关键在于共享资源是immutable（不会改变的）。即在实例产生后，没有改变字段的方法了，即只有只读的方法（所有的方法都是safeMethod），那么任何线程对共享资源的访问就不可造成冲突了。就算想破坏这个共享资源都没有办法，呵呵。 String类就是Immutable Pattern的典型。String类没有提供任何改变字符串属性的方法。当然就是Immutable Pattern了。 从代码上来看，Immutable Pattern的形式如下：

class A{ 
    public void safeMethod1(){} 
    publi c void safeMethod2(){} 
} 

由于没有用到synchronized关键字，那么访问共享资源的效率是很高的。在某些情况下，如果某个共享资源用到了synchronized关键字，即不是immtable。那么，可以根据这个类的具体用处，分为两个类，一个是immutable，另一个是mutable（可变的），如果这两个类可以互相转化，那么在不同的场合用不同的类就可以提高程序的效率了。Java中对字符串这个共享资源提供了两个类：String类和StringBuffer类。他们就是对应的immutable和mutable，两者可以通过构造函数（String有个构造函数的参数是StringBuffer，StringBuffer有个构造函数的参数String）转化。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

Single Threaded Execution模式的核心就是single，即某个共享资源同时只能被某一个线程访问。可以做如下比喻来理解这个模式：门（共享资源），人（线程）。一个门一次只能由一个人通过。如果一个人正在通过这个门，那么其他人只能等待了。 当然，共享资源中某些方法是线程安全的（SafeMethod），就不用考虑多个线程同时调用的情况了。只有对不安全的方法（UnsafeMethod）才需要考虑多线程访问的问题。 可以对Single Thread Execution模式这样理解：如果另外的线程也行执行被保护的UnsafeMethod，那么就需要判断是否有其他线程正在执行被保护的UnsafeMethod。如果有，则等待；没有，则执行。 对Single Threaded Execution Pattern来说，代码的典型表现形式就是对所有的UnsafeMethod方法加上synchronized关键字。如：

class A{ 
    public void safeMethod(){ } 
    public synchronized void unsafeMethod1(){ } 
    publi synchronized void unsafeMethod2(){ } 
}

当下面的情况发生时，可能会出现死锁

1. 有多个共享资源
2. 线程锁定了一个共享资源，但还没有解除锁定就锁定了另外一个共享资源
3. 各个线程获取共享资源的顺序不固定

也就是说，打破上面的三个情况的任何一个，就可以避免死锁的发生。 参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

Oracle的数据库驱动有两种，oci和thin，没有用过oci，这里用的是thin。 问题描述： 有一张表MESSAGE，里面有个字段是content varchar2(4000)。 如果直接用Statement来更新这个字段，是不会用任何问题的。因为Statement的原理就是直接将整个sql语句发到数据库执行。 但是，如果用PreparedStatement的setString(）方法来设置这个字段，就有问题了，当设置的字符串长度大于2000时，就会报错：”java.sql.SQLException: 数据大小超出此类型的最大值“。 问题分析： 这些天学着用iBatis，就遇到了上面的这个问题。因为如果在iBatis中使用内联参数（#做占位符），底层实现的时候就是用的PreparedStatement来实现的，所以就遇到了上面的问题。 至于为什么用PreparedStatement会出先这个问题，JavaEye上的一篇文章《当PreparedStatement中的参数遇到大字符串》给出了很好的解释（牛逼啊！）

(1)Using the JDBC thin driver (2)Using binds (not defines) (3)Using SQL CHAR datatypes (4)Connecting to a database whose character set is neither ASCII (US7ASCII) nor ISO Latin1 (WE8ISO8859P1) When the database character set is neither US7ASCII nor WE8ISO8859P1, the JDBC thin driver converts Java UTF-16 characters to UTF-8 encoding bytes for SQL CHAR binds. The UTF-8 encoding bytes are then transferred to the database, and the database converts the UTF-8 encoding bytes to the database character set encoding.” 原来是JDBC在转换过程中对字符串的长度做了限制。这个限制和数据库中字段的实际长度没有关系。 所以，setCharacterStream()方法可以逃过字符转换限制，也就成为了解决此问题的方案之一。 而JDBC对转换字符长度的限制是为了转换过程中的数据扩展。 问题解决： 根据上面的分析，可以用PreparedStatement的setCharacterStream()方法来解决问题。 在iBatis中，可以使用下面的自定义类型处理器来处理（参考文章《用ibatis向oracle数据库的varchar2(4000)列写值的问题》）

/**
 * String implementation of TypeHandler
 */
public class StringTypeHandler extends BaseTypeHandler implements TypeHandler {
 /**
 * 在使用oracle时，如果在一个varchar2(4000)的字段上插入的字符过长（一般只能插入666个汉字，视字符集不同会有所不同），
 * 会导致失败，具体报错会因驱动版本不同而不同。
 * 如果使用setCharacterStream则可以插入最多的字符。因此，我将这个方法改了一下。
 */
 public void setParameter(PreparedStatement ps, int i, Object parameter,
 String jdbcType) throws SQLException {
 //原来的代码
 //ps.setString(i, ((String) parameter));

 //以下是我加的代码，为了尽量提高效率，作了一下判断
 String s = (String) parameter;
 if (s.length() < 667) { //以字符中全是汉字为底线。
 ps.setString(i, s);
 } else {
 ps.setCharacterStream(i, new StringReader(s), s.length());
 }
 }

 public Object getResult(ResultSet rs, String columnName) throws
 SQLException {
 Object s = rs.getString(columnName);
 if (rs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object getResult(ResultSet rs, int columnIndex) throws SQLException {
 Object s = rs.getString(columnIndex);
 if (rs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object getResult(CallableStatement cs, int columnIndex) throws
 SQLException {
 Object s = cs.getString(columnIndex);
 if (cs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object valueOf(String s) {
 return s;
 }
 }

其实，上面的解决方案是比较麻烦的，今天发现了一个更好的解决方案，就是将oracle jdbc驱动换成用于oracle10g第二版的驱动ojdbc14.jar。就行了，唉，前面折腾了几天的问题竟然可以这么容易地解决...

final int i = 1;

final int i;

public A(){

this.i = 2;

}

static final int i = 12;

static final int i;

static{

i = 12;

}

1. 子类可以覆盖父类的实例方法（方法名、参数和返回值都一样），另外，这里还有一个重载（overload）的概念，重载是一个静态的概念，是在编译时根据方法名和参数来确定的，重载是一个类自身的一个属性，和继承没有关系。
2. 子类可以隐藏父类的类方法（方法名、参数和返回值都一样）
3. 子类可以隐藏父类的字段（实例字段和静态字段）（通过在子类中定义字段名相同（类型可和父类不一样）的字段即可）。

1. 《Java多线程设计模式》中国铁道出版社 2005

1. 方法区(Method Area)、
2. Java栈
3. Java堆。

在Java中，为了生成一个线程，有两种方法：

1. 继承Thread类，覆盖run方法。在使用时，调用Thread实例的start方法即可启动一个线程，此线程将执行run方法里面的代码。
2. 实现Runnable接口，实现run方法。在使用时，调用Thread实例（传入实现Runnable接口的类实例）的start方法，此线程将执行run方法里面的代码。

启动线程的方法只能用start方法，不能用run方法...start方法才会启动一个线程去执行run方法，而run方法仅仅是一个类实例的方法！！！

在此，需要强调的是，线程和Thread类的区别。线程是一个动态的概念，而Thread类（或其实例）是静态的概念。虽然说从代码上看，执行Thread实例的start方法或者run方法（只能在实现Runnable接口时）好像把Thread实例当作了一个线程，当事实上，应该这样理解：Thread类就是一个普通的类，和其他类没有什么两样，但是他的start方法或者run方法比较特殊，可以启动一个新的线程。当新线程启动后，就马上执行Thread类里面run方法的代码或者Runnable接口的run方法。 在Java中，为了实现多线程之间的同步和互斥，提供了一个关键字，synchronized。这个关键字有两个用法：

1. 用于方法声明中。如： public synchronized void methd(){ .... } 把这种用法称之为synchronized方法。
2. 用于方法体中。如： public void method(){ synchronized(this){ .... } }把这种方法称为synchronized语句。

当不同的线程运行synchronized方法或者synchronized语句时，首先会获得锁，然后再执行，当退出时，会释放锁。当锁还没有被释放时，如果有其他线程访问，那么这些线程会阻塞。如果锁被释放，那么jvm会让所有在此锁上阻塞的所有线程竞争，将有一个线程得到锁，其他线程将继续阻塞。 其实，synchronized方法就是在方法体的最前面加了一个锁，在方法体的最后面释放掉了这个锁。synchronized语句就是在被包含的语句 前加了一个锁，在被包含的语句后释放掉了锁。这里需要强调锁的概念，可以这么认为，Java中每一个对象都有一个锁的，可以使用synchronized 方法和synchronized语句来获得这些锁。 下面通过实例来理解synchronized方法和synchronized语句。 1，下面的两个方法是等价的： public synchronized void methd(){ .... } public void method(){ synchronized(this){ .... } } 怎么理解上面的等价？ synchronized方法（只能）获得当前对象的锁，那么，在synchronized语句中显示的指明要获得锁的对象为this就可以使两者等价了。 在synchronized方法中，多个线程同时只能访问某个对象（可能含多个synchronized方法）的一个synchonized方法。 对下面这个银行类来说，使用synchronized方法就可以达到线程的互斥。多个线程同时只能有一个线程访问一个synchronized方法。 public class Bank{ public synchronized void deposite(){ 对某个帐户进行增加 } public synchronized void withdraw(){ 对某个帐户进行减少 } } 如果，我们想对某个对象的方法进行更灵活的线程互斥访问，可以使用synchornized语句，显示的声明要获得的锁的对象。 2， public synchronized static  void methd(){ .... } 上面的方法都可以防止多个线程同时访问这个类中的method方法。它可以对类的所有对象实例起作用。他等价于下面的方法。 public static  void method(){ synchronized(this.getClass()){ .... } } 这里还需要补充一下，synchronized方法被继承后就不是synchronized的了，除非在子类中再次声明方法为synchronized的。 Object类是Java所有对象的基类，Object类中有几个方法，提供了对多线程编程的支持：

1. wait()方法将当前运行的线程阻塞，放置于当前线程锁执行的对象的wait set中，然后取消此线程对锁的获得。
2. notify()/notifyAll()方法将把当前线程执行的对象的wait set中的某一个/所有线程拿出来。

注意，wait和notify/notifyAll方法只能在线程已获得对象实例的锁时才能调用，否则，将抛出java.lang.IllegalMonitorStateException。 这篇文章写的好累啊，语言组织能力咋这么弱...

DDMS 的全称是Dalvik Debug Monitor Service，它为我们提供例如：为测试设备截屏，针对特定的进程查看正在运行的线程以及堆信息、Logcat、广播状态信息、模拟电话呼叫、接收SMS、虚拟地理坐标等等。

如何启动 DDMS

DDMS 工具存放在SDK – tools/路径下，启动DDMS方法如下:

1. 直接双击ddms.bat运行；
2. 在Eclipes调试程序的过程中启动DDMS，在Eclipes中的界面如下：
   
   选择“Other”，界面如下：
   
   双击DDMS就可以启动了。

DDMS对Emulator和外接测试机有同等效用。如果系统检测到它们(VM)同时运行，那么DDMS将会默认指向 Emulator。以上2种启动后的操作有些不一样，建议分别尝试下。

DDMS 的工作原理

DDMS将搭建起IDE与测试终端(Emulator 或者connected device)的链接，它们应用各自独立的端口监听调试器的信息，DDMS可以实时监测到测试终端的连接情况。当有新的测试终端连接后，DDMS将捕捉到 终端的ID,并通过adb建立调试器，从而实现发送指令到测试终端的目的。

DDMS监听第一个终端App进程的端口为8600，APP进程将分配8601，如果有更多终端或者更多APP进程将按照这个顺序依次类推。DDMS通过8700端口（”base port”）接收所有终端的指令。

下边通过GUI详细了解DDMS的一些功能

Devices

在GUI的左上角可以看到标签为”Devices”的面板，这里可以查看到所有与DDMS连 接的终端的详细信息，以及每个终端正在运行的APP进程，每个进程最右边相对应的是与调试器链接的端口。因为Android是基于Linux内核开发的操 作平台，同时也保留了Linux中特有的进程ID，它介于进程名和端口号之间。

在面板的右上角有一排很重要的按键他们分别是Debug the selected process、Update Threads、Update Heap、Stop Process和ScreenShot。

Emulator Control

通过这个面板的一些功能可以非常容易的使测试终端模拟真实手机所具备的一些交互功能，比如：接听电话，根据选项模拟各种不同网络情况，模拟接受SMS消息和发送虚拟地址坐标用于测试GPS功能等。

Telephony Status: 通过选项模拟语音质量以及信号连接模式。
Telephony Actions: 模拟电话接听和发送SMS到测试终端。
Location Control: 模拟地理坐标或者模拟动态的路线坐标变化并显示预设的地理标识，可以通过以下3种方式：

• Manual： 手动为终端发送二维经纬坐标。
• GPX： 通过GPX文件导入序列动态变化地理坐标，从而模拟行进中GPS变化的数值。
• KML： 通过KML文件导入独特的地理标识，并以动态形式根据变化的地理坐标显示在测试终端。

Threads、Heap、File Exporler

这几项，我们在其他开发工具中也经常使用，就在不此详细说明了。通过File Exporler可以查看Android模拟器中的文件，可以很方便的导入/出文件。

Locate、Console

Locate：显示输出的调试信息，详见Android下如何调试程序？；
Console：是Android模拟器输出的信息，加载程序等信息；

使用DDMS模拟发送短信，操作过程如下：

在Emulator Control"Telephony Actions 中输入以下内容

单击发送后，在Android模拟器中打开Messaging，看到下面的短信：

单击新短信，详细查看短信内容：

中文显示为乱码，在未来的开发中，我们必须要注意中文字符的问题。

总结说明

DDMS是我们开发人员最好的调试工具，它将是每个从事Android开发的人员都不可缺少的。

    Java标注（Annotation）是Java语言5.0版本开始支持加入源代码的特殊语法元数据。

    Java语言中的类、方法、变量、参数和包等都可以被标注。Java标注和Javadoc不同，标注有自反性。在编译器生成类文件时，标注可以被嵌入到字节码中，由Java虚拟机执行时获取到标注。

    Java标注可以用于编译时，也可以用于运行时。下面的讨论主要集中于运行时。

    Annotation分类

    1，内建Annotation——Java5.0版在java语法中经常用到的内建Annotation：
    @Deprecated用于修饰已经过时的方法；
    @Override用于修饰此方法覆盖了父类的方法（而非重载）；
    @SuppressWarnings用于通知java编译器禁止特定的编译警告。

    下面代码展示了内建Annotation类型的用法：

要玩GPhone的模拟器，当然需要先去google上面下载Android的SDK，解压出来后在SDK的根目录下有一个tools文件夹，里面就是模拟器和一些非常有用的工具。

双击“emulator.exe”，直接启动模拟器，简单吧。当然，如果要对模拟器进行一些定制，还是要从命令行调用，带上参数启动。下面就来介绍一下启动是常用的几个参数：

1.模拟器外观的定制：
480x320, landscape: emulator -skin HVGA-L
320x480, portrait : emulator -skin HVGA-P (default)
320x240, landscape: emulator -skin QVGA-L
240x320, portrait : emulator -skin QVGA-P

2.为模拟器加上SD卡：
emulator -sdcard D:"sdcard.img

下面我们再来说说如何创建"sdcard.img"文件：
“tools”目录下还有另外一个很好用的工具“mksdcard.exe”，一看名字就知道——make sdcard。对，就用它来创建一个“SD卡”。

命令为：
mksdcard 1024M D:"sdcard.img

OK,这样一个容量为1G的SD卡就创建完毕了。

使用SDCard:

创建: mksdcard <1024M> <sdcard.img>
(bytes(default)，K，M)

连接到模拟器: emulator -sdcard <目录/sdcard.img>

传文件到SDCard: adb push <目录/audio.mp3> </sdcard/audio.mp3>

玩过手机模拟器的人一般最感兴趣的当然是模拟器能做什么呢？下面一一道来：

GPhone的模拟器有个特有的号码：15555218135，这个就类似我们实体手机的SIM卡号码啦。要实现拨号，用手机？当然不行！

更简单，三步：
1.运行 cmd
2.连接: telnet localhost 5554
3.命令:gsm call 15555218135

look！是不是模拟器上显示来电了？接听/挂断和实体手机一样。

发短信也一样简单，重复上面1，2两步，第三部命令改一下：
sms send 15555218135 Hello,this is a Message.

来说说PC与模拟器文件传输的方法吧。这里需要用到另一个重要工具，也在“tools”目录下，“adb.exe”。

adb:

adb(Android Debug Bridge)是Android 提供的一个通用的调试工具，借助这个工具，我们可以管理设备或手机 模拟器 的状态 。还可以进行以下的操作：
1、快速更新设备或手机模拟器中的代码，如应用或Android系统升级；
2、在设备上运行shell命令；
3、管理设备或手机模拟器上的预定端口；
4、在设备或手机模拟器上复制或粘贴文件

一些常用的操作：

进入Shell: adb shell

通过上面的命令，就可以进入设备或模拟器的shell环境中，在这个Linux Shell中，你可以执行各种Linux 的命令，另外如果只想执行一条shell命令，可以采用以下的方式：
adb shell [command]
如：adb shell dmesg会打印出内核的调试信息。
(Android的linux shell做了大量精简，很多linux常用指令都不支持)

上传文件: adb push <PC文件> </tmp/...>
下载文件: adb pull </tmp/...> <PC文件>

安装程序: adb install <*.apk>
卸载软件: adb shell rm /data/app/<*.apk>

补充一点，通过adb安装的软件(*.apk)都在"/data/app/"目录下，所以安装时不必制定路径，卸载只需要简单的执行"rm"就行。

结束adb: adb kill-server

显示android模拟器状态:
adb devices (端口信息)
adb get-product (设备型号)
adb get-serialno (序列号)

等待正在运行的设备: adb wait-for-device

端口转发: adb forward adb forward tcp:5555 tcp:1234
(将默认端口TCP 5555转发到1234端口上)

查看bug报告: adb bugreport

adb shell sqlite3 访问数据库SQLite3
adb shell logcat -b radio 记录无线通讯日志： 一般来说，无线通讯的日志非常多，在运行时没必要去记录，但我们还是可以通过命令，设置记录：

应用程序配置文件:
"AndroidManifest.xml"中
"<category android:name="android.intent.category.LAUNCHER" />"
决定是否应用程序是否显示在Panel上

-----------------------------------------------------------------------------------

am指令(在shell内使用am来加载android应用):
am [start|instrument]   
   
am start [-a <ACTION>]
  [-d <DATA_URI>]
  [-t <MIME_TYPE>]                
  [-c <CATEGORY> [-c <CATEGORY>] ...] 
  [-e <EXTRA_KEY> <EXTRA_VALUE> [-e <EXTRA_KEY> <EXTRA_VALUE> ...]
  [-n <COMPONENT>] [-D] [<URI>]       

am instrument [-e <ARG_NAME> <ARG_VALUE>]
  [-p <PROF_FILE>]                
  [-w] <COMPONENT>

启动浏览器:
am start -a android.intent.action.VIEW -d http://www.google.cn/

拨打电话:
am start -a android.intent.action.CALL -d tel:10086

启动google map直接定位到北京:
am start -a android.intent.action.VIEW geo:0,0?q=beijing

-----------------------------------------------------------------------------------

目录：
# ls
ls
sqlite_stmt_jou
cache
sdcard
etc
init
init.goldfish.r
init.rc
data
system
proc
sys
sbin
default.prop
root
dev

这里要说明下，从andorid中得到的文件流的字符串的顺序是按“类型+权限+拥有者+数组+大小+日期+名称+链接到”顺序排列的，其中类型“d”表示的是文件夹，"l"表示的是链接,'-'表示的是文件。

例如d rwxrwx--- system    cache                2009-01-09 11:46              cache

上面的目录就是通过解析ls命令返回的字符串进行解析的。

-----------------------------------------------------------------------------------

数据库:

联络人(含通话记录)数据库：/data/data/com.android.providers.contacts/databases/contacts.db
媒体库(貌似记录铃声设置等信息): /data/data/com.android.providers.media/internal.db
系统设置: /data/data/com.android.providers.settings/databases/settings.db
短信库: /data/data/com.android.providers.telephony/databases/mmssms.db
Web设置: /data.data/com.android.settings/databases/webview.db
地图搜索历史记录:/data/data/com.google.android.apps.maps/databases/search_history.db
帐号库?(内含androidId信息) : /data/data/com.google.android.googleapps/databases/accounts.db

铃声: /system/media/audio
时区设置: /data/property/persist.sys.timezone

-----------------------------------------------------------------------------------
目前的安装模式
　　安装前：
1. emulator -wipe-data
2. adb push busybox ./
3. adb shell ./busybox tar -cf /tmp/data.tar /data
4. adb pull /tmp/data.tar .
5. mkdir original
6. cd original
7. tar -xf ../data.tar

　　安装后：
1. adb shell ./busybox tar -cf /tmp/data.tar /data
2. adb pull /tmp/data.tar .
3. mkdir after_install
4. cd after_install
5. tar -xf ../data.tar

    目前来看，就是/data/app和data/data下多了两个相关文件，同时在/data/system/packages.xml中增加了安装的程序信息。似乎菜单也是从这个文件中得到是否新安装程序，以及如何显示相关信息比如名称什么的。

android模拟器和真机的不同之处：

    * 不支持呼叫和接听实际来电；但可以通过控制台模拟电话呼叫(呼入和呼出)
    * 不支持USB连接
    * 不支持相机/视频捕捉
    * 不支持音频输入(捕捉)；但支持输出(重放)
    * 不支持扩展耳机
    * 不能确定连接状态
    * 不能确定电池电量水平和交流充电状态
    * 不能确定SD卡的插入/弹出
    * 不支持蓝牙

中国台湾省 中国大陆

程式----------->程序

图示----------->图标

功能表--------->菜单

视窗----------->窗口

作业----------->工作

内存----------->记忆体

埠------------->端口

资讯----------->信息

硬盘----------->硬碟

互动----------->交互

光盘----------->光碟

硬碟机--------->硬盘驱动器

光碟机--------->光盘驱动器

变数----------->变量

物件----------->对象

乱数----------->随机数

测验----------->测试

滑鼠----------->鼠标

回应----------->响应

设定----------->设置

撰写----------->编写

列印----------->打印

网路----------->网络

档案----------->文件

位元----------->比特

档名----------->文件名

影像----------->图像

萤屏----------->屏幕

存盘----------->存储

指标----------->指示

影片----------->动画

真伪----------->真假

显示幕--------->显示器

工具列--------->工具栏

重绘----------->刷新

装置----------->设置

游标----------->光标

关於----------->关于

支援----------->支持

软体----------->软件

硬体----------->硬件

著作权--------->版权

来自：http://www.javaeye.com/topic/106626

一、简介：
hsql数据库是一款纯Java编写的免费数据库，许可是BSD-style的协议。
相对其他数据库来说，其体积小，才563kb。
仅一个hsqldb.jar文件就包括了数据库引擎，数据库驱动，还有其他用户界面操作等内容。
下载地址：http://hsqldb.org/

二、使用hsql数据库：
1、hsql数据库引擎有几种服务器模式：常用的Server模式、WebServer模式、Servlet模式、Standlone模式、Memory-On&shy;ly数据库。

2、最为常用的Server模式：
1)首先却换到lib文件夹下，运行java -cp hsqldb.jar
org.hsqldb.Server -database.0 db/mydb -dbname.0 xdb
执行命令后，将会在db文件夹下创建一个数据库mydb，别名（用于访问数据库）是xdb，如果存在mydb数据库，将会打开它。
2)运行数据库界面操作工具：java -cp hsqldb.jar
org.hsqldb.util.DatabaseManager
在Type选项里选上相应的服务器模式，这里选择HSQL
Database Engine
Server模式；Driver不用修改；URL修改为jdbc:hsqldb:hsql://localhost/xdb
（主要这里xdb就是上面我们设置的别名）;user里设置用户名，第一次登录时，设置的是管理员的用户名，password设置密码。然后点击Ok。
3)第一次运行数据库引擎，创建数据库完毕。好了，你可以打开db文件夹，会发现里面多了几个文件。
mydb.properties文件：是关于数据库的属性文件。
mydb.script：hsql主要保存的表（这里按hsql的说法是Memory表，就是最为常用的），里面的格式都是文本格式，可以用文本查看，里面的语&shy;句都是sql语句，熟悉sql语句的话，你也可以手动修改它。每次运行数据库引擎的话都是从这里加载进内存的。
mydb.lck表示数据库处于打开状态。
其他的请参看hsqldb包里的手册。

3、WebServer模式和Server运行模式基本一样，只是支持了Http等协议，主要用于防火墙，默认端口是9001。启动Server，java
-cp hsqldb.jar org.hsqldb.WebServer ...剩余的和上面的一致。

4、Servlet模式可以允许你通过Servlet容器来访问数据库，请查看hsqlServlet.java的源代码，和WebServer类似。

5、另一个值得思考的模式是Standalone模式：不能通过网络来访问数据库，主要是在一个JVM中使用，那样的话，访问的速度会更加快。虽然文档里 面提到&shy;主要是用于开发时使用，但是我们可以假设一下，该方法不需要一个引擎类的东西，而类似于打开文件的方式，返回一个 Connection对象：
Connection c = DriverManager.getConnection("jdbc:hsqldb:file:mydb",
"sa", "");
将会在当前目录找到mydb数据库相关文件，打开并返回一个Connection对象。该方式有点好处就是可以不使用引擎，在需要的时候操作数据。所以那 些对数&shy;据库不是特别有要求的，但又需要一个操作数据库的方式的话，可以使用这种方法。对于那些不想额外在数据库引擎花费金钱的话，可以 使用这种方法。但是不推荐使用该&shy;方法。记得Hibernate里SessionFactory可以使用 openSession(Connecttion
c)来获得一个Session对象的，因此，在测试或者实际应用的话都可以这样使用。

6、Memory-Only
数据库：顾名思义，主要是内存中使用，不用于保存数据。可以用于在内存中交换数据。

上面是关于hsqldb的一些基本信息的介绍，可以看到它的一些优势和特性。
我们可以把hsqldb内置在web程序中，除考虑Standalone模式外，最好是采用最为常用的Server模式。
那么Server模式如何和web程序合理搭配使用呢。
可以采用两种方式：
1）采用上面提到的方法，运行java -cp hsqldb.jar
org.hsqldb.Server -database.0 db/mydb -dbname.0 xdb
来启动db，通过设置的URL：jdbc:hsqldb:hsql://localhost/xdb
以达到在程序中访问hsql数据库的
（注：设置URL等信息，可以通过hibernate来配置，例如：
hibernate.dialect org.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username sa
hibernate.connection.password
hibernate.connection.url jdbc:hsqldb:hsql://localhost/xdb ）
2）为了省去第一种方法的琐碎，可以在启动web容器的过程中同时启动hsqldb。具体做法如下：编写一个有关hsql的Listener类，扩展javax&shy;.servlet.ServletContextListener，可以在配置文件中设置dbPath、dbName、port等等hsqldb的信息，启动h&shy;sqldb。
在web.xml中配置
<listener>

<listener-class>com.iplan.portal.framework.web.HsqlListener</listener-class&shy;>
</listener>
这样在启动web容器的时候，同时启动了hsqldb，关闭容器的时候同时也shutdown掉hsqldb。

MyEclipse6.5集成SVN

第一步：安装Mylyn：

      打开Myeclipse6.5，依次点击Hellp-->Software Updates-->Find and Install

      在弹出的对话框中选择第二项（Search for new features to install)，点击next后，在新的对话框中选择New Remote Site...然后填写下面内容：

Name：Mylyn

URL：http://download.eclipse.org/tools/mylyn/update/e3.3

     然后一路点击下一步。完成安装后重启workspace。

第二步：安装Subversive：

      打开Myeclipse6.5，依次点击Hellp-->Software Updates-->Find and Install

      在弹出的对话框中选择第二项（Search for new features to install)，点击next后，在新的对话框中选择New Remote Site...然后填写下面内容：

Name：subversive

URL：http://download.eclipse.org/technology/subversive/0.7/update-site/

      然后一路点击下一步。完成安装后重启workspace。

第三步：安装Subservice Connectors：

      打开MyEclipse6.5，依次点击Hellp-->Software Updates-->Find and Install

      在弹出的对话框中选择第二项（Search for new features to install)，点击next后，在新的对话框中选择New Remote Site...然后填写下面内容：

Name：subservice connectors

URL：http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/

      然后一路点击下一步。完成安装后重启workspace。

      到这里安装完毕。

      然后在MyEclipse6.5点击Window-->Show View-->Other...-->SVN-->SVN Repositories,点击OK，添加SVN Repositories的窗口。

      好了，下面就可以新建一个Repository Location了。

在SVN Repositories窗口中右键New-->Repository Location，输入SVN服务端的URL和用户名，密码，点击确定后就完成了。

ROWNUM的概念
ROWNUM是 一个虚假的列。它将被分配为 1，2，3，4，...N，N 是行的数量。一个ROWNUM值不是被永久的分配给一行 （这是最容易被误解的）。表中的某一行并没有标号；你不可以查询ROWNUM值为5的行——根本没有这个概念。另一个容易搞糊涂的问题是ROWNUM值是 何时被分配的。ROWNUM值的分配是在查询的谓词解析之后，任何排序和聚合之前进行的。ROWNUM值只有当被分配之后才会增长。这就是为什么下面的查 询永远都不会返回结果：
select * from countries where rownum>1;
ROWNUM > 1对于第一行来说并不是真值，ROWNUM没有增长到 2。所以，没有比1大的ROWNUM.永远都不要使用’ROWNUM>？‘和’ROWNUM=2…N’这样的条件。

用rownum显示排序结果的前N条记录
FROM/WHERE子句先被执行.
根据FROM/WHERE子句输出的行, ROWNUM被分配给他们并自增长.
SELECT 被应用.
GROUP BY 被应用.
HAVING is 被应用.
ORDER BY 被应用.
这就是为什么下面的SQL几乎总是错误的:
select rownum,job_title,min_salary
from jobs where rownum<3 order by min_salary;
正确的写法:
        select rownum,tmp.* from (
        select job_title,min_salary
        from jobs order by min_salary) tmp
        where rownum<=3;

用ROWNUM实现分页
select * from
        (select /*+ FIRST_ROWS(n) */ a.*,
        ROWNUM rnum
        from (your_query_goes_here, with order by) a
        where ROWNUM <=
        :MAX_ROW_TO_FETCH )
where rnum >= :MIN_ROW_TO_FETCH;
FIRST_ROWS(N)使优化器考虑最短时间获得前N条记录.
:MAX_ROW_TO_FETCH 某一页中结果集的最后一行。如果你每页显示10行，要显示第6页,那么此值取60。
:MIN_ROW_TO_FETCH 某一页中结果集的第一行。如果你每页显示10行，要显示第6页,那么此值取50。

ROWNUM对性能的影响
ROWNUM可以避免oracle在磁盘上进行排序。rownum无法避免全表扫描的发生，但是它可以避免对整个表数据的排序操作，在指定了rownum后，排序操作在内存中可以轻松完成。

如上图，事务2会报主键冲突的错误，而再刷新一下页面（再执行一边程序），可能就正常了。
还有一个问题，那就是完成生成主键的程序 （一般情况包含plsql块）本身对于并发调用也是一个瓶颈，因为这样的程序段往往是提供给好多程序去调用，如果代码端写的不够优化（比如没有使用邦定变 量等等），或者此代码段存在问题，那么它所影响的是系统的全局。我们应该提倡开发人员使用sequence。sequence消除了序列化问题，而且改善 了应用的并发能力。

创建sequence

sequence的命名最重要的是要统一，命名规则是次要的。
 CREATE SEQUENCE emp_sequence
      INCREMENT BY 1
      START WITH 1
      NOMAXVALUE
      NOCYCLE
      CACHE 10;
这 里需要重点说明的是cache参数，它是为了应对并发访问的。cache参数告诉oracle预先分配一个sequence numbers的集合，并且保留在内存中，以便sequence number能够被快速的访问。这个内存的大小就是cache所指定的大小，当多个用户同时访问一个sequence的时候，是在oracle SGA中读取sequence当前的合理数值，如果并发访问太大，cache的大小不够，那么就会产生sequence cache相关的等待（enq: SQ - contention），影响系统性能。
既然cache涉及到了内存，那么就会想到oracle实例恢复的问题。如果数据库shutdown abort，sequence会如何呢？当然会有问题，sequence number保存在内存里的但是没有被应用到表中的会丢失！

修改sequence

除了修改sequence的starting number，你什么都能改，如果想改starting number，只能先drop然后create。
ALTER SEQUENCE emp_sequence
    INCREMENT BY 10
    MAXVALUE 10000
    CYCLE
    CACHE 20;
修 改很有用，最典型的情况是“需要把sequence 的current value改大一点，避免程序报错！”。你就可以看看current value是多少，然后修改increment by 足够大的值，然后执行.nextval，最后别忘了再将increnent by改成原来的值，还要注意做这些工作的前提是当前没有人用此sequence。

使用 sequence

CURRVAL 和 NEXTVAL 能够在以下情况使用:
insert的values字句、select中的select列表、update中的set字句

CURRVAL 和 NEXTVAL 不能够在以下情况使用:
子查询、视图和实体化视图的查询、带distinct的select语句、带 group by和order by的select语句、带union或intersect或minus的select语句、select中的where字句、create table与alter table中的default值、check约束条件。

删除sequence

drop sequence seq_a;
当删除sequence后，对应它的同义词会被保留，但是引用时会报错。

oracle rac环境中的sequence

oracle为了在rac环境下为了sequence的一致性，使用了三种锁：row cache lock、SQ锁、SV锁。
row cache lock的目的是在sequence指定nocache的情况下调用sequence.nextval过程中保证序列的顺序性；
SQ锁是应用于指定了cache+noorder的情况下调用sequence.nextval过程中。
SV 锁（dfs lock handel) 是调用sequence.nextval期间拥有的锁。前提是创建sequence时指定了cache 和order属性 (cache+order)。order参数的目的是为了在RAC上节点之间生成sequence的顺序得到保障。

创建sequence赋予的cache值较小时，有enq:sq-contention等待增加的趋势。
cache的缺省值是20.因此创建并发访问多的sequence时，cacheh值应取大一些。否则会发生enq:sq-contention等待事件。

rac上创建sequence时，如果指定了cache大小而赋予noorder属性，则各节点将会把不同范围的sequence值cache到内 存上。若两个节点之间都必须通过依次递增方式使用sequence，必须赋予如下的order属性（一般不需要这样做）"sql> create sequence seq_b cache 100 order"。如果是已赋予了cache+order属性的sequence，oracle使用SV锁进行同步。SV锁争用问题发生时的解决方法与sq锁 的情况相同，就是将cache 值进行适当调整。

在RAC多节点环境下，Sequence的Cache属性对性能的影响很大。应该尽量赋予cache+noorder属性，并要给予足够的 cache值。如果需要保障顺序，必须赋予cache+order属性。但这时为了保障顺序，实例之间需要不断的交换数据。因此性能稍差。

来自：http://silverw0396.javaeye.com/blog/90554

一．引言

    ORACLE数据库字符集，即Oracle全球化支持(Globalization Support)，或即国家语言支持（NLS）其作用是用本国语言和格式来存储、处理和检索数据。利用全球化支持，ORACLE为用户提供自己熟悉的数据库母语环境，诸如日期格式、数字格式和存储序列等。Oracle可以支持多种语言及字符集，其中oracle8i支持48种语言、76个国家地域、229种字符集，而oracle9i则支持57种语言、88个国家地域、235种字符集。由于oracle字符集种类多，且在存储、检索、迁移oracle数据时多个环节与字符集的设置密切相关，因此在实际的应用中，数据库开发和管理人员经常会遇到有关oracle字符集方面的问题。本文通过以下几个方面阐述，对oracle字符集做简要分析

二．字符集基本知识

2.1字符集
    实质就是按照一定的字符编码方案，对一组特定的符号，分别赋予不同数值编码的集合。Oracle数据库最早支持的编码方案是US7ASCII。
    Oracle的字符集命名遵循以下命名规则:
    <Language><bit size><encoding>
    即:  <语言><比特位数><编码>
    比如: ZHS16GBK表示采用GBK编码格式、16位（两个字节）简体中文字符集

2.2字符编码方案
2.2.1 单字节编码
    （1）单字节7位字符集，可以定义128个字符，最常用的字符集为US7ASCII

    （2）单字节8位字符集，可以定义256个字符，适合于欧洲大部分国家
            例如：WE8ISO8859P1(西欧、8位、ISO标准8859P1编码)

2.2.2 多字节编码
    （1）变长多字节编码
    某些字符用一个字节表示，其它字符用两个或多个字符表示，变长多字节编码常用于对亚洲语言的支持，例如日语、汉语、印地语等
    例如：AL32UTF8（其中AL代表ALL,指适用于所有语言）、zhs16cgb231280

    （2）定长多字节编码
    每一个字符都使用固定长度字节的编码方案，目前oracle唯一支持的定长多字节编码是AF16UTF16，也是仅用于国家字符集

2.2.3 unicode编码
    Unicode是一个涵盖了目前全世界使用的所有已知字符的单一编码方案，也就是说Unicode为每一个字符提供唯一的编码。UTF-16是unicode的16位编码方式，是一种定长多字节编码，用2个字节表示一个unicode字符，AF16UTF16是UTF-16编码字符集。
    UTF-8是unicode的8位编码方式，是一种变长多字节编码，这种编码可以用1、2、3个字节表示一个unicode字符，AL32UTF8，UTF8、UTFE是UTF-8编码字符集

2.3 字符集超级
    当一种字符集（字符集A）的编码数值包含所有另一种字符集（字符集B）的编码数值，并且两种字符集相同编码数值代表相同的字符时，则字符集A是字符集B的超级，或称字符集B是字符集A的子集。
    Oracle8i和oracle9i官方文档资料中备有子集-超级对照表（subset-superset pairs），例如：WE8ISO8859P1是WE8MSWIN1252的子集。由于US7ASCII是最早的Oracle数据库编码格式，因此有许多字符集是US7ASCII的超集，例如WE8ISO8859P1、ZHS16CGB231280、ZHS16GBK都是US7ASCII的超集。

2.4 数据库字符集（oracle服务器端字符集）
    数据库字符集在创建数据库时指定，在创建后通常不能更改。在创建数据库时，可以指定字符集(CHARACTER SET)和国家字符集(NATIONAL CHARACTER SET)。
2.4.1 字符集
    (1)用来存储CHAR, VARCHAR2, CLOB, LONG等类型数据
    (2)用来标示诸如表名、列名以及PL/SQL变量等
    (3)用来存储SQL和PL/SQL程序单元等

2.4.2 国家字符集：
    (1)用以存储NCHAR, NVARCHAR2, NCLOB等类型数据
    (2)国家字符集实质上是为oracle选择的附加字符集，主要作用是为了增强oracle的字符处理能力，因为NCHAR数据类型可以提供对亚洲使用定长多字节编码的支持，而数据库字符集则不能。国家字符集在oracle9i中进行了重新定义，只能在unicode编码中的AF16UTF16和UTF8中选择，默认值是AF16UTF16

2.4.3查询字符集参数
    可以查询以下数据字典或视图查看字符集设置情况
    nls_database_parameters、props$、v$nls_parameters
    查询结果中NLS_CHARACTERSET表示字符集，NLS_NCHAR_CHARACTERSET表示国家字符集

2.4.4修改数据库字符集
    按照上文所说，数据库字符集在创建后原则上不能更改。如果需要修改字符集，通常需要导出数据库数据，重建数据库，再导入数据库数据的方式来转换，或通过ALTER DATABASE CHARACTER SET语句修改字符集，但创建数据库后修改字符集是有限制的，只有新的字符集是当前字符集的超集时才能修改数据库字符集，例如UTF8是US7ASCII的超集，修改数据库字符集可使用ALTER DATABASE CHARACTER SET UTF8。

2.5 客户端字符集（NLS_LANG参数）
2.5.1 客户端字符集含义
    客户端字符集定义了客户端字符数据的编码方式，任何发自或发往客户端的字符数据均使用客户端定义的字符集编码,客户端可以看作是能与数据库直接连接的各种应用，例如sqlplus,exp/imp等。客户端字符集是通过设置NLS_LANG参数来设定的。
2.5.2 NLS_LANG参数格式
    NLS_LANG=<language>_<territory>.<client character set>
    Language:显示oracle消息,校验，日期命名
    Territory：指定默认日期、数字、货币等格式
    Client character set：指定客户端将使用的字符集
    例如：NLS_LANG=AMERICAN_AMERICA.US7ASCII 
    AMERICAN是语言，AMERICA是地区，US7ASCII是客户端字符集
2.5.3客户端字符集设置方法
     1)UNIX环境
         $NLS_LANG=“simplified chinese”_china.zhs16gbk
         $export NLS_LANG
         编辑oracle用户的profile文件
    2)Windows环境
         编辑注册表
         Regedit.exe---HKEY_LOCAL_MACHINE---SOFTWARE---ORACLE—HOME0
2.5.4 NLS参数查询
    Oracle提供若干NLS参数定制数据库和用户机以适应本地格式，例如有NLS_LANGUAGE,NLS_DATE_FORMAT,NLS_CALENDER等，可以通过查询以下数据字典或v$视图查看。
    NLS_DATABASE_PARAMETERS--显示数据库当前NLS参数取值，包括数据库字符集取值
    NLS_SESSION_PARAMETERS--显示由NLS_LANG 设置的参数，或经过alter session 改变后的参数值（不包括由NLS_LANG 设置的客户端字符集）
    NLS_INSTANCE_PARAMETE--显示由参数文件init<SID>.ora 定义的参数V$NLS_PARAMETERS--显示数据库当前NLS参数取值
2.5.5修改NLS参数
    使用下列方法可以修改NLS参数
    （1）修改实例启动时使用的初始化参数文件
    （2）修改环境变量NLS_LANG
    （3）使用ALTER SESSION语句，在oracle会话中修改
    （4）使用某些SQL函数
    NLS作用优先级别：Sql function>alter session>环境变量或注册表>参数文件>数据库默认参数

三．导入/导出与字符集转换

3.1 EXP/IMP
    Export 和 Import 是一对读写Oracle数据的工具。Export 将 Oracle 数据库中的数据输出到操作系统文件中, Import 把这些文件中的数据读到Oracle 数据库中，由于使用exp/imp进行数据迁移时，数据从源数据库到目标数据库的过程中有四个环节涉及到字符集，如果这四个环节的字符集不一致，将会发生字符集转换。

EXP
     ____________   _________________  _____________
     |imp导入文件|<-|环境变量NLS_LANG|<-|数据库字符集|
     ------------   -----------------  -------------

IMP 
     ____________   _________________  _____________
     |imp导入文件|->|环境变量NLS_LANG|->|数据库字符集|
     ------------   -----------------  -------------

    四个字符集是
   （1）源数据库字符集
   （2）Export过程中用户会话字符集（通过NLS_LANG设定）
   （3）Import过程中用户会话字符集（通过NLS_LANG设定）
   （4）目标数据库字符集

3.2导出的转换过程
    在Export过程中，如果源数据库字符集与Export用户会话字符集不一致，会发生字符集转换，并在导出文件的头部几个字节中存储Export用户会话字符集的ID号。在这个转换过程中可能发生数据的丢失。
例:如果源数据库使用ZHS16GBK，而Export用户会话字符集使用US7ASCII，由于ZHS16GBK是16位字符集,而US7ASCII是7位字符集，这个转换过程中，中文字符在US7ASCII中不能够找到对等的字符，所以所有中文字符都会丢失而变成“?? ”形式，这样转换后生成的Dmp文件已经发生了数据丢失。
因此如果想正确导出源数据库数据，则Export过程中用户会话字符集应等于源数据库字符集或是源数据库字符集的超集

3.3导入的转换过程
    （1）确定导出数据库字符集环境
    通过读取导出文件头，可以获得导出文件的字符集设置
    （2）确定导入session的字符集，即导入Session使用的NLS_LANG环境变量
    （3）IMP读取导出文件
    读取导出文件字符集ID，和导入进程的NLS_LANG进行比较
    （4）如果导出文件字符集和导入Session字符集相同，那么在这一步骤内就不需要转换，如果不同，就需要把数据转换为导入Session使用的字符集。可以看出，导入数据到数据库过程中发生两次字符集转换
    第一次:导入文件字符集与导入Session使用的字符集之间的转换，如果这个转换过程不能正确完成，Import向目标数据库的导入过程也就不能完成。
    第二次:导入Session字符集与数据库字符集之间的转换。
    然而,oracle8i的这种转换只能在单字节字符集之间进行,oracle8i导入Session不支持多字节字符集之间的转换，因此为了避免第一次转换，导入Session使用的NLS_LANG与导出文件字符集相同，第二次转换（通过SQL*Net）支持任何两种字符集。以上情况在Oracle9i中略有不同

四．乱码问题

    oracle在数据存储、迁移过程中经常发生字符乱码问题，归根到底是由于字符集使用不当引起。下面以使用客户端sqlplus向数据库插入数据和导入/导出（EXP/IMP）过程为例，说明乱码产生的原因。

4.1使用客户端sqlplus向数据库存储数据
    这个过程存在3个字符集设置
    （1）客户端应用字符集
    （2）客户端NLS_LANG参数设置
    （3）服务器端数据库字符集(Character Set)设置
    客户端应用sqlplus中能够显示什么样的字符取决于客户端操作系统语言环境(客户端应用字符集)，但在应用中录入这些字符后，这些字符能否在数据库中正常存储，还与另外两个字符集设置紧密相关，其中客户端NLS_LANG参数主要用于字符数据传输过程中的转换判断。常见的乱码大致有两种情形：
    （1）汉字变成问号“？”；
当从字符集A 转换成字符集B时，如果转换字符之间不存在对应关系，NLS_LANG使用替代字符“？”替代无法映射的字符
    （2）汉字变成未知字符（虽然有些是汉字，但与原字符含义不同）
转换存在对应关系，但字符集A 中的字符编码与字符集B 中的字符编码代表不同含义

4.2发生乱码原因 
    乱码产生是由于几个字符集之间转换不匹配造成，分以下几种情况：
    （注：字符集之间如果不存在子集、超集对应关系时的情况不予考虑，因为这种情况下字符集之间转换必产生乱码）   
    1）服务器端数据库字符集与客户端应用字符集相同，与客户端NLS_LANG参数设置不同
    如果客户端NLS_LANG字符集是其它两种字符集的子集，转换过程将出现乱码。
    解决方法：将三种字符集设置成同一字符集，或NLS_LANG字符集是其它两种字符集的超集
    2）服务器端数据库字符集与客户端NLS_LANG参数设置相同，与客户端应用字符集不同
    如果客户端应用字符集是其它两种字符集的超集时，转换过程将出现乱码，但对于单字节编码存储中文问题，可参看本文第5章节的分析
    3）客户端应用字符集、客户端NLS_LANG参数设置、服务器端数据库字符集互不相同
    此种情况较为复杂，但三种字符集之间只要有不能转换的字符，则必产生乱码

4.3导入/导出过程出现乱码原因
    这个过程存在4个字符集设置，在3.1章节中已分析
   （1）源数据库字符集
   （2）EXP过程中NLS_LANG参数
   （3）IMP过程中NLS_LANG参数
   （4）目标数据库字符集
    出现乱码原因
    1）当源数据库字符集不等于EXP过程中NLS_LANG参数，且源数据库字符集是EXP过程中NLS_LANG的子集，才能保证导出文件正确，其他情况则导出文件字符乱码
    2）EXP过程中NLS_LANG字符集不等于IMP过程中NLS_LANG字符集，且EXP过程中NLS_LANG字符集是IMP过程中NLS_LANG字符集的子级, 才能保证第一次转换正常，否则第一次转换中出现乱码。
    3）如果第一次转换正常，IMP过程中NLS_LANG字符集是目标数据库字符集的子集或相同，才能保证第二次转换正常，否则则第二次转换中出现乱码

五．单字节编码存储中文问题

    由于历史的原因，早期的oracle没有中文字符集（如oracle6、oracle7、oracle7.1）,但有的用户从那时起就使用数据库了，并用US7ASCII字符集存储了中文，或是有的用户在创建数据库时，不考虑清楚，随意选择一个默认的字符集，如WE8ISO8859P1或US7ASCII，而这两个字符集都没有汉字编码，虽然有些时候选用这种字符集好象也能正常使用，但用这种字符集存储汉字信息从原则上说就是错误的，它会给数据库的使用与维护带来一系列的麻烦。
    正常情况下，要将汉字存入数据库，数据库字符集必须支持中文，而将数据库字符集设置为US7ASCII等单字节字符集是不合适的。US7ASCII字符集只定义了128个符号，并不支持汉字。另外，如果在SQL*PLUS中能够输入中文，操作系统缺省应该是支持中文的，但如果在NLS_LANG中的字符集设置为US7ASCII，显然也是不正确的，它没有反映客户端的实际情况。但在实际应用中汉字显示却是正确的，这主要是因为Oracle检查数据库与客户端的字符集设置是同样的，那么数据在客户与数据库之间的存取过程中将不发生任何转换，但是这实际上导致了数据库标识的字符集与实际存入的内容是不相符的。而在SELECT的过程中，Oracle同样检查发现数据库与客户端的字符集设置是相同的，所以它也将存入的内容原封不动地传送到客户端，而客户端操作系统识别出这是汉字编码所以能够正确显示。
    在这个例子中，数据库与客户端都没有设置成中文字符集，但却能正常显示中文，从应用的角度看好象没问题。然而这里面却存在着极大的隐患，比如在应用length或substr等字符串函数时，就可能得到意外的结果。
    对于早期使用US7ASCII字符集数据库的数据迁移到oracle8i/9i中（使用zhs16gbk），由于原始数据已经按照US7ASCII格式存储，对于这种情况，可以通过使用Oracle8i的导出工具，设置导出字符集为US7ASCII，导出后使用UltraEdit等工具打开dmp文件，修改第二、三字符，修改 0001 为0354,这样就可以将US7ASCII字符集的数据正确导入到ZHS16GBK的数据库中。

六．结束语

    为了避免在数据库迁移过程中由于字符集不同导致的数据损失，oracle提供了字符集扫描工具（character set scanner），通过这个工具我们可以测试在数据迁移过程中由于字符集转换可能带来的问题，然后根据测试结果，确定数据迁移过程中最佳字符集解决方案。

Sun  的关于 JavaBean 规范见：http://java.sun.com/javase/technologies/desktop/javabeans/docs/spec.html，其中可下载到 JavaBean 规范的  PDF 文档。


实际中的问题

首 先，当然还是要说它的属性及 setter/getter 方法。属性以小写字母开头，驼峰命名格式，相应的 getter/setter 方法是 get/set 接上首字母大写的属性名。多数情况是对的，且当前流行的 IDE(Eclipse、JBuilder) 也都认这个死理，这里 NetBean 值得表扬一下。但要是碰到些遗留的代码中属性名不规范，或者有些人就是顽固，或真是对属性命名犹豫不决时的写下的代码时，那还是有得你研究一下。

这里来看看 Eclipse 为几个属性生成的 getter/setter 方法吧：

sName(从 C 转过来的，受匈牙利的影响，认为 Name 是个字符串，所以加个前缀 s)           getSName()/setSName(String name)
URL (平时认为是缩略语/专有名词，理当全部大写，这在我们对待 ID 时经常发生的)           getURL()/setURL(String url)

上 面第一个由 Eclipse 为我们生成的 getSName()/setSName(String name) 方法，参照 JavaBean  规范来说，其实是错误的。如果出现这样的方法，放到我们的标签(像 Struts 标签，如 <s:textfield name="sName"/>)，或是进行 Hibernate/iBatis 那种映射时，你就能收到报 找不到 sName 属性相应的 getter/setter 方法 那样的错误。不是明明有 getSName() 和 setSName(String name)，可是方法名错了，正确的版本应该是 getsName() 和 setsName(String name)。

前面首先解释了属性命名不规范产生问题的原因，现在就来更仔细的了解关于 JavaBean 属性及其 getter/setter 方法的约定，有些是硬性的。


属性与存取访问的规定

为 JavaBean 创建属性时，必须牢记：缩略语通常被视为一个独立的单词，而不是单个字母。例如，URL 对应的属性名应该用 url，相应的 getUrl()/setUrl()，所以 ID 还是用 id 作为属性吧，相应的 getId()/setId()。

规 范中另一个特别的地方就是，第二个字母为大写的属性名要区别对待。如果属性名的第二个字母是大写的，那么该属性名直接用作 getter/setter 方法中 get/set 的后部分，就是说大小写不变。这就是为什么 sName 对应的存取方法是 getsName()/setsName() 的原因，不能不说这条规则很令人费解。那就更有必要看看下面表格的规范：

    来自J道Banq http://www.jdon.com/artichect/dbdead.htm

随着用户的爆发量增长，在某个凌晨醒来时，你发现：数据库已死。

传统软件系统实则应该叫数据库软件系统，是一个数据库系统，开发这样的系统非常简单，成本 也非常低廉，只要根据需求先设计好数据表结构，然后，就找一些大学毕业生写大量SQL语句，虽然还使用 JAVA/PHP/.NET等语言，但实际上这些语言只是将SQL送往数据库执行的运输工，没有什么价值和地位。

所以，这样的系统运行在互联网环境下以后，主要负载就集中在数据库的SQL运行上，也就是说：整个软件系统性能关键点就集中在数据库上了，数据库是性能 主角，是王者；虽然你购置了昂贵的Websphere/weblogic等应用服务器，但是由于Java只是运输工，根本起不到性能上负载分担的作用。

著名的社区网站MySpace就是因为一个好的idea，用户疯狂增长，但是系统却不能平滑承受增长的用户访问，这些用户访问网站缓慢、无法访问甚至丢失数据，他们经过几次伤筋动骨的架构升级，在微软SQLServer直接技术支持下， 好容易才勉强应付过去。看看他们痛苦经历，你是否也愿意再来一次呢？详细情况： http://www.jdon.com/jivejdon/thread/34601.html

从中可以看出，数据库性能微调和挖潜总是有限度的，对数据库性能优化提高性能的步伐永远赶不上用户增长量， 有人也提出数据库集群的概念，其实数据库集群是一个骗人概念，一般只是备份，在集群数量和failover上有制约， 否则，数据库巨头Oracle不会跑到JavaEE阵营摇旗呐喊，还最早推出EJB3服务器，并扬言要收购JavaEE过去老大 Bea Weblogic。

很显然，数据库成已经为软件系统的主要性能瓶颈了，单纯依靠数据库自救的方式已经行不通，是宣布数据库退出主角时候了，那么由谁来宣布：教皇数据库已死？无疑是Java。

Java社区早在本世纪初就提出中间件概念，用以取代数据库地位，实则就是将软件系统主要负载从数据库上转移到中间件服务器上，分担负载。 也就是说：Java社区提出：既然数据库已经成为瓶颈，修修补补也无济于事，不如放弃它，不再依赖它。

也就是说：Java不再做SQL的运输工，不再是跑龙套的了，而是主角，那么如何让Java成为主角呢？那必须依赖对象这个概念，对象是生活在中间件服务器内存中，它又是数据库数据的业务封装，它和数据库有着 千丝万缕的关系，但是它又和关系数据库存在天然矛盾，两者水火不容。

过去，我们是将业务逻辑写成SQL送往数据库执行，导致数据库成为业务逻辑主要运行瓶颈，那么，如果我们将 业务逻辑用对象概念表达，而不是SQL，那么我们的业务逻辑就围绕内存中的对象反复计算，这样，负载不是集中在 对象运行的中间件服务器上（也就是应用服务器Weblogic/websphere/JBoss/Tomcat）？而对象/中间件都是用Java 语言表达的，无疑，这样的架构，Java才成为主角。

再进一步想想：如果我们从软件系统开始之初，就使用对象分析设计，不与数据库沾边，整个流程就完全OO，分析设计直至代码都摆脱了数据库影响，这个流程如下：

分析建模 细化设计(通过Evans DDD) 架构设计 代码实现 调试测试 部署运行。

那么数据库在什么时候建立呢？数据库表结构的创建可以延缓到部署运行时，由Hibernate/EJB CMP/JPA等ORM技术自动实现。这样， 整个上游环节就不涉及数据库技术，而是使用更符合自然的表达OO方式，软件质量就更高了。我在J道网站已经大量阐述了如何从OO分析 到OO实现的过程，包括我的Jdon框架也直接支持这样一个自然方式。

现在，很多人已经理解，分析设计要用OO，但是数据库是运行阶段缺少不了的，确实，这是正确观点，我们夺取数据库的王位，不是将它打倒，只是理性和平移交权力重心而已，数据库退出主角地位，让位于Java中间件，也预示着过去数据库为王的时代的结束， 但是数据库会和操作系统一样，成为我们现代软件系统一个不可缺少重要的基础环节。

正是基于这样事实，虽然我早在2005年喊出“数据库时代的终结一文，回帖长达几百贴， 大部分是怀疑论，不信论，其实2003年国外TSS就有一篇“给数据库休息吧” （休息不代表退休，而是退居幕后，就象操作系统作用一样），由此可见，由于传统观点影响和不及时与国际新思想同步，国内数据库保皇派还是有相当人数的。我 BanQ人微言轻，抛出这些观点被保皇派讥讽为所疯话，那么看看，著名ORM框架Hibernate和SEAM框架创始人Gavin King的一段观点：

In almost all enterprise applications, the database is the primary bottleneck, and the least scalable tier of the runtime environment. 数据库成为了大多数企业应用的主要瓶颈，也成为了运行环境中最不具伸缩性的层。... PHP/Ruby的用户会说什么都不共享（share nothing）的架构照样具有很好的伸缩性，.... 这些傻瓜真正想的是“除了数据库以外什么都不共享(Share nothing except for the database)”的架构。更多参看这里

所谓伸缩性，就是弹性，整个软件架构既支持小负载运行，也支持大负载支持，只要增加服务器即可； 由于软件系统负载已经从SQL转移到内存中的对象上，那么我们就可以通过增加这些应用服务器数量，通过分布式计算甚至云计算，达到业务对象在多台应用服务 器之间传递共享，而不必通过数据库这个环节，既减轻数据库负载，又能轻松扩充性能，不必走 集中试大型主机之路，只要添置低廉PC服务器即可。经过权威测试：websphere/weblogic的20台PC服务器集群性能不亚于一台SUN/IBM的中型机，性价比已经一目了然了。

JavaEE的服务器的集群相对于Linux等操作系统集群的好处在于：JavaEE集群能够针对某个繁忙负载大的具体业务功能进行集群，换句话说： 就是做到精确制导，精确解决问题，而显然，Linux操作系统的集群则无法直至业务核心的。

从另外一个方面看：虽然现在PHP号称走上对象路线，Ruby的铁轨开始铺进企业，但是他们的运行环境实则依赖数据库的， 特别是Ruby On Rails还是最适合Evans DDD对象建模路线，但是目前来讲还是"披着羊皮的狼"，批着DDD，实则是以数据库中心。当然相信 ROR等将来会提供分布式计算环境，但是JavaEE在2002年时就通过EJB以及分布式缓存成熟稳定地提供分布式计算的中间件，并且已经大量成熟应用。

本文结束以前，我相信大家明白，在众多语言平台竞争中，为什么Java能够击败过去拳王数据库，夺得新的拳王冠军，以及他的特点所在。有人可能会说：你忘记谈.NET了，这个不用我回答你，用微软中国董事长张亚勤的话回答：8年前.NET战略很天真， 你会将你的重要业务企业计算依赖一个很天真不成熟的技术吗？除非你自己也很天真:)。

  J2EE，Java2平台企业版（Java2PlatformEnterpriseEdition），是Sun公司为企业级应用推出的标准(Platform)。Java平台共分为三个主要版本JavaEE、JavaSE和JavaME。

  Sun公司在1998年发表1.2版本的时候，使用了新名称Java2Platform，即Java2平台，修改后的JDK称为 Java2PlatformSoftwareDevelpingKit，并分为标准版(StandardEdition，J2SE),企业版 (EnterpriseEdition，J2EE)，微型版(MicroEdition，J2ME)。J2EE便由此诞生。

  Java2平台包括标准版（J2SE）、企业版（J2EE）和微缩版（J2ME）三个版本。他们的范围是：J2SE包含于J2EE中，J2ME包含了J2SE的核心类，但新添加了一些专有类。

  随着Java技术的发展，J2EE平台得到了迅速的发展，成为Java语言中最活跃的体系之一。现如今，J2EE不仅仅是指一种标准平台，她更多的表达着一种软件架构和设计思想。

  2005年6月，JavaOne大会召开，SUN公司公开JavaSE6。此时，Java的各种版本已经更名以取消其中的数字2：J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为Java ME。

一、配置系统管理（Admin Web Application）

大多数商业化的J2EE服务器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。Tomcat按照自己的方式，同样提供一个成熟 的管理工具，并且丝毫不逊于那些商业化的竞争对手。Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。当然也可以管理像初始化参数，user、group、role的多种数据库管理等。在后续的版本中，这些功能将得 到很大的扩展，但现有的功能已经非常实用了。Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。（译者注：CATALINA_BASE即tomcat安装目录下的server目录）

你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。也就是说CATALINA_BASE/webapps /admin.xml的路径是绝对路径。作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。

如果你使用UserDatabaseRealm（默认），你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml文件中。你编辑这个文件，添加一个名叫“admin”的role 到该文件中，如下：

＜role name="admin"/＞

你同样需要有一个用户，并且这个用户的角色是“admin”。象存在的用户那样，添加一个用户（改变密码使其更加安全）：

＜user name="admin"

            

            

            

            password="deep_dark_secret"

            

            

            

            roles="admin"/＞

            

            

当你完成这些步骤后，请重新启动Tomcat，访问http://localhost:8080/admin，你将看到一个登录界面。Admin Web Application采用基于容器管理的安全机制，并采用了Jakarta Struts框架。一旦你作为“admin”角色的用户登录管理界面，你将能够使用这个管理界面配置Tomcat。

二、配置应用管理（Manager Web Application）

Manager Web Application让你通过一个比Admin Web Application更为简单的用户界面，执行一些简单的Web应用任务。Manager Web Application被被定义在一个自动部署文件中：

CATALINA_BASE/webapps/manager.xml

你必须编辑这个文件，以确保context的docBase参数是绝对路径，也就是说CATALINA_HOME/server/webapps/manager的绝对路径。（译者注：CATALINA_HOME即tomcat安装目录）

如果你使用的是UserDatabaseRealm，那么你需要添加一个角色和一个用户到CATALINA_BASE/conf/tomcat-users.xml文件中。接下来，编辑这个文件，添加一个名为“manager”的角色到该文件中：

＜role name=”manager”＞

你同样需要有一个角色为“manager”的用户。像已经存在的用户那样，添加一个新用户（改变密码使其更加安全）：

＜user name="manager"

            

            

            

            password="deep_dark_secret"

            

            

            

            roles="manager"/＞

            

            

然后重新启动Tomcat，访问http://localhost/manager/list，将看到一个很朴素的文本型管理界面，或者访问 http: //localhost/manager/html/list，将看到一个HMTL的管理界面。不管是哪种方式都说明你的Manager Web Application现在已经启动了。

Manager application让你可以在没有系统管理特权的基础上，安装新的Web应用，以用于测试。如果我们有一个新的web应用位于/home/user /hello下在，并且想把它安装到/hello下，为了测试这个应用，我们可以这么做，在第一个文件框中输入“/hello”（作为访问时的 path），在第二个文本框中输入“file:/home/user/hello”（作为Config URL）。

Manager application还允许你停止、重新启动、移除以及重新部署一个web应用。停止一个应用使其无法被访问，当有用户尝试访问这个被停止的应用时，将 看到一个503的错误??“503 - This application is not currently available”。

移除一个web应用，只是指从Tomcat的运行拷贝中删除了该应用，如果你重新启动Tomcat，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。

三、部署一个web应用

有两个办法可以在系统中部署web服务。

1.拷贝你的WAR文件或者你的web应用文件夹（包括该web的所有内容）到$CATALINA_BASE/webapps目录下。

2.为你的web服务建立一个只包括context内容的XML片断文件，并把该文件放到$CATALINA_BASE/webapps目录下。这个web应用本身可以存储在硬盘上的任何地方。

如果你有一个WAR文件，你若想部署它，则只需要把该文件简单的拷贝到CATALINA_BASE/webapps目录下即可，文件必须以 “.war” 作为扩展名。一旦Tomcat监听到这个文件，它将（缺省的）解开该文件包作为一个子目录，并以WAR文件的文件名作为子目录的名字。

接下来，Tomcat将在内存中建立一个context，就好象你在server.xml文件里建立一样。当然，其他必需的内容，将从server.xml中的DefaultContext获得。

部署web应用的另一种方式是写一个Context XML片断文件，然后把该文件拷贝到CATALINA_BASE/webapps目录下。一个Context片断并非一个完整的XML文件，而只是一个context元素，以及对该应用的相应描述。

这种片断文件就像是从server.xml中切取出来的context元素一样，所以这种片断被命名为“context片断”。

举个例子，如果我们想部署一个名叫MyWebApp.war的应用，该应用使用realm作为访问控制方式，我们可以使用下面这个片断：

＜!--

            

            

            

            Context fragment for deploying MyWebApp.war

            

            

            

            --＞

            

            

            

            ＜Context path="/demo"

            

            

            

            docBase="webapps/MyWebApp.war"

            

            

            

            debug="0" privileged="true"＞

            

            

            

            ＜Realm className=

            

            

            

            "org.apache.catalina.realm.UserDatabaseRealm”

            

            

            

            resourceName="UserDatabase"/＞

            

            

            

            ＜/Context＞

            

            

四、配置虚拟主机（Virtual Hosts）

关于server.xml中“Host”这个元素，只有在你设置虚拟主机的才需要修改。虚拟主机是一种在一个web服务器上服务多个域名的机制，对 每个域名而言，都好象独享了整个主机。实际上，大多数的小型商务网站都是采用虚拟主机实现的，这主要是因为虚拟主机能直接连接到Internet并提供相 应的带宽，以保障合理的访问响应速度，另外虚拟主机还能提供一个稳定的固定IP。

基于名字的虚拟主机可以被建立在任何web服务器上，建立的方法就是通过在域名服务器（DNS）上建立IP地址的别名，并且告诉web服务器把去往 不同域名的请求分发到相应的网页目录。因为这篇文章主要是讲Tomcat，我们不准备介绍在各种操作系统上设置DNS的方法，如果你在这方面需要帮助，请 参考《DNS and Bind》一书，作者是Paul Albitz and Cricket Liu (O'Reilly)。为了示范方便，我将使用一个静态的主机文件，因为这是测试别名最简单的方法。

在Tomcat中使用虚拟主机，你需要设置DNS或主机数据。为了测试，为本地IP设置一个IP别名就足够了，接下来，你需要在server.xml中添加几行内容，如下：

　＜Server port="8005"







shutdown="SHUTDOWN" debug="0"＞







＜Service name="Tomcat-Standalone"＞







＜Connector className=







"org.apache.coyote.tomcat4.CoyoteConnector"







port="8080"







minProcessors="5" maxProcessors="75"







enableLookups="true"







redirectPort="8443"/＞







＜Connector className=







"org.apache.coyote.tomcat4.CoyoteConnector"







port="8443" minProcessors="5"







maxProcessors="75"







acceptCount="10" debug="0"







scheme="https" secure="true"/＞







＜Factory className="org.apache.coyote.







tomcat4.CoyoteServerSocketFactory"







clientAuth="false" protocol="TLS" /＞







＜/Connector＞







＜Engine name="Standalone"







defaultHost="localhost" debug="0"＞







＜!-- This Host is the default Host --＞







＜Host name="localhost"







debug="0" appBase="webapps"







unpackWARs="true" autoDeploy="true"＞







＜Context path="" docBase="ROOT" debug="0"/＞







＜Context path="/orders"







docBase="/home/ian/orders" debug="0"







reloadable="true" crossContext="true"＞







＜/Context＞







＜/Host＞







＜!-- This Host is the first







"Virtual Host": http://www.example.com/ --＞







＜Host name="www.example.com"







appBase="/home/example/webapp"＞







＜Context path="" docBase="."/＞







＜/Host＞







＜/Engine＞







＜/Service＞







＜/Server＞

Tomcat的server.xml文件，在初始状态下，只包括一个虚拟主机，但是它容易被扩充到支持多个虚拟主机。在前面的例子中展示的是一个简 单的 server.xml版本，其中粗体部分就是用于添加一个虚拟主机。每一个Host元素必须包括一个或多个context元素，所包含的context元 素中必须有一个是默认的context，这个默认的context的显示路径应该为空（例如，path=””）。

五、配置基础验证（Basic Authentication）

容器管理验证方法控制着当用户访问受保护的web应用资源时，如何进行用户的身份鉴别。当一个web应用使用了Basic Authentication（BASIC参数在web.xml文件中auto-method元素中设置），而有用户访问受保护的web应用 时，Tomcat将通过HTTP Basic Authentication方式，弹出一个对话框，要求用户输入用户名和密码。在这种验证方法中，所有密码将被以64位的编码方式在网络上传输。

注意：使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。若没有额外的加密方法，网络管理员将能够截获（或滥用）用户的密码。

但是，如果你是刚开始使用 Tomcat，或者你想在你的web应用中测试一下基于容器的安全管理，Basic Authentication还是非常易于设置和使用的。只需要添加＜security-constraint＞和＜login-config＞两个元素 到你的web应用的web.xml文件中，并且在CATALINA_BASE/conf/tomcat-users.xml文件中添加适当的＜role＞ 和＜user＞即可，然后重新启动Tomcat。

下面例子中的web.xml摘自一个俱乐部会员网站系统，该系统中只有member目录被保护起来，并使用Basic Authentication进行身份验证。请注意，这种方式将有效的代替Apache web服务器中的.htaccess文件。

＜!--







Define the







Members-only area,







by defining







a "Security Constraint"







on this Application, and







mapping it to the







subdirectory (URL) that we want







to restrict.







--＞







＜security-constraint＞







＜web-resource-collection＞







＜web-resource-name＞







Entire Application







＜/web-resource-name＞







＜url-pattern＞/members/*＜/url-pattern＞







＜/web-resource-collection＞







＜auth-constraint＞







＜role-name＞member＜/role-name＞







＜/auth-constraint＞







＜/security-constraint＞







＜!-- Define the Login







Configuration for







this Application --＞







＜login-config＞







＜auth-method＞BASIC＜/auth-method＞







＜realm-name＞My Club







Members-only Area＜/realm-name＞







＜/login-config＞

六、配置单点登录（Single Sign-On）

一旦你设置了realm和验证的方法，你就需要进行实际的用户登录处理。一般说来，对用户而言登录系统是一件很麻烦的事情，你必须尽量减少用户登录验证的次数。作为缺省的情况，当用户第一次请求受保护的资源时，每一个web应用都会要求用户登录。

如果你运行了多个web应用，并且每个应用都需要进行单独的用户验证，那这看起来就有点像你在与你的用户搏斗。用户们不知道怎样才能把多个分离的应用整合成一个单独的系统，所有他们也就不知道他们需要访问多少个不同的应用，只是很迷惑，为什么总要不停的登录。

Tomcat 4的“single sign-on”特性允许用户在访问同一虚拟主机下所有web应用时，只需登录一次。为了使用这个功能，你只需要在Host上添加一个SingleSignOn Valve元素即可，如下所示：

＜Valve className=

            

            

            

            "org.apache.catalina.

            

            

            

            authenticator.SingleSignOn"

            

            

            

            debug="0"/＞

            

            

在Tomcat初始安装后，server.xml的注释里面包括SingleSignOn Valve配置的例子，你只需要去掉注释，即可使用。那么，任何用户只要登录过一个应用，则对于同一虚拟主机下的所有应用同样有效。使用single sign-on valve有一些重要的限制：

1.value必须被配置和嵌套在相同的Host元素里，并且所有需要进行单点验证的web应用（必须通过context元素定义）都位于该Host下。

2.包括共享用户信息的realm必须被设置在同一级Host中或者嵌套之外。

3.不能被context中的realm覆盖。

4.使用单点登录的web应用最好使用一个Tomcat的内置的验证方式（被定义在web.xml中的＜auth-method＞中），这比自定义的验证方式强，Tomcat内置的的验证方式包括basic、digest、form和client-cert。

5.如果你使用单点登录，还希望集成一个第三方的web应用到你的网站中来，并且这个新的web应用使用它自己的验证方式，而不使用容器管理安全，那你基本上就没招了。你的用户每次登录原来所有应用时需要登录一次，并且在请求新的第三方应用时还得再登录一次。

当然，如果你拥有这个第三方web应用的源码，而你又是一个程序员，你可以修改它，但那恐怕也不容易做。

6.单点登录需要使用cookies。

七、配置用户定制目录（Customized User Directores）

一些站点允许个别用户在服务器上发布网页。例如，一所大学的学院可能想给每一位学生一个公共区域，或者是一个ISP希望给一些web空间给他的客户，但这又不是虚拟主机。在这种情况下，一个典型的方法就是在用户名前面加一个特殊字符（~），作为每位用户的网站，比如：

http://www.cs.myuniversity.edu/~username

http://members.mybigisp.com/~username

Tomcat提供两种方法在主机上映射这些个人网站，主要使用一对特殊的Listener元素。Listener的className属性应该是 org.apache.catalina.startup.UserConfig，userClass属性应该是几个映射类之一。

如果你的系统是Unix，它将有一个标准的/etc/passwd文件，该文件中的帐号能够被运行中的Tomcat很容易的读取，该文件指定了用户的主目录，使用PasswdUserDatabase 映射类。

＜Listener className=

            

            

            

            "org.apache.catalina.startup.UserConfig"

            

            

            

            directoryName="public_html"

            

            

            

            userClass="org.apache.catalina.

            

            

            

            startup.PasswdUserDatabase"/＞

            

            

web文件需要放置在像/home/users/ian/public_html或者/users/jbrittain/public_html一样的目录下面。当然你也可以改变public_html 到其他任何子目录下。

实际上，这个用户目录根本不一定需要位于用户主目录下里面。如果你没有一个密码文件，但你又想把一个用户名映射到公共的像/home一样目录的子目录里面，则可以使用HomesUserDatabase类。

　＜Listener className=

            

            

            

            "org.apache.catalina.startup.UserConfig"

            

            

            

            directoryName="public_html"

            

            

            

            homeBase="/home"

            

            

            

            userClass="org.apache.catalina.

            

            

            

            startup.HomesUserDatabase"/＞

            

            

这样一来，web文件就可以位于像/home/ian/public_html或者/home/jasonb/public_html一样的目录下。这种形式对Windows而言更加有利，你可以使用一个像c:home这样的目录。

这些Listener元素，如果出现，则必须在Host元素里面，而不能在context元素里面，因为它们都用应用于Host本身。

八、在Tomcat中使用CGI脚本

Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。

CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scrīpting等，甚至包括Java。

当然，你大概不会把一个Java应用程序当作CGI来运行，毕竟这样太过原始。一般而言，开发Servlet总要比CGI具有更好的效率，因为当用户点击一个链接或一个按钮时，你不需要从操作系统层开始进行处理。

Tomcat包括一个可选的CGI Servlet，允许你运行遗留下来的CGI脚本。

为了使Tomcat能够运行CGI，你必须做如下几件事：

1.把servlets-cgi.renametojar （在CATALINA_HOME/server/lib/目录下）改名为servlets-cgi.jar。处理CGI的servlet应该位于Tomcat的CLASSPATH下。

2.在Tomcat的CATALINA_BASE/conf/web.xml 文件中，把关于＜servlet-name＞ CGI的那段的注释去掉（默认情况下，该段位于第241行）。

3.同样，在Tomcat的CATALINA_BASE/conf/web.xml文件中，把关于对CGI进行映射的那段的注释去掉（默认情况下，该段位于第299行）。注意，这段内容指定了HTML链接到CGI脚本的访问方式。

4.你可以把CGI脚本放置在WEB-INF/cgi 目录下（注意，WEB-INF是一个安全的地方，你可以把一些不想被用户看见或基于安全考虑不想暴露的文件放在此处），或者你也可以把CGI脚本放置在 context下的其他目录下，并为CGI Servlet调整cgiPathPrefix初始化参数。这就指定的CGI Servlet的实际位置，且不能与上一步指定的URL重名。

5.重新启动Tomcat，你的CGI就可以运行了。

在Tomcat中，CGI程序缺省放置在WEB-INF/cgi目录下，正如前面所提示的那样，WEB-INF目录受保护的，通过客户端的浏览器无法窥探到其中内容，所以对于放置含有密码或其他敏感信息的CGI脚本而言，这是一个非常好的地方。

为了兼容其他服务器，尽管你也可以把CGI脚本保存在传统的/cgi-bin目录，但要知道，在这些目录中的文件有可能被网上好奇的冲浪者看到。另外，在Unix中，请确定运行Tomcat的用户有执行CGI脚本的权限。

九、改变Tomcat中的JSP编译器（JSP Compiler）

在Tomcat 4.1（或更高版本，大概），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。

这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。

使用起来是容易的，因为你只需要在＜init-param＞ 元素中定义一个名字叫“compiler”，并且在value中有一个支持编译的编译器名字，示例如下：

＜servlet＞

            

            ＜servlet-name＞jsp＜/servlet-name＞

            

            ＜servlet-class＞

            

            org.apache.jasper.servlet.JspServlet

            

            ＜/servlet-class＞

            

            ＜init-param＞

            

            ＜param-name＞logVerbosityLevel＜/param-name＞

            

            ＜param-value＞WARNING＜/param-value＞

            

            ＜/init-param＞

            

            ＜init-param＞

            

            ＜param-name＞compiler＜/param-name＞

            

            ＜param-value＞jikes＜/param-value＞

            

            ＜/init-param＞

            

            ＜load-on-startup＞3＜/load-on-startup＞

            

            ＜/servlet＞

            

            

当然，给出的编译器必须已经安装在你的系统中，并且CLASSPATH可能需要设置，那处决于你选择的是何种编译器。

十、限制特定主机访问（Restricting Access to Specific Hosts）

有时，你可能想限制对Tomcat web应用的访问，比如，你希望只有你指定的主机或IP地址可以访问你的应用。这样一来，就只有那些指定的的客户端可以访问服务的内容了。为了实现这种效 果，Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。

通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。例如你可以把Admin Web application设置成只允许本地访问，设置如下：

＜Context path=

            

            

            

            "/path/to/secret_files" ...＞

            

            

            

            ＜Valve className="org.apache.

            

            

            

            catalina.valves.RemoteAddrValve"

            

            

            

            allow="127.0.0.1" deny=""/＞

            

            

            

            ＜/Context＞

            

            

如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机就会被允许，除此之外的都是拒绝的。

  web服务器可以解析(handles)http协 议。当web服务器接收到一个http请求(request)，会返回一个http响应 (response)，例如送回一个html页面。为了处理一个请求(request)，web服务器可以响应(response)一个静态页面或图片， 进行页面跳转(redirect)，或者把动态响应(dynamic response)的产生委托(delegate)给一些其它的程序例如cgi脚本，jsp(javaserver pages)脚本，servlets，asp(active server pages)脚本，服务器端(server-side)javascript，或者一些其它的服务器端(server-side)技术。无论它们(译者 注:脚本)的目的如何，这些服务器端(server-side)的程序通常产生一个html的响应(response)来让浏览器可以浏览。

  要知道，web服务器的代理模型(delegation model)非常简单。当一个请求(request)被送到web服务器里来时，它只单纯的把请求(request)传递给可以很好的处理请求 (request)的程序(译者注:服务器端脚本)。web服务器仅仅提供一个可以执行服务器端(server-side)程序和返回(程序所产生的)响 应(response)的环境，而不会超出职能范围。服务器端(server-side)程序通常具有事务处理(transaction processing)，数据库连接(database connectivity)和消息(messaging)等功能。

  虽然web服务器不支持事务处理或数据库连接池，但它可以配置(employ)各种策略(strategies)来实现容错性(fault tolerance)和可扩展性(scalability)，例如负载平衡(load balancing)，缓冲(caching)。集群特征(clustering—features)经常被误认为仅仅是应用程序服务器专有的特征。

应用程序服务器(the application server)

  根据我们的定义，作为应用程序服务器，它通过各种协议，可以包括http，把商业逻辑暴露给(expose)客户端应用程序。web服务器主要是处 理向浏览器发送html以供浏览，而应用程序服务器提供访问商业逻辑的途径以供客户端应用程序使用。应用程序使用此商业逻辑就象你调用对象的一个方法 (或过程语言中的一个函数)一样。

  应用程序服务器的客户端(包含有图形用户界面(gui)的)可能会运行在一台pc、一个web服务器或者甚至是其它的应用程序服务器上。在应用程序 服务器与其客户端之间来回穿梭(traveling)的信息不仅仅局限于简单的显示标记。相反，这种信息就是程序逻辑(program logic)。正是由于这种逻辑取得了(takes)数据和方法调用(calls)的形式而不是静态html，所以客户端才可以随心所欲的使用这种被暴露 的商业逻辑。

  在大多数情形下，应用程序服务器是通过组件(component)的应用程序接口(api)把商业逻辑暴露(expose)(给客户端应用程序) 的，例如基于j2ee(java 2 platform, enterprise edition)应用程序服务器的ejb(enterprise javabean)组件模型。此外，应用程序服务器可以管理自己的资源，例如看大门的工作(gate-keeping duties)包括安全(security)，事务处理(transaction processing)，资源池(resource pooling)，和消息(messaging)。就象web服务器一样，应用程序服务器配置了多种可扩展(scalability)和容错(fault tolerance)技术。

一个例子

  例如，设想一个在线商店(网站)提供实时定价(real-time pricing)和有效性(availability)信息。这个站点(site)很可能会提供一个表单(form)让你来选择产品。当你提交查询 (query)后，网站会进行查找(lookup)并把结果内嵌在html页面中返回。网站可以有很多种方式来实现这种功能。我要介绍一个不使用应用程序 服务器的情景和一个使用应用程序服务器的情景。观察一下这两中情景的不同会有助于你了解应用程序服务器的功能。

情景1:不带应用程序服务器的web服务器

  在此种情景下，一个web服务器独立提供在线商店的功能。web服务器获得你的请求(request)，然后发送给服务器端(server- side)可以处理请求(request)的程序。此程序从数据库或文本文件(flat file，译者注:flat file是指没有特殊格式的非二进制的文件，如properties和xml文件等)中查找定价信息。一旦找到，服务器端(server-side)程序 把结果信息表示成(formulate)html形式，最后web服务器把会它发送到你的web浏览器。

  简而言之，web服务器只是简单的通过响应(response)html页面来处理http请求(request)。

情景2:带应用程序服务器的web服务器

  情景2和情景1相同的是web服务器还是把响应(response)的产生委托(delegates)给脚本(译者注:服务器端(server -side)程序)。然而，你可以把查找定价的商业逻辑(business logic)放到应用程序服务器上。由于这种变化，此脚本只是简单的调用应用程序服务器的查找服务(lookup service)，而不是已经知道如何查找数据然后表示为(formulate)一个响应(response)。这时当该脚本程序产生html响应 (response)时就可以使用该服务的返回结果了。

  在此情景中，应用程序服务器提供(serves)了用于查询产品的定价信息的商业逻辑。(服务器的)这种功能(functionality)没有指 出有关显示和客户端如何使用此信息的细节，相反客户端和应用程序服务器只是来回传送数据。当有客户端调用应用程序服务器的查找服务(lookup service)时，此服务只是简单的查找并返回结果给客户端。

  通过从响应产生(response-generating)html的代码中分离出来，在应用程序之中该定价(查找)逻辑的可重用性更强了。其他的 客户端，例如收款机，也可以调用同样的服务(service)来作为一个店员给客户结帐。相反，在情景1中的定价查找服务是不可重用的因为信息内嵌在 html页中了。

  总而言之，在情景2的模型中，在web服务器通过回应html页面来处理http请求(request)，而应用程序服务器则是通过处理定价和有效性(availability)请求(request)来提供应用程序逻辑的。

警告(caveats)

  现在，xml web services已经使应用程序服务器和web服务器的界线混淆了。通过传送一个xml有效载荷(payload)给服务器，web服务器现在可以处理数据和响应(response)的能力与以前的应用程序服务器同样多了。

  另外，现在大多数应用程序服务器也包含了web服务器，这就意味着可以把web服务器当作是应用程序服务器的一个子集(subset)。虽然应用程 序服务器包含了web服务器的功能，但是开发者很少把应用程序服务器部署(deploy)成这种功能(capacity)(译者注:这种功能是指既有应用 程序服务器的功能又有web服务器的功能)。相反，如果需要，他们通常会把web服务器独立配置，和应用程序服务器一前一后。这种功能的分离有助于提高性 能(简单的web请求(request)就不会影响应用程序服务器了)，分开配置(专门的web服务器，集群(clustering)等等)，而且给最佳 产品的选取留有余地。

Red5如何响应rmpt的请求，中间涉及哪些关键类？

1.Red5在启动时会调用RTMPMinaTransport的start()方法，该方法会开启rmtp的socket监听端口（默认是1935），然后使用mina(apache的io操作类库)的api将RTMPMinaIoHandler绑定到该端口。

2.RTMPMinaIoHandler上定义了messageReceived、messageSent、sessionOpened和 sessionClosed等方法，当有socket请求时，相应的方法会被调用，这时RTMPMinaIoHandler会使用当前的socket连接 来创建一个RTMPMinaConnection（或者使用一个之前创建好的RTMPMinaConnection），并将其作为参数传递给定义于 RTMPHandler类上的相应的messageReceived、messageSent、connectionOpened和 connectionClosed方法。

3.RTMPHandler会调用Server类的lookupGlobal获得当前的GlobalScope，然后再利用GlobalScope 找到当前socket请求应该使用的WebScope（这个WebScope就是我们在自己的项目的WEB-INF"red5-web.xml中定义的 啦）。最后，RTMPHandler会调用RTMPMinaConnection的connect方法连接到相应的WebScope。

4.至此，控制流进入了我们自己项目中了，通常来说，WebScope又会将请求转移给ApplicationAdapter，由它来最终响应请求，而我们的项目通过重载ApplicationAdapter的方法来实现自己的逻辑。

Red5如何启动？在它的启动过程中如何初始化这些关键类？

这里探讨的是Red5 standalone的启动过程（也就是我们执行red5.bat），关于Red5如何在tomcat中启动，目前仍在研究中。

Red5启动过程如下：

1.编辑red5.bat，找到关键的一行：

可以看到它是调用org.red5.server.Standalone作为程序启动的入口，这也是为什么使用eclipse在debug模式下启动 Standalone就可以调试Red5代码。需要注意的是，如果你要调试Red5，记得除了源代码(src)之外，把conf和webapps两个文件 夹都拷入项目中，并把conf加入classpath。

2.观察Standalone的main方法，你会看到它使用spring的ContextSingletonBeanFactoryLocator来载 入classpath下面的red5.xml，注意ContextSingletonBeanFactoryLocator还会在下面的步骤中被使用，由 于它是singleton的，所以保证了我们自己的项目中定义的bean可以引用red5.xml中定义的bean，这个下面会有介绍。

try {
    ContextSingletonBeanFactoryLocator.getInstance(red5Config).useBeanFactory("red5.common");
} catch (Exception e) {
    // Don't raise wrapped exceptions as their stacktraces may confuse people
    raiseOriginalException(e);
}

3.查看red5.xml，这个文件首先定义了指向classpath:/red5-common.xml的名字为“red5.common”的 BeanFactory，注意它会是整个BeanFactory层次中的根节点，所以在red5-common.xml中定义的bean可以被其他地方所 引用。

这里我们主要留意red5-common.xml中定义的类型为org.red5.server.Server的“red5.server”，它会在接下来很多地方被用到。

4.回到red5.xml，接着定义指向classpath:/red5-core.xml的名字为“red5.core”的BeanFactory，注意“red5.core”是以“red5.common”为parent context。

查看red5-core.xml，这个文件主要定义了之前说过的RTMPMinaTransport，RMTPMinaIoHandler和 RTMPHandler这些类的Bean。对于RTMPMinaTransport，注意init-method="start"这段代码，这说明 RTMPMinaTransport的start方法会在该Bean初始化时调用，正如上面提到的，该方法会做开启1935端口，绑定 RTMPMinaIoHandler到该端口等等的操作。对于RTMPHandler，注意它的server属性通过“red5.server”引用了定 义在parent context（red5-common.xml）上面的Server，通过它RTMPHandler能够找到GlobalScope，进而找到 WebScope。

5.再次回到red5.xml，接下来定义类型为org.red5.server.ContextLoader的bean，并在初始化后调用它的init方法。

查看该方法的源代码，可以看到它会读取在classPath下面的red5.globals文件，对于每一行初始化一个以“red5.common”为 parent context的BeanFactory，具体来说，现在red5.globals中只有一行 default.context=${red5.root}/webapps/red5-default.xml，那么会创建一个名字为 “default.context”的指向webapps/red5-default.xml的Bean Factory，它以“red5.common”为parent context。

查看red5-default.xml，发现它主要是定义了GlobalScope的bean，然后把它注册到“red5.server”上。

6.继续看red5.xml，最后定义类型为org.red5.server.jetty.JettyLoader的bean，并且在初始化后调用它的init方法，查看该方法源代码，很明显它是初始化并且启动jetty这个web server。

7.到了这里似乎所有的初始化和启动都完毕了，但是问题就来了，这里仅仅定义了 RTMPMinaIoHandler，RTMPHandler，Server和GlobalScope，但是在我们之前提到过的Red5响应rmpt的请 求的过程中，还需要有WebScope来最终处理RTMPMinaConnection，这个WebScope又是怎么配置并且加进来的呢？

8.查看webapps下的项目，这里以oflaDemo为例，查看WEB-INF下面的web.xml，发现有以下三个参数 contextConfigLocation，locatorFactorySelector和parentContextKey，同时还有一个 org.springframework.web.context.ContextLoaderListener。

查看这个listener的javadoc，其实这个listener会在web app（就是我们自己的项目）启动时，创建一个指向contextConfigLocation（其实就是WEB-INF"red5-web.xml）的 Bean Factory，同时为它设置parent context。这个parent context实际上是使用locatorFactorySelector找到ContextSingletonBeanFactoryLocator， 进而使用parentContextKey找到定义在这个locator里面的Bean Fanctory，由于ContextSingletonBeanFactoryLocator是singleton的，所以这个 ContextSingletonBeanFactoryLocator对象跟我们在第2步中拿到的对象是一样的，而由于 parentContextKey被设置成“default.context”，这就意味着该parent context是第5步中定义的名为“default.context”的Bean Factory。基于以上的参数，我们得到这样一个Bean Factory的链条，由上至下分别是

这就使得red5-web.xml可以使用red5-common.xml和red5-default.xml中定义的bean。

9.最后查看webapps"oflaDemo"WEB-INF"red5-web.xml，它定义了类型为 org.red5.server.WebScope的bean，初始化了它的server（指向“red5.server”），parent（指向 “global.scope”）等属性，最后调用它的register方法初始化，查看该方法源代码，发现它会把自己注册到GlobalScope上面， 至此所有的关键类的初始化完毕。

Spring beanFactory 的层次图

看清了Red5 Standalone的启动过程，感觉为了实现自定义项目集成到Red5的核心服务上，Red5 Standalone非常依赖于spring的多个Bean Factory之间的复杂层次关系，之所以Red5能建立这样一种层次关系，是因为它能够控制jetty这样一个嵌入式的web server。问题在于，一旦Red5需要作为一个web app运行在类似Tomcat这样的独立的web server上面，那么整个过程就很不一样了，所以后很多东西都要改，我想这也是为什么Red5 0.8 RC1为什么只有安装版但还没有war版的原因。

最后，如果哪位成功在Tomcat上配置过Red5 0.7的war版本，还请告诉我一声，我试了0.6的war可以，不知道0.7为什么老不行。。。

后来，我们放弃了在页面上写逻辑 

    后来，程序写得越来越多，我们发现，这种在HTML代码中编写Java代码来完成逻辑的方式存在着不少问题：

    1. Java代码由于混杂在一个HTML环境中而显得混乱不堪，可读性非常差。一个JSP文件有时候会变成几十K，甚至上百K。要找一段逻辑，经常无法定位。

    2. 编写代码时非常困惑，不知道代码到底应该写在哪里，也不知道别人是不是已经曾经实现过类似的功能，到哪里去引用。

    3. 突然之间，某个需求发生了变化。于是，每个人蒙头开始全程替换，还要小心翼翼的，生怕把别人的逻辑改了。

    4. 逻辑处理程序需要自己来维护生命周期，对于类似数据库事务、日志等众多模块无法统一支持。

    在这个时候，如果有一个产品，它能够将页面上的那些Java代码抽取出来，让页面上尽量少出现Java代码，该有多好。于是许多人开始使用servlet来处理那些业务逻辑。

    Java代码：
 

    在这里，我们需要在web.xml中为这个servlet配置url的请求关系。

    Xml代码：