看了两天资料终于搞明白WAS DataSource v5 是怎么工作的了。总结一下，WAS DataSource v5与v4中对DataSource Connection 的管理区别所在。

I.先看看WAS里面是如何访问DataSouce的：

1. An application retrieves a DataSource object from the JNDI naming space.
2. After the DataSource object is obtained, the application code calls
getConnection() on the data source to get a Connection object. The
connection is obtained from a pool of connections.
3. Once the connection is acquired, the application sends SQL queries or
updates to the database.

WAS6 支持J2EE1.3，J2EE1.4 和 J2EE1.2。这两种类型的区别在于如何管理Connentions.

II.J2EE 1.3 and J2EE 1.4 DataSource Support(DataSource v5)

在v5 里，Connections Pooling 通过 JCA Connection Manager 和 Relation Resource Adapter实现。

The JCA Connection Manager provides connection pooling, local transaction,
and security support.
The relational resource adapter provides JDBC wrappers and the JCA CCI
implementation that allows BMP, JDBC applications, and CMP beans to access
the database.

在WAS里面，有个叫做Persistence Resouce Adapter的东西来控制DataSource的链接。

它提供了对EJB的relation persistence bean和对BMP，JDBC application的数据库访问。

Persistence Resouce Adapter由支持EJB CMP 模型的Persistence Manager 和 relational resource adapter  组成。

 Relational Resource Adapter 是 Persistence Manager 用来控制数据访问的工具，提供了 relational persistence services 给 EJB beans. Relational Resource Adapter的实现 基于J2EE Connector (JCA) 规范 并 实现了JCA CCI 和 SPI 的interfaces.

现在很明白了，在v5中，应用适用datasource 的时候，datasource 使用JCA来访问关系型数据库。

EJB的工作顺序如下：
1. An EJB performs a JNDI lookup of a data source connection factory and
issues a getConnection() request.
2. The connection factory delegates the request to a connection manager.
3. The connection manager looks for an instance of a connection pool in the
application server. If no connection pool is available, then the manager uses
the ManagedConnectionFactory to create a physical, or nonpooled,
connection.

III.J2EE 1.2 DataSource Support(DataSource v4)

区别在于，v4使用了自己的JDBC Connection Manager 来控制Connetion Pooling和JDBC 连接。 This support is included with WebSphere Application Server V6 to provide support for J2EE 1.2 applications. If an application chooses to use a Version 4 data source, the application will have the same connection behavior as in Version 4 of the application server。

Use the Version 4 data source for the following:

J2EE 1.2 applications
All EJB beans, JDBC applications, or Version 2.2 servlets must use the
Version 4 data source.

EJB 1.x modules with 1.1 deployment descriptor
All of these must use the Version 4 data source

IV.总结

在v5中，使用JCA和RA来管理Connections。

在v4中，适用JDBC Connection Manger来管理Connections.

具体的实现可以参阅：IBM Ｒed Book ->WebSphere Application Server V6 System Management & Configuration Handbook p345-p365.

//2-1

#include "../TestSuite/Test.h"
#include <vector>
using namespace std;
class VectorTest : public TestSuite::Test{
 vector<int> v_Int;
public:
 VectorTest(){

 }
 void run()
 {
  TestFuc();
 }
 void TestFuc(){
        v_Int.push_back(5);
  test_(v_Int.front()==5);
  test_(v_Int.back() == 5);
  test_(v_Int.at(0) == 5);
  v_Int.pop_back();
  test_(v_Int.size()==0);
  try{
   v_Int.at(1);
   fail_("invalited pos in vector \n");
  }
  catch (std::out_of_range) {

   succeed_();
  }
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 VectorTest obj_Test;
 obj_Test.run();
 obj_Test.report();
 getchar();
 return 0;
}

/////////////////////////////////////////////////////////
/////  VC2005                                               ////
////  Author:Tonyhuo                                    ////
////////////////////////////////////////////////////////
//1-2
#include <exception>
#include <iostream>
using namespace std;
class EXAMPLE{
public:
 class CharException{
 const char * str_Exception;
 public:
  CharException(const char * msg = 0):str_Exception(msg){}
  const char * What(){return str_Exception;}
 };
 void  f()
 {
  throw  CharException("MY Exception");
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 try{
        EXAMPLE obj;
  obj.f();
 }
 catch(EXAMPLE::CharException& e)
 {
  cout<<e.What()<<endl;
 }
 return 0;
}
///////////////////////////////////////////////////////////////////////////////////
1-4
#include <exception>
#include <iostream>
using namespace std;
int main()
{
 try{

 }
 catch(…)
 {
  cout<<"All exception caught!"<<endl;
 }
}
///////////////////////////////////////////////////////////////////////////////////////
1-9
//compile by g++
#include <exception>
#include <iostream>
#include <string>
using namespace std;
class MyException{};
class MyException2:public runtime_error{
public:
 MyException2(const string & msg =""):runtime_error(msg){}
};
void f(int i) throw(char,int,bool,MyException)
{  
 switch(i)
    {
    case 1: throw ‘a’;
    case 2: throw 32;
    case 3: throw true;
    case 4: throw MyException();
    case 5: throw MyException2();
    }
}
void my_unexpected()
{
 throw MyException2("test");;
}
void g() throw(MyException2){
    throw 3;
}
int main()
{
 for(int j =1;j<=4;j++)
  try { f(j);}
     catch(char)
  {
   cout<<"char exception caught"<<endl;
  }
  catch(int)
  {
   cout<<"int exception caught"<<endl;
  }    
  catch(bool)
  {
   cout<<"bool exception caught"<<endl;
  }    
  catch(MyException&)
  {
   cout<<"MyException exception caught"<<endl;
  }
    set_unexpected(my_unexpected);
 try{
  g();
 }
 catch (MyException2&)
 {
            cout <<"reback from g()"<<endl;
 }
 getchar();
 getchar();
}
///////////////////////////////////////////////////////////////////////////////////////////
1-11
#include <exception>
#include <iostream>
using namespace std;
class MotorError{};
class Motor{
public:
 Motor(){throw MotorError();}
};
class Car{
Motor obj_m;
public:
 Car():obj_m(){}
};
class Garage{
public:
 Car obj_c;
 Garage() try:obj_c(){

 }
 catch(MotorError&)
 {
  cout<<"Car::MotorError"<<endl;
  throw 1;
 }
};
int main()
{
 try
 {
  Garage obj;
 }
 catch(int)
 {
  cout<<"int exception caught"<<endl;
 }
 getchar();
}

1.最长公共子序列的结构

解最长公共子序列问题时最容易想到的算法是穷举搜索法，即对X的每一个子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列，并且在检查过程中选出最长的公共子序列。X的所有子序列都检查过后即可求出X和Y的最长公共子序列。X的一个子序列相应于下标序列{1, 2, …, m}的一个子序列，因此，X共有2^m个不同子序列，从而穷举搜索法需要指数时间。

事实上，最长公共子序列问题也有最优子结构性质，因为我们有如下定理：

定理: LCS的最优子结构性质

设序列X=<x₁, x₂, …, x_m>和Y=<y₁, y₂, …, y_n>的一个最长公共子序列Z=<z₁, z₂, …, z_k>，则：

1. 若x_m=y_n，则z_k=x_m=y_n且Z_k-1是X_m-1和Y_n-1的最长公共子序列；
2. 若x_m≠y_n且z_k≠x_{m ，}则Z是X_m-1和Y的最长公共子序列；
3. 若x_m≠y_n且z_k≠y_n ，则Z是X和Y_n-1的最长公共子序列。

其中X_m-1=<x₁, x₂, …, x_m-1>，Y_n-1=<y₁, y₂, …, y_n-1>，Z_k-1=<z₁, z₂, …, z_k-1>。

证明

1. 用反证法。若z_k≠x_m，则<z₁, z₂, …, z_k ,x_m >是X和Y的长度为k十1的公共子序列。这与Z是X和Y的一个最长公共子序列矛盾。因此，必有z_k=x_m=y_n。由此可知Z_k-1是X_m-1和Y_n-1的一个长度为k-1的公共子序列。若X_m-1和Y_n-1有一个长度大于k-1的公共子序列W，则将x_m加在其尾部将产生X和Y的一个长度大于k的公共子序列。此为矛盾。故Z_k-1是X_m-1和Y_n-1的一个最长公共子序列。
2. 由于z_k≠x_m，Z是X_m-1和Y的一个公共子序列。若X_m-1和Y有一个长度大于k的公共子序列W，则W也是X和Y的一个长度大于k的公共子序列。这与Z是X和Y的一个最长公共子序列矛盾。由此即知Z是X_m-1和Y的一个最长公共子序列。
3. 与 2.类似。

这个定理告诉我们，两个序列的最长公共子序列包含了这两个序列的前缀的最长公共子序列。因此，最长公共子序列问题具有最优子结构性质。

2.子问题的递归结构

由最长公共子序列问题的最优子结构性质可知，要找出X=<x₁, x₂, …, x_m>和Y=<y₁, y₂, …, y_n>的最长公共子序列，可按以下方式递归地进行：当x_m=y_n时，找出X_m-1和Y_n-1的最长公共子序列，然后在其尾部加上x_m(=y_n)即可得X和Y的一个最长公共子序列。当x_m≠y_n时，必须解两个子问题，即找出X_m-1和Y的一个最长公共子序列及X和Y_n-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

由此递归结构容易看到最长公共子序列问题具有子问题重叠性质。例如，在计算X和Y的最长公共子序列时，可能要计算出X和Y_n-1及X_m-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题，即计算X_m-1和Y_n-1的最长公共子序列。

与矩阵连乘积最优计算次序问题类似，我们来建立子问题的最优值的递归关系。用c[i,j]记录序列X_i和Y_j的最长公共子序列的长度。其中X_i=<x₁, x₂, …, x_i>，Y_j=<y₁, y₂, …, y_j>。当i=0或j=0时，空序列是X_i和Y_j的最长公共子序列，故c[i,j]=0。其他情况下，由定理可建立递归关系如下：

3.计算最优值

直接利用(2.2)式容易写出一个计算c[i,j]的递归算法，但其计算时间是随输入长度指数增长的。由于在所考虑的子问题空间中，总共只有θ(m*n)个不同的子问题，因此，用动态规划算法自底向上地计算最优值能提高算法的效率。

计算最长公共子序列长度的动态规划算法LCS_LENGTH(X,Y)以序列X=<x₁, x₂, …, x_m>和Y=<y₁, y₂, …, y_n>作为输入。输出两个数组c[0..m ,0..n]和b[1..m ,1..n]。其中c[i,j]存储X_i与Y_j的最长公共子序列的长度，b[i,j]记录指示c[i,j]的值是由哪一个子问题的解达到的，这在构造最长公共子序列时要用到。最后，X和Y的最长公共子序列的长度记录于c[m,n]中。

Procedure LCS_LENGTH(X,Y);begin  m:=length[X];  n:=length[Y];  for i:=1 to m do c[i,j]:=0;  for j:=1 to n do c[0,j]:=0;  for i:=1 to m do    for j:=1 to n do      if x[i]=y[j] then        begin          c[i,j]:=c[i-1,j-1]+1;          b[i,j]:="↖";        end      else if c[i-1,j]≥c[i,j-1] then        begin          c[i,j]:=c[i-1,j];          b[i,j]:="↑";        end      else        begin          c[i,j]:=c[i,j-1];          b[i,j]:="←"        end;  return(c,b);end;

由于每个数组单元的计算耗费Ο(1)时间，算法LCS_LENGTH耗时Ο(mn)。

4.构造最长公共子序列

由算法LCS_LENGTH计算得到的数组b可用于快速构造序列X=<x₁, x₂, …, x_m>和Y=<y₁, y₂, …, y_n>的最长公共子序列。首先从b[m,n]开始，沿着其中的箭头所指的方向在数组b中搜索。当b[i,j]中遇到"↖"时，表示X_i与Y_j的最长公共子序列是由X_i-1与Y_j-1的最长公共子序列在尾部加上x_i得到的子序列；当b[i,j]中遇到"↑"时，表示X_i与Y_j的最长公共子序列和X_i-1与Y_j的最长公共子序列相同；当b[i,j]中遇到"←"时，表示X_i与Y_j的最长公共子序列和X_i与Y_j-1的最长公共子序列相同。

下面的算法LCS(b,X,i,j)实现根据b的内容打印出X_i与Y_j的最长公共子序列。通过算法的调用LCS(b,X,length[X],length[Y])，便可打印出序列X和Y的最长公共子序列。

Procedure LCS(b,X,i,j);begin  if i=0 or j=0 then return;  if b[i,j]="↖" then    begin      LCS(b,X,i-1,j-1);      print(x[i]); {打印x[i]}    end  else if b[i,j]="↑" then LCS(b,X,i-1,j)
                      else LCS(b,X,i,j-1);end; 

在算法LCS中，每一次的递归调用使i或j减1，因此算法的计算时间为O(m+n)。

例如，设所给的两个序列为X=<A，B，C，B，D，A，B>和Y=<B，D，C，A，B，A>。由算法LCS_LENGTH和LCS计算出的结果如图2所示。

图2   算法LCS的计算结果

5.算法的改进

对于一个具体问题，按照一般的算法设计策略设计出的算法，往往在算法的时间和空间需求上还可以改进。这种改进，通常是利用具体问题的一些特殊性。

例如，在算法LCS_LENGTH和LCS中，可进一步将数组b省去。事实上，数组元素c[i,j]的值仅由c[i-1,j-1]，c[i-1,j]和c[i,j-1]三个值之一确定，而数组元素b[i,j]也只是用来指示c[i,j]究竟由哪个值确定。因此，在算法LCS中，我们可以不借助于数组b而借助于数组c本身临时判断c[i,j]的值是由c[i-1,j-1]，c[i-1,j]和c[i,j-1]中哪一个数值元素所确定，代价是Ο(1)时间。既然b对于算法LCS不是必要的，那么算法LCS_LENGTH便不必保存它。这一来，可节省θ(mn)的空间，而LCS_LENGTH和LCS所需要的时间分别仍然是Ο(mn)和Ο(m+n)。不过，由于数组c仍需要Ο(mn)的空间，因此这里所作的改进，只是在空间复杂性的常数因子上的改进。

另外，如果只需要计算最长公共子序列的长度，则算法的空间需求还可大大减少。事实上，在计算c[i,j]时，只用到数组c的第i行和第i-1行。因此，只要用2行的数组空间就可以计算出最长公共子序列的长度。更进一步的分析还可将空间需求减至min(m, n)。