单击“开始→运行”，在“打开”框中键入“MOUNTVOL /E”，然后单击“确定”按钮，重新启动电脑。

posted @ 2008-11-01 15:19 javaGrowing 阅读(514) | 评论 (0) | 编辑收藏

maven

Archetype	Command
JSF Basic	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-jsf -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Spring MVC Basic	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-spring -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Struts 2 Basic	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-struts -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Tapestry Basic	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-tapestry -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
JSF Modular	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-modular-jsf -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Spring MVC Modular	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-modular-spring -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Struts 2 Modular	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-modular-struts -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Tapestry Modular	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-modular-tapestry -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject
Core (backend only)	mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-core -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 -DgroupId=com.mycompany.app -DartifactId=myproject

You should be able to run AppFuse immediately if you have a MySQL 5.x database installed and it's accessible to root using no password. If you'd prefer to use an embedded database, we've recently added Database Profiles for H2, HSQLDB, etc.

MySQL Security
Running MySQL using root with no password is not the most secure thing to do. Once your database is created, you can change the root password using the command below:

mysql --user=root --pass='' mysql -e "update user set password=password('newpw') where user='root'; flush privileges;"

AppFuse uses the username "root" and a blank password by default. To change these values, modify the <jdbc.username> and <jdbc.password> properties in your project's pom.xml (at the bottom).

Run your application

Running AppFuse is easy now. Once the archetype project is created, Maven will create and populate your database using the hibernate3 and dbunit plugins, respectively. All you have to do is use Maven to run the Jetty container and view your application.

Check your new project into source control, unless you have a good reason not to. Google Code has free Subversion hosting, as do many others.
From the command line, cd into your new project's directory and run mvn to download JARs, Tomcat and run the integration tests in your project. Now is a good time to take a coffee break or grab a beer - downloading everything and running the tests can take 5-10 minutes.
To view your application run mvn jetty:run-war from your project's directory (for a modular project, you'll need to run mvn jetty:run-war from your project's web directory). Maven will start Jetty and you should be able to view your application in your browser at http://localhost:8080.
The default username/password for an admin user is admin/admin. For a regular user, use user/user.
To override files from AppFuse, run mvn war:inplace. This will extract the dependent WARs into src/main/webapp, where you can change files to your heart's content. When you have the war expanded in your source tree, you can run mvn jetty:run. This will allow you to change files on-the-fly and Jetty will reload them as needed. The only problem with this approach is you end up with an "exploded AppFuse" in your project, which won't bode well for upgrading. We recommend you check your project into source control before running mvn war:inplace. That way, it'll be easier for you to decide what needs to be checked in (over written) and what can be deleted.

If you receive OutOfMemory errors when using mvn jetty:run, see this mailing list thread.

You can change AppFuse from its "embedded mode" to full-source mode by running mvn appfuse:full-source from your project's root directory.

Bug with Ant 1.7.0
Local repositories and projects on Windows platforms are held in directories whose paths contain no spaces. To fix this issue, modify your $M2_HOME/conf/settings.xml and change your localRepository to something like the following:

<localRepository>c:\docume~1\username\.m2\repository</localRepository>

Development Environment
See development environment for detailed instructions on how to setup your computer to develop AppFuse-based applications.

Changing database settings
To change your MySQL database settings, simply change the <jdbc.*> properties at the bottom of your pom.xml. See Database Profiles to use a database other than MySQL

set MAVEN_OPTS=-Xmx512m -Xms512m -XX:MaxPermSize=512m

posted @ 2008-09-03 18:07 javaGrowing 阅读(471) | 评论 (0) | 编辑收藏

request.getParameter("变量名")获取的字符串中原来的加号变成了空格，url传值

今天我在调程序时，遇到了见郁闷的事，我用ajax从前台显示页面传字符串变量给处理页面，出现了件怪事，我想传的内容是abc+，但接收以后用System.out.println()输出是abc空格。反复测试好几遍，都是这个结果，真是令人郁闷。在网上搜了搜，找到了原因。
原因：   url中有些字符被转义，比如空格被编码成加号，于是传的参数明明是加号，获取的值却成了空格。如何解决呢？如果是通过url传递参数，应该对其进行必要的编码。
解决办法：
         在javascript中加入   function URLencode(sStr)
{
    return escape(sStr).replace(/\+/g, '%2B').replace(/\"/g,'%22').replace(/\'/g, '%27').replace(/\//g,'%2F');
}
对字符串进行处理.如：var str=URLencode("abc+")

posted @ 2007-12-19 09:02 javaGrowing 阅读(11295) | 评论 (5) | 编辑收藏

SAP 月末结帐步骤

The following processes including SD,MM,PP,FI,CO .

SD Relevant Steps:
1.Check if all delivery in due list have been processedVL06G (Could set background jobs to automatically generate the billing due list for posting)
2.Check if all picking in due list have been processedVL06P
3.Check if all goods issue in due list have been processedVL04
4.Check if all billed AR has been release to accountingVFX3

PP Relevant Steps:
1.Check if all back flash error has been solved (COGI Check every day this kind of problem and solved on time)
2.Check if all production orders that will not be followed have been finally confirmed or technically closed. Do final confirmation even small quantity variance exist but we consider this order has finished
3.Do technical close at month end for the orders will not be followed in the future
4.Confirmation. Do not confirm any assembly scrap when do production order conf.

MM Relevant Steps
1.Check if all goods movement has been booked in SAP
2.GR/IR clearing accounts maintenance if needed
3.Open the MM period for movement posting when new period starts MMPV

FI Relevant Steps
1.Book all accounting entries for:
- Accrued expense
- Do recurring entry (prepayment, accrued expense, amortization)
- Process G/L, vendor, customer balance & open items
- Cost allocations by FI
2.AM Fixed asset depreciation run and period postingAFAB
3.AM Periodic posting ASKB
4.G/L,AR,AP balance check & Open item clearing
5.Foreign currency revaluation for bank/cash & AR AP open items
Bank/cash revaluation: F.06
AR AP open items: F.05
6.GR/IR clearing account regrouping process F.19
7.Automatic clearing for G/L accounts, vendor and customer F.13

CO Relevant Steps
1.Release standard cost estimate
CK24Only when there are costing run to be released.
2.Cost reallocation according to activity
Distribution: CKV5
Assessment: KSU5
3.Cost splitting among activity KSS2
4.Actual activity price calculation KSII
5.Production order revaluation with actual activity price CON2
6.WIP calculationfor the production orders KKAO
7.Variance calculation for the production orders KKS1
8.Production / Costing orders settlement CO88/KO88
9.Material ledger closing > MMPV first
a.Create costing runCKRU00
b.Allow settlementCKMF_RUN
c.Allow closing entriesCKMG_RUN
d.Material selectionCKMB_RUN
e.Determine costing sequenceCKMC_RUN
f.Settle single levelCKMH_RUN
g.Settle multi levelCKMM_RUN
h.Post closingCKMI

posted @ 2007-12-18 16:03 javaGrowing 阅读(895) | 评论 (0) | 编辑收藏

javascript 的几种排序方法

所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：
　　输入：n个记录R₁，R₂，…，R_n，其相应的关键字分别为K₁，K₂，…，K_n。
　　输出：R_il，R_i2，…，R_in，使得K_i1≤K_i2≤…≤K_in。(或K_i1≥K_i2≥…≥K_in)。

这里，我们简单介绍几种排序方法，直接插入排序、希儿排序、冒泡排序、快速排序、直接选择排序，文中所提及的代码在IE6下测试通过。

直接插入排序基本思想
假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n]。从i=2起直至i=n为止，依次将R[i]插入当前的有序区R[1..i-1]中，生成含n个记录的有序区。

算法描述

希尔排序基本思想
　先取一个小于n的整数d₁作为第一个增量，把文件的全部记录分成d₁个组。所有距离为d_l的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d₂<d₁重复上述的分组和排序，直至所取的增量d_t=1(d_t<d_t-l<…<d₂<d₁)，即所有记录放在同一组中进行直接插入排序为止。
　该方法实质上是一种分组插入方法。

算法描述

冒泡排序基本思想
将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组 R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

算法描述

快速排序基本思想
将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos- 1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字 pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

算法描述

posted @ 2007-07-23 16:23 javaGrowing 阅读(491) | 评论 (0) | 编辑收藏

Dom +　Javascript 在本机浏览器中对的表格数据进行排序

在本机浏览器中对的表格数据进行排序
在Web应用中，数据从服务器端返回到客户端，以表格形式表现出来。如果要对数据集按指定的列排序显示，常规做法都是向服务器发出请求，服务器端程序重新从数据库中取出按指定列排序的数据，返回给客户端，页面重新显示排序后数据。

采用这种方式有如下缺点：
1- 响应时间延迟，每次排序都要向服务器端发送请求，等待结果返回，同时增加网络负载。
2- 编程复杂，可维护性差，而且客户端和服务器端代码耦合度很高，客户端和服务器端都要处理排序涉及的列名、排序方式，如果有分页和查询条件，都需要在客户端页面中保留，排序请求时重新传递到服务器端，当参数数量很多时极易出错。
3- 重用度很低，针对不同表格，很难抽象出一个公共程序来共用，需要逐个编写代码实现，增加工作量。

现在换一个角度考虑，数据既然已下载到了客户端，在重新排序时没有必要再重服务器端获取，只要对浏览器中的数据重新排序显示就可以了。要实现该目标，需要做到以下几点：
1 - 获得表格中要排序的数据，将其放入一个2维数组中。
2 - 对2维数组排序。
3 - 用排序后的数据重新更新表格。

利用浏览器支持的DOM(Document Object Model)和JavaScript即可实现上述目标。

通常页面中会很多的<table>，要获得需要排序数据所在的table，需要在<table>中增加一个id属性，便于document对象用getElementById得到该表格对象，例如要排序的表格定义如下：
<table id="st" >
    <tr>
        <td>1</td>
        <td>2</td>
    </tr>
</table>

在javascript中，用var objTable = document.getElementById("st")就可得到表格对象，该对象在DOM中定义为一个Element。

然后用 var objRows = objTable.getElementsByTagName("tr")得到该表格中全部的行对象，ObjRows.length返回该表格行数； var rowi = objRows[i].getElementsByTagName("td")得到第i行的全部<td>节点，i从0开始计数， rowi.item(j)则可得到第i行，第j列的节点，该节点的innerHTML为该节点<td></td>之间的内容。

获取表格数据到2维数组的代码见源代码，此处略。

下面说明在javascript中2维数组的构造和排序。
javascript不支持2维数组，因此需要用数组的数组来模拟一个2维数组，其方法是先定义一个1维数组，元素个数为2维数组的行数，然后对每个元素赋一个值，值为一个数组，其元素个数为2维数组的列数。构造代码如下：

var rows = new Array(R); //R为行数
for(var i = 0; i < rows.length; i++){
    rows[i] = new Array(C);    //C为列数
}

利用javascript中的Array.sort(comparer)对rows中的元素排序，比较方式由重新定义的比较函数得到。要根据第j列元素的大小排序，只要定义如下函数即可：

function compareCol(a,b){

    if (a[j] < b[j])
        return -1;

    if (a[j] > b[j])
        return 1;

   return 0;

}

因为compareCol只能有两个参数，因此j要定义为全局变量。

用rows.sort (compareCol)就可实现根据j列值的大小对行进行排序。根据javascript文档，字符串比较大小是按照其Unicode编码的大小来比较，对英文排序没有问题，对中文排序时就不是按通常的拼音排序，那需要javascript提供本地化支持，目前没有发现javascript此功能。该功能在java中可用java.text.Collator实现。

以上介绍了在本地对浏览器中的数据进行排序的主要思想，为方便使用，将这些功能进行了封装，以javascript函数的提供，存放在sorttable.js文件中，在需要的页面中用<script type=text/javascript src='sorttable.js'></script>引入。

下面说明排序函数原型和使用方法。

函数1 function sortTable(tableId,sortCol,compareType)
对页面中指定表格中的数据进行排序，通常第一行为标题行，排序时从第二行开始，第一次调用为升序排列，第二次为降序排列，依次轮换。
tableId    为<table id=''>中id的值，在同一个页面中要唯一。
sortCol    排序时用来比较大小的数据所在的列，从1开始计数。
compareType 排序时比较大小的方式，s-按字符串比较大小，n-按数字比较大小。

函数2 function sortTableInRange(tableId,sortCol,compareType,startRow,endRow,startCol,endCol)

        对表格中指定的区域数据排序，有时数据第一列为流水号，最后一行为合计，这些数据不需要参与排序，可用此函数来对部分数据排序。

        tableId    为<table id=''>中id的值，在同一个页面中要唯一。
        sortCol    排序时用来比较大小的数据所在的列，从1开始计数。
        compareType 排序时比较大小的方式，s-按字符串比较大小，n-按数字比较大小。
        startRow,endRow 要排序区域开始和结束行号，从1开始计数。例如对第2行到第7行排序，startRow=2，endRow=7
        startCol,endCol 要排序区域开始和结束列号，从1开始计数。

存在的问题：
1- 中文不能按拼音排序。

要注意的问题：
要排序的table必须用ID标示，并要作为参数传给排序函数，表格中的数据应该是可以排序的，否则结果不可预知；要排序的表格不能有嵌套表，否则排序出错。

本函数已在IE6.0 ,FireFox1.01中运行通过。源代码和例子代码见后。

参考资料：

Danny Goodman with Michael Morrison   JavaScript Bible 5th ,John Wiley and Sons 2004

David Flanagan JavaScript The Definitive Guide 4th , O'Reilly 2001

附源代码：要运行例子，需要将javascript代码保存到sorttable.js文件中，html部分代码保存到同一目录下另一文件中即可。

sorttable.js

1 //=========================================================
2  //
3  //  在本机对浏览器页面表格中的数据行进行排序的javascript函数
4  //
5  //  author William  QQ: 22967225
6 //  create date 2005-12-2
7  //  version 1.0
8  //=========================================================
9
10  //column index for sort
11  var indexCol;
12  //比较函数，用于Array.sort()排序时比较用。
13  //本函数比较数组元素array1[indexCol]和元素array2[indexCol]Unicode值的大小
14  function arrayCompare(array1,array2){
15   //alert(array1.length+"--"+array1[indexCol]);
16   if (array1[indexCol] < array2[indexCol])
17    return -1;
18   if (array1[indexCol] > array2[indexCol])
19    return 1;
20
21   return 0;
22
23  }
24  //比较数组元素array1[indexCol]和元素array2[indexCol]的数值大小
25  function arrayCompareNumber(array1,array2){
26
27   if (parseInt(array1[indexCol]) < parseInt(array2[indexCol]))
28    return -1;
29   if (parseInt(array1[indexCol]) > parseInt(array2[indexCol]))
30    return 1;
31
32   return 0;
33  }
34  //与arrayCompare相反方式比较大小，用于倒序使用
35  function arrayCompareRev(array1,array2){
36
37   if (array1[indexCol] < array2[indexCol])
38    return 1;
39   if (array1[indexCol] > array2[indexCol])
40    return -1;
41
42   return 0;
43
44  }
45  //与arrayCompareNumber相反方式比较大小，用于倒序使用
46  function arrayCompareNumberRev(array1,array2){
47   if (parseInt(array1[indexCol]) < parseInt(array2[indexCol]))
48    return 1;
49   if (parseInt(array1[indexCol]) > parseInt(array2[indexCol]))
50    return -1;
51
52   return 0;
53  }
54
55  //define a 2-dimension array
56  function BiArray(rows,cols){
57
58   //simulate multidimension array
59   this.rows = rows;
60   this.cols = cols;
61
62   //construct array
63   var lines = new Array(rows);
64   for(var i = 0;i < lines.length; i++){
65    lines[i] = new Array(cols);
66   }

posted @ 2007-07-23 16:20 javaGrowing 阅读(428) | 评论 (0) | 编辑收藏

解析responseBody

function toHtml(strBody,cset)
{
var Rec=new ActiveXObject("ADODB.RecordSet");
Rec.Fields.Append("DDD",201,1);
Rec.Open();
Rec.AddNew();

Rec(0).AppendChunk(strBody);

Rec.Update();
var HTML=Rec(0).Value;
Rec.Close();
delete Rec;
document.charset=cset;
return(HTML);
}

posted @ 2007-05-26 01:07 javaGrowing 阅读(993) | 评论 (0) | 编辑收藏

完美ajax类　支持事件

出处：http://www.smallrain.net/study_show.asp?id=703

<div id="Error"></div>
<div id="State"></div>
<div id="DownloadEnd"></div>
<Script Language="JavaScript">
<!--
// more javascript from http://www.smallrain.net

function Ajax(OnError,OnState,OnDownloadEnd)
{
// 错误字符串
this.ErrorStr   = null;
// 错误事件驱动,当发生错误时触发
this.OnError   = OnError;
// 状态事件驱动,当状态改变时触发
this.OnState   = OnState;
// 完成事件驱动,当类操作完成时触发
this.OnDownloadEnd = OnDownloadEnd;

// XMLHTTP 发送数据类型 GET 或 POST
this.method  = "GET";
// 将要获取的URL地址
this.URL  = null;
// 指定同步或异步读取方式(true 为异步,false 为同步)
this.sync  = true;
// 当method 为 POST 时所要发送的数据
this.PostData  = null
// 返回读取完成后的数据
this.RetData   = null;

// 创建XMLHTTP对像
this.HttpObj   = this.createXMLHttpRequest();
if(this.HttpObj == null)
{
  // 对像创建失败时中止运行
  return;
}

var Obj = this;
// 调用事件检测
this.HttpObj.onreadystatechange = function()
{
Ajax.handleStateChange(Obj);
}
}

// UTF 转入 GB (by:Rimifon)
Ajax.prototype.UTFTOGB = function(strBody)
{
var Rec=new ActiveXObject("ADODB.RecordSet");
Rec.Fields.Append("DDD",201,1);
Rec.Open();
Rec.AddNew();
Rec(0).AppendChunk(strBody);
Rec.Update();
var HTML=Rec(0).Value;
Rec.Close();
delete Rec;
return(HTML);
}

// 创建XMLHTTP对像
Ajax.prototype.createXMLHttpRequest = function()
{
if (window.XMLHttpRequest)
{
  //Mozilla 浏览器
  return new XMLHttpRequest();
}
else if (window.ActiveXObject)
{
        var msxmls = new Array('Msxml2.XMLHTTP.5.0','Msxml2.XMLHTTP.4.0','Msxml2.XMLHTTP.3.0','Msxml2.XMLHTTP','Microsoft.XMLHTTP');
        for (var i = 0; i < msxmls.length; i++)
        {
                try
                {
                        return new ActiveXObject(msxmls[i]);
                }catch (e){}

  }
}
this.ErrorStr = "你的浏览器不支持XMLHttpRequest对象．"
if(this.OnError)
{
  this.OnError(this.ErrorStr);
}
    return null;
}

// 发送HTTP请求
Ajax.prototype.send = function()
{

if (this.HttpObj !== null)
{
  this.URL = this.URL + "?t=" + new Date().getTime();
  this.HttpObj.open(this.method, this.URL, this.sync);
  if(this.method.toLocaleUpperCase() == "GET")
  {
   this.HttpObj.send(null);
  }
  else if(this.method.toLocaleUpperCase() == "POST")
  {
   this.HttpObj.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
   this.HttpObj.send(this.PostData);
  }
  else
  {
   this.ErrorStr = "错误的[method]命令．"
   if(this.OnError)
   {
    this.OnError(this.ErrorStr);
   }
   return;
  }

  if (this.HttpObj.readyState == 4)
  {
   // 判断对象状态
              if (this.HttpObj.status == 200)
                {
    this.RetData = this.UTFTOGB(this.HttpObj.responseBody);
    if(this.OnDownloadEnd)
    {
     this.OnDownloadEnd(this.RetData);
    }
                        return;
                }
   else
   {
    this.ErrorStr = "您所请求的页面有异常．"
    if(this.OnError)
    {
     this.OnError(this.ErrorStr);
    }
    return;
   }
  }

}

// 事件检测
Ajax.handleStateChange = function(Obj)
{
if(Obj.OnState)
{
Obj.OnState(Obj.HttpObj.readyState);
}

if (Obj.HttpObj.readyState == 4)
{
  // 判断对象状态
            if (Obj.HttpObj.status == 200)
                {
   Obj.RetData = Obj.UTFTOGB(Obj.HttpObj.responseBody);
   if(Obj.OnDownloadEnd)
   {
    Obj.OnDownloadEnd(Obj.RetData);
   }
                        return;
                }
  else
  {
   Obj.ErrorStr = "您所请求的页面有异常．"
   if(Obj.OnError)
   {
    Obj.OnError(Obj.ErrorStr);
   }
   return;
  }
}
}

// 错误回调事件函数
function EventError(strValue)
{
document.getElementById("Error").innerHTML = strValue;
}

// 状态回调事件函数
function EventState(strValue)
{
var strState = null;
switch (strValue)
{
     case 0:
  strState = "未初始化...";
  break;

     case 1:
  strState = "开始读取数据...";
  break;

     case 2:
  strState = "读取数据...";
  break;

     case 3:
  strState = "读取数据中...";
  break;

     case 4:
  strState = "读取完成...";
  break;

     default:
  strState = "未初始化...";
  break;
}
document.getElementById("State").innerHTML = strState;
}

// 完成回调事件函数
function EventDownloadEnd(strValue)
{
document.getElementById("DownloadEnd").innerHTML = strValue;
}

// 初始化Ajax对像,引入事件回调函数
var A1 = new Ajax(EventError,EventState,EventDownloadEnd);
// 指定method数据发送类型
A1.method = "GET";
// 指定URL地址
A1.URL = "http://www.smallrain.net/help.htm"
// 指定为异步处理
A1.sync = true;
//发送请求
A1.send();
//-->
</Script>

posted @ 2007-05-26 00:37 javaGrowing 阅读(643) | 评论 (0) | 编辑收藏

ajax代理程序自动判断字符编码

ajax代理程序自动判断字符编码

由于ajax在跨域的访问上有问题,目前最好的方法是做代理.写了个代理程序和心得.

为了做ajax的代理,研究了下服务器端的xmlhttp并和客户端的ajax中的xmlhttp做了个比较,后台代码是asp的.

服务器端的xmlhttp也就是asp小偷程序,我把代码改成了javascript.

1.在服务器端的xmlhttp.Open("GET",url,false)异步必须是关闭的,而客户端的异步是打开的,这个很好理解.
2.在服务器端的xmlhttp.Responsebody 这里用的是Responsebody而不是ResponseText或ResponseXml,一开始我是用ResponseText,但在函数bytesToBSTR转换编码的时候提示错误,经过比较发现其他的asp小偷程序里的代码都是Responsebody,分析后,发现body返回来的是二进制数据而不是像ResponseText或ResponseXml那样返回字符或dom对象.

ajax的asp代理函数介绍:
send_request(url) ,url为地址

服务器端代码如下带自动判断所有字符编码,已测试日语韩语繁体:

<%@LANGUAGE="JAVASCRIPT" CODEPAGE="65001"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>XMLHTTP</title>
</head>
<%

Server.ScriptTimeout=9999999;
function send_request(url) {
var codedtext;
http_request = Server.CreateObject("Microsoft.XMLHTTP");
http_request.Open("GET",url,false);
http_request.Send(null);
if (http_request.ReadyState == 4){
  //自动判断编码开始
  var charresult = http_request.ResponseText.match(/CharSet=(\S+)\">/i);
  if (charresult != null){
  var Cset = charresult[1];
  }else{Cset = "gb2312"}//对获取不到的网站采用gb2312编码,可自行更改

//自动判断编码结束
  codedtext = bytesToBSTR(http_request.Responsebody,Cset);
  }else{
  codedtext = "Erro";
  }
return(codedtext);
}

function bytesToBSTR(body,Cset){
var objstream;
objstream = Server.CreateObject("Adodb.Stream");
objstream.Type = 1;
objstream.Mode = 3;
objstream.Open();
objstream.Write(body);
objstream.Position = 0;
objstream.Type = 2;
objstream.Charset = Cset;
bytesToBSTR = objstream.Readtext;
objstream.Close;
return(bytesToBSTR);
}

%>
<body>
<% Response.Write(send_request("http://www.daum.net")) %>
</body>
</html>

posted @ 2007-05-26 00:31 javaGrowing 阅读(422) | 评论 (0) | 编辑收藏

JAVA之精髓IO流

一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1) input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(
new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();

//1b. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

//3. 从内存取出格式化输入
try{
DataInputStream in3 =
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e){
System.out.println("End of stream");
}

//4. 输出到文件
try{
BufferedReader in4 =
new BufferedReader(
new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}

//5. 数据的存储和恢复
try{
DataOutputStream out2 =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}

//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。

posted @ 2007-05-19 20:11 javaGrowing 阅读(325) | 评论 (0) | 编辑收藏

SD的重要的数据表

表说明

组织结构             T001  Company Code
		TVKO  Sales Organization
		TSPA  DIvision
		TVTW  Distribution Channel
		TVTA  Sales Area
		TVBUR Sales Office
		TVGRP Sales Person Group
		T001W Plant
		TVST  Shipping Point
		TVLA  Loading Point
		T014  Credit Control Area
客户               KNA1   General Data                  KNB1   Customer Master – Co.

posted @ 2007-05-17 09:30 javaGrowing 阅读(418) | 评论 (0) | 编辑收藏

sap的SD, FI,MM的业务集成

SD 和 MM 模块的业务集成：

1. 当你创建销售订单（SO），所有的项目将从MM模块拷贝物料主数据.

2. MRP和可用性检查也从MM模块读取相关数据.

3. While you create inbound/outbound delivery with reference to a sales order,the shipping point determination takes place with the help of the loading group, plant data, shipping conditions etc. This also refers to Material Master.

4. The material which you are entering in a sales order must be extended to the sales area of your sales order/customer otherwise you cannot transact with this material.

SD 和 FI模块的业务集成 :-

1. Whenever you create a delivery with reference to a sales order, goods movement takes place in the bacgground. eg. In case of standard sales order, you create an outbound goods delivery to the customer.
Here movement 601 takes place. This movement is configured in MM. Also, this movement hits some G/L account in FI. Every such movement of good s hits some G/L account.

2. The accounts posting in FI is done with reference to the billing documents (invoice, debit note, credit note etc) created in SD. Thus this is a link between SD and FI

3. Tax determination: In case of a tax determination also, there is a direct link between SD and MM

SD 与其他模块的集成点列表

销售订单 –
Integration Points                      Module
•Availability Check                -       MM
•Credit Check                        -       FI
•Costing                                 -       CO/ MM
•Tax Determination              -       FI
•Transfer of Requirements -       PP/ MM

发货和过账 –
Integration Points                      Module
•Availability Check                -       MM
•Credit Check                      -       FI
•Reduces stock                    -       MM
•Reduces Inventory $           -       FI/ CO
•Requirement Eliminated   -       PP/ MM

发票 -
Integration Points                      Module
•Debit A/R                              -       FI/ CO
•Credit Revenue                   -       FI/ CO
•Updates G/ L                       -       FI/ CO
(Tax, discounts, surcharges, etc.)
•Milestone Billing                 -       PS

退货 & Credit Memo -
Integration Points                      Module
•Increases Inventory              -       MM
•Updates G/ L                         -       FI
•Credit Memo                           -       FI
•Adjustment to A/R                 -       FI
•Reduces Revenue                -       FI

个人收集的业务重要函数

Function Name	Function Description	Function Pool	Function Pool Description	示例程序

SD_SALEDOCUMENT_CREATE
SD_ORDER_CREDIT_RELEASE	SD 信用管理	VKMP
RV_AVAILABILITY_CHECK	RV 可用量和需求	V03V
RV_REQUIREMENT_GENERATE	RV 可用量和需求	V03V
RV_DELIVERY_CREATE	SD 交货汇总处理	V50S

出库单－》财务凭证
WS_REVERSE_GOODS_ISSUE	Goods Mvmnts and Goods Mvments Reversals	V51W		RVV50L09
MB_CREATE_GOODS_MOVEMENT	为交货的发货	MBWL
MB_CANCEL_GOODS_MOVEMENT	为交货的发货	MBWL
订单 / 出库单－》发票
RV_INVOICE_CREATE	出具发票(新建)	V60A
RV_INVOICE_DOCUMENT_ADD	（保存）其中 SLL_DOCUMENT_TRANSFER单元的调用可作发票出口


发票－》财务凭证
RV_ACCOUNTING_DOCULIST_CREATE		V60B	RV-RF 接口
RV_ACCOUNTING_DOCUMENT_CREATE	发票－》凭证	V60B	RV-RF 接口	VF02 （过帐）
FI_PERIOD_CHECK	财务会计－》凭证－》过帐期间－》未清和关帐过帐期间（表t001b）	FACS	FI/CO 接口的 FI 服务	很多的检查函数
sd_invoice_release_to_account	释放发票－》凭证调用 RV_INVOICE_DOCUMENT_ADD	V60A	RV-RF 接口	VFX3
RV_INVOICE_LIST_DOCUMENT_ADD		V60A		VF02
RV_INVOICE_DOCUMENT_ADD	根据 RFBFK 决定是否调用（ 591 行） RV_ACCOUNTING_DOCUMENT_CREATE	V60A		VF02 （保存）


AC_DOCUMENT_CREATE		RWCL	会计合算接口
AC_DOCUMENT_REVERSE		RWCL	会计合算接口


RV_MISSING_DOCUMENT_DATA	确定不完整的销售凭证	VO5M		RVAUFERR




NUMBER_CHECK	检查号码是否在号码区间内		R/3 Central Basis Development: Number Ranges
BORDER-RIGHT: windowtext 1pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: medium none; PADDING-LEFT: 5.4pt; PADDING-BOTTOM: 0cm; BORDER-LEFT: windowtext 1pt solid; WIDTH: 182pt; PADDING-TOP

posted @ 2007-05-17 09:29 javaGrowing 阅读(2319) | 评论 (0) | 编辑收藏

credit memo和debit memo

总的说来，credit memo和debit memo是对企业向顾客已经交付的货物的价值进行调整的单据类
型。举个例，如果您已经就所交付的货物向买主开具了100元的发票，可是由于货物质量的瑕疵，
买主主张“货接受但必须削价10元”，如果您接受了这个主张，那您就得开具10元的credit memo
（即实际业务中的所谓“红字发票”）。总之，与原始invoice的价值相比，增价用debit memo，
降价用credit memo，两者都是billing document type。
credit memo request 和debit memo request都是sales document type，其原理与一般的销售订
单类型并无质的区别。只是，两个memo request的下游transaction都是直接参照订单创建
billing document，而不需要有delivery。
credit memo request --> credit memo, debit memo request --> debit memo，这就是它们的
流程。

posted @ 2007-05-17 09:22 javaGrowing 阅读(606) | 评论 (0) | 编辑收藏

ABAP-内表

1. 内表的类型及定义：

（ 1 ） .ANY TABLE ：即任意表类型，此种定义方式只能在传递参数的时候定义。

例如： FORM XXX USING/CHANGING TYPE ANY TABLE .

（ 2 ） .ANY TABLE 包括了两种类型： INDEX TABLE 和 HASHED TABLE 。

《 1 》 .INDEX TABLE ：包括了 STANDARD TABLE 和 SORTED TABLE

A. STANDARD TABLE ：其实就是一个线性表，通过 key 访问内表是线性查找的，也就是说，随着表中记录的增加，对表的操作的时间开销也相应的增加。

定义方法： TYPES/DATA ： LIKE/TYPE STANDARD TABLE OF .

B. SORTED TABLE: 顾名思义，表中的记录是按照一定的顺序排列的。访问表的主要方式是表中定义的 key ，如果 key 不唯一，则选择 index 最小的那个。也可以通过 index 来访问排序表，如果你想通过 index 插入一条记录，系统会自动检查你插入的位置是否正确。所以，如果插入的时间比插入到标准表的时间会长。因此，尽量选择 key 来对排序表进行操作。

定义方法： TYPES/DATA ： LIKE/TYPE SORTED TABLE OF .

《 2 》 .HASHED TABLE ：对哈希表只能用你定义的 key 进行操作，而不能使用 index 进行操作。因此，定义哈希表必须定义 unique key 。注意：所有关于使用 index 操作表的语句都不能用于操作哈希表。例如： sort ， loop 等。

定义方法： TYPES/DATA ： LIKE/TYPE HASHED TABLE OF .

2. 内表的操作：

（ 1 ） . 创建：

A. 定义一个结构，然后 type/like 这个结构

例如：

TYPES: BEGIN OF ,
         ...
         _{igt; ...,
         ...
       END OF .}

DATA TYPE STANDARD TABLE OF
                 WITH NON-UNIQUE DEFAULT KEY
                 INITIAL SIZE
                 WITH HEADER LINE.

B. type/like 系统表或者数据库表或者结构

DATA TYPE STANDARD TABLE OF < 系统表名 >
INITIAL SIZE
WITH HEADER LINE.

（ 2 ） . 添加数据：

A ． APPEND ：直接向表中添加数据

1. APPEND [wa TO|INITIAL LINE TO] itab[ASSIGNING |REFERENCE INTO dref].

2. APPEND LINES OF itab1 [FROM idx1] [TO idx2] TO itab2.

3. APPEND [wa TO] itab SORTED BY f [ASSIGNING

B ．向表中插入数据：

1. INSERT [wa INTO|INITIAL LINE INTO] itab [INDEX idx] [ASSIGNING |REFERENCE INTO dref].

2. INSERT [wa INTO|INITIAL LINE INTO] TABLE itab [ASSIGNING |REFERENCE INTO dref].

3. INSERT LINES OF itab1 [FROM idx1] [TO idx2] INTO itab2 [INDEX idx3].

4. INSERT LINES OF itab1 [FROM idx1] [TO idx2] INTO TABLE itab2.

C ．相同字段求和向表里添加：

Basic form

COLLECT [wa INTO] itab.

Extras:

1. ... ASSIGNING
2. ... REFERENCE INTO dref
3. ... SORTED BY f

（ 3 ） . 删除数据：

1. DELETE itab.
2. DELETE TABLE itab WITH TABLE KEY k1 = v1 ... kn = vn.
3. DELETE TABLE itab [FROM wa].
4. DELETE itab INDEX idx.
5. DELETE itab FROM idx1 TO idx2.
6. DELETE itab WHERE logexp.
7. DELETE ADJACENT DUPLICATES FROM itab.

（ 4 ） . 修改数据：

1. MODIFY itab [FROM wa] [INDEX idx] [ASSIGNING |REFERENCE INTO dref] [TRANSPORTING f1 ... fn].

2. MODIFY TABLE itab [FROM wa] [ASSIGNING |REFERENCE INTO dref] [TRANSPORTING f1 ... fn].

3. MODIFY itab [FROM wa] TRANSPORTING f1 ... fn WHERE cond.

posted @ 2007-04-30 09:22 javaGrowing 阅读(730) | 评论 (0) | 编辑收藏

ABAP-报表的事件

一，首先介绍一下 ABAP 的程序的类型：

Program type （程序类型）

Introductory statement （类型描述）

1

REPORT （报表）

M

PROGRAM （屏幕程序）

F

FUNCTION-POOL （函数组）

K

CLASS-POOL （类组）

J

CLASS-POOL （接口组）

T

TYPE-POOL （类型池）

二，下面介绍报表中用到的事件以及作用 :

1. LOAD-OF-PROGRAM ：程序开始执行时候自动调用

这个事件在 SUBMIT ， CALL TRANSACTION ， PERFORM 等执行的时候系统会自动调用这个事件。所以无需声明即可。

2. INITIALIZATION

（ 1 ） . 只能用于报表程序

（ 2 ） . 在选择屏幕出现之前执行，如果用逻辑数据库的话，这个是唯一能够修改选择屏幕初始值的地方。

（ 3 ） . 通常的用法是在这里给选择屏幕中的字段赋值。

3. AT SELECTION-SCREEN

（ 1 ） . 其实就像一个 FORM ，所以在这个事件里声明的变量都是局部变量。

（ 2 ） . 根据 SY-UCOMM 这个系统变量可以判断用户的命令

（ 3 ） . 在这个事件里响应的是屏幕上选择条件中的事件，例如 CHECKBOX 的选择与否， RADIOBUTTON 的选择， LISTBOX 的选择等等。所以分为以下几个方面：

1. ... ON psel ：在 PARAMETER 变化是触发的事件

2. ... ON END OF sel ： SELECT-OPTION 触发的事件

3. ... ON VALUE-REQUEST FOR psel_low_high ：选择的帮助 (F4)

4. ... ON HELP-REQUEST FOR psel_low_high ：选择的帮助 (F1)

5. ... ON RADIOBUTTON GROUP radi ：单选按钮事件

6. ... ON BLOCK block ：框架的触发事件

7. ... OUTPUT ：响应屏幕上的事件，修改选择屏幕的唯一方法

4. START-OF-SELECTION

报表程序必须执行的事件，在进入第二屏幕之前触发。

5. GET

获得逻辑数据库的值。前提是必须首先声明逻辑数据库。

6. END-OF-SELECTION

第二屏幕显示完毕，结束处理。

7. MODULE

这个是当你调用自己定义的屏幕时，响应屏幕事件的方法。

8. ENDMODULE

9. CHECK

只对逻辑数据库使用，检查是否取得数据。

10. REJECT

同样只对逻辑数据库使用，退出。

11. STOP

结束一个处理块。

12. RETURN

返回一个处理块。

三，附加说明：

1. SET PF-STATUS ：

基本语法格式： SET PF-STATUS pfstat.

扩展：

1. ... EXCLUDING f oder ... EXCLUDING itab

2. ... IMMEDIATELY

3. ... OF PROGRAM progname

这个是设置屏幕菜单，命令行等的命令，详细地信息我会在后面关于菜单设计的时候说明。

2. SET TITLEBAR ：

设置屏幕标题，在屏幕显示之前调用。

posted @ 2007-04-30 09:21 javaGrowing 阅读(1181) | 评论 (0) | 编辑收藏

提高ABAP编程技能的途径-学习分析SAP示例程序

（转贴，希望给和我一样在“黑暗”中摸索的ABAP初学者一点指引）

1、在SE38环境下的程序名输入栏输入'DEMO*'后按F4，你可以查到SAP所有的DEMO示例程序，好好看看，你会学到很多ABAP功能的实现方法。

2、运行“ABAPDOCU”T-cdoe，你可以看到ABAP DOCUMENT及示例程序。

3、想提高ALV的编程水平吗？

在SE38环境下的程序名输入栏输入'BCALV*'后按F4，你可以查到很多ALV示例程序，慢慢看吧。

posted @ 2007-04-30 09:07 javaGrowing 阅读(844) | 评论 (0) | 编辑收藏

AR Processing for FINI

AR Processing for FINI Paradise

1. Create Customer
2. Create Sales Organization view for Customer
3. Check material Master ( Finished goods) T-code: MM03
4. Create sales order T-code: VA01
5. Make delivery Note T-code: VL01N
6. Post Good issue T-code: VL02N
7. Check Material document and accounting document
8. Billing from SD T-code: VF01
9. Check Open item for the Customer T-code:FBL5N
10. Manual incoming payment T-code:F-28
11. Check Open Item again
12. Check Sales and COGS in DC-SOI reports T-code: KE30

posted @ 2007-04-30 08:59 javaGrowing 阅读(340) | 评论 (0) | 编辑收藏

SD定价的优先级

在 SBO 中销售订单的价格是按照此优先级进行定价的：业务伙伴的特殊价格 > 业务伙伴的折扣组 > 价格清单的层次展开 > 价格清单。
条件是：预先给业务伙伴设定价格清单 a ，里面有物料 a1 ，价格为 600 ， a1 物料属于 CPU 物料组。
1 、如果业务伙伴设定了特殊价格为 500 ，在做 a1 的销售订单时，则销售订单中的价格会采用 500 。
2 、如果没有为业务伙伴设定特殊价格，则系统会看是否有为业务伙伴设置折扣组，如果为此业务伙伴下面的 CPU 物料组设置了 10%, 则销售订单中的价格为 600× （ 1 － 10%)=540 。
3 、如果以上都没有为业务伙伴设置特殊价格及折扣组，则系统再会判断业务伙伴预先设定的价格清单有无做清单扩展，比如价格清单 a 中的物料 a1 在国庆期间打 8 折，则销售订单中的价格为 600×0.8=480 。
4 、如果以上都未设置，则系统会直接采用预先给业务伙伴设定的价格清单 a 中 a1 物料的价格 600 。

posted @ 2007-04-30 08:52 javaGrowing 阅读(507) | 评论 (0) | 编辑收藏

SAP 月末结帐步骤 SD 篇

SD Relevant Steps:
1.Check if all delivery in due list have been processedVL06G
(Could set background jobs to automatically generate the billing due list for posting)
2.Check if all picking in due list have been processedVL06P
3.Check if all goods issue in due list have been processedVL04
4.Check if all billed AR has been release to accountingVFX3

posted @ 2007-04-30 08:48 javaGrowing 阅读(448) | 评论 (0) | 编辑收藏

公司仓库管理需要那些流程?

成品进仓管理流程：

1、仓库根据已审核《采购订单》内容准备成品收货。

2、厂家送货到达后，厂家提供《送货清单》给收货仓管员，《送货清单》应清晰显示送货单位名称、送货单位印章或经手人签名、货品的名称、规格、数量、采购订单号。收货仓管员将《送货清单》和对应的《采购订单》相核对。相核不符者拒收。相符者仓管员以《送货清单》和《采购订单》验收货品，收货量大于定购量时，仓库主管要通过营销部同意和取得营销部有权人的书面通知后才能超量收货。

3、仓管员收货无误后，在《送货清单》上签收，并加盖收货专用章，一联自留，一联交对方。

4、仓管员在电脑上开具《采购单》，并由仓库主管审核生效。将《采购单》打印一式三联，经仓库主管和仓管员签字加盖收货专用章后，第一联存根自留，第二联财务联连同送货单位的《送货清单》交财务，第三联对方联同时交财务。

5、返修品回仓，以对应的《采购退货单》为依据收货，仓管员核实货单无误后在电脑上开具《采购退返单》，注明原《采购退货单》号，并经仓库主管审核生效。

成品出仓管理流程：

1、仓库主管根据营销部传来的《销售订单》备货并作好记载，将配好之货品清单交质检部验货。质检部将合格成品装箱并在电脑上填制《装箱单》，审核装箱单。在每个包装箱内放置一张装箱单。包装好的成品分类放到相应的仓库存放区域。

2、质检部将《装箱单》汇总导出为未审核《销售单》，等待营销部总监审核发货。

3、仓管员根据客户持有的已盖章《销售单》和电脑里对应的《出仓单》（对于批发商）或《转仓单》（对于加盟商）发货。打印《出仓单》或《转仓单》一式二份，由仓管员、仓库主管和客户签字，一份交客户，一份仓库自留。

4、营销部业务流程：

1、营销部将客户传真来的《销售订单》输入电脑，并由营销部总监审核。查询当前仓库库存情况。若需要向厂家订货的，将《销售订单》导出为《采购订单》并审核。若仓库有货不需要向厂家订货，就将《销售订单》传给仓库，由仓库捡货装箱。

2、收到仓库传来的未审核《销售单》后（由《装箱单》汇总而成），由营销部总监确认客户货款余额的状况。若客户有足够的货款余额，则审核此《销售单》（已审核《销售单》会自动生成《出仓单》（对于批发客户）或《转仓单》（对于加盟商）传给仓库，仓库凭此《出仓单》或《转仓单》发货。）。若客户货款余额不足，则等待客户货款到帐后再审核《销售单》。

3、已审核《销售单》打印一式三联，并签名盖章。第一联存根自留，第二联财务联交财务，第三联对方联交客户。

4、营销部分析加盟商及其专卖店的库存状况，并向加盟商提出补货、调拨等建议。

5、分析分公司和自营专卖店的库存和销售情况，若需要补货，则开具《转仓单》，将总公司仓库的货品调拨到分公司和专卖店。若需要在分公司或专卖店之间调拨货品，开具《调拨单》。营销部总监审核《调拨单》。经审核后的《调拨单》自动生成一张《进仓单》和一张《出仓单》并传给相关仓库。由相关仓库收货、发货。

6、营销部审核分公司和专卖店传回的销售单，冲减相应的库存和增加应收款。

7、营销部审核加盟商传回的销售《出仓单》，冲减加盟商库存。

8、营销部审核分公司和加盟商传回的《转仓单》，调整分公司和加盟商的仓库库存。

9、营销部审核分公司和加盟商传回的《盘点单》，调整分公司和加盟商的仓库库存。

10、营销部将货品资料传给各个分公司和加盟商。

仓库盘点流程：

1、盘点准备仓库主管将还未有自编码的存货通知支援中心补编编码，并通知有关部门填制相关单据处理帐外物资。营销部、鞋业部和服装部通知厂家和客户在盘点日期间停止送收货品。财务部将盘点日前已经审核生效的单据记帐。仓库主管组织仓库人员对货品进行分区摆放，存货以成品区、辅料区、成品待检区、次品区、台面辅料区、样板鞋区分成六大区域分别得出存货实存情况。

2、盘点进行仓库主管组织仓库人员初盘存货，对存货六大区域各指派1人担任组长，2人配合。以盘点表记录初盘结果。仓库主管连同另外4名员工组成复盘小组，对初盘结果进行复盘，出现差异仓库自查原因。仓库主管将初盘数据输入电脑，将《盘点单》打印提供给财务部，财务部组织公司人员组成抽盘小组，以2人为1组对各大区域进行抽盘工作。抽盘人员从实物中抽取20%复核初盘资料，从初盘资料中抽取30%对实物进行抽盘。抽盘量要求占总库存的50%。发现差异由仓库主管重新盘点更正初盘资料。差错率高于1%，仓库主管对该区域货品进行重新全盘。经复盘通过的《盘点单》由财务部审核，并打印一式二份，由仓库主管、财务主管签字，各持1份。

3、盘点后期工作仓库主管将已审核《盘点单》导出为进、出仓单，电脑自动生成《盘盈单》和《盘亏单》。仓库主管查找盘盈盘亏的原因，并将《库存盘点汇总表》和差异原因查找报告交财务主管复核上交总经理审批后。财务部据审批结果审核《盘盈单》和《盘亏单》调整库存帐。

4、盘点其他规定盘点工作规定每月进行一次，时间为月末最后2天。头天晚上8时开始至次日中午完成初盘和复盘工作，下午进行抽盘工作。参加盘点工作的人员必须认真负责，货品磅码、单位必须规范统一；名称、货号、规格必须明确；数量一定是实物数量，真实准确；绝对不允许重盘和漏盘。由于人为过失造成盘点数据不真实，责任人要负过失责任。对于盘点结果发现属于实物责任人不按货品要求收发及保管财物造成损失，实物责任人要承担经济赔偿责任。

posted @ 2007-04-29 14:15 javaGrowing 阅读(1949) | 评论 (0) | 编辑收藏

SAP R/3 财务基本概念及集成性浅释---集成性及存在的问题

作者：张小虎

< 一 > 、 GR/IR （分为购销与代销） 在 SAP 里，当货到票未到或票到货未到也得到了及时的处理。在传统的会计核算中，当企业购入存货时，若未能及时收至货物的发票，此时是不做任何帐务处理的，若至月末仍未能收到，会采用一种估价入帐的方法进行会计处理，而后月初红字冲回。但在 SAP 里，若继续采用这种核算方法，将会使 SAP 所倡导的信息即时性反映得不到实现。因此，在 SAP 的帐务体系里出现了一个新的科目： GR/IR ，英文全称为 GOODSRECEIPTSORINVOICERECEIPTS ，中文译为货到票未到或票到货未到。如当仓库进货时，即使未收到发票， SAP 能自动产生借：存货，贷： GR/IR （ GOODSRECEIPTSORINVOICERECEIPTS ） , 此时是以采购单上的采购价（不含税④）作为入帐金额。发票到时，通过发票校验程序，系统会自动产生借： GR/IR 贷：供应商。此时的供应商是根据采购单上标明供应商自动过入。若发生发票上金额与采购单的金额不一致的情况，系统会根据该笔采购当时的库存情况自动分配该差额的去向，如转入存货成本或销售成本或在二者之间分配。至月末，若仍有未到的发票，由于在报表层次是不能反映 GR/IR 的，因此系统会有一个程序将未结清的 GR/IR 转入应付帐款 — 票到货未到或应付帐款 — 货到票未到反映（该二科目非统驭科目，但前四位编码与正常的统驭科目一致），至第二个月初，系统会自动将未结清的 GR/IR 冲回，等待结清。对于代销商品的 GR/IR ，系统会在报表将其与存货项目一并反映。购销的 GR/IR 与代销的 GR/IR 区别是通过商品的主数据中设置得以实现的。当创建一个商品主数据时，必须设置该商品是属于购销或代销商品，若是购销商品，则当该商品入库时，系统会产生借：存货贷：（购销） GR/IR ；若是代销商品，则当该商品入库时，系统会产生借：存货贷：（代销） GR/IR ；当然代销的 GR/IR 必须等到产生销售清单时，才能在收到供应商发票时转入应付某供应商的明细帐内。
< 二 > 、重要的几类凭证的产生

1 、 MM （ materialmanagement, 物料管理模块）、 SD(salesanddistribution ，销售与分销模块 ) 模块产生这里指的集成，是指与 MM 模块及 SD 模块有关的帐务集成。

A 、与 MM 模块有关的帐务集成：第一步：当 MM 模块收到货物时借：存货（或受托代销商品）贷： GR/IR （或代销商品款）（该分录是系统自动产生的，无须手工）入帐金额为采购单是采购单上所列金额，采购单上金额则来自于商品主数据中维护的金额，若采购前已知某商品价格上涨（或下降），则需在该主数据内预先维护，以便采购单引用（在采购单上也可直接更改采购价）。第二步：收到供应商送来的发票时，有一个发票校验（ invoiceverification ）动作 , 该动作可由 MM 模块的人员进行，也可由财务组的人员进行，但考虑到内部控制的要求，多数公司安排由财务部门执行。借： GR/IR （或代销 GR/IR ）应交税金 — 增值税 - 进项税贷：供应商（为一个系统自动产生的号码）（该分录由手工输入）注：若为代销的 GR/IR ，应为代销商品清单已产生，供应商按供销商品清单所列物品开出的发票。供应商开来的发票可能会出现比采购单金额小或大于 1 元内的情况，系统会自动将差额过入至营业费用 — 四舍五入差异。若开来的发票金额比采购单金额大于一元以上的情况时，可能是商品主数据中维护的金额不及时所致，此时可手工更改采购单金额，系统过入后，会自动将发票校验凭证锁死，相应产生的应付帐款 --- 供应商的该笔交易也被锁死，只有在有权限人批准后，才能支付。过入的大于采购单的差额会由系统自动在存货成本与销售成本之间分配。若发票金额小于 1 元以上，则仍需手工更改采购采购订单使金额与发票金额一致，这样系统就会将差额自动在存货成本与销售成本之间进行分配，但些时系统不会有锁死该笔交易（因为已不必要）。当存在退货给供应商的情况时，系统仍要求按上述顺序做相反的动作，此后结清 GR/IR 的发票校验用的供应商发票就是红字发票了（系统称之为货方凭证）。

B 、与 SD （销售）模块有关的帐务第一步，当 MM 模块对外发货时，填好外向发货单，发货过帐后，则借：商品销售成本（购销或代销）贷：存货（受托代销商品）（此为系统自动产生的分录！）第二步，当向顾客开出销售清单时（即 BILLING ），此非通常所说的开正式税务发票！借：顾客（为系统产生的 10 位数号码，会自动过入至应收帐款的统驭科目，原理前述）贷：商品销售收入应交税金 — 增值税 - 销项税（此为系统自动产生的分录！）若货物售出后，顾客退货，则需做一个上述的反向动作！收到顾客退货时，称为反向发货。开出的销售清单为红字（称为贷方凭证）。系统同样会产生上述相反的分录。

< 三 > 、 SAP 零售模块存在的问题

1 、代销的结算对于代销的业务， SAP 是按照 GAAP （ generallyacceptedaccountingprinciple ）来进行设计的，相关原文如下： becausetitletothemerchandiseisheldbyconsignorbutphysicalpossessionisheldbytheconsignee……..theconsigneedoesnotmakeanentryforreceiptoftheinventoryinthegeneralledger;however,memorandumcontrolrecordsusuallyarekept. ②。即，对于代销商品，受托人是不进行会计处理的，只在备查帐进行记录，以便于数量的控制。 SAP 的零售系统完全是按照此思路进行设计的。但中国的企业会计制度对于受托代销商品的核算且全然不是如此（具体参见《企业会计制度》说明）。因此，两者的差异较大，完全不适合中国的企业会计制度核算的要求，同时在税务上也存在一定的问题。为此，必须对代销的有核算尤其是结算应进行客户化的开发。一般在对于代销商品的核算进行设置时，在商品主数据中的评估组中设计了两个评估码，即前述的 3100 （购销）与 3400 （代销）。代码的不同，只是确定了不同的会计科目如库存商品、受托代销商品、 GR/IR 及代销 GR/IR ，但在与供应商的结算上，二者却是大不相同的。购销的结算是供应商直接与经销商的交易额进行结算，而代销的结算则是根据代销商的商品代销清单来进行的，这样系统中的每一张采购单都不可能是立即结清的，而且对于数量众多的代销商品，系统如何选择未结清的采购单及单价，这些都是客户化开发中应当考虑及困难之处。

2 、退货单价的确定（退还供应商）这问题与上述相关，即对于代销商品退回给供应商时，系统应选用什么单价。如某些公司的蓝图设计，为所有未结清采购订单中的最早价。这是考虑到近年来，商品的采购价都呈下降之趋势。但系统客户化开发的过程中显示，对于最早价的选择，需用手工的方式进行。这样，当交易量大时，会降低作业效率，同时，手工操作难以确保有些标准是否会得到一致的执行。

3 、分录借贷顺序在 SAP 系统中，对于会计分录的顺序，不是完全按照借贷的顺序来显示，有时可能是贷借，虽然不会影响到整个分录的准确性，但似乎不符合会计核算的要求。希望将来的版本在这方面能有所改进。

4 、收入的提早确认从前述，我们可以看到，当存货发出时，系统就自动产生借：销售成本贷：存货。在做 BILLING 动作时，才产生借：客户贷：销售收入贷：应交税金。这种作法表明， SAP 对于收入的确认是以发货为时点的，意味着发货就一定代表客户对货物的接受。虽然在现实交易中 ( 零售业 ) 确实有 90% 的可能在发货时就代表客户对该货物的接受。但更符合会计收入确认的作法是，应设置诸如 “ 发出商品 ” 的科目用于核算当对发出货物的客户接受性没有把握时的情景，待客户接受后，再将 “ 发出商品 ” 转为销售成本。另外， BILLING 的动作在后也有可能为用户有意迟延确认收入留下空间。

5 、特殊期间较难与资产负债表日后事项协调在前述中说及，在 SAP 中会计期间可划为 16 个，即有 4 个特殊的会计期间用于对已结帐的总帐进行调整，基本上资产负债表日后事项的情况都能在 4 个特殊的会计期间处理，但对于退货的会计处理较难与会计准则要求的相吻合。因为，对于商品每到月末都要有一个关帐动作，即表明关帐后就不能对已关帐的前两个期间的存货业务进行调整。会计准则要求，对于上年度销售，会计报表发出之前发生的退货，应以 “ 以前年度损益调整 ” 作为过渡科目，然后再将 “ 以前年度损益调整 ” 结转至 “ 未分配利润 ” ，再对当年度的资产负债表的年初数重新计算调整，并在会计报表附注中说明③。但由于 SAP 的商品月度间关帐已不可能将退货在以前月份调整，同时，退货时，当收至客户的退货， MM 模块有个反向发货动作将产生，借：存货贷：销售成本（入帐价值为退货时的商品移动平均价），而不是贷：以前年度损益调整，对顾客开出红字发票时，借：销售收入应交税金 — 增值税贷：客户（以当时的销售价），而不是借：以前年度损益调整。因此，在这一点， SAP 较难与会计准则的有关要求相一致。

6 、利用利润中心产生负债表
SAP 的成本中心与利润中心使财务会计与管理会计得以有机结合！在每一个独立核算的会计主体中，每一个职能部门都是一个成本中心，如 5 个职能部门，则可以将其分为 5 个成本中心或 2 个成本中心，这可按管理部门的管理需求进行确定，但只可能有一个利润中心，即这个独立核算的会计主体。在 SAP 中，成本中心与利润中心是事先必须设定的。即，当我们在输入一个与费用有关的总帐分录时，如借：管理费用 --- 工资贷：现金时， SAP 就要求必须再对费用的所属部门进行再输入，如必须输入一个成本中心；对现金则必须输入一个利润中心。这是因为，当输入一个成本中心后，所有与该成本中心有关的金额都会得以汇集，然后这个成本中心会被分配至一个利润中心（成本中心的主数据中设定），从而能从利润中心自动地产生管理用的某个独立核算会计主体的损益表。上述现金也被要求输入一个利润中心，是为了能产生一个与独立核算主体的资产负债表。当一个独立法人有二个以上的独立会计核算主体时，此功能就变得非常之好用！即该二个独立核算的会计主体不须再进行独立的会计核算了，只须分配好各自的成本中心与利润中心即可！在 SAP 中，独立会计核算的损益表是容易产生的，但要产生一个具有平衡关系的资产负债表较有一个难度！上述所说的要做到如现金，这可自动产生，但与总部之间的往来，就要通过月末手的方式输入部份分录以产生资产负债表。假设某法人有二个独立核算的门店，在传统的会计体系中，该法人的资产负债表上应有 “ 拨付所属资金 ” 的科目用以核算对两个门店之间的资金拨付关系，门店的资产负债表上应有 “ 上级拨入资金 ” 的科目与法人资负表相对应，当每月发生往来时，可通过该二科目进行核算或再加一个内部往来科目进行核算。月末时，法人报表应汇总再抵消 “ 拨付所属资金 ” 与 “ 上级拨入资金 ” 及相关的内部往来科目。但在 SAP 中，此时已不用如上所述进行核算了！如将某门店的装修费拨付门店时，原来的做法是：借：拨付所属资金贷：长期待摊费用，而 SAP 直接在长期待摊费用下输入一个利润中心即能产生相应的某门店的会计报表。当然，对于一些往来及月末（或年末）实现的利润，则必须通过手工输入调整的分录以使门店产生资产负债表。但这样做法也有一个缺点：由于减少了传统会计的抵消内部往来的做法，当总部与门店之间的存货调拨在不加价的情况下，通过月末手工调整的方式是能实现门店的资产负债表。但总部对门店的货物调拨有加价的情况下⑤，就显得较难处理了。

7 、现金流量表的编制在 SAP 中，对于现金流量表的编制是采用公式的方式计算而出的。如经营活动产生的现金流量是通过当年销售收入 + 应收帐款的期初数 — 应收帐款的期末数 + 预收帐款的期末数 — 预收帐款的期初数等公式计算而出，但是我们知道该公司对于企业的正常业务来说是有效的，但现代社会中，非货币性交易及债务重组的业务时有发生，这部份交易是不与现金流转有关的，但同样在减少诸如应收帐款的金额，故在利用公式来推导现金流量表时，尚需加入某些因素，即经营活动产生的现金流量应为当年度产生的销售收入 + 应收帐款的期初数 -- 应收帐款的期末数 + 预收帐款的期末数 — 预收帐款的期初数 + 当期收回前期核销的坏帐 — 以非现金资产抵偿债务而减少的应收帐款 — 当期核销的坏帐，由于新增的因素在报表层次是如无法体现的（报表的应收帐款期末数是结果），故利用未调整前的公式计算出的现金流量表是不准确的。尚有现金流量表的某些项目是不能用公司来计算的，如购建固定资产、无形资产和其他长期资产支付的现金需根据有关科目分析确定等。因此，我们希望利用控制模块的某些道理来完成现金流量表的编制。比如，在输入凭证时，初级成本要素被要求分配一个成本中心，实际上这成本中心是在归集有关初级成本要素及金额。那能不能在凭证输入时，凡与现金流动有关的金额都被分配一个现金流量表中的项目，如当借：现金 1000 贷：客户 1000 时，在行项目中现金应分配给 “ 销售商品、提供劳务产生的现金 ” ，又如当借：费用 2000 贷：现金 2000 ，则在行项目中这 2000 元就应分配至 “ 支付职工以及为职工支付现金 ” 等，这样产生出来的现金流量将非常之准确，可信性将极高。

posted @ 2007-04-26 09:48 javaGrowing 阅读(872) | 评论 (0) | 编辑收藏

SAP R/3 财务基本概念及集成性浅释---主数据篇

作者：张小虎

ERP 是英文 Enterprise resources planning 的缩写，意思为企业资源计划。在企业中，存在各种各样的资源，如财务资源、人力资源、信息资源、供应商资源、客户资源等等，如何将这些资源进行合理规划，实现资源的最优化的配置，从而提高企业整体的经营能力与经营效率是企业管理者孜孜以求的目标。经济学上有一个著名理论：短边效应。也就是说，有长短不一的木块 ( 表示各种各样的资源 ) ，做成一个木桶，其装水容量的多寡不是由最长木块决定的，而是由最短的木块决定的。过去几十年来，由于电信技术、计算机技术及应用软件开发的滞后，大型企业为提高管理效率而进行的各种各样探索都难以得到最终的实现，其重要原因就在于信息的不能及时传递。人们通常所说的企业内部各个部门都是一个“信息孤岛”，指的就是信息 ( 包括财务、人力等方面 ) 的不能及时传递与处理，由此带来管理上的效率损失及机会成本的上升。随着我们国家市场化改革进程的不断加快及全球经济的一体化，各个行业内部的竞争加剧是不可避免的一个趋势，竞争的加剧对企业管理提出了更高的要求，正如莎士比亚所说的，“是生存还是死亡，这真是一个问题”。要提高企业管理水平，首先必须突破信息传递及处理这个“瓶颈”。 70 年代以来，国外企业为突破这个“瓶颈”，就陆续开始了企业资源计划的尝试。

至 90 年代初期，已经获得很大的成功，这主要应归功于相关技术，如电信、计算机及应用软件等得到了空前的发展。实施 ERP ，至少有三个方面的好处： 1 ．各种信息能够得到即时的处理与传递。如有非常及时性的财务数据及库存数据，这对于大型企业是非常必要的。 2 ．可以打破企业管理者的管理边界，同时不会造成效率上的损失。传统的分工理论形成的每个管理人员的管理边界，超出此边界将是不经济的，但实施 ERP ，如上问题可以轻松得以解决，因为 ERP 的精髓就是要信息的及时处理与传递。信息的及时传递及处理可以使管理的边界得以突破。正如和光商务股份有限公司的总经理刘铁所说：实旌 ERP 可以将管理的需求“一竿子捅到底” 1 3 ．可以降低企业内部的交易费用，同时也有利于企业组织结构的再造。实施了 ERP ，各项交易、业务流程都变得透明，信息也得到了及时的处理与传递，带来的结果是内部交易费用的降低，机构的设置也将变的简单、高效，原来“金字塔型”的组织结构变成了“扁平型”的组织结构。

毫无疑问，如上种种好处，将会使成功实施 ERP 的企业在激烈的市场竞争中获得极大的优势，具体地说，将会使企业降低费用、提高资金的运用效率，提供决策的准确数据、降低机会成本等。

支持实施 ERP 的管理软件有非常之多，如 SAP R ／ 3 、 Oracle 、 PeopleSoft 等。本文着重介绍 SAP R ／ 3 软件就是其中集成性最好、功能最强的管理软件。为什么 SAPR ／ 3 软件集成性最好并且能够及时处理并传递信息，主要是有赖于主数据的有关设置。以下开始本文有关 SAPR ／ 3 软件中与财务有关的介绍。
主数据 ( 主记录 )

第一次接触 SAP R ／ 3 软件的人，当看到主数据这样的字眼时，肯定不知所云。在 SAPR ／ 3 软件中，主数据相当是该软件的识别及自动后续处理系统。比如人的大脑，当我们见到资产负债表中的有关科目时，如长期投资，我们的大脑马上就会这样的反应：它是属于资产类的科目，期末应将余额予以结转；核算时，当其投资对被投资单位有控制、共同控制或重大影响时，应采用权益法进行核算，否则应采用成本法核算等。又如对于销售收入，我们马上就知道这是损益类科目，期末应将其结转至本年利润，而后转至未分配利润等。我们的大脑为什么有这些知识，就是因为我们经过了长期的财务知识方面的训练，所以就会有这样的识别及核算能力。对于软件系统，它不具有像人类一样的大脑，所以软件开发人员就开发了一套适合系统并使其能够像人脑一样的识别及处理财务数据。这就是 SAPR ／ 3 软件的主数据。

因此，当我们要做各项交易之前，必须到相应的主数据中去创建它 ( 当然这个创建是按照主数据中的固有格式进行的 ) ，这样系统才能认可它、自动处理它。通常我们叫这个过程为“去报个到，取个号”。与财务有关的主数据包括有总账主数据、供应商主数据、客户主数据、商品主数据、固定资产主数据、成本及利润中心主数据等六大类。下面分别阐述。

( 一 ) 总账主数据

总账主数据，它起到统驭整个财务的作用。不同的会计科目在总账主数据中创建会应用到不同的“字段” ( 英文单词为 field) ，通过这些不同“字段”的组合，就会形成系统能够识别并能够为我们现行会计核算所接受的会计科目。如下例举几个重要的科目予以说明。

号码 10010101 10030101 10040101
公司代码 KHl0 KHl0 KHlO
类别资产负债表科目资产负债表科目资产负债表科目
账户组现金／银行类其他资产类其他资产类
描述现金应收账款一国内贸易款库存商品
统驭科目类型 X D X
未清项目管理 X X X
行项目显示 √ X X
字段状态组 G001 G067 G001
号码 10050101 20010101 20020101
公司代码 KHl0 KHl0 KHl0
类别资产负债表科目资产负债表科目资产负债表科目
账户组固定资产类负债权益类负债权益类
描述固定资产一房屋建筑物短期借款应付账款一国内贸易款
统驭科目类型 A K K
未清项目管理 X X X
行项目显示 X X X
字段状态组 G007 G001 G067
号码 20060101 20070101 20080101
公司代码 KHl0 KHl0 KHl0
类别资产负债表科目资产负债表科目资产负债表科目
账户组负债权益类负债权益类负债权益类
描述购销 GR ／ IR 代销 GR ／ IR 实收资本
统驭科目类型 X X X
未清项目管 √ √ X
行项目显示 √ √ √
字段状态组 G001 G001 G001
号码 50010101 50020101 50040101
公司代码 KHl0 KHl0 KHl0
类别损益表科目损益表科目损益表科目
账户组损益类损益类损益类
描述销售收入 - 购销销售成本一购销管理费用一电费
统驭科目类型 X X X
未清项目管理 X X X
行项目显示 √ √ √
字段状态组 G029 G030 G004
仅允许自动记账 √ √

几个重要的会计科目，其余科目即可举一反三，知其所以然。在所列示的科目中，科目号码是根据《企业会计制度一会计科目名称和编号》规定的前四位数加上后四位而成，在创建时须手工填入 ( 即非系统产生 ) 。科目类别仅分成两类：即为资产负债表科目或为损益表科目。账户组分为六项：现金／银行类、固定资产类、其他资产类、负债／权益类、损益类、转移数据类。描述项既可按需创建的科目进行字面的描述，又可分为长文本与短文本描述。统驭科目类型分为三类：供应商类别 (K) 、客户类别 (D) 、固定资产类别 (A) ，主要是针对应收账款、应付账款、固定资产等模块过入的金额，他们的交易是不通过总账模块进行的，但在各自模块完成的同时，会将相应的金额过入总账。未清项目管理主要是用于须清账的科目，如 GR ／ IR ，银行的过渡科目、工资的清算等。激活了未清项目管理，必须同时激活行项目显示的功能，但在总账主数据的设置中，应收、应付、固定资产等是不能激活未清项目管理及行项目显示功能。行项目显示即表示，设置此项时，系统会有向下挖掘 (Drilldown) 的功能，当我们在查看总账的某个科目时，若对某金额有怀疑，可将鼠标对准该金额连续点击两下，系统可显示明细账的金额，再对准明细账的金额连续点击两下，系统会显示某凭证的金额。字段状态组，表示若某个总帐科目选用了不同的字段状态组，其将来在凭证输入时，需要填入不同的字段，如对于其他业务收入科目，其选用的字段状态组为 G029 ，当我们输入一个分录借：现金贷：其他业务收入时，系统会要求再输入一个利润中心的字段，否则该张凭证不能够产生。又如当我们输入一个分录借：管理费用一电费贷：现金时，系统会要求我们输入一个成本中心的字段。仅允许自动记账表示，该总账科目必须由其他模块自动过入，不用手工输入凭证，如销售收入一购销，因为该总账科目是在销售及分销模块完成“出具发票”功能时自动产生的，所以仅允许自动过账。

创建完总账的主数据后，手工输入的总账科目将得到系统的确认与认可。如传统的分录录入方式为借：现金贷：其他业务收入，在系统中将变成：借： 10010101 贷： 50100101( 假设为其他业务收入 ) 。系统在总账分录输入后，将会自动将相关金额过入至总账及更新会计报表。

( 二 ) 供应商主数据

当我们与一个供应商发生交易之前，应当在供应商主数据内创建该供应商，以使系统能够识别它并处理它。这仍然是“去报个到，取个号 " ，但这是到供应商主数据中去报到并取号。下面将创建供应商的有关过程做一个介绍。

供应商编号：除地点类别是以手工方式输入号码外，其余皆为系统自动生成的号码。
供应商类别：包括有国内贸易供应商、进口贸易供应商、关联供应商、一次性供应商、无库存供应审、招商供应商、地点等。在创建供应商时，只须在其中选择一项即可。
描述：与供应商有关的信息如公司名称、地址等输入相应的字段即可。
购货方号码：若某一供应商既是供应商又是客户，须做自动清账账务时，应在此处填写在客户主数据中生成的号码。
会计信息：此处应填的是统驭科目，该统驭科目首先应在总账主数据中创建好。
检查双重发票：此处是指检查收货凭证与发票的校验，为必输的字段。打勾√即可。
付款条件：指的是付款的期限，系统已设定好各种类型的付款期限，选择即可。选择好后，该系统会自动计算对该供应商的欠款是否已到期，有利于资金周转的筹划。
付款方式：如现金、支票、银行转账等。也是在系统内选择即可。将来做自动付款业务时，系统会根据自动付款方式的参数选择是否支付该款项。
结算客户：此处是与购货方号码相关联的，欲做自动清账账务，必须在此处打勾√。

如上主数据的内容填写完毕后，系统即会自动产生一个供应商的编号 ( 除地点的类别是手工方式输入外 ) ，如 10100001 ，该编号代表了与供应商有关的各种信息及后续处理的功能。并且在分录的输入上也与传统的有所不同了。如传统的分录方式为：借：营业费用一电费贷：应付账款一 XX 供应商，但在系统中的分录录入方式变为：借：营业费用一电费 ( 这将也有一个总科目号码 ) 贷： 1010000l( 与该供应商有关的交易金额将会由系统自动过入至创建该供应商主数据选定的统驭科目，同时在总账层次中的该统驭科目也得到了自动的更新 ) 。

另外，对于不同类别的供应商，创建完毕后，会产生不同号码范围段的编号。如国内供应商的号码范围段为 101 开头的 8 位数，国外供应商其号码范围段为 18 开头的 8 位数。熟悉后，看着供应商的编码范围即可知道，该供应商是属于何一类型的供应商。

( 三 ) 客户主数据
与供应商主数据一样，有新的客户与我们发生交易时，应当创建客户主数据。

客户编号：除类别为“地点”客户编号须手工输入外，其余类别的客户编号皆由系统自动产生。
客户类别：有国内个人客户、国内批发客户、关联客户、租赁客户、地点、其他等六大类。
描述：即为对客户的一般情况进行描述，如公司名称、地址、邮编、联系人等。
统驭科目：此处输入在总账主数据中已创建好的应收账款统驭科目，如应收账款一国内个人客户
(11310101) ，应收账款一国内批发客户 (11310201) 等。零售企业的大部分客户都是个人客户，因此只须创建一个一次性的客户，而后通过修改有关描述性的字段即可。
付款期限：此处是指客户付款给单位的付款期限，由于主要以零售为主，付款期限定为立即付款，但可针对个别客户 ( 如在合同中规定的收款期限 ) 另行设定。系统已设置各种的付款期限。通过此处的设置，将来做催款程序时，系统会根据设置的参数自动计算应收账款的账龄及打印催款函。
付款方式：可以有现金、支票等方式。
催款程序：选择催款程序，可以产生催款函件。
与创建供应商主数据一样，当创建完毕客户主数据时，系统会自动产生一个客户的编号 ( 如 500000001) ，该编号代表了该供应商的相关信息及后续功能。凭证输入方式上，将与传统的手工方式有很大的不同。如传统的凭证为借：应收账款一 XX 客户贷：其他业务收入一租金，在系统中将变为借： 500000001 贷：其他业务收入一租金 ( 这将也有一个总科目号码 ) ，交易金额自动会过入统驭科目如 11310101 的应收账款一国内个人客户，同时也即时更新总账中的统驭科目。
同样，不同类别的客户，其创建完主数据后产生的编号是不一样的，如国内个人客户，其编号范围为 500000000-599999999 ，国内批发客户其编号范围为 3 10000000-3 19999999 等。这将便于我们区分不同类别的客户。

( 四 ) 商品主数据
商品数据的内容较为复杂，主要由主数据组负责创建，对于财务人员需要了解的内容主要有以下几项：

描述：即对商品一般性的描述，如品名、类别、供应商等。
评估类：主要有两类 3100 与 3600 ，其中 3100 代表该商品为购销类商品，决定了系统自动生成的 GR ／ IR 为购销类的 GR ／ IR ； 3600 代表该商品为代销的商品，决定了系统自动生成的 GR ／ IR 为代销类的 GR ／ IR 。
价格控制类型： SAP 中有两种价格控制类型，一为标准成本法，二为加权移动平均法，该两种方法用于存货的发出时结转销售成本用。
移动平均价：由系统自动计算得出。系统会根据每批次的采购单价及数量对目前的库存商品发出单价进行移动平均计算出作为结转销售成本用的单价。
总库存量：是指目前的库存总量。
销售价格：由系统根据一定的毛利要求并结合有关细节得出。此销售单价将成为创建销售订单时的单价，若有打折，系统会根据打折比例算出最终销售价，这也将成为计算销售收入的单价 ( 系统会自动将增值税计出后并从收入中剔除 ) 。
利润中心：主要是为创建利润中心的损益表而用。若该商品维护的层次到某个门店，则将来销售确立时，收入与成本将为转入总账层次与利润中心层次。
商品主数据创建完毕后，系统会产生一个商品号，该号码代表了如上有关的信息及计入某个总账科目如库存商品、受托代销商品的要求。

( 五 ) 固定资产主数据

同样的，当财务上要做一件与固定资产有关的交易，如购置，首先必须在固定资产主数据中去创建它，然后才能在财务上开始与之相关的业务。如下是创建固定主数据的一些重要内容。在系统中，对于固定资产的大部分业务是系统自动完成的，所以如下的内容是有必要的。

类别：在传统的会计核算中，通常可以将一个企业的固定资产分为几大类：房屋建筑物、机械设备、交通工具、办公设备、其他等。在系统中，也是遵循这样一种分类方法，但为了便于系统区分固定资产折旧时所应计入的科目，如管理用的固定资产折旧费用应计入管理费用一折旧科目及营业或生产用固定资产折旧费用应计入营业费用 ---q~ 旧或制造费用一折旧，在系统中，将固定资产的分类进一步细分，分成房屋建筑物 ( 总部 ) 、房屋建筑物 ( 门店 ) 、机械设备 ( 总部 ) 、机械设备 ( 门店 ) 、交通工具 ( 总部 ) 、交通工具 ( 门店 ) 、办公设备 ( 总部 ) 、办公设备 ( 门店 ) 、其他 ( 总部 ) 、其他 ( 门店 ) 等，同时在 SAP 系统中，在建工程、无形资产 ( 商标、土地使用权、著作权、商誉等 ) 也属于固定资产模块的核算范畴。因此，当我们欲创建某个固定资产的主数据时，如总部用的服务器，就应选择总部办公设备这一类型，随后系统会自动确定相应的科目定位码。
描述：即对应创建的固定资产进行如名称类别等描述。
科目定位码：是与系统设定的固定资产类别紧密地联系在一起的。该科目定位码实际上起到了统驭科目的功能。如在本次设定中，总部的房屋建筑物的科目定位码为 1010 ，门店的房屋建筑物的科目定位码为 1020 ，但这两定位码同时会与总账科目固定资产——房屋建筑物联系起来，如当财务增加一个固定资产时，就会通过科目定位码使总账科目固定资产 _ 谤屋建筑物金额相应增加。
成本中心：这是与控制模块有关的设置。如总部用的服务器，就应选择与总部某个部门有关的成本中心。
若该服务器的折旧费用应由不同的成本中心分担，可以该成本中心为基础，在控制模块内采用分摊或分配的功能进行划分。
分析用途：分为一次性或分期购入、是否抵押、是否保险四类，这是为区分各个不同固定资产的状态而设的。如若想了解有多少固定资产已经被抵押，则可以在查看报表时，选择是否抵押的功能，系统就会将所有已抵押的固定资产列示出来。
折旧年限：分为账面折旧与税务折旧，账面的折旧年限与折旧率会计入总账，税务的折旧年限与折旧率则会作为调整递延税款所用。如某固定资产的账面折旧年限为 3 年，年折旧额为 lO 000 元，税务折旧年限为 5 年，年折旧额为 8 000 元，则系统会将 10 000 元作为总账的折旧金额并计入相关费用，但系统也会算出税务的折旧额为 8 000 元，但这 8 000 元只是便于我们做递延税款的手工调整。
创建完某个固定资产的主数据后，系统会自动产生一个该固定资产的号码，如 11 11 11 11 11 ，我们在财务输入分录时，借： 1111111111 贷： 10010101( 现金 ) ，交易金额会自动过入至总账层次。

在固定资产模块中，折旧是系统自动运行的，不需手工计算。并会过入相应的总账科目。

利润中心主数据、成本中心主数据的内容应属于控制模块中的主要功能，在建立主数据方面相对而言较为简单，关键在于企业内部对于利润中心及成本中心的如何划分，也就是说对管理深度要求到什么水平。

posted @ 2007-04-26 09:47 javaGrowing 阅读(756) | 评论 (0) | 编辑收藏

SAP R/3财务基本概念及集成性浅释---总帐等概念

作者：张小虎

1 ，科目表的建立及分配在 SAP 中，科目表的层次较公司代码高，也就是说先创建好科目表，然后可以分配给不同的公司使用。在同一集团范围内，为了使各个集团范围内的公司使用的科目表都能一致，通常是先创建一个虚拟的公司及科目表，然后集团范围内公司都可从其拷贝。科目表中的科目就是在总帐的主数据中分别创建的。这里值得一提是，在 SAP 中的科目表与传统的手工方式在科目体系中有了很大的不同。传统的帐务体系将会计科目分为 1 级科目、 2 级科目、 3 级科目等。但在 SAP 已没有这样分法了。除了应收、应付、固定资产等统驭科目外，所有的明细或 2 、 3 科目上升为总帐科目（当然在使用之前，应进行有关主数据的设置），如传统的银行存款 — 工商银行 XX 支行 XX 帐号，这只是银行存款的一个子科目，但在 SAP 中，此时已设置为一个总帐科目了，科目代码是根据企业会计制度中的有关编码扩充至 8 位编码，如一个企业有许多银行存款，在 SAP 中就变成了有许多总帐科目。在总帐层次显示时，是分别显示的，但到报表层次时，则根据所有银行科目中的前四位代码汇集成一个科目银行存款进行披露。管理费用也一样，在 SAP 中有非常多管理费用的总帐科目（如工资、奖金、津贴等）。但在总帐还包含有从其他模块中过入的金额，如统驭科目，统驭如应付 / 收及固定资产的明细科目，因此在 SAP 的总帐科目表中，我们看到的就不是目前的五、六十个科目，而是将近五百个的总帐科目。由于应收、应付、固定资产有各自独立的模块，所以有各自的明细帐。但反映在总帐及报表层次时，分别为细分的统驭科目（如应收帐款可根据企业管理的需要分为应收国内的款项与应收国外的款项等）。 SAP 所有的财务信息都是即时的，当记录一笔总帐分录时，相应的总帐、报表都已生成，当应收明细帐生成时，通过统驭科目就可即时过入总帐与报表。也就是说，在 SAP 的帐务里，任何时点都会产生新的总帐与新的报表（注意该总帐与报表并不完全体现法人的资产负债损益情况，尚有折旧、预提待摊因素要考虑）。

2 ，统驭科目的概念及分类，统驭科目的变更统驭科目（ reconciliation account ）指的就是将明细科目归集起来的意思。前面我们说到，系统总帐科目表中包括统驭科目，该统驭科目是与应收模块、应付模块、固定资产模块有关的，其中长、短期借款运用了应付模块的功能，也成为了统驭科目。在实际业务过程，我们可能会发生统驭科目选用错误，此时就要用到统驭科目的变更功能。如客户 A 的统驭科目被误选为 11310101 ，并有一笔分录输入，假设为 1000 元，此时的总帐科目 11310101 就有 1000 元余额，事后发现用错统驭科目，为此在此客房的主数据中更改统驭科目假设为 113102101 （注意这并不会更改已过入 11310101 的 1000 元），更改完毕后，至月末（假设本月只有一笔分录及余额为 1000 元）运行客户重组程序，系统会产生借： 11310299 （系 11310201 的调整科目，但非统驭科目） 1000 贷： 11310199 （系 11310101 的调整科目，但非统驭科目） 1000 ，在报表层次上 11310101 与 11310199 被安排在一行后余额变为 0 ， 11310201 与 11310299 被安排在一行后余额变为 1000 ，这样在报表层次就将由于选错统驭科目而产生的错误纠正了。第二个月初，系统会自动运行相反的调整分录，借： 11310199 （系 11310101 的调整科目，但非统驭科目） 1000 贷： 11310299 （系 11310201 的调整科目，但非统驭科目） 1000. 直到选错统驭科目的金额被支付出去后，才不需运行上述程序。

3 ，凭证的输入规则在 SAP 中，总帐科目在输入分录是需要遵循传统的记帐方法， “ 有借必有贷，借贷必相等 ” 。但对于应收、应付的发票输入（即作会计分录）单边则可，如在应付模块作发票输入，填入供应商的号码，日期、金额后，其次填写行项目，此时的行项目的字段中已经默认了借方，用户只需选择适当的总帐科目（如管理费用 —XX ）、金额、成本中心即可。产生的分录即为借贷皆具的双边分录了。应收模块的发票输入也同样。在应收、应付模块中除了后勤模块的 “ 发票校验程序 ” 及销售模块的 “ 出具发票程序 ” 自动过入应付、应收帐款外，尚有许多处如 “ 过帐 ” 、 “ 清帐 ” 也具有半自动生成会计分录的功能。另外，在 SAP 中，凭证具有较宽泛的意义，如后勤模块的产生的收货单据，在 SAP 中也称为凭证，发票也称凭证，因此财务人员在实际操作中应注意区别。

4 ，凭证的类别传统的会计核算中，将凭证的类别分为收、付、转三类或直接就是一类记帐凭证。 SAP 对凭证的分类基本上也遵循收、付、转三类的原则，即总帐凭证（类似转帐凭证） SA ，与供应商有关的凭证（类似于付款凭证）： KR （应付供应商的凭证）、 KG （供应商转来的红字发票， SAP 称为贷记凭证）、 KZ （付款给供应商的凭证），与客户有关的凭证（类似于收款凭证）： DR （开具发票给顾客的凭证）、 DG （开具红字发票给顾客的凭证）、 DZ （向顾客收款的凭证），与固定资产交易有关的凭证 AA 等。

5 ，记帐码在手工的会计核算过程中，我们通过用记帐符号 “ 借 ” 与 “ 贷 ” 来描述资产、负债的增、减。但在 SAP 中，却变得有些复杂了，比如，对于总帐科目的凭证，用符号 40 来表示总帐的借方，用 50 来表示总帐的贷方，分录例示如下： 40 ： 10010101 （现金） 50 ： 50150101 （营业外收入）；对于与供应商发票有关的凭证输入，主要与应付帐款有关的借贷方就比较复杂了，如贷方用 31 、 32 、 33 、 34 、 35 、 36 、 37 、 38 、 39 ，借方用 21 、 22 、 23 、 24 、 25 、 26 、 27 、 28 、 29 ，如供应商发票输入分录为： 40 ： 50100101 （营业费用 - 电费） 31 ： 10100037 （表示通过主数据创建的供应商编号）。对于与应收帐款有关的，其应收帐款的借贷方所用的记帐码：用 01 、 02 、 03 、 04 、 05 、 06 、 07 、 08 、 09 表示借方，用 11 、 12 、 13 、 14 、 15 、 16 、 17 、 18 、 19 表示贷方，如输入一笔与客户发票有关的分录： 01 ：客户有关的号码 50 ：其他业务收入。与固定资产有关的业务，用 70 表示借方，用 75 表示贷方，假设通过应付模块采购固定资产， 70 ：固定资产号码 31 ： 10100037. 与存货有关的业务，用 89 表示借方，用 99 表示贷方，如 89 ：存货贷： 50 ： GR/IR ，退货时， 40 ： GR/IR 99 ：存货（与存货有关的会计业务，大部分是系统自动产生的，因此少了一道麻烦！）。记帐码在 SAP 中实际上起到如下的作用：在行项目中决定可输入的科目的类别；行项目是以借方或贷输入；决定其他字段的状态。

6 ，凭证号码的产生在 SAP 中，凭证号码可以由系统产生也可由手工产生，但系统产生的凭证号是连续的，手工产生的号码难免会产生跳号等失误，因此对系统设置时采用的凭证号码是由系统自动产生的。同时，对不同类别的凭证，系统对其产生的号码的范围不尽一致，如输入供应商发票产生的凭证号在 1900000000-1999999999 之间，付款给供应商的的凭证产生的凭证号在 1500000000-1599999999 ，与固定资产有关的凭证产生的凭证号在 0100000000-0199999999 之间，开具发票给客户产生的凭证号在 1600000000-1699999999 之间等等！尚有其他号码范围，可参照总帐蓝图中的有关叙述。当然，号码范围是与年度有关的，即开始新一个会计年度时，号码区间又会被重新选用，从而避免号码被用尽的可能。

7 ，记帐期间变式，会计年度与特殊期间记帐期间变式是较难理解的一个内容。通过手工的做法是，在某一期间内所有交易都必须在同一时点结帐，以便总帐及财务报表的生成。但在系统中，由于每一时点都可以产生一个即时会计报表，因此某些类型的凭证可以在期间结束时予以关帐，而某些却又可以继续开着，即某些类型凭证可在 8 月份入七月份的帐。当然从严格的角度说，这是不合适的。这就是记帐期间变式。特殊会计期间，在系统中，会计期间基本上分为 12 个期间，这与正常手工核算无二，但由于在年度的会计期间结束后（此时 12 月 31 日会计报表已产生），仍然存在应当调整的事项，如审计时发现有些费用的确认不尽合理，有些交易金额必须重新确认（如某些资产负债表日后事项），这时的调整就在特殊期间进行。 SAP 的特殊会计期间分为 4 个，即 13-16 期间。但有些资产负债表业务却又难以在特殊期间实现，如资产负债后日后发生的上一年度的退货，由于这涉及到集成的业务，所以在 SAP 较难实现（具体参见后述）。

8 ，初级成本要素与次级成本要素初级成本要素与次级成本要素。 SAP 除总帐的及时集成外，它的另一个特点是与控制模块的及时集成。在 SAP 中所有的总帐中的费用科目都被要求创建成为初级成本要素。这样，当输入一个总帐的费用分录时，系统会要求输入一个成本中心，即表示此时系统已将该初级成本要素分配给了某一成本中心。即通过一个分录就将总帐与控制模块的要求同时满足，这就是 SAP 的无缝集成。当然控制模块中只有该要素的金额，而不是像总帐的记录是通过双边分录来实现的，因此某成本心的费用报表是各个初级成本要素总汇。次级成本要素是指，某一成本中心的费用要素可整理成为次级的费用要素（项目），并将其通过一定的比例分摊给不同的成本中心。控制模块就是通过这两个要素反映了企业内外部间的资金流动情况。在 SAP 中，初级成本要素就类似于科目表，它可以分配给任何一个成本中心，包括法人间的成本中心，即不同的成本中心可能包括的初级成本要素是一模一样的，但金额却不尽相同。

9 ，分配与分摊分配与分摊对于成本要素的来说是一个很重要的功能。并且这功能就类似于固定资产折旧一样，一月只能执行一次。分配的功能是与初级成本要素相关的，分摊的功能是与次级成本要素的功能相关的。这两个功能同样都可用到计划（预算）与实际发生额中。如可创建一个循环，将某成本中心（可超过一个以上）的初级成本要素（可超过一个以上），按一定的比例分配给其他成本中心（可超过一个以上），当然也将这循环分为几个段，各段间相应的要求可以不一样，这样每月末执行时，就可以很好地反映初级成本要素的流向情况。同样的，也可创建一个分摊循环，将某成本中心（可超过一个以上）的初级成本要素（可超过一个以上）重新组合成为一个次级成本要素，然后再将其按一定的比例分配给其他成本中心（可超过一个以上），当然也将这循环分为几个段，各段间相应的要求可以不一样，这样每月末执行时，就可以很好地反映次级成本要素的流向情况。分配与分摊的区别在于，分配是将某一成本中心的初级成本要素分给另一成本心，被分配的初级成本要素会与被分配的成本中心的相同的初级成本要素一并反映，而分摊则是将次级成本要素分摊到另一成本中心，与被分摊的成本中心的初级成本要素一同反映，这样有利于区分本成本中心的发生的费用与分摊过来的费用的界限。需要说明的是，同一利润中心下的成本中心的分配或分摊，并不影响该利润中心的利润额，但跨利润中心进行分配或分摊，则影响了不同利润中心的利润额，两种方法产生（分配或分摊的规则相同时）的影响一致。

posted @ 2007-04-26 09:47 javaGrowing 阅读(501) | 评论 (0) | 编辑收藏

SAP R/3系统的财务会计结构

作者：不详

SAP R/3 是德国思爱普公司（ System Application Products ， SAP ）推出的企业资源计划（ Enterprise Resources Planning ， ERP ）大型系统集成管理软件。企业经营管理的全球化和多元化推动了世界范围内企业结构的变化，并且使业务流程日益复杂。这种趋势推动了产品和业务流程的革新和信息高速公路的应用。所有这些都要求以更短的反应时间来进行更多的协调与控制工作。时效性的决策必须基于不断地提供实时的信息。 SAP R/3 系统提供包括所有业务领域的业务处理流程的集成的解决方案，它是基于三层（可扩至多层）的客户机 / 服务器系统结构，支持多币种（可同时使用多达三种货币作为记帐和结算的本位币）多语言（ 15 种国家语言）的完整的企业管理解决方案。

SAP R/3 主要由财务会计（ FI ）、财务控制（ CO ）、资产管理（ AM ）、销售与分销（ SD ）、物料管理（ MM ）、生产计划（ PP ）、质量管理（ QM ）、工厂维护（ PM ）、人力资源管理（ HR ）、项目管理（ PS ）、工作流程管理（ WF ）、行业解决方案（ IS ）等功能模块组成。而财务会计、金库、管理会计、投资管理和资产管理等构成了整个 SAP R3 集成系统的核心部分 —— 财会子系统（ FI & CO ）。 SAP 产品以其强大功能、高度集成性、实时性、灵活性、开放性、可靠性以及国际普遍适用性得到了业界的广泛赞誉并占有了包括中国在内的广阔的 ERP 软件市场。包括长虹、康佳、海尔空调、李宁公司、小天鹅、联想集团、中化、中航油在内的数十家企业先后采纳了 SAP 公司的 R/3 产品作为企业的应用解决方案。 1999 年， SAP 公司其 ERP/MRP Ⅱ的软件销售收入达到了 24.35 亿美元，荣获当年 ERP 软件销售市场第一名。 1. SAP R/3 系统的集成性

SAP R/3 系统具有高度的集成性，它不仅在财务会计与管理会计内部集成，同时也在系统内的所有模块之间集成。在物料（ MM ）、销售（ SD ）等模块进行业务操作的同时，系统自动同步生成财务凭证。这样省去了传统的大量的收集、整理、制单的基础工作，减少了不必要的重复工作与由此而产生的差错，并且提高了工作效率，使财务人员可腾出更多的时间来处理与分析数据。由于系统高度集成性，数据实时更新、共享，横向上，企业管理分析所需的大量数据信息都可由系统中方便的取得。而且只要权限许可，原则上任何人在任何位置任何时间都可得到所需要的最新信息和数据，而不再需要专人整理汇总上报工作；纵向上，对一个集团来说，可随时随地获得跨公司、跨区域、跨部门的最新管理分析数据，减少信息传递的中间环节，提高信息利用率，方便快捷地进行分析决策。与传统的专用财务软件不同， R/3 系统不仅能对已发生的业务进行事后的核算，更重要的是能对实际业务进行事前计划和事中控制及事后分析评估。 2. SAP R/3 系统的财务和管理控制组织架构 组织结构的确定，需要从对外法定报表和内部管理角度详细加以考虑。哪个层次上产生对外或对内的报表，是由组织结构定义决定的。 SAP R/3 系统可以定制用户自己的组织结构。对于一个大型的跨地域的集团性公司来说，通常在 SAP R/3 系统中可定义包括集团公司、公司代码、业务范围、成本控制范围、业务关联区和成本中心等组织结构元素。 2.1 集团公司（ Company ）复杂的组织日益需要一个全景式的会计报表，这种趋势在当今竞争日趋激烈的经济全球化进程中显得越来越重要。 SAP R/3 系统中定义的集团公司的组织结构元素，可以是实际的或虚拟存在的集团公司，主要用以合并会计报表。一个集团公司可包含一个或一个以上的公司代码，通常是在集团公司层次上出具合并财务报表。 2.2 公司代码（ Company Code ）公司代码代表一个独立的会计实体，拥有完整的会计帐套。是对外报送法定资产负债表和损益表的最小单位，所有的凭证都将过帐在公司代码层次上。一个公司（分公司）虽然不是法人，但是如果需要单独核算，对外出具资产负债表和损益表，也可以设置成单独的公司代码。 2.3 业务范围（ Business Area ）主要用于企业内部管理，是创建内部资产负债表和损益表的组织结构。可以按照不同的部门或业务种类等多种方式在 SAP R/3 系统中来设置业务范围。 2.4 成本控制范围（ Controlling Area ）成本控制范围是管理会计的组织结构单元，用来核算企业的收益及费用支出使用情况。在成本控制范围下可建立成本中心（组）或内部定单等成本控制对象。一个成本控制范围可包含多个公司代码，但一个公司代码只能分配给一个成本控制范围。所有的成本中心（即费用发生单位）都将包括在此成本控制范围中。因此，对公司外部运营情况的考核需要通过每个公司代码的资产负债表和损益表来揭示，而内部管理的考核可以跨整个集团公司的范围。 2.5 业务关联区（ Operating Concern ）业务关联区也是管理会计的组织结构单元，一个业务关联区可有多个成本控制范围，一个成本控制范围只能指派给一个业务关联区。业务关联区是获利能力分析中的核心组织结构，用来监控及分析该业务关联区内各 “ 获利段 ” 的运作情况和获利能力。 “ 获利段 ” 可以是销售地区、产品、客户等属性的灵活组合。因此可以按照各获利段为依据生成获利分析报表，考核其获利能力。 2.6 成本中心（ Cost Center ）成本中心是管理会计中的最小职责单位，是每一笔费用的具体接收者。成本中心建立后需要将每个成本中心分配给标准成本中心组。这样才能保证费用记帐在成本中心及部门上。成本中心的标准层次结构反映了成本中心与成本中心、成本中心与成本中心组、成本中心组与成本中心组之间的关系。标准层次结构中的每个节点代表一个成本中心组，当然除了标准层次结构中的成本中心组之外，还可根据业务需求在标准层次之外自己定义需要的成本中心组。 3. SAP R/3 系统的财务会计（ FI ）

SAP R/3 系统对会计信息的公开性，依据有关各国会计法规进行了相应的定义，同时也适用于国际性的企业。其财会子系统符合 40 多个主要工业国，也包括中国的相关会计法规。 SAP R/3 系统的集成性确保了会计信息能够满足自动更新的要求。当用户在后勤模块处理业务时，这些业务所引起的财务上的变动将自动记入会计系统。此外，对系统外部数据， SAP R/3 系统还为其用户提供了电子化处理同业务伙伴间的数据交换的功能。

R/3 系统的财务会计应用模块由总分类帐、应收帐款和应付帐款、固定资产、法定合并以及特殊统计会计功能等组合而成。 3.1 总分类帐（ G/L ）

3.1.1 会计科目表 SAP R/3 系统提供了定义不同会计科目表的功能，使灵活多变的评估成为可能。作为经营用的会计科目表，包含了日常经营管理所需要的科目，也允许进行特殊的，在公司范围内的业务处理，财务会计和成本核算都使用同一个会计科目表；作为地区性的会计科目表，包含了为满足当地法规而设的科目。记帐的数据是基于政府的规定和预先定义的一些规则而处理的，其项目和经营用的会计科目表有所区别；作为集团公司的会计科目表，包含了在集团公司内所有公司代码使用的所有科目，其记帐数据是基于外部集团公司会计的要求，其项目和经营用的会计科目表不同。日常的凭证是记帐到经营用的会计科目表中的，但用户也可以按照某一个国家的特定要求或集团进行会计评估。

3.1.2 货币为了满足许多国家对货币的法规要求， SAP R/3 系统支持用户同时使用多达三种货币作为记帐和结算的本位币。而且所有的业务处理均能以记帐本位币、集团公司货币以及客户自定义的硬通货记帐。另外， SAP R/3 系统还支持自动处理有关外币评估、信息分类以及应收帐款的到期处理。

3.1.3 会计期间 SAP R/3 系统提供最多十六个的记帐会计期间。十二个正常的会计期间另有可自定义的一至四个特别记帐期间。会计年度也可以与日历年度相同或不同，同时还可定义缩短的会计年度（少于十二个会计期间）。

3.1.4 财务报表 SAP R/3 系统提供了丰富的报表功能。从法定的会计报表到自定义的各种内部管理报表都可方便获得。由于系统是高度集成的，所有的业务发生时系统都会同步更新各种财务报表的余额。因此，如果需要且权限许可，任何人在任何时间、任何地方均可获得所需财务报表。原则上，只要有一项业务发生，系统就可以提供更新的财务报表，甚至是对外的资产负债表、损益表等。

3.1.5 总分类帐概述 SAP R/3 系统的总分类帐与目前国内所说的总分类帐其会计概念并不完全一样。 SAP R/3 系统中的总分类帐科目包括除核算应收帐款和应付帐款科目外的所有科目。除了总帐科目中的统驭科目外，所有的总分类帐科目都是可以直接记帐的，并且对于所有总分类帐科目都可以使用未清项管理。总分类帐科目的主记录数据结构可分为会计科目表层数据和公司代码层数据。会计科目表层数据用于整个主记录，如总帐科目代码，名称，是资产负债表科目还是损益表科目；公司代码层数据包含了如何控制业务数据的输入与记帐的参数，如何管理科目的数据，以及与其它公司代码相关的数据，如货币、税码、统驭科目和未清项管理等。总分类帐的记帐数据来源于以下方面：后勤等功能模块的集成自动记帐到总分类帐；明细分类帐（如应收帐款 / 应付帐款）中的记帐相应自动更新总分类帐；在总分类帐中的直接记帐。 3.2 应收帐款（ A/R ）应收帐款模块是 SAP R/3 系统的财会子系统中对客户进行监测与控制的模块。在此模块中，帐户分析、示警报告逾期清单以及灵活的催款功能，都使用户可以方便地处理客户未清项。系统为应收帐款设置明细分类帐，并为其设置统驭帐户。每一笔应收帐款都按未清项进行管理， SAP R/3 系统的应收帐款模块提供一对一的清帐方式，同时也支持按余额总数进行清帐的方式。如果条件许可，系统与电子银行联网，还可实现自动处理进帐业务并提供电子对帐单。系统可以随时从系统中得到每个客户的帐龄分析报告，还可以对已逾期的应收款进行催款。根据未清项目的欠款天数以及对客户信用管理策略设置不同的催款等级进行催款管理。集成地使用 SAP R/3 的销售及财务会计模块，在销售模块业务发生时，系统自动生成会计凭证，应收帐款明细帐自动更新，同时统驭帐户总帐余额也同步更新，并保持数据的一致性。当然，系统也支持手动输入记帐。 3.3 应付帐款（ A/P ）应付帐款的核算与应收帐款相似，不再赘述。 3.4 特殊分类帐另外， SAP R/3 财会子系统提供了特殊分类帐模块，可为用户提供特殊的计算功能。在此模块中，一个特殊分类帐可以通过对科目的设置（如成本中心、产品等），从不同的视角来反映科目的余额。用户可以对每一个分类帐进行计划、分配和货币转换处理。当实际业务发生时，这些特殊分类帐也能自动地更新。这能满足不同的厂商对报表的要求。 3.5 固定资产

SAP R/3 系统的固定资产模块涵盖了所有主要工业国家在法定报表和资产价值地评估方面的要求。能处理包括资产购置、折旧、转移、报废等业务。除了法定的对资产价值评估，可自定义许多折旧和评估的方法。固定资产的核算和管理是财务会计的重要组成部分。无论是出于外部或内部的会计核算的要求，对固定资产进行计划和监控也显得更加重要。对固定资产的管理，系统主要是通过资产的分类来实现的，这样可以在系统中定义任意多个帐户分配以及相应的统驭科目。资产分类，在 SAP R/3 资产管理应用程序中占据核心的位置。高度集成使用 SAP R/3 系统使用户能应用高效率的功能。这对于资产管理模块中的资产购置尤其明显。与其相关技术 / 作业部门（应用程序）主要有：财务会计模块 —— 应付帐款，物料模块 —— 收货及发票校验和库存管理，项目管理模块 —— 项目结算，工厂维护模块 —— 后资本化等。对于折旧，系统支持使用多种不同的折旧方法并提供了综合模拟及资产负债表优化的功能，这样就可以通过模拟折旧方法中的更改来执行报表，将优化的折旧结果转帐到报表中。这种模拟的功能为用户提供了对资产价值的不同视角，并且能处理计划和实际的投资。同样，系统支持固定资产的报废和部分报废并自动计算所有待结算的金额。 3.6 法定合并与单独的企业财务报表相比，合并财务报表已经显得日益重要。

SAP R/3 系统允许用户能够选择多种方式对集团公司下属的子公司的业绩进行评估。合并财务报表不是简单地将子公司会计报表进行简单地相加，而是对资产、应收 / 应付帐款、债务、利润、销售收入等进行重新分类、评估、合并及内部抵销。所有地合并业务都是由系统自动完成。除了法定合并以外，系统还允许用户在计划值地基础上经常地结算和作合并会计报表，如汇总的财务报表。 3.7 财务会计信息系统

SAP R/3 的财务会计信息系统（ FIS ）是基于 SAP 的综合数据信息仓库（ EIS ）的交互式信息系统。它使用户可以在指定的数据参数的基础上对相应的财会数据作评估。财务会计信息系统对不同币种的分析、总分类帐科目分析、资产负债表和损益表的分析等领域的经营管理提供有效和综合的支持。用户可以对所有的组织结构单元（如公司代码、公司和业务部门）和各种会计期间（会计年度和会计期间）进行评估。报表既可以用公司代码的货币，也可以用其它平行使用的货币 —— 如集团公司货币、硬通货等。功能强大的信息查询功能是 SAP 产品的另一突出特点。

posted @ 2007-04-26 09:46 javaGrowing 阅读(557) | 评论 (0) | 编辑收藏

SAP FI模块与SD、MM的接口配置基本方法(转帖）

1 FI/SD 借口配置
FI/SD通过tcode VKOA为billing设置过帐科目，用户可以创建自己的科目定义数据表。科目是做到COA级的，通过KOFI/KOFK这两个condition type确定分别过帐到FI和CO凭证中。由于PricingProc.是同SalesOrg.相关联的，所以科目在Organization上首先要做到SalesOrg. 级，其后的AccountKey是在PricingProc.中和不同的PriceConditionType相关联的，决定着最终销售收入、折扣、附加费用、预提等过到不同科目上。

2 FI/MM 借口配置
FI/MM通过tcode OBYC为所有的库存移动设置过帐科目，系统用不同的TransactionKey决定了不同的移动类型/业务类型，对于这些TK的含义，SAPLIB中有较为详细的解释，可参阅。
科目的配置可以按照需要做在ValuationArea(Plant)和ValuationClass层。特别是我认为FI/MM AccountDetermination中最有意思的就是TK为GBB的科目定义，其中有一个东东叫做GeneralModificationKey，这个GMK是同MovementType直接相连的；除了很多标准的GMK之外，用户也可以自定义，并将它们同自定义的MovementType相关联，以决定不同的MT连接到不同的过帐科目上。

3 实例说明
可以按照资料到系统中配置一下，并做一些例子，有助于理解这些科目配置
3.1、对于收货(特别是来自采购的收货)和发票录入IV/LIV，常用的TransactionKey为：
BSX 同ValuationClass相关联的所有基于存货科目的过帐
FR1、FR3 运费和关税的清帐科目(需要通过IV/LIV做Clear，类似GR/IR科目)
FR2、FR4 运费和关税预提科目(无需Clear)
WRX 存货GR/IR科目
DIF SmallDifference(小金额差异)，未超过发票价差容限的金额过到此科目(OMR6中定义ToleranceLimit)
KDM 处理收货同收发票汇率不一致造成的差异过帐
KDR 处理收外币发票时，由于四舍五入的原因造成的本币金额同GRIR本币金额不一致的差异过帐
UPF 处理UnplannedDeliveryCost(计划外运费)是否单独过到某个制定科目而不是过到存货或价差科目
PRD 标准成本法下处理PPV的科目，即采购价差科目

3.2、对于发货和其他库存移动，常用的TransactionKey通常只需要关注GBB，即所谓库存移动的抵减或对应科目，其中比较重要的一个概念就是GeneralModificationKey，这个东东是同MovemtType关联的，较常用的有：
AUF : 无Acct.Assignmt的PP/CO订单的收货和结算
BSA : 通过561/562做库存初始化的过帐科目
INV : 库存差异导致的收入和费用科目，一般为P+L科目
VAX/VAY: 销售订单的发货成本科目
VBO : 委托加工业务，提供给供应商的库存出货科目
VBR : 处理内部发货业务，如直接消耗到成本中心、资产或内部订单等
VKA : 基于Acct.Assignmt的销售订单业务，如BTO、MTO业务等
VKP : 基于Acct.Assignmt的项目业务，如BTP、MTP业务等
ZOB : 无PO收退货，如501/502
ZOF : 无PP订单收退货，如521/522
同样，你可以基于自定义的MovemtType，设置相关联的自定义的GMK，并在GBB中指定科目。此外，如果启用MaterialLedger、标准成本法核算货ProductCostbyPeriod等，相关的LKW，PRV， PRP，PRQ和PRY等也需要做相关设置，详见帮助。

3.3 对于收货科目设置，举个稍复杂的例子：
A000工厂下的物料A，ValuationClass为V000；拟在MM/InfoRecord中定价2％的采购运费，不需要通过IV/LIV清帐；价差容限定义1元以下为SmallDifference；在采购过程中发生了计划外运费，并希望过到制定科目上；收发票时的汇率同收货时不同，有差异。
示例会计科目如下：
1401 原材料存货科目
2181 预提运费
5121 计划外运费
5122 SmallDifference
5151 汇率差异
6000 存货GR/IR

可通过OBYC配置为:
库存过帐 BSX A000 V000 1401
预提运费 FR2 A000 V000 2181
小额价差 DIF 5122
计划外运 UPF 5121
汇率差异 KDM A000 V000 5151
GR/IR WRX A000 V000 6000

收货时的分录为(MAP计价方式，忽略VAT)：
Dr. 1401 1020.00
Cr. 6000 1000.00
2181 20.00
收采购发票时的分录为：
Dr. 6000 1000.00
5121 100.00
5122 0.80
5151 1.20
Cr. A/P 1102.00
收运费发票的分录：
Dr. 2181 20.00
Cr. A/P 20.00

比如你用MB1A通过201做PGI，在OMJJ中你可以看到有一个Account Grouping，双击进去后有如下一条String: 201 K X X WA03 2 GBB VBR。其中K表示Consumption Posting，而GBB VBR是连接Account的关键。用OBYC，选择GBB（指库存抵减过帐）双击，里面比较复杂的设置有可能是：Valuation Modif.(a Plant) > General Modif.(VBR) > VC > Account!。
这样，201就通过GBB,VBR同相关科目联到了一起。
当然，这是个很简单的例子，SAP对于不同的Special Stock，数量、金额是否更新，都会在OMJJ 中引用不同的所谓(Value String)，这个东东比较复杂，我是做FICO的，了解得不多，不过很值得研究啊.

101是针对采购、生产和成本控制订单收货的MT，在OMJJ>Account Groupg. 中你可以看到常用的Movemt. Indicator是B（采购订单）和F（生产订单），请特别注意看Consumption Posting(A,V,E,P...)字段有值的那些行，他们链接的Transaction Key是KBS，这个KBS叫做Account Assigned Purchase-Order，在OBYC中是无法手工配置科目的。SAP在Movement Type的Post String/Value String中处理这种KBS时，会直接指向库存科目，即在BYC中，Transaction Key为BSX库存科目定义。

刚才提到在OMJJ>Account Grouping中的101那些行，它们的Value String是WE06，你可以用t-code SE16看一个表叫做T156W，查看WE06的那些行，你会发现：
WE06 01 KBS
WE06 02 WRX
这KBS刚才说过了，那么这个WRX你会在OBYC中发现，它定义的是GR/IR的科目，即收货时
Dr. Inventory (KBS/BSX)
Cr. GR/IR (WRX)

用这种方法，你就可以分析其他的MT了，如同101类似的105/106,122/123等，蛮复杂的。
另外，在SAP Library中的相关IMG配置解释得也不完整，有很多Transaction Key在4.6C 的Library都没有说明，只能自己研究了。
我们曾经用过的方法，就是用不同的MT做库存移动，然后在程序中设动态断点，依据那些 Value String，跟踪它到底用的是那些Transaction Key和科目定义。

posted @ 2007-04-26 09:43 javaGrowing 阅读(526) | 评论 (0) | 编辑收藏

(转)如何提高读取BSEG的性能（sap已清项和未清项的提取）

The FI-GL table BSEG, which is one of our biggest PR1 tables, is an example of a clustered table. At the database-level, there is no table called BSEG, but instead RFBLG is being used for the BSEG data. Most of the fields known in BSEG are not known in the database table RFBLG, but are compressed in a VARDATA field of RFBLG. So tests in the WHERE clause of SELECTs agains BSEG are not used by the database (e.g. lifnr = vendor account number, hkont = G/L account, kostl = cost center). As a consequence, these tests are done after the facts similar to using the CHECK statement, and as already said in tip 1, CHECK statements are worse than tests in the WHERE-clause.

Check this link also.
https://forums.sdn.sap.com/thread.jspa?forumID=50&threadID=38572&messageID=373481#373481
1) select with header information from bkpf
2) use secondary index tables
http://forums.sdn.sap.com/jive3/thread.jspa?forumID=50&threadID=14280&messageID=105504#105504
1.BSAK Accounting: Secondary Index for Vendors
2.BSAS Accounting: Secondary Index for G/L Accounts
3.BSIK Accounting: Secondary Index for Vendors
4.BSID Accounting: Secondary Index for Customers
5.BSIM Secondary Index, Documents for Material
6.BSAD Accounting: Secondary index for customers
7.BSIS Accounting: Secondary Index for G/L Accounts
3) use logical data base e.g.: BRF
4)具体说明
BSAD：应收明细（已清帐）
BSID：应收明细（未清帐）
BSAS：总帐明细（已清帐）
BSIS：总帐明细（未清帐）
BSAK：应付明细（已清帐）
BSIK：应付明细（未清帐）
BSEG主要通过“凭证号”“会计年度”“行号”和这六张表关联，BKPF 是财务凭证抬头，BSEG 是财务凭证行项目。在财务凭证记账的时候，数据被插入 BKPF 和 BSEG，如果有必要，数据同时插入以上六张表中的一个未清表。
一般情况下一笔业务产生的凭证都是未清的，那么：
   如果该业务行是客户相关的，则被记录到BSID；
   如果该业务行是供应商相关的，则被记录到BSIK；
   无论和客户相关还是和供应商相关，都是和总帐相关，所以也会有记录到BSIS；
   但是如果这笔业务被清帐了，则相应的记录会从BSI*转移到BSA*

一般情况下：
   应收账款、预收账款、其他应收款、应收汇票等科目既和客户相关，又和未清项管理的总帐科目相关；
   应付账款、预付账款、其他应付款、应付汇票等科目既和供应商相关，又和未清项管理的总帐科目相关；
   其他总帐科目一般不启用未清项管理，所以记录一般都放在BSIS中。

5)未清项和已清项的概念
清项(Open Item)，表示财务凭证行项目的一种挂账的状态，这种状态，提示该行项目需要被清帐(Clearing)。在 FS00 设置科目的时候，有一个选项是 'Open Item Mngment'，该选项选中后，表示财务凭证行项目中记账科目为此科目时，该行项目有未清或者已清的状态。
已清项(Close Item)，表示该行项目已经被清帐。
具体应用中，'Open Item Mngment' 用得比较普遍的是应收（客户）和应付（供应商）的科目。
此外，在总帐中，也有一些应用，比如对于银行的对账单，也一般使用，这样可以再对帐无误后再做清帐。

为什么需要使用到未清项管理？目的是为了记录完整的业务交易。比如对客户A有两笔应收款 A1 与 A2，A1 因为有些商务纠纷，可能需要进一步交涉，所以客户先针对 A2付款。如果没有未清项管理，这一笔收款可能只能针对时间顺序靠前的交易 A1 了，显然，这样是一种比较混乱的状态。实际上，几乎大部分科目理论上都可以进行未清项管理，但是，有可能这样做不能带来显著的效益反而带来管理成本的增加。

6)未清项和已清项sap提供的TCODE
在 SAP R/3 中，使用 FBL1N , FBL3N, FBL5N 分别可以查看供应商，总账，客户类型科目的未清已清项。

posted @ 2007-04-18 14:16 javaGrowing 阅读(791) | 评论 (0) | 编辑收藏

在Struts中使用JavaBean和List（多行数据）类型属性

在 Strust 中，我们可能经常要在 ActionForm 中使用其他 JavaBean 作为属性类型，这里就存在着如何使用好这些属性与 HTML Form 之间的数据交换，下面我们就这些问题做一讲解。

如在用户注册界面中，我们通常会将用户的联系方式形成一个单独的新的 Class ，如 Contact ，包含以下属性：电话 (tel) ，手机(cell) ， Email(email) ， QQ(qq) ，通信地址 (adress) 等等，这样条理也比较清晰，以下是这个ActionForm 的部分代码：

public class RegisterForm extends ActionForm

{

private Integer id;

private String logonName;

private String realName;

private Contact contact=new Contact();

………..

}

在这里我们需要将 Contact 实例化（在 reset 函数中需要重新实例化），这主要因为 Struts 的机制：如我们将 HTML 的Form 元素（如 email ）值传给 ActionForm ， Struts 需要执行的操作是getContact().setEmail(String email) ，如果这时返回的 contact 对象为空的话，那么赋值如何进行，而且Struts 也不会知道如何去实例化 Contact ，有时这些 JavaBean 的类型有可能是接口，实例化更是未知，所以关于JavaBean 类型在 ActionForm 中的实例化，你需要自行完成，而且必须完成。至于在实际操作中判断 JavaBean是否被进行过相关操作（不再是初始状态），你需要自行判断，其实也很简单，如可在 Contact 类中编写一个函数检验一下即可。

ActionForm 创建完毕后，我们需要在 Jsp Form 中引用这些 JavaBean 类型的属性值，那就很简单啦，只需采用“ Form 的属性名称”＋“ . ”＋“ JavaBean 中的属性名称”结构构成的名称付给相关元素即可。如：

<html:text property="contact.email">

通过这种方式我们就可以处理好 ActionForm 中的 JavaBean 类型的属性值了。

实际的情况可能更复杂些，我们有时可能要提交多行数据到后退，而且行内的数据是相关的，如我们需要提交多个用户的联系方式，这些行内的数据，如email ，电话，手机，这些数据都是和用户编码相关的，现在我们修改一下 Contact 类，添加一个用户编码 (userId)属性，这时我们构建的 ActionForm 中可能需要一个列表数据（ List ）类型来处理这种情况。以下是这个 ActionForm的部分代码：

public class ModifyBatchContactForm extends ActionForm

{

private List contact =new AutoArrayList (Contact.class);

…..

}

在以上代码中，我们同样处理了 List 类型数据的初始化。 Struts 在给 List 中的对象赋值时，当然需要先获取 List数据，然后在获取 List 中某一个对象（通过 Index），最后给对象赋值。在这里想我们可以更详细点分析浏览器端传过来数据，字段值形式如下：contact[0].email= linux_china@hotmail.com ， Struts 获取 ActionForm 中的 List数据后，通过 Index （此时为 0 ）来获取 List 中封装的 JavaBean 对象，然而此时 List是空的（尽管初始化了，但是没有数据），是无法取得封装的对象的，因此我们要在 Struts 获取 List中封装的对象的时候给它创建一个，这样就保证对象的获取和赋值的成功进行，所有我们新建一个 AutoArrayList 类，继承ArrayList ，只要重写 get(int index) 方法即可，其实很简单，代码如下：

public class AutoArrayList extends ArrayList {

private Class itemClass;

public AutoArrayList(Class itemClass) {

this.itemClass = itemClass;

}

public Object get(int index) {

try {

while (index >= size()) {

add( itemClass.newInstance());

}

} catch (Exception e) {

e.printStackTrace();

}

return super.get(index);

}

}

这样我们就完成可以多行数据提交的 ActionForm设计，这里还有点提醒，如果从浏览器端传过来的行索引是跳跃是的，如缺少中间行，而你不想要这些数据的话，且首尾行 index相差很大的话，这种方式可能不太适合。这种多行提交形式比较适合对固定行的数据处理。如果行数不固定的话，你可以参考使用 MapForm 方式实现。

下面我们就看看如何在 Jsp 中使用这个 ActionForm ，其实只需要执行一个循环即可：

<logic:iterate id=" contact " name=" FormName " property=" contact " indexid="index">

<html:text name=" contact " property="userId" indexed="true">

<html:text name=" contact " property="email" indexed="true">

</html:text>

这里我们再讲解一下，代码中出现的“ contact ”（红色）都是 ActionForm 中的 List数据类型变量名称，请确保一致，请不要更改名称，这也是方便提交到后台的数据接收。“ FormName ”为在 struts-config中声明的 ActionForm 名称。 indexed="true" 可以确保生成的 html 元素的名称唯一，不要缺少这个声明。以上的Jsp 代码，你也可以使用 JSTL 来完成，就看你习惯如何了。

通过以上步骤，我们完成了多行数据的提交所有环节，这样 Struts 就会完成其他所有的事情，我们的代码逻辑和实现也简单多了。

总结：通过以上两个例子，相以信对 ActionForm 中使用 JavaBean 和 List 类型数据不会再陌生，同时使用 Map类型，这样可创建更好的 ActionForm 设计，关于 MapForm ，请参考http://www.jetmaven.net/documents/j_mapformInStruts.php 。不过引入这种方式后，在Validator 方面你可能要花点脑筋啦（如通过 XDoclet 生成 Validator文件可能功能不全），可能你需要手写一些代码来完成相关工作</html:text></logic:iterate></html:text>

posted @ 2006-12-14 09:28 javaGrowing 阅读(616) | 评论 (0) | 编辑收藏

通用js校验类

common.js

 //扩展String类功能
//删除字符串二边空格
   String.prototype.trim = function()
   {
    return this.replace(/(^[\s]*)|([\s]*$)/g, "");
   };
   //删除字符串左边空格
   String.prototype.lTrim = function()
   {
    return this.replace(/(^[\s]*)/g, "");
   };
   //删除字符串右边空格
   String.prototype.rTrim = function()
   {
    return this.replace(/([\s]*$)/g, "");
   };

---------------------------------------------------------------------
chkUtil.js

 //定义一个可静态调用方法的js类
function ChkUtil() { }
//校验是否为空(先删除二边空格再验证)
ChkUtil.isNull = function (str) {
 if (null == str ||  ""== str.trim()) {
  return true;
 } else {
  return false;
 }
};
//校验是否全是数字
ChkUtil.isDigit  = function (str) {
 var patrn=/^\d+$/;
 return patrn.test(str);
};
//校验是否是整数
ChkUtil.isInteger = function (str) {
 var patrn=/^([+-]?)(\d+)$/;
 return patrn.test(str);
};
//校验是否为正整数
ChkUtil.isPlusInteger = function (str) {
 var patrn=/^([+]?)(\d+)$/;
 return patrn.test(str);
};
//校验是否为负整数
ChkUtil.isMinusInteger = function (str) {
 var patrn=/^-(\d+)$/;
 return patrn.test(str);
};
//校验是否为浮点数
ChkUtil.isFloat=function(str){
 var patrn=/^([+-]?)\d*\.\d+$/;
 return patrn.test(str);
};
//校验是否为正浮点数
ChkUtil.isPlusFloat=function(str){
  var patrn=/^([+]?)\d*\.\d+$/;
  return patrn.test(str);
};
//校验是否为负浮点数
ChkUtil.isMinusFloat=function(str){
  var patrn=/^-\d*\.\d+$/;
  return patrn.test(str);
};
//校验是否仅中文
ChkUtil.isChinese=function(str){
 var patrn=/[\u4E00-\u9FA5\uF900-\uFA2D]+$/;
 return patrn.test(str);
};
//校验是否仅ACSII字符
ChkUtil.isAcsii=function(str){
var patrn=/^[\x00-\xFF]+$/;
return patrn.test(str);
};
//校验手机号码
ChkUtil.isMobile = function (str) {
 var patrn = /^0?1((3[0-9]{1})|(59)){1}[0-9]{8}$/;
 return patrn.test(str);
};
//校验电话号码
ChkUtil.isPhone = function (str) {
 var patrn = /^(0[\d]{2,3}-)?\d{6,8}(-\d{3,4})?$/;
 return patrn.test(str);
};
//校验URL地址
ChkUtil.isUrl=function(str){
var patrn= /^http[s]?:\/\/[\w-]+(\.[\w-]+)+([\w-\.\/?%&=]*)?$/;
return patrn.test(str);
};
//校验电邮地址
ChkUtil.isEmail = function (str) {
 var patrn = /^[\w-]+@[\w-]+(\.[\w-]+)+$/;
 return patrn.test(str);
};
//校验邮编
ChkUtil.isZipCode = function (str) {
 var patrn = /^\d{6}$/;
 return patrn.test(str);
};
//校验合法时间
ChkUtil.isDate = function (str) {
  if(!/\d{4}(\.|\/|\-)\d{1,2}(\.|\/|\-)\d{1,2}/.test(str)){
    return false;
  }
  var r = str.match(/\d{1,4}/g);
  if(r==null){return false;};
  var d= new Date(r[0], r[1]-1, r[2]);
  return (d.getFullYear()==r[0]&&(d.getMonth()+1)==r[1]&&d.getDate()==r[2]);
};
//校验字符串：只能输入6-20个字母、数字、下划线(常用手校验用户名和密码)
ChkUtil.isString6_20=function(str){
 var patrn=/^(\w){6,20}$/;
 return patrn.test(str);
};

------------------------------------------------------------------
调用示例


  <script type='text/javascript' src='./common.js'></script>
  <script type='text/javascript' src='./chkUtil.js'></script>
  <script type='text/javascript'>
   function $F(id){
      if(ChkUtil.isNull(id)){alert("函数$F()的参数不能为空");return false;}
      return document.getElementById(id).value;
   }
   function test(){
    var area=$F("area");
    if(area==false)return;
    alert(ChkUtil.isDate(area));//判断是否是合法日期
   }

发表时间:2006-10-28 13:01

posted @ 2006-11-15 13:50 javaGrowing 阅读(1699) | 评论 (0) | 编辑收藏

解决select菜单边框无法设置的问题

posted @ 2006-11-12 00:17 javaGrowing 阅读(250) | 评论 (0) | 编辑收藏

JSP文件下载及出现getOutputStream() has already been called for this response的解决方法(转载)

一、采用RequestDispatcher的方式进行

1、web.xml文件中增加

<mime-mapping>

<mime-type>application/vnd.ms-word</mime-type>

</mime-mapping>

2、程序如下：

<%@page language="java" import="java.net.*" pageEncoding="gb2312"%>
<%

response.setContentType("application/x-download");//设置为下载application/x-download

String filenamedownload = "/系统解决方案.doc";//即将下载的文件的相对路径

String filenamedisplay = "系统解决方案.doc";//下载文件时显示的文件保存名称

filenamedisplay = URLEncoder.encode(filenamedisplay,"UTF-8");

response.addHeader("Content-Disposition","attachment;filename=" + filenamedisplay);

try

{

RequestDispatcher dispatcher = application.getRequestDispatcher(filenamedownload);

if(dispatcher != null)

{

dispatcher.forward(request,response);

}

response.flushBuffer();

}

catch(Exception e)

{

e.printStackTrace();

}

finally

{

}

%>

二、采用文件流输出的方式下载

1、web.xml文件中增加

<mime-mapping>

<mime-type>application/vnd.ms-word</mime-type>

</mime-mapping>

2、程序如下：

<%@page language="java" contentType="application/x-msdownload" import="java.io.*,java.net.*" pageEncoding="gb2312"%>
<%

//关于文件下载时采用文件流输出的方式处理：

//加上response.reset()，并且所有的％>后面不要换行，包括最后一个；

//因为Application Server在处理编译jsp时对于％>和<％之间的内容一般是原样输出，而且默认是PrintWriter，

//而你却要进行流输出：ServletOutputStream，这样做相当于试图在Servlet中使用两种输出机制，

//就会发生：getOutputStream() has already been called for this response的错误

//详细请见《More Java Pitfill》一书的第二部分 Web层Item 33：试图在Servlet中使用两种输出机制 270

//而且如果有换行，对于文本文件没有什么问题，但是对于其它格式，比如AutoCAD、Word、Excel等文件

//下载下来的文件中就会多出一些换行符0x0d和0x0a，这样可能导致某些格式的文件无法打开，有些也可以正常打开。

response.reset();//可以加也可以不加

response.setContentType("application/x-download");//设置为下载application/x-download

// /../../退WEB-INF/classes两级到应用的根目录下去，注意Tomcat与WebLogic下面这一句得到的路径不同，WebLogic中路径最后没有/

System.out.println(this.getClass().getClassLoader().getResource("/").getPath());

String filenamedownload = this.getClass().getClassLoader().getResource("/").getPath() + "/../../系统解决方案.doc";

String filenamedisplay = "系统解决方案.doc";//系统解决方案.txt

filenamedisplay = URLEncoder.encode(filenamedisplay,"UTF-8");

response.addHeader("Content-Disposition","attachment;filename=" + filenamedisplay);

OutputStream output = null;

FileInputStream fis = null;

try

{

output = response.getOutputStream();

fis = new FileInputStream(filenamedownload);

byte[] b = new byte[1024];

int i = 0;

while((i = fis.read(b)) > 0)

{

output.write(b, 0, i);

}

output.flush();

}

catch(Exception e)

{

System.out.println("Error!");

e.printStackTrace();

}

finally

{

if(fis != null)

{

fis.close();

fis = null;

}

if(output != null)

{

output.close();

output = null;

}

%>

posted @ 2006-11-10 14:25 javaGrowing 阅读(1764) | 评论 (0) | 编辑收藏

javascript 操作 excel

posted @ 2006-11-09 21:24 javaGrowing 阅读(629) | 评论 (0) | 编辑收藏

解决Oracle 9i和Tomcat端口冲突(转载)

问题：
1、同时安装Desktop、Engine，Engine部分控件不能用，老是提示要授权。
2、将Desktop卸载，Engine大多数控件能用，少部分不能用。

问题关键：
Engine授权文件有问题。现在网上Engine9.0的授权文件版本太多了，但有些可以，有些是不能用的。其实我就是被这个问题所困，迟迟不能解决，现将可用的Engine9.0授权文件公布如下（绝对可用）：
3dengine,9,ecp379783729,none,D7MGJE2110L5J9HSX169
designer,9,ecp240010879,none,GB20C3RM03HXNTNE9005
gdbedit,9,ecp180013971,none,PMYP34S0PBAM2T8AG239
spatialengine,9,ecp339810398,none,8SJA84S0PDJ94P7EJ048
standardengine,9,ecp100001222,none,6PC42XLJH4C5LMZ59217
streetmapengine,9,ecp299948323,none,1JHDJK988L2MC2EN0146

解决方法：
1、安装Desktop，配置License Manager，过程我就不说了吧；
2、安装Engine，用以上授权文件注册。
3、此时部分控件仍然不能用。
4、请将license.dat中的Feature Designe项删除并保存，重启License Manager；
5、问题解决。

23:24 | 固定链接 | 引用通告 (0) | 记录它 | gis

2006/10/24

解决Oracle 9i和Tomcat端口冲突(转载)

方案一：
    新装了系统后，发现在调试程序时TOMCAT提示8080端口已被占用，于是运行NETSTAT -ANO查看端口使用情况，发现8080端口被ORACLE的监听器给占用了，于是结合上网查到方法，将ORACLE XDB的HTTP服务端口改成8081，问题解决。

总结一下可解决的方法：
一、更改TOMCAT的默认端口
     相关文件："TOMCAT ROOT"\conf\server.xml

二、使用sys登录Oracle，利用dbms_xdb修改端口设置
SQL> call dbms_xdb.cfg_update(updateXML(
    2        dbms_xdb.cfg_get()
    3      , '/xdbconfig/sysconfig/protocolconfig/httpconfig/http-port/text()'
    4      , 8081))
    5 /
    运行完后提示：Call completed.
接着
SQL> COMMIT;
    提示：Commit complete.
SQL> EXEC dbms_xdb.cfg_refresh;

提示：PL/SQL procedure successfully completed.

三、使用Enterprise Manager Console，选择数据库——XML 数据库——配置，更改http-port的默认值为8081。

方案二：
安装Oracle数据库后，当我们访问8080端口时，会弹出一个XDB窗口，要求输入用户名和密码。这样将和我们本地一些使用该端口的应用冲突，比如tomcat、jboss等，虽然这些端口是可以修改的，但总是不爽oracle一直占用这个端口。

Oracle数据库可以使用TCP协议通过8080端口进行连接，所以占用了8080端口。
要取消占用，可以打开Oracle安装目录下的database目录内的SPFILE[SID名].ORA文件进行修改。这个文件是Oracle的启动配置文件。
把其中的*.dispatchers='(PROTOCOL=TCP) (SERVICE=or9iXDB)'这一行去掉即可。
然后重启计算机，或者在服务中重启OracleService[SID名]这个服务。重启后可能无法使用Enterprise Manager Console和其他客户端连接，这时请使用Oracle的Configuration and Migration Tools/Net Configuration Assistant工具删除监听器，然后新建一个监听器，重启监听器。
使用Configuration and Migration Tools/Net Manager工具，将服务命名删除，然后新建一个。

现在Oracle应该就可以正常使用，8080也不会占用了。

补充：

其实这与服务的启动顺序有关，可以先把oracle监听器服务设为手动，tomcat设为自动，重启电脑，测试http://localhost:8080,这时可以看到大猫了，哈哈...

然后再把oracle监听器启动，就不会冲突了。

posted @ 2006-11-09 09:13 javaGrowing 阅读(596) | 评论 (1) | 编辑收藏

禁用jsp页面缓存

response.setHeader("Cache-Control","no-cache"); //HTTP 1.1

response.setHeader("Pragma","no-cache"); //HTTP 1.0

response.setDateHeader ("Expires", 0); //prevents caching at the proxy server

posted @ 2006-11-08 14:42 javaGrowing 阅读(1288) | 评论 (0) | 编辑收藏

hibernate双键关联解决办法

我的数据库结构是这样的：

点击图片可在新窗口打开

首先一开始我可以获得一个频道的channelId，我根据这个channelId得到一个首页区块的List，我在hibernate中配置homepagearea的加载方式，这样就可以通过homepage的到关联的栏目column(多对一关系)，然后我还是使用hibernate的自动加载，取到column关联的专题subject(一对多关系)。
这时候问题出来了，由于column到subject的关联没有带channel信息，所以，我取到的subject实际上是一个column下所有的subject，而我期望的是要得到，一个homepagearea下根据channelId和columnId取得的subject.

解决思路：
希望通过hibernate直接建立homepage和subject的1对多关联关系

解决方法
首先我改变原来利用工具生成的hibernate配置文件和entitybean
先列出原来的homepagearea的配置文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
<class
    name="com.easou.wapsearch.channel.entity.CsHomepageArea"
    table="CS_HOMEPAGE_AREA"
    schema="WAPUSER"
    lazy="true"
>
    <id
        name="id"
        type="long"
        column="ID"
        length="22"
    >
    <generator class="assigned">

    </generator>
    </id>
    <property
        name="createdBy"
        type="long"
        column="CREATED_BY"
        length="22"
    />
    <property
        name="createdDate"
        type="timestamp"
        column="CREATED_DATE"
        length="7"
    />
    <property
        name="isMore"
        type="long"
        column="IS_MORE"
        length="22"
    />
    <property
        name="name"
        type="string"
        column="NAME"
        length="50"
    />
    <property
        name="rowCount"
        type="long"
        column="ROW_COUNT"
        length="22"
    />
    <property
        name="showCount"
        type="long"
        column="SHOW_COUNT"
        length="22"
    />
    <property
        name="theOrder"
        type="long"
        column="THE_ORDER"
        length="22"
    />
    <property
        name="updateBy"
        type="long"
        column="UPDATE_BY"
        length="22"
    />
    <property
        name="updateDate"
        type="timestamp"
        column="UPDATE_DATE"
        length="7"
    />

<many-to-one
        name="csChannel"
    >
        <column name="CHANNEL_ID" length="22"/>
    </many-to-one>
    
    <many-to-one
        name="csColumn"
    >
        <column name="COLUMN_ID" length="22"/>
    </many-to-one>

</class>
</hibernate-mapping>

为了让homepagearea和subject形成一种一对多的关系，我增加的一个
<set name="csSubjects" inverse="true" cascade="save-update"
   lazy="false" order-by="THE_ORDER" table="CS_SUBJECT"
   outer-join="true">
   <key>
    <column name="CHANNEL_ID" index="CHANNEL_ID" />
    <column name="COLUMN_ID" index="COLUMN_ID" />
   </key>
   <one-to-many
    class="com.easou.wapsearch.channel.entity.CsSubject" />
</set>
但是由于hibernate一对多映射的一端必须是主键，而且我这里需要关联的还是2列信息，所以我还必须要修改配置文件的主键设置
<composite-id mapped="false" unsaved-value="none">
      <key-many-to-one name="csChannel" column="CHANNEL_ID"></key-many-to-one>
   <key-many-to-one name="csColumn" column="COLUMN_ID"></key-many-to-one>
</composite-id>
并且遮蔽掉原有的channel和column多对一关联关系，否则会报告重复错误
<!-- Associations
   bi-directional many-to-one association to CsChannel
  <many-to-one name="csChannel" lazy="true">
   <column name="CHANNEL_ID" length="22" />
  </many-to-one>
   bi-directional many-to-one association to CsColumn
  <many-to-one name="csColumn" lazy="true">
   <column name="COLUMN_ID" length="22" />
  </many-to-one>

-->
这样hibernate才会在加载homepagearea时自动把subject的关联信息也加载进来了

最后的homepagearea配置文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
<class name="com.easou.wapsearch.channel.entity.CsHomepageArea"
  table="CS_HOMEPAGE_AREA" schema="WAPUSER" lazy="true">
  <composite-id mapped="false" unsaved-value="none">
      <key-many-to-one name="csChannel" column="CHANNEL_ID"></key-many-to-one>
   <key-many-to-one name="csColumn" column="COLUMN_ID"></key-many-to-one>
  </composite-id>
  <property name="createdBy" type="long" column="CREATED_BY"
   length="22" />
  <property name="createdDate" type="timestamp"
   column="CREATED_DATE" length="7" />
  <property name="isMore" type="long" column="IS_MORE"
   length="22" />
  <property name="name" type="string" column="NAME" length="50" />
  <property name="rowCount" type="long" column="ROW_COUNT"
   length="22" />
  <property name="showCount" type="long" column="SHOW_COUNT"
   length="22" />
  <property name="theOrder" type="long" column="THE_ORDER"
   length="22" />
  <property name="updateBy" type="long" column="UPDATE_BY"
   length="22" />
  <property name="updateDate" type="timestamp"
   column="UPDATE_DATE" length="7" />

<!-- Associations
   bi-directional many-to-one association to CsChannel
  <many-to-one name="csChannel" lazy="true">
   <column name="CHANNEL_ID" length="22" />
  </many-to-one>
   bi-directional many-to-one association to CsColumn
  <many-to-one name="csColumn" lazy="true">
   <column name="COLUMN_ID" length="22" />
  </many-to-one>

  -->
  <set name="csSubjects" inverse="true" cascade="save-update"
   lazy="false" order-by="THE_ORDER" table="CS_SUBJECT"
   outer-join="true">
   <key>
    <column name="CHANNEL_ID" index="CHANNEL_ID" />
    <column name="COLUMN_ID" index="COLUMN_ID" />
   </key>
   <one-to-many
    class="com.easou.wapsearch.channel.entity.CsSubject" />

</set>

</class>

</hibernate-mapping>

经验总结：
1、本来使用hibernate的加载策略就是为了把一些业务逻辑直接融合在数据库关系当中，但是由于自己逻辑没有考虑清楚造成了加载时信息的丢失(而且我觉得我的表结构有问题，不知有有没有dba给我指点一下问题)。
2、hibernate的一对多关联关系多端是1端是针对主键的，所以不论你是关联的是1列2列还是3列，它们都应该是你的1端的主键或者联合主键(其实一对一，多对一，多对多的原理也是相似的)。

参考资料：hibernate_reference(3.2)

posted @ 2006-11-08 11:50 javaGrowing 阅读(374) | 评论 (0) | 编辑收藏

更改IE浏览器默认的源文件编辑器

用户在浏览网页时，如果在网页中单击鼠标右键并选择菜单中的“查看源文件”选项后，系统就会调用记事本打开该网页的HTML源文件，用户可以通过修改注册表来更改默认的打开程序，然后如下：
一：打开注册表。
“开始”菜单->“运行”->输入 regedit 然后点确定。
二：打开HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\INTERNET EXPLORER,在其下新建一个主键"View Source Editor",在其下再新一个主键"Editor Name",又击右侧窗口中的"默认"将数值设为更换程序的路径及文件名.

三:重新启动INTERNET EXPLORER,查看某个网页的源文件,用户就会发现打开的程序已经更改了.

posted @ 2006-11-06 20:19 javaGrowing 阅读(286) | 评论 (0) | 编辑收藏

提高网页的用户体验：字体大小的设计

现在国内绝大多数的站点都用CSS把字体大小设定为12px，像素虽然也是相对尺寸单位，但只是相对于屏幕的分辨率，当屏幕的分辨率一定时，如果你感到字太小，阅读有困难，在非标准浏览器中就无能为力了，所以说，如果把单位改成em，

那么就可以用CTRL+鼠标滚动把字放大，或者用菜单上的查看>文字大小来改变字的大小。

如何设定

1.在body标签里将字体尺寸设为62.5%，如果在body里没有CSS设定，那么浏览器默认的大小是16px，设了62.5%，则字体尺寸=16px*62.5%=10px，这时你能用em方便地设大小了，比如你需要用12px，只要设1.2em。

以下是引用片段：


body{}{ 

font-size:62.5%; 

} 

h1{}{ 

fong-size:1.4em;/**//*h1字的大小相当于14px*/ 

}

2.body里字体尺寸设为75%，则字体尺寸=16px*75%=12px，1em相当于12px.
以下是引用片段：
body{}{ 

font-size:75%; 

} 

h1{}{ 

fong-size:1.5em;/**//*h1字的大小相当于18px*/ 

}

第一种方法更好些。

如果是英文网站的话，还可以设定为small、x-small......

当然这样一来，对页面的设计要求会高一些。

posted @ 2006-11-06 17:40 javaGrowing 阅读(284) | 评论 (0) | 编辑收藏

禁止window.close()方法弹出的询问窗

< script language = " javascript " >

window.moveTo( 2000 , 2000 );

var para = window.location.search;

var width = screen.availWidth;

var height = screen.availHeight;

var arg = window.showModalDialog('ChooseEstate.htm' + para,window,'dialogWidth:' + width + 'px;dialogHeight:' + height + 'px;help: 0 ;');

window.close();

</ script >

－－－－使用以上代码，会弹出一个询问窗口，是否关闭当前窗口，我们只要稍做更改，就可避过这个机制：

< script language = " javascript " >

window.moveTo( 2000 , 2000 );

var para = window.location.search;

var width = screen.availWidth;

var height = screen.availHeight;

var arg = window.showModalDialog('ChooseEstate.htm' + para,window,'dialogWidth:' + width + 'px;dialogHeight:' + height + 'px;help: 0 ;');

window.opener = window; 或window.opener=null;

window.close();

</ script >

posted @ 2006-11-06 11:39 javaGrowing 阅读(459) | 评论 (0) | 编辑收藏

javascript中的编码与解码

javascript中可用的编码解码函数，有如下的组合：

escape(string);
unescape(string);
encodeURI(string);
decodeURI(string);
encodeURIComponent(string);
decodeURIComponent(string);

他们之间的区别为：

escape/unescape：
以16进制编码字符串，对空格、符号等字符用%xx编码表示，对中文等字符用%uxxxx编码表示。自javascript1.5之后，此方法已经不被推荐使用。

encodeURI/decodeURI：
以UTF-8编码编码字符串，对这些字符：“ ; , / ? : @ & = + $ ”不做编码。

encodeURIComponent/decodeURIComponent：
以UTF-8编码编码所有字符串。

因为escape/unescape已经deprecated。就不说它了，encodeURI和encodeURIComponent之前的区别用实例说明：

比如说要使用get方式将一个参数u，传递给服务器：

						
										var
								
						 u="index.php?blogId=1&op=Default";
						
										var
								
						 getURL="http://www.simplelife.cn/test.php?p="+encodeURI(u);

这里，如果使用了encodeURI，那么最终的getURL的值为：

						http://www.simplelife.cn/test.php?p=index.php?blogId=1&op=Default
				

这样，对参数u中的字符"&op=Default"，将不会作为字符串参数传递到服务器端，而是当作test.php的参数传递过去了，因为对"&op=Default"中的字符"&"没有做编码。
所以，在这种应用场景下，就需要使用encodeURIComponent，编码后的getURL值为：

						http://www.simplelife.cn/test.php?p=index.php%3FblogId%3D1%26op%3DDefault
				

这样，参数就可以顺利传递过去了。在服务器端得到的字符串将是正确的u。

反之，如果需要通过get方式访问某一URL，但是URL中包含中文等字符，为了防止乱码等编码问题，需要将URL通过encodeURI进行编码。

posted @ 2006-11-03 15:49 javaGrowing 阅读(16156) | 评论 (3) | 编辑收藏

javabean实现文件上传

请求分析
　　要实现文件上载，我们必须先了解上载文件的HTTP请求。下面这个简单的应用示范了如何上载文件以及把HTTP请求的原始数据写入文件。

用文本编辑器查看该文件即可了解请求的格式，在此基础上我们就可以提取出上载文件的名字、文件内容以及原本混合在一起的其他信息。

　　这个简单的应用是开发真正文件上载JavaBean的准备工作。它由三个文件构成：HTML文件main.html，JSP页面Jsp1.jsp，JavaBean文件SimpleBean.java。

　　main.html提供一个表单，用户从这里选择文件并把文件上载到服务器。main.html的代码如下：
<html>
<head>
<title>文件上载</title>
</head>
<body>
<form action="jsp1.jsp" enctype="MULTIPART/FORM-DATA" method=post>
作者: <input type="text" name="author" />
<br />
公司: <input type="text" name="company" />
<br />
选择要上载的文件 <input type="file" name="filename" />
<br />
<input type="submit" value="上载" />
</form>
</body>
</html>

　　可以看到，<form>标记有一个enctype属性，属性值是"MULTIPART/FORM-DATA"。包括提交按钮在内，表单里面共有4个输入元素。前面两个输入元素是普通的text元素，即author和company。第三个输入元素的type属性是file，这个输入元素就是用来选择文件的元素。

　　表单的action属性值是Jsp1.jsp，这意味着请求（包括上载的文件）将发送给Jsp1.jsp文件。Jsp1.jsp简单地调用名为SimpleBean的JavaBean。
<jsp:useBean id="TheBean" scope="page" class="SimpleBean " />
<%
TheBean.doUpload(request);
%>

下面是SimpleBean的实现代码：
import java.io.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletInputStream;

public class FileUploadBean {
public void doUpload(HttpServletRequest request) throws
IOException {
PrintWriter pw = new PrintWriter(
new BufferedWriter(new FileWriter("Demo.out")));
ServletInputStream in = request.getInputStream();
int i = in.read();
while (i != -1) {
pw.print((char) i);
i = in.read();
}
pw.close();
}
}

这个JavaBean把HttpServletRequest对象的表单原始数据写入Demo.out文件。应用的用户界面由main.html文件提供，如下图所示。

　　我们选择上载的文件是abisco.html。选择上载HTML文件是为了便于观察上载后的格式，因为HTML文件本质上是文本文件，我们可以方便地浏览其内容。abisco.html文件的内容如下：
<html>
<head>
<title>Abisco</title>
</head>
</html>
　　点击“上载”按钮之后，表单就发送给了Jsp1.jsp文件，一起发送的还有abisco.html文件。Jsp1.jsp文件不会向浏览器发送任何应答内容，但它会生成一个Demo.out文件。
　　打开Demo.out文件，我们可以看到如下内容：
-----------------------------7d15340138
Content-Disposition: form-data; name="Author"
A. Christie
-----------------------------7d15340138
Content-Disposition: form-data; name="Company"
Abisco
-----------------------------7d15340138
Content-Disposition: form-data; name="Filename"; filename="C:123dataabisco.html"
Content-Type: text/html
<html>
<head>
<title>Abisco</title>
</head>
</html>
-----------------------------7d15340138--
　　可以看到，HTTP请求体内包含了所有的表单输入，包括上载的文件。这些输入数据的分隔由一个分隔符实现。分隔符由一系列的“-”字符和一个随机数字构成。在上面的例子中，分隔符为“-----------------------------7d15340138”。最后一个分隔符结束请求体，这个分隔符的后面多出两个“-”符号。

　　对于非文件类型的输入数据，分隔符后面跟着下面这行内容：Content-Disposition: form-data; name=inputName。其中inputName是表单元素的名字。例如：Content-Disposition: form-data; name="Author"。在这行内容的后面，紧跟着两个连续的回车换行符和表单元素值。

　　而对于文件型输入域，分隔符的后面有两行内容。第一行内容包含输入元素的名字以及上载文件在客户端的完整路径，如上例中这行内容是“Content-Disposition: form-data; name="Filename"; filename="C:123dataabisco.html"”。这行内容指出文件输入元素的名字是filename，文件的路径是“C:123dataabisco.html”。注意Windows浏览器会设置文件路径，而Unix/Linux以及Mac浏览器只发送文件名字。

　　第二行包含了文件的内容类型，因此它的具体内容和上载的文件有关。本例中第二行的内容是“Content-Type: text/html”。

　　和非文件输入元素一样，文件内容在两个连续的回车换行符之后正式开始。

上载文件
　　众所周知，JavaBean是Java平台的软件组件，下面要实现的上载功能就是用JavaBean实现，所以它可以方便地应用到任何需要文件上载功能的应用之中。

代码清单如下：
package com.brainysoftware.web;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.ServletInputStream;
import java.util.Dictionary;
import java.util.Hashtable;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileUploadBean {
private String savePath, filepath, filename, contentType;
private Dictionary fields;

public String getFilename() {
return filename;
}

public String getFilepath() {
return filepath;
}

public void setSavePath(String savePath) {
this.savePath = savePath;
}

public String getContentType() {
return contentType;
}

public String getFieldValue(String fieldName) {
if (fields == null || fieldName == null)
return null;
return (String) fields.get(fieldName);
}

private void setFilename(String s) {
if (s==null)
return;
int pos = s.indexOf("filename="");
if (pos != -1) {
filepath = s.substring(pos+10, s.length()-1);
// Windows浏览器发送完整的文件路径和名字
// 但Linux/Unix和Mac浏览器只发送文件名字
pos = filepath.lastIndexOf("\");
if (pos != -1)
filename = filepath.substring(pos + 1);
else
filename = filepath;
}
}

private void setContentType(String s) {
if (s==null)
return;
int pos = s.indexOf(": ");
if (pos != -1)
contentType = s.substring(pos+2, s.length());
}

public void doUpload(HttpServletRequest request) throws IOException {
ServletInputStream in = request.getInputStream();
byte[] line = new byte[128];
int i = in.readLine(line, 0, 128);
if (i < 3)
return;
int boundaryLength = i - 2;
String boundary = new String(line, 0, boundaryLength); //-2丢弃换行字符
fields = new Hashtable();

while (i != -1) {
String newLine = new String(line, 0, i);
if (newLine.startsWith("Content-Disposition: form-data; name="")) {
if (newLine.indexOf("filename="") != -1) {
setFilename(new String(line, 0, i-2));
if (filename==null)
return;

//文件内容
i = in.readLine(line, 0, 128);
setContentType(new String(line, 0, i-2));
i = in.readLine(line, 0, 128);

//空行
i = in.readLine(line, 0, 128);
newLine = new String(line, 0, i);
PrintWriter pw = new PrintWriter(new BufferedWriter(new
FileWriter((savePath==null? "" : savePath) + filename)));
while (i != -1 && !newLine.startsWith(boundary)) {
// 文件内容的最后一行包含换行字符

// 因此我们必须检查当前行是否是最

// 后一行
i = in.readLine(line, 0, 128);
if ((i==boundaryLength+2 || i==boundaryLength+4)
&& (new String(line, 0, i).startsWith(boundary)))
pw.print(newLine.substring(0, newLine.length()-2));
else
pw.print(newLine);
newLine = new String(line, 0, i);
}
pw.close();
}
else {
// 普通表单输入元素
// 获取输入元素名字
int pos = newLine.indexOf("name="");
String fieldName = newLine.substring(pos+6, newLine.length()-3);
i = in.readLine(line, 0, 128);
i = in.readLine(line, 0, 128);
newLine = new String(line, 0, i);
StringBuffer fieldValue = new StringBuffer(128);
while (i != -1 && !newLine.startsWith(boundary)) {
// 最后一行包含换行字符
// 因此我们必须检查当前行是否是最后一行
i = in.readLine(line, 0, 128);
if ((i==boundaryLength+2 || i==boundaryLength+4)
&& (new String(line, 0, i).startsWith(boundary)))
fieldValue.append(newLine.substring(0, newLine.length()-2));
else
fieldValue.append(newLine);
newLine = new String(line, 0, i);
}
fields.put(fieldName, fieldValue.toString());
}
}
i = in.readLine(line, 0, 128);
}
}
}
　　代码的第一行是包声明，如果你不想让该类从属于任何包，可以删除这行代码。接下来的几行代码声明了该JavaBean所要引用的各个类和接口。
　　FileUploadBean类有5个私有的属性（域），6个公用的方法，2个私有的方法。

属性
FileUploadBean类的5个域都是私有的，它们是：
private String savePath

该域指定了文件上载后保存到服务器的哪一个路径。savePath的值用setSavePath方法设置。这个值应该在调用doUpload方法之前设置；如没有设置，上载后的文件将保存到服务器的默认目录。

private String filepath
该域指定了上载文件在客户端的完整路径。filepath的值由doUpload方法设置，在JSP页面或者Servlet中调用getFilepath方法可以获取filepath域的值。对于非Windows下的浏览器，该值等于filename。

private String filename
该域是上载文件的名字。filename的值由setFilename方法设置。在JSP或者Servlet中调用getFilename方法可以获取filename域的值。

private String contentType
该域是上载文件的内容类型。contentType的值由doUpload方法设置，你可以用getContentType方法获得contentType域的值。

private Dictionary fields
fields域保存了用户在表单中输入数据的名字/值对。调用getFieldValue方法可以获取表单输入元素的值。

方法
　　前面四个public类型的方法用于返回FileUploadBean对象的私有域，它们是：getFilepath，getFilename，getContentType以及getFieldValue。

public String getFilepath()
返回filepath私有域的值。

public String getFilename()
返回filename私有域的值。

public String getContentType()
返回contentType私有域的值。

public String getFieldValue(String fieldName)
返回HTML表单中指定输入元素的值，元素的名字通过fieldName参数指定。

public void setSavePath(String savePath)
用该方法指定服务器上保存上载文件的目录的名字。

public void doUpload(HttpServletRequest request) throws IOException
doUpload是FileUploadBean类中最重要的一个方法。它的任务有二个：第一，它从HTML表单提取出输入域的名字和值并保存到Dictionary对象；第二，doUpload方法提取出上载的文件，把这个文件保存到savePath指定的路径，并分别把文件的名字、路径、内容类型赋给filename、filepath和contentType域。

private void setContentType(String s)
由doUpload方法调用。setContentType方法从原始字节数据提取出上载文件的内容类型。

private void setFilename(String s)
由doUpload方法调用。setFilename方法从原始字节数据提取出文件路径和名字。
　　doUpload方法的参数是Servlet/JSP容器创建的HttpServletRequest对象。HttpServletRequest对象描述了程序为了提取出HTML表单元素名字-值对以及上载文件必须处理的HTTP请求。doUpload方法首先通过HttpServletRequest对象的getInputStream方法获得ServletInputStream对象。

　　如前所述，每一个表单元素由分界符和一组回车换行符分隔。因此，我们可以一行一行地读入HttpServletRequest对象的内容。下面这行代码定义了一个名为line的byte数组：
byte[] line = new byte[128];

　　然后，我们用ServletInputStream对象的readLine方法读入HttpServletRequest对象内容的第一行：
int i = in.readLine(line, 0, 128);

　　第一行应该是分界符，而且如果没有错误的话，它的长度应该大于3。如果它的长度小于3，我们可以认为出现了错误，doUpload方法应该立即返回：
if (i < 3)
return;

　　分界符和分界符的长度都非常重要，从本文后面你可以看到这一点。分界符由一组回车换行符结束，因此它的实际长度要比readLine方法返回的字节数少2。

int boundaryLength = i - 2;
　　丢弃byte数组line的最后2个回车换行符即可获得分界符：

String boundary = new String(line, 0, boundaryLength);
　　接下来，fields域被实例化成Hashtable对象。这个Hashtable对象将用来保存HTML表单元素的名字/值对。

fields = new Hashtable();
　　由于已经有了分界符，接下来我们就可以开始提取出表单元素的值。具体方法是用一个while循环按行读入HttpServletRequest对象的内容，直至遇到内容结束readLine方法返回-1为止。所有的表单元素都以分界符开始，后面跟上“Content-Disposition”行，这一行由下面这些字符开始：

Content-Disposition: form-data; name=
　　表单元素有两种类型：文件，非文件（普通的表单元素，如TEXT或者HIDDEN元素）。这两种表单元素的区别在于文件元素包含字符串“filename="filename"”。由此，我们可以利用该信息把文件和非文件的表单输入元素区别开来，代码如下：
if (newLine.startsWith("Content-Disposition: form-data; name="")) {
if (newLine.indexOf("filename="") != -1) {

// 文件型表单输入元素
// 这里加上提取文件的代码
. . .
}
else {
// 普通表单输入元素
// 这里加上提取表单元素的代码
. . .
}
}

　　现在，我们首先来看看提取文件内容的代码。
　　文件路径包含在“Content-Disposition”的后面。为提取文件路径和文件名字，doUpload方法调用了setFilename私有方法。setFilename方法提取出文件路径和文件名字信息，然后把它们赋值给filepath和filename域。调用setFilename方法之后，filename域应该不再是null。如果此时filename域仍旧是null，则说明遇到了问题，doUpload方法直接返回。

if (filename==null)
return;

　　“Content-Disposition”行之后的下一行是内容类型行。因此，doUpload方法接着调用readLine方法，然后调用setContentType私有方法。setContentType方法和setFilename方法相似，它从原始字节数据中提取出上载文件的内容类型并保存到contentType域。

　　紧接内容类型行的下一行是空行，因此程序再调用了一次readLine方法。

i = in.readLine(line, 0, 128);
　　接下来开始了真正的文件内容。我们先应该做好通过PrintWriter对象把文件写入磁盘的准备。

PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(( savePath==null? "" : savePath ) + filename)));

　　上载文件保存到哪个位置取决于savePath域是否已经设置。如果savePath域没有设置，它的值是null，则文件将被保存到默认目录；如果savePath域已经设置，它的值不是null，则上载的文件被保存到它所指定的目录。

　　然后我们就可以提取文件的内容。具体方法是使用while循环，每次循环读入一行内容并通过PrintWriter的输出方法把它写入磁盘。但我们知道，文件的最后一行包含两个回车换行符号，所以保存到磁盘的字节数据不应该包含这两个字符。因此，如果读入的行不是文件的最后一行，我们把所有读到的字节数据写入磁盘；如果读入的行已经是文件的最后一行，写入磁盘的字节数据要减去最后两个字符。

　　然而，我们并不知道文件的大小，我们只知道紧接文件内容的下一行又是一个分界符；或者，如果文件是最后一个HTML表单元素，接下来的一行是分界符加上两个短划线字符。因此，只要检查下一行内容是否是分界符，我们就知道了何时应该结束while循环。这就是前面说分界符很重要的原因，在这里我们必须用到分界符。

　　虽然我们可以读取下一行内容然后用startsWith方法检查它是否是一个分界符，然而，由于字符串操作的开销非常大，为了减少字符串操作，我们比较readLine读入的字节数组的长度。后者应该等于boundaryLength + 2；或者，如果它是HttpServletRequest对象中的最后一行，由于多出了最后两个短划线字符，它应该等于boundaryLength + 4。由于一行内容即使不是分界符也可以和分界符一样长，当长度匹配之后我们又将它与分界符比较。这就是前面提到boundaryLength很重要的原因了。

　　整个处理过程的实现代码如下：
while (i != -1 && !newLine.startsWith(boundary)) {
i = in.readLine(line, 0, 128);
if ((i==boundaryLength+2 || i==boundaryLength+4) && (new String(line, 0, i).startsWith(boundary)))
pw.print(newLine.substring(0, newLine.length()-2));
else pw.print(newLine);

newLine = new String(line, 0, i);
}

　　把文件内容保存到磁盘之后，我们关闭了PrintWriter。
pw.close();
非文件的表单元素也可以用类似的方法提取。不同之处在于，此时我们不再把数据写入磁盘，而是把名字-值对保存到Dictionary对象。

fields.put(fieldName, fieldValue.toString());

应用实例
　　编译好Bean之后，我们就可以从Servlet或者JSP页面中使用它了。可能你在Tomcat之类的Servlet/JSP环境下使用Bean，部署Bean最简单的方法是把class文件压缩成jar文件，然而把jar文件放到Tomcat的lib目录下。要让Tomcat装入jar文件，你必须重新启动Tomcat。

　　下面是一个HTML文件和一个JSP文件，它们示范了这个Bean的应用。HTML文件包含一个表单以及几个输入元素：
<html>
<head>
<title>文件上载</title>
</head>
<body>
<form action=jsp1.jsp enctype="MULTIPART/FORM-DATA" method=post>
作者: <input type=text name=author>
<br>
公司: <input type=text name=company>
<br>
说明: <textarea name=comment></textarea>
<br>
选择要上载的文件<input type=file name=filename>
<br>
文件描述: <input type=text name=description>
<br>
<input type=submit value="Upload">
</form>
</body>
</html>

　　用户提交上述表单之后，该HTTP请求将由Jsp1.jsp处理。Jsp1.jsp运用FileUpload这个Bean来处理请求。Jsp1.jsp的代码如下：
<%@ page contentType="text/html;charset=gb2312"%>
<jsp:useBean id="TheBean" scope="page"
class="com.brainysoftware.web.FileUploadBean" />
<%
TheBean.doUpload(request);
out.println("Filename:" + TheBean.getFilename());
out.println("<BR>内容类型:" + TheBean.getContentType());
out.println("<BR>作者:" + TheBean.getFieldValue("Author"));
out.println("<BR>公司:" + TheBean.getFieldValue("Company"));
out.println("<BR>说明:" + TheBean.getFieldValue("Comment"));
%>

posted @ 2006-11-03 13:12 javaGrowing 阅读(1247) | 评论 (0) | 编辑收藏

Oracle智能代理与OMS的问题(智能代理启动不了)

解决：

1.删除%oracle_home%\network\agent\*.Q
2.重新启动服务即可
c:\agentctl start

解释：
OracleOraHome90Agent服务如果不能启动，则OIA也就不能运行，OIA不能运行则无法实现在OMS登陆后的Intelligent Agent节点搜索功能，如果不是Intelligent Agent自动搜索的节点，而是手动搜索配置的节点，则登陆OMS后无法使用诸多OMS提供的GUI功能，例如数据备份和数据导入/导出等。

而由于OracleOraHome90Agent服务的启动和Oracle安装时的机器名域名等密切相关，造成后来改动机器名后，OracleOraHome90Agent总是无法启动，疑惑了很久，查了很多资料，都没能解决这个问题，于是抱着试试看的心情，在Google上以“OracleOraHome92Agent”为关键字搜索，结果就出现了最上面所提供的解决方案，真是踏破铁鞋无觅处，得来全不费功夫阿！看了那些*.Q的二进制文件，估计是Agent在安装时的配置信息，在机器名发生变动后，启动OracleOraHome90Agent服务时，OracleOraHome90Agent要读取这些二进制文件中的配置信息，配置文件中的机器名与现在的机器名不符合，造成了OracleOraHome90Agent不能启动，将这些配置文件全部删除，然后用命令行agentctl start从新启动OracleOraHome90Agent，则会从新将现有的最新机器名写入到配置信息，并从新创建这些配置文件，因而问题得到解决。

总结：

Oracle对服务器机器名，域名等信息高度依赖，所以如无特殊要求，在Oracle数据库安装后，不要轻易修改机器名和域名等相关信息，不然可能会造成很多不必要的麻烦。

posted @ 2006-10-26 11:13 javaGrowing 阅读(318) | 评论 (0) | 编辑收藏

通过oms实现Oracle的数据备份

在oracle 9i中可以方便的把数据导出为文件，或者从文件导入。通过oracle的管理服务器（oracle management server，oms）可以方便的实现，整个操作过程中有很多地方需要解释说明，但是完整的指导资料不多。各大论坛上很多所谓的高手，对该主题的回答往往是，高手是不用oms的，用exp/impl吧。如果你执意追问，他多半会告诉你，其实我也不知道。如果有一份文档可以傻瓜式的指导他们如何来做，大多数人会欣喜若狂且若无其事的下载保存，回去慢慢研究。对于这样自以为高手的人，只送他们两个字：鄙视。

　使用Enterprise Manager Console登陆的时候，会有两个选项：独立启动和登陆到Oracle Management Server。前者可以让我们执行一些普通的管理工作，比如管理帐户、数据库对象等，只有后者才能为我们提供备份的功能。不过在登陆到oms之前，你必须首先安装oms服务。

　　启动oracle universal installer，查看已安装产品，展开oracle主目录--oraHome92，如果没有oracle9i management and integration，表示你尚未安装。安装方法是：

　　在oracle universal installer的可用产品列表中，选择安装oracle 9i management and integration?oracle management server即可。

　　安装完成后，你需要配置一个管理资料库，启动：Configuration and Migration tools-Enterprise Manager Configuration Assistant。在配置操作中选择配置本地的oracle management server-创建一个新的资料库档案-典型。系统将会创建一个名为oemrep的数据库，保存管理信息，其中你需要指定sys和system帐号的密码。

　　安装完成后，启动manage server服务，windows下你可以到后台服务中直接启动，它的名字是OracleOraHome92ManagementServer。同时请保证其他自动启动的oracle服务也是启动的。

　　然后可以用Enterprise Manaer Console登陆了，帐号sysman 密码oem_temp。第一次登陆后系统会要求你输入新的sysman密码。如果在登陆的时候出现”身份证明不正确”的提示，请确认你使用的登陆帐号是 sysman，如果帐号无误却始终出现该错误，请删除刚才建立的资料库，重新建一个。

　　如果你使用windows，备份数据之前，首先需要建立一个操作系统的用户，专门用于oracle备份，比如建立用户oracle_back，隶属于Administrator组和ora_dba组。然后需要在本地策略中给该用户赋一个批处理权限。方法是：

　　控制面板-管理工具-本地安全策略-本地策略-用户权利指派-作为批处理作业登陆，在该权限下面增加刚才建立的oracle_back用户。

　　回到Enterprise Manager Console，打开配置?首选项?首选身份证明，在目标名中找到你的机器名，同时它的目标类型为节点，在下面的身份证明中输入oracle_back和它的密码。然后找到你要备份的数据库名，它的目标类型是数据库，在身份证明中输入dba帐号。Ok，现在你可以备份数据了。在任意一张表中点右键，选择数据管理?导出，你就可以在作业中看到这个任务。

posted @ 2006-10-19 16:19 javaGrowing 阅读(301) | 评论 (0) | 编辑收藏

Tomcat5下server.xml的翻译

<Server port="8005" shutdown="SHUTDOWN" debug="0">

  
  

  
  

  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"
            debug="0"/>
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"
            debug="0"/>

  
  
  <GlobalNamingResources>

    
    
    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>

    
    

    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
       description="User database that can be updated and saved">
    </Resource>
    <ResourceParams name="UserDatabase">
      <parameter>
        <name>factory</name>
        <value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>
      </parameter>
      <parameter>
        <name>pathname</name>
        <value>conf/tomcat-users.xml</value>
      </parameter>
    </ResourceParams>

  </GlobalNamingResources>

  
  

  
  
  <Service name="Catalina">

    
    

    
    
    <Connector port="8080"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               debug="0" connectionTimeout="20000"
               disableUploadTimeout="true" />
    
    




    
    
    

    
    
    <Connector port="8009"
               enableLookups="false" redirectPort="8443" debug="0"
               protocol="AJP/1.3" />

    
    
    
    
    

    
    

    
    

    
    
    <Engine name="Catalina" defaultHost="localhost" debug="0">

      
      
      

      
      
      <Logger className="org.apache.catalina.logger.FileLogger"
              prefix="catalina_log." suffix=".txt"
              timestamp="true"/>

      
      

      
      
      
      

      
      

      

      

      

      
      
      <Host name="localhost" debug="0" appBase="webapps"
       unpackWARs="true" autoDeploy="true"
       xmlValidation="false" xmlNamespaceAware="false">

        
        
        

        
        

        

        
        
        

        
        <!-- 与这个虚拟主机有关系所有上下文所共享的日志。默认情况下（使用FileLogger时），
             日志文件被创建在相对于$CATALINA_HOME目录下的logs目录下。如果你希望，你也可
             以给directory指定一个不同的路径。可以使用相对于$CATALINA_HOME的相对路径，也
             可以使用绝对路径。
        <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs" prefix="localhost_log." suffix=".txt"
            timestamp="true"/>

      </Host>

    </Engine>

  </Service>

</Server>

posted @ 2006-10-17 14:47 javaGrowing 阅读(360) | 评论 (0) | 编辑收藏

Tomcat Class Loader HOW-TO

当Tomcat5启动以后，它创建一系列类加载器。这些类加载器以父子关系组织在一起，父类加载器在子类加载器的上面：

      Bootstrap
          |
       System
          |
       Common
      /      \
Catalina   Shared
                   /   \
        Webapp1 Webapp2 ...

这些类加载器所扮演的角色，以及它们可以见到的类和资源的规则如下：

如上图所示，Tomcat5 在初始化的时候创建如下类加载器：

Bootstrap - 这个类加载器可以加载Java虚拟机的运行时基础类，以及在系统扩展目录($JAVA_HOME/jre/lib/ext)中的所有Jar包中的类。注意－一些JVM可能用多个类加载器来实现它，或者它是根本不能被看见的。

System - 这个类加载器一般可以加载CLASSPATH环境变量的内容。所有这个类对于Tomcat内部的类和web应用程序的都是可见的。尽管如此，标准的Tomcat5启动脚本($CATALINA_HOME/bin/catalina.sh 或 %CATALINA_HOME%\bin\catalina.bat)都会忽略CLASSPATH环境变量，取而代之的是从如下仓库加载：

$CATALINA_HOME/bin/bootstrap.jar - 包含Tomcat5 服务器初始化的main()方法，以及所需的类加载器的实现类。
$JAVA_HOME/lib/tools.jar - 包括把JSP页面编译成Serlet类所需的"javac"编译器.
$CATALINA_HOME/bin/commons-logging-api.jar - Jakarta commons logging API.
$CATALINA_HOME/bin/commons-daemon.jar - Jakarta commons daemon API.
jmx.jar - The JMX 1.2 实现.

Common - 这个类加载器可以使一些附加的类对于Tomcat 内部的类和web应用程序可见。正常情况下，应用程序不应该替换它。所有$CATALINA_HOME/common/classes目录下的未打包类和资源，以及$CATALINA_HOME/commons/endorsed、$CATALINA_HOME/commons/i18n、$ CATALINA_HOME/common/lib目录下的Jar包中的类和资源都是这个类加载器的加载对象。默认情况，包括如下内容：

commons-el.jar - Jakarta commons el, Jasper用的EL表达式实现
jasper-compiler.jar - The JSP 2.0 编译器.
jasper-compiler-jdt.jar - The Eclipse JDT Java 编译器.
jasper-runtime.jar - The JSP 2.0 运行库.
jsp-api.jar - The JSP 2.0 API.
naming-common.jar - Tomcat5的JNDI 实现，用于内存命名环境
naming-factory.jar - Tomcat5的JNDI 实现，用于企业级资源引用(EJB, connection pools).
naming-factory-dbcp.jar - Jakarta commons DBCP, 为Web应用程序提供JDBC连接池。这个类已经从默认的org.apache.commons包中移出。
naming-java.jar - java命名空间处理器.
naming-resources.jar - The specialized JNDI naming context implementation used to represent the static resources of a web application. This is not related to the support of the J2EE ENC, and cannot be removed.
servlet-api.jar - The Servlet 2.4 API.
tomcat-i18n-**.jar - Optional JARs containing resource bundles for other languages. As default bundles are also included in each individual JAR, they can be safely removed if no internationalization of messages is needed.

Catalina - 这个类加载器主要加载Tomcat5自己所需要的类和资源。这些类和资源对于Web应用程序是完全不可见的。在$CATALINA_HOME/server/classes目录下的所有类和资源，$CATALINA_HOME/server/lib下的所有Jar包中类和资源是这个类加载器的加载对象。默认情况，包括个如下内容：

catalina.jar - Tomcat5中Catalina Servlet容器的实现部分。
catalina-ant.jar - 在管理web应用程序时要用倒的一些Ant任务。
catalina-optional.jar - 一些Catalina可选组件。
commons-modeler.jar - Tomcat通过JMX暴露其内部对象是用的一些MBean实现。
servlets-xxxxx.jar - 这些类同内部的Servlet一起提供Tomcat的部分功能，它们都是独立的，所以如果不需要相应的服务可以将其删除。或者它们可以从属于特定的安全管理器。
tomcat-coyote.jar - Coyote API.。
tomcat-http.jar - 标准的Java HTTP/1.1 连接器.。
tomcat-ajp.jar - AJP web 服务器的连接器，一般用于Apache，iPlanet iAS和 iWS.。
tomcat-util.jar - Tomcat连接器需要的工具类。

Shared - 这个类加载器用于把一些类和资源共享给所有的web应用程序。(除非Tomcat内部的类也需要访问这些类，在这种情况下你应该把它们放在Common类加载能加载的地方). 在$CATALINA_BASE/shared/classes 目录下的所有未打包类和资源，以及$CATALINA_BASE/shared/lib目录下的所有Jar包中的类和资源可以被其加载。如果通过$ CATALINA_BASE环境变量来从同一个tomcat程序运行了多个在实例，那么这个类加载器的仓库是相对于$CATALINA_BASE而不是$ CATALINA_HOME。

WebappX - 系统会为部署在一个Tomcat实例中的每个应用程序创建一个这样的类加载器，它们为所属的应用程序加载类。所有你的web应用程序包的/WEB-INF/classes目录下的类和资源，以及
/WEB-INF/lib 目录下的所有Jar包中的类和资源是这个类的加载对象。这些类和资源仅对这个应用程序可见，并且这个应用程序也看不见其他应用程序的类和资源。

就像上面所描述的，web应用程序的类加载的加载流程与默认的Java 2的类记载托管模型是不一样的。当有一个请求需要应用程序的WebappX 类加载器加载一个类的时候，这个类加载器是首先到自己的仓库中查找，而不是先交给上面的类加载器查找。这里有一些例外。JRE的基础类是不能被覆盖的。对于其他一些类（如J2SE 1.4+中的XML解析器组件），可以使用J2SE1.4的签名特性。最后任何包括servlet API类的Jar包会被忽略。Tomcat5中的其他的类加载器使用正常托管模式。

这样在一个web应用程序中，类和资源的加载顺序是这样：

Bootstrap classes of your JVM
System class loader classses (described above)
/WEB-INF/classes of your web application
/WEB-INF/lib/*.jar of your web application
$CATALINA_HOME/common/classes
$CATALINA_HOME/common/endorsed/*.jar
$CATALINA_HOME/common/i18n/*.jar
$CATALINA_HOME/common/lib/*.jar
$CATALINA_BASE/shared/classes
$CATALINA_BASE/shared/lib/*.jar

posted @ 2006-10-17 14:43 javaGrowing 阅读(390) | 评论 (0) | 编辑收藏

CSS选择符

一.选择符模式
模式/含义/内容描述

*
匹配任意元素。(通用选择器)
E
匹配任意元素 E (例如一个类型为 E 的元素)。(类型选择器)
E F
匹配元素 E 的任意后代元素 F 。(后代选择器)
E > F
匹配元素 E 的任意子元素 F 。(子选择器)
E:first-child
当元素 E 是它的父元素中的第一个子元素时，匹配元素 E 。(:first-child 伪类)
E:link E:visited
如果 E 是一个目标还没有访问过(:link)或者已经访问过(:visited)的超链接的源锚点时匹配元素 E 。(link 伪类)
E:active E:hover E:focus
在确定的用户动作中匹配 E 。(动态伪类)
E:lang(c)
如果类型为 E 的元素使用了(人类)语言 c (文档语言确定语言是如何被确定的)，则匹配该元素。(:lang() 伪类)
E + F
如果一个元素 E 直接在元素 F 之前，则匹配元素 F 。(临近选择器)
E[foo]
匹配具有”foo”属性集(不考虑它的值)的任意元素 E 。(属性选择器)
E[foo="warning"]
匹配其“foo”属性值严格等于“warning”的任意元素 E 。(属性选择器)
E[foo~="warning"]
匹配其“foo”属性值为空格分隔的值列表，并且其中一个严格等于“warning”的任意元素 E 。(属性选择器)
E[lang|="en"]
匹配其“lang”属性具有以“en”开头(从左边)的值的列表的任意元素 E 。(属性选择器)
DIV.warning
仅 HTML。用法同 DIV[class~="warning"]。(类选择器)
E#myid
匹配 ID 等于“myid”的任意元素 E 。(ID 选择器)
Quote
From：http://www.w3.org/TR/CSS2/selector.html
我们用下面的例子来解释“父元素”、“子元素”、“父/子”及“相邻”这几个概念。
<div title="这是一个div">
<h1>这是是h1的内容</h1>
<p>这是一个段落p的内容！<strong>这里是strong的内容</strong>这是一个段落p的内容！</p>
</div>
从以上代码中，我们可以找出这样的关系：
h1 和 p 同为 div 的“儿子”，两者分别同 div 形成“父/子”关系。
h1,p,strong 都是 div 的“子元素”。（三者都包含在 div 之内）
div 是 h1 和 p 的“父元素”。
strong 和 p 形成“父/子”关系，strong 的“父元素”是 p 。
但 strong 和 div 并非“父/子”关系，而是“祖孙”关系，但 strong 依然是 div 的“子（孙）元素”。
div 是 h1 p strong 三者的“祖先”，三者是 div 的“子（孙）元素”。
h1 和 p 两者是相邻的。
继承上面的实例来具体演示一下E F的关系：假如，我们需要将 strong 内的内容二字变为绿色，我们可以有哪些方法呢？

div strong {color:green;} /* －正确。strong 是 div 的“子元素”*/
p > strong {color:green;} /* －正确。strong 和 p 是“父/子”关系*/
div > strong {color:green;} /* －错误！strong 虽然是 div 的“子（孙）元素”，但两者乃是“祖孙”关系，而非“父/子”关系，因此不能用 > 符号连接*/

临近选择器和通用选择器：通用选择器以星号“*”表示，可以用于替代任何 tag 。
实例：

h2 + * { color:green }/*所有紧随 h2 的元素内的文字都将呈现红色*/

二.选择符分类介绍

1.通配选择符
语法：
* { sRules }
说明：
通配选择符。选定文档目录树(DOM)中的所有类型的单一对象。
假如通配选择符不是单一选择符中的唯一组成，“*”可以省略。
示例：
*[lang=fr] { font-size:14px; width:120px; }
*.div { text-decoration:none; }

2.类型选择符
语法：
E { sRules }
说明：
类型选择符。以文档语言对象(Element)类型作为选择符。
示例：
td { font-size:14px; width:120px; }
a { text-decoration:none; }
3.属性选择符
语法：
E [ attr ] { sRules }
E [ attr = value ] { sRules }
E [ attr ~= value ] { sRules }
E [ attr |= value ] { sRules }
说明：
属性选择符。
选择具有 attr 属性的 E
选择具有 attr 属性且属性值等于 value 的 E
选择具有 attr 属性且属性值为一用空格分隔的字词列表，其中一个等于 value 的 E 。这里的 value 不能包含空格
选择具有 attr 属性且属性值为一用连字符分隔的字词列表，由 value 开始的 E
示例：
h[title] { color: blue; }
/* 所有具有title属性的h对象 */

span[class=demo] { color: red; }

div[speed="fast"][dorun="no"] { color: red; }

a[rel~="copyright"] { color:black; }
4.包含选择符
语法：
E1 E2 { sRules }

说明：
包含选择符。选择所有被 E1 包含的 E2 。即 E1.contains(E2)==true 。
示例：
table td { font-size:14px; }

div.sub a { font-size:14px; }
5.子对象选择符
语法：
E1 > E2 { sRules }
说明：
子对象选择符。选择所有作为 E1 子对象的 E2 。
示例：
body > p { font-size:14px; }
/* 所有作为body的子对象的p对象字体尺寸为14px */

div ul>li p { font-size:14px; }
6.ID选择符
语法：
#ID { sRules }

说明：
ID选择符。以文档目录树(DOM)中作为对象的唯一标识符的 ID 作为选择符。
示例：
#note { font-size:14px; width:120px;}
7.类选择符
语法：
E.className { sRules }
说明：
类选择符。在HTML中可以使用此种选择符。其效果等同于E [ class ~= className ] 。请参阅属性选择符( Attribute Selectors )。
在IE5+，可以为对象的 class 属性(特性)指定多于一个值( className )，其方法是指定用空格隔开的一组样式表的类名。例如：<div class="class1 class2">。
示例：
div.note { font-size:14px; }
/* 所有class属性值等于（包含）"note"的div对象字体尺寸为14px */

.dream { font-size:14px; }
/* 所有class属性值等于（包含）"note"的对象字体尺寸为14px */

8.选择符分组
语法：
E1 , E2 , E3 { sRules }
说明：
选择符分组。将同样的定义应用于多个选择符，可以将选择符以逗号分隔的方式并为组。
示例：
.td1,div a,body { font-size:14px; }
td,div,a { font-size:14px; }

9.伪类及伪对象选择符

语法：
E : Pseudo-Classes { sRules }
E : Pseudo-Elements { sRules }
说明：
伪类及伪对象选择符。
伪类选择符。请参阅伪类( Pseudo-Classes )[:link :hover :active :visited :focus :first-child :first :left :right :lang]。
伪对象选择符。请参阅伪对象( Pseudo-Elements )[:first-letter :first-line :before :after]。
示例：
div:first-letter { font-size:14px; }
a.fly :hover { font-size:14px; color:red; }

posted @ 2006-09-14 18:22 javaGrowing 阅读(161) | 评论 (0) | 编辑收藏

提高eclipse运行速度

在1g内存下.用这个参数很管用. 速度感觉加快

eclipse.exe -vmargs -xverify:none -xx:+useparallelgc -xx:permsize=20m -xms64m -xmx512m

posted @ 2006-08-23 16:21 javaGrowing 阅读(228) | 评论 (0) | 编辑收藏

XML DOM - The Document Object

The Document object is the root-node of a document. All nodes in a node-tree are childnodes of the Document object.

Examples

We will use the following XML document in the examples below: note.xml.

documentElement - Return the node name of the root element

createElement() - Create a new element

createTextNode() - Create a new text node

createCDATASection() - Create a new CDATA node

createComment() - Create a new comment node

getElementsByTagName() - Return the value of a specified node

The Document object

The Document object represents the entire XML document.

The Document object is the root-node of a document. All nodes in a node-tree are childnodes of the Document object.

A node can be an element node, an attribute node, a text node, or any other of the node types explained in the "Node types" chapter.

IE: Internet Explorer, F: Firefox, N: Netscape, W3C: World Wide Web Consortium (Internet Standard)

Document Object Properties

Property	Description	IE	F	N	W3C
async	Specifies whether downloading of an XML file should be handled asynchronously or not. True means that the load() method returns the control to the caller before the download is complete. False means that the download must be completed before the caller gets the control back	5	-	-	No
attributes	Returns a NamedNodeMap that contains all attributes of a node	5	1	6	No
baseName	Returns the name of a node (without namespaces)	5	-	-	No
childNodes	Returns a node list that contains all children of a node	5	1	6	No
dataType	Returns the data type of a node	5	-	-	No
definition	Returns the definition of a node in the DTD/Schema	5	-	-	No
doctype	Returns the DTD or Schema for the document	6	1	6	Yes
documentElement	Returns the root element of the document	5	1	6	Yes
firstChild	Returns the first child node of a node	5	1	6	No
implementation	Returns the DOMImplementation object for this particular document	6	1	6	Yes
lastChild	Returns the last child node of a node	5	-	-	No
namespaceURI	Returns the URI of the namespace	5	1	6	No
nextSibling	Returns the node immediately following a node. Two nodes are siblings if they have the same parent node	5	1	6	No
nodeName	Returns the name of the node	5	1	6	No
nodeType	Returns the node type as a number	5	1	6	No
nodeTypedValue	Returns the value of a node expressed in its defined data type	5	-	-	No
nodeTypeString	Returns the node type as a string	5	-	-	No
nodeValue	Returns the value of the node	5	1	6	No
ownerDocument	Returns the Document object of a node (returns the root node of the document)	5	1	6	No
parentNode	Returns the parent node of a node	5	1	6	No
parsed	Returns true if the node and all of its descendants have been parsed. Otherwise it returns false	5	-	-	No
parseError	Returns a ParseError object containing information about the parse error	5	-	-	No
prefix	Returns the namespace prefix of a node	5	-	-	No
preserveWhiteSpace	Returns true if the default processing preserves white space. Otherwise it returns false	5	-	-	No
previousSibling	Returns the node immediately previous to the current node. Two nodes are siblings if they have the same parent node	5	1	6
readyState	Returns the current state of the XML document	5	-	-	No
text	Returns the text content of a node and all its children	5	-	-	No
url	Returns the URL for the last loaded XML document	5	-	-	No
validateOnParse	Indicates whether the document should be validated by the parser. Default is true. If false, only well-formed XML will be parsed	5	-	-	No
xml	Returns the XML of a node and all its children	5	-	-	No

Document Object Methods

Method	Description	IE	F	N	W3C
abort()	Aborts the XML download	5	-	-	No
appendChild("name")	Appends a new childnode to a node	5	-	-	No
cloneNode(boolean)	Creates an exact clone node of a node. If the boolean parameter is set to true, the cloned node clones all the child nodes of the original node as well	5	-	-	No
createAttribute("name")	Creates a new attribute node	6	1	6	Yes
createCDATASection("text")	Creates a new CDATA section node	5	-	-	Yes
createComment("text")	Creates a new comment node	6	-	-	Yes
createDocumentFragment()	Creates an empty documentFragment object	5	1	6	Yes
createElement("name")	Creates a new element node	5	1	6	Yes
createEntityReference("name")	Creates a new entityReference node	5	-	-	Yes
createNode(type,name,ns)	Creates a new node	5	-	-	No
createProcessingInstruction(target,text)	Creates a new processingInstruction node	5	-	-	Yes
createTextNode("text")	Creates a new text node	5	1	6	Yes
getElementById("id")		5	1	6	Yes
getElementByName("name")		5	1	6
getElementsByTagName("name")	Returns the specified node, and all its child nodes, as a node list	5	1	6	Yes
hasChildNodes()	Returns true if a node has child nodes. Otherwise it returns false	5	-	-	No
insertBefore(newnode,refnode)	Inserts a new node before an existing node	5	-	-	No
load("URL")	Loads the specified XML document	5	-	-	No
loadXML("text")	Loads an XML document using the specified string	5	-	-	No
nodeFromID(id)	Returns the node for the element whose ID attribute matches the one specified	5	-	-	No
removeChild("name")	Removes and returns the specified node	5	-	-	No
replaceChild(newnode,oldnode)	Replaces an oldnode with a newnode, and returns the oldnode	5	-	-	No
save(obj)	Saves an XML document to the specified location	5	-	-	No
selectNodes(pattern)	Creates a node list of all the matching descendant nodes returned by the specified pattern	5	-	-	No
selectSingleNode(pattern)	Returns a Node object for the first descendant node to match the specified pattern	5	-	-	No
transformNode(stylesheet)	Processes a node and its descendants using the specified XSL stylesheet, and returns the result	5	-	-	No
transformNodeToObject(stylesheet,object)	Processes a node and its descendants using the specified XSL stylesheet, and returns the result in the specified object	5	-	-	No

Events

Event	Description	IE	F	N	W3C
ondataavailable	Executes some code when the XML document data is available Syntax: document.ondataavailable="myFunction"	5	-	-	No
onreadystatechange	Executes some code when the readyState property changes Syntax: document.onreadystatechange="myFunction"	5	-	-	No
ontransformnode	Triggered before each node in the XML is transformed by each node in the style sheet Syntax: boolean = ontransformnode(nodecode,nodedata)	5	-	-	No

posted @ 2006-08-01 09:28 javaGrowing 阅读(310) | 评论 (0) | 编辑收藏

使用XMLHTTP Request Object获取服务器数据

在Web客户端使用xmlhttp对象，可以十分方便的和服务器交换数据，我们可以获取和发送任何类型的数据，甚至二进制数据到服务器上。xmlhttp技术同时也是目前大多数无刷新页面使用的和服务器交换数据的方式，这种方式比以往的隐藏iframe的方法要方便和经济的多。

同时让我们高兴得是xmlhttp并不是IE特有的东西，虽然目前还不是W3C的标准，不过IE, Netscape/Mozilla, 和Safari都支持。在IE中我们使用new ActiveXObject('MSXML2.XMLHTTP')或者new ActiveXObject("Microsoft.XMLHTTP")来获得的xmlhttp对象实例，使用前者还是后者和客户端机器安装的MSXML版本有关。在Netscape/Mozilla和Safari中，使用new XMLHttpRequest()来获得xmlhttp对象实例。比如在IE中，我们通常这样使用：

var xmlhttp = null;

try

{

xmlhttp = new ActiveXObject("MSXML2.XMLHTTP");

}

catch(e)

{

try

{

xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");

}

catch(e2){}

}

使用xmlhttp对象其实是并不是什么困难的事，它一共就6个方法8个属性。不过它最主要的是提供了两种执行模式：同步模式和异步模式。同步模式可以比较精确的控制程序流程，可是如果服务器的Response太慢，browser会有死掉失去相应的问题；而使用异步模式由于是事件触发方式控制流程，会给程序运行带来一些不可与预计的问题，因为你不知道客户端等待服务器Response的过程中，用户会在browser里做什么操作。

下面是一个同步方式获取服务器数据的简单示例：

function GetRemoteData(url)

{

var xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");

try

{

xmlhttp.open('GET', url, false);

if ( xmlhttp.status == 200 )

{

return xmlhttp.responseText;

}

throw '';

}

catch(e)

{

return '';

}

XMLHTTP对象的属性和方法列表(来自IXMLHTTPRequest接口)：

Name	Type	Description
onreadystatechange	N/A	指定当就绪状态发生改变时调用的事件处理函数，仅用于异步操作
readyState	Long	异步操作的状态：未初始化(0)，正在加载(1)，已加载(2)，交互(3)，已完成(4)
responseBody	Variant	将响应信息正文作为unsigned byte数组返回
responseStream	Variant	将响应信息正文作为一个ADO Stream对象返回
responseText	String	将响应信息正文作为一个文本字符串返回
responseXML	Object	通过XMLDom将响应信息正文解析为XMLDocument对象
status	Long	服务器返回的HTTP状态码
statusText	String	服务器HTTP响应行状态

Name	Desciption
abort	取消当前 HTTP 请求
getAllResponseHeaders	从响应信息中检索所有的标头字段
getResponseHeader	从响应信息正文中获得一个 HTTP 标头值
open(method, url, boolAsync, bstrUser, bstrPassword)	打开一个与 HTTP 服务器的连接
send(varBody)	设定一个请求的标头字段
setRequestHeader(bstrHeader, bstrValue)	向 HTTP 服务器发送请求。可包含正文。

这里面显然就open方法比较麻烦，带了一大堆参数，它们的含义分别是：

Parameter	Description
method	HTTP的通信方式，比如GET, HEAD, POST, PUT, DELETE, CONNECT等
url	接收数据的服务器的URL地址，URL可带QueryString
boolAsync	一个布尔标识，说明请求是否为异步的。如果是异步通信方式，客户端就不等待服务器的响应；如果是同步方式，客户机会等到服务器返回消息后才去执行其它操作
bstrUser	用户ID，用于服务器身份验证
bstrPassword	用户密码，用于服务器身份验证

异步通讯的示例：

xmlhttp.open("GET", "default.aspx", true);

xmlhttp.onreadystatechange = function()

{

if ( xmlhttp.readyState==4 )

{

alert(xmlhttp.responseText);

}

xmlhttp.send(null);

其实使用xmlhttp就这么简单，复杂的是服务器端数据的组织方式，而且需要开发人员同时熟悉Client和Server端的开发，才能事半功倍。可是好像说了半天这个玩意儿和xml没有什么关系啊，怎么叫xmlhttp呢？我们注意到response的数据类型中有一个responseXML，不过它解析返回的XMLDocument属于XMLDOM的内容了，和使用xmlhttp来和服务器通讯的关系并不大，以后再来细说。

posted @ 2006-07-29 11:46 javaGrowing 阅读(325) | 评论 (0) | 编辑收藏

servlet 获取out对象

javax.servlet.jsp.JspWriter out;
　javax.servlet.jsp.PageContext pageContext =

　　javax.servlet.jsp.JspFactory.getDefaultFactory().getPageContext( this , request, response, null , true , 8192 , true );

　out = pageContext.getOut();

posted @ 2006-06-14 23:15 javaGrowing 阅读(2989) | 评论 (0) | 编辑收藏

Oracle/PLSQL: To_Date Function

In Oracle/PLSQL, the to_date function converts a string to a date.

The syntax for the to_date function is:

to_date( string1, [ format_mask ], [ nls_language ] )

string1 is the string that will be converted to a date.

format_mask is optional. This is the format that will be used to convert string1 to a date.

nls_language is optional. This is the nls language used to convert string1 to a date.

The following is a list of options for the format_mask parameter. These parameters can be used in many combinations.

Parameter Explanation

YEAR Year, spelled out

YYYY 4-digit year

YYY
YY
Y Last 3, 2, or 1 digit(s) of year.

IYY
IY
I Last 3, 2, or 1 digit(s) of ISO year.

IYYY 4-digit year based on the ISO standard

RRRR Accepts a 2-digit year and returns a 4-digit year.
A value between 0-49 will return a 20xx year.
A value between 50-99 will return a 19xx year.

Q Quarter of year (1, 2, 3, 4; JAN-MAR = 1).

MM Month (01-12; JAN = 01).

MON Abbreviated name of month.

MONTH Name of month, padded with blanks to length of 9 characters.

RM Roman numeral month (I-XII; JAN = I).

WW Week of year (1-53) where week 1 starts on the first day of the year and continues to the seventh day of the year.

W Week of month (1-5) where week 1 starts on the first day of the month and ends on the seventh.

IW Week of year (1-52 or 1-53) based on the ISO standard.

D Day of week (1-7).

DAY Name of day.

DD Day of month (1-31).

DDD Day of year (1-366).

DY Abbreviated name of day.

J Julian day; the number of days since January 1, 4712 BC.

HH Hour of day (1-12).

HH12 Hour of day (1-12).

HH24 Hour of day (0-23).

MI Minute (0-59).

SS Second (0-59).

SSSSS Seconds past midnight (0-86399).

FF Fractional seconds. Use a value from 1 to 9 after FF to indicate the number of digits in the fractional seconds. For example, 'FF4'.

AM, A.M., PM, or P.M. Meridian indicator

AD or A.D AD indicator

BC or B.C. BC indicator

TZD Daylight savings information. For example, 'PST'

TZH Time zone hour.

TZM Time zone minute.

TZR Time zone region.

Parameter	Explanation
YEAR	Year, spelled out
YYYY	4-digit year
YYY YY Y	Last 3, 2, or 1 digit(s) of year.
IYY IY I	Last 3, 2, or 1 digit(s) of ISO year.
IYYY	4-digit year based on the ISO standard
RRRR	Accepts a 2-digit year and returns a 4-digit year. A value between 0-49 will return a 20xx year. A value between 50-99 will return a 19xx year.
Q	Quarter of year (1, 2, 3, 4; JAN-MAR = 1).
MM	Month (01-12; JAN = 01).
MON	Abbreviated name of month.
MONTH	Name of month, padded with blanks to length of 9 characters.
RM	Roman numeral month (I-XII; JAN = I).
WW	Week of year (1-53) where week 1 starts on the first day of the year and continues to the seventh day of the year.
W	Week of month (1-5) where week 1 starts on the first day of the month and ends on the seventh.
IW	Week of year (1-52 or 1-53) based on the ISO standard.
D	Day of week (1-7).
DAY	Name of day.
DD	Day of month (1-31).
DDD	Day of year (1-366).
DY	Abbreviated name of day.
J	Julian day; the number of days since January 1, 4712 BC.
HH	Hour of day (1-12).
HH12	Hour of day (1-12).
HH24	Hour of day (0-23).
MI	Minute (0-59).
SS	Second (0-59).
SSSSS	Seconds past midnight (0-86399).
FF	Fractional seconds. Use a value from 1 to 9 after FF to indicate the number of digits in the fractional seconds. For example, 'FF4'.
AM, A.M., PM, or P.M.	Meridian indicator
AD or A.D	AD indicator
BC or B.C.	BC indicator
TZD	Daylight savings information. For example, 'PST'
TZH	Time zone hour.
TZM	Time zone minute.
TZR	Time zone region.

For example:

to_date('2003/07/09', 'yyyy/mm/dd') would return a date value of July 9, 2003.

to_date('070903', 'MMDDYY') would return a date value of July 9, 2003.

to_date('20020315', 'yyyymmdd') would return a date value of Mar 15, 2002.

posted @ 2006-05-22 18:45 javaGrowing 阅读(1043) | 评论 (1) | 编辑收藏

JAVA中正则表达式的应用（二）

简介：

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它包括两个类： Pattern和 Matcher

Pattern	一个Pattern是一个正则表达式经编译后的表现模式。
Matcher	一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

以下我们就分别来看看这两个类：

回页首

Pattern类:

Pattern的方法如下：

static Pattern	compile(String regex) 将给定的正则表达式编译并赋予给Pattern类
static Pattern	compile(String regex, int flags) 同上，但增加flag参数的指定，可选的flag参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ
int	flags() 返回当前Pattern的匹配flag参数.
Matcher	matcher(CharSequence input) 生成一个给定命名的Matcher对象
static boolean	matches(String regex, CharSequence input) 编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个Matcher实例。
String	pattern() 返回该Patter对象所编译的正则表达式。
String[]	split(CharSequence input) 将目标字符串按照Pattern里所包含的正则表达式为模进行分割。
String[]	split(CharSequence input, int limit) 作用同上，增加参数limit目的在于要指定分割的段数，如将limi设为2，那么目标字符串将根据正则表达式分为割为两段。

一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个Pattern类的实例，这个Pattern对象将会使用 matcher()方法来生成一个Matcher实例，接着便可以使用该 Matcher实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个Matcher是可以共用一个Pattern对象的。

现在我们先来看一个简单的例子，再通过分析它来了解怎样生成一个Pattern对象并且编译一个正则表达式，最后根据这个正则表达式将目标字符串进行分割：

												
														import java.util.regex.*;
public class Replacement{
      public static void main(String[] args) throws Exception {
        // 生成一个Pattern,同时编译一个正则表达式
        Pattern p = Pattern.compile("[/]+");
        //用Pattern的split()方法把字符串按"/"分割
        String[] result = p.split(
"Kevin has seen《LEON》seveal times,because it is a good film."
+"/ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部"
+"好电影。/名词:凯文。");
        for (int i=0; i<result.length; i++)
            System.out.println(result[i]);
      }
}

输出结果为：

Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。
名词:凯文。

很明显，该程序将字符串按"/"进行了分段，我们以下再使用 split(CharSequence input, int limit)方法来指定分段的段数，程序改动为：
tring[] result = p.split("Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。"，2);

这里面的参数"2"表明将目标语句分为两段。

输出结果则为：

Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

由上面的例子，我们可以比较出java.util.regex包在构造Pattern对象以及编译指定的正则表达式的实现手法与我们在上一篇中所介绍的Jakarta-ORO 包在完成同样工作时的差别，Jakarta-ORO 包要先构造一个PatternCompiler类对象接着生成一个Pattern对象，再将正则表达式用该PatternCompiler类的compile()方法来将所需的正则表达式编译赋予Pattern类：

PatternCompiler orocom=new Perl5Compiler();

Pattern pattern=orocom.compile("REGULAR EXPRESSIONS");

PatternMatcher matcher=new Perl5Matcher();

但是在java.util.regex包里，我们仅需生成一个Pattern类，直接使用它的compile()方法就可以达到同样的效果: Pattern p = Pattern.compile("[/]+");

因此似乎java.util.regex的构造法比Jakarta-ORO更为简洁并容易理解。

回页首

Matcher类:

Matcher方法如下：

Matcher	appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里。
StringBuffer	appendTail(StringBuffer sb) 将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。
int	end() 返回当前匹配的子串的最后一个字符在原目标字符串中的索引位置。
int	end(int group) 返回与匹配模式里指定的组相匹配的子串最后一个字符的位置。
boolean	find() 尝试在目标字符串里查找下一个匹配子串。
boolean	find(int start) 重设Matcher对象，并且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串。
String	group() 返回当前查找而获得的与组匹配的所有子串内容
String	group(int group) 返回当前查找而获得的与指定的组匹配的子串内容
int	groupCount() 返回当前查找所获得的匹配组的数量。
boolean	lookingAt() 检测目标字符串是否以匹配的子串起始。
boolean	matches() 尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
Pattern	pattern() 返回该Matcher对象的现有匹配模式，也就是对应的Pattern 对象。
String	replaceAll(String replacement) 将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。
String	replaceFirst(String replacement) 将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。
Matcher	reset() 重设该Matcher对象。
Matcher	reset(CharSequence input) 重设该Matcher对象并且指定一个新的目标字符串。
int	start() 返回当前查找所获子串的开始字符在原目标字符串中的位置。
int	start(int group) 返回当前查找所获得的和指定组匹配的子串的第一个字符在原目标字符串中的位置。

（光看方法的解释是不是很不好理解？不要急，待会结合例子就比较容易明白了）

一个Matcher实例是被用来对目标字符串进行基于既有模式（也就是一个给定的Pattern所编译的正则表达式）进行匹配查找的，所有往Matcher的输入都是通过CharSequence接口提供的，这样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作。

我们分别来看看各方法的使用：

★matches()/lookingAt ()/find()：
一个Matcher对象是由一个Pattern对象调用其matcher()方法而生成的，一旦该Matcher对象生成,它就可以进行三种不同的匹配查找操作：

matches()方法尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
lookingAt ()方法将检测目标字符串是否以匹配的子串起始。
find()方法尝试在目标字符串里查找下一个匹配子串。

以上三个方法都将返回一个布尔值来表明成功与否。

★replaceAll ()/appendReplacement()/appendTail()：
Matcher类同时提供了四个将匹配子串替换成指定字符串的方法：

replaceAll()
replaceFirst()
appendReplacement()
appendTail()

replaceAll()与replaceFirst()的用法都比较简单，请看上面方法的解释。我们主要重点了解一下appendReplacement()和appendTail()方法。

appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里，而appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

例如，有字符串fatcatfatcatfat,假设既有正则表达式模式为"cat"，第一次匹配后调用appendReplacement(sb,"dog"),那么这时StringBuffer sb的内容为fatdog，也就是fatcat中的cat被替换为dog并且与匹配子串前的内容加到sb里，而第二次匹配后调用appendReplacement(sb,"dog")，那么sb的内容就变为fatdogfatdog，如果最后再调用一次appendTail（sb）,那么sb最终的内容将是fatdogfatdogfat。

还是有点模糊？那么我们来看个简单的程序：

												
														//该例将把句子里的"Kelvin"改为"Kevin"
import java.util.regex.*;
public class MatcherTest{
    public static void main(String[] args) 
                         throws Exception {
        //生成Pattern对象并且编译一个简单的正则表达式"Kelvin"
        Pattern p = Pattern.compile("Kevin");
        //用Pattern类的matcher()方法生成一个Matcher对象
        Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in Kelvin Chen's KelvinSoftShop company");
        StringBuffer sb = new StringBuffer();
        int i=0;
        //使用find()方法查找第一个匹配的对象
        boolean result = m.find();
        //使用循环将句子里所有的kelvin找出并替换再将内容加到sb里
        while(result) {
            i++;
            m.appendReplacement(sb, "Kevin");
            System.out.println("第"+i+"次匹配后sb的内容是："+sb);
            //继续查找下一个匹配对象
            result = m.find();
        }
        //最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；
        m.appendTail(sb);
        System.out.println("调用m.appendTail(sb)后sb的最终内容是:"+ sb.toString());
    }
}

最终输出结果为：
第1次匹配后sb的内容是：Kevin
第2次匹配后sb的内容是：Kevin Li and Kevin
第3次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin
第4次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's Kevin
调用m.appendTail(sb)后sb的最终内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's KevinSoftShop company.

看了上面这个例程是否对appendReplacement()，appendTail()两个方法的使用更清楚呢，如果还是不太肯定最好自己动手写几行代码测试一下。

★group()/group(int group)/groupCount()：
该系列方法与我们在上篇介绍的Jakarta-ORO中的MatchResult .group()方法类似(有关Jakarta-ORO请参考上篇的内容)，都是要返回与组匹配的子串内容，下面代码将很好解释其用法：

												
														import java.util.regex.*;

public class GroupTest{
    public static void main(String[] args) 
                         throws Exception {
        Pattern p = Pattern.compile("(ca)(t)");        
        Matcher m = p.matcher("one cat,two cats in the yard");
        StringBuffer sb = new StringBuffer();
        boolean result = m.find();
        System.out.println("该次查找获得匹配组的数量为："+m.groupCount());
        for(int i=1;i<=m.groupCount();i++){
         System.out.println("第"+i+"组的子串内容为： "+m.group(i));
        }
    }
}

输出为：
该次查找获得匹配组的数量为：2
第1组的子串内容为：ca
第2组的子串内容为：t

Matcher对象的其他方法因比较好理解且由于篇幅有限，请读者自己编程验证。

回页首

一个检验Email地址的小程序：

最后我们来看一个检验Email地址的例程，该程序是用来检验一个输入的EMAIL地址里所包含的字符是否合法，虽然这不是一个完整的EMAIL地址检验程序，它不能检验所有可能出现的情况，但在必要时您可以在其基础上增加所需功能。

												
														import java.util.regex.*;
public class Email {
   public static void main(String[] args) throws Exception {
      String input = args[0];
      //检测输入的EMAIL地址是否以 非法符号"."或"@"作为起始字符      
      Pattern p = Pattern.compile("^\\.|^\\@");
      Matcher m = p.matcher(input);
      if (m.find()){
        System.err.println("EMAIL地址不能以'.'或'@'作为起始字符");
      }
      //检测是否以"www."为起始
      p = Pattern.compile("^www\\.");
      m = p.matcher(input);
      if (m.find()) {
        System.out.println("EMAIL地址不能以'www.'起始");
      }
      //检测是否包含非法字符
      p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
      m = p.matcher(input);
      StringBuffer sb = new StringBuffer();
      boolean result = m.find();
      boolean deletedIllegalChars = false;
      while(result) {
         //如果找到了非法字符那么就设下标记
         deletedIllegalChars = true;
         //如果里面包含非法字符如冒号双引号等，那么就把他们消去，加到SB里面
         m.appendReplacement(sb, "");
         result = m.find();
      }
      m.appendTail(sb);
      input = sb.toString();
      if (deletedIllegalChars) {
          System.out.println("输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改");
          System.out.println("您现在的输入为: "+args[0]);
          System.out.println("修改后合法的地址应类似: "+input);
     }
   }
}

例如，我们在命令行输入：java Email www.kevin@163.net

那么输出结果将会是：EMAIL地址不能以'www.'起始

如果输入的EMAIL为@kevin@163.net

则输出为：EMAIL地址不能以'.'或'@'作为起始字符

当输入为：cgjmail#$%@163.net

那么输出就是：

输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改
您现在的输入为: cgjmail#$%@163.net
修改后合法的地址应类似: cgjmail@163.net

回页首

总结：

本文介绍了jdk1.4.0-beta3里正则表达式库--java.util.regex中的类以及其方法，如果结合与上一篇中所介绍的Jakarta-ORO API作比较，读者会更容易掌握该API的使用，当然该库的性能将在未来的日子里不断扩展，希望获得最新信息的读者最好到及时到SUN的网站去了解。

回页首

结束语：

本来计划再多写一篇介绍一下需付费的正则表达式库中较具代表性的作品，但觉得既然有了免费且优秀的正则表达式库可以使用，何必还要去找需付费的呢，相信很多读者也是这么想的:，所以有兴趣了解更多其他的第三方正则表达式库的朋友可以自己到网上查找或者到我在参考资料里提供的网址去看看。

回页首

参考资料

java.util.regex的帮助文档
Dana Nourie 和Mike McCloskey所写的 Regular Expressions and the Java" Programming Language
需要更多的第三方正则表达式资源以及基于它们所开发的应用程序请看 http://www.meurrens.org/ip-Links/java/regex/index.html

回页首

关于作者


		陈广佳 Kevin Chen,汕头大学电子信息工程系工科学士，台湾大新出版社珠海区开发部，现正围绕中日韩电子资料使用JAVA开发电子词典等相关项目。可通过E-mail: cgjmail@163.net于他联系。

posted @ 2006-05-22 13:24 javaGrowing 阅读(365) | 评论 (0) | 编辑收藏

JAVA中正则表达式的应用 (一)

正则表达式：

正则表达式是一种可以用于模式匹配和替换的强有力的工具，一个正则表达式就是由普通的字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式，它描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

正则表达式在字符数据处理中起着非常重要的作用，我们可以用正则表达式完成大部分的数据分析处理工作，如:判断一个串是否是数字、是否是有效的Email地址，从海量的文字资料中提取有价值的数据等等，如果不使用正则表达式，那么实现的程序可能会很长，并且容易出错。对这点本人深有体会，面对大量工具书电子档资料的整理工作，如果不懂得应用正则表达式来处理，那么将是很痛苦的一件事情，反之则将可以轻松地完成，获得事半功倍的效果。

由于本文目的是要介绍如何在JAVA里运用正则表达式，因此对刚接触正则表达式的读者请参考有关资料，在此因篇幅有限不作介绍。

回页首

JAVA对正则表达式的支持：

在JDK1.3或之前的JDK版本中并没有包含正则表达式库可供JAVA程序员使用，之前我们一般都在使用第三方提供的正则表达式库，这些第三方库中有源代码开放的，也有需付费购买的，而现时在JDK1.4的测试版中也已经包含有正则表达式库---java.util.regex。

故此现在我们有很多面向JAVA的正则表达式库可供选择，以下我将介绍两个较具代表性的 Jakarta-ORO和 java.util.regex，首先当然是本人一直在用的 Jakarta-ORO：

回页首

Jakarta-ORO正则表达式库

1．简介：

Jakarta-ORO是最全面以及优化得最好的正则表达式API之一，Jakarta-ORO库以前叫做OROMatcher，是由Daniel F. Savarese编写，后来他将其赠与Jakarta Project，读者可在Apache.org的网站下载该API包。

许多源代码开放的正则表达式库都是支持Perl5兼容的正则表达式语法，Jakarta-ORO正则表达式库也不例外，他与Perl 5正则表达式完全兼容。

2．对象与其方法：

★PatternCompiler对象：
我们在使用Jakarta-ORO API包时，最先要做的是，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

												
												
												
																														PatternCompiler compiler=new Perl5Compiler();
	PatternCompiler compiler=new Perl5Compiler();

★Pattern对象：
要把所对应的正则表达式编译成Pattern对象，需要调用compiler对象的compile()方法，并在调用参数中指定正则表达式。举个例子，你可以按照下面这种方式编译正则表达式"s[ahkl]y"：

												
												
												
																														 Pattern pattern=null;
 
														
																Pattern pattern=null;
try {
pattern=compiler.compile("s[ahkl]y ");
} catch (MalformedPatternException e) {
e.printStackTrace();
}

在默认的情况下，编译器会创建一个对大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配"say"、"shy"、 "sky"和"sly"，但不匹配"Say"和"skY"。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数:
pattern=compiler.compile("s[ahkl]y",Perl5Compiler.CASE_INSENSITIVE_MASK);

Pattern对象创建好之后，就可以通过PatternMatcher类用该Pattern对象进行模式匹配。

★PatternMatcher对象:

PatternMatcher对象依据Pattern对象和字符串展开匹配检查。你要实例化一个Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：
PatternMatcher matcher=new Perl5Matcher();

PatternMatcher对象提供了多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：

boolean matches(String input, Pattern pattern)：当要求输入的字符串input和正则表达式pattern精确匹配时使用该方法。也就是说当正则表达式完整地描述输入字符串时返回真值。
boolean matchesPrefix(String input, Pattern pattern)：要求正则表达式匹配输入字符串起始部分时使用该方法。也就是说当输入字符串的起始部分与正则表达式匹配时返回真值。
boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用该方法。当正则表达式为输入字符串的子串时返回真值。

但以上三种方法只会查找输入字符串中匹配正则表达式的第一个对象，如果当字符串可能有多个子串匹配给定的正则表达式时，那么你就可以在调用上面三个方法时用PatternMatcherInput对象作为参数替代String对象，这样就可以从字符串中最后一次匹配的位置开始继续进行匹配，这样就方便的多了。

用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：

boolean matches(PatternMatcherInput input, Pattern pattern)
boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)
boolean contains(PatternMatcherInput input, Pattern pattern)

★Util.substitute()方法:
查找后需要要进行替换，我们就要用到Util.substitute()方法，其语法如下：

												
												
												
														
																public static String substitute(PatternMatcher matcher,
Pattern pattern,Substitution sub,String input,
int numSubs)

前两个参数分别为PatternMatcher和Pattern对象。而第三个参数是个Substiution对象，由它来决定替换操作如何进行。第四个参数是要进行替换操作的目标字符串，最后一个参数用来指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只进行指定次数的替换。

在这里我相信有必要详细解说一下第三个参数Substiution对象，因为它将决定替换将怎样进行。

Substiution:
Substiution是一个接口类，它为你提供了在使用Util.substitute()方法时控制替换方式的手段，它有两个标准的实现类：StringSubstitution与Perl5Substitution。当然，同时你也可以生成自己的实现类来定制你所需要的特殊替换动作。

StringSubstitution：
StringSubstitution 实现的是简单的纯文字替换手段，它有两个构造方法：

StringSubstitution()->缺省的构造方法，初始化一个包含零长度字符串的替换对象。

StringSubstitution(java.lang.String substitution)->初始化一个给定字符串的替换对象。

Perl5Substitution：
Perl5Substitution 是StringSubstitution的子类，它在实现纯文字替换手段的同时也允许进行针对MATH类里各匹配组的PERL5变量的替换，所以他的替换手段比其直接父类StringSubstitution更为多元化。

它有三个构造器：

Perl5Substitution()

Perl5Substitution(java.lang.String substitution)

Perl5Substitution(java.lang.String substitution, int numInterpolations)

前两种构造方法与StringSubstitution一样，而第三种构造方法下面将会介绍到。

在 Perl5Substitution的替换字符串中可以包含用来替代在正则表达式里由小扩号围起来的匹配组的变量，这些变量是由$1, $2,$3等形式来标识。我们可以用一个例子来解释怎样使用替换变量来进行替换：

假设我们有正则表达式模式为b\d+:（也就是b[0-9]+:），而我们想把所有匹配的字符串中的"b"都改为"a",而"："则改为"-"，而其余部分则不作修改，如我们输入字符串为"EXAMPLE b123:"，经过替换后就应该变成"EXAMPLE a123-"。要做到这点，我们就首先要把不做替换的部分用分组符号小括号包起来，这样正则表达式就变为"b(\d+):"，而构造Perl5Substitution对象时其替换字符串就应该是"a$1-"，也就是构造式为Perl5Substitution（"a$1-"），表示在使用Util.substitute()方法时只要在目标字符串里找到和正则表达式" b(\d+): "相匹配的子串都用替换字符串来替换，而变量$1表示如果和正则表达式里第一个组相匹配的内容则照般原文插到$1所在的为置，如在"EXAMPLE b123："中和正则表达式相匹配的部分是"b123："，而其中和第一分组"(\d+)"相匹配的部分则是"123"，所以最后替换结果为"EXAMPLE a123-"。

有一点需要清楚的是，如果你把构造器Perl5Substitution(java.lang.String substitution,int numInterpolations)

中的numInterpolations参数设为INTERPOLATE_ALL，那么当每次找到一个匹配字串时，替换变量（$1，$2等）所指向的内容都根据目前匹配字串来更新，但是如果numInterpolations参数设为一个正整数N时，那么在替换时就只会在前N次匹配发生时替换变量会跟随匹配对象来调整所代表的内容，但N次之后就以一致以第N次替换变量所代表内容来做为以后替换结果。

举个例子会更好理解：

假如沿用以上例子中的正则表达式模式以及替换内容来进行替换工作，设目标字符串为"Tank b123: 85 Tank b256: 32 Tank b78: 22"，并且设numInterpolations参数为INTERPOLATE_ALL，而Util.substitute()方法中的numSub变量设为SUBSTITUTE_ALL（请参考上文Util.substitute()方法内容），那么你获得的替换结果将会是： Tank a123- 85 Tank a256- 32 Tank a78- 22

但是如果你把numInterpolations设为2，并且numSubs依然设为SUBSTITUTE_ALL，那么这时你获得的结果则会是： Tank a123- 85 Tank a256- 32 Tank a256- 22

你要注意到最后一个替换所用变量$1所代表的内容与第二个$1一样为"256"，而不是预期的"78"，因为在替换进行中，替换变量$1只根据匹配内容进行了两次更新，最后一次就使第二次匹配时所更新的结果，那么我们可以由此知道，如果numInterpolations设为1，那么结果将是： Tank a123- 85 Tank a123- 32 Tank a123- 22

3．应用示例：

刚好前段时间公司准备出一个《伊索预言》的英语学习互动教材，其中有电子档资料的整理工作，我们就以此为例来看一下Jakarta-ORO与JDBC2.0 API结合起来对数据库内的资料进行简单提取与整理的实现。假设由录入部的同事送过来的存放在MS SQLSERVER 7数据库里的电子档的表结构如下（注：或许在不同的DBMS中有相应的正则表达式的应用，但这不在本文讨论范围内）：

表名：AESOP, 表中每条记录包含有三列:
ID（int）：单词索引号
WORD（varchar）：单词
CONTENT(varchar)：存放单词的相关解释与例句等内容

其中CONTENT列中内容的格式如下：
[音标] [词性] （解释）{(例句一/例句解释/例句中该词的词性: 单词在句中的意思) (例句二/例句解释/例句中该词的词性: 单词在句中的意思)}

如对应单词Kevin,CONTENT中的内容如下：
['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now./凯文现住在珠海/名词: 凯文)}

我们的例子主要针对CONTENT列中内容进行字符串处理。

★查找单个匹配：
首先，让我们尝试把CONTNET列中的[音标]字段的内容列示出来，由于所有单词的记录中都有这一项并且都在字串开始位置，所以这个查找工作比较简单：

确定相应的正则表达式：\[[^]]+\]
这个是很简单的正则表达式，其意思是要求相匹配的字符串必须为以一对中括号包含的所有内容，如['kevin] 、[名词]等，但内容中不包括"]"符号，也就是要避免出现"[][]"会作为一个匹配对象的情况出现（有关正则表达式的基础知识请参照有关资料，这里不再详述）。

注意，在Java中，你必须对每一个向前的斜杠（"\"）进行转义处理。所以我们要在上面的正则表达式里每个"\"前面加上一个"\"以免出现编译错误，也就是在JAVA中初始化正则表达式的字符串的语句应该为：

String restring=" \\[[^]]+\\]";

并且在表达式里每个符号中间不能有空格，否则就会同样出现编译错误。
实例化PatternCompiler对象，创建Pattern对象
PatternCompiler compiler=new Perl5Compiler();

Pattern pattern=compiler.compile(restring);

创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：

																
																
																
																																						  PatternMatcher matcher=new Perl5Matcher();
        if (matcher.contains(content,pattern)) {
                 //处理代码片段
        }

这里matcher.contains(content,pattern)中的参数 content是从数据库里取来的字符串变量。该方法只会查到第一个匹配的对象字符串，但是由于音标项均在CONETNET内容字符串中的起始位置，所以用这个方法就已经可以保证把每条记录里的音标项找出来了,但更为直接与合理的办法是使用boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)方法，该方法验证目标字符串是否以正则表达式所匹配的字串为起始。

具体实现的完整的程序代码如下：

																
																
																
																																						package RegularExpressions;
//import……
import org.apache.oro.text.regex.*;
//使用Jakarta-ORO正则表达式库前需要把它加到CLASSPATH里面，如果用IDE是//JBUILDER，那么也可以在JBUILDER里直接自建新库。

public class yisuo{
  public static void main(String[] args){
  try{     
//使用JDBC DRIVER进行DBMS连接，这里我使用的是一个第三方JDBC 
//DRIVER，Microsoft本身也有一个面向SQLSERVER7/2000的免费JDBC //DRIVER，但其性能真的是奇差，不用也罢。
        Class.forName("com.jnetdirect.jsql.JSQLDriver");
          Connection con=DriverManager.getConnection
          ("jdbc:JSQLConnect://kevin:1433","kevin chen","re");
          Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
          ResultSet.CONCUR_UPDATABLE);
//为使用Jakarta-ORO库而创建相应的对象
String rsstring=" \\[[^]]+\\]"; 
          PatternCompiler orocom=new Perl5Compiler();
          Pattern pattern=orocom.compile(rsstring);
          PatternMatcher matcher=new Perl5Matcher();
          ResultSet uprs = stmt.executeQuery("SELECT * FROM aesop");
          while (uprs.next()) {
Stirng  word=uprs.getString("word");
          Stirng  content=uprs.getString("content");
            if(matcher.contains(content,pattern)){
          //或if(matcher.matchesPrefix(content,pattern)){
                MatchResult result=matcher.getMatch();
                Stirng pure=result.toString();
                System.out.println(word+"的音标为："+pure);
            }
          }
       }
  catch(Exception e) {
             System.out.println(e);
       }
  }
}

输出结果为：kevin的音标为['kevin]

在这个处理中我是用toString()方法来取得结果，但是如果正则表达式里是用了分组符号（圆括号），那么就可以用group(int gid)的方法来取得相应各组匹配的结果，如正则表达式改为" (\[[^]]+\])"，那么就可以用以下方法来取得结果：pure=result.group(0);

用程序验证，输出结果同样为：kevin的音标为['kevin]

而如果正则表达式为（\[[^]]+\]）（\[[^]]+\]），则会查找到两个连续的方括号所包含的内容，也就找到[音标] [词性]两项，但是两项的结果分别在两个组里面，分别由下面语句获得结果：

result.group(0)->返回[音标] [词性]两项内容，也就是与整个正则表达式相匹配的结果字符串，在这里也就为['kevin] [名词]

result.group(1) ->返回[音标]项内容，结果应是['kevin]

result.group(2) ->返回[词性]项内容，结果应是[名词]

继续用程序验证，发现输出并不正确，主要是当内容有中文时就不能成功匹配，考虑到可能是Jakarta-ORO正则表达式库版本不支持中文的问题，回看一下原来我一直用的还是2.0.1的老版本，马上到Jakarta.org上下载最新的2.0.4版本装上再用程序验证，得出的结果就和预期一样正确。

★查找多个匹配：
经过第一步的尝试使用Jakarta-ORO后，我们已经知道了如何正确使用该API包来查找目标字符串里一个匹配的子串，下面我们接着来看一看当目标字符串里包含不止一个匹配的子串时我们如何把它们一个接一个找出来进行相应的处理。

首先我们先试个简单的应用，假设我们想把CONTNET字段内容里所有用方括号包起来的字串都找出来，很清楚地，CONTNET字段的内容里面就只有两项匹配的内容：[音标]和 [词性]，刚才我们其实已经把它们分别找出来了，但是我们所用的方法是分组方法，把"[音标] [词性]"作为一整个正则表达式匹配的内容先找到，再根据分组把[音标]和 [词性]分别挑出来。但是现在我们需要做的是把[音标]和[词性]分别做为与同一个正则表达式匹配的内容，先找到一个接着再找下一个，也就是刚才我们的表达式为（\[[^]]+\]）（\[[^]]+\]）,而现在应为" \[[^]]+\] "。

我们已经知道在匹配操作的三个方法里只要用PatternMatcherInput对象作为参数替代String对象就可以从字符串中最后一次匹配的位置开始继续进行匹配，实现的程序片段如下：

												
												
												
																														PatternMatcherInput input=new PatternMatcherInput(content);
            while (matcher.contains(input,pattern)) {
                result=matcher.getMatch();
                System.out.println(result.group(0)) 
            }

输出结果为:['kevin]
[名词]

接着我们来做复杂一点的处理，就是我们要先把下面内容：
['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now. /凯文现住在珠海/名词: 凯文)}中的整个例句部分（也就是由大括号所包含的部分）找出来，再分别把例句一和例句二找出，而各例句中的各项内容（英文句、中文句、词性、解释）也要分项列出。

第一步当然是要定出相应的正则表达式，需要有两个，一是和整个例句部分（也就是由大括号包起来的部分）匹配的正则表达式："\{.+\}",

另一个则要和每个例句部分匹配（也就是小括号中的内容），：$([^)]+$

而且由于要把例句的各项分离出来，所以要再把里面的各部分用分组的方法匹配出来：" ([^(]+)/(.+)/(.+):([^)]+) "。

为了简便起见，我们不再和从数据库里读出，而是构造一个包含同样内容的字符串变量，程序片段如下：

												
														try{
         String content="['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词:凯文) (Kevin is living in ZhuHai now./凯文现住在珠海/名词: 凯文)}";
         String ps1="\\{.+\\}";
         String ps2="\\([^)]+\\)";
         String ps3="([^(]+)/(.+)/(.+):([^)]+)";
         String sentence;
         PatternCompiler orocom=new Perl5Compiler();
         Pattern pattern1=orocom.compile(ps1);
         Pattern pattern2=orocom.compile(ps2);
         Pattern pattern3=orocom.compile(ps3);
         PatternMatcher matcher=new Perl5Matcher();
//先找出整个例句部分
            if (matcher.contains(content,pattern1)) {
            MatchResult result=matcher.getMatch();
            String example=result.toString();
            PatternMatcherInput input=new PatternMatcherInput(example);
        //分别找出例句一和例句二
            while (matcher.contains(input,pattern2)){
                result=matcher.getMatch();
                sentence=result.toString();
        //把每个例句里的各项用分组的办法分隔出来
                if (matcher.contains(sentence,pattern3)){
                  result=matcher.getMatch();
                  System.out.println("英文句: "+result.group(1));
                  System.out.println("句子中文翻译: "+result.group(2));
                  System.out.println("词性: "+result.group(3));
                  System.out.println("意思: "+result.group(4));
                }
            }
        }
       }
  catch(Exception e) {
             System.out.println(e);
       }

输出结果为：
英文句: Kevin loves comic.
句子中文翻译: 凯文爱漫画
词性: 名词
意思: 凯文
英文句: Kevin is living in ZhuHai now.
句子中文翻译: 凯文现住在珠海
词性: 名词
意思: 凯文

★查找替换：
以上的两个应用都是单纯在查找字符串匹配方面的，我们再来看一下查找后如何对目标字符串进行替换。

例如我现在想把第二个例句进行改动，换为：Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

也就是把
['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now. /凯文现住在珠海/名词: 凯文)}

改为：
['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)}

之前，我们已经了解Util.substitute()方法与Substiution接口，以及Substiution的两个实现类StringSubstitution和Perl5Substitution，我们就来看看怎么用Util.substitute()方法配合Perl5Substitution来完成我们上面提出的替换要求，确定正则表达式：

我们要先找到其中的整个例句部分，也就是由大括号包起来的字串，并且把两个例句分别分组，所以正则表达式为："\{($[^)]+$)($[^)]+$)\}"，如果用替换变量来代替分组，那么上面的表达式可以看为"\{$1$2\}",这样就可以更容易看出替换变量与分组间的关系。

根据上面的正则表达式Perl5Substitution类可以这样构造： Perl5Substitution("{$1( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)}")

再根据这个Perl5Substitution对象来使用Util.substitute()方法便可以完成替换了，实现的代码片段如下：

												
														try{
   String content="['kevin] [名词]（人名凯文）{(Kevin loves comic.
   /凯文爱漫画/名词: 凯文)(Kevin lives in ZhuHai now./凯文现住在珠海/名词: 凯文)}";
   String ps1="\\{(\\([^)]+\\))(\\([^)]+\\))\\}";
   String sentence;
   String pure;
   PatternCompiler orocom=new Perl5Compiler();
   Pattern pattern1=orocom.compile(ps1);
   PatternMatcher matcher=new Perl5Matcher();
       String result=Util.substitute(matcher,
        pattern1,new Perl5Substitution(
       "{$1( Kevin has seen《LEON》seveal times,because it is a good film./ 
       凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)}",1),
        content,Util.SUBSTITUTE_ALL);
        System.out.println(result);
   }
  catch(Exception e) {
             System.out.println(e);
       }

输出结果是正确的，为：
['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)}

至于有关使用numInterpolations参数的构造器用法，读者只要根据上面的介绍自己动手试一下就会清楚了，在此就不再例述。

回页首

总结：

本文首先介绍了Jakarta-ORO正则表达式库的对象与方法，并且接着举例让读者对实际应用有进一步的了解，虽然例子都比较简单，但希望读者们在看了该文后对Jakarta-ORO正则表达式库有一定的认知，在实际工作中有所帮助与启发。

其实在Jakarta org里除了Jakarta-ORO外还有一个百分百的纯JAVA正则表达式库，就是由Jonathan Locke赠与Jakarta ORG的Regexp，在该包里面包含了完整的文档以及一个用于调试的Applet例子，对其有兴趣的读者可以到此下载。

posted @ 2006-05-22 13:19 javaGrowing 阅读(1212) | 评论 (0) | 编辑收藏

log4j.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>

<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c %d{ISO8601}
-- %p -- %m%n"/>
</layout>
</appender>

<appender name="DEBUG" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="C:\\logs\\app-debug.log"/>
<param name="Append" value="true"/>
<param name="MaxFileSize" value="500KB"/>
<param name="MaxBackupIndex" value="2"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c %d{ISO8601}
-- %p -- %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="DEBUG" />
<param name="LevelMax" value="DEBUG" />
</filter>
</appender>

<appender name="INFO" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="C:\\logs\\app-info.log"/>
<param name="Append" value="true"/>
<param name="MaxFileSize" value="500KB"/>
<param name="MaxBackupIndex" value="2"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c %d{ISO8601}
-- %p -- %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="INFO" />
<param name="LevelMax" value="INFO" />
</filter>
</appender>

<appender name="WARN" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="C:\\logs\\app-warn.log"/>
<param name="Append" value="true"/>
<param name="MaxFileSize" value="500KB"/>
<param name="MaxBackupIndex" value="2"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c %d{ISO8601}
-- %p -- %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="WARN" />
<param name="LevelMax" value="WARN" />
</filter>
</appender>

<appender name="ERROR" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="C:\\logs\\app-error.log"/>
<param name="Append" value="true"/>
<param name="MaxFileSize" value="500KB"/>
<param name="MaxBackupIndex" value="2"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c %d{ISO8601}
-- %p -- %m%n"/>
</layout>
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="ERROR" />
<param name="LevelMax" value="ERROR" />
</filter>
</appender>

<root>
<priority value="debug"/>
<appender-ref ref="STDOUT"/>
<appender-ref ref="DEBUG"/>
<appender-ref ref="INFO"/>
<appender-ref ref="WARN"/>
<appender-ref ref="ERROR"/>
</root>

</log4j:configuration>

posted @ 2006-05-15 10:04 javaGrowing 阅读(725) | 评论 (1) | 编辑收藏

Tomcat配置技巧Top 10

编者按：现在开发Java Web应用，建立和部署Web内容是一件很简单的工作。使用Jakarta Tomcat作为Servlet和JSP容器的人已经遍及全世界。Tomcat具有免费、跨平台等诸多特性，并且更新得很快，现在非常的流行。

你所需要做的就是：按照你的需求配置Tomcat，只要你正确配置，Tomcat一般都能适合你的要求。下面是一系列关于Tomcat的配置技巧，这些技巧源自于我的书：《Tomcat权威指南》，希望对你有所帮助。—— Jason Brittain

1．配置系统管理（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。

2．配置应用管理（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，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。

3．部署一个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 path="/demo" docBase="webapps/MyWebApp.war"

debug="0" privileged="true">

<Realm className="org.apache.catalina.realm.UserDatabaseRealm"

resourceName="UserDatabase"/>

</Context>

把该片断命名为“MyWebApp.xml”，然后拷贝到CATALINA_BASE/webapps目录下。

这种context片断提供了一种便利的方法来部署web应用，你不需要编辑server.xml，除非你想改变缺省的部署特性，安装一个新的web应用时不需要重启动Tomcat。

4．配置虚拟主机（Virtual Hosts）

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

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

在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">



<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>



<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=””）。

5．配置基础验证（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文件。



<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>



<login-config>

<auth-method>BASIC</auth-method>

<realm-name>My Club Members-only Area</realm-name>

</login-config>

6．配置单点登录（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。

7．配置用户定制目录（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本身。

8．在Tomcat中使用CGI脚本

Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scripting等，甚至包括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脚本的权限。

9．改变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可能需要设置，那处决于你选择的是何种编译器。

10．限制特定主机访问（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>

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

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

作者简介：

Jason Brittain是CollabNet公司的一名资深软件工程师，主要负责软件底层架构的开发。他已经为Apache Jakarta项目做了很多贡献，多年以来，他一直是一名积极的开源软件开发者。

Ian F. Darwin已经在计算机行业工作了30年：从1980年开始使用Unix，从1995年开始使用Java，从1998年开始使用OpenBSD。他是两本Oreilly图书的作者：Checking C Programs with lint 和 Java Cookbook，还与Jason Brittain合著了Tomcat: The Definitive Guide。

译者简介：

陈光（Holen Chen），J2EE项目经理，熟悉知识管理及电子政务，致力于Apache Jakarta项目在国广的推广及深层次应用，可通过 holen@263.net与作者联系。

posted @ 2006-05-15 10:00 javaGrowing 阅读(270) | 评论 (0) | 编辑收藏

Log4J 最佳实践之全能配置文件

下面给出得Log4J配置文件实现了输出到控制台，文件，回滚文件，发送日志邮件，输出到数据库日志表，自定义标签等全套功能。

log4j.rootLogger=DEBUG,CONSOLE,A1,im
#DEBUG,CONSOLE,FILE,ROLLING_FILE,MAIL,DATABASE

log4j.addivity.org.apache=true

###################
# Console Appender
###################
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

#####################
# File Appender
#####################
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis

########################
# Rolling File
########################
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

####################
# Socket Appender
####################
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

########################
# Log Factor 5 Appender
########################
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

########################
# SMTP Appender
#######################
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=chenyl@hollycrm.com
log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=chenyl@hollycrm.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

########################
# JDBC Appender
#######################
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

###################
#自定义Appender
###################
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net

log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

posted @ 2006-05-15 09:57 javaGrowing 阅读(237) | 评论 (0) | 编辑收藏

比较全面的log4j配置

log4j.rootLogger=DEBUG,CONSOLE,A1,im
log4j.addivity.org.apache=true

# 应用于控制台

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

#应用于文件

log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis

# 应用于文件回滚

log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件

log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=web@www.wuset.com
log4j.appender.MAIL.SMTPHost=www.wusetu.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=web@www.wusetu.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

#自定义Appender

log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net

log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

posted @ 2006-05-15 09:35 javaGrowing 阅读(342) | 评论 (0) | 编辑收藏

Tomcat参数说明

server.xml配置简介
下面我们将讲述这个文件中的基本配置信息，更具体的配置信息见tomcat的文档
server: port    指定一个端口，这个端口负责监听关闭tomcat的请求
shutdown    指定向端口发送的命令字符串
service: name    指定service的名字
Connector    (表示客户端和service之间的连接):
port    指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
minProcessors    服务器启动时创建的处理请求的线程数
maxProcessors    最大可以创建的处理请求的线程数
enableLookups    如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址
redirectPort    指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号
acceptCount    指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
connectionTimeout    指定超时的时间数(以毫秒为单位)
Engine    (表示指定service中的请求处理机，接收和处理来自Connector的请求):
defaultHost    指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
Context    (表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见servlet规范):
docBase    应用程序的路径或者是WAR文件存放的路径
path    表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****
reloadable    这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序
host    (表示一个虚拟主机):
name    指定主机名
appBase    应用程序基本目录，即存放应用程序的目录
unpackWARs    如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序
Logger    (表示日志，调试和错误信息):
className    指定logger使用的类名，此类必须实现
org.apache.catalina.Logger    接口
prefix    指定log文件的前缀
suffix    指定log文件的后缀
timestamp    如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
Realm    (表示存放用户名，密码及role的数据库):
className    指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
Valve    (功能与Logger差不多，其prefix和suffix属性解释和Logger中的一样):
className    指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
directory    指定log文件存放的位置
pattern    有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多
注意：
1：经过我测试，我设置Context 的path="",reloadable=true，然后放一个WAR文件到webapps目录，结果tomcat不能检测出此文件(重起tomcat可以)，而把此文件解压，则tomcat会自动检测出这个新的应用程序。如果不能自动检测WAR文件，我们可以利用下面管理中讲的方法来部署应用程序。
2：默认的server.xml中，Realm元素只设置了一个className属性，但此文件中也包含几个通过JDBC连接到数据库进行验证的示例(被注释掉了)，通过Realm元素我们可以实现容器安全管理(Container Managed Security)。
3：还有一些元素我们没有介绍，如Parameter，loader，你可以通过tomcat的文档获取这些元素的信息。

posted @ 2006-05-13 12:52 javaGrowing 阅读(509) | 评论 (0) | 编辑收藏

tomcat中的几点配置说明

1. 如何加大tomcat连接数

在tomcat配置文件server.xml中的<Connector ... />配置中，和连接数相关的参数有：
minProcessors：最小空闲连接线程数，用于提高系统处理性能，默认值为10
maxProcessors：最大连接线程数，即：并发处理的最大请求数，默认值为75
acceptCount：允许的最大连接数，应大于等于maxProcessors，默认值为100
enableLookups：是否反查域名，取值为：true或false。为了提高处理能力，应设置为false
connectionTimeout：网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。

其中和最大连接数相关的参数为maxProcessors和acceptCount。如果要加大并发连接数，应同时加大这两个参数。

web server允许的最大连接数还受制于操作系统的内核参数设置，通常Windows是2000个左右，Linux是1000个左右。Unix中如何设置这些参数，请参阅Unix常用监控和管理命令

tomcat4中的配置示例：
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="10" maxProcessors="1024"
enableLookups="false" redirectPort="8443"
acceptCount="1024" debug="0" connectionTimeout="30000" />

对于其他端口的侦听配置，以此类推。

2. tomcat中如何禁止列目录下的文件
在/conf/web.xml中，把listings参数设置成false即可，如下：
<servlet>
...
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
...
</servlet>

3. 如何加大tomcat可以使用的内存

tomcat默认可以使用的内存为64MB，在较大型的应用项目中，这点内存是不够的，需要调大。

Unix下，在文件/bin/catalina.sh的前面，增加如下设置：
JAVA_OPTS='-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】'
需要把这个两个参数值调大。例如：
JAVA_OPTS='-Xms256m -Xmx512m'
表示初始化内存为256MB，可以使用的最大内存为512MB

4. 如何添加默认访问页面
修改文件web.xml，在welcome-list里面添加index.wml作为默认的访问页面
<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

posted @ 2006-05-13 12:49 javaGrowing 阅读(289) | 评论 (0) | 编辑收藏

Tomcat设置类似IIS的访问密码

例如你要控制对ROOT目录下文件的访问：首先更改$TOMCAT_HOME/ROOT/WEB-INF/web.xml

1.在<web-app>和</web-app>之间加入

　　<security-constraint>
　　<web-resource-collection>
　　<web-resource-name>Entire Application</web-resource-name>
　　<url-pattern>/*</url-pattern>
　　</web-resource-collection>
　　<auth-constraint>
　　
　　<role-name>user</role-name>
　　</auth-constraint>
　　</security-constraint>

　　
　　<login-config>
　　<auth-method>BASIC</auth-method>
　　<realm-name>TEST ACCESS CONTROL</realm-name>
　　</login-config>

　　2.然后在$TOMCAT_HOME/conf/tomcat-users.xml中加入
　　
　　<user name="user" password="password" roles="user"/>
　　roles的名字和web.xml中的相对应

　　在TOMCAT4.03中测试通过

posted @ 2006-05-13 12:29 javaGrowing 阅读(308) | 评论 (0) | 编辑收藏

如何增大以Windows服务方式运行的Tomcat的可用内存

首先安装tomcat时候最好选择zip打包方式直接解压到某个目录！

打开{tomat}/bin/service.bat，找到如下一行

"%EXECUTABLE%" //US//%SERVICE_NAME% ++JvmOptions "-Djava.io.tmpdir=%CATALINA_BASE%\temp" --JvmMs 128 --JvmMx 256

知道怎么做了嘛？把128和256替换成你想要的值，例如初始内存256，最大内存512。第一个数值是初始内存大小，单位是兆，第二个数值是最大内存！

修改完保存该文件后执行如下命令来安装服务

service install {service_name}

{service_name}替换成你想

posted @ 2006-05-13 11:58 javaGrowing 阅读(752) | 评论 (0) | 编辑收藏

Tomcat之配置多个虚拟主机指向同一个应用

当我们需要将多个域名同时指向同一个应用，而且要求不能跟Tomcat默认的应用冲突时怎么办？今天小红帽问起这个问题，顺便研究了一下，可以通过下面配置来实现

<Host name="javayou.com" appBase="webapps"
       unpackWARs="true" autoDeploy="false"
       xmlValidation="false" xmlNamespaceAware="false">
       <Alias>www.javayou.com</Alias>
       <Alias>wap.javayou.com</Alias>
       <Context path="" docBase="C:\PROJECTS\JAVA\DLOG4J_V3\webapp" reloadable="true"/>
</Host>

上面的例子把三个域名分别是 javayou.com, www.javayou.com, wap.javayou.com 都指到了dlog这个应用。

当然了，如果你的Tomcat只跑一个应用那就不用那么费劲了，把name设置为localhost就搞定了，别说是三个域名了，三万个也没问题啊。

posted @ 2006-05-13 11:53 javaGrowing 阅读(878) | 评论 (0) | 编辑收藏

Tomcat中设置远程debug方法

何为远程调试？我们一般调试一个web项目的java代码时，需要将你的tomcat服务器和你的开发工具（比如Jbuilder）集成，或需要工具的一些插件支持(比如Eclipse下的myclipse等)，这些方式都是在本地进行，即你的开发工具和tomcat运行在同一台服务器上，如果你的开发工具和服务器不再一台机器上那就需要实现远程调试功能了。

实现方法：
在tomcat的catalina.bat文件中加入下面的设置，当然SET CATALINA_OPTS 变量应该在使用它之前。这是在tomcat启动时设置一些虚拟机参数，使服务器允许远程连接功能，address=5888表示远程连接的端口号，可以设置成任意其他不冲突端口。其他的应用服务器比如weblogic也应该可以设置这些参数，有兴趣的可以测试。

SET CATALINA_OPTS = -server -Xdebug -Xnoagent -Djava.compiler = NONE -Xrunjdwp:transport = dt_socket , server = y , suspend = n , address = 5888

这样就Ok了，重启动tomcat,可以直接独立启动，而不用在eclipes的插件中启动。打开eclipse中的debug设置窗口，选择Remote Java Application ，新建一个debug项，输入服务器IP和刚才设置端口号，点ok就可以进入debug状态了。Jbuilder中同样可以设置Remote Java Application。

另有Javaeyes论坛的一片文章如下

http://www.hibernate.org.cn/viewtopic.php?t=799&postdays=0&postorder=asc&start=0

ibm论坛的原始文章如下

http://www-900.ibm.com/developerWorks/cn/linux/opensource/os-ecbug/但是该文章没有说明如何设置tomcat使其启动后支持远程调试连接。

用以参考~

<jvmarg value="-Xdebug"/>
        <jvmarg value="-Xnoagent"/>
        <jvmarg value="-Djava.compiler=none"/>
        <jvmarg value-Xrunjdwp:transport=dt_socket,server=y,address=4000,suspend=n"/>

另外（version 4.1.29）：

我手工将catalina.bat中

set JPDA=

修改为

set JPDA=jpda
set JPDA_TRANSPORT=dt_socket
set JPDA_ADDRESS=XXXX

然后在eclipse里面创建一个remote java application ，将port设置为XXXX的值，也可。

因为调试的启用，无非设置transport属性允许远程连接并且指定一个端口号而已，指定之后在eclipse里面对应的配置该端口号即可。

posted @ 2006-05-11 09:36 javaGrowing 阅读(6223) | 评论 (0) | 编辑收藏

全面理解Java中的String数据类型

1. 首先String不属于8种基本数据类型，String是一个对象。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

　　2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；

　　3. String str=”kvill”；String str=new String (“kvill”);的区别：

　　在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。

　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　看例1：

String s0=”kvill”;
String s1=”kvill”;
String s2=”kv” + “ill”;
System.out.println( s0==s1 );
System.out.println( s0==s2 );

　　结果为：

true
true

　　首先，我们要知道Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中” kvill”的一个引用。

　　所以我们得出s0==s1==s2;

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

　　看例2：

String s0=”kvill”;
String s1=new String(”kvill”);
String s2=”kv” + new String(“ill”);
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );

　　结果为：

false
false
false

　　例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

　　4. String.intern()：

　　再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

　　例3：

String s0= “kvill”;
String s1=new String(”kvill”);
String s2=new String(“kvill”);
System.out.println( s0==s1 );
System.out.println( “**********” );
s1.intern();
s2=s2.intern(); //把常量池中“kvill”的引用赋给s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );

　　结果为：

false
**********
false //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中”kvill”的引用
true

　　最后我再破除一个错误的理解：

　　有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的 String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

　　看例4：

String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );

　　结果：

false
kvill kvill
true

　　在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个” kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

　　s1==s1.intern()为false说明原来的“kvill”仍然存在；

　　s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

　　5. 关于equals()和==:

　　这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

　　6. 关于String是不可变的

　　这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的

posted @ 2006-03-03 09:03 javaGrowing 阅读(341) | 评论 (0) | 编辑收藏

应聘Java笔试时可能出现问题及其答案(第二版第二部分)

摘要: 线程编程方面 60、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？答：有两种实现方法，分别是继承Thread类与实现Runnable接口用synchronized关键字修饰同步方法反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于... 阅读全文

posted @ 2006-02-28 11:11 javaGrowing 阅读(1924) | 评论 (0) | 编辑收藏

应聘Java笔试时可能出现问题及其答案(第二版第四部分)

摘要: 代码与编程题135、写一个Singleton出来Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。一般Singleton模式通常有几种种形式:第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方... 阅读全文

posted @ 2006-02-28 11:01 javaGrowing 阅读(1606) | 评论 (0) | 编辑收藏

应聘Java笔试时可能出现问题及其答案(第二版第三部分)

摘要: EJB方面 94、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDB... 阅读全文

posted @ 2006-02-28 11:00 javaGrowing 阅读(1336) | 评论 (0) | 编辑收藏

应聘Java笔试时可能出现问题及其答案(第二版第一部分)

摘要: Java 基础方面 : ... 阅读全文

posted @ 2006-02-28 10:57 javaGrowing 阅读(3598) | 评论 (15) | 编辑收藏

2006年快乐

posted @ 2006-02-08 11:45 javaGrowing 阅读(228) | 评论 (0) | 编辑收藏

JDBC高级应用三

JDBC高级应用三

再谈JDBC连结

为什么要反复谈JDBC连结,因为所以JDBC的性能,最主要的就是JDBC连结,而SQL语句的
优化,和JAVA编程无关,你的一个查询语句的效率,是你对于SQL语法的使用技巧,这一方
面你就可请教DBA,而不是来看我这种程序设计者的文章.

我们已经知道,取得数据库连结,有几种层次的实现方法,一是直接得到物理连结,而是通
过传统的连结池(没有多大区别),三是通过java的扩展包javax.sql.DataSource得到连结
句柄,对于上面两种,没有什么可以多说的,对于DataSource,我们再深入一些.
一般来说,DataSource是容器本身作为一个JDNI查找的对象返回出来的,也就是说要依赖
容器进行配置,而如果一个100%的应用程序(Application),比如基于swing的App,我根本
不需要运行容器,那我如何取得DataSource对象?这时可能要你自己写基于DataSource的
连结池了(是不是有些太深入了?要做就做高手,SUN能做我们就能做).
如果自己要实现DataSource,要清楚几个关系,即DataSource中返回的Connection是一个连
结的句柄,它要和实际的物理连结关连,这些实际的物理连结就是PooledConnection,我们
叫它池中的连结,可以通过实现ConnectionPoolDataSource,从中得到PooledConnection,
这部分本来是厂商实现的,但这部份实现和传统的连结池没有什么大的区别,主要是从
ConnectionPoolDataSource中得到PooledConnection的物理连结,但如何从PooledConnection
中getConnection(),返回给用户.这部分实现就是DataSource实现的性能高低的关键,一般
来说,我们可以先把一个物理连结PooledConnection和多个客户连结相关连来增加性能,也
就是一个PooledConnection本身再作为一个工场的种子,通过一个PooledConnection再返回
多个Connection,说白了就是多个Connection的请求通过一个PooledConnection传递给数据库.
只要用户调用Connection的close()方法,就打断这个Connetion与PooledConnection的关联而
让PooledConnection可以和新的Connection进行关联.

JDBC事务

JDBC1开始,就支持本地事务,所谓要地事务,就是在一个连结中的多个操作可以作为一个事务
过程来提交.注意,只要你使用conn.setAutoCommit(false);方法就隐式地打开了一个事务.当
事务被commit或abort时,隐含的是打开了一个新的事务.
另外,当一次事务被commit或abort,PreparedSattement和CallableStatement绑定的结果集全
部被关闭,而普通的Statement绑一的结果集将被维持.
在处理多个操作时:
conn.setAutoCommit(false);
Statement st1 = conn.createSatatement(sql1);
Statement st2 = conn.createSatatement(sql2);
Statement st3 = conn.createSatatement(sql3);
Statement st4 = conn.createSatatement(sql4);
st1.executeXXXXX();
st2.executeXXXXX();
st3.executeXXXXX();
st4.executeXXXXX();
在这里,我们要么把四个操作一起回滚,或一起提交,但如果我们认为,1-3的操作是要求一致完
成,而4的操作在一至三完成时再完成.在经前的版本中我们要把它们分开在两次事务中,但在
JDBC3.0以后,我们可以利用conn.setSavepoint() 来得到一个SavePoint来对同一事务中不同阶
段进行断点保存.然后可以在任何断点上进行提交和回滚.同时我们还可以利用
conn.setTransactionIsolation()来设置隔离级别.
要注意的是,对事务的支持要看数据库的具体实现.如果数据库本身不支持事务,那么以上的操作
都是无效的,可以从 DatabaseMetaData中查询数据库对事务的支持情况.

毕竟,本地事务功能并不是很强,而如果不是编程人员对SQL语句传入错误,那么在一次连结中
多个操作只完成部份的机率并不容易发生(当然有时还会发生的,要不本地事务就不会产生了).
其实,JDBC事务最重要的是分布式事务,即同时操作不同的连结,可能是同物理库的不同空间,也
可能是同一主机的不同数据库或不同主机的多个数据库.这就很难保证每个操作都是成功的,发
生操作不一致的机会太多了,可以说如果不在事务中测试你就无法相信操作的一致性.所以分布
式事务是JDBC的重要技术.
在下一节我们重点介绍JDBC分布式事务.

posted @ 2006-01-09 15:01 javaGrowing 阅读(295) | 评论 (0) | 编辑收藏

JDBC高级应用二

JDBC高级应用(二)
本来想继续谈JDBC的高级连结方式,事务模式.但发现关于大对象存储有很多人在问,所以
先来插入一节关于大对象存储的内容,然后再接着原来的思路写下去.

JDBC的大对象存储听起来复杂,其实如果你明白了原理以后,就非常简单,网上有关这方面的
教材很少,而SUN的文档中,我从1.2开始看到一在仍然是错误的,不知道写文档的人长脑子没
有,就那几行代码你试试不就知道了,这么多次重抄下来还是错误的.

大对象分类:一般来说,大对象分为:大的文本对象,比如一个很长的文本(请你要注意什么是
文本文件,什么是二进制文件)文件,或者是你定义的一个长字符串,比如你定义了:
String s = "我们要去吃饭了......................然后睡觉!";
从吃饭到睡觉中间省略了实际的10000000000000字,虽然你不会真的定义这么称的String,但
有时会从什么地方得到这样的String,要写到数据库中.
另一种就是大的二进制对象,象执行文件,图象文件等,注意,word,excel,ppt这些"带格式"的文
档都应该以二进制对象存储.

一般来说,数据库如果支持大对象存储,会有这几种类型的SQL数据类型:
BLOB,CLOCB,NLOB,也有的数据数只有一种BLOB,基本上是这样的:BLOB用来存放二进制文件,而
CLOB用来存放文本文件,NLOB是对多字节文本文件支持.假如你的文本文件是纯英文的,放在
BLOB中当然可以,也就是说它是以byte格式存储的,而多字节是以CHAR格式存储的.

同样对于这几种类型的文档,有几种相对应的存取方式:
setter:
利用PreparedStatement的setXXX方法,
setAsciiStream()方法用于写入一般的文本流.setBinaryStream()方法用于写入二进制流
而setUnicodeStream()用于写好UNICODE编码的文本,与此相对应的ResultSet中三个getter方法
用于取回:getAsciiStream(),getBinaryStream(),getBinaryStream().
对于文件本身,要把它作为一个流,只要new InputStream(new FileInputStream("文件路径"))
就可以了,但对于大的String对象,你不会写入文件再转换成输入流吧?
new StringBufferInputStream(String s),记住了.
JDBC2以后提供了java.sql.BLOB对象,我不建议大家使用它,一是很麻类,二是容易出错,要先插
入一个空的BLOB对象,然后再填充它,实在没有必要,直接setXXX就行了,我试过,至少mysql,
oracle,sql server是可以直接set的.
好了,我们先看一个例子如何写入文件到数据库:
数据结构:
create table test(
  name varchar(200),
  content BLOB
);
File f = new File("a.exe");//先生成File对象是为了取得流的长度.FileInputStram可以直接
                           //传入文件路径
InputStream in = new InputStream(new FileInputStream(f));
PreparedStatement ps = conn.prepareStatement("insert into test (?,?)");
ps.setString(1,"a.exe");
ps.setBinaryStream(2,in,(int)f.length());
ps.executeUpdate();
f的长度一定要做从long到int的转换,SUN的文档中好几版都没有改过来.就这么简单,当然,不同的
数据库存本身要设置它允许的最大长度,MYSQL默认只能传1M的文件,要修改参数原能存更大的文件.
如果要从数库中取得文件:
PreparedStatement ps = conn.prepareStatement("select * from test where name=?");
ps.setString(1,"a.exe");
ResultSet rs = ps.executeQuery();
if(rs.next()){
InputStream in = rs.getBinaryStream("content");
}
得到in对象后,你可以进行任何处理,写向文件和写向页面只是out对象不同而已:
写向文件:
DateOutputStream out = new DateOutputStream(new FileOutputStream("b.exe"));
写向页面:
response.reset();
response.setContType("类型");
ServletOutputSreamt out = response.getOutputSream();
得到out对象后,就可以输出了:
byte[] buf = new byte[1024];
int len = 0;
while((len = in.read(buf)) >0)
  out.write(buf,0,len);
in.close();
out.close();
对于向页面输入,要设置什么样的ContType,要看你想如何输出,如果你想让对方下载,就设为
"application/octet-stream",这样即使是文本,图象都会下载而不会在浏览器中打开.如果你要想
在浏览器中打开,就要设置相应的类型,还要在容器的配置文件中设置支持这种文档类型的输出,但
对于很多格式的文件,到底要输出什么类型,其实就是HTTP的MIME集,比如图片:image/gif,当然你如
果你的文件扩展名(ext)不确定,你也不要用if(ext.equals("gif"))......这样来判断,我教你一个
技巧,我之所以说是技巧,是我没有在别的地方发现有人用这种方法,对我来说我是绝对不会把别人的
方法拿来说是我的技巧的:
构造一个file类型的URL,我们知道URL目前JAVA可以支持HTTP,FTP,MAILTO,FILE,LDAP等,从FILE类型
的URL就可以得到它的MIME:

URL u = new URL("file://a.exe");
String mime = u.openConnection().getContentType();
这样你就可以直接response.setContType(mime);而不用一个一个类型判断了.
好了,大对象存储就说到这儿,不同的数据仍然和些特殊的规定,不在此一一列举了.

posted @ 2006-01-09 10:08 javaGrowing 阅读(305) | 评论 (0) | 编辑收藏

JDBC的高级应用一

JDBC高级应用一

关于数据库连结

我们所说有JDBC高级应用,并不是说它的技术含量很高(也许JAVA平台上不存在什么"技术含量"的说
法,因为JAVA是给大家用的而不是给某些人用的).说它是高级应用,是因为它是对于JDBC基础应用来
说的扩展,也就是可以优化你的应用性能,或方便于应用的实现.所以说它是一种高级应用而不叫高级
技术.

    JDBC中,java.sql包是基础的,也是核心的功能,javax.sql包则是高级的,扩展的功能.所以
为了交流的方便,我们把它们区分为core API和optional API.

    但是仍然然有一些core API中的功能,我把它归纳到高级应用中.象存储过程的调用,多结果集
的处理,我之所以要把这些东西拿出来说明,是目前你在网上找不到任何一份详细的文档和例程,可以
说有95%以上的开发人员都不知道真正如何处理这些工作.所以我会在回上海后详细写这一段的内容.
现在我们还是来看看optional API给我们带来的好处:

    我们已经了解,执行一个SQL语句,要经过如下几步:
    1.Connction
    2.Statement
    3.Statement.executeXXXXX();
    4.可选的对结果集的处理
    5.必要的Connction的关闭.(再次提醒如果你想成为中级水平以上的程序员,请你把关闭语
    句写在finally块中,在通过下面的介绍后我介绍一个方法可以用来验证你的程序是否有连结
    泄漏)

    这其中,生成Connction对象是最最重要的工作,也是最消耗资源的,因为连结对象要驱动底层
的SOCKET,调用物理连结和数据库进行通信,所以生成,关闭,再生成这种连结对象就相当于我们在二十
世纪八十年代(1980年以后出身的不了解吧?)喝易拉罐饮料一样.你买一瓶饮料是一块二角钱,你可知道
那罐子(Connection)值一块零八分.而你喝下去的东西只值一角二分钱,这是我们那儿一个饮料厂的真实
数据.
    在javax.sql包出来以前,我们只能买这样的饮料来喝,除非你不喝.也有一些人不服气自己生
产饮料(poolman),可是消费者很快发现,它只是把原来单卖的易拉罐现在打包卖给了我们,因为它还是
用原来的包装原料来生产的,poolman这种类型的连结池,其根本是从DriverManager中getConnection
出来的.真正的效率如果不是你心理作用的话,也许比单个连结还要低!!!以及一些江湖好汉的"杰作",
都无法跳出这个框框.我自己在那一段时间也曾醉心于研究这些"连结池",因为谁都可以把别人的原码
读过后,再加上其他人的优点写出一个更好的来,可是,大家可以看到,我写出了好用的Upload,DownLoad,
HtmlUtil,Encoder,Decoder等一系列工具.可是我没有写出成功的连结池.......

    我们再来深入一步,为什么DriverManager生成的连结和基于它的连结池不能真正提高性能.
DriverManager对象中,绝大多数的JDBC是封装了一个物理连结,也就是它抓住了一个和数据库通信的
Socket,当你使用DriverManager.getConnection()时也就是有一个和数据库连结的Socket让你占用了.
而且这个方法是同步的.大家知道这样的物理连结对于任何系统是有限制的,比如一个WEB服务器一般
最大并发是150到250之间,数据库服务器也是这样的道理,你不仅要考虑你的程序不能用光连结,还要
考虑不同Runtime中或其它应用程序也在同时和你一起使用这些物理连结,如果一台服务器上有JAVA
WEB SERVER,还有一个C的应用程序也访问数据库,你不能那么无礼地要求人家C程序员他的程序必须
等你的JAVA调用空闲才能访问数据库吧.所以物理连结是极其宝贵的.
    基于DriverManager.getConnection()的连结池只不过是预先生成这样的物理连结放在一个
pool中,然后编号等你调用,它省略的是生成这样的连结的时间.注意你得到的连结在你没有释放之前,
它无法处理别的工作,因为连结句柄在用户手中,另外这种连结池调用时是由程序调用者初始化的,
每一次调用都必须有初始化工作,而调用者是否以优化的方法去运行它,完成还要看每个人的编程水
平.另一方面,如果这种连结池是如果用于WEB容器管理,那简单是垃圾,因为它强迫使用静态变量来
保持连结,容器根本无法做到访问控制.而且它不能在不同Runtime中被调用.

    而javax.sql的实现采用了在用户连结和物理连结中间加一个缓冲的中间层,它虽然也只生
成30个物理连结,但用户本身不能访问它,DataSource返回给用户的是一个JAVA抽象对象,客户程序把
连结请求放回缓冲中由DataSource统一调度物理连结来处理,这样可以最大程序利用宝贵的物理连结
也许现在的30个物理连结仍然不够负载,你仍然需要修改实际连结数,但我们知道,我们现在的这种连
结方式已经不是DriverManager.getConnection()能比的了.也就是说,在同样多的物理连结下,
DataSource可以给我们更多(是多得多的)的调用机会,其实,正常情况下一个从DriverManager中
getConnection()出来物理连结的负载量只有百分之几,就是因为你的调用抓住了它的句柄而不能让
它很好地工作.另外程序员只能返回它而不能关闭它,因为传统连结池中连结对象一旦由用户关闭,
就要再次重新生成物理新的连结,所以用户只能释放,对于非连结池和连结池得到的连结对象,
要用不同的代码编程,简单是一种痛苦.一旦没有注意,在处理完数据后不是释放而是关闭,这个错误
到底是谁的过错?????????????

    我上面说java.sql实现绝大多数是得到物理连结,也有例外,但不是那些以前的连结池,而是
OSE,就是oracle的servlet环境,它是把servlet服务器实现在数据库的地址空间上,servlet服务去调
用数据库根本没有通过传统的连结,因为数据是"敞开"的,这就象通过网络访问其它计算机文件和访问
本地文件的区别. 虽然它也提供标准的JDBC接口让你调用,但它底层根本不是用JDBC封装的.

    DataSource的另外一个优点就是它完全实现数据库和应用程序的分离,如何配置服务器生成
DataSource的引用和程序开发无关,你在程序开发中,只要通过JDNI查找DataSource的逻辑名称就行.
而DriverManager.getConnection()中,你不得不把数据库驱动程序名,访问地址,用户,密码写在你的
应用程序中,即使可以从配置文件中读取这些属性串,而不同的服务器配置文件的路径你都要修改.而
DataSource提供了标准的配置.

    说来说去,如何用DataSource来连结数据库?

    非常简单:

    DataSource ds = (DataSource)new InitialContext().lookup("jdbc/mydb");
    Connection conn = ds.getConnection();

    当然我是为了说明它简单故意把它的异常给忽略了.实际应用中.你应该捕获它的异常.

    如果你还不明白什么是JDNI,我劝你先找一些这方面的资料看看,这可以是网编程方面的
基础协议啊.

    关于DataSource ds = (DataSource)new InitialContext().lookup("jdbc/mydb");有几点
需要说明的是,你只要配置好你的服务器(tomcat,resin,weblogic)这些服务器中都有一个例子,如果
你不是很懂,你先把那个例子改动几个字就行了.用一段时间你就会慢慢理解它们代表什么了.
然后你在容器环境下调用new InitialContext().lookup("jdbc/mydb")容器就会自动找到那个
DataSource对象给你调用,这个过程对用户来说是透明的.
    那边那个聪明的朋友已经问了,因为DataSource的属性是已经配置好的放在容器中的,那我
不在容器环境下,比如一个独立的application,我如何能取到DataSource呢?
    其实,如果你能知道new InitialContext()时,容器调用了哪些默认的配置,你就可以把
这些配置参数手工加进去而不依赖容器环境了.好在InitialContext可以getEnvironment() ,在生
成这个对象后你可以get一下看看,把这些参数记下来,以后在没有这些参数的环境下put进去.
    这里多几句话,谈一下学习方法,我在国内主持几个论坛(不多,两三个),从没有问过别人什
么问题,java技术又不是我发明的,不可能我什么都懂,一是问了好象有损于"高手"风范(哈哈,其实
真正的高手还是要问别人的,只有我这种假高手才不会问别人).另一方面是我根本不必问别人,比如
象application下,连结不同厂家的DataSource要put什么东西进去呢?一是去他们的网站看资料,虽然
我的英语水平只有大家的10%,但我上英文网站的次数可能比你们多.二是看有没有什么共用的API能
得到,好在可以getEnvironment(),但假如没有这个方法呢?这就要看你的学习态度了,有人会这论坛
叫"高手球命",还有什么"急用,在线等待"什么的.而我,会把new InitialContext()反编译出来看看
它调用了什么(孔子说,为了学习的目的,反编译是允许的,甚至说是伟大的,光明的,正确的思想,是有
道德的,脱离了低级趣味的,有益于人民的行为!!!----孔子语录补集第123页第4行,1989年10月版)
如果一个对象在构造时要求有参数,而它又有一个没有参数的重载的构造方法,你想想它肯定在没有
参数的构造方法中调用了默认参数,你要做的就是把它们打印出来.有多少人是这样做的?

    jdbc optional API的其它扩展功能:
    javax.sql不仅仅是在性能上的提高,而且它还支持分布式事务,在传统的连结过程中,我们
可以在一个连结过程中,setAutoCommit()为fasle,然后通过rollback()或commit()那回滚和提交事
务,这种在一个连结过程中的事务称为本地事务,但假如在一个事务中要对多个数据库操作,或多过
Servlet参与操作,那就必须使用分布式事务.

    关于JDBC的事务我会放在下面来介绍,一个值得庆贺的功能出来了,就是事务保存点已经
JDBC3.0中实现,以前,如果我们把事务原子A,B,C放在一个事务中,如果A,B执行了,C失败,我们只能
把A,B都回滚了,但现在我们可以先把A,B保存为一个点,然后以这个点为回滚或提交,这就象在用WORD
编写文章时我们可以在不同的时候保存一个副本,而不会要么一字没有了,要么就是当前编辑的状态.

    现在我们来优化我们在基础知识中实现的Bean,今天在家,没法上论坛,上次写的连结部分
叫什么名字忘记了,现在我们就叫它PooledDB吧.
    当时我们已经把那个Bean分为三个部分,把生成连结部分独立出来了,而业务方法部份和扩
展部分根本不要动它,这就是继承的好处:)

package com.inmsg.beans;

import javax.naming.*;
import javax.sql.*;

public class PooledDB {

      Connection con = null;
      private String source = "";
      public PooledDB() throws Exception {//默认构造方法,如果构造时不加参数,连结jdbc/office
            source = "java:comp/env/jdbc/office";
            Context ct = new InitialContext();
            DataSource ds = (DataSource) ct.lookup(source);
          con = ds.getConnection();
    }

    //然后增加重载方法,用来连结其它的数据源
    public PooledDB(String source) throws Exception {
            this.source = source;
            Context ct = new InitialContext();
            DataSource ds = (DataSource) ct.lookup(source);
          con = ds.getConnection();
    }
    //注意一定要先把source赋给成员变量this.source,因为下面还有一个makeConnection()
    //辅助方法,如果不把source赋给this.source,则makeConnection()调用默认的source字符串

    private void makeConnection() throws Exception {
            Context ct = new InitialContext();
            DataSource ds = (DataSource) ct.lookup(source);
            con = ds.getConnection();
    }

    //现在我们把close()方法拿到父类来实现,这是经过综合考虑的,它是一个业务方法,无论是什么
    //方式取得连结,它本身不会修改,但为什么还封装到父类中呢?因为这样可以用一个独立的父类来
    //做连结测试,如果我只想试一下数据库能不能连结,我就不必再引用子类,直接用这个父类就行了
    public void close() throws Exception{
        if(con != null && !con.isClosed()) con.close();
    }
}

    一般来说,构造方法尽量捕获异常处理而不要抛出异常,但作为Bean的实现,捕获异常调用者不容易
看到异常信息,所以抛给调用者处理,另外这个类又要在应用程序中调用,又要考虑作为Bean调用,所以一定
要有一个无参数的构造方法,否则不能作为javaBean调用.把异常抛出给调用者的另一目的,我在设计时是这
样考虑的,就是强迫你一定在使用try{}catch(){}块,这样你就会想到再加一个finally{},再次提醒,一定要
以下面的形式来调用你数据库连结的Bean或封装类:
    PooledDB pd = null;
    try{
        pd = new PooledDB();
        ....................
    }
    catch(Exception e){}
    finally{try{pd.close();}catch(Exception ex){}}

    如果要测试你的数据库连结是否有泄漏,请你把DataSource中最大连结数设为1,只用一个连结的情
况下,如果你的程序中哪一处没有关闭连结,则下面的程序就不能再访问,然后从头到尾测试你的程序吧,一旦
发现不能访问数据库了,就查看刚才访问的代码,这样所有程序测试后,就可以放心了,一般来说我是不用这么
测试的,因为我在写数据库连结时是没有生成对象就写好close:

    PooledDB pd = null;
    try{}
    catch(Exception e){}
    finally{try{pd.close();}catch(Exception ex){}}
    然后原在try{}的花括号中回车加上pd = PooledDB();和业务代码的 :)当然,你们都比我聪明用不
着这样死套也不会忘记close()的.
    不要太高兴,到目前为止你仍然还没得到一个最好的解决方案,以下我们还会对这个数据库连结的
Bean(类)不断优化的..................................

    好了,javax.sql的连结先说到这儿吧,今天是周六,出去玩一会了(广州街头上没有什么美女!)

posted @ 2006-01-09 10:07 javaGrowing 阅读(311) | 评论 (0) | 编辑收藏

JDBC基础

JDBC基础(一)

本来不想写这部份入门级的内容,但既然栏目定为JDBC专栏,还是简单写一些吧.
JDBC基础(一)

    来,我们认识一下!
    JDBC,JAVA平台的DATABASE的连通性.白话一句,什么意思啊?
    就是JAVA平台上和数据库进行连结的"工具".

    还是先一起来回顾一下接口吧:从下向上,接口是对"案例"的抽象,由一个案例抽象出一些规则.
反过来,从上向下,被抽象出来的接口是对案例的一种承诺和约束.
    也就是说,只要你实现我规定的接口,你的类就已经具有了接口对外承诺的方法,只要"客户"会
操作接口,不需要重新学习就会操作实现了该接口的新类!
    好了,用行话来说:
    1.通过接口可以实现不相关的类的相同行为.
    2.通过接口可以指明多个类需要实现的方法.
    3.通过接口可以了解对象的交互方法而不需要了解对象所对应的类蓝本.
    这几句话很明白吧?好象有一本什么模式的书把这段话用了30多页写出来,结果别人看了还不如
我这几句话明白,不过我明白了为什么有些人要写书了.

    搞懂了以上这东西,JDBC就好明白了.
    为了通用,JAVA中要求有一种机制,在操作不同厂商数据库时有相同的方法去操作,而不是每接
触一种数据库就要学习新的方法.完成这种机制的"东西"就叫"JDBC"了.
    简单地分,JDBC有两部分组成,JDBC API和JDBC Driver Interface.
    JDBC API就是提供给"客户"(就是象你我这种菜鸟级程序员来用的,如果是高手都自己写JDBC了,
哈哈)的一组独立于数据库的API,对任何数据库的操作,都可以用这组API来进行.那么要把这些通用的API
翻译成特定数据库能懂的"指令",就要由JDBC Driver Interface来实现了,所以这部份是面向JDBC驱动程
序开发商的编程接口,它会把我们通过JDBC API发给数据库的通用指令翻译给他们自己的数据库.

    还是通过实际操作来看看JDBC如何工作的吧.

    因为JDBC API是通用接口,那么程序是如何知道我要连结的是哪种数据库呢?所以在和数据库连
结时先要加载(或注册可用的Driver),其实就是JDBC签名.加载驱动程序和好多方法,最常用的就是先把驱
动程序类溶解到内存中,作为"当前"驱动程序.注意"当前"是说内存中可以有多个驱动程序,但只有现在加
载的这个作为首选连结的驱动程序.
    Class.forName("org.gjt.mm.mysql.Driver");
    Class.forName方法是先在内存中溶解签名为"org.gjt.mm.mysql.Driver"的Driver类,Driver类
就会把相应的实现类对应到JDBC API的接口中.比如把org.gjt.mm.mysql.Connection的实例对象赋给
java.sql.Connection接口句柄,以便"客户"能通过操作java.sql.Connection句柄来调用实际的
org.gjt.mm.mysql.Connection中的方法.之于它们是如果映射的,这是厂商编程的,"客户"只要调用
Class.forName("org.gjt.mm.mysql.Driver");方法就可以顺利地操作JDBC API了.

    一个普通数据库的连结过程为:
    1.加载驱动程序.
    2.通过DriverManager到得一个与数据库连结的句柄.
    3.通过连结句柄绑定要执行的语句.
    4.接收执行结果.
    5.可选的对结果的处理.
    6.必要的关闭和数据库的连结.
JDBC基础(二)

因为是基础篇,所以还是对每一步骤简单说明一下吧:

    前面说是,注册驱动程序有多方法,Class.forName();是一种显式地加载.当一个驱
动程序类被Classloader装载后,在溶解的过程中,DriverManager会注册这个驱动类的实例.
这个调用是自动发生的,也就是说DriverManager.registerDriver()方法被自动调用了,当然
我们也可以直接调用DriverManager.registerDriver()来注册驱动程序,但是,以我的经验.
MS的浏览中APPLET在调用这个方法时不能成功,也就是说MS在浏览器中内置的JVM对该方法的
实现是无效的.
    另外我们还可以利用系统属性jdbc.drivers来加载多个驱动程序:
System.setProperty("jdbc.drivers","driver1:driver2:.....:drivern");多个驱动程序之
间用":"隔开,这样在连结时JDBC会按顺序搜索,直到找到第一个能成功连结指定的URL的驱动
程序.
    在基础篇里我们先不介绍DataSource这些高级特性.

    在成功注册驱动程序后,我们就可以用DriverManager的静态方法getConnection来得
到和数据库连结的引用:
    Connection conn = DriverManager.getConnection(url);
    如果连结是成功的,则返回Connection对象conn,如果为null或抛出异常,则说明没有
和数据库建立连结.
    对于getConnection()方法有三个重载的方法,一种是最简单的只给出数据源即:
getConnection(url),另一种是同时给出一些数据源信息即getConnection(url,Properties),
另外一种就是给出数据源,用户名和密码:getConnection(url,user,passwod),对于数据源信息.
如果我们想在连结时给出更多的信息可以把这些信息压入到一个Properties,当然可以直接压
入用户名密码,别外还可以压入指定字符集,编码方式或默认操作等一些其它信息.

    在得到一个连结后,也就是有了和数据库找交道的通道.我们就可以做我们想要的操
作了.
    还是先来介绍一些一般性的操作:
    如果我们要对数据库中的表进行操作,要先缘故绑定一个语句:
    Statement stmt = conn.createStatement();
    然后利用这个语句来执行操作.根本操作目的,可以有两种结果返回,如果执行的查询
操作,返回为结果集ResultSet,如果执行更新操作,则返回操作的记录数int.
    注意,SQL操作严格区分只有两个,一种就是读操作(查询操作),另一种就是写操作(更
新操作),所以,create,insert,update,drop,delete等对数据有改写行为的操作都是更新操作.

    ResultSet rs = stmt.executeQuery("select * from table where xxxxx");
    int x = stmt.executeUpdate("delete from table where ......");
    如果你硬要用executeQuery执行一个更新操作是可以的,但不要把它赋给一个句柄,
当然稍微有些经验的程序员是不会这么做的.
    至于对结果集的处理,我们放在下一节讨论,因为它是可操作的可选项,只有查询操作
才返回结果集,对于一次操作过程的完成,一个非常必要的步骤是关闭数据库连结,在你没有了
解更多的JDBC知识这前,你先把这一步骤作为JDBC操作中最最重要的一步,在以后的介绍中我会
不断地提醒你去关闭数据库连结!!!!!!!!!!!

    按上面介绍的步骤,一个完成的例子是这样的:(注意,为了按上面的步骤介绍,这个例
子不是最好的)
    try{
        Class.forName("org.gjt.mm.mysql.Driver");
    }catch(Exception e){
        System.out.println("没有成功加载驱动程序:"+e.toString());
        return;
    }//对于象我这样的经验,可以直接从e.toString()的简单的几个字判断出异常原因,
     //如果你是一个新手应该选捕获它的子类,如何知道要捕获哪几个异常呢?一个简单
     //的方法就是先不加try{},直接Class.forName("org.gjt.mm.mysql.Driver");,编
     //译器就会告诉你要你捕获哪几个异常了,当然这是偷机取巧的方法,最好还是自己
     //去看JDK文档,它会告诉你每个方法有哪些异常要你捕获.
    Connection conn = null;
    try{
        conn = DriverManager.getConnection(
                        "jdbc:mysql://host:3306/mysql",
                        "user",
                        "passwd");
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("select * from table");
        //rs 处理
        [rs.close();]
        [stmt.close();]
    }
    catch(Exception e){
        System.out.println("数据库操作出现异常:"+e.toString());
    }
    finally{
        try{conn.close();}catch(Exception){}
    }//不管你以前是学习到的关于数据库流程是如何操作的,如果你相信我,从现在开始,
     //请你一定要把数据库关闭的代码写到finally块中,切切!
JDBC基础(三)

关于Statement对象:
    前面说过,Statement对象是用来绑定要执行的操作的,在它上面有三种执行方法:
即用来执行查询操作的executeQuery(),用来执行更新操作的executeUpdate()和用来执行
动态的未知的操作的execute().
    JDBC在编译时并不对要执行的SQL语句检测,只是把它看着一个String,只有在驱动
程序执行SQL语句时才知道正确与否.
    一个Statement对象同时只能有一个结果集在活动.这是宽容性的,就是说即使没有
调用ResultSet的close()方法,只要打开第二个结果集就隐含着对上一个结果集的关闭.所以
如果你想同时对多个结果集操作,就要创建多个Statement对象,如果不需要同时操作,那么可
以在一个Statement对象上须序操作多个结果集.

    这里我不得不特别说明一下,很多人会用一个Statement进行嵌套查询,然后就来问
我说为什么不能循环?道理上面已经说清楚了.我们来详细分析一下嵌套查询:
    Connection conn = null;
    Statement stmt = null;
    conn = .......;
    stmt = conm.createStatement(xxxxxx);
    ResultSet rs = stmt.executeQuery(sql1);
    while(rs.next()){
        str = rs.getString(xxxxx);
        ResultSet rs1 = stmt.executeQuery("select * from 表 where 字段=str");
    }
当stmt.executeQuery("select * from 表 where 字段=str");赋给rs1时,这时隐含的操作
是已经关闭了rs,你还能循环下去吗?
所以如果要同时操作多个结果集一定要让它他绑定到不同的Statement对象上.好在一个connection
对象可以创建任意多个Statement对象,而不需要你重新获取连结.

    关于获取和设置Statement的选项:只要看看它的getXXX方法和setXXX方法就明白了,这儿
作为基础知识只提一下以下几个:
    setQueryTimeout,设置一个SQL执行的超时限制.
    setMaxRows,设置结果集能容纳的行数.
    setEscapeProcessing,如果参数为true,则驱动程序在把SQL语句发给数据库前进行转义替
换,否则让数据库自己处理,当然这些默认值都可以通过get方法查询.

    Statement的两个子类:
    PreparedStatement:对于同一条语句的多次执行,Statement每次都要把SQL语句发送给数据
库,这样做效率明显不高,而如果数据库支持预编译,PreparedStatement可以先把要执行的语句一次发
给它,然后每次执行而不必发送相同的语句,效率当然提高,当然如果数据库不支持预编译,
PreparedStatement会象Statement一样工作,只是效率不高而不需要用户工手干预.
    另外PreparedStatement还支持接收参数.在预编译后只要传输不同的参数就可以执行,大大
提高了性能.

    PreparedStatement ps = conn.prepareStatement("select * from 表 where 字段=?");
    ps.setString(1,参数);
    ResultSet rs = ps.executeQuery();

    CallableStatement:是PreparedStatement的子类,它只是用来执行存储过程的.
    CallableStatement sc = conn.prepareCall("{call query()}");
    ResultSet rs = cs.executeQuery();

    关于更高级的知识我们在JDBC高级应用中介绍.
JDBC基础(四)

    作为基础知识的最后部分,我们来说一说结果集的处理,当然是说对一般结果集的处理.
至于存储过程返回的多结果集,我们仍然放在高级应用中介绍.
    SQL语句如何执行的是查询操作,那就要返回一个ResultSet对象,要想把查询结果最后
明白地显示给用户,必须对ResultSet进行处理.ResultSet返回的是一个表中符合条件的记录,对
ResultSet的处理要逐行处理,而对于每一行的列的处理,则可以按任意顺序(注意,这只是JDBC规
范的要求,有些JDBC实现时对于列的处理仍然要求用户按顺序处理,但这是极少数的).事实上,虽
然你可以在处理列的时候可以按任意顺序,但如果你按从左到右的顺序则可以得到较高的性能.

    这儿从底层来讲解一下ResultSet对象,在任何介绍JDBC的书上你是不会获得这样的知
识的,因为那是数据库厂商的事.ResultSet对象实际维护的是一个二维指针,第一维是指向当前
行,最初它指向的是结果集的第一行之前,所以如果要访问第一行,就要先next(),以后每一行都
要先next()才能访问,然后第二维的指针指向列,只要当你去rs.getXXX(列)时,才通过
Connection再去数据库把真实的数据取出来,否则没有什么机器能真的把要取的数据都放在内
存中.
    所以,千万要记住,如果Connection已经关闭,那是不可能再从ResultSet中取到数据的.
有很多人问我,我可不可以取到一个ResultSet把它写到Session中然后关闭Connection,这样就
不要每次都连结了.我只能告诉你,你的想法非常好,但,是错误的!当然在javax.sql包中JDBC高
级应用中有CacheRow和WebCacheRow可以把结果集缓存下来,但那和我们自己开一个数据结构把
ResultSet的行集中所有值一次取出来保存起来没有什么两样.
    访问行中的列,可以按字段名或索引来访问.下面是一个简单的检索结果的程序:

    ResultSet rs = stmt.executeQuery("select a1,a2,a3 from table");
    while(rs.next()){
        int i = rs.getInt(1);
        String a = rs.getString("a2");
        ..............
    }

    对于用来显示的结果集,用while来进行next()是最普通的,如果next()返回false,则
说明已经没有可用的行了.但有时我们可能连一行都没有,而如果有记录又不知道是多少行,这时
如果要对有记录和没有记录进行不同的处理,应该用以下流程进行判断:

    if(rs.next()){
        //因为已经先next()了,所经对记录应该用do{}while();来处理
        do{
            int i = rs.getInt(1);
            String a = rs.getString("a2");
        }while(rs.next());
    }
    esle{
        System.out.println("没有取得符合条件的记录!");
    }

    类型转换:
    ResultSet的getXXX方法将努力把结果集中的SQL数据类型转换为JAVA的数据类型,事实
大多数类型是可以转换的,但仍然有不少糊弄是不能转换的,如你不能将一个SQL的float转换成
JAVA的DATE,你无法将 VARCHAR "我们"转换成JAVA的Int.

    较大的值:
    对于大于Statement中getMaxFieldSize返回值的值,用普通的getBytes()或getString()
是不能读取的,好在JAVA提供了读取输入浪的方法,对于大对象,我们可以通过rs.getXXXStream()
来得到一个InputStream,XXX的类型包括Ascii,Binay,Unicode.根据你存储的字段类型来使用不
同的流类型,一般来说,二进制文件用getBinayStream(),文本文件用getAsciiStyream(),对于
Unicode字符的文本文件用getUnicodeStream(),相对应的数据库字段类型应该为:Blob,Clob和
Nlob.

    获取结果集的信息:
    大多数情况下编程人员对数据库结构是了解的,可以知道结果集中各列的情况,但有时并
不知道结果集中有哪些列,是什么类型.这时可以通过getMetaData()来获取结果集的情况:

    ResulSetMetaData rsmd = rs.getMetaData();
    rsmd.getColumnCount()返回列的个数.
    getColumnLabel(int)返回该int所对应的列的显示标题
    getColumnName(int)返回该int所对应的列的在数据库中的名称.
    getColumnType(int)返回该int所对应的列的在数据库中的数据类型.
    getColumnTypeName(int)返回该int所对应的列的数据类型在数据源中的名称.
    isReadOnly(int)返回该int所对应的列是否只读.
    isNullable(int)返回该int所对应的列是否可以为空

posted @ 2006-01-09 10:04 javaGrowing 阅读(333) | 评论 (0) | 编辑收藏

深入理解嵌套类和内部类

一、什么是嵌套类及内部类？
    可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型: 静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
    其一、在一个类（外部类）中直接定义的内部类；
    其二、在一个方法（外部类的方法）中定义的内部类;
    其三、匿名内部类。
下面，我将说明这几种嵌套类的使用及注意事项。

　
二、静态嵌套类
如下所示代码为定义一个静态嵌套类，

public class StaticTest {
  private static String name = "javaJohn";
  private String id = "X001";

  static class Person{
    private String address = "swjtu,chenDu,China";
    public String mail = "josserchai@yahoo.com";//内部类公有成员
    public void display(){
      //System.out.println(id);//不能直接访问外部类的非静态成员
      System.out.println(name);//只能直接访问外部类的静态成员
      System.out.println("Inner "+address);//访问本内部类成员。
    }
  }

   public void printInfo(){
     Person person = new Person();
     person.display();

     //System.out.println(mail);//不可访问
     //System.out.println(address);//不可访问

     System.out.println(person.address);//可以访问内部类的私有成员
     System.out.println(person.mail);//可以访问内部类的公有成员

   }

   public static void main(String[] args) {
       StaticTest staticTest = new StaticTest();
       staticTest.printInfo();
   }
}

在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。
若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内
部类的的成员有些特别，不能直接访问，但可以通过内部类实例来访问，这是因为静态嵌套内的所有成员和方法默认为
静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。

三、在外部类中定义内部类
如下所示代码为在外部类中定义两个内部类及它们的调用关系：

class Outer{
  int outer_x = 100;

  private class Inner{//私有的内部类
   public int y = 10;
   private int z = 9;
   int m = 5;
   public void display(){
     System.out.println("display outer_x:"+ outer_x);
   }

   private void display2(){
    System.out.println("display outer_x:"+ outer_x);
   }

}

 public Inner getInner(){//即使是对外公开的方法,外部类也无法调用
   return new Inner();
 }

 void test(){ 
   Inner inner = new Inner(); //可以访问
   inner.display();
   inner.display2();
   //System.out.println("Inner y:" + y);//不能访问内部内变量
   System.out.println("Inner y:" + inner.y);//可以访问
   System.out.println("Inner z:" + inner.z);//可以访问
   System.out.println("Inner m:" + inner.m);//可以访问

   InnerTwo innerTwo = new InnerTwo();
   innerTwo.show();
 }

 class InnerTwo{
   Inner innerx = getInner();//可以访问
   public void show(){
    //System.out.println(y);//不可访问Innter的y成员
    //System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
    innerx.display();//可以访问
    innerx.display2();//可以访问
    System.out.println(innerx.y);//可以访问
    System.out.println(innerx.z);//可以访问
    System.out.println(innerx.m);//可以访问
   }
 }

}

public class Test
{
 public static void main(String args[]){
  
  Outer outer = new Outer();
 // Outer.Inner a=outer.getInner();//Inner类是私有的,外部类不能访问，如果Inner类是public ,则可以。
  outer.test();
 }
}

内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序
中的方法，不可直接访问内部类的变量。

四、在方法中定义内部类
如下所示代码为在方法内部定义一个内部类:

public class FunOuter { 
 int out_x = 100;

 public void test(){
  class Inner{
    String x = "x";
    void display(){
       System.out.println(out_x);
    }
  }
 Inner inner = new Inner();
 inner.display();
}

public void showStr(String str){
  //public String str1 = "test Inner";//不可定义，只允许final修饰
  //static String str4 = "static Str";//不可定义，只允许final修饰
  String str2 = "test Inner";
  final String str3 = "final Str";
  class InnerTwo{
    public void testPrint(){
    System.out.println(out_x);//可直接访问外部类的变量
    //System.out.println(str);//不可访问本方法内部的非final变量
    //System.out.println(str2);//不可访问本方法内部的非final变量
    System.out.println(str3);//只可访问本方法的final型变量成员
    }
  }
  InnerTwo innerTwo = new InnerTwo();
  innerTwo.testPrint();
}

public void use(){
   //Inner innerObj = new Inner();//此时Inner己不可见了。
   //System.out.println(Inner.x);//此时Inner己不可见了。
}


 public static void main(String[] args) {
  FunOuter outer = new FunOuter();
  outer.test();
 }
}

从上面的例程我们可以看出定义在方法内部的内部类的可见性更小，它只在方法内部可见，在外部类(及外部类的其它方法中)中都不可见了。同时，它有一个特点，就是方法内的内部类连本方法的成员变量都不可访问，它只能访问本方法的final型成员。同时另一个需引起注意的是方法内部定义成员，只允许final修饰或不加修饰符，其它像static等均不可用。

五、匿名内部类
如下所示代码为定义一个匿名内部类:匿名内部类通常用在Java的事件处理上

import java.applet.*;
import java.awt.event.*;

    public class AnonymousInnerClassDemo extends Applet{
    public void init(){
        addMouseListener(new MouseAdapter(){
            public void mousePressed(MouseEvent me){
             showStatus("Mouse Pressed!");
        }
        });
    }
    public void showStatus(String str){
        System.out.println(str);
    }
    }

在上面的例子中，方法addMouseListener接受一个对象型的参数表达式，于是，在参数里，我们定义了一个匿名内部类,这个类是一个MouseAdapter类型的类，同时在这个类中定义了一个继承的方法mousePressed，整个类做为一个参数。这个类没有名称，但是当执行这个表达式时它被自动实例化。同时因为，这个匿名内部类是定义在AnonymousInnerClassDemo 类内部的，所以它可以访问它的方法showStatus。这同前面的内部类是一致的。

六、内部类使用的其它的问题

通过以上，我们可以清楚地看出内部类的一些使用方法，同时，在许多时候，内部类是在如Java的事件处理、或做为值对象来使用的。同时，我们需注意最后一个问题，那就是，内部类同其它类一样被定义，同样它也可以继承外部其它包的类和实现外部其它地方的接口。同样它也可以继承同一层次的其它的内部类,甚至可以继承外部类本身。下面我们给出最后一个例子做为结束：

public class Layer {
  //Layer类的成员变量
  private String testStr = "testStr";

  //Person类，基类
  class Person{
    String name;
    Email email;
    public void setName(String nameStr){
     this.name = nameStr;
    }

    public String getName(){
      return this.name;
    } 

    public void setEmail(Email emailObj){
      this.email = emailObj;
    }

    public String getEmail(){
      return this.email.getMailStr();
    }

    //内部类的内部类，多层内部类
    class Email{ 
     String mailID;
     String mailNetAddress;

     Email(String mailId,String mailNetAddress){
     this.mailID = mailId;
     this.mailNetAddress = mailNetAddress;
     }

     String getMailStr(){
        return this.mailID +"@"+this.mailNetAddress;
     }
    } 
  }

   //另一个内部类继承外部类本身
   class ChildLayer extends Layer{
     void print(){
       System.out.println(super.testStr);//访问父类的成员变量
     }
   }

   //另个内部类继承内部类Person
    class OfficePerson extends Person{ 
     void show(){
       System.out.println(name);
       System.out.println(getEmail()); 
     }
    }

    //外部类的测试方法 
    public void testFunction(){
      //测试第一个内部类
      ChildLayer childLayer = new ChildLayer();
      childLayer.print();

      //测试第二个内部类
      OfficePerson officePerson = new OfficePerson();
      officePerson.setName("abner chai");
      //注意此处，必须用对象.new 出来对象的子类对象
      //而不是Person.new Email(...)
      //也不是new Person.Email(...)
      officePerson.setEmail(officePerson.new Email("josserchai","yahoo.com"));

       officePerson.show();
    }

     public static void main(String[] args) {
      Layer layer = new Layer();
      layer.testFunction();
     }
}

posted @ 2006-01-07 16:45 javaGrowing 阅读(329) | 评论 (0) | 编辑收藏

createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);参数

用缺省设置创建时，ResultSet 是一种只能访问一次（one-time-through）、只能向前访问（forward-only）和只读的对象。您只能访问数据一次，如果再次需要该数据，必须重新查询数据库。

然而，并不只有这一种方式。通过设置 Statement 对象上的参数，您可以控制它产生的 ResultSet。例如：

...
         Class.forName(driverName);
         db = DriverManager.getConnection(connectURL);
         Statement statement = db.createStatement(
                            ResultSet.TYPE_SCROLL_SENSITIVE,
                                                  ResultSet.CONCUR_UPDATABLE
                        );

         String orderElName = xmlfileEl.getElementsByTagName("order").item(0)
                                       .getFirstChild().getNodeValue();
...

这个 Statement 现在将产生可以更新并将应用其他数据库用户所作更改的 ResultSet。您还可以在这个 ResultSet 中向前和向后移动。

第一个参数指定 ResultSet 的类型。其选项有：

TYPE_FORWARD_ONLY：缺省类型。只允许向前访问一次，并且不会受到其他用户对该数据库所作更改的影响。
TYPE_SCROLL_INSENSITIVE：允许在列表中向前或向后移动，甚至可以进行特定定位，例如移至列表中的第四个记录或者从当前位置向后移动两个记录。不会受到其他用户对该数据库所作更改的影响。
TYPE_SCROLL_SENSITIVE：象 TYPE_SCROLL_INSENSITIVE 一样，允许在记录中定位。这种类型受到其他用户所作更改的影响。如果用户在执行完查询之后删除一个记录，那个记录将从 ResultSet 中消失。类似的，对数据值的更改也将反映在 ResultSet 中。
第二个参数设置 ResultSet 的并发性，该参数确定是否可以更新 ResultSet。其选项有：

CONCUR_READ_ONLY：这是缺省值，指定不可以更新 ResultSet
CONCUR_UPDATABLE：指定可以更新 ResultSet

posted @ 2006-01-06 16:31 javaGrowing 阅读(4420) | 评论 (1) | 编辑收藏

Introducing to Spring Framework

摘要: 作者：Rod Johnson 译者：yanger，taowen 校对：taowen 关于Spring Framework，今年夏天你可能已经听见很多的议论。在本文中,我将试图解释Spring能完成什么，和我怎么会认为它能帮助你开发J2EE应用程序。又来一个framework？你可能正在想“不过是另外一个的framework”。当已经有许多... 阅读全文

posted @ 2006-01-06 09:24 javaGrowing 阅读(328) | 评论 (0) | 编辑收藏

从 ASP.NET 服务器控件插入客户端脚本

从 ASP.NET 服务器控件插入客户端脚本

Scott Mitchell

2003 年 8 月

适用于：
Microsoft® ASP.NET

前提条件：本文假设读者熟悉 ASP.NET。

难度： 2

摘要：尽管从技术角度讲，ASP.NET 服务器控件的所有功能都可以在服务器端执行，但通常情况下通过添加客户端脚本可以大大增强服务器控件的可用性。本文将探讨服务器控件发送客户端脚本的两种方法，还将构建两个使用这些技术的服务器控件：PopupGreeting，一个在首次加载的 Web 页面上显示带有特定消息的客户端模式对话框的服务器控件；ConfirmButton，一个增强的 Button Web 控件，如果用户点击此按钮，则在发回 Web 窗体前向用户显示一个 JavaScript confirm() 的对话框。（本文包含一些指向英文站点的链接。）

下载 InjectingClientSideScript.msi。

尽管从技术角度讲，Microsoft® ASP.NET 服务器控件的所有功能都可以在服务器端执行，但通常情况下通过添加客户端脚本可以大大增强服务器控件的可用性。例如，ASP.NET 验证 Web 控件可以在服务器端执行所有的验证检查。但是，对于高版本浏览器，验证 Web 控件也会发送客户端脚本，以在客户端进行验证。这就是说，这些浏览器的用户可以获得响应效果更好的动态体验。

在开发 ASP.NET 服务器控件时，您不妨问问自己，如何才能通过使用客户端脚本来增强可用性。一旦找到可行的方案，其他要做的就是增强服务器控件的功能，以使其发送合适的客户端脚本。

ASP.NET 服务器控件可以发送两种客户端脚本：

客户端脚本块
客户端 HTML 属性

客户端脚本块通常是用 JavaScript 编写的，其中通常包含在发生特定的客户端事件时执行的函数。客户端 HTML 属性提供将客户端事件与客户端脚本联系在一起的方法。例如，以下的 HTML 页面中包含了客户端脚本块，脚本块中包含了名为 doClick() 的函数。该页面同时还包含一个按钮（通过 <input> HTML 元素创建），这个按钮的 onclick 属性与 doClick() 函数绑定。也就是说，只要用户单击该按钮，就开始执行 doClick() 函数中的客户端代码。在本示例中，将显示一个弹出式对话框（图 1）。

<html>
  <body>
    <form>
      <script language="JavaScript">
      <!--
         function doClick() {
            alert("You clicked me!");
         }
      // -->
      </script>

      <input type="button" onclick="doClick()" value="Click Me!" />
    </form>
  </body>
</html>

图 1 是单击“Click Me!”按钮时 HTML 页面的屏幕快照。

图 1：单击“Click Me!”按钮时显示的弹出式对话框

对于以上 HTML 页面中的客户端脚本，有几点值得注意。首先，客户端脚本块包含在 HTML 注释（）中。之所以这样，是因为如果不将脚本块放入 HTML 注释中，那些不能识别脚本的旧式浏览器就会显示 <script> 块的内容。此外，还要注意，脚本块中 HTML 注释的结束标记前有一个 JavaScript 注释，即 //。这是因为旧版本的 Netscape 在遇到 --> 时，会抛出 JavaScript 分析异常，因此必须将其注释掉。幸运的是，现代的浏览器已不需要这一额外操作，所以在为 Intranet 或其他由浏览器控制的环境开发 Web 页面时，您就不必采取此类预防措施了。

如果您对客户端脚本不是很熟悉，alert(string) 函数的作用就是显示一个模式弹出式对话框，对话框中包含的消息由 string 参数指定。所有 HTML 元素都有若干个可以绑定一段客户端 JavaScript 代码的客户端属性（例如，onclick、onmouseover、onmouseout、onfocus 和 onblur 等等）。例如，在上面的 HTML 页面中，<input> 元素的 onclick 属性绑定到 doClick() 函数，因此在单击该按钮时将执行 doClick() 函数。有关 JavaScript 事件及其关联的 HTML 属性的列表，请参阅 Introduction to Dynamic HTML 一文。有关客户端 JavaScript 的详细信息，请参阅 HTML and Dynamic HTML 一文。

在本文中，我们将学习如何在 ASP.NET 服务器控件中发送客户端脚本块和 HTML 元素属性。我们首先讨论如何使用 System.Web.UI.Page 类中的两个方法来向 ASP.NET Web 页面添加客户端脚本块，这两个方法是 RegisterStartupScript() 和 RegisterClientScriptBlock()。掌握这一知识后，我们将构建一个简单的服务器控件，让这个控件在每次加载页面时显示一个客户端弹出式对话框。之后，我们再来了解如何将 HTML 属性添加到 ASP.NET 服务器控件的 HTML 元素。最后，我们将归纳所有知识，实际构建一个 ConfirmButton Web 控件，当单击这个控件时，将向用户提示一个对话框，询问用户是否要继续。

使用 RegisterStartupScript() 和 RegisterClientScriptBlock() 添加客户端脚本块

System.Web.UI.Page 类包含的两个方法可以将客户端脚本代码发送到由 ASP.NET Web 页面提供的 HTML 中：

RegisterStartupScript(key, script)
RegisterClientScriptBlock(key, script)

这两个方法都接受两个字符串作为输入。第二个参数 script 是要插入到页面中的客户端脚本，包括 <script> 的起始标记和终止标记。第一个参数 key 是插入的客户端脚本的唯一标识符。

这两个方法唯一的不同之处在于从“何处”发送脚本块。RegisterClientScriptBlock() 在 Web 窗体的开始处（紧接着 <form runat="server"> 标识之后）发送脚本块，而 RegisterStartupScript() 在 Web 窗体的结尾处（在 </form> 标识之前）发送脚本块。

为什么会有两种不同的方法来发送客户端脚本？要更好地了解这一点，我们必须首先了解，客户端脚本可以分为两类：一类是在加载页面后立即运行的代码，一类是在发生某些客户端事件时才运行的代码。前者的常见示例是将焦点设置到文本框的客户端代码。例如，当您访问 Google 时，在页面加载后就会执行一小段客户端代码，以自动将焦点设置到搜索文本框。

以下是后一类代码（为响应客户端事件而运行的代码）的示例。具体而言，在该示例中，单击按钮时将显示一个弹出式对话框：

<html>
  <body>
    <form>
      <script language="JavaScript">
      <!--
        function displayPopup() {
            alert("Hello, world.");
        }
      // -->
      </script>

      <input type="button" value="Click Me!" onclick="displayPopup()" />
    </form>
  </body>
</html>

在这段代码中，<input> 标记中的 onclick="displayPopup()" 用于指明在单击按钮时，JavaScript 函数 displayPopup() 应该运行。

RegisterStartupScript() 方法可用于添加要在加载页面后运行的脚本块。通过这种方法添加的脚本块位于 Web 窗体的结尾处，因为必须在脚本运行前定义脚本要修改的 HTML 元素。也就是说，如果您要使用客户端脚本将焦点设置到文本框，必须确保文本框的 HTML 标记位于设置该文本框的焦点的脚本之前。例如，下面的 HTML 将显示一个文本框，并将焦点设置到该文本框：

<input type="text" id="myTextBox" />

<script language="JavaScript">
<!--
   document.getElementById("myTextBox").focus();
// -->
</script>

相反，以下 HTML 不会将焦点设置到文本框，因为文本框是在脚本块“之后”定义的：

<script language="JavaScript">
<!--
   document.getElementById("myTextBox").focus();
// -->
</script>

<input type="text" id="myTextBox" />

因此，RegisterStartupScript() 方法将 <script> 块置于 Web 窗体的结尾处，以保证在执行客户端脚本之前已声明 Web 窗体中的所有 HTML 元素。

RegisterClientScriptBlock() 方法用于为响应客户端事件而执行的脚本代码。通过此方法发送的脚本块位于 Web 页面的开始处，因为这种方法不要求将脚本块置于所有 HTML 元素之后。

探讨 IsStartupScriptRegistered() 和 IsClientScriptBlockRegistered()

除 RegisterStartupScript() 和 RegisterClientScriptBlock() 方法之外，Page 类还包含两个在发送客户端脚本时常用的辅助方法：

IsStartupScriptRegistered(key)
IsClientScriptBlockRegistered(key)

如上所述，在使用 RegisterStartupScript() 或 RegisterClientScriptBlock() 插入客户端脚本块时，提供了一个唯一标识脚本块的关键字。这两个方法都接受一个输入（字符串 key），并返回一个布尔值，以指示带有指定关键字的脚本块是否已添加到页面中。具体地说，如果带有特定 key 的脚本块已经注册，这些方法将返回 True，否则将返回 False。

要了解如何使用这两个方法，可以看一看 ASP.NET 验证 Web 控件，如 RequiredFieldValidator、RegularExpressionValidator 等等。这些控件都会用到一个常用的验证 JavaScript 文件 (WebValidation.js)，该文件位于 ASP.NET Web 应用程序的 aspnet_client/system_web/版本号 目录中。因此，所有这些控件都会发送相同的脚本块，这个脚本块将调用在 WebValidation.js 文件中定义的相应的 JavaScript 函数，以启动客户端的验证过程。要完成这个过程，这些控件会使用 Page 类的 RegisterClientScriptBlock() 方法，并使用关键字 ValidatorIncludeScript。

接下来要考虑的是，如果一个 ASP.NET Web 页面中包含多个验证 Web 控件，会出现什么情况呢？所有这些 Web 控件都要使用相同的关键字发送相同的脚本块。如果使用这个关键字调用两次 RegisterClientScriptBlock() 或 RegisterStartupScript() 方法，则第二次调用会被认为是复制脚本块而被忽略。因此，即使一个 Web 页面上有多个验证控件，也只是发送一个公共脚本块的实例。但是，请注意，除第一个控件之外的其他所有验证 Web 控件都会构建要发送的公共客户端脚本，而这只是在浪费时间。

这时就应该使用 IsClientScriptBlock() 和 IsStartupScript() 方法。这样一来，验证 Web 控件就不会先花时间构建要发送的客户端代码，而是先检查是否已经存在使用关键字 ValidatorIncludeScript 注册的脚本。如果存在，控件就会放弃构建客户端脚本块，因为脚本块已经由页面上的其他验证控件构建了。

因此，每次构建客户端脚本时，应该首先调用 IsClientScriptBlock() 或 IsStartupScript() 方法，以确定是否需要生成客户端脚本。在下面一节，我们将看到一些示例，在这些示例中，IsClientScriptBlock()、IsStartupScript() 方法先后与 RegisterClientScriptBlock() 和 RegisterStartupScript() 方法结合使用。

从 ASP.NET 服务器控件发送客户端脚本块

请记住，RegisterStartupScript() 和 RegisterClientScriptBlock() 方法是 System.Web.UI.Page 类的方法。幸运的是，可以容易地从 ASP.NET 服务器控件调用这两个方法，因为 System.Web.UI.Control 类（所有 ASP.NET 服务器控件都直接或间接地从这个类导出）有一个包含对 Page 实例的引用的 Page 属性，而这个 Page 实例包含服务器控件。因此，要从 ASP.NET 服务器控件添加客户端脚本块，您只需使用下面的语法：

this.Page.RegisterClientScriptBlock(key, script);

通常，添加客户端脚本块这个任务会使用 OnPreRender() 方法来处理，这个方法在控件生命周期的预呈现阶段执行。

让我们创建一个只显示客户端弹出式对话框的 ASP.NET 服务器控件。此示例将说明构建一个发送客户端脚本的控件是很容易的。

首先，在 Microsoft® Visual Studio® .NET 中创建一个新的 Web Control Library（Web 控件库）项目。这将创建一个只有一个类的新项目，这个类从 System.Web.UI.WebControls.WebControl 导出。但是，我们希望这个类从 System.Web.UI.Control 类导出。为什么呢？因为 WebControl 类用于支持显示为 HTML 元素的服务器控件，而 Control 类则用于不会显示为 HTML 元素的服务器控件。

大多数内置的 ASP.NET 服务器控件都会发送一个 HTML 元素。例如，TextBox Web 控件发送一个 <input> 元素，其类型属性设置为 text；DataGrid Web 控件发送一个 <table> 元素，为每条要显示的记录发送 <tr> 元素，为每个字段发送 <td> 列。但是，不是所有的控件都需要发送 HTML 元素。例如，Literal 控件只是按原样输出它的 Text 属性，而不将这个属性放在 HTML 元素中。同样，Repeater 也不将其输出放在 HTML 元素中。那些显示为 HTML 元素的服务器控件，如 TextBox、Button、DataGrid 等等，是从 System.Web.UI.WebControls.WebControl 类导出的，而那些不产生 HTML 元素的控件，如 Literal、Repeater 等，是从 System.Web.UI.Control 类导出的。

既然我们要创建的服务器控件不可见（它只是发送一个显示弹出式控件的客户端脚本块），这个控件最好从 System.Web.UI.Control 导出，而不是从 System.Web.UI.WebControls.WebControl 导出。

这个控件只需要两个属性：

PopupMessage - 表示要在弹出式对话框中显示的消息的字符串。
Enabled - 表示是否启用控件的布尔值。如果启用控件，则显示弹出式对话框，否则不显示。（必须添加一个 Enabled 属性，是因为导出该控件的 Control 类不包括 Enabled 属性，此属性只是隐含地由那些从 WebControl 导出的控件使用。）

除了这两种属性之外，我们需要覆盖 OnPreRender() 方法。在这里，我们需要调用 RegisterStartupScript()，并传递控件唯一的关键字和恰当的客户端脚本以显示弹出式对话框。这个类的完整代码如下所示：

using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;

namespace ClientSideScript
{
   /// <summary>
   /// WebCustomControl1 的摘要描述。
   /// </summary>
   [DefaultProperty("Text"),
      ToolboxData("<{0}opupGreeting runat=server></{0}opupGreeting>")]
   public class PopupGreeting : System.Web.UI.Control
   {
      [Bindable(true),
         Category("Appearance"),
         DefaultValue("")]
      public string PopupMessage
      {
         get
         {
            // 检查 ViewState 中是否存在该项目
            object popupMessage = this.ViewState["PopupMessage"];
            if (popupMessage != null)
               return this.ViewState["PopupMessage"].ToString();
            else
               return "Welcome to my Web site!";
         }

         set
         {
            // 指定 ViewState 变量
            ViewState["PopupMessage"] = value;
         }
      }

      [Bindable(true),
      Category("Appearance"),
      DefaultValue("")]
      public bool Enabled
      {
         get
         {
            // 检查 ViewState 中是否存在该项目
            object enabled = this.ViewState["Enabled"];
            if (enabled != null)
               return (bool) this.ViewState["Enabled"];
            else
               return true;
         }

         set
         {
            // 指定 ViewState 变量
            ViewState["Enabled"] = value;
         }
      }


      protected override void OnPreRender(EventArgs e)
      {
         base.OnPreRender;

string scriptKey = "intoPopupMessage:" + this.UniqueID;

         if (!Page.IsStartupScriptRegistered(scriptKey) && this.Enabled &&
                      !Page.IsPostBack)
         {
            string scriptBlock = 
               @"<script language=""JavaScript"">
               <!--
                  alert(""%%POPUP_MESSAGE%%"");
               // -->
               </script>";
            scriptBlock = scriptBlock.Replace("%%POPUP_MESSAGE%%", this.PopupMessage);

            Page.RegisterStartupScript(scriptKey, scriptBlock);
         }
      }
   }
}

请记住下面两件事：首先，Enabled 和 PopupMessage 属性保存在 ViewState 中，这样在回传时这些值可以始终保持一致；其次，在 OnPreRender() 方法中，用于脚本块的关键字是文本 intoPopupMessage: 加上控件的 UniqueID 属性。如果使用一个硬编码的关键字，则当页面中有多个控件时，只有第一个控件能够注册其脚本块，因此只显示一个弹出式对话框。通过在脚本块关键字中使用 UniqueID，就能保证该控件的每个实例都能获取其脚本块。

在注册脚本块之前，代码首先检查三个条件：

没有使用同一关键字注册的脚本。这当然是不可能的，因为每个控件实例都应该有一个 UniqueID 属性值。但是，不妨先练习使用 IsStartupScriptRegistered() 方法，然后再花时间创建和注册启动脚本。
控件的 Enabled 属性为 True。
页面没有被回传。这段代码只允许弹出式对话框在第一次加载页面时显示，而不是在每次回传页面时都显示。我们还可以增添更为灵活的功能，即为该控件添加一个布尔属性，以允许用户指定是否在回传时也生成弹出式对话框。

如果满足这三个条件，则脚本被指定，并且 PopupMessage 属性值被插入到脚本中适当的位置。最后，调用 Page 属性的 RegisterStartupScript() 方法，传入关键字及脚本代码。

PopupGreeting 代码可以从本文结尾处提供的下载中获得。该下载包括名为 ClientSideControlsAndTester 的 Visual Studio .NET 解决方案，其中包含两个项目：

ClientSideControls，包含 PopupGreeting 服务器控件
ClientSideTester，包括一个为测试 ClientSideControls 而设计的 ASP.NET Web 应用程序

ClientSideControls 项目编译后的程序集名为 ClientSideControls.dll。要在您自己的 ASP.NET Web 应用程序中使用 PopupGreeting 服务器控件，请将 ClientSideControls.dll 文件添加到您的 Web 应用程序的引用中。然后，在设计器中，右键单击 Toolbox（工具箱）并选择“Add/Remove Items . . .”（添加/删除项），再次选择 ClientSideControls.dll 文件。这样就向 Toolbox（工具箱）中添加了名为 PopupGreeting 的新项。然后，您可以从 Toolbox（工具箱）将该控件拖到设计器中。

图 2 显示了 PopupGreeting 控件添加到 Toolbox（工具箱）并添加到设计器后，Visual Studio .NET 的屏幕快照。Toolbox（工具箱）中的 PopupGreeting 控件用红色线圈出，设计器中的 PopupGreeting 输出用蓝色线圈出，在屏幕快照右侧的“Properties”（属性）窗格中可以查看 PopupGreeting 的属性。

图 2：PopupGreeting 服务器控件已添加到 ASP.NET Web 窗体页面

发送 ASP.NET 服务器 Web 控件的 HTML 属性

如上所述，有两种方法可以通过服务器控件发送客户端脚本：

通过使用客户端脚本块
通过 HTML 元素属性

在上一节中，我们探讨了如何使用 Page 类的 RegisterStartupScript() 和 RegisterClientScriptBlock() 方法向 ASP.NET Web 页面添加客户端脚本块。在最后这一节，我们了解如何将 HTML 元素属性添加到服务器控件的 HTML 元素。

在开始之前，请注意这种方法通常只适用于从 System.Web.UI.WebControls.WebControl 类导出的服务器控件，因为从这个类导出的控件会发送某些 HTML 元素。不发送 HTML 元素的服务器控件（如上一节中的 PopupGreeting 服务器控件），则不必写出 HTML 元素属性，因为这些控件运行时不会写出 HTML 元素。

WebControl 类包含一个将 HTML 元素属性添加到由 Web 控件发出的 HTML 元素的方法。该方法称为 AddAttributesToRender()，它只有一个输入参数，即 HtmlTextWriter 的实例。要向 Web 控件添加 HTML 属性，您可以使用 HtmlTextWriter 的以下两个方法之一：

AddAttribute()
AddStyleAttribute()

AddAttribute() 方法用于将 title、class、style 和 onclick 等 HTML 属性添加到 HTML 元素。AddStyleAttribute() 用于将样式设置添加到 HTML 元素，如 background-color、color 和 font-size 等。

AddAttribute() 有几个重载窗体，但在代码中，我们将使用以下窗体：AddAttribute(HtmlTextWriterAttribute, value)。第一个参数，即 HtmlTextWriterAttribute，应该是 HtmlTextWriterAttribute 枚举的成员。该枚举包含像 Align、Bgcolor、Class 和 Onclick 等项。您可以在 .NET Framework Class Library，HtmlTextWriterAttribute Enumeration 中找到完整的列表。value 输入参数用于指定分配给特定 HTML 属性的值。最后，如果您想添加一个 HtmlTextWriterAttribute 枚举中未定义的 HTML 属性，可以使用 AddAttribute() 方法的替代形式 AddAttribute(attributeName, value)，其中的 attributeName 和 value 均为字符串。

为了运用该信息，我们创建一个作为确认按钮的服务器 Web 控件。确认按钮是一种提交按钮，当用户单击此按钮时，将显示一个弹出式对话框，询问用户是否确定要继续操作。用户可以单击“取消”，不提交窗体。此项功能对用于删除信息的按钮特别有用，因为最终用户（或网站管理员）可能会在无意中单击鼠标删除数据库中的条目，如果没有机会取消，将是非常令人烦恼的事。

为了减少工作量，我们从 System.Web.UI.WebControls.Button 类中导出 ConfirmButton Web 控件，因为这个类本身已完成了涉及呈现提交按钮的所有繁重工作。在导出的类中，我们只需添加一个属性，这样用户可以指定确认消息，然后覆盖按钮的 AddAttributesToRender() 方法，并添加一个属性以处理客户端事件 onclick。

首先，在 Visual Studio .NET 中创建一个新的 Web Control Library（Web 控件库）项目，或者在 ClientSideControls 项目中添加一个新的 Web Custom Control（Web 自定义控件）。ConfirmButton 类的完整源代码如下所示：

using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;

namespace ClientSideControls
{
   /// <summary>
   /// ConfirmButton 的摘要描述。
   /// </summary>
   [DefaultProperty("Text"), 
      ToolboxData("<{0}:ConfirmButton runat=server></{0}:ConfirmButton>")]
   public class ConfirmButton : Button
   {
      [Bindable(true), 
         Category("Appearance"), 
         DefaultValue("")] 
      public string PopupMessage
      {
         get
         {
            // 检查 ViewState 中是否存在该项目
            object popupMessage = this.ViewState["PopupMessage"];
            if (popupMessage != null)
               return this.ViewState["PopupMessage"].ToString();
            else
               return "Are you sure you want to continue?";
         }

         set
         {
            // 指定 ViewState 变量
            ViewState["PopupMessage"] = value;
         }
      }


      protected override void AddAttributesToRender(HtmlTextWriter writer)
      {
         base.AddAttributesToRender(writer);

         string script = @"return confirm(""%%POPUP_MESSAGE%%"");";
         script = script.Replace("%%POPUP_MESSAGE%%", 
            this.PopupMessage.Replace("\"", "\\\""));

         writer.AddAttribute(HtmlTextWriterAttribute.Onclick, script);
      }
   }
}

首先要注意的是，ConfirmButton 类是从 Button 类导出的。由于 Button 类已包含 Button Web 控件使用的所有属性和方法，因此我们所做的只是添加属性和方法，以在用户单击按钮时显示一个确认对话框。现在我们需要一个属性，即 PopupMessage，它是要在确认弹出式对话框中显示的消息。默认情况下，这条消息是“Are you sure you want to continue?”（您确定要继续吗？）如果使用 ConfirmButton 来确认删除，可能需要将该消息更改为“This action will permanently delete the selected item. Are you sure you want to do this?”（此操作将永久删除所选项。您确定要继续吗？）

我们只需覆盖一个方法，即 AddAttributesToRender()。在此方法中，我们只要构建当触发 <input> 元素的 onclick 事件时要执行的客户端 JavaScript，然后通过传入的 HtmlTextWriter 对象的 AddAttribute() 方法添加这段 JavaScript。关于这个方法，有一点要注意，必须将 PopupMessage 属性值中的所有双引号实例替换为转义双引号（即 \"）。另外还要注意，默认情况下，AddAttribute() 会对第二个参数中的字符进行 HTML 编码。也就是说，ASP.NET Web 页面中如果包含 PopupMessage 属性被设置为“Do you want to continue?”（要继续吗？）的 ConfirmButton，该页面将发送以下 HTML 标记：

<input type="submit" name="ConfirmButton1" 
value="Click Me!" id="ConfirmButton1" onclick="return confirm
(&quot;Do you want to continue?&quot;" />

如果您不熟悉 JavaScript 的 confirm(string) 函数，那么请您注意，该函数只接受一个字符串参数，并显示一个带有特定字符串的模式对话框。该对话框中包含两个按钮：“确定”和“取消”。如果单击“确定”，confirm() 函数返回 True，否则返回 False。请注意，onclick 事件将返回 confirm() 函数调用的结果。当通过单击提交按钮来提交表单时，如果提交按钮的 onclick 事件返回 False，则表单未被提交。因此，只有在用户确认后，可以使用 confirm() 函数提交表单。有关 confirm() 的详细信息，请参阅 ASP Warrior 网站中的 Javascript Confirm Form Submission。

图 3：操作中的 ConfirmButton

ConfirmButton 在按钮的 onclick 事件处理程序中使用了内嵌的 JavaScript，还可以在 ConfirmButton 的 OnPreRender() 方法的客户端脚本块中创建一个函数，然后调整 onclick 属性以调用该函数。

小结

在本文中，我们探讨了两种通过 ASP.NET 服务器控件插入客户端脚本的方法。第一种方法是使用 Page 类的 RegisterStartupScript() 和 RegisterClientScriptBlock() 方法插入客户端脚本块。第二种方法是向 HTML 元素的属性添加客户端脚本。后者通过覆盖 Web 服务器控件的 AddAttributesToRender() 方法，并使用 HtmlTextWriter 的 AddAttribute() 方法来完成。

我们还在文中介绍了两个简单的服务器控件，它们都利用了客户端脚本来改进其功能。PopupGreeting 控件在页面首次加载时显示一个模式弹出式对话框，ConfirmButton Web 控件在用户单击按钮提交表单时，提示用户进行确认。

您可以在自己的服务器控件中插入客户端脚本，这将显著改善用户体验。本文提供的两个服务器控件相对比较简单，在可用性和独创性上没有什么突出之处。MetaBuilders.com 中展示了很多利用从 ASP.NET 服务器控件中插入客户端脚本而实现的功能，这些功能会给您留下深刻印象。在 MetaBuilders.com，您可以找到一些服务器控件，它们有的可以自动将焦点添加到文本框，有的可以在两个下拉列表之间传递条目，有的可以向下拉列表中添加或删除条目，还有的可以在一系列下拉列表中显示父子关系的数据，等等。最大的好处是，这些控件是免费的，并包括完整的源代码。

祝大家编程快乐！

作者简介

Scott Mitchell 著有五本关于 ASP/ASP.NET 的书籍，是 4GuysFromRolla.com 网站的创始人，过去五年来一直从事 Microsoft Web 技术方面的研究。Scott 是 ASP 和 ASP.NET 社区非常活跃的一名成员，十分热爱 ASP 和 ASP.NET 技术，并非常愿意帮助其他人了解这些令人振奋的技术。有关 DataGrid、DataList 和 Repeater 控件的详细信息，请参阅 Scott 的著作《ASP.NET Data Web Controls Kick Start》（ISBN 为 0672325012）。

对由 Microsoft® Internet 信息服务 (IIS) 处理的 Microsoft® ASP.NET 页面的每个请求都会被移交到 ASP.NET HTTP 管道。HTTP 管道由一系列托管对象组成，这些托管对象按顺序处理请求，并将 URL 转换为纯 HTML 文本。HTTP 管道的入口是 HttpRuntime 类。ASP.NET 结构为辅助进程中的每个 AppDomain 创建一个此类的实例。（请注意，辅助进程为每个当前正在运行的 ASP.NET 应用程序维护一个特定的 AppDomain。）

HttpRuntime 类从内部池中获取 HttpApplication 对象，并安排此对象来处理请求。HTTP 应用程序管理器完成的主要任务就是找到将真正处理请求的类。当请求 .aspx 资源时，处理程序就是页面处理程序，即从 Page 继承的类的实例。资源类型和处理程序类型之间的关联关系存储在应用程序的配置文件中。更确切地说，默认的映射集是在 machine.config 文件的 <httpHandlers> 部分定义的。但是，应用程序可以在本地的 web.config 文件中自定义自己的 HTTP 处理程序列表。以下这一行代码就是用来为 .aspx 资源定义 HTTP 处理程序的。

<add verb="*" path="*.aspx" type="System.Web.UI.PageHandlerFactory"/>

扩展名可以与处理程序类相关联，并且更多是与处理程序工厂类相关联。在所有情况下，负责处理请求的 HttpApplication 对象都会获得一个实现 IHttpHandler 接口的对象。如果根据 HTTP 处理程序来解析关联的资源/类，则返回的类将直接实现接口。如果资源被绑定到处理程序工厂，则还需要额外的步骤。处理程序工厂类实现 IHttpHandlerFactory 接口，此接口的 GetHandler 方法将返回一个基于 IHttpHandler 的对象。

HTTP 运行时是如何结束这个循环并处理页面请求的？ProcessRequest 方法在 IHttpHandler 接口中非常重要。通过对代表被请求页面的对象调用此方法，ASP.NET 结构会启动将生成浏览器输出的进程。

真正的 Page 类

特定页面的 HTTP 处理程序类型取决于 URL。首次调用 URL 时，将构建一个新的类，这个类被动态编译为一个程序集。检查 .aspx 资源的分析进程的结果是类的源代码。该类被定义为命名空间 ASP 的组成部分，并且被赋予了一个模拟原始 URL 的名称。例如，如果 URL 的终点是 page.aspx，则类的名称就是 ASP.Page_aspx。不过，类的名称可以通过编程方式来控制，方法是在 @Page 指令中设置 ClassName 属性。

HTTP 处理程序的基类是 Page。这个类定义了由所有页面处理程序共享的方法和属性的最小集合。Page 类实现 IHttpHandler 接口。

在很多情况下，实际处理程序的基类并不是 Page，而是其他的类。例如，如果使用了代码分离，就会出现这种情况。代码分离是一项开发技术，它可以将页面所需的代码隔离到单独的 C# 和 Microsoft Visual Basic® .NET 类中。页面的代码是一组事件处理程序和辅助方法，这些处理程序和方法真正决定了页面的行为。可以使用 <script runat=server> 标记对此代码进行内联定义，或者将其放置在外部类（代码分离类）中。代码分离类是从 Page 继承并使用额外的方法的类，被指定用作 HTTP 处理程序的基类。

还有一种情况，HTTP 处理程序也不是基于 Page 的，即在应用程序配置文件的 <pages> 部分中，包含了 PageBaseType 属性的重新定义。

<pages PageBaseType="Classes.MyPage, mypage" />

PageBaseType 属性指明包含页面处理程序的基类的类型和程序集。从 Page 导出的这个类可以自动赋予处理程序扩展的自定义方法和属性集。

页面的生命周期

完全识别 HTTP 页面处理程序类后，ASP.NET 运行时将调用处理程序的 ProcessRequest 方法来处理请求。通常情况下，无需更改此方法的实现，因为它是由 Page 类提供的。

此实现将从调用为页面构建控件树的 FrameworkInitialize 方法开始。FrameworkInitialize 方法是 TemplateControl 类（Page 本身从此类导出）的一个受保护的虚拟成员。所有为 .aspx 资源动态生成的处理程序都将覆盖 FrameworkInitialize。在此方法中，构建了页面的整个控件树。

接下来，ProcessRequest 使页面经历了各个阶段：初始化、加载视图状态信息和回发数据、加载页面的用户代码以及执行回发服务器端事件。之后，页面进入显示模式：收集更新的视图状态，生成 HTML 代码并随后将代码发送到输出控制台。最后，卸载页面，并认为请求处理完毕。

在各个阶段中，页面会触发少数几个事件，这些事件可以由 Web 控件和用户定义的代码截取并进行处理。其中的一些事件是嵌入式控件专用的，因此无法在 .aspx 代码级进行处理。

要处理特定事件的页面应该明确注册一个适合的处理程序。不过，为了向后兼容早期的 Visual Basic 编程风格，ASP.NET 也支持隐式事件挂钩的形式。默认情况下，页面会尝试将特定的方法名称与事件相匹配，如果实现匹配，则认为此方法就是匹配事件的处理程序。ASP.NET 提供了六种方法名称的特定识别，它们是 Page_Init、Page_Load、Page_DataBind、Page_PreRender 和 Page_Unload。这些方法被认为是由 Page 类提供的相应事件的处理程序。HTTP 运行时会自动将这些方法绑定到页面事件，这样，开发人员就不必再编写所需的粘接代码了。例如，如果命名为 Page_Load 的方法绑定到页面的 Load 事件，则可省去以下代码。

this.Load += new EventHandler(this.Page_Load);

对特定名称的自动识别是由 @Page 指令的 AutoEventWireup 属性控制的。如果该属性设置为 false，则要处理事件的所有应用程序都需要明确连接到页面事件。不使用自动绑定事件的页面性能会稍好一些，因为不需要额外匹配名称与事件。请注意，所有 Microsoft Visual Studio® .NET 项目都是在禁用 AutoEventWireup 属性的情况下创建的。但是，该属性的默认设置是 true，即 Page_Load 等方法会被识别，并被绑定到相关联的事件。

下表中按顺序列出了页面的执行包括的几个阶段，执行的标志是一些应用程序级的事件和/或受保护并可覆盖的方法。

表 1：ASP.NET 页面生命中的关键事件

阶段	页面事件	可覆盖的方法
页面初始化	Init
加载视图状态		LoadViewState
处理回发数据		任意实现 IPostBackDataHandler 接口的控件中的 LoadPostData 方法
加载页面	Load
回发更改通知		任意实现 IPostBackDataHandler 接口的控件中的 RaisePostDataChangedEvent 方法
处理回发事件	由控件定义的任意回发事件	任意实现 IPostBackDataHandler 接口的控件中的 RaisePostBackEvent 方法
页面显示前阶段	PreRender
保存视图状态		SaveViewState
显示页面		Render
卸载页面	Unload

以上所列的阶段中有些在页面级是不可见的，并且仅对服务器控件的编写者和要创建从 Page 导出的类的开发人员有意义。Init、Load、PreRender、Unload，再加上由嵌入式控件定义的所有回发事件，就构成了向外发送页面的各个阶段标记。

执行的各个阶段

页面生命周期中的第一个阶段是初始化。这个阶段的标志是 Init 事件。在成功创建页面的控件树后，将对应用程序触发此事件。换句话说，当 Init 事件发生时，.aspx 源文件中静态声明的所有控件都已实例化并采用各自的默认值。控件可以截取 Init 事件以初始化在传入的 Web 请求的生命周期内所需的所有设置。例如，这时控件可以加载外部模板文件或设置事件的处理程序。请注意，这时视图状态信息尚不可用。

初始化之后，页面框架将加载页面的视图状态。视图状态是名称/值对的集合，在此集合中，控件和页面本身存储了对所有 Web 请求都必须始终有效的全部信息。视图状态代表了页面的调用上下文。通常，它包含上次在服务器上处理页面时控件的状态。首次在会话中请求页面时，视图状态为空。默认情况下，视图状态存储在静默添加到页面的隐藏字段中，该字段的名称是 __VIEWSTATE。通过覆盖 LoadViewState 方法（Control 类的受保护、可覆盖方法），组件开发人员可以控制视图状态的存储方式以及视图状态的内容映射到内部状态的方式。

有些方法（如 LoadPageStateFromPersistenceMedium 以及其对应的 SavePageStateToPersistenceMedium），可以用来将视图状态加载并保存到其他存储介质（例如会话、数据库或服务器端文件）中。与 LoadViewState 不同，上述方法只能在从 Page 导出的类中使用。

存储视图状态之后，页面树中控件的状态与页面最后一次显示在浏览器中的状态相同。下一步是更新它们的状态以加入客户端的更改。处理回发数据阶段使控件有机会更新其状态，从而准确反映客户端相应的 HTML 元素的状态。例如，服务器的 TextBox 控件对应的 HTML 元素是 <input type=text>。在回发数据阶段，TextBox 控件将检索 <input> 标记的当前值，并使用该值来刷新自己内部的状态。每个控件都要从回发的数据中提取值并更新自己的部分属性。TextBox 控件将更新它的 Text 属性，而 CheckBox 控件将刷新它的 Checked 属性。服务器控件和 HTML 元素的对应关系可以通过二者的 ID 找到。

在处理回发数据阶段的最后，页面中的所有控件的状态都将使用客户端输入的更改来更新前一状态。这时，将对页面触发 Load 事件。

页面中可能会有一些控件，当其某个敏感属性在两个不同的请求中被修改时，需要完成特定的任务。例如，如果 TextBox 控件的文本在客户端被修改，则此控件将触发 TextChanged 事件。每个控件在其一个或多个属性被修改为客户端输入的值时都可以决定触发相应的事件。对于这些更改对其非常关键的控件，控件实现 IPostBackDataHandler 接口，此接口的 LoadPostData 方法是在 Load 事件后立即调用的。通过对 LoadPostData 方法进行编码，控件将验证自上次请求后是否发生了关键更改，并触发自己的更改事件。

页面生命周期中的关键事件是被调用以执行服务器端代码的事件，此代码与客户端触发的事件相关联。当用户单击按钮时，将回发页面。回发值的集合中包括启动整个操作的按钮的 ID。如果控件实现 IPostBackEventHandler 接口（如按钮和链接按钮），页面框架将调用 RaisePostBackEvent 方法。此方法的行为取决于控件的类型。就按钮和链接按钮而言，此方法将查找 Click 事件处理程序并运行相关的委托。

处理完回发事件之后，页面就可以显示了。这个阶段的标志是 PreRender 事件。控件可以利用这段时间来执行那些需要在保存视图状态和显示输出的前一刻执行的更新操作。下一个状态是 SaveViewState，在此状态中，所有控件和页面本身都将更新自己 ViewState 集合的内容。然后，将得到序列化、散列、Base64 编码的视图状态，而且此视图状态与隐藏字段 __VIEWSTATE 相关联。

通过覆盖 Render 方法可以改变各个控件的显示机制。此方法接受 HTML 书写器对象，并使用此对象来积累所有要为控件生成的 HTML 文本。Page 类的 Render 方法的默认实现包括对所有成员控件的递归调用。对于每个控件，页面都将调用 Render 方法，并缓存 HTML 输出。

页面生命中的最后一个标志是 Unload 事件，在页面对象消除之前发生。在此事件中，您应该释放所有可能占用的关键资源（例如文件、图形对象、数据库连接等）。

在此事件之后，也就是最后，浏览器接收 HTTP 响应数据包并显示页面。

小结

ASP.NET 页面对象模型因其事件机制而显得格外新颖独特。Web 页面由控件组成，这些控件既可以产生丰富的基于 HTML 的用户界面，又可以通过事件与用户交互。以前，在 Web 应用程序的上下文中设置事件模型是件有挑战性的工作。可我们惊奇的看到，客户端生成的事件可以由服务器端的代码来解决，而且只进行一些相应的修改后，此过程仍可以输出相同的 HTML 页面。

掌握这个模型对于了解页面生命周期的各个阶段，以及页面对象如何被 HTTP 运行时实例化并使用是非常重要的。

关于作者

Dino Esposito 是一位来自意大利罗马的培训教师和顾问。作为 Wintellect 团队的成员，Dino 专门研究 ASP.NET 和 ADO.NET，主要在欧洲和美国从事教学和咨询工作。此外，Dino 还负责管理 Wintellect 的 ADO.NET 课件，并为 MSDN 期刊的“Cutting Edge”专栏撰写文章。要与他联系，请向 dinoe@wintellect.com 发送电子邮件。

发表于 2003年11月4日 8:18

posted @ 2006-01-05 15:03 javaGrowing 阅读(239) | 评论 (0) | 编辑收藏

Session详解

作者：郎云鹏来自：dev2dev

作者：郎云鹏（dev2dev ID: hippiewolf）

摘要：虽然session机制在web应用程序中被采用已经很长时间了，但是仍然有很多人不清楚session机制的本质，以至不能正确的应用这一技术。本文将详细讨论session的工作机制并且对在Java web application中应用session机制时常见的问题作出解答。

目录：
一、术语session
二、HTTP协议与状态保持
三、理解cookie机制
四、理解session机制
五、理解javax.servlet.http.HttpSession
六、HttpSession常见问题
七、跨应用程序的session共享
八、总结
参考文档

一、术语session
在我的经验里，session这个词被滥用的程度大概仅次于transaction，更加有趣的是transaction与session在某些语境下的含义是相同的。

session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话时从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。有时候我们可以看到这样的话“在一个浏览器会话期间，...”，这里的会话一词用的就是其本义，是指从一个浏览器窗口打开到关闭这个期间①。最混乱的是“用户（客户端）在一次会话期间”这样一句话，它可能指用户的一系列动作（一般情况下是同某个具体目的相关的一系列动作，比如从登录到选购商品到结账登出这样一个网上购物的过程，有时候也被称为一个transaction），然而有时候也可能仅仅是指一次连接，也有可能是指含义 ①，其中的差别只能靠上下文来推断②。

然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义，“面向连接”指的是在通信双方在通信之前要先建立一个通信的渠道，比如打电话，直到对方接了电话通信才能开始，与此相对的是写信，在你把信发出去的时候你并不能确认对方的地址是否正确，通信渠道不一定能建立，但对发信人来说，通信已经开始了。“保持状态”则是指通信的一方能够把一系列的消息关联起来，使得消息之间可以互相依赖，比如一个服务员能够认出再次光临的老顾客并且记得上次这个顾客还欠店里一块钱。这一类的例子有“一个TCP session”或者“一个POP3 session”③。

而到了web服务器蓬勃发展的时代，session在web开发语境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器之间保持状态的解决方案④。有时候session也用来指这种解决方案的存储结构，如“把xxx保存在session里”⑤。由于各种用于web开发的语言在一定程度上都提供了对这种解决方案的支持，所以在某种特定语言的语境下，session也被用来指代该语言的解决方案，比如经常把Java里提供的 javax.servlet.http.HttpSession简称为session⑥。

鉴于这种混乱已不可改变，本文中session一词的运用也会根据上下文有不同的含义，请大家注意分辨。
在本文中，使用中文“浏览器会话期间”来表达含义①，使用“session机制”来表达含义④，使用“session”表达含义⑤，使用具体的“HttpSession”来表达含义⑥

二、HTTP协议与状态保持
HTTP协议本身是无状态的，这与HTTP协议本来的目的是相符的，客户端只需要简单的向服务器请求下载某些文件，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的，好比一个顾客和一个自动售货机或者一个普通的（非会员制）大卖场之间的关系一样。

然而聪明（或者贪心？）的人们很快发现如果能够提供一些按需生成的动态信息会使web变得更加有用，就像给有线电视加上点播功能一样。这种需求一方面迫使HTML逐步添加了表单、脚本、DOM等客户端行为，另一方面在服务器端则出现了CGI规范以响应客户端的动态请求，作为传输载体的HTTP协议也添加了文件上载、cookie这些特性。其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。

让我们用几个例子来描述一下cookie和session机制之间的区别与联系。笔者曾经常去的一家咖啡店有喝5杯咖啡免费赠一杯咖啡的优惠，然而一次性消费5杯咖啡的机会微乎其微，这时就需要某种方式来纪录某位顾客的消费数量。想象一下其实也无外乎下面的几种方案：
1、该店的店员很厉害，能记住每位顾客的消费数量，只要顾客一走进咖啡店，店员就知道该怎么对待了。这种做法就是协议本身支持状态。
2、发给顾客一张卡片，上面记录着消费的数量，一般还有个有效期限。每次消费时，如果顾客出示这张卡片，则此次消费就会与以前或以后的消费相联系起来。这种做法就是在客户端保持状态。
3、发给顾客一张会员卡，除了卡号之外什么信息也不纪录，每次消费时，如果顾客出示该卡片，则店员在店里的纪录本上找到这个卡号对应的纪录添加一些消费信息。这种做法就是在服务器端保持状态。

由于HTTP协议是无状态的，而出于种种考虑也不希望使之成为有状态的，因此，后面两种方案就成为现实的选择。具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上它还有其他选择。

三、理解cookie机制
cookie机制的基本原理就如上面的例子一样简单，但是还有几个问题需要解决：“会员卡”如何分发；“会员卡”的内容；以及客户如何使用“会员卡”。

正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript或者VBScript也可以生成cookie。

而cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。意思是麦当劳的会员卡只能在麦当劳的店里出示，如果某家分店还发行了自己的会员卡，那么进这家店的时候除了要出示麦当劳的会员卡，还要出示这家店的会员卡。

cookie的内容主要包括：名字，值，过期时间，路径和域。
其中域可以指定某一个域比如.google.com，相当于总店招牌，比如宝洁公司，也可以指定一个域下的具体某台机器比如www.google.com或者froogle.google.com，可以用飘柔来做比。
路径就是跟在域名后面的URL路径，比如/或者/foo等等，可以用某飘柔专柜做比。
路径与域合在一起就构成了cookie的作用范围。
如果不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览器会话期的 cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。如果设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。

存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式。对于IE，在一个打开的窗口上按Ctrl-N（或者从文件菜单）打开的窗口可以与原窗口共享，而使用其他方式新开的IE进程则不能共享已经打开的窗口的内存cookie；对于Mozilla Firefox0.8，所有的进程和标签页都可以共享同样的cookie。一般来说是用javascript的window.open打开的窗口会与原窗口共享内存cookie。浏览器对于会话cookie的这种只认cookie不认人的处理方式经常给采用session机制的web应用程序开发者造成很大的困扰。

下面就是一个goolge设置cookie的响应头的例子
HTTP/1.1 302 Found
Location: http://www.google.com/intl/zh-CN/
Set-Cookie: PREF=ID=0565f77e132de138:NW=1:TM=1098082649:LM=1098082649:S=KaeaCFPo49RiA_d8; expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com
Content-Type: text/html

这是使用HTTPLook这个HTTP Sniffer软件来俘获的HTTP通讯纪录的一部分

浏览器在再次访问goolge的资源时自动向外发送cookie

使用Firefox可以很容易的观察现有的cookie的值
使用HTTPLook配合Firefox可以很容易的理解cookie的工作原理。

IE也可以设置在接受cookie前询问

这是一个询问接受cookie的对话框。

四、理解session机制
session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。

当程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否已包含了一个session标识 - 称为session id，如果已包含一个session id则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（如果检索不到，可能会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。

保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于 SEEESIONID，而。比如weblogic对于web应用程序生成的cookie，JSESSIONID= ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764，它的名字就是 JSESSIONID。

由于cookie可以被人为的禁止，必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。经常被使用的一种技术叫做URL重写，就是把session id直接附加在URL路径的后面，附加方式也有两种，一种是作为URL路径的附加信息，表现形式为http://...../xxx; jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764
另一种是作为查询字符串附加在URL后面，表现形式为http://...../xxx?jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764
这两种方式对于用户来说是没有区别的，只是服务器在解析的时候处理的方式不同，采用第一种方式也有利于把session id的信息和正常程序参数区分开来。
为了在整个交互过程中始终保持状态，就必须在每个客户端可能请求的路径后面都包含这个session id。

另一种技术叫做表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时能够把session id传递回服务器。比如下面的表单
<form name="testform" action="/xxx">
<input type="text">
</form>
在被传递给客户端之前将被改写成
<form name="testform" action="/xxx">
<input type="hidden" name="jsessionid" value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764">
<input type="text">
</form>
这种技术现在已较少应用，笔者接触过的很古老的iPlanet6(SunONE应用服务器的前身)就使用了这种技术。
实际上这种技术可以简单的用对action应用URL重写来代替。

在谈论session机制的时候，常常听到这样一种误解“只要关闭浏览器，session就消失了”。其实可以想象一下会员卡的例子，除非顾客主动对店家提出销卡，否则店家绝对不会轻易删除顾客的资料。对session来说也是一样的，除非程序通知服务器删除一个session，否则服务器会一直保留，程序一般都是在用户做log off的时候发个指令去删除session。然而浏览器从来不会主动在关闭之前通知服务器它将要关闭，因此服务器根本不会有机会知道浏览器已经关闭，之所以会有这种错觉，是大部分session机制都使用会话cookie来保存session id，而关闭浏览器后这个session id就消失了，再次连接服务器时也就无法找到原来的session。如果服务器设置的cookie被保存到硬盘上，或者使用某种手段改写浏览器发出的 HTTP请求头，把原来的session id发送给服务器，则再次打开浏览器仍然能够找到原来的session。

恰恰是由于关闭浏览器不会导致session被删除，迫使服务器为seesion设置了一个失效时间，当距离客户端上一次使用session的时间超过这个失效时间时，服务器就可以认为客户端已经停止了活动，才会把session删除以节省存储空间。

五、理解javax.servlet.http.HttpSession
HttpSession是Java平台对session机制的实现规范，因为它仅仅是个接口，具体到每个web应用服务器的提供商，除了对规范支持之外，仍然会有一些规范里没有规定的细微差异。这里我们以BEA的Weblogic Server8.1作为例子来演示。

首先，Weblogic Server提供了一系列的参数来控制它的HttpSession的实现，包括使用cookie的开关选项，使用URL重写的开关选项，session持久化的设置，session失效时间的设置，以及针对cookie的各种设置，比如设置cookie的名字、路径、域，cookie的生存时间等。

一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用，Weblogic Server支持的持久性方式包括文件、数据库、客户端cookie保存和复制。

复制严格说来不算持久化保存，因为session实际上还是保存在内存里，不过同样的信息被复制到各个cluster内的服务器进程中，这样即使某个服务器进程停止工作也仍然可以从其他进程中取得session。

cookie生存时间的设置则会影响浏览器生成的cookie是否是一个会话cookie。默认是使用会话cookie。有兴趣的可以用它来试验我们在第四节里提到的那个误解。

cookie的路径对于web应用程序来说是一个非常重要的选项，Weblogic Server对这个选项的默认处理方式使得它与其他服务器有明显的区别。后面我们会专题讨论。

关于session的设置参考[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869

六、HttpSession常见问题
（在本小节中session的含义为⑤和⑥的混合）

1、session在何时被创建
一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <%@page session="false"%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。

由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

2、session何时被删除
综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）

3、如何做到在浏览器关闭时删除session
严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。

4、有个HttpSessionListener是怎么回事
你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有HttpSessionBindingListener，HttpSessionActivationListener和 HttpSessionAttributeListener。

5、存放在session中的对象必须是可序列化的吗
不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。在Weblogic Server的session中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果session中有不可序列化的对象，在session销毁时会有一个Exception，很奇怪。

6、如何才能正确的应付客户端禁止cookie的可能性
对所有的URL使用URL重写，包括超链接，form的action，和重定向的URL，具体做法参见[6]
http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770

7、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session
参见第三小节对cookie的讨论，对session来说是只认id不认人，因此不同的浏览器，不同的窗口打开方式以及不同的cookie存储方式都会对这个问题的答案有影响。

8、如何防止用户打开两个浏览器窗口操作导致的session混乱
这个问题与防止表单多次提交是类似的，可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端，同时保存在session里，客户端提交表单时必须把这个id也返回服务器，程序首先比较返回的id与保存在session里的值是否一致，如果不一致则说明本次操作已经被提交过了。可以参看《J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口，一般不设置这个id，或者使用单独的id，以防主窗口无法操作，建议不要再window.open打开的窗口里做修改操作，这样就可以不用设置。

9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue
做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。

10、为什么session不见了
排除session正常失效的因素之外，服务器本身的可能性应该是微乎其微的，虽然笔者在 iPlanet6SP1加若干补丁的Solaris版本上倒也遇到过；浏览器插件的可能性次之，笔者也遇到过3721插件造成的问题；理论上防火墙或者代理服务器在cookie处理上也有可能会出现问题。
出现这一问题的大部分原因都是程序的错误，最常见的就是在一个应用程序中去访问另外一个应用程序。我们在下一节讨论这个问题。

七、跨应用程序的session共享

常常有这样的情况，一个大项目被分割成若干小项目开发，为了能够互不干扰，要求每个小项目作为一个单独的web应用程序开发，可是到了最后突然发现某几个小项目之间需要共享一些信息，或者想使用session来实现SSO (single sign on)，在session中保存login的用户信息，最自然的要求是应用程序间能够访问彼此的session。

然而按照Servlet规范，session的作用范围应该仅仅限于当前应用程序下，不同的应用程序之间是不能够互相访问对方的session的。各个应用服务器从实际效果上都遵守了这一规范，但是实现的细节却可能各有不同，因此解决跨应用程序session共享的方法也各不相同。

首先来看一下Tomcat是如何实现web应用程序之间session的隔离的，从Tomcat设置的cookie路径来看，它对不同的应用程序设置的cookie路径是不同的，这样不同的应用程序所用的session id是不同的，因此即使在同一个浏览器窗口里访问不同的应用程序，发送给服务器的session id也可以是不同的。

根据这个特性，我们可以推测Tomcat中session的内存结构大致如下。

笔者以前用过的iPlanet也采用的是同样的方式，估计SunONE与iPlanet之间不会有太大的差别。对于这种方式的服务器，解决的思路很简单，实际实行起来也不难。要么让所有的应用程序共享一个session id，要么让应用程序能够获得其他应用程序的session id。

iPlanet中有一种很简单的方法来实现共享一个session id，那就是把各个应用程序的cookie路径都设为/（实际上应该是/NASApp，对于应用程序来讲它的作用相当于根）。
<session-info>
<path>/NASApp</path>
</session-info>

需要注意的是，操作共享的session应该遵循一些编程约定，比如在session attribute名字的前面加上应用程序的前缀，使得setAttribute("name", "neo")变成setAttribute("app1.name", "neo")，以防止命名空间冲突，导致互相覆盖。

在Tomcat中则没有这么方便的选择。在Tomcat版本3上，我们还可以有一些手段来共享session。对于版本4以上的 Tomcat，目前笔者尚未发现简单的办法。只能借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段。

我们再看一下Weblogic Server是如何处理session的。

从截屏画面上可以看到Weblogic Server对所有的应用程序设置的cookie的路径都是/，这是不是意味着在Weblogic Server中默认的就可以共享session了呢？然而一个小实验即可证明即使不同的应用程序使用的是同一个session，各个应用程序仍然只能访问自己所设置的那些属性。这说明Weblogic Server中的session的内存结构可能如下

对于这样一种结构，在session机制本身上来解决session共享的问题应该是不可能的了。除了借助于第三方的力量，比如使用文件、数据库、 JMS或者客户端cookie，URL参数或者隐藏字段等手段，还有一种较为方便的做法，就是把一个应用程序的session放到 ServletContext中，这样另外一个应用程序就可以从ServletContext中取得前一个应用程序的引用。示例代码如下，

应用程序A
context.setAttribute("appA", session);

应用程序B
contextA = context.getContext("/appA");
HttpSession sessionA = (HttpSession)contextA.getAttribute("appA");

值得注意的是这种用法不可移植，因为根据ServletContext的JavaDoc，应用服务器可以处于安全的原因对于context.getContext("/appA");返回空值，以上做法在Weblogic Server 8.1中通过。

那么Weblogic Server为什么要把所有的应用程序的cookie路径都设为/呢？原来是为了SSO，凡是共享这个session的应用程序都可以共享认证的信息。一个简单的实验就可以证明这一点，修改首先登录的那个应用程序的描述符weblogic.xml，把cookie路径修改为/appA访问另外一个应用程序会重新要求登录，即使是反过来，先访问cookie路径为/的应用程序，再访问修改过路径的这个，虽然不再提示登录，但是登录的用户信息也会丢失。注意做这个实验时认证方式应该使用FORM，因为浏览器和web服务器对basic认证方式有其他的处理方式，第二次请求的认证不是通过session来实现的。具体请参看[7] secion 14.8 Authorization，你可以修改所附的示例程序来做这些试验。

八、总结
session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的经验，而是始终需要具体情况具体分析。

关于作者：
郎云鹏（dev2dev ID: hippiewolf），软件工程师，从事J2EE开发
电子邮件：langyunpeng@yahoo.com.cn
地址：大连软件园路31号科技大厦A座大连博涵咨询服务有限公司

参考文档：
[1] Preliminary Specification http://wp.netscape.com/newsref/std/cookie_spec.html
[2] RFC2109 http://www.rfc-editor.org/rfc/rfc2109.txt
[3] RFC2965 http://www.rfc-editor.org/rfc/rfc2965.txt
[4] The Unofficial Cookie FAQ http://www.cookiecentral.com/faq/
[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869
[6] http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770
[7] RFC2616 http://www.rfc-editor.org/rfc/rfc2616.txt

posted @ 2006-01-04 22:22 javaGrowing 阅读(387) | 评论 (0) | 编辑收藏

Java 理论与实践: 用弱引用堵住内存泄漏

作者：Brian Goetz 来自：developerWorks 中国

　　虽然用 Java™ 语言编写的程序在理论上是不会出现“内存泄漏”的，但是有时对象在不再作为程序的逻辑状态的一部分之后仍然不被垃圾收集。本月，负责保障应用程序健康的工程师 Brian Goetz 探讨了无意识的对象保留的常见原因，并展示了如何用弱引用堵住泄漏。
　　要让垃圾收集（GC）回收程序不再使用的对象，对象的逻辑生命周期（应用程序使用它的时间）和对该对象拥有的引用的实际生命周期必须是相同的。在大多数时候，好的软件工程技术保证这是自动实现的，不用我们对对象生命周期问题花费过多心思。但是偶尔我们会创建一个引用，它在内存中包含对象的时间比我们预期的要长得多，这种情况称为无意识的对象保留（unintentional object retention）。

　　全局 Map 造成的内存泄漏

　　无意识对象保留最常见的原因是使用 Map 将元数据与临时对象（transient object）相关联。假定一个对象具有中等生命周期，比分配它的那个方法调用的生命周期长，但是比应用程序的生命周期短，如客户机的套接字连接。需要将一些元数据与这个套接字关联，如生成连接的用户的标识。在创建 Socket 时是不知道这些信息的，并且不能将数据添加到 Socket 对象上，因为不能控制 Socket 类或者它的子类。这时，典型的方法就是在一个全局 Map 中存储这些信息，如清单 1 中的 SocketManager 类所示：

　　清单 1. 使用一个全局 Map 将元数据关联到一个对象

public class SocketManager {
    private Map<Socket,User> m = new HashMap<Socket,User>();

    public void setUser(Socket s, User u) {
        m.put(s, u);
    }
    public User getUser(Socket s) {
        return m.get(s);
    }
    public void removeUser(Socket s) {
        m.remove(s);
    }
}

SocketManager socketManager;
...
socketManager.setUser(socket, user);

　　这种方法的问题是元数据的生命周期需要与套接字的生命周期挂钩，但是除非准确地知道什么时候程序不再需要这个套接字，并记住从 Map 中删除相应的映射，否则，Socket 和 User 对象将会永远留在 Map 中，远远超过响应了请求和关闭套接字的时间。这会阻止 Socket 和 User 对象被垃圾收集，即使应用程序不会再使用它们。这些对象留下来不受控制，很容易造成程序在长时间运行后内存爆满。除了最简单的情况，在几乎所有情况下找出什么时候 Socket 不再被程序使用是一件很烦人和容易出错的任务，需要人工对内存进行管理。

　　找出内存泄漏

　　程序有内存泄漏的第一个迹象通常是它抛出一个 OutOfMemoryError，或者因为频繁的垃圾收集而表现出糟糕的性能。幸运的是，垃圾收集可以提供能够用来诊断内存泄漏的大量信息。如果以 -verbose:gc 或者 -Xloggc 选项调用 JVM，那么每次 GC 运行时在控制台上或者日志文件中会打印出一个诊断信息，包括它所花费的时间、当前堆使用情况以及恢复了多少内存。记录 GC 使用情况并不具有干扰性，因此如果需要分析内存问题或者调优垃圾收集器，在生产环境中默认启用 GC 日志是值得的。

　　有工具可以利用 GC 日志输出并以图形方式将它显示出来，JTune 就是这样的一种工具（请参阅参考资料）。观察 GC 之后堆大小的图，可以看到程序内存使用的趋势。对于大多数程序来说，可以将内存使用分为两部分：baseline 使用和 current load 使用。对于服务器应用程序，baseline 使用就是应用程序在没有任何负荷、但是已经准备好接受请求时的内存使用，current load 使用是在处理请求过程中使用的、但是在请求处理完成后会释放的内存。只要负荷大体上是恒定的，应用程序通常会很快达到一个稳定的内存使用水平。如果在应用程序已经完成了其初始化并且负荷没有增加的情况下，内存使用持续增加，那么程序就可能在处理前面的请求时保留了生成的对象。

　　清单 2 展示了一个有内存泄漏的程序。MapLeaker 在线程池中处理任务，并在一个 Map 中记录每一项任务的状态。不幸的是，在任务完成后它不会删除那一项，因此状态项和任务对象（以及它们的内部状态）会不断地积累。

　　清单 2. 具有基于 Map 的内存泄漏的程序

public class MapLeaker {
    public ExecutorService exec = Executors.newFixedThreadPool(5);
    public Map<Task, TaskStatus> taskStatus
        = Collections.synchronizedMap(new HashMap<Task, TaskStatus>());
    private Random random = new Random();

private enum TaskStatus { NOT_STARTED, STARTED, FINISHED };

private class Task implements Runnable {
private int[] numbers = new int[random.nextInt(200)];

        public void run() {
            int[] temp = new int[random.nextInt(10000)];
            taskStatus.put(this, TaskStatus.STARTED);
            doSomeWork();
            taskStatus.put(this, TaskStatus.FINISHED);
        }
    }

    public Task newTask() {
        Task t = new Task();
        taskStatus.put(t, TaskStatus.NOT_STARTED);
        exec.execute(t);
        return t;
    }
}

　　图 1 显示 MapLeaker GC 之后应用程序堆大小随着时间的变化图。上升趋势是存在内存泄漏的警示信号。（在真实的应用程序中，坡度不会这么大，但是在收集了足够长时间的 GC 数据后，上升趋势通常会表现得很明显。）

图 1. 持续上升的内存使用趋势

　　确信有了内存泄漏后，下一步就是找出哪种对象造成了这个问题。所有内存分析器都可以生成按照对象类进行分解的堆快照。有一些很好的商业堆分析工具，但是找出内存泄漏不一定要花钱买这些工具 —— 内置的 hprof 工具也可完成这项工作。要使用 hprof 并让它跟踪内存使用，需要以 -Xrunhprof:heap=sites 选项调用 JVM。

　　清单 3 显示分解了应用程序内存使用的 hprof 输出的相关部分。（hprof 工具在应用程序退出时，或者用 kill -3 或在 Windows 中按 Ctrl+Break 时生成使用分解。）注意两次快照相比，Map.Entry、Task 和 int[] 对象有了显著增加。

　　请参阅清单 3。

　　清单 4 展示了 hprof 输出的另一部分，给出了 Map.Entry 对象的分配点的调用堆栈信息。这个输出告诉我们哪些调用链生成了 Map.Entry 对象，并带有一些程序分析，找出内存泄漏来源一般来说是相当容易的。

　　清单 4. HPROF 输出，显示 Map.Entry 对象的分配点

TRACE 300446:
java.util.HashMap$Entry.<init>(<Unknown Source>:Unknown line)
java.util.HashMap.addEntry(<Unknown Source>:Unknown line)
java.util.HashMap.put(<Unknown Source>:Unknown line)
java.util.Collections$SynchronizedMap.put(<Unknown Source>:Unknown line)
com.quiotix.dummy.MapLeaker.newTask(MapLeaker.java:48)
com.quiotix.dummy.MapLeaker.main(MapLeaker.java:64)

　　弱引用来救援了

　　SocketManager 的问题是 Socket-User 映射的生命周期应当与 Socket 的生命周期相匹配，但是语言没有提供任何容易的方法实施这项规则。这使得程序不得不使用人工内存管理的老技术。幸运的是，从 JDK 1.2 开始，垃圾收集器提供了一种声明这种对象生命周期依赖性的方法，这样垃圾收集器就可以帮助我们防止这种内存泄漏 —— 利用弱引用。

　　弱引用是对一个对象（称为 referent）的引用的持有者。使用弱引用后，可以维持对 referent 的引用，而不会阻止它被垃圾收集。当垃圾收集器跟踪堆的时候，如果对一个对象的引用只有弱引用，那么这个 referent 就会成为垃圾收集的候选对象，就像没有任何剩余的引用一样，而且所有剩余的弱引用都被清除。（只有弱引用的对象称为弱可及（weakly reachable）。）

　　WeakReference 的 referent 是在构造时设置的，在没有被清除之前，可以用 get() 获取它的值。如果弱引用被清除了（不管是 referent 已经被垃圾收集了，还是有人调用了 WeakReference.clear()），get() 会返回 null。相应地，在使用其结果之前，应当总是检查 get() 是否返回一个非 null 值，因为 referent 最终总是会被垃圾收集的。

　　用一个普通的（强）引用拷贝一个对象引用时，限制 referent 的生命周期至少与被拷贝的引用的生命周期一样长。如果不小心，那么它可能就与程序的生命周期一样 —— 如果将一个对象放入一个全局集合中的话。另一方面，在创建对一个对象的弱引用时，完全没有扩展 referent 的生命周期，只是在对象仍然存活的时候，保持另一种到达它的方法。

　　弱引用对于构造弱集合最有用，如那些在应用程序的其余部分使用对象期间存储关于这些对象的元数据的集合 —— 这就是 SocketManager 类所要做的工作。因为这是弱引用最常见的用法，WeakHashMap 也被添加到 JDK 1.2 的类库中，它对键（而不是对值）使用弱引用。如果在一个普通 HashMap 中用一个对象作为键，那么这个对象在映射从 Map 中删除之前不能被回收，WeakHashMap 使您可以用一个对象作为 Map 键，同时不会阻止这个对象被垃圾收集。清单 5 给出了 WeakHashMap 的 get() 方法的一种可能实现，它展示了弱引用的使用：

　　清单 5. WeakReference.get() 的一种可能实现

public class WeakHashMap<K,V> implements Map<K,V> {

    private static class Entry<K,V> extends WeakReference<K>
      implements Map.Entry<K,V> {
        private V value;
        private final int hash;
        private Entry<K,V> next;
        ...
    }

    public V get(Object key) {
        int hash = getHash(key);
        Entry<K,V> e = getChain(hash);
        while (e != null) {
            K eKey= e.get();
            if (e.hash == hash && (key == eKey || key.equals(eKey)))
                return e.value;
            e = e.next;
        }
        return null;
    }

　　调用 WeakReference.get() 时，它返回一个对 referent 的强引用（如果它仍然存活的话），因此不需要担心映射在 while 循环体中消失，因为强引用会防止它被垃圾收集。WeakHashMap 的实现展示了弱引用的一种常见用法 —— 一些内部对象扩展 WeakReference。其原因在下面一节讨论引用队列时会得到解释。

　　在向 WeakHashMap 中添加映射时，请记住映射可能会在以后“脱离”，因为键被垃圾收集了。在这种情况下，get() 返回 null，这使得测试 get() 的返回值是否为 null 变得比平时更重要了。

　　用 WeakHashMap 堵住泄漏

　　在 SocketManager 中防止泄漏很容易，只要用 WeakHashMap 代替 HashMap 就行了，如清单 6 所示。（如果 SocketManager 需要线程安全，那么可以用 Collections.synchronizedMap() 包装 WeakHashMap）。当映射的生命周期必须与键的生命周期联系在一起时，可以使用这种方法。不过，应当小心不滥用这种技术，大多数时候还是应当使用普通的 HashMap 作为 Map 的实现。

　　清单 6. 用 WeakHashMap 修复 SocketManager

public class SocketManager {
    private Map<Socket,User> m = new WeakHashMap<Socket,User>();

    public void setUser(Socket s, User u) {
        m.put(s, u);
    }
    public User getUser(Socket s) {
        return m.get(s);
    }
}

　　引用队列

　　WeakHashMap 用弱引用承载映射键，这使得应用程序不再使用键对象时它们可以被垃圾收集，get() 实现可以根据 WeakReference.get() 是否返回 null 来区分死的映射和活的映射。但是这只是防止 Map 的内存消耗在应用程序的生命周期中不断增加所需要做的工作的一半，还需要做一些工作以便在键对象被收集后从 Map 中删除死项。否则，Map 会充满对应于死键的项。虽然这对于应用程序是不可见的，但是它仍然会造成应用程序耗尽内存，因为即使键被收集了，Map.Entry 和值对象也不会被收集。

　　可以通过周期性地扫描 Map，对每一个弱引用调用 get()，并在 get() 返回 null 时删除那个映射而消除死映射。但是如果 Map 有许多活的项，那么这种方法的效率很低。如果有一种方法可以在弱引用的 referent 被垃圾收集时发出通知就好了，这就是引用队列的作用。

　　引用队列是垃圾收集器向应用程序返回关于对象生命周期的信息的主要方法。弱引用有两个构造函数：一个只取 referent 作为参数，另一个还取引用队列作为参数。如果用关联的引用队列创建弱引用，在 referent 成为 GC 候选对象时，这个引用对象（不是 referent）就在引用清除后加入到引用队列中。之后，应用程序从引用队列提取引用并了解到它的 referent 已被收集，因此可以进行相应的清理活动，如去掉已不在弱集合中的对象的项。（引用队列提供了与 BlockingQueue 同样的出列模式 —— polled、timed blocking 和 untimed blocking。）

　　WeakHashMap 有一个名为 expungeStaleEntries() 的私有方法，大多数 Map 操作中会调用它，它去掉引用队列中所有失效的引用，并删除关联的映射。清单 7 展示了 expungeStaleEntries() 的一种可能实现。用于存储键-值映射的 Entry 类型扩展了 WeakReference，因此当 expungeStaleEntries() 要求下一个失效的弱引用时，它得到一个 Entry。用引用队列代替定期扫描内容的方法来清理 Map 更有效，因为清理过程不会触及活的项，只有在有实际加入队列的引用时它才工作。

　　清单 7. WeakHashMap.expungeStaleEntries() 的可能实现

    private void expungeStaleEntries() {
Entry<K,V> e;
        while ( (e = (Entry<K,V>) queue.poll()) != null) {
            int hash = e.hash;

            Entry<K,V> prev = getChain(hash);
            Entry<K,V> cur = prev;
            while (cur != null) {
                Entry<K,V> next = cur.next;
                if (cur == e) {
                    if (prev == e)
                        setChain(hash, next);
                    else
                        prev.next = next;
                    break;
                }
                prev = cur;
                cur = next;
            }
        }
    }

　　结束语

　　弱引用和弱集合是对堆进行管理的强大工具，使得应用程序可以使用更复杂的可及性方案，而不只是由普通（强）引用所提供的“要么全部要么没有”可及性。下个月，我们将分析与弱引用有关的软引用，将分析在使用弱引用和软引用时，垃圾收集器的行为。

posted @ 2006-01-04 18:35 javaGrowing 阅读(242) | 评论 (0) | 编辑收藏

扩展Struts

作者：Sunil Patil
翻译：loryliu

版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:
Sunil Patil;loryliu
原文地址:
http://www.onjava.com/pub/a/onjava/2004/11/10/ExtendingStruts.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43857_Struts.html
关键词： extending Struts

简介

我见过许多项目开发者实现自己专有的MVC框架。这些开发者并不是因为想实现不同于Struts的某些功能，而是还没有意识到怎么去扩展Struts。通过开发自己的MVC框架，你可以掌控全局，但同时这也意味着你必须付出很大的代价；在项目计划很紧的情况下也许根本就不可能实现。

Struts不但功能强大也易于扩展。你可以通过三种方式来扩展Struts:

1.PlugIn：在应用启动或关闭时须执行某业务逻辑，创建你自己的PlugIn类

2.RequestProcessor：在请求处理阶段一个特定点欲执行某业务逻辑，创建你自己的RequestProcessor。例如：你想继承RequestProcessor来检查用户登录及在执行每个请求时他是否有权限执行某个动作。

3.ActionServlet：在应用启动或关闭或在请求处理阶段欲执行某业务逻辑，继承ActionServlet类。但是必须且只能在PligIn和RequestProcessor都不能满足你的需求时候用。

本文会列举一个简单的Struts应用来示范如何使用以上三种方式扩展Struts。在本文末尾资源区有每种方式的可下载样例源代码。Struts Validation 框架和 Tiles 框架是最成功两个的Struts扩展例子。

我是假设读者已经熟悉Struts框架并知道怎样使用它创建简单的应用。如想了解更多有关Struts的资料请参见资源区。

PlugIn

根据Struts文档，“PlugIn是一个须在应用启动和关闭时需被通知的模块定制资源或服务配置包”。这就是说，你可以创建一个类，它实现PlugIn的接口以便在应用启动和关闭时做你想要的事。

假如创建了一个web应用，其中使用Hibernate做为持久化机制；当应用一启动，就需初始化Hinernate，这样在web应用接收到第一个请求时，Hibernate已被配置完毕并待命。同时在应用关闭时要关闭Hibernate。跟着以下两步可以实现Hibernate PlugIn的需求。

1.创建一个实现PlugIn接口的类，如下：

public class HibernatePlugIn implements PlugIn{
        private String configFile;
        // This method will be called at application shutdown time
        public void destroy() {
                System.out.println("Entering HibernatePlugIn.destroy()");
                //Put hibernate cleanup code here
                System.out.println("Exiting HibernatePlugIn.destroy()");
        }
        //This method will be called at application startup time
        public void init(ActionServlet actionServlet, ModuleConfig config)
                throws ServletException {
                System.out.println("Entering HibernatePlugIn.init()");
                System.out.println("Value of init parameter " +
                                    getConfigFile());
                System.out.println("Exiting HibernatePlugIn.init()");
        }
        public String getConfigFile() {
                return name;
        }
        public void setConfigFile(String string) {
                configFile = string;
        }
}

实现PlugIn接口的类必须是实现以下两个方法：
init() 和destroy().。在应用启动时init()被调用，关闭destroy()被调用。Struts允许你传入初始参数给你的PlugIn类；为了传入参数你必须在PlugIn类里为每个参数创建一个类似JavaBean形式的setter方法。在HibernatePlugIn类里，欲传入 configFile的名字而不是在应用里将它硬编码进去

2.在struts-condig.xml里面加入以下几行告知Struts这个新的PlugIn

<struts-config>
        ...
        <!-- Message Resources -->
        <message-resources parameter=
          "sample1.resources.ApplicationResources"/>

        <!-- Declare your plugins -->
        <plug-in className="com.sample.util.HibernatePlugIn">
                <set-property property="configFile"
                   value="/hibernate.cfg.xml"/>
        </plug-in>
</struts-config>

ClassName 属性是实现PlugIn接口类的全名。为每一个初始化传入PlugIn类的初始化参数增加一个<set-property>元素。在这个例子里，传入config文档的名称，所以增加了一个config文档路径的<set-property>元素。

Tiles和Validator框架都是利用PlugIn给初始化读入配置文件。另外两个你还可以在PlugIn类里做的事情是：

假如应用依赖于某配置文件，那么可以在PlugIn类里检查其可用性，假如配置文件不可用则抛出ServletException。这将导致ActionServlet不可用。

PlugIn接口的init()方法是你改变ModuleConfig方法的最后机会，ModuleConfig方法是描述基于Struts模型静态配置信息的集合。一旦PlugIn被处理完毕，Struts就会将ModuleCOnfig冻结起来。

请求是如何被处理的

ActionServlet 是Struts框架里唯一一个Servlet，它负责处理所有请求。它无论何时收到一个请求，都会首先试着为现有请求找到一个子应用。一旦子应用被找到，它会为其生成一个RequestProcessor对象，并调用传入HttpServletRequest和HttpServletResponse为参数的process()方法。

大部分请处理都是在RequestProcessor.process()发生的。Process()方法是以模板方法（Template Method）的设计模式来实现的，其中有完成request处理的每个步骤的方法；所有这些方法都从process()方法顺序调用。例如，寻找当前请求的ActionForm类和检查当前用户是否有权限执行action mapping都有几个单独的方法。这给我们提供了极大的弹性空间。Struts的RequestProcessor对每个请求处理步骤都提供了默认的实现方法。这意味着，你可以重写你感兴趣的方法，而其余剩下的保留默认实现。例如，Struts默认调用request.isUserInRole()检查用户是否有权限执行当前的ActionMapping，但如果你需要从数据库中查找，那么你要做的就是重写processRoles()方法，并根据用户角色返回true 或 false。

首先我们看一下process()方法的默认实现方式，然后我将解释RequestProcessor类里的每个默认的方法，以便你决定要修改请求处理的哪一部分。

public void process(HttpServletRequest request,
                        HttpServletResponse response)
    throws IOException, ServletException {
        // Wrap multipart requests with a special wrapper
        request = processMultipart(request);
        // Identify the path component we will
        // use to select a mapping
        String path = processPath(request, response);
        if (path == null) {
            return;
        }
        if (log.isDebugEnabled()) {
            log.debug("Processing a '" + request.getMethod() +
                      "' for path '" + path + "'");
        }
        // Select a Locale for the current user if requested
        processLocale(request, response);
        // Set the content type and no-caching headers
        // if requested
        processContent(request, response);
        processNoCache(request, response);
        // General purpose preprocessing hook
        if (!processPreprocess(request, response)) {
            return;
       }
        // Identify the mapping for this request
        ActionMapping mapping =
            processMapping(request, response, path);
        if (mapping == null) {
            return;
        }
        // Check for any role required to perform this action
        if (!processRoles(request, response, mapping)) {
            return;
        }
        // Process any ActionForm bean related to this request
        ActionForm form =
            processActionForm(request, response, mapping);
        processPopulate(request, response, form, mapping);
        if (!processValidate(request, response, form, mapping)) {
            return;
        }
        // Process a forward or include specified by this mapping
        if (!processForward(request, response, mapping)) {
            return;
        }
        if (!processInclude(request, response, mapping)) {
            return;
        }
        // Create or acquire the Action instance to
        // process this request
        Action action =
            processActionCreate(request, response, mapping);
        if (action == null) {
            return;
        }
        // Call the Action instance itself
        ActionForward forward =
            processActionPerform(request, response,
                                action, form, mapping);
        // Process the returned ActionForward instance
        processForwardConfig(request, response, forward);
    }

1、processMultipart(): 在这个方法中，Struts读取request以找出contentType是否为multipart/form-data。假如是，则解析并将其打包成一个实现HttpServletRequest的包。当你成生一个放置数据的HTML FORM时，request的contentType默认是application/x-www-form-urlencoded。但是如果你的form 的input类型是FILE-type允许用户上载文件，那么你必须把form的contentType改为multipart/form-data。如这样做，你永远不能通过HttpServletRequest的getParameter()来读取用户提交的form值；你必须以 InputStream的形式读取request，然后解析它得到值。

2、processPath(): 在这个方法中，Struts将读取request的URI以判断用来得到ActionMapping元素的路径。

3、processLocale(): 在这个方法中，Struts将得到当前request的Locale；Locale假如被配置，将作为 org.apache.struts.action.LOCALE属性的值被存入HttpSession。这个方法的附作用是HttpSession会被创建。假如你不想此事发生，可将在struts-config.xml 文件里ControllerConfig的local属性设置为false,如下：

<controller>
        <set-property property="locale" value="false"/>
</controller>

4、processContent()：通过调用response.setContentType()设置response的contentType。这个方法首先会试着的得到配置在struts-config.xml里的contentType。默认为text/html，重写方法如下：

<controller>
        <set-property property="contentType" value="text/plain"/>
</controller>

5、processNoCache()：Struts将为每个response的设置以下三个header，假如已在struts 的config.xml将配置为no-cache。

response.setHeader("Pragma", "No-cache");
response.setHeader("Cache-Control", "no-cache");
response.setDateHeader("Expires", 1);

假如你想设置为no-cache header，在struts-config.xml中加如以下几行

<controller>
        <set-property property="noCache" value="true"/>
</controller>

6、processPreprocess()：这是一个一般意义的预处理hook，其可被子类重写。在RequestProcessor里的实现什么都没有做，总是返回true。如此方法返回false会中断请求处理。

7、processMapping():这个方法会利用path信息找到ActionMapping对象。ActionMapping对象在struts-config.xml file文件里表示为<action>

<action path="/newcontact" type="com.sample.NewContactAction"
        name="newContactForm" scope="request">
        <forward name="sucess" path="/sucessPage.do"/>
        <forward name="failure" path="/failurePage.do"/>
</action>

ActionMapping元素包含了如Action类的名称及在请求中用到的ActionForm的信息，另外还有配置在当前ActionMapping的里的ActionForwards信息。

8、processRoles(): Struts的web 应用安全提供了一个认证机制。这就是说，一旦用户登录到容器，Struts的processRoles()方法通过调用request.isUserInRole()可以检查他是否有权限执行给定的ActionMapping。
<action path="/addUser" roles="administrator"/>

假如你有一个AddUserAction，限制只有administrator权限的用户才能新添加用户。你所要做的就是在AddUserAction 的action元素里添加一个值为administrator的role属性。

9、processActionForm()：每个ActionMapping都有一个与它关联的ActionForm类。struts在处理ActionMapping时，他会从<action>里name属性找到相关的ActionForm类的值。

<form-bean name="newContactForm" 
           type="org.apache.struts.action.DynaActionForm">
                <form-property name="firstName"
                          type="java.lang.String"/>
                <form-property name="lastName"
                          type="java.lang.String"/>
</form-bean>

在这个例子里，首先会检查org.apache.struts.action.DynaActionForm类的对象是否在request 范围内。如是，则使用它，否则创建一个新的对象并在request范围内设置它。

10、processPopulate():：在这个方法里，Struts将匹配的request parameters值填入ActionForm类的实例变量中。

11、processValidate()：Struts将调用ActionForm的validate()方法。假如validate()返回ActionErrors，Struts将用户转到由<action>里的input属性标示的页面。

12、processForward() and processInclude()：在这两个方法里，Struts检查<action>元素的forward和include属性的值，假如有配置，则把forward和include 请求放在配置的页面内。

<action forward="/Login.jsp" path="/loginInput"/>
        <action include="/Login.jsp" path="/loginInput"/>

你可以从他们的名字看出其不同之处。processForward()调用RequestDispatcher.forward(),， processInclude()调用RequestDispatcher.include()。假如你同时配置了orward 和include 属性，Struts总会调用forward，因为forward,是首先被处理的。

13、processActionCreate()：这个方法从<action>的type属性得到Action类名，并创建返回它的实例。在这里例子中struts将创建一个com.sample.NewContactAction类的实例。

14、processActionPerform()：这个方法调用Action 类的execute()方法，其中有你写入的业务逻辑。

15、processForwardConfig()：Action类的execute()将会返回一个ActionForward类型的对象，指出哪一页面将展示给用户。因此Struts将为这个页面创建RequestDispatchet，然后再调用RequestDispatcher.forward()方法。

以上列出的方法解释了RequestProcessor在请求处理的每步默认实现及各个步骤执行的顺序。正如你所见，RequestProcessor很有弹性，它允许你通过设置<controller>里的属性来配置它。例如，假如你的应用将生成XML内容而不是HTML，你可以通过设置 controller的某个属性来通知Struts。

创建你自己的RequestProcessor

从以上内容我们已经明白了RequestProcessor的默认实现是怎样工作的，现在我将通过创建你自己的RequestProcessor.展示一个怎样自定义RequestProcessor的例子。为了演示创建一个自定义RequestProcessor，我将修改例子实现以下连个业务需求：

我们要创建一个ContactImageAction类，它将生成images而不是一般的HTMl页面

在处理这个请求之前，将通过检查session里的userName属性来确认用户是否登录。假如此属性没有被找到，则将用户转到登录页面。

分两步来实现以上连个业务需求。
创建你自己的CustomRequestProcessor类，它将继承RequestProcessor类，如下：

public class CustomRequestProcessor
    extends RequestProcessor {
        protected boolean processPreprocess (
            HttpServletRequest request,
            HttpServletResponse response) {
            HttpSession session = request.getSession(false);
        //If user is trying to access login page
        // then don't check
        if( request.getServletPath().equals("/loginInput.do")
            || request.getServletPath().equals("/login.do") )
            return true;
        //Check if userName attribute is there is session.
        //If so, it means user has allready logged in
        if( session != null &&
        session.getAttribute("userName") != null)
            return true;
        else{
            try{
                //If no redirect user to login Page
                request.getRequestDispatcher 
                    ("/Login.jsp").forward(request,response);
            }catch(Exception ex){
            }
        }
        return false;
    }

    protected void processContent(HttpServletRequest request,
                HttpServletResponse response) {
            //Check if user is requesting ContactImageAction
            // if yes then set image/gif as content type
            if( request.getServletPath().equals("/contactimage.do")){
                response.setContentType("image/gif");
                return;
            }
        super.processContent(request, response);
    }
}

在CustomRequestProcessor 类的processPreprocess方法里，检查session的userName属性，假如没有找到，将用户转到登录页面。

对于产生images作为ContactImageAction类的输出，必须要重写processContent方法。首先检查其request是否请求 /contactimage路径，如是则设置contentType为image/gif；否则为text/html。

加入以下几行代码到sruts-config.xml文件里的<action-mapping>后面，告知Struts ，CustomRequestProcessor应该被用作RequestProcessor类

<controller>
        <set-property  property="processorClass"
        value="com.sample.util.CustomRequestProcessor"/>
</controller>

请注意，假如你只是很少生成contentType不是text/html输出的Action类，重写processContent()就没有问题。如不是这种情况，你必须创建一个Struts子系统来处理生成image Action的请求并设置contentType为image/gif

Title框架使用自己的RequestProcessor来装饰Struts生成的输出。

ActionServlet

假如你仔细研究Struts web应用的web.xml文件，它看上去像这样：

<web-app >
        <servlet>
            <servlet-name>action=</servlet-name>
            <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
            <!-- All your init-params go here-->
        </servlet>
        <servlet-mapping>
            <servlet-name>action</servlet-name>
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
</web-app >

这就是说，ActionServlet负责处理所有发向Struts的请求。你可以创建ActionServlet的一个子类，假如你想在应用启动和关闭时或每次请求时做某些事情。但是你必须在继承ActionServlet类前创建PlugIn 或 RequestProcessor。在Servlet 1.1前，Title框架是基于继承ActionServlet类来装饰一个生成的response。但从1.1开始，就使用 TilesRequestProcessor类。

结论

开发你自己的MVC模型是一个很大的决心——你必须考虑开发和维护代码的时间和资源。Struts是一个功能强大且稳定的框架，你可以修改它以使其满足你大部分的业务需求。

另一方面，也不要轻易地决定扩展Struts。假如你在RequestProcessor里放入一些低效率的代码，这些代码将在每次请求时执行并大大地降低整个应用的效率。当然总有创建你自己的MVC框架比扩展Struts更好的情况。

资源
下载本文源码：[下载文件]
Struts主页
"Jakarta Struts框架介绍"
"学习Jakarta Struts 1.1"

Sunil Pail已从事J2EE四年，现今与IBM实验室合作。

posted @ 2005-12-30 09:48 javaGrowing 阅读(336) | 评论 (0) | 编辑收藏

利用Jakarta Commons组件beanutils、dbutils简化JDBC数据库操作（一）

关键字：beanutils、dbutils、JDBC 数据库
摘要：本文简单介绍了Jakarta Commons旗下beanutils、dbutils在基于JDBC API数据库存取操作中的运用。
     虽然现在出现了很多ORM框架，可是还是有很多朋友也许还在使用JDBC，就像我现在一样，除了学习的时候在使用Hibernate、Spring类似这些优秀的框架，工作时一直都在使用JDBC。本文就简单介绍一下利用Jakarta Commons旗下beanutils、dbutils简化JDBC数据库操作，以抛砖引玉，希望对像我一样在使用JDBC的朋友有所帮助。
    下面就分两部分简单介绍beanutils、dbutils在基于JDBC API数据库存取操作中的运用。第一部分显介绍beanutils在JDBC数据库存取操作中的运用，第二部分介绍dbutils在JDBC数据库存取操作中的运用，最后看看他们的优缺点，谈谈本人在项目运用过程中对他们的一点心得体会，仅供参考，其中有错误的地方希望大虾不吝赐教，大家多多交流共同进步。
一、Jakarta Commons beanutils
       Beanutils是操作Bean的锐利武器，其提过的BeanUtils工具类可以简单方便的读取或设置Bean的属性，利用Dyna系列，还可以在运行期创建Bean，符合懒人的习惯，正如LazyDynaBean，LazyDynaClass一样，呵呵。这些用法已经有很多文章提及，也可以参考apache的官方文档。
对于直接利用JDBC API访问数据库时（这里针对的是返回结果集ResultSet的查询select），大多数都是采用两种方式，一种是取出返回的结果集的数据存于Map中，另一种方式是Bean里。针对第二种方式，Beanutils里提供了ResultSetDynaClass结合DynaBean以及RowSetDynaClass结合DynaBean来简化操作。下面用以个简单的例子展示一下beanutils的这两个类在JDBC数据库操作中的运用。
请在本机建立数据库publish，我用的是MySQL，在publish数据库中建立表book,脚本如下：
CREATE TABLE book(
  id int(11) NOT NULL auto_increment,
  title varchar(50) character set latin1 NOT NULL,
  authors varchar(50) character set latin1 default NULL,
  PRIMARY KEY  (id)
)
         然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:
         然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:
package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.ResultSetDynaClass;
public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     ResultSetDynaClass rsDynaClass = new ResultSetDynaClass(rs);
                     Iterator itr = rsDynaClass.iterator();
                     System.out.println("title-------------authors");
                     while (itr.hasNext()) {
                            DynaBean dBean = (DynaBean) itr.next();
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"title")
                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "authors"));
                     }
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
       }
}
用RowSetDynaClass处理的源代码如下所示:
package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.RowSetDynaClass;
public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              List rsDynaClass = rsTest();
              System.out.println("title ------------- authors ");
              Iterator itr = rsDynaClass.iterator();
              while (itr.hasNext()) {
                     DynaBean dBean = (DynaBean) itr.next();
                     try {
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"name")
                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "mobile"));
                     } catch (Exception e) {
                            // TODO 自动生成 catch 块
                            e.printStackTrace();
                     }
              }
       }
       private static List rsTest() {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     RowSetDynaClass rsdc = new RowSetDynaClass(rs);
                     return rsdc.getRows();
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
              return null;
       }
}
这两个方法输出的结果应该是一样的。但是很显然第二种方式比第一种方式要好，它把数据访问部分抽取出来放到一个方法中，显得简单清晰。
其实在利用ResultSetDynaClass时，必须在ResultSet等数据库资源关闭之前，处理好那些数据，你不能在资源关闭之后使用DynaBean，否则就会抛出异常，异常就是说不能在ResultSet之后存取数据（具体的异常名我也忘了），当然你也可以采用以前的方式一个一个的把数据放到Map里，如果你一定要那样做，建议还是别用Beanutils，因为这没带给你什么好处。总之利用ResultSetDynaClass你的程序的扩展性非常部好。
从第二中方式可以看出，利用RowSetDynaClass可以很好的解决上述ResultSetDynaClass遇到的问题，RowSetDynaClass的getRows()方法，把每一行封装在一个DynaBean对象里，然后，把说有的行放到一个List里，之后你就可以对返回的List里的每一个DynaBean进行处理，此外对于DynaBean你还可以采用标准的get/set方式处理，当然你也可以用PropertyUtils. getSimpleProperty(Object bean, String name)进行处理。
从上面的分析中，你应该可以决定你应该使用ResultSetDynaClass还是RowSetDynaClass了。

posted @ 2005-12-29 22:41 javaGrowing 阅读(282) | 评论 (0) | 编辑收藏

利用Jakarta Commons组件beanutils、dbutils简化JDBC数据库操作（二）

二、Jakarta Commons dbutils：
    用JDBC API时最令人讨厌的就是异常处理，也很烦琐，而且很容易出错，本人曾考虑过利用模板进行处理，后来看到了dbutils，之后就采用那个dbutils，采用模板的方式各位朋友可以参考Spring，Spring的JdbcTemplate不灵活而强大，呵呵，说句闲话，实在太佩服Rod Johnson了，Rod Johnson真的很令人尊敬。
    Dbutils的QueryRunner把大多数与关闭资源相关的封装起来，另外，你也可以使用DbUtils进行关闭，当然DbUtils提供的功能当然不止这些，它提过了几个常用的静态方法，除了上述的关闭资源外，DbUtils. commitAndClose(Connection conn)还提供事务提及等操作。
还是以一个例子来说说吧，毕竟我不是搞业务的，小嘴巴吧嗒吧哒不起来啊，呵呵。
    为了和采用Beanutils更好的进行对比，这个例子还是实现同样的功能，数据库同样采用前一篇文章中提到的publish。
同样的，用你喜欢的编辑器建立一个类DbutilsJDBCTest，示例代码如下所示:
package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapListHandler;
public class DbutilsJDBCTest{
    public static void main(String[] args) {
        Connection conn = null;
        String jdbcURL = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
        String jdbcDriver = "com.mysql.jdbc.Driver";
        try {
            DbUtils.loadDriver(jdbcDriver);
            // Username "root". Password "root"
            conn = DriverManager.getConnection(jdbcURL, "root", "root");
            QueryRunner qRunner = new QueryRunner();
            System.out.println("***Using MapListHandler***");
            //以下部分代码采用Map存储方式，可以采用Bean的方式代替进行处理
            List lMap = (List) qRunner.query(conn,
                    "select title,authors  from books", new MapListHandler());
            //以下是处理代码，可以抽取出来
System.out.println("title ------------- authors ");
                for (int i = 0; i < lMap.size(); i++) {
                        Map vals = (Map) lMap.get(i);
                        System.out.println(vals.get("title")+"-------------"+ vals.get("authors"));
                }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
    }
}

怎么样?是不是比采用Beanutils的ResultSetDynaTrial和RowSetDynaClass好多了？采用Beanutils令人难缠的是关闭那些资源以及处理那些异常，而这里采用Dbutils显然代码量减少了很多。
上例在处理结果集时，它把数据库中的每一行映射成一个Map，其中列名作为Key，该列对应的值作为Value存放，查询的所有的数据一起放在一个List里，然后进行处理，当然，一个更明智的处理是直接返回List然后再单独进行处理。
事实上上例返回的结果集中的每一行不必放在一个Map里，你可以放在一个Bean里，当然如果你真的很懒，你也可以使用Beanutils的LazyDynaClass和LazyDynaBean，不过也许没有必要那么做，至于原因请看下文。

如果使用Bean而不是用Map，那么，你也许需要建立一个Bean，如下：
package cn.qtone.test;
public class Book {
    public int id;
    public String title;
    public String authors ;
    public StudentBean() {
    }
    public String getAuthors() {
        return authors;
    }
    public void setAuthors(String authors) {
        this.authors = authors;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
}

然后简单修改一下DbutilsJDBCTest 中的部分代码即可，代替之后的源代码如下：

package cn.qtone.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;

public class DbutilsJDBCTest{
    public static void main(String[] args) {
        Connection conn = null;
        String jdbcURL = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
        String jdbcDriver = "com.mysql.jdbc.Driver";
        try {
            DbUtils.loadDriver(jdbcDriver);
            // Username "root". Password "root"
            conn = DriverManager.getConnection(jdbcURL, "root", "root");
            QueryRunner qRunner = new QueryRunner();
            System.out.println("***Using BeanListHandler ***");
            //以下部分代码采用Map存储方式，可以采用Bean的方式代替进行处理
List lBeans = (List) qRunner.query(conn," select title,authors from books ", new BeanListHandler(Book.class));
    //以下是处理代码，可以抽取出来
System.out.println("title ------------- authors ");
    for (int i = 0; i < lBeans.size(); i++) {
            Book vals = (Book) lBeans.get(i);
          System.out.println(vals.getTitle ()+"-------------"+ vals. getAuthors ());
                }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
    }
}
    这两种法输出的结果应该是一样的。两种处理方式都差不多，但我更愿意采用第一种，因为第一种少写一个bean，而且我测试过采用Map的方式即第一种方式性能要好的多，采用Bean性能比较低可能是因为采用反射的缘故，采用反射的东东性能和不采用反射的还是有点差距。也是这个原因，不推荐采用LazyDynaClass和LazyDynaBean，因为采用这二者是在运行期动态创建Bean类和Bean属性，然后再创建Bean对象的，其性能可想而知了（不过我没有测试过啊，所以我说这个话可说是没有根据的，感兴趣的朋友自己测试一下，记得告诉我结果哦，呵呵），除了MapListHandler以及BeanListHandler之外，DButils还提供了其他的Handler，如果这些不能满足你的需求，你也可以自己实现一个Handler。
    最后，也是最大的体会,也许是最大的收获吧，那就是:对于每一个项目,在根据每一个需求获取相应解决方案时,先寻找开源组件,看是否已经有满足某些功能需求的开源组件,如果没有,再考虑自主开发或者向第三方购买，否则尽量采用开源组件.
    请尽量享用开源的魅力，尽情的拥抱开源吧。
    好了，终于写完了，有什么问题请联系我，大家互相交流交流。

posted @ 2005-12-29 22:39 javaGrowing 阅读(277) | 评论 (0) | 编辑收藏

Ant实践

1. Ant是什么？
2. 安装Ant
3. 运行Ant
4. 编写build.xml
5. 内置task(internet)
6. EAR task(internet)
7. WAR task(internet)
8. JUnit task(internet)

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

1.Ant是什么？

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

Ant是一种基于Java的build工具。理论上来说，它有些类似于（Unix）C中的make ，但没有make的缺陷。

既然我们已经有了make, gnumake, nmake, jam以及其他的build工具为什么还要要一种新的build工具呢？因为Ant的原作者在多种(硬件)平台上开发软件时，无法忍受这些工具的限制和不便。类似于make的工具本质上是基于shell（语言）的：他们计算依赖关系，然后执行命令（这些命令与你在命令行敲的命令没太大区别）。这就意味着你可以很容易地通过使用OS特有的或编写新的（命令）程序扩展该工具；然而，这也意味着你将自己限制在了特定的OS，或特定的OS类型上，如Unix。

Makefile也很可恶。任何使用过他们的人都碰到过可恶的tab问题。Ant的原作者经常这样问自己：“是否我的命令不执行只是因为在我的tab前有一个空格？！！”。类似于jam的工具很好地处理了这类问题，但是（用户）必须记住和使用一种新的格式。

Ant 就不同了。与基于shell命令的扩展模式不同，Ant用Java的类来扩展。（用户）不必编写shell命令，配置文件是基于XML的，通过调用 target树，就可执行各种task。每个task由实现了一个实现了特定Task接口的对象来运行。（如果你对Ant一点概念都没有的话，可能看不懂这一节，没有关系，后面会对target,task做详细的介绍。你如果没有太多的时间甚至可以略过这一节，然后再回来浏览一下这里的介绍，那时你就会看懂了。同样，如果你对make之类的工具不熟悉也没关系，下面的介绍根本不会用到make中的概念。）

必须承认，这样做，在构造 shell命令时会失去一些特有的表达能力。如`find . -name foo -exec rm {}`，但却给了你跨平台的能力－你可以在任何地方工作。如果你真的需要执行一些shell命令，Ant有一个<exec> task，这个task允许执行特定OS上的命令。

2.安装Ant

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

由于Ant是一个Open Source的软件，所以有两种安装Ant的方式，一种是用已编译好的binary 文件安装Ant，另一种是用源代码自己build Ant。

binary 形式的Ant可以从http://jakarta.apache.org/builds/ant/release/v1.4.1/bin下载。如果你希望你能自己编译Ant，则可从 http://jakarta.apache.org/builds/ant/release/v1.4.1/src。注意所列出的连接都是最新发行版的 Ant。如果你读到此文时，发现已经有了更新的版本，那么请用新版本。如果你是一个疯狂的技术追求者，你也可以从Ant CVS repository下载最新版本的Ant。

系统需求

要想自己build Ant。你需要一个JAXP兼容的XML解析器（parser）放在你的CLASSPATH系统变量中。

binary 形式的Ant包括最新版的Apache Crimson XML解析器。你可以从http://java.sun.com/xml/ 得到更多的关于JAXP的信息。如果你希望使用其他的JAXP兼容的解析器。你要从Ant的lib目录中删掉jaxp.jar以及 crimson.jar。然后你可将你心爱的解析器的jar文件放到Ant的lib目录中或放在你的CLASSPATH系统变量中。

对于当前版本的Ant，需要你的系统中有JDK，1.1版或更高。未来的Ant版本会要求使用JDK 1.2或更高版本。

安装Ant

binary 版的Ant包括三个目录:bin, docs 和lib。只有bin和lib目录是运行Ant所需的。要想安装Ant，选择一个目录并将发行版的文件拷贝到该目录下。这个目录被称作ANT_HOME。

在你运行Ant之前需要做一些配置工作。

将bin目录加入PATH环境变量。
设定ANT_HOME环境变量，指向你安装Ant的目录。在一些OS上，Ant的脚本可以猜测ANT_HOME（Unix和Windos NT/2000）－但最好不要依赖这一特性。
可选地，设定JAVA_HOME环境变量（参考下面的高级小节），该变量应该指向你安装JDK的目录。

注意：不要将Ant的ant.jar文件放到JDK/JRE的lib/ext目录下。Ant是个应用程序，而lib/ext目录是为JDK扩展使用的（如JCE，JSSE扩展）。而且通过扩展装入的类会有安全方面的限制。

可选Task

Ant 支持一些可选task。一个可选task一般需要额外的库才能工作。可选task与Ant的内置task分开，单独打包。这个可选包可以从你下载Ant的同一个地方下载。目前包含可选task的jar文件名叫jakarta-ant-1.4.1-optional.jar。这个jar文件应该放到Ant安装目录的lib目录下。

每个可选task所需的外部库可参看依赖库小节。这些外部库可以放到Ant的lib目录下，这样Ant就能自动装入，或者将其放入环境变量中。

Windows

假定Ant安装在c:\ant\目录下。下面是设定环境的命令：

set ANT_HOME=c:\ant
set JAVA_HOME=c:\jdk1.2.2
set PATH=%PATH%;%ANT_HOME%\bin
Unix (bash)

假定Ant安装在/usr/local/ant目录下。下面是设定环境的命令：

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin
高级

要想运行Ant必须使用很多的变量。你至少参考需要下面的内容：

Ant的CLASSPATH必须包含ant.jar以及你所选的JAXP兼容的XML解析器的jar文件。
当你需要JDK的功能（如javac或rmic task）时，对于JDK 1.1，JDK的classes.zip文件必须放入CLASSPATH中；对于JDK 1.2或JDK 1.3，则必须加入tools.jar。如果设定了正确的JAVA_HOME环境变量，Ant所带的脚本，在bin目录下，会自动加入所需的JDK类。
当你执行特定平台的程序（如exec task或cvs task）时，必须设定ant.home属性指向Ant的安装目录。同样，Ant所带的脚本利用ANT_HOME环境变量自动设置该属性。
Building Ant

要想从源代码build Ant，你要先安装Ant源代码发行版或从CVS中checkout jakarta-ant模块。

安装好源代码后，进入安装目录。

设定JAVA_HOME环境变量指向JDK的安装目录。要想知道怎么做请参看安装Ant小节。

确保你已下载了任何辅助jar文件，以便build你所感兴趣的task。这些jar文件可以放在CLASSPATH中，也可以放在 lib/optional目录下。参看依赖库小节可知不同的task需要那些jar文件。注意这些jar文件只是用作build Ant之用。要想运行Ant，你还要像安装Ant小节中所做的那样设定这些jar文件。

现在你可以build Ant了：

build -Ddist.dir=<directory_to_contain_Ant_distribution> dist (Windows)
build.sh -Ddist.dir=<directory_to_contain_Ant_distribution> dist (Unix)

这样就可你指定的目录中创建一个binary版本。

上面的命令执行下面的动作：

如果有必要可以bootstrap Ant的代码。bootstrap 包括手工编辑一些Ant代码以便运行Ant。bootstrap 用于下面的build步骤。
向build脚本传递参数以调用bootstrap Ant。参数定义了Ant的属性值并指定了Ant自己的build.xml文件的"dist" target。

大多数情况下，你不必直接bootstrap Ant，因为build脚本为你完成这一切。运行bootstrap.bat (Windows) 或 bootstrap.sh (UNIX) 可以build一个新的bootstrap版Ant。

如果你希望将Ant安装到ANT_HOME目录下，你可以使用：

build install (Windows)
build.sh install (Unix)

如果你希望跳过冗长的Javadoc步骤，可以用：

build install-lite (Windows)
build.sh install-lite (Unix)

这样就只会安装bin和lib目录。

注意install和install-lite都会覆盖ANT_HOME中的当前Ant版本。

依赖库

如果你需要执行特定的task，你需要将对应的库放入CLASSPATH或放到Ant安装目录的lib目录下。注意使用mapper时只需要一个regexp库。同时，你也要安装Ant的可选jar包，它包含了task的定义。参考上面的安装Ant小节。

Jar Name Needed For Available At
An XSL transformer like Xalan or XSL:P style task http://xml.apache.org/xalan-j/index.html or http://www.clc-marketing.com/xslp/
jakarta-regexp-1.2.jar regexp type with mappers jakarta.apache.org/regexp/
jakarta-oro-2.0.1.jar regexp type with mappers and the perforce tasks jakarta.apache.org/oro/
junit.jar junit tasks www.junit.org
stylebook.jar stylebook task CVS repository of xml.apache.org
testlet.jar test task java.apache.org/framework
antlr.jar antlr task www.antlr.org
bsf.jar script task oss.software.ibm.com/developerworks/projects/bsf
netrexx.jar netrexx task www2.hursley.ibm.com/netrexx
rhino.jar javascript with script task www.mozilla.org
jpython.jar python with script task www.jpython.org
netcomponents.jar ftp and telnet tasks www.savarese.org/oro/downloads

3.运行Ant

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

运行Ant非常简单，当你正确地安装Ant后，只要输入ant就可以了。

没有指定任何参数时，Ant会在当前目录下查询build.xml文件。如果找到了就用该文件作为buildfile。如果你用 -find 选项。Ant就会在上级目录中寻找buildfile，直至到达文件系统的根。要想让Ant使用其他的buildfile，可以用参数 -buildfile file，这里file指定了你想使用的buildfile。

你也可以设定一些属性，以覆盖buildfile中指定的属性值（参看property task）。可以用 -Dproperty=value 选项，这里property是指属性的名称，而value则是指属性的值。也可以用这种办法来指定一些环境变量的值。你也可以用property task来存取环境变量。只要将 -DMYVAR=%MYVAR% (Windows) 或 -DMYVAR=$MYVAR (Unix) 传递给Ant －你就可以在你的buildfile中用${MYVAR}来存取这些环境变量。

还有两个选项 -quite，告诉Ant运行时只输出少量的必要信息。而 -verbose，告诉Ant运行时要输出更多的信息。

可以指定执行一个或多个target。当省略target时，Ant使用标签<project>的default属性所指定的target。

如果有的话，-projecthelp 选项输出项目的描述信息和项目target的列表。先列出那些有描述的，然后是没有描述的target。

命令行选项总结：

ant [options] [target [target2 [target3] ...]]
Options:
-help print this message
-projecthelp print project help information
-version print the version information and exit
-quiet be extra quiet
-verbose be extra verbose
-debug print debugging information
-emacs produce logging information without adornments
-logfile file use given file for log output
-logger classname the class that is to perform logging
-listener classname add an instance of class as a project listener
-buildfile file use specified buildfile
-find file search for buildfile towards the root of the filesystem and use the first one found
-Dproperty=value set property to value
例子

ant

使用当前目录下的build.xml运行Ant，执行缺省的target。

ant -buildfile test.xml

使用当前目录下的test.xml运行Ant，执行缺省的target。

ant -buildfile test.xml dist

使用当前目录下的test.xml运行Ant，执行一个叫做dist的target。

ant -buildfile test.xml -Dbuild=build/classes dist

使用当前目录下的test.xml运行Ant，执行一个叫做dist的target，并设定build属性的值为build/classes。

文件

在Unix 上，Ant的执行脚本在做任何事之前都会source（读并计算值）~/.antrc 文件；在Windows上，Ant的批处理文件会在开始时调用%HOME%\antrc_pre.bat，在结束时调用%HOME%\ antrc_post.bat。你可以用这些文件配置或取消一些只有在运行Ant时才需要的环境变量。看下面的例子。

环境变量

包裹脚本（wrapper scripts）使用下面的环境变量（如果有的话）：

JAVACMD Java可执行文件的绝对路径。用这个值可以指定一个不同于JAVA_HOME/bin/java(.exe)的JVM。
ANT_OPTS 传递给JVM的命令行变量－例如，你可以定义属性或设定Java堆的最大值

手工运行Ant

如果你自己动手安装（DIY）Ant，你可以用下面的命令启动Ant:

java -Dant.home=c:\ant org.apache.tools.ant.Main [options] [target]

这个命令与前面的ant命令一样。选项和target也和用ant命令时一样。这个例子假定你的CLASSPATH包含:

ant.jar

jars/classes for your XML parser

the JDK's required jar/zip files

4.编写build.xml

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

Ant的buildfile是用XML写的。每个buildfile含有一个project。

buildfile中每个task元素可以有一个id属性，可以用这个id值引用指定的任务。这个值必须是唯一的。（详情请参考下面的Task小节）

Projects

project有下面的属性：

Attribute Description Required
name 项目名称. No
default 当没有指定target时使用的缺省target Yes
basedir 用于计算所有其他路径的基路径。该属性可以被basedir property覆盖。当覆盖时，该属性被忽略。如果属性和basedir property都没有设定，就使用buildfile文件的父目录。 No

项目的描述以一个顶级的<description>元素的形式出现（参看description小节）。

一个项目可以定义一个或多个target。一个target是一系列你想要执行的。执行Ant时，你可以选择执行那个target。当没有给定target时，使用project的default属性所确定的target。

Targets

一个target可以依赖于其他的target。例如，你可能会有一个target用于编译程序，一个target用于生成可执行文件。你在生成可执行文件之前必须先编译通过，所以生成可执行文件的target依赖于编译target。Ant会处理这种依赖关系。

然而，应当注意到，Ant的depends属性只指定了target应该被执行的顺序－如果被依赖的target无法运行，这种depends对于指定了依赖关系的target就没有影响。

Ant会依照depends属性中target出现的顺序（从左到右）依次执行每个target。然而，要记住的是只要某个target依赖于一个target，后者就会被先执行。

<target name="A"/>
<target name="B" depends="A"/>
<target name="C" depends="B"/>
<target name="D" depends="C,B,A"/>

假定我们要执行target D。从它的依赖属性来看，你可能认为先执行C，然后B，最后A被执行。错了，C依赖于B，B依赖于A，所以先执行A，然后B，然后C，最后D被执行。

一个target只能被执行一次，即时有多个target依赖于它（看上面的例子）。

如果（或如果不）某些属性被设定，才执行某个target。这样，允许根据系统的状态（java version, OS, 命令行属性定义等等）来更好地控制build的过程。要想让一个target这样做，你就应该在target元素中，加入if（或unless）属性，带上target因该有所判断的属性。例如：

<target name="build-module-A" if="module-A-present"/>
<target name="build-own-fake-module-A" unless="module-A-present"/>

如果没有if或unless属性，target总会被执行。

可选的description属性可用来提供关于target的一行描述，这些描述可由-projecthelp命令行选项输出。

将你的tstamp task在一个所谓的初始化target是很好的做法，其他的target依赖这个初始化target。要确保初始化target是出现在其他target依赖表中的第一个target。在本手册中大多数的初始化target的名字是"init"。

target有下面的属性：

Attribute Description Required
name target的名字 Yes
depends 用逗号分隔的target的名字列表，也就是依赖表。 No
if 执行target所需要设定的属性名。 No
unless 执行target需要清除设定的属性名。 No
description 关于target功能的简短描述。 No

Tasks

一个task是一段可执行的代码。

一个task可以有多个属性（如果你愿意的话，可以将其称之为变量）。属性只可能包含对property的引用。这些引用会在task执行前被解析。

下面是Task的一般构造形式：

<name attribute1="value1" attribute2="value2" ... />

这里name是task的名字，attributeN是属性名，valueN是属性值。

有一套内置的（built-in）task，以及一些可选task，但你也可以编写自己的task。

所有的task都有一个task名字属性。Ant用属性值来产生日志信息。

可以给task赋一个id属性：

<taskname id="taskID" ... />

这里taskname是task的名字，而taskID是这个task的唯一标识符。通过这个标识符，你可以在脚本中引用相应的task。例如，在脚本中你可以这样：

<script ... >
task1.setFoo("bar");
</script>

设定某个task实例的foo属性。在另一个task中（用java编写），你可以利用下面的语句存取相应的实例。

project.getReference("task1").

注意1：如果task1还没有运行，就不会被生效（例如：不设定属性），如果你在随后配置它，你所作的一切都会被覆盖。

注意2：未来的Ant版本可能不会兼容这里所提的属性，因为很有可能根本没有task实例，只有proxies。

Properties

一个project可以有很多的properties。可以在buildfile中用property task来设定，或在Ant之外设定。一个property有一个名字和一个值。property可用于task的属性值。这是通过将属性名放在"${" 和"}"之间并放在属性值的位置来实现的。例如如果有一个property builddir的值是"build"，这个property就可用于属性值：${builddir}/classes。这个值就可被解析为 build/classes。

内置属性

如果你使用了<property> task 定义了所有的系统属性，Ant允许你使用这些属性。例如，${os.name}对应操作系统的名字。

要想得到系统属性的列表可参考the Javadoc of System.getProperties。

除了Java的系统属性，Ant还定义了一些自己的内置属性：
basedir project基目录的绝对路径 (与<project>的basedir属性一样)。
ant.file buildfile的绝对路径。
ant.version Ant的版本。
ant.project.name 当前执行的project的名字；由<project>的name属性设定.
ant.java.version Ant检测到的JVM的版本；目前的值有"1.1", "1.2", "1.3" and "1.4".

例子

<project name="MyProject" default="dist" basedir=".">


<property name="src" value="."/>
<property name="build" value="build"/>
<property name="dist" value="dist"/>

<target name="init">

<tstamp/>

<mkdir dir="${build}"/>
</target>

<target name="compile" depends="init">

<javac srcdir="${src}" destdir="${build}"/>
</target>

<target name="dist" depends="compile">

<mkdir dir="${dist}/lib"/>

<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>

<target name="clean">

<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>

</project>

Token Filters

一个project可以有很多tokens，这些tokens在文件拷贝时会被自动扩展，这要求在支持这一行为的task中选择过滤拷贝功能。这一功能可用filter task在buildfile中设定。

既然这很可能是一个有危害的行为，文件中的tokens必须采取@token@的形式，这里token是filter task中设定的token名。这种token语法与其他build系统执行类似filtering的语法相同，而且与大多数的编程和脚本语言以及文档系统并不冲突，

注意：如果在一个文件中发现了一个@token@形式的token，但没有filter与这个token关连，则不会发生任何事；因此，没有转义方法－但只要你为token选择合适的名字，就不会产生问题。

警告：如果你在拷贝binary文件时打开filtering功能，你有可能破坏文件。这个功能只针对文本文件。

Path-like Structures
你可以用":"和";"作为分隔符，指定类似PATH和CLASSPATH的引用。Ant会把分隔符转换为当前系统所用的分隔符。

当需要指定类似路径的值时，可以使用嵌套元素。一般的形式是

<classpath>
<pathelement path="${classpath}"/>
<pathelement location="lib/helper.jar"/>
</classpath>
location属性指定了相对于project基目录的一个文件和目录，而path属性接受逗号或分号分隔的一个位置列表。path属性一般用作预定义的路径－－其他情况下，应该用多个location属性。

为简洁起见，classpath标签支持自己的path和location属性。所以：

<classpath>
<pathelement path="${classpath}"/>
</classpath>
可以被简写作：

<classpath path="${classpath}"/>
也可通过<fileset>元素指定路径。构成一个fileset的多个文件加入path-like structure的顺序是未定的。

<classpath>
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</classpath>
上面的例子构造了一个路径值包括：${classpath}的路径，跟着lib目录下的所有jar文件，接着是classes目录。

如果你想在多个task中使用相同的path-like structure，你可以用<path>元素定义他们（与target同级），然后通过id属性引用－－参考Referencs例子。

path-like structure可能包括对另一个path-like structurede的引用（通过嵌套<path>元素）：

<path id="base.path">
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</path>
<path id="tests.path">
<path refid="base.path"/>
<pathelement location="testclasses"/>
</path>

前面所提的关于<classpath>的简洁写法对于<path>也是有效的，如：

<path id="tests.path">
<path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
可写成：

<path id="base.path" path="${classpath}"/>
命令行变量

有些task可接受参数，并将其传递给另一个进程。为了能在变量中包含空格字符，可使用嵌套的arg元素。

Attribute Description Required
value 一个命令行变量；可包含空格字符。只能用一个
line 空格分隔的命令行变量列表。
file 作为命令行变量的文件名；会被文件的绝对名替代。
path 一个作为单个命令行变量的path-like的字符串；或作为分隔符，Ant会将其转变为特定平台的分隔符。

例子

<arg value="-l -a"/>
是一个含有空格的单个的命令行变量。

<arg line="-l -a"/>
是两个空格分隔的命令行变量。

<arg path="/dir;/dir2:\dir3"/>
是一个命令行变量，其值在DOS系统上为\dir;\dir2;\dir3；在Unix系统上为/dir:/dir2:/dir3 。

References

buildfile元素的id属性可用来引用这些元素。如果你需要一遍遍的复制相同的XML代码块，这一属性就很有用－－如多次使用<classpath>结构。

下面的例子：

<project ... >
<target ... >
<rmic ...>
<classpath>
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>
<pathelement path="${additional.path}"/>
</classpath>
</rmic>
</target>
<target ... >
<javac ...>
<classpath>
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>
<pathelement path="${additional.path}"/>
</classpath>
</javac>
</target>
</project>
可以写成如下形式：

<project ... >
<path id="project.class.path">
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>
<pathelement path="${additional.path}"/>
</path>
<target ... >
<rmic ...>
<classpath refid="project.class.path"/>
</rmic>
</target>
<target ... >
<javac ...>
<classpath refid="project.class.path"/>
</javac>
</target>
</project>
所有使用PatternSets, FileSets 或 path-like structures嵌套元素的task也接受这种类型的引用。

posted @ 2005-12-29 09:16 javaGrowing 阅读(260) | 评论 (0) | 编辑收藏

Oracle的入门心得

Oracle的体系太庞大了，对于初学者来说，难免会有些无从下手的感觉，什么都想学，结果什么都学不好，所以把学习经验共享一下，希望让刚刚入门的人对Oracle有一个总体的认识，少走一些弯路。

一、定位

Oracle分两大块，一块是开发，一块是管理。开发主要是写写存储

以下内容为程序代码:
<SCRIPT language=javascript src="/CMS/JS/newsad.js">

</script>

过程、触发器什么的，还有就是用Oracle的Develop工具做form。有点类似于程序员，需要有较强的逻辑思维和创造能力，个人觉得会比较辛苦，是青春饭；管理则需要对Oracle数据库的原理有深刻的认识，有全局操纵的能力和紧密的思维，责任较大，因为一个小的失误就会down掉整个数据库，相对前者来说，后者更看重经验。

    因为数据库管理的责任重大，很少公司愿意请一个刚刚接触Oracle的人去管理数据库。对于刚刚毕业的年轻人来说，可以先选择做开发，有一定经验后转型，去做数据库的管理。当然，这个还是要看人个的实际情况来定。

二、学习方法

    我的方法很简单，就是：看书、思考、写笔记、做实验、再思考、再写笔记。

     看完理论的东西，自己静下心来想想，多问自己几个为什么，然后把所学和所想的知识点做个笔记；在想不通或有疑问的时候，就做做实验，想想怎么会这样，同样的，把实验的结果记下来。思考和做实验是为了深入的了解这个知识点。而做笔记的过程，也是理清自己思路的过程。

    学习的过程是使一个问题由模糊到清晰，再由清晰到模糊的过程。而每次的改变都代表着你又学到了一个新的知识点。

    学习的过程也是从点到线，从线到网，从网到面的过程。当点变成线的时候，你会有总豁然开朗的感觉。当网到面的时候，你就是高手了。

     很多网友，特别是初学的人，一碰到问题就拿到论坛上来问，在问前，你有没有查过书，自己有没有研究过，有没有搜索一下论坛？这就叫思维惰性。由别人来回答你的问题，会让你在短时间内不费劲地弄懂这个知识点，然而通过自己的努力去研究它，不但会更深入的了解这个知识点，更重要的是在研究的过程会提高你解决问题和分析问题的能力。总的来说，没有钻研的学习态度，不管学什么东西，都不会成功的。

    当然，初学的人很多时候是因为遇到问题时，无从下手，也不知道去哪里找资料，才会到论坛上提问题的。但我认为，在提问的时候，是不是可以问别人是如何分析这个问题？从哪里可以找到相关的资料？而不是这个问题的答案是什么？授人以鱼不如授人以渔。

    下面我讲下我处理问题的过程

    首先要知道Oracle的官方网站：www.oracle.com 这里有Oracle的各种版本的数据库、应用工具和权威的官方文档。其次，还要知道http://metalink.oracle.com/这里是买了Oracle服务或是oracle的合作伙伴才可以进去的，里面有很多权威的解决方案和补丁。然后就是一些著名网站：asktom.oracle.com www.orafaq.net, www.dbazine.com。这里有很多经验之谈。

    遇到问题了。如果是概念上的问题，第一时间可以找tahiti.oracle.com，这里会给你最详细的解释。如果在运行的过程中出了什么错误。可以去metalink看看。如果是想知道事务的处理的经验之谈。可以去asktom。当然。这里只是相对而言。 [page]
三、Oracle的体系
    Oracle的体系很庞大，要学习它，首先要了解Oracle的框架。在这里，简要的讲一下Oracle的架构，让初学者对Oracle有一个整体的认识。

     1、物理结构（由控制文件、数据文件、重做日志文件、参数文件、归档文件、密码文件组成）

    控制文件：包含维护和验证数据库完整性的必要信息、例如，控制文件用于识别数据文件和重做日志文件，一个数据库至少需要一个控制文件.

    数据文件：存储数据的文件.

    重做日志文件：含对数据库所做的更改记录，这样万一出现故障可以启用数据恢复。一个数据库至少需要两个重做日志文件.

    参数文件：定义Oracle例程的特性，例如它包含调整SGA中一些内存结构大小的参数.

    归档文件：是重做日志文件的脱机副本，这些副本可能对于从介质失败中进行恢复很必要。

    密码文件：认证哪些用户有权限启动和关闭Oracle例程.

    2、逻辑结构（表空间、段、区、块）

    表空间：是数据库中的基本逻辑结构，一系列数据文件的集合。
    段：是对象在数据库中占用的空间.
    区：是为数据一次性预留的一个较大的存储空间.
    块：ORACLE最基本的存储单位，在建立数据库的时候指定.

    3、内存分配（SGA和PGA）

    SGA：是用于存储数据库信息的内存区，该信息为数据库进程所共享。它包含Oracle 服务器的数据和控制信息,它是在Oracle服务器所驻留的计算机的实际内存中得以分配，如果实际内存不够再往虚拟内存中写。

    PGA：包含单个服务器进程或单个后台进程的数据和控制信息，与几个进程共享的SGA 正相反PGA 是只被一个进程使用的区域，PGA 在创建进程时分配在终止进程时回收.

    4、后台进程（数据写进程、日志写进程、系统监控、进程监控、检查点进程、归档进程、服务进程、用户进程）

    数据写进程：负责将更改的数据从数据库缓冲区高速缓存写入数据文件
    日志写进程：将重做日志缓冲区中的更改写入在线重做日志文件
    系统监控：检查数据库的一致性如有必要还会在数据库打开时启动数据库的恢复
    进程监控：负责在一个Oracle 进程失败时清理资源
    检查点进程：负责在每当缓冲区高速缓存中的更改永久地记录在数据库中时,更新控制文件和数据文件中的数据库状态信息。
    归档进程：在每次日志切换时把已满的日志组进行备份或归档
    服务进程：用户进程服务。
    用户进程：在客户端，负责将用户的SQL语句传递给服务进程，并从服务器段拿回查询数据。

    5、Oracle例程：Oracle例程由SGA内存结构和用于管理数据库的后台进程组成。例程一次只能打开和使用一个数据库。

    6、SCN(System ChangeNumber)：系统改变号，一个由系统内部维护的序列号。当系统需要更新的时候自动增加，他是系统中维持数据的一致性和顺序恢复的重要标志。

四、深入学习

     管理：可以考OCP证书，对Oracle先有一个系统的学习，然后看Oracle Concepts、Oracle online document,对oracle的原理会有更深入的了解，同时可以开始进行一些专题的研究如：RMAN、RAS、STATSPACT、 DATAGUARD、TUNING、BACKUP&RECOVER等等。

    开发：对于想做Oracle开发的，在了解完 Oracle基本的体系结构之后，可以重点关注PL/SQL及Oracle的开发工具这一部分。PL/SQL主要是包括怎么写SQL语句，怎么使用 Oracle本身的函数，怎么写存储过程、存储函数、触发器等。 Oracle的开发工具主要就是Oracle自己的Developer Suite（Oracle Forms Developer and Reports Developer这些），学会如何熟练使用这些工具。

介绍几本oracle入门的好书

    Oracle官方文档：《concept》上面讲了oracle的体系和概念，很适合初学者看。
    OCP的教学用书，也就是STUDY GUIDE(SG)。
    Oracle8i 备份恢复手册
    Oracle8高级管理与优化
    Oracle8i PLSQL程序设计
    Oracle8数据库管理员手册
    以上书本都是机械工业出版社出版。

介绍几个网站

    http://tahiti.oracle.com oracle的官方文档

    现在http://www.oracle.com.cn/onlinedoc/index.htm也有官方文档，速度奇快

    http://metalink.oracle.com/,Oracle的技术支持网站。需要购买Oracle服务才能有一个帐号，才能登陆，有大量的Knowledge Base，大量问题解决经验。

    http://www.oracle.com oracle的官方网站，可以在这里down Oracle的软件、官方文档和获得最新的消息

    http://www.dbazine.com/ Oracle的杂志

    http://asktom.oracle.com

    http://www.orafaq.net/

    http://www.ixora.com.au/

    http://www.oracle-base.com

    http://www.dba-oracle.com/oracle_links.htm

posted @ 2005-12-28 22:59 javaGrowing 阅读(172) | 评论 (0) | 编辑收藏

struts中文的解决

转自 www.javaresearch.org
作者 fishandfly

1.使ApplicationResources.properties支持中文
建立一个ApplicationResources_ISO.properties文件，把应用程序用的message都写进去，然后在dos下执行这个命令，
native2ascii -encoding gb2312 ApplicationResources_ISO.properties ApplicationResources.properties
这样就会将ISO编码的ApplicationResources转换成GB2312编码的格式了，同时保存到ApplicationResources.properties.
native2ascii这个工具是jdk自带的一个东东，所以如果path都设定正确就可以直接运行了，你可以在$java_home$/bin下找到他。
转换后的中文类似于这个样子
iso 格式下：tj.type=商品车类型
gb2312格式下：tj.type=\u5546\u54c1\u8f66\u7c7b\u578b
然后在struts-config.xml中设置应用这个资源文件
<message-resources parameter="com.huahang.tj.ApplicationResources" key="org.apache.struts.action.MESSAGE" />
开发jsp时在jsp的开头写上<%@ page contentType="text/html; charset=gb2312" %>，将字符集设置成gb2312就可以了。

2.使数据库操作支持中文。
数据库操作支持中文一直让我比较头痛，但是感谢善解人衣向我推荐了www.chinaxp.org，这个网站是用struts框架开发的，而且
开放源码，下载了源码后发现它的中文处理得很好，阅读部分源码，没有发现什么特殊的字符集转换，很纳闷，偶然看到楼上网友
留言知道原来servlet可以统一设置字符转换。chinaxp.org就是这么做的。
在web.xml中加上
<filter>
<filter-name>Set Character Encoding</filter-name>
<filter-class>com.huahang.tj.struts.filters.SetCharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GB2312</param-value>
</init-param>
<init-param>
<param-name>ignore</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>Set Character Encoding</filter-name>
<servlet-name>action</servlet-name>
</filter-mapping>
这里会涉及一个bean,源码如下：
/*
* XP Forum
*
* Copyright Coffee

2002-2003 RedSoft Group. All rights reserved.
*
*/
package com.huahang.tj.struts.filters;

import javax.servlet.*;
import java.io.IOException;

/**
* <p>Filter that sets the character encoding to be used in parsing the
* incoming request, either unconditionally or only if the client did not
* specify a character encoding. Configuration of this filter is based on
* the following initialization parameters:</p>
* <ul>
* <li><strong>encoding</strong> - The character encoding to be configured
* for this request, either conditionally or unconditionally based on
* the <code>ignore</code> initialization parameter. This parameter
* is required, so there is no default.</li>
* <li><strong>ignore</strong> - If set to "true", any character encoding
* specified by the client is ignored, and the value returned by the
* <code>selectEncoding()</code> method is set. If set to "false,
* <code>selectEncoding()</code> is called <strong>only</strong> if the
* client has not already specified an encoding. By default, this
* parameter is set to "true".</li>
* </ul>
*
* <p>Although this filter can be used unchanged, it is also easy to
* subclass it and make the <code>selectEncoding()</code> method more
* intelligent about what encoding to choose, based on characteristics of
* the incoming request (such as the values of the <code>Accept-Language</code>
* and <code>User-Agent</code> headers, or a value stashed in the current
* user's session.</p>
*
* @author <a href="mailto:jwtronics@yahoo.com">John Wong</a>
*
* @version $Id: SetCharacterEncodingFilter.java,v 1.1 2002/04/10 13:59:27 johnwong Exp $
*/
public class SetCharacterEncodingFilter implements Filter {

// ----------------------------------------------------- Instance Variables

/**
* The default character encoding to set for requests that pass through
* this filter.
*/
protected String encoding = null;

/**
* The filter configuration object we are associated with. If this value
* is null, this filter instance is not currently configured.
*/
protected FilterConfig filterConfig = null;

/**
* Should a character encoding specified by the client be ignored?
*/
protected boolean ignore = true;

// --------------------------------------------------------- Public Methods

/**
* Take this filter out of service.
*/
public void destroy() {

this.encoding = null;
this.filterConfig = null;

}

/**
* Select and set (if specified) the character encoding to be used to
* interpret request parameters for this request.
*
* @param request The servlet request we are processing
* @param result The servlet response we are creating
* @param chain The filter chain we are processing
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet error occurs
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain)
throws IOException, ServletException {

// Conditionally select and set the character encoding to be used
if (ignore || (request.getCharacterEncoding() == null)) {
String encoding = selectEncoding(request);
if (encoding != null)
request.setCharacterEncoding(encoding);
}

// Pass control on to the next filter
chain.doFilter(request, response);

}

/**
* Place this filter into service.
*
* @param filterConfig The filter configuration object
*/
public void init(FilterConfig filterConfig) throws ServletException {

this.filterConfig = filterConfig;
this.encoding = filterConfig.getInitParameter("encoding");
String value = filterConfig.getInitParameter("ignore");
if (value == null)
this.ignore = true;
else if (value.equalsIgnoreCase("true"))
this.ignore = true;
else if (value.equalsIgnoreCase("yes"))
this.ignore = true;
else
this.ignore = false;

}

// ------------------------------------------------------ Protected Methods

/**
* Select an appropriate character encoding to be used, based on the
* characteristics of the current request and/or filter initialization
* parameters. If no character encoding should be set, return
* <code>null</code>.
* <p>
* The default implementation unconditionally returns the value configured
* by the <strong>encoding</strong> initialization parameter for this
* filter.
*
* @param request The servlet request we are processing
*/
protected String selectEncoding(ServletRequest request) {

return (this.encoding);

}

}//EOC
加上这个后，在action中就可以直接从form中接收gb2312编码的数据了，返回时自然也是gb2312了。
但是这个好像需要servlet 2.2以上的容器

综合上面的方法，我解决了struts中的中文问题，现在还没发现新的问题。

我的环境是
windows2000 Professional,tomcat 4.04 , struts1.1b2

posted @ 2005-12-27 15:56 javaGrowing 阅读(361) | 评论 (0) | 编辑收藏

用Struts Validator检查你的表单

用Struts Validator检查你的表单
2004-05-12	浏览次数：1286

用Validator（验证器）提供的丰富的内置验证方法简化Struts的开发过程。

Struts框架的一个主要好处是它提供了对接收到的表单数据进行验证的内置界面。如果有任何验证失败，则应用程序都会重新显示HTML表单，这样就可以改正无效的数据了。如果验证成功，则处理过程会继续进行。Struts框架的简单验证界面会减少与处理数据验证有关的令人头疼的事情，这样你就可以把精力集中到验证代码上，而不是放到捕获数据、重新显示不完整或无效数据的技巧上。

但是，Struts内置的验证界面也有缺点。例如，在整个应用程序中验证代码常常会大量重复，因为许多域需要相同的验证逻辑。对一些相似字段的验证逻辑进行任何修改都要求在几个地方修改代码，还要重新编译受影响的代码。为了解决这个问题并增强Struts验证界面的功能，作为Struts的第三方附加件创建了Validator框架。后来，Validator被集成到核心Struts代码库中，并从Struts中分离出来，现在它是一个独立的Jakarta Commons项目。虽然Validator是一个独立的框架，但它仍能与其他程序封装在一起后提供，并与Struts无缝集成。

Validator概述

没有Validator，你就不得不编写验证表单数据所需的全部代码，并把它放入Form Bean对象的validate( )方法中。对于想在其上进行数据验证的每个Form Bean域来说，都需要编写逻辑代码来实现验证。此外，你还必须编写代码来存储验证失败时的出错消息。

有了Validator，你就不必在Form Bean中编写用于验证或存储错误消息的任何代码。相反，Form Bean提供了Validator的一个ActionForm子类，它提供验证或存储错误消息的功能。

可把Validator框架作为一个可用于Form Bean验证的可插入的验证例行程序系统来进行安装。每个验证例行程序都只是一个Java方法，负责执行特定类型的验证任务，验证可能通过，也可能失败。默认情况下，Validator与几个有用的验证例行程序封装在一起来提供，这些例行程序能满足大多数情况下的验证要求。但是，如果Validator框架没有提供你需要的验证例行程序，那么你可以自己创建定制的验证例行程序，并将它插入到该框架中。此外，Validator还支持服务器端和客户端（JavaScript）的验证，而Form Bean只提供服务器端验证界面。

Validator使用两个XML配置文件来分别确定安装哪个验证例行程序和如何将它们应用于给定的应用程序。第一个配置文件validator-rules.xml说明应该被插入到框架中的验证例行程序，并提供每个验证的逻辑的名称。validator-rules.xml文件还定义了每个验证例行程序的客户端JavaScript代码。可以配置Validator让它把这个JavaScript代码发送到浏览器上，这样验证就可以在客户端和服务器端进行了。

第二个配置文件validation.xml确定哪个验证例行程序应用到哪个Form Bean。文件中的定义使用struts-config.xml文件给出的Form Bean的逻辑名称以及validator-rules.xml文件给出的验证例行程序的逻辑名称，以便把二者关联起来。

使用Validator框架包括启用Validator插件、配置Validator的两个配置文件，以及创建提供Validator的ActionForm子类的Form Beans。下面详细解释如何配置和使用Validator。

启用Validator插件

虽然Validator框架是与Struts封装在一起提供的，但在默认状况下Validator并不被启用。为了启用Validator，要向你的应用程序的struts-config.xml文件中添加下面的插件定义。

<!-- Validator Configuration -->
<plug-in className="org.apache.struts
.validator.ValidatorPlugIn">
  <set-property property="pathnames"
               value="/WEB-INF/
  validator-rules.xml, /WEB-INF/
  validation.xml"/>
</plug-in>

该定义告诉Struts为你的应用程序加载并初始化Validator插件。在初始化时，该插件装入由路径名属性指定的、用逗号分隔的Validator配置文件清单。每个配置文件的路径应该用与Web应用程序的相关的路径来指定，如前面的例子所示。

请注意，你的应用程序的struts-config.xml文件必须与Struts Configuration Document Type Definition（Struts配置文档类型定义，DTD）一致，后者规定文件中元素出现的顺序。所以，你必须把Validator插件定义放到该文件的适当位置。确保文件中元素适当排列的最简便方法就是使用诸如Struts Console的工具，它自动格式化你的配置文件，以便与DTD保持一致。

配置validator-rules.xml

Validator框架可以设置为可插入系统，其验证例行程序仅仅是插入到该系统中执行具体验证的Java方法。validator-rules.xml文件说明性地插入Validator用于执行验证的验证例行程序中。Struts示例应用程序带有这个文件的预配置拷贝。在大多数情况下，你不必修改这个预配置拷贝，除非你要向该框架中添加自己定制的验证。

清单1 是一个示例validator-rules.xml文件，说明如何将验证例行程序插入到Validator中。validator-rules.xml文件中的每个验证例行程序都有自己的定义，它用validator标记声明，利用name属性为该验证例行程序指定逻辑名，并指定该例行程序的类和方法。该例行程序的逻辑名称供该文件中的其他例行程序以及validation.xml文件中的验证定义用于引用该例行程序。

请注意，validator标记放在javascript的标记中，javascript标记用于定义客户端JavaScript代码，以便在客户端执行与服务器端相同的验证。

提供的验证程序

默认情况下，Validator中包括几个基本验证例行程序，你可以用它们来处理大多数验证问题。这些例行程序具有逻辑名称，如required（用于输入要求的值）、CreditCard（用于输入信用卡号码值）、email（用于输入电子邮件地址值），等等。

创建Form Bean

为了使用Validator，你的应用程序的Form Bean必须归到Validator的ActionForm的某一子类，而不是ActionForm本身。Validator的ActionForm子类提供了ActionForm的validate( )方法（它嵌入到Validator框架中）的实施过程。你不必从头编写验证代码并把它投入validate( )方法中，相反，可以完全忽略该方法，因为Validator为你提供了验证代码。

与Struts提供的核心功能相类似，Validator提供给你两种可供选择的方法来创建Form Bean。你可以选择的第一种方法就是像下面这样创建一个特定的Form Bean对象：

package com.jamesholmes.minihr;

import org.apache.struts.validator
.ValidatorForm;

public class LogonForm extends ValidatorForm {
  private String username;
  private String password;
  
  public String getUsername() {
    return username;
  }
  
  public void setUsername(String 
username) {
    this.username = username;
  }

  public String getPassword() {
    return password;
  }
public void setPassword(String 
password) {
    this.password = password;
  }
}

这个类与你不是用Validator所创建的类相似，但它提供ValidatorForm而不是ActionForm。这个类也不提供ActionForm的空reset( )和validate( )方法的实施过程，因为ValidatorForm提供了相应过程。

在struts-config.xml文件中配置这个特定Form Bean的方法与配置正则Form Bean的方法相同：

<form-beans>
  <form-bean name="logonForm"
            type="com.jamesholmes
  .minihr.LogonForm"/>
</form-beans>

用表单标记的name属性给特定Form Bean指定的逻辑名是在定义validation.xml文件中的验证时所使用的名称，如下所示：

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">

<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username" 
            depends="required">
        <arg0 key="prompt.username"/>
      </field>
    </form>
  </formset>
</form-validation>

Validator使用该表单标记的name属性的值将验证定义与要应用这些定义的Form Bean的名称相匹配。

创建Form Bean时可以选择的第二种方法是在struts-config.xml文件中定义一个动态Form Bean，如下所示：

<form-beans>
  <form-bean name="logonForm"
            type="org.apache
.struts.validator.DynaValidatorForm">
    <form-property name="username"
            type="java.lang.String"/>
    <form-property name="password"
            type="java.lang.String"/>
  </form-bean>
</form-beans>

动态Form Bean不要求创建特定的Form Bean对象；相反，要定义Form Bean应该具有的属性和类型，而Struts为你动态创建Form Bean。 Validator允许你使用这个概念，就像在核心Struts中使用这个概念一样。与使用Validator的惟一区别就是要指定Form Bean是org.apache.struts.validator.DynaValidatorForm类型，而不是org.apache.struts.action.DynaActionForm类型。

分配给动态Form Bean的逻辑名是在定义validation.xml文件中的验证时使用的名称。Validator使用与之相匹配的名称将这些验证与Form Bean联系在一起。

除了创建Form Bean的这两种标准方法之外，Validator还提供了一个高级特性，用于将多个验证定义与一个Form Bean定义联系起来。当你使用基于validatorForm或基于DynaValidatorForm的Form Bean时，Validator使用struts-config.xml文件中的Form Bean的逻辑名称，将Form Bean映射到validation.xml文件中的验证定义。这种机制在大多数情况下非常有用，但在某些时候，Form Bean要在多个操作中共享。一个操作可能使用Form Bean的所有域（fields），而另一个操作可能只使用这些域的一个子集。因为验证定义被连接到Form Bean，所以只使用域的一个子集的操作就无法绕过对未使用域的验证。当验证Form Bean时，就会对未使用的域生成错误消息，因为Validator无从知道不去验证未使用的域，它只是简单地把它们看作缺失或无效。

为了解决这个问题，Validator提供了两个附加的ActionForm子类，它使你能够将验证与操作相关联，而不是与Form Bean相关联。这样你就可以根据哪个操作正在使用Form Bean来指定把哪些验证用于该Form Bean了。对于特定的Form Bean，你要像下面这样声明org.apache.struts.validator.ValidatorActionForm子类：

public class AddressForm extends ValidatorActionForm {
  ...
}

对于动态Form Bean，在struts-config.xml文件中为Form Bean定义指定org.apache.struts.validator.DynaValidatorActionForm的类型，如下所示：

<form-bean name="addressForm"
          type="org.apache.struts
.validator.DynaValidatorActionForm">
  ...
</form-bean>

在validation.xml文件中，把一组验证映射到一个操作路径，而不是映射到Form Bean名，因为如果你定义了Create Address和Edit Address两个操作（它们使用同一个Form Bean），那么每个操作都会有一个惟一的操作名，如下所示：

<action-mappings>
  <action path="/createAddress"
         type="com.jamesholmes
  .minihr.CreateAddressAction"
         name="addressForm"/>
  <action path="/editAddress"
         type="com.jamesholmes
  .minihr.EditAddressAction"
         name="addressForm"/>
</action-mappings>

下面的validation.xml文件片断显示了两组验证，它们用于同一个Form Bean，但却有不同的操作路径：

<formset>
  <form name="/createAddress">
    <field property="city"
          depends="required">
      <arg0 key="prompt.city"/>
    </field>
  </form>
  <form name="/editAddress">
    <field property="state"
          depends="required">
      <arg0 key="prompt.state"/>
    </field>
  </form>
</formset>

因为Form Bean要么属于ValidatorActionForm子类，要么属于DynaValidatorActionForm子类，所以Validator知道用一个操作路径代替Form Bean的逻辑名称来找出用于Form Bean的验证。

配置validation.xml文件

validation.xml文件用于声明将应用到Form Beans的一组验证。要验证的每个Form Bean在这个文件中都有自己的定义。在这个定义中，指定要应用到该Form Bean的各域的验证。下面是一个validation.xml文件的例子，说明如何定义验证：

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">

<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username"
            depends="required">
        <arg0 key="prompt.username"/>
      </field>
      <field property="password"
            depends="required">
        <arg0 key="prompt.password"/>
      </field>
    </form>
  </formset>
</form-validation>

validation.xml文件的第一个元素是form-validation。这个元素是该文件的主元素，而且只定义一次。在form-validation元素内定义form-set元素，它包括多个表单元素。一般来说，在文件中只定义一个form-set元素，但是如果要将验证国际化，那就要在每个地方单独使用一个form-set元素。

每个表单元素使用name属性将名称与其所包含的域验证集关联起来。Validator使用这个逻辑名称将这些验证映射到在struts-config.xml文件中定义的一个Form Bean。根据要验证的Form Bean的类型，Validator力求将该名称与Form Bean的逻辑名称或操作路径相匹配。在表单元素内，field元素定义要应用到Form Bean的特定域的验证。field元素的property属性对应于特定Form Bean中的域名。depends属性利用validator-rules.xml文件指定验证例行程序的逻辑名称，这些例行程序将应用到域验证中。

配置ApplicationResources.properties

Validator使用Struts的资源绑定（Resource Bundle）机制将错误消息具体化。不用在框架中对错误消息进行硬编码，Validator使你能在ApplicationResources.properties文件中为一个消息指定一个键值，如果验证失败则将返回该键值。validator-rules.xml文件中的每个验证例行程序都用validator标记的msg属性指定错误消息的键值，如下所示：

<validator name="required"
          classname="org.apache
.struts.validator.FieldChecks"
          method="validateRequired"
          methodParams="java.lang
.Object, org.apache.commons.validator
.ValidatorAction, org.apache.commons
.validator.Field, org.apache.struts
.action.ActionErrors, javax.servlet
.http.HttpServletRequest"
          msg="errors.required">

如果在验证例行程序运行时验证失败，则返回与msg属性指定的键值对应的消息。

下面的片段显示来自ApplicationResources.properties文件的验证出错时的默认消息集，它们由Struts示例应用程序提供。每个消息的键值对应于每个由validator-rules.xml文件中的验证例行程序所指定的消息，它们由Struts示例应用程序提供。

# Error messages for Validator framework validations
errors.required={0} is required.
errors.minlength={0} cannot be less than {1} characters.
errors.maxlength={0} cannot be greater than {2} characters.
errors.invalid={0} is invalid.
errors.byte={0} must be a byte.
errors.short={0} must be a short.
errors.integer={0} must be an integer.
errors.long={0} must be a long.0.   errors.float={0} must be a float.
errors.double={0} must be a double.
errors.date={0} is not a date.
errors.range={0} is not in the range {1} through {2}.
errors.creditcard={0} is not a valid credit card number.
errors.email={0} is an invalid e-mail address.

请注意，每条消息都有占位符，形式为{0}、{1}或{2}。在运行期间，占位符被另一个值代替，如所验证的域的名称。这一特性特别有用，它使你能够创建可被几个不同的域重复使用的通用验证错误消息。

例如，下面给出required验证的错误消息errors.required：

errors.required={0} is required.

当你使用validation.xml文件中的该required验证时，必须定义用于替换该错误消息中的{0}的值，如下所示：

<form name="auctionForm">
  <field property="bid" depends="required">
    <arg0 key="prompt.bid"/>
  </field>
</form>

错误消息最多可以有4个占位符：{0}和{3}。这些占位符分别称为arg0到arg3，你可以通过使用arg0~arg3标记来指定它们。在上面的例子中，arg0标记指定了用于替换{0}占位符的值。该标记的key属性指定来自ApplicationResources.properties文件的一个消息键值，它的值用于替换占位符，如下所示：

下一步
阅读
关于Validator的更多文章
jakarta.apache.org/commons/validator

关于Struts Console的更多文章
www.jamesholmes.com/struts

prompt.bid=Auction Bid

使用消息键值代替占位符的值，这一方法使你不必在validation.xml文件中对替换值反复硬编码。但是，如果你不想使用Resource Bundle的键值/值机制来指定占位符的值，则可以使用arg0标记的如下语法显式地指定占位符的值：

<arg0 key="Auction Bid" resource="false"/>

在这个例子中，resource属性的值设为false，以便通知Validator要把该key属性指定的值作为占位符的值，而不要作为ApplicationResources.properties文件中消息的一个键值。

启用客户端验证

Validator除了提供了简化服务器端表单数据验证过程的框架外，它还提供了执行客户端验证时易于使用的方法。在validator-rules.xml文件中定义的每一个验证例行程序都可以随意指定JavaScript代码，这些代码可以在浏览器（客户端上的）中运行，从而执行与服务器端进行的验证相同的验证过程。在客户端进行验证时，除非所有表单都通过验证，否则这些表单不允许被提交。

为了启用客户端验证，必须在每个需要验证的JSP中放上Struts HTML Tag Library（标记库）的javascript标记，如下所示：

<html:javascript formName="logonForm"/>

javascript标记要求使用formName属性来为想要对其执行验证的表单指定validation.xml文件中给出的表单定义名，如下所示：

<form name="logonForm">
  <field property="username"
        depends="required">
    <arg0 key="prompt.username"/>
  </field>
  <field property="password"
        depends="required">
    <arg0 key="prompt.password"/>
  </field>
</form>

为表单定义指定的服务器端的所有验证都将在客户端运行。由于客户端验证用JavaScript执行，所以可以有多种方法不去执行它。要确保验证过程总是能运行，不论你是否选择启用了客户端验证，Validator都在服务器端执行这些验证。

结论

Validator框架针对表单数据的验证提供了可配置的系统，从而为核心Struts框架添加了很多有价值的功能。通过把Validator框架用于你的应用程序，你可以节约时间并简化Struts应用程序的开发过程。

posted @ 2005-12-27 11:50 javaGrowing 阅读(1787) | 评论 (14) | 编辑收藏

用Java解决国际化问题

首都经贸大学信息学院尹海琴

01-7-18 上午 09:11:22

如果应用系统是面向多种语言的，编程时就不得不设法解决国际化问题，包括操作界面的风格问题、提示和帮助语言的版本问题、界面定制个性化问题等。

由于Java语言具有平台无关、可移植性好等优点，并且提供了强大的类库，所以Java语言可以辅助我们解决上述问题。Java语言本身采用双字节字符编码，采用大汉字字符集，这就为解决国际化问题提供了很多方便。从设计角度来说，只要把程序中与语言和文化有关的部分分离出来，加上特殊处理，就可以部分解决国际化问题。在界面风格的定制方面，我们把可以参数化的元素，如字体、颜色等，存储在数据库里，以便为用户提供友好的界面；如果某些部分包含无法参数化的元素，那么我们可能不得不分别设计，通过有针对性的编码来解决具体问题。

Java类包

在用Java解决国际化问题的过程中，可能利用到的主要的类都是由java.util包提供的。该类包中相关的类有Locale、 ResourceBundle、ListResourceBundle、PropertyResourceBundle等，其继承关系如下图所示。

其中各类提供的主要功能如下：

Locale：该类包含对主要地理区域的地域化特征的封装。其特定对象表示某一特定的地理、政治或文化区域。通过设定Locale，我们可以为特定的国家或地区提供符合当地文化习惯的字体、符号、图标和表达格式。例如，我们可以通过获得特定Locale下的Calendar类的实例，显示符合特定表达格式的日期。

ResourceBundle：该类是一个抽象类，需要通过静态方法ResourceBundle.getBundle()指定具体实现类或属性文件的基本名称。基本名称会协同指定的或默认的Locale类，决定具体调用的类或属性文件的唯一名称。例如：指定基本类或属性文件名称为TestBundle，而指定的Locale是CHINESE，那么最适合匹配的类名称为TestBundle_zh_CN.class，而最佳匹配属性文件名称为 TestBundle_zh_CN.properties。按照Java Doc和相关文档的要求，如果该类或属性文件没有找到，系统会查找近似匹配（主文件名依次为TestBundle_zh和TestBundle的类或属性文件）。该类提供的getKeys()方法用于获得所有成员的键名，并提供handleGetObject方法获得指定键的对应元素。

ListResourceBundle：该类继承ResourceBundle类，主要是增加了一些便于操作的成分，但还是抽象类。如果希望使用类的方式实现具体的ResourceBundle，一般情况下最好继承这个类。

PropertyResourceBundle：该类也继承ResourceBundle类，可以实例化。该类的行为特征如同java.util.properties类，可以从输入流中获得具体属性对。

如果涉及日期和时间显示等问题时，可以利用java.text包以及java.util包中的TimeZone、SimpleTimeZone和Calendar等类进行辅助处理。

参数化解决方法

在具体应用时，可以把具体国家或地区特征中可以参数化的部分放在经过特殊命名的属性文件中，在确定具体的Locale后，通过PropertyResourceBundle类读取相应的属性文件，实现国际化特征。

使用PropertyResourceBundle类获得当地版本的国际化信息，部分代码如下：

　　……

　　public static final String BASE_PROP_FILE =

“DISP”;

　　public static final String SUFFIX =

“.properties”;

　　locale = Locale.getDefault();

　　String propFile = BASE_PROP_FILE ＋ “_” ＋ locale.toString()＋ SUFFIX;

　　ResourceBundle rb;

　　try {

　　　File file = new File(propFile);

　　　if (file.exists()) {

　　　is = new FileInputStream(file);

　　 rb = new PropertyResourceBundle(is);

　　 if (rb == null) System.out.println(“No Resource”);

　　　}

　　} catch (IOException ioe) {

　　　System.out.println(“Error open file named ” ＋ propFile);

　　}

　　Enumeration e = rb.getKeys();

　　while (e.hasMoreElements()){

　　　key = (String)e.nextElement();

　　　value = (String)rb.handleGetObject(key);

　　　System.out.println(“KEY: ” ＋ key ＋

“\t\t Value: ” ＋ value);

　　}

　　……

　　DISP_zh_TW.properties文件的具体内容如下：

　　Key1=\u53ef\u4ee5

　　Key2=\u64a4\u9500

等号后面是利用native2ascii程序转化后的繁体汉字，如果不进行转化，系统可能显示乱码。

处理提示和帮助

对于提示语言和帮助文件部分，可以把语言映射放在属性文件或者ListResourceBundle类的子类中。下面程序是一个Servlet，它通过接受客户端的选择，把特定语言和字符版本的信息返回到客户端。

　　……

　　public class ProcessServlet extends HttpServlet

　　{ //默认语言为中文

　　　public static final String DEFAULT_LANGUAGE = “zh”;

　　　//默认字符集为简体中文

　　　public static final String DEFAULT_COUNTRY = “CN”;

　　　public void service(HttpServletRequest req,

HttpServletResponse res) throws IOException, ServletException {

　　 HttpSession session = req.getSession(true);

　　 // 从客户端收到的指定语言和字符的参数应当与Sun公司相关规定一致

　　 String lang = req.getParameter

(“language”);

　　 String country = req.getParameter

(“country”);

　　 if (lang == null)

　　　　{

//如果没有收到参数，就试图从Session里获得

　　 lang = (String) session.getAttribute

(“language”);

　　 country = (String) session.getAttribute

(“country”)

　　 } else {

　　 session.setAttribute(“language”, lang);

　　 session.setAttribute(“country”, country);

　　 }

　　 if (lang == null)

　　　　{

//如果无法从上述手段得到语言和字符信息，就使用默认值

　　 lang = DEFAULT_LANGUAGE;

　　 country = DEFAULT_COUNTRY

　　 session.setAttribute(“language”, lang);

　　　session.setAttribute(“country”, country);

　　 }

　　 Locale locale = null;

　　 ResourceBundle bundle = null;

　　 try {

　　 locale = new Locale(lang, country);

　　 } catch (Exception e) {

　　 System.out.println(“No locale with” ＋

country ＋ “_” ＋ lang);

　　 locale = Locale.getDefault();

　　 }

　　 try {

　　 bundle = ResourceBundle.getBundle(

“DisplayList”, locale);

　　 } catch( MissingResourceException e) {

　　 System.out.println( “No resources available for locale ” ＋ locale);

　　 bundle = ResourceBundle.getBundle

(“DisplayList”, Locale.US);

　　 }

　　 res.setContentType(“text/html”);

　　 PrintWriter out = res.getWriter();

　　 out.println(“<html>”);

　　 out.println(“<head>”);

　　 String title = bundle.getString(“title”);

　 String welcome =bundle.getString

(“welcome”);

　　 String notice = bundle.getString(“notice”);

　　 out.println(“<title>”＋ title ＋

“</title>”);

　　 out.println(“</head>”);

　　 out.println(“<body bgcolor=\”

white\“>”);

　　 out.println(“<h3>” ＋ welcome ＋

“</h3>”);

　　 out.println(“<br>”);

　　 out.println(“<b>” ＋ notice ＋

“</b>”);

　　 out.println(“</body>”);

　　 out.println(“</html>”);

　　　}

上述Servlet使用的属性文件（DisplayList_zh_CN.

properties）内容如下：

title=中文版

welcome=这是简体中文版面

notice=简体中文测试成功

注意：该文件直接采用了中文，而不是经过转化的Unicode编码，这是由于大多数Web服务器不需要上述转化。

在实际使用中，如果Web服务器支持Servlet 2.3规范（如jakarta－tomcate 4.0），那么上面提到的Servlet应当稍加改变，以作为其他Servlet的处理器使用。另外，如果把ResourceBundle的特定版本存放在无状态会话Bean中，就可以在一定程度上提高程序效率。

小结

笔者在实际测试中发现了如下问题，其中部分问题得到了解决：

1. 对于显示字符出现乱码的问题，如果是通过属性文件实现国际化解决方案，那么可能是直接在属性文件中写入了非标准ASCII文字。解决方法是利用JDK提供的工具native2ascii.exe扫描所有属性文件，用扫描结果覆盖原有文件内容。如果我们是利用类文件实现转换方案，那么需要重新编译相关类文件，并在编译时指定编码集。例如，编译使用国标码的类文件，采用的编译命令如下：

javac －encoding GB2312 your_java_file

2. 虽然Sun宣称，在ResourceBundle类的实例化过程中，该类会查找与指定的基础类绝对匹配和尽量与指定的Locale属性相匹配的类。例如：如果我们指定ResourceBundle基础类为TestBundle，而Locale中指定使用zh_CN（中国大陆地区简体中文），那么如果系统找不到TestBundle_zh_CN，系统应当顺次查找TestBundle_zh、TestBundle。但是笔者在系统开发过程中发现，该匹配没有产生任何实际效果。

笔者的测试平台是Windows 2000 Server，没有配置任何Service Pack，使用的JDK版本是1.3.0版本。笔者试图通过查看JDK目录下src.jar中附带的源码找到引起问题的原因，但是发现有关的操作被封装在 sun.misc包中，而src.jar文件没有提供该包中任何类的源码。本文把这个问题提出来，希望与有关开发人员一起探讨。

posted @ 2005-12-14 10:57 javaGrowing 阅读(385) | 评论 (0) | 编辑收藏

Java反射机制

摘要: 侯捷观点 Java反射机制摘要 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fie... 阅读全文

posted @ 2005-12-09 16:58 javaGrowing 阅读(931) | 评论 (1) | 编辑收藏

认识.NET的集合

认识.NET的集合 - 开发者 - ZDNet China

认识.NET的集合

作者： BUILDER.COM
Wednesday, May 15 2002 11:06 AM

集合（collection）提供了一种结构化组织任意对象的方式，而且我们早就知道集合在日常编程工作中的重要性。.NET类库提供了丰富的集合数据类型，其种类之繁多甚至使许多人看得眼都花了，这些集合对象都具有各自的专用场合。不管怎么说，更多的选择也就意味着更高的灵活性，但同时也意味着更高的复杂性。因此，对集合各个类型的用途和使用条件具有适度的了解是完全必要的。下面就请随我进行一场.NET集合之旅吧！

.NET集合定义

从.NET的角度看，所谓的集合可以定义为一种对象，这种对象实现一个或者多个System.Collections.ICollection、System.Collections.IDictionary和System.Collections.IList接口。这一定义把System.Collections名称空间中的“内置”集合划分成了三种类别：

有序集合：仅仅实现ICollection接口的集合，在通常情况下，其数据项目的插入顺序控制着从集合中取出对象的的顺序。System.Collections.Stack和 System.Collections.Queue类都是ICollection集合的典型例子。

索引集合：实现Ilist的集合，其内容能经由从零开始的数字检索取出，就象数组一样。System.Collections.ArrayList对象是索引集合的一个例子。

键式集合：实现 IDictionary 接口的集合，其中包含了能被某些类型的键值检索的项目。IDictionary集合的内容通常按键值方式存储，可以用枚举的方式排序检索。 System.Collections.HashTable类实现了IDictionary 接口。

正如你看到的那样，给定集合的功能在很大程度上受到特定接口或其实现接口的控制。如果你对面向对象编程缺乏了解，那么你可能对上面说的这些话感到难以理解。不过你至少应该知道，以接口这种方式构造对象的功能不但造就了具有整套类似方法的对象族，而且还能让这些对象在必要的情况下可以当作同类，以OOP（面向对象编程）的术语来说，这就是大名鼎鼎的多态性技术。

System.Collections概述

System.Collections名称空间包含了在你的应用程序中可以用到的6种内建通用集合。另一些更为专业化的集合则归属于System.Collections.Specialized，在某些情况下你会发现这些专用集合也是非常有用的。加上一些异常（exception）类，这些专业化集合在功能上和内建集合是类似的。现在就让我们审视一下通用集合以及少量的不太富于专业化的集合。

堆栈和队列

System.Collections.Stack 和 System.Collections.Queue 类，两者仅仅实现了ICollection 接口，按照存储项目加到集合的顺序保存System.Object类型的项目。对象只能按其加入顺序从集合中检索：堆栈是后进先出，而队列则是先进先出。通常情况下，你在以下场合可以考虑采用以上这些集合：

接收和处理集合内项目时顺序比较重要。

你能在处理项目之后丢弃它。

你不需要访问集合中的任意项目。

ArrayList

System.Collections.ArrayList类，仅仅实现 Ilist，最适合描述为一种正常数组和集合的混合类型。ArrayList按照项目被加入集合的顺序存储项目。每个项目都被分配一个索引标识符而且能由关联它们的索引数字以任何顺序被检索。当新项目加入集合时会扩大ArrayList从而令其相比普通数组更具灵活性。然而，ArrayList负载比传统数组更大而且没有实现严格的类型化，也就可以接受任何转换为System.Object的对象（换句话说，对什么东西都来者不拒）。

SortedList

System.Collections.SortedList，它实现了IDictionary和ICollection接口，是最基本的排序集合，与Vb6下的Collection对象非常类似。SortedList存储对象并按照关联的键值对这些存储对象排序。它们也是同时支持索引数字和键对象检索的唯一内建的.NET集合。

HashTable

强有力的System.Collections.HashTable集合实现了IDictionary 和 Icollection，能用来存储多种类型的对象连同关联的唯一字符串键值。在HashTable集合中的项目按照源自其键值的哈希代码所确定的顺序存储。集合内每个对象的键值都必须唯一，而其哈希代码则不一定唯一。

什么是哈希代码？
哈希代码实质上就是从一快数据中消除所有冗余部分之后的结果，它主要起到对数据辅助分类或排序的作用。

当某个项目加入集合时，HashTable即调用键值的GetHashCode方法，由于所有的类都是从System.Objec继承的，所以调用该方法即可确定该类的哈希代码并且按该代码排序存储。你可以强迫使用定制的哈希函数，方法有二，一是重载类的GetHashCode方法，二是向HashTable构造器传递实现了System.Collections.IHashcodeProvider接口的对象，在这种情况下，该对象将用于为所有加入集合的键值产生哈希代码。

从性能的角度看，因为键值搜索仅限于具有同样哈希代码的键值，所以HashTable能够很快地从集合中检索任意一个元素，从而减少了必须通过检查以发现匹配的键值的数量。然而，因为插入到集合中的每个对象-键值对都必须产生相应的哈希代码，所以项目插入的代价就有点高了。因此，HashTable主要运用在按照任意键值反复检索大量相对静态的数据这一场合下。

ListDictionary 和 HybridDictionary

ListDictionary 和 HybridDictionary 类归属于System.Collections.Specialized。它们都在按照唯一键值的原则来组织项目，而且都实现了 IDictionary 和 ICollection 。ListDictionary在内部以链表的方式存储项目，建议用在不会增长超过10个项目的集合中。HybridDictionary采用一个内部链表（实际上就是ListDictionary）作为小集合，当集合变得足够大（超过10个项目）以至于链表实现效率降低时就会转换为HashTable。

StringCollection 和 StringDictionary

System.Collections.Specialized.StringCollection 和 System.Collections.Specialized.StringDictionary 都对存储字符串的集合进行了优化。 StringCollection实现了 IList 和 ICollection 而且实质上就是ArrayList，只不过实现了强烈的类型化仅仅接受字符串而已。StringCollection最理想的应用场合是经常更新或增加的少量数据，而StringDictionary则最适用于不经常增加项目到诸如HashTable之类集合中的大量数据。

NameValueCollection

System.Collections.Specialized.NameValueCollection最有趣的地方在于它能包含关联同一键值的多个项目，这正是它与其他内建集合的差别所在。除此以外，它在功能上类似HashTable，按照源自每一项目键值的哈希代码对项目排序从而也具有类同的优缺点。

存在的问题

如果说由 .NET 类库所提供的内建集合也存在问题的话，那多半是它们几乎都在内部把项目存储为System.Object.类型。从最大灵活性的角度看那是一个好想法，但同时也给采用这些通用集合的程序员提出了一些问题。首先，只要你把一个新项目加到集合中去，运行时就必须实施类型转换操作（创建值类型的索引以便可以当作对象引用）。这是一种低效的操作而且在处理大型集合时会产生相当可观的性能问题。其次，只要你访问通用集合中的一个项目，该项目都将作为System.Object类型被返回，这就意味着你不得不把它转换为真实的类型才能对其进行有意义的操作。
责任编辑：炒饭

posted @ 2005-12-09 11:32 javaGrowing 阅读(352) | 评论 (0) | 编辑收藏

java对象容器

数组与其它容器的区别体现在三个方面：效率，类型识别以及可以持有primitives.

数组是java提供的，是能随机存储和访问reference序列的诸多方法中，最高效的一种。数组是线形序列，所以它可以快速访问其中的元素，但速度是有代价的，当你创建了一个数组之后它的容量就固定了，而且在其生命周期里不能改变。也许你会提议先创建一个数组，等到快不够用的时候，再创建一个新的，然后将旧数组里的reference 全部导到新的里面。其实ArrayList 就是这么做的。但是这种灵活性所带来的开销，使得ArrayList 的效率比起数组有了明显下降。

在我们写程序的时候往往不知道要用多少对象，或者要用一种更复杂方式来存储对象情况。为此，Java 提供了“容器类(container class)”。其基本类型有List, Set 和Map。有了这些工具，你就能解决很多问题了。它们还有一些别的特性。比方说Set 所持有的对象，个个都不同，Map则是一个“关联性数组(associative array)”，它能在两个对象之间建立联系。此外，与数组不同，它们还能自动调整大小，所以你可以往里面放任意数量的对象。这样写程序的时候，就不用操心要开多大的空间了。

Java2 的容器类要解决“怎样持有对象”，而它把这个问题分成两类：

1. Collection: 通常是一组有一定规律的独立元素。List 必须按照特定的顺序持有这些元素，而Set 则不能保存重复的元素。(bag没有这个限制，但是Java的容器类库没有实现它，因为List 已经提供这种功能了。)

2. Map: 一组以“键——值”(key-value)形式出现的pair。初看上去，它应该是一个pair的Collection，但是真这么去做的话，它就会变得很滑稽，所以还是把这个概念独立列出来为好。退一步说，真的要用到Map 的某个子集的时候，创建一个Collection 也是很方便的。Map可以返回“键(key)的”Set，值的Collection，或者pair的Set。和数组一样，Map 不需要什么修改，就能很容易地扩展成多维。你只要直接把Map 的值设成Map 就可以了(然后它的值再是Map，以此类推)。我们先来看看容器的一般特性，然后深入细节，最后再看什么会有这么多版本，以及如何进行选择。

List 会老老实实地持有你所输入的所有对象，既不做排序也不做编辑。Set 则每个对象只接受一次，而且还要用它自己的规则对元素进行重新排序(一般情况下，你关心的只是Set 包没包括某个对象，而不是它到底排在哪里——如果是那样，你最好还是用List)。而Map 也不接收重复的pair，至于是不是重复，要由key来决定。此外，它也有它自己的内部排序规则，不会受输入顺序影响。如果插入顺序是很重要的，那你就只能使用LinkedHashSet 或LinkedHashMap 了。

第一眼看到这张图的时候，你会觉得很震撼。不过你马上就会知道，实际上只有三种容器组件——Map，List 和Set，而每种又有两到三个实现。最常用的几个容器已经用粗黑线框了起来。看到这里，这张图就不再那么令人望而生畏了。
用点号框起来的是interface，用虚线框起来的是abstract 类，实线
则表示普通的(“实体concrete”)类。点线的箭头表示类实现了这个interface(或者，abstract 类表示部分实现了这个interface)。实线
箭头表示这个类可以制造箭头所指的那个类的对象。比如，Collection
能制造Iterator，而List 还能制造ListIterator(也能制造Iterator，因为List 是继承自Collection 的)。
与存放对象有关的接口包括Collection，List，Set 和Map。在理想情况下，绝大多数代码应该只同这些接口打交道，只是在创建容器的时候才要精确地指明它的确切类型。所以你可以这样创建一个List。
List x = new LinkedList( );

当然，你也可以选择让x 成为LinkedList(而不是泛型的List)，这样x 就带上了准确的类型信息interface 的优雅 (同时也是它的本意)就在于，你想修改具体的实现的时候，只要改一下创建的声明就可以了，就
像这样：
List x = new ArrayList( );
无需惊动其它代码(用迭代器也能获得一些这种泛型性)。这个类系里面有很多以“Abstract”开头的类，初看起来这可能会让人有点不明白。实际上它们只是一些部分实现某个接口的办成品。假如你要编一个你自己的Set，不要从Set 接口开始挨个实现它的方法；相反你最好继承AbstractSet，这样就能把编程的工作量压缩到最低了。但是，实际上容器类库的功能已经够强的了，我们要求的事情它几乎都能做
到。所以对我们来说，你完全可以忽略以“Abstract”开头的类。

List 的功能
正如你从ArrayList 那里所看到的，List 的基本用法是相当简单的。虽然绝大多数时候，你只是用add( )加对象，用get( )取对象，用iterator( )获取这个序列的Iterator，但List 还有一些别的很有用的
方法。
实际上有两种List：擅长对元素进行随机访问的，较常用的ArrayList，和更强大的LinkedList。LinkedList 不是为快速的随机访问而设计的，但是它却有一组更加通用的方法。

List (接口)	List 的最重要的特征就是有序；它会确保以一定的顺序保存元素。List 在Collection 的基础上添加了大量方法，使之能在序列中间插入和删除元素。(只对LinkedList 推荐使用。)List 可以制造ListIterator 对象，你除了能用它在List 的中间插入和删除元素之外，还能用它沿两个方向遍历List。
ArrayList*	一个用数组实现的List。能进行快速的随机访问，但是往列表中间插入和删除元素的时候比较慢。ListIterator 只能用在反向遍历ArrayList 的场合，不要用它来插入和删除元素，因为相比LinkedList，在ArrayList 里面用ListIterator 的系统开销比较高。
LinkedList	对顺序访问进行了优化。在List 中间插入和删除元素的代价也不高。随机访问的速度相对较慢。(用ArrayList 吧。)此外它还有addFirst( )， addLast( )，getFirst( )，getLast( )， removeFirst( )和removeLast( )等方法(这些方法，接口和基类均未定义)，你能把它当成栈(stack)，队列(queue)或双向队列(deque)来用。下面这段程序把各种操作都集中到方法里面：List 都能作的事(basicTest( ))，用Iterator 在列表中移动(iterMotion( ))，修改列表的元素(iterManipulation( ))，查看List 的操作结果(testVisual( ))，以及LinkedList 所独有的方法。

Set 的功能
Set 的接口就是Collection 的，所以不像那两个List，它没有额外的
功能。实际上Set 确确实实就是一个Collection——只不过行为方式不
同罢了。(这是继承和多态性的完美运用：表达不同地行为。)Set 会拒绝
持有多个具有相同值的对象的实例(对象的“值”又是由什么决定的呢？
这个问题比较复杂，我们以后会讲的)。

Set (接口)	加入Set 的每个元素必须是唯一的；否则， Set 是不会把它加进去的。要想加进Set， Object 必须定义equals( )，这样才能标明对象的唯一性。Set 的接口和Collection 的一模一样。Set 的接口不保证它会用哪种顺序来存储元素。
HashSet*	为优化查询速度而设计的Set。要放进HashSet 里面的Object 还得定义hashCode( )。
TreeSet	是一个有序的Set，其底层是一棵树。这样你就能从Set 里面提取一个有序序列了。
LinkedHashSet	(JDK 1.4) 一个在内部使用链表的Set，既有HashSet 的查询速度，又能保存元素被加进去的顺序(插入顺序)。用Iterator 遍历Set 的时候，它是按插入顺序进行访问的。

Map 的功能
ArrayList 能让你用数字在一个对象序列里面进行选择，所以从某种意义上讲，它是将数字和对象关联起来。但是，如果你想根据其他条件在一个对象序列里面进行选择的话，那又该怎么做呢？从概念上讲，它看上去像是一个ArrayList，但它不用数字，而是用另一个对象来查找对象！这是一种至关重要的编程技巧。这一概念在Java 中表现为Map。put(Object key, Object value)方法会往Map 里面加一个值，并且把这个值同键(你查找时所用的对象)联系起来。给出键之后，get(Object key)就会返回与之相关联的值。
你也可以用containsKey( ) 和 containsValue( )测试Map 是否包含有某个键或值。
Java 标准类库里有好几种Map：HashMap，TreeMap， LinkedHashMap，WeakHashMap，IdentityHashMap。
它们都实现了Map 的基本接口，但是在行为方式方面有着明显的差异。这些差异体现在，效率，持有和表示对象pair 的顺序，持有对象的时间长短，以及如何决定键的相等性。性能是Map 所要面对的一个大问题。如果你知道get( )是怎么工作的，你就会发觉(比方说)在ArrayList 里面找对象会是相当慢的。而这
正是HashMap 的强项。它不是慢慢地一个个地找这个键，而是用了一种被称为hash code的特殊值来进行查找的。散列(hash)是一种算法，它会从目标对象当中提取一些信息，然后生成一个表示这个对象的“相对
独特”的int。hashCode( )是Object 根类的方法，因此所有Java对象都能生成hash code。HashMap 则利用对象的hashCode( )来进行快速的查找。这样性能就有了急剧的提高。

Map (接口)	维持键－值的关联(即pairs)，这样就能用键来找值了。
HashMap*	基于hash表的实现。(用它来代替Hashtable。)提供时间恒定的插入与查询。在构造函数中可以设置 hash表的capacity 和load factor。可以通过构造函数来调节其性能。
LinkedHashMap	(JDK 1.4) 很像HashMap，但是用Iterator 进行遍历的时候，它会按插入顺序或最先使用的顺序(least-recently-used (LRU) order)进行访问。除了用Iterator 外，其他情况下，只是比HashMap 稍慢一点。用Iterator 的情况下，由于是使用链表来保存内部顺序，因此速度会更快。
TreeMap	基于红黑树数据结构的实现。当你查看键或pair 时，会发现它们是按顺序 (根据Comparable 或Comparator，我们过一会讲)排列的。TreeMap 的特点是，你所得到的是一个有序的Map。TreeMap 是Map 中唯一有subMap( )方法的实现。这个方法能让你获取这个树中的一部分。
WeakHashMap	一个weak key的Map，是为某些特殊问题而设计的。它能让Map 释放其所持有的对象。如果某个对象除了在Map 当中充当键之外，在其它地方都没有其reference 的话，那它将被当作垃圾回收。
IdentityHashMap	(JDK 1.4) 一个用==，而不是equals( )来比较键的hash map。不是为我们平常使用而设计的，是用来解决特殊问题的。散列是往Map 里存数据的常用算法。有时你会需要知道散列算法的工作细节，所以我们会稍后再讲。

posted @ 2005-12-09 11:09 javaGrowing 阅读(2718) | 评论 (1) | 编辑收藏

to_date('2003/07/09', 'yyyy/mm/dd')	would return a date value of July 9, 2003.
to_date('070903', 'MMDDYY')	would return a date value of July 9, 2003.
to_date('20020315', 'yyyymmdd')	would return a date value of Mar 15, 2002.

javaGrowing

常用链接

留言簿(12)

随笔分类(84)

随笔档案(92)

文章分类(32)

文章档案(33)

相册

收藏夹(1)

ajax

java

java专家论坛

linux

Oracle

PHP

sap

xml

其他

好站链接

英语学习

软件下载

電子書

搜索

积分与排名

最新随笔

最新评论

阅读排行榜

评论排行榜

Run your application

Dom + Javascript 在本机浏览器中对的表格数据进行排序

解决Oracle 9i和Tomcat端口冲突(转载)

Examples

The Document object

Document Object Properties

Document Object Methods

Events

Oracle/PLSQL: To_Date Function

目录

作者简介

推荐链接：

目录

关于作者

1.Ant是什么？

2.安装Ant

3.运行Ant

4.编写build.xml

用Java解决国际化问题

.NET集合定义

System.Collections概述

堆栈和队列

存在的问题

Dom +　Javascript 在本机浏览器中对的表格数据进行排序