BlogJava-内蒙古java团队-文章分类-J2EE技术专区

OpenLayers Map理解

帅子 — Wed, 24 Nov 2010 02:03:00 GMT

摘要: 1，视口坐标的原点在左上角，水平向右为x轴正向，垂直向下为y 轴正向；2，地图坐标原点为初始图层的中心点，水平向右为x轴正向，垂直向上为y轴正向；3，视口中心点永远与地图中心点重合，不一定与瓦片中心点重合；4，拖动图层的逻辑描述：地图是不动的，视口移动从而展示不同的地图区域； Resolution：解析度 = 地图尺寸/视口尺寸好比摄像机，镜头拉得越近解析度越小，地图看得越清晰。 map.ca... 阅读全文

帅子 2010-11-24 10:03 发表评论

Fusion 是如何启动的

帅子 — Thu, 11 Nov 2010 16:06:00 GMT

网页模板文件在加载完毕时，通过调用“ Fusion.initialize(); ”来启动 Fusion 框架的初始化过程。但是，在执行这行代码执行之前， Fusion 就已经执行了一些启动代码（ bootstrap ）。这些代码主要涉及确定浏览器语言、加载其余 Fusion 脚本代码和加载商业地图脚本等等。这些工作的代码位于“ \lib\fusion.js ”文件中，从 1064 行至文件尾。当网页加载到 fusion.js 时候，这些代码就会被执行。

让我们先看看加载其余 Fusion 脚本代码做了什么。前文我们提到了，三种加载 Fusion 框架方式是等效的。其中独立压缩方式和独立文件方式是等效的是很容易理解的，这是因为独立压缩方式仅仅是去掉了无用的空格、换行符号和注释。那么，分散加载方式加载的 fusion.js 仅仅是独立文件方式加载的 fusionSF.js 里面代码的一部分，它们两者之间又是如何保证等效的呢？原来，当 Fusion 中有一个要加载脚本文件的列表（ fusion.js 的 1080-1091 行），这个列表的文件和 fusion.js 放在一起，跟 fusionSF.js 文件是完全等效的。在启动代码中， Fusion 如果发现当前采用的是分散加载方式（ Fusion._singleFile 值为 false ），那么就会通过向网页中添加 script 标签的形式来增加新文件。

除了加载其余 Fusion 脚本代码之外，启动代码所做的一个不得不提的工作就是加载商业地图脚本。这个是 2.1.0 新增的一个功能。如果用户需要在地图中加入雅虎、谷歌或者必应地图，那么在启动代码中， Fusion 会检查网页布局文件中是否有 GoogleScript 、 YahooScript 或者 VitualEarthScript 标签，并访问标签里面包含的脚本地址来加载对应的脚本。

当浏览器调用 Fusion.initialize() 脚本的时候， Fusion 便开始了加载的过程。 Fusion 加载的过程分为两步。第一步是将服务器端的网页布局文件变成一个浏览器中包含的信息对象；第二步是根据这个信息对象逐步初始化各个部分。

下面，我们将分别介绍这两个步骤。

从服务器到浏览器——加载应用程序定义
在 Fusion 框架中，网页布局文件又称为应用程序定义（ ApplicationDefinition ）文件。在本章其余部分，这两个词可能会交替使用，但两者意思完全相同。

Fusion 是通过地图代理（ MapAgent ）来获取应用程序定义的。但在此之前， Fusion 先需要知道地图代理的位置。虽然在默认状态下， FusionRoot 是直接放置于“ \fusion ”文件夹中。但 Fusion 本身相对独立一些，支持将 Fusion 放置在其他文件夹中。这时就需要有一个地方能够告诉 Fusion 地图代理的位置，这个地方就位于 Fusion 的 configuration 属性中， Fusion 通过 Fusion.configuration.mapguide.webTierUrl 属性值找到 MapGuide 的位置（该属性值的形式应当类似“ http://localhost/mapguide ”）。如果您使用的是独立文件加载方式或独立压缩加载方式的话，这个属性是已经被设置好了的 (fusionSF.js 的 63201-62346 行 ) 。而对于分散加载方式，这个属性在初始状态下是为定义的，这时 Fusion 会去访问并加载服务器的“ \config.json ”做为 Fusion.configuration 的值。也就是说，如果您采用的是分散加载的方式，而且 Fusion 并没有采用默认的文件夹部署，那么，您可以修改这个文件来指示 Fusion 去哪儿寻找地图代理。

找到地图代理的位置后， Fusion 就会初始化一个 Fusion.Lib.ApplicationDefinition 对象（ fusion.js 的 482 行，这个对象的定义位于 “ \lib\ApplicationDefinition.js ”中）。该对象会在初始化的过程中，通过地图代理请求应用程序定义的内容，并把该定义转化成一个浏览器可以处理的 Javascript 对象。

为了获得一个浏览器可以处理的 Javascript 对象，需要先把应用程序定义文件转成一个 Javascript 对象。这个工作是“ \common\php\Xml2JSON.php ”页面完成的。 Fusion 把获得的应用程序定义 XML 发送到该页面，该页面就会返回转换后的 JSON 对象。但是这个转换过程仅仅是一个形式上的转换，要想让这个 JSON 对象最终可以被 Fusion 框架处理，还需要进一步把它的各个部分解析成 Fusion 库中相应的实例，这个过程由 ApplicationDefinition 的 parseAppDef 函数来完成。

我们知道，应用程序定义中各个部分是采用了一个层次化的结构最终放置在一个 ApplicationDefinition 根节点下。同样地，转换后的 Javascript 对象也是采用类似的结构放置在一个 Fusion.Lib.ApplicationDefinition 对象中。 XML 标签与浏览器对象的转换关系如表 3-1 所示（限于空间，这里应用程序定义的浏览器对象类别省略掉前缀“ Fusion.Lib ”，其余的浏览器对象省略掉前缀“ Fusion.Lib.ApplicationDefinition ”）。

要注意的是，这个过程仅仅是一个把 XML 标签转化成对应的浏览器对象，并没有开始对这些对象的初始化。还有一个有意思的地方是，当构造 Widget 对象的时候，构造代码会通过检查是否定义了类“ Fusion.Widget.< 小工具类型 > ”来检查浏览器中是否已经加载了相应的小工具脚本。如果没有，构造代码会调用 Fusion.require 函数来将脚本代码放置到 Fusion 的一个待加载脚本列表中。这个列表将在下一步进行加载。

当 parseAppDef 将整个应用程序定义文件转换成浏览器对象后， Fusion 就会调用 loadQueuedScripts 函数来加载上一步中发现的没有加载的小工具脚本代码。当所有代码加载完毕之后， Fusion 就会开始整个小工具的初始化工作。

小工具的初始化
当所有代码加载完毕之后， Fusion 会调用 ApplicationDefinition 对象的 create 函数，该函数最终会调用 WidgetSet 的 create 函数，这时，小工具便一个接一个的开始初始化了。

小工具的初始化工作无外乎两个方面：构造一个小工具对象、将其放置到界面中。构造小工具对象的过程相对简单，只要调用“ Fusion.Widget.< 小工具类型 > ”类的构造函数即可。而将小工具放置在界面中的过程，则相对复杂一些。

小工具界面的初始化，有点像一个“填空”过程。

首先， create 函数会检查小工具的 uiClass 属性，并用该属性值作为类名初始化一个界面类。比如，“关于”小工具的 uiClass 属性的值是 Jx.Button ，那么， create 函数会初始化一个 Jx.Button 对象，做为“关于”的界面。在这个初始化过程中，小工具信息中的 label 、 imageUrl 、 imageClass 、 isExclusive 等属性会被作为参数传递到初始化过程中，用来提供初始化的信息。

初始化界面元素之后， create 函数会调用小工具脚本代码的 setUiObject 函数，来允许小工具执行一些定制化的内容。 Fusion.Widget 已经为我们实现了一些常用的代码，比如设置提示、将按钮的按下和弹起事件与小工具的 activate 和 deactivate 函数进行关联等等。如果您需要对于小工具界面提供的空间进行“填空”，一般也会在这个函数内完成。

当 setUiObject 函数执行完毕后，小工具的界面就初始化完毕了。接下来，需要将小工具的界面添加到页面中。这时候有以下两种情况：

1. 如果小工具不属于任何容器，那么 Fusion 框架就会认为这个小工具的界面是一个独立的页面元素。因此， Fusion 框架去寻找页面中以小工具名称作为标识的 div ，并把小工具的界面“填空”到这个 div 中。举个例子，概览地图（ OverviewMap ）小工具的名称（ name ）为 OverviewMap 。那么， Fusion 框架就会通过去寻找网页中标识为 OverviewMap 的 div ，并将小工具的界面利用其 addTo 函数添加到这个 div 中。

2. 如果小工具属于某一容器，那么 Fusion 框架会先寻找相应的容器界面（此前 Fusion 会像添加小工具界面到页面中那样，把容器界面“填空”到相应的 div 中），然后将小工具通过 addTo 函数添加到这个 div 中。

这里我们可以看出，其实在小工具初始化之前，其位于网页中的位置就已经在网页模板中，根据其对应的名称或者容器名称决定下来了。如果您想修改小工具在网页中的位置，您完全不需要改变应用程序定义的内容，而只需要改变网页模板就可以了。

当小工具的界面都被初始化完毕之后，界面就完全加载完毕了。用户就可以通过与界面的交互来使用小工具提供的功能了。

有一点要说明的是，虽然地图小工具也称为小工具，也放置在 Fusion.Widget 命名空间中。但是， Fusion 对于地图小工具的处理是完全不同于其他小工具的。地图小工具在应用程序定义中使用其专用的 MapWidget 标签。 WidgetSet 类也有一个专门的位置来放置地图小工具（ mapWidget 属性）。 Fusion.Widget.Map 也并不是继承自 Fusion.Widget 的，甚至其 create 函数的参数列表也不同于普通的小工具。地图小工具与其他小工具的唯一一点相似是，在“填空”的时候，地图小工具也会添加到以其名称为标识的 div 中。

从中我们不难看出，地图小工具的地位是其他小工具无法比拟的。这是因为，地图是网页地理信息系统最核心的部分。大部分用户交互都是通过地图完成的。所以，我们有必要了解一下地图小工具。

帅子 2010-11-12 00:06 发表评论

MapGuide for java WebGIS的开发

帅子 — Mon, 09 Aug 2010 02:55:00 GMT

首先说说环境的安装：

1. 下载 MapGuide Server 和 MapGuide Web Server Extensions. 到下载页面下载并安装 MgServerSetup-2.0.x.exe 和 MgWebServerExtensionsSetup-2.0.x.exe （https://mapguide.osgeo.org/download/releases/2.0.0 ）

2. 下载 java viewersample-2.0.zip. 解压到 C:\Program Files\MapGuideOpenSource2.0\WebServerExtensions\www.

    注意，解压后，www文件夹下，要有个名叫javav iewersample 的文件夹。改文件夹下，有个readme.Txt，请按上面的说明，进行配置。

    在Apach的目录下面找到conf/httped的文件打开后在文件后面添加：

    JkMount /mapguide/javaviewersample/* worker1

安装数据发布工具Meastro开源的工具。

3. 下载示例数据

到下载页面，下载 Sheboygan.mgp （注意，下载后，后缀可能是zip，将其改成mgp）拷贝该文件到 C:\ProgramFiles\MapGuideOpenSource2.0\Server\Packages. 目录下。

4. 打开一个浏览器，输入 http://localhost:8008/mapguide/mapadmin/login.php .使用站点管理程序，装载示例数据，登陆用户名是 "Administrator" ，密码是 "admin". 管理页面出来后，在左侧的导航条，选择 "Load Packages" . 然后选中靠近 Sheboygan.Mgp 的单选按钮，点击 "Load Package".

5. 启动示例程序

在浏览器中输入 http://localhost:8008/mapguide/javaviewersample/ajaxtiledviewersample.jsp , 将会看到运行效果，到此， MapGuide Open Source 就被运行起来了。

注：默认的方式是apache+tomcat通过jk的方式配合，其实是可以直接访问tomcat的8080端口。主要需要了解 C:\Program Files\MapGuideOpenSource2.0\WebServerExtensions?\www\WEB-INF\lib下的MapGuideApi.jar。然后看看javaviewersample下的示例程序。

注意：

如果这样配置的话，在访问页面的时候会报错：MapGuideJavaApi.dll等路径找不到等等的错误，还有ace失败等错误。

这个时候需要把bin目录下面的ace，xenroll.dll文件拷贝到系统的system32下面，先把以前的文件重命名或备份下以免发生错误。

然后重启动服务即可，可以看到你的地图了。

下篇继续maestro的发布工具介绍......

帅子 2010-08-09 10:55 发表评论

Java数组排序Arrays.sort，以及Comparator接口的用法

帅子 — Wed, 19 May 2010 09:17:00 GMT

有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法，但既然java包里有自带的Arrays.sort排序方法，在数组元素比较少的时候为何不用？

　　Sorting an Array 1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 };

　　Arrays.sort(intArray);

　　输出： [-23, 1, 3, 4]

　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" };

　　Arrays.sort(strArray);

　　输出： [C, a, z]

　　3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　输出： [a, C, z]

　　4. 反向排序， Reverse-order sort

　　Arrays.sort(strArray, Collections.reverseOrder());

　　输出：[z, a, C]

　　5. 忽略大小写反向排序 Case-insensitive reverse-order sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　Collections.reverse(Arrays.asList(strArray));

　　输出： [z, C, a]

　　java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有必要去重复制造轮子。

　　Arrays类有一个静态方法sort,利用这个方法我们可以传入我们要排序的数组进去排序，因为我们传入的是一个数组的引用，所以排序完成的结果也通过这个引用的来更改数组.对于整数、字符串排序，jdk提供了默认的实现，如果要对一个对象数组排序，则要自己实现java.util.Comparator接口。

　　package demo1.client;

　　import java.util.Arrays;

　　import java.util.Comparator;

　　public class ArraySortDemo {

　　public void sortIntArray() {

　　int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };

　　System.out.println("排序前");

　　for (int i = 0; i < arrayToSort.length; i++)

　　System.out.println(arrayToSort[i]);

　　// 调用数组的静态排序方法sort

　　Arrays.sort(arrayToSort);

　　System.out.println("排序后");

　　for (int i = 0; i < arrayToSort.length; i++)

　　System.out.println(arrayToSort[i]);

　　}

　　public void sortStringArray() {

　　String[] arrayToSort = new String[] { "Oscar", "Charlie", "Ryan",

　　"Adam", "David" };

　　System.out.println("排序前");

　　for (int i = 0; i < arrayToSort.length; i++)

　　System.out.println(arrayToSort[i]);

　　System.out.println("排序后");

　　//调用数组的静态排序方法sort

　　Arrays.sort(arrayToSort);

　　for (int i = 0; i < arrayToSort.length; i++)

　　System.out.println(arrayToSort[i]);

　　}

　　public void sortObjectArray() {

　　Dog o1 = new Dog("dog1", 1);

　　Dog o2 = new Dog("dog2", 4);

　　Dog o3 = new Dog("dog3", 5);

　　Dog o4 = new Dog("dog4", 2);

　　Dog o5 = new Dog("dog5", 3);

　　Dog[] dogs = new Dog[] { o1, o2, o3, o4, o5 };

　　System.out.println("排序前");

　　for (int i = 0; i < dogs.length; i++) {

　　Dog dog = dogs[i];

　　System.out.println(dog.getName());

　　}

　　Arrays.sort(dogs, new ByWeightComparator());

　　System.out.println("排序后：");

　　for (int i = 0; i < dogs.length; i++) {

　　Dog dog = dogs[i];

　　System.out.println(dog.getName());

　　}

　　public static void main(String[] args) {

　　ArraySortDemo t = new ArraySortDemo();

　　t.sortIntArray();

　　t.sortStringArray();

　　t.sortObjectArray();

　　}

　　class Dog {

　　private String name;

　　private int weight;

　　public Dog(String name, int weight) {

　　this.setName(name);

　　this.weight = weight;

　　}

　　public int getWeight() {

　　return weight;

　　}

　　public void setWeight(int weight) {

　　this.weight = weight;

　　}

　　public void setName(String name) {

　　this.name = name;

　　}

　　public String getName() {

　　return name;

　　}

　　class ByWeightComparator implements Comparator {

　　public final int compare(Object pFirst, Object pSecond) {

　　int aFirstWeight = ((Dog) pFirst).getWeight();

　　int aSecondWeight = ((Dog) pSecond).getWeight();

　　int diff = aFirstWeight - aSecondWeight;

　　if (diff > 0)

　　return 1;

　　if (diff < 0)

　　return -1;

　　else

　　return 0;

　　}

帅子 2010-05-19 17:17 发表评论

Servlet和JSP经验总结

帅子 — Wed, 19 May 2010 09:00:00 GMT

在servlet的init()方法中缓存数据

　　当应用服务器初始化Servlet和JSP实例之后，为客户端请求提供服务之前，它会调用这个servlet的init()方法。在一个servlet的生命周期中，init()方法只会被调用一次。通过在init()方法中缓存一些静态的数据或完成一些只需要执行一次的、耗时的操作，就可大大地提高系统性能。

　　例如，通过在init()方法中建立一个JDBC连接池是一个最佳例子，假设我们是用jdbc2.0的DataSource接口来取得数据库连接，在通常的情况下，我们需要通过JNDI来取得具体的数据源。我们可以想象在一个具体的应用中，如果每次SQL请求都要执行一次JNDI查询的话，那系统性能将会急剧下降。解决方法是如下代码，它通过缓存DataSource，使得下一次SQL调用时仍然可以继续利用它

　　1.publicclassControllerServletextendsHttpServlet{

　　2.privatejavax.sql.DataSourcetestDS=null;

　　3.publicvoidinit(ServletConfigconfig)throwsServletException{

　　4.super.init(config);

　　5.Contextctx=null;

　　6.try{ctx=newInitialContext();

　　7.testDS=(javax.sql.DataSource)ctx.lookup("jdbc/testDS");

　　8.}

　　9.catch(NamingExceptionne){

　　10.ne.printStackTrace();

　　11.}

　　12.catch(Exceptione){

　　13.e.printStackTrace();

　　14.}

　　15.}

　　16.publicjavax.sql.DataSourcegetTestDS(){

　　17.returntestDS;

　　18.}

　　19.......

　　20.}

　　禁止Servlet和JSP自动重载(auto-reloading)

　　Servlet和JSP提供了一个实用的技术，即自动重载技术，它为开发人员提供了一个好的开发环境，当你改变servlet和JSP页面后而不必重启应用服务器。然而，这种技术在产品运行阶段对系统的资源是一个极大的损耗，因为它会给JSP引擎的类装载器(classloader)带来极大的负担。因此关闭自动重载功能对系统性能的提升是一个极大的帮助。

　　不要滥用HttpSession

　　在很多应用中，我们的程序需要保持客户端的状态，以便页面之间可以相互联系。但不幸的是由于HTTP具有天生无状态性，从而无法保存客户端的状态。因此一般的应用服务器都提供了session来保存客户的状态。在JSP应用服务器中，是通过HttpSession对像来实现session的功能的，但在方便的同时，它也给系统带来了不小的负担。因为每当你获得或更新session时，系统者要对它进行费时的序列化操作。你可以通过对 HttpSession的以下几种处理方式来提升系统的性能：

　　如果没有必要，就应该关闭JSP页面中对HttpSession的缺省设置：如果你没有明确指定的话，每个JSP页面都会缺省地创建一个HttpSession。如果你的JSP中不需要使用session的话，那可以通过如下的JSP页面指示符来禁止它：

　　21.＜%@ page session="false"%＞

　　不要在HttpSession中存放大的数据对像：如果你在HttpSession中存放大的数据对像的话，每当对它进行读写时，应用服务器都将对其进行序列化，从而增加了系统的额外负担。你在HttpSession中存放的数据对像越大，那系统的性能就下降得越快。

　　当你不需要HttpSession时，尽快地释放它：当你不再需要session时，你可以通过调用HttpSession.invalidate()方法来释放它。

　　尽量将session的超时时间设得短一点：在JSP应用服务器中，有一个缺省的session的超时时间。当客户在这个时间之后没有进行任何操作的话，系统会将相关的session自动从内存中释放。超时时间设得越大，系统的性能就会越低，因此最好的方法就是尽量使得它的值保持在一个较低的水平。

将页面输出进行压缩

　　压缩是解决数据冗余的一个好的方法，特别是在网络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)进行来对HTML文件进行压缩，这种方法可以戏剧性地减少HTML文件的下载时间。因此，如果你将servlet或JSP页面生成的HTML页面进行压缩的话，那用户就会觉得页面浏览速度会非常快。但不幸的是，不是所有的浏览器都支持gzip压缩，但你可以通过在你的程序中检查客户的浏览器是否支持它。下面就是关于这种方法实现的一个代码片段：

　　22.publicvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)

　　throwsIOException,ServletException{

　　23.OutputStreamout=null

　　24.Stringencoding=request.getHeader("Accept-Encoding");

　　25.if(encoding!=null&&encoding.indexOf("gzip")!=-1){

　　26.request.setHeader("Content-Encoding","gzip");

　　27.out=newGZIPOutputStream(request.getOutputStream());

　　28.}

　　29.elseif(encoding!=null&&encoding.indexOf("compress")!=-1){

　　30.request.setHeader("Content-Encoding","compress");

　　31.out=newZIPOutputStream(request.getOutputStream());

　　32.}

　　33.else{

　　34.out=request.getOutputStream();

　　35.}

　　36.......

　　37.}

　　使用线程池

　　应用服务器缺省地为每个不同的客户端请求创建一个线程进行处理，并为它们分派service()方法，当service()方法调用完成后，与之相应的线程也随之撤消。由于创建和撤消线程会耗费一定的系统资源，这种缺省模式降低了系统的性能。但所幸的是我们可以通过创建一个线程池来改变这种状况。另外，我们还要为这个线程池设置一个最小线程数和一个最大线程数。在应用服务器启动时，它会创建数量等于最小线程数的一个线程池，当客户有请求时，相应地从池从取出一个线程来进行处理，当处理完成后，再将线程重新放入到池中。如果池中的线程不够地话，系统会自动地增加池中线程的数量，但总量不能超过最大线程数。通过使用线程池，当客户端请求急剧增加时，系统的负载就会呈现的平滑的上升曲线，从而提高的系统的可伸缩性。

　　选择正确的页面包含机制

　　在JSP中有两种方法可以用来包含另一个页面1、使用include指示符(＜ %@ includee file=”test.jsp” %＞)。2、使用jsp指示符(＜ jsp:includee page=”test.jsp” flush=”true”/＞)。在实际中我发现，如果使用第一种方法的话，可以使得系统性能更高。

　　正确地确定javabean的生命周期

　　Servlet和JSP一个强大的地方就是对javabean的支持。通过在JSP页面中使用＜jsp:useBean＞标签，可以将javabean直接插入到一个JSP页面中。它的使用方法如下：

　　38.＜jsp:useBean id="name" scope="page|request|session|application"

　　class= "package.className" type="typeName"＞

　　39.＜/jsp:useBean＞

　　其中scope属性指出了这个bean的生命周期。缺省的生命周期为page。如果你没有正确地选择bean的生命周期的话，它将影响系统的性能。

　　举例来说，如果你只想在一次请求中使用某个bean，但你却将这个bean的生命周期设置成了session，那当这次请求结束后，这个bean将仍然保留在内存中，除非session超时或用户关闭浏览器。这样会耗费一定的内存，并无谓的增加了JVM垃圾收集器的工作量。因此为bean设置正确的生命周期，并在bean的使命结束后尽快地清理它们，会使用系统性能有一个提高。

　　需要注意：

　　1.在字符串连接操作中尽量不使用“＋”操作符：在java编程中，我们常常使用“＋”操作符来将几个字符串连接起来，但你或许从来没有想到过它居然会对系统性能造成影响吧？由于字符串是常量，因此JVM会产生一些临时的对像。你使用的“＋”越多，生成的临时对像就越多，这样也会给系统性能带来一些影响。解决的方法是用StringBuffer对像来代替“＋”操作符。

　　2.避免使用System.out.println()方法：由于System.out.println()是一种同步调用，即在调用它时，磁盘I/O操作必须等待它的完成，因此我们要尽量避免对它的调用。但我们在调试程序时它又是一个必不可少的方便工具，为了解决这个矛盾，我建议你最好使用Log4j工具，它既可以方便调试，而不会产生System.out.println()这样的方法。

　　3.ServletOutputStream 与 PrintWriter的权衡:使用PrintWriter可能会带来一些小的开销，因为它将所有的原始输出都转换为字符流来输出，因此如果使用它来作为页面输出的话，系统要负担一个转换过程。而使用ServletOutputStream作为页面输出的话就不存在一个问题，但它是以二进制进行输出的。

帅子 2010-05-19 17:00 发表评论

JSP验证码大全之Servlet实现(二)

帅子 — Wed, 28 Apr 2010 02:00:00 GMT

Servlet中实现数字英文混合验证码
以下为在Servlet中产生数字跟英文混合验证码的代码分析。

package org.improviser.validateCode;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServlet;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.Random;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class ValidateCodeServlet extends HttpServlet
{

private int x=0;
//设置验证码图片中显示的字体高度
private int fontHeight;
private int codeY;

//在这里定义了验证码图片的宽度
private int width=60;
//定义验证码图片的高度。
private int height=20;
//定义验证码字符个数，此处设置为5位
private int codeNum=5;

char[] codes = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ,'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z',};

/**
* 对验证图片属性进行初始化
*/
public void init() throws ServletException
{
//从部署文件web.xml中获取程序初始化信息，图片宽度跟高度，字符个数信息
//获取初始化字符个数
String strCodeNums=this.getInitParameter("codeNum");
//获取验证码图片宽度参数
String strW=this.getInitParameter("w");
//获取验证码图片高度参数
String strH=this.getInitParameter("h");

//将配置的字符串信息转换成数值类型数字
try
{
if(strH!=null && strH.length()!=0)
{
height=Integer.parseInt(strH);
}
if(strW!=null && strW.length()!=0)
{
width=Integer.parseInt(strW);
}
if(strCodeNums!=null && strCodeNums.length()!=0)
{
codeNum=Integer.parseInt(strCodeNums);
}
}
catch(NumberFormatException e)
{}

x=width/(codeNum+1);
fontHeight=height-2;
codeY=height-4;

}

protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, java.io.IOException
{
//定义验证码图像的缓冲流
BufferedImage buffImg = new BufferedImage(
width, height,BufferedImage.TYPE_INT_RGB);
//产生图形上下文
Graphics2D g = buffImg.createGraphics();

//创建随机数产生函数
Random random = new Random();

//将验证码图像背景填充为白色
g.setColor(Color.WHITE);
g.fillRect(0, 0, width, height);

//创建字体格式，字体的大小则根据验证码图片的高度来设定。
Font font = new Font("Fixedsys", Font.PLAIN, fontHeight);
//设置字体。
g.setFont(font);

//为验证码图片画边框，为一个像素。
g.setColor(Color.BLACK);
g.drawRect(0, 0, width - 1, height - 1);

//随机生产222跳图片干扰线条，使验证码图片中的字符不被轻易识别
g.setColor(Color.BLACK);
for(int i = 0; i ＜222; i++)
{
int x = random.nextInt(width);
int y = random.nextInt(height);
int xl = random.nextInt(12);
int yl = random.nextInt(12);
g.drawLine(x, y, x + xl, y + yl);
}

//randomCode保存随机产生的验证码
StringBuffer randomCode = new StringBuffer();

//定义颜色三素
int red = 0, green = 0, blue = 0;

//随机生产codeNum个数字验证码
for (int i = 0; i ＜ codeNum; i++) {
//得到随机产生的验证码
String strRand = String.valueOf(codeSequence[random.nextInt(82)]);
//使用随机函数产生随机的颜色分量来构造颜色值，这样输出的每位数字的颜色值都将不同。
red = random.nextInt(255);
green = random.nextInt(255);
blue = random.nextInt(255);

//用随机产生的颜色将验证码绘制到图像中。
g.setColor(new Color(red, green, blue));
g.drawString(strRand, (i + 1) * x, codeY);

//将产生的四个随机数组合在一起。
randomCode.append(strRand);
}
// 将生产的验证码保存到Session中
HttpSession session = req.getSession();
session.setAttribute("validate", randomCode.toString());

// 设置图像缓存为no-cache。
resp.setHeader("Pragma", "no-cache");
resp.setHeader("Cache-Control", "no-cache");
resp.setDateHeader("Expires", 0);

resp.setContentType("image/jpeg");

//将最终生产的验证码图片输出到Servlet的输出流中
ServletOutputStream sos = resp.getOutputStream();
ImageIO.write(buffImg, "jpeg", sos);
sos.close();
}

}

   以上即是在Servlet中产生英文数字混合验证码的过程，以下介绍下在web.xml中对图片进行部署。

   七、Servlet验证码的部署
    在web.xml中声明servlet。

<servlet>
<servlet-name>ValidateCodeServletservlet-name>
<servlet-class>org.improviser.validateCode.ValidateCodeServletservlet-class>
<init-param>
<param-name>widthparam-name>
<param-value>160param-value>
init-param>
<init-param>
<param-name>heightparam-name>
<param-value>68param-value>
init-param>
<init-param>
<param-name>codeCountparam-name>
<param-value>5param-value>
init-param>
servlet>

<servlet-mapping>
<servlet-name>ValidateCodeServletservlet-name>
<url-pattern>/validateCodeServleturl-pattern>
servlet-mapping>

帅子 2010-04-28 10:00 发表评论

JSP验证码大全之Servlet实现(一)

帅子 — Wed, 28 Apr 2010 01:59:00 GMT

         本文将介绍另一种J2EE中验证码的产生跟使用，即在Servlet中定义验证码的产生并使用，通过将验证码的生成封装到JAVA类中，更好的达到代码跟页面分离的效果，因此提倡使用该方法。
  Servlet中实现四位数字验证码
   以下为在Servlet中实现四位数字验证码的源码分析。

import java.awt.image.*;
import com.sun.image.codec.jpeg.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.awt.*;
/*
* 功能：调用AuthCodeServlet可以生成一个4位数字的验证码图片,验证码的图片宽度和高度可以通过配置文件进行定义
* 验证码调用格式为: /servlet/AuthCodeServlet?w=78&h=32
* 或者使用默认长宽/servlet/AuthCodeServlet
*/
   public class AuthCodeServlet extends HttpServlet {
   // 处理post
    public void doPost(HttpServletRequest req,HttpServletResponse res)
    throws ServletException,IOException {
    doGet(req,res);
}

//设置字体
private Font mFont=new Font("Times New Roman", Font.PLAIN,16);

public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {

     HttpSession session=request.getSession();
     response.setContentType("image/gif");
     response.setHeader("Pragma","No-cache");
     response.setHeader("Cache-Control","no-cache");
     response.setDateHeader("Expires", 0);
     int width=70; //验证码默认长度
     int height=24; //验证码默认宽度
     if(request.getParameter("w")!=null && !request.getParameter("w").equals(""))
      width = Integer.parseInt(request.getParameter("w"));
     if(request.getParameter("h")!=null && !request.getParameter("h").equals(""))
      height = Integer.parseInt(request.getParameter("h"));

     ServletOutputStream out=response.getOutputStream(); //获取输出流
     BufferedImage image=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB); //新建验证图片，并设置验证码图片的大小
     Graphics gra=image.getGraphics(); //获取图形上下文
     Random random=new Random();
     gra.setColor(getRandColor(260,210));    //设置验证码的图片背景色
     gra.fillRect(0,0,width,height);
     gra.setColor(Color.BLUE); //设置字体色为蓝色
     gra.setFont(mFont); //设置定义的字体格式

     // 随机产生254条干扰直线，使图象中的验证码不易被解析程序分析到
     gra.setColor(getRandColor(110,240));
     for (int i=0;i<254;i++)
     {
      int x = random.nextInt(width);
      int y = random.nextInt(height);
             int xl = random.nextInt(63);
             int yl = random.nextInt(64);
      gra.drawLine(x,y,x+xl,y+yl);
     }

     // 取随机产生的验证码(4位数字)
     String sRand="";
     for (int i=0;i<4;i++){
     String rand=String.valueOf(random.nextInt(353));
     sRand+=rand;
     // 将认证码显示到图象中
      gra.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
     //调用随机函数构建随机颜色三素
         gra.drawString(rand,13*i+6,16);
     }
         session.setAttribute("authCode",sRand);
         JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(out);
         encoder.encode(image);
}

   static Color getRandColor(int ff,int cc){
          //给定范围获得随机颜色
          Random random = new Random();
          if(fc>255) ff=255;
          if(bc>255) cc=255;
          int r=ff+random.nextInt(cc-ff);
          int g=ff+random.nextInt(cc-ff);
          int b=ff+random.nextInt(cc-ff);
          return new Color(r,g,b);
   }

   static public String getAuthCode(HttpSession session){
    //返回验证码
    return (String)session.getAttribute("AuthCode");
   }
}

帅子 2010-04-28 09:59 发表评论

JSP验证码大全之验证码使用与乱码解决[转]

帅子 — Wed, 28 Apr 2010 01:57:00 GMT

对验证码的使用分为两个部分，分别为验证码的调用和验证过程，以下分别做说明介绍。
三、在JSP中调用验证码
使用验证码直接在图片处调用产生验证码的JSP文件即可，同时在刷新验证码按钮处的js代码中使用JSP验证码文件，页面源码如下。

< form id = "dForm" method = post action = "val.jsp" >

< ul class = "sFrm" >

< li >< b > b >< img id = "code" border = 0 src = "Num.jsp" />< input type = "button" value = " 看不清，换一张 " onClick = "document.getElementById('code').src='ColorChinese.jsp'" >< div class = "clear0" > div > li >

< li >< b > 验证码 b >< input type = "text" name = "input" maxlength = 8 value = "" styleClass = "sIpt itemFm" >< div class = "clear0" > div > li >

< li class = "bar" >< b > b >< input type = "submit" value = " 验证测试 " styleClass = "logbtn3" > li >

ul >
form >

   四、在JSP中验证码的验证过程以及中文乱码处理
            获取用户输入的验证码并与Session中的验证码比较，相同即通过，否则拒绝，对于JSP中中文验证码的处理注意要在页面中定义JSP页面编码跟获取Session的字符编码一致，此处使用的是统一的GB2312编码，否则将出现验证码无法成功验证的情况。

val.jsp
<%@ page language="java" pageEncoding="GB2312" %>

request.setCharacterEncoding("gb2312");

    //获取Session会话中缓存的验证码
    String rand = (String)session.getAttribute("rand");
    //获取用户输入的验证码
    String input = request.getParameter("input");

if(rand==null||input==null)

{

//无输入验证码处理代码
}

if (rand.equals(input)) {

//验证码对比成功

}

else

{
//验证码失败处理代码

}
%>

帅子 2010-04-28 09:57 发表评论

JSP验证码大全之中文验证码[转]

帅子 — Wed, 28 Apr 2010 01:56:00 GMT

摘要: 中文验证码在JSP中的实现，使用中文验证码的好处是能提高验证的有效性，提高验证的安全度，因为中文相对于英文或数字笔画结构相对比较复杂，从而增加了分析程序解析验证码图片并读取验证信息的难度。在文中并分析中文验证的实现过程。二、JSP中实现中文验证码源码如下： ChineseVal.jsp &... 阅读全文

帅子 2010-04-28 09:56 发表评论

JSP验证码大全之数字验证码[转]

帅子 — Wed, 28 Apr 2010 01:54:00 GMT

      验证码应用在各种场合中，十分广泛，在多种多样的系统或软件中的新用户帐户注册、用户登录、网站统一登陆或者用户在网站发布信息模块发布文章或内容都添加的随机码功能，对用户操作过程进行一种验证，使用验证码的目的就是为了避免网络中的自动注册程序或者自动发布程序的滥用。验证码的原理其实就是随机选择一些字符码以将字符码以图片的形式展现在软件验证界面或验证页面上，当用户在进行提交操作的同时需要将图片上的验证码输入并同时提交，如果提交的字符验证码与服务器session保存的字符码相同，则认为提交信息有效，否则拒绝提交。在使用验证码过程中，为了避免自动分析程序解析图片并获得验证信息，通常需要在图片上随机生成一些干扰线或者将复杂的字符对图片进行扭曲模糊，从而增加了自动识别程序分析验证图片的难度。
   JSP验证码源码大全将分别用几个篇幅的内容来介绍在JSP中几种验证码的实现源码以及使用。
   一、JSP中产生数字验证码源码
   数字验证码是一种最常用的验证字符码形式，以下为数字实现的JSP源码：

Num.jsp
<%@ page contentType="image/jpeg" import="java.awt.*,java.awt.image.*,java.util.*,javax.imageio.*" %>

<%!

Color getRandColor(int cc,int bb)

{

Random random = new Random();

if(fc>255) cc=255;

if(bc>255) bb=255;

int r=cc+random.nextInt(bb-cc);

int g=cc+random.nextInt(bb-cc);

int b=cc+random.nextInt(bb-cc);

returnnew Color(r,g,b);

} //获取随机颜色

response.setHeader("Pragma","No-cache");

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

response.setDateHeader("Expires", 0);

int width=80; //定义验证码图片的长度

int height=30; //定义验证码图片的宽度

BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

Graphics g = image.getGraphics();

Random random = new Random();

g.setColor(getRandColor(200,250));

g.fillRect(0, 0, width, height);

g.setFont(new Font("Times New Roman",Font.PLAIN,18));

//定义字体形式

g.setColor(getRandColor(160,200));

for (int i=0;i<155;i++)

{

int i_x = random.nextInt(width);

int i_y = random.nextInt(height);

int i_xl = random.nextInt(12);

int i_yl = random.nextInt(12);

g.drawLine(i_x,i_y,i_x+i_xl,i_y+i_yl);

}

//用线条画背景

String s_Rand="";

for (int i=0;i<4;i++)

{

String rand=String.valueOf(random.nextInt(10));

s_Rand+=rand;

g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));

g.drawString(rand,13*i+6,16);

}

//产生4位随机码

session.setAttribute("rand",s_Rand);

//将验证码存入Session中

g.dispose();

ImageIO.write(image, "JPEG", response.getOutputStream());

//输出验证图片

out.clear();

out = pageContext.pushBody();

帅子 2010-04-28 09:54 发表评论

在JSP页面中的应用JavaBean [转]

帅子 — Thu, 15 Apr 2010 15:04:00 GMT

摘要: JavaBean 是一种基于 Java的软件组件。JSP 对于在 Web 应用中集成 JavaBean 组件提供了完善的支持。这种支持不仅能缩短开发时间（可以直接利用经测试和可信任的已有组件，避免了重复开发），也为 JSP 应用带来了更多的可伸缩性。 JavaBean 组件可以用来执行复杂的计算任务，或负责与数据库的交互以及数据提取等。如果我们有三... 阅读全文

帅子 2010-04-15 23:04 发表评论

Java实现汉字转换为拼音 [转]

帅子 — Tue, 02 Feb 2010 09:12:00 GMT

代码说明：

　　Java实现汉字转换为拼音的GUI版本。

　　GUI代码部分：

　　/**

　　* @(#)CnToSpellGUI.java

　　* kindani

　　* 2004-10-25??

　　* */

　　import java.awt.*;

　　import java.awt.event.*;

　　import javax.swing.*;

　　import javax.swing.event.*;

　　/**

　　JDK版本

　　1.4

　　* @author KIN

　　* @version 1.0

　　* @see

　　* @since 1.0

　　public class CnToSpell2GUI extends JFrame {

　　private CnToSpell2GUI c = null;

　　public CnToSpell2GUI () {

　　super("Cn to Spell");

　　setSize(800,100);

　　getContentPane().setLayout(new FlowLayout());

　　// component layout

　　JTextArea from = new JTextArea(5,20);

　　JTextArea to = new JTextArea(5,20);

　　JButton b = new JButton("cn to pinyin");

　　getContentPane().add(new JLabel("From:"));

　　getContentPane().add(from);

　　getContentPane().add(b);

　　getContentPane().add(new JLabel("To:"));

　　getContentPane().add(to);

　　// action handle

　　b.addActionListener(new Cn2PinyinActionListener(from,to));

　　setVisible(true);

　　// set this for pack

　　c = this;

　　}
/**button action listener to convert text to pinyin from one textbox to another textbox*/

　　class Cn2PinyinActionListener implements ActionListener{

　　private JTextArea from = null;

　　private JTextArea to = null;

　　public Cn2PinyinActionListener(JTextArea from, JTextArea to) {

　　this.from = from;

　　this.to = to;

　　}

　　public void actionPerformed(ActionEvent e) {

　　if (from.getText().length() == 0) {

　　JOptionPane.showMessageDialog(from,"From text is empty!","Warning",JOptionPane.WARNING_MESSAGE);

　　}

　　String text = from.getText();

　　to.setText(CnToSpell.getFullSpell(text));

　　c.pack();

　　}

　　public static void main(String [] args) {

　　CnToSpell2GUI g = new CnToSpell2GUI();

　　}

　　　/**

　　* @(#)CnToSpell.java

　　* 修订记录:

　　* 1)更改者：Easydozer

　　* 时　间：2004-10-20

　　* 描　述：创建

　　package com.easydozer.commons.util;

　　import java.util.Iterator;

　　import java.util.LinkedHashMap;

　　import java.util.Set;

　　/**

　　汉字转化为全拼

　　JDK版本:

　　1.4

　　* @author 谢计生

　　* @version 1.0

　　* @see

　　* @since 1.0

　　public class CnToSpell

　　{

　　private static LinkedHashMap spellMap = null;

　　static

　　{

　　if(spellMap == null){

　　spellMap = new LinkedHashMap(400);

　　}

　　initialize();

　　System.out.println("Chinese transfer Spell Done.");

　　}
private CnToSpell()

　　{

　　}

　　private static void spellPut(String spell,int ascii)

　　{

　　spellMap.put(spell,new Integer(ascii));

　　}

　　private static void initialize()

　　{

　　spellPut("a", -20319);

　　spellPut("ai", -20317);

　　spellPut("an", -20304);

　　spellPut("ang", -20295);

　　spellPut("ao", -20292);

　　spellPut("ba", -20283);

　　spellPut("bai", -20265);

　　spellPut("ban", -20257);

　　spellPut("bang", -20242);

　　spellPut("bao", -20230);

　　spellPut("bei", -20051);

　　spellPut("ben", -20036);

　　spellPut("beng", -20032);

　　spellPut("bi", -20026);

　　spellPut("bian", -20002);

　　spellPut("biao", -19990);

　　spellPut("bie", -19986);

　　spellPut("bin", -19982);

　　spellPut("bing", -19976);

　　spellPut("bo", -19805);

　　spellPut("bu", -19784);

　　spellPut("ca", -19775);

　　spellPut("cai", -19774);

　　spellPut("can", -19763);

　　spellPut("cang", -19756);

　　spellPut("cao", -19751);

　　spellPut("ce", -19746);

　　spellPut("ceng", -19741);

　　spellPut("cha", -19739);

　　spellPut("chai", -19728);

　　spellPut("chan", -19725);

　　spellPut("chang", -19715);

　　spellPut("chao", -19540);

　　spellPut("che", -19531);

　　spellPut("chen", -19525);

　　spellPut("cheng", -19515);

　　spellPut("chi", -19500);

　　spellPut("chong", -19484);

　　spellPut("chou", -19479);

　　spellPut("chu", -19467);

　　spellPut("chuai", -19289);

　　spellPut("chuan", -19288);

　　spellPut("chuang", -19281);

　　spellPut("chui", -19275);

　　spellPut("chun", -19270);

　　spellPut("chuo", -19263);

　　spellPut("ci", -19261);

　　spellPut("cong", -19249);

　　spellPut("cou", -19243);

　　spellPut("cu", -19242);

　　spellPut("cuan", -19238);

　　spellPut("cui", -19235);

　　spellPut("cun", -19227);

　　spellPut("cuo", -19224);

　　spellPut("da", -19218);

　　spellPut("dai", -19212);

　　spellPut("dan", -19038);
spellPut("dang", -19023);

　　spellPut("dao", -19018);

　　spellPut("de", -19006);

　　spellPut("deng", -19003);

　　spellPut("di", -18996);

　　spellPut("dian", -18977);

　　spellPut("diao", -18961);

　　spellPut("die", -18952);

　　spellPut("ding", -18783);

　　spellPut("diu", -18774);

　　spellPut("dong", -18773);

　　spellPut("dou", -18763);

　　spellPut("du", -18756);

　　spellPut("duan", -18741);

　　spellPut("dui", -18735);

　　spellPut("dun", -18731);

　　spellPut("duo", -18722);

　　spellPut("e", -18710);

　　spellPut("en", -18697);

　　spellPut("er", -18696);

　　spellPut("fa", -18526);

　　spellPut("fan", -18518);

　　spellPut("fang", -18501);

　　spellPut("fei", -18490);

　　spellPut("fen", -18478);

　　spellPut("feng", -18463);

　　spellPut("fo", -18448);

　　spellPut("fou", -18447);

　　spellPut("fu", -18446);

　　spellPut("ga", -18239);

　　spellPut("gai", -18237);

　　spellPut("gan", -18231);

　　spellPut("gang", -18220);

　　spellPut("gao", -18211);

　　spellPut("ge", -18201);

　　spellPut("gei", -18184);

　　spellPut("gen", -18183);

　　spellPut("geng", -18181);

　　spellPut("gong", -18012);

　　spellPut("gou", -17997);

　　spellPut("gu", -17988);

　　spellPut("gua", -17970);

　　spellPut("guai", -17964);

　　spellPut("guan", -17961);

　　spellPut("guang", -17950);

　　spellPut("gui", -17947);

　　spellPut("gun", -17931);

　　spellPut("guo", -17928);

　　spellPut("ha", -17922);

　　spellPut("hai", -17759);

　　spellPut("han", -17752);

　　spellPut("hang", -17733);

　　spellPut("hao", -17730);

　　spellPut("he", -17721);

　　spellPut("hei", -17703);

　　spellPut("hen", -17701);

　　spellPut("heng", -17697);

　　spellPut("hong", -17692);

　　spellPut("hou", -17683);

　　spellPut("hu", -17676);

　　spellPut("hua", -17496);

　　spellPut("huai", -17487);

　　spellPut("huan", -17482);

　　spellPut("huang", -17468);

　　spellPut("hui", -17454);

　　spellPut("hun", -17433);

　　spellPut("huo", -17427);

　　spellPut("ji", -17417);

　　spellPut("jia", -17202);

　　spellPut("jian", -17185);

　　spellPut("jiang", -16983);

　　spellPut("jiao", -16970);

　　spellPut("jie", -16942);

　　spellPut("jin", -16915);

　　spellPut("jing", -16733);

　　spellPut("jiong", -16708);

　　spellPut("jiu", -16706);

　　spellPut("ju", -16689);

　　spellPut("juan", -16664);

　　spellPut("jue", -16657);

　　spellPut("jun", -16647);

　　spellPut("ka", -16474);

　　spellPut("kai", -16470);

　　spellPut("kan", -16465);

　　spellPut("kang", -16459);

　　spellPut("kao", -16452);

　　spellPut("ke", -16448);

　　spellPut("ken", -16433);

　　spellPut("keng", -16429);

　　spellPut("kong", -16427);

　　spellPut("kou", -16423);

　　spellPut("ku", -16419);

　　spellPut("kua", -16412);

　　spellPut("kuai", -16407);

　　spellPut("kuan", -16403);

　　spellPut("kuang", -16401);

　　spellPut("kui", -16393);

　　spellPut("kun", -16220);
spellPut("kuo", -16216);

　　spellPut("la", -16212);

　　spellPut("lai", -16205);

　　spellPut("lan", -16202);

　　spellPut("lang", -16187);

　　spellPut("lao", -16180);

　　spellPut("le", -16171);

　　spellPut("lei", -16169);

　　spellPut("leng", -16158);

　　spellPut("li", -16155);

　　spellPut("lia", -15959);

　　spellPut("lian", -15958);

　　spellPut("liang", -15944);

　　spellPut("liao", -15933);

　　spellPut("lie", -15920);

　　spellPut("lin", -15915);

　　spellPut("ling", -15903);

　　spellPut("liu", -15889);

　　spellPut("long", -15878);

　　spellPut("lou", -15707);

　　spellPut("lu", -15701);

　　spellPut("lv", -15681);

　　spellPut("luan", -15667);

　　spellPut("lue", -15661);

　　spellPut("lun", -15659);

　　spellPut("luo", -15652);

　　spellPut("ma", -15640);

　　spellPut("mai", -15631);

　　spellPut("man", -15625);

　　spellPut("mang", -15454);

　　spellPut("mao", -15448);

　　spellPut("me", -15436);

　　spellPut("mei", -15435);

　　spellPut("men", -15419);

　　spellPut("meng", -15416);

　　spellPut("mi", -15408);

　　spellPut("mian", -15394);

　　spellPut("miao", -15385);

　　spellPut("mie", -15377);

　　spellPut("min", -15375);

　　spellPut("ming", -15369);

　　spellPut("miu", -15363);

　　spellPut("mo", -15362);

　　spellPut("mou", -15183);

　　spellPut("mu", -15180);

　　spellPut("na", -15165);

　　spellPut("nai", -15158);

　　spellPut("nan", -15153);

　　spellPut("nang", -15150);

　　spellPut("nao", -15149);

　　spellPut("ne", -15144);

　　spellPut("nei", -15143);

　　spellPut("nen", -15141);

　　spellPut("neng", -15140);

　　spellPut("ni", -15139);

　　spellPut("nian", -15128);

　　spellPut("niang", -15121);

　　spellPut("niao", -15119);

　　spellPut("nie", -15117);

　　spellPut("nin", -15110);

　　spellPut("ning", -15109);

　　spellPut("niu", -14941);

　　spellPut("nong", -14937);

　　spellPut("nu", -14933);

　　spellPut("nv", -14930);

　　spellPut("nuan", -14929);

　　spellPut("nue", -14928);

　　spellPut("nuo", -14926);

　　spellPut("o", -14922);

　　spellPut("ou", -14921);

　　spellPut("pa", -14914);

　　spellPut("pai", -14908);

　　spellPut("pan", -14902);

　　spellPut("pang", -14894);

　　spellPut("pao", -14889);

　　spellPut("pei", -14882);

　　spellPut("pen", -14873);

　　spellPut("peng", -14871);

　　spellPut("pi", -14857);

　　spellPut("pian", -14678);

　　spellPut("piao", -14674);

　　spellPut("pie", -14670);

　　spellPut("pin", -14668);

　　spellPut("ping", -14663);

　　spellPut("po", -14654);

　　spellPut("pu", -14645);

　　spellPut("qi", -14630);

　　spellPut("qia", -14594);

　　spellPut("qian", -14429);

　　spellPut("qiang", -14407);

　　spellPut("qiao", -14399);

　　spellPut("qie", -14384);

　　spellPut("qin", -14379);

　　spellPut("qing", -14368);

　　spellPut("qiong", -14355);

　　spellPut("qiu", -14353);

　　spellPut("qu", -14345);

　　spellPut("quan", -14170);

　　spellPut("que", -14159);

　　spellPut("qun", -14151);

　　spellPut("ran", -14149);

　　spellPut("rang", -14145);

　　spellPut("rao", -14140);

　　spellPut("re", -14137);

　　spellPut("ren", -14135);

　　spellPut("reng", -14125);

　　spellPut("ri", -14123);

　　spellPut("rong", -14122);

　　spellPut("rou", -14112);

　　spellPut("ru", -14109);

　　spellPut("ruan", -14099);

　　spellPut("rui", -14097);

　　spellPut("run", -14094);

　　spellPut("ruo", -14092);

　　spellPut("sa", -14090);

　　spellPut("sai", -14087);

　　spellPut("san", -14083);

　　spellPut("sang", -13917);

　　spellPut("sao", -13914);
spellPut("se", -13910);

　　spellPut("sen", -13907);

　　spellPut("seng", -13906);

　　spellPut("sha", -13905);

　　spellPut("shai", -13896);

　　spellPut("shan", -13894);

　　spellPut("shang", -13878);

　　spellPut("shao", -13870);

　　spellPut("she", -13859);

　　spellPut("shen", -13847);

　　spellPut("sheng", -13831);

　　spellPut("shi", -13658);

　　spellPut("shou", -13611);

　　spellPut("shu", -13601);

　　spellPut("shua", -13406);

　　spellPut("shuai", -13404);

　　spellPut("shuan", -13400);

　　spellPut("shuang", -13398);

　　spellPut("shui", -13395);

　　spellPut("shun", -13391);

　　spellPut("shuo", -13387);

　　spellPut("si", -13383);

　　spellPut("song", -13367);

　　spellPut("sou", -13359);

　　spellPut("su", -13356);

　　spellPut("suan", -13343);

　　spellPut("sui", -13340);

　　spellPut("sun", -13329);

　　spellPut("suo", -13326);

　　spellPut("ta", -13318);

　　spellPut("tai", -13147);

　　spellPut("tan", -13138);

　　spellPut("tang", -13120);

　　spellPut("tao", -13107);

　　spellPut("te", -13096);

　　spellPut("teng", -13095);

　　spellPut("ti", -13091);

　　spellPut("tian", -13076);

　　spellPut("tiao", -13068);

　　spellPut("tie", -13063);

　　spellPut("ting", -13060);

　　spellPut("tong", -12888);

　　spellPut("tou", -12875);

　　spellPut("tu", -12871);

　　spellPut("tuan", -12860);

　　spellPut("tui", -12858);

　　spellPut("tun", -12852);

　　spellPut("tuo", -12849);

　　spellPut("wa", -12838);

　　spellPut("wai", -12831);

　　spellPut("wan", -12829);

　　spellPut("wang", -12812);

　　spellPut("wei", -12802);

　　spellPut("wen", -12607);

　　spellPut("weng", -12597);

　　spellPut("wo", -12594);

　　spellPut("wu", -12585);

　　spellPut("xi", -12556);

　　spellPut("xia", -12359);

　　spellPut("xian", -12346);

　　spellPut("xiang", -12320);

　　spellPut("xiao", -12300);

　　spellPut("xie", -12120);

　　spellPut("xin", -12099);

　　spellPut("xing", -12089);

　　spellPut("xiong", -12074);

　　spellPut("xiu", -12067);

　　spellPut("xu", -12058);

　　spellPut("xuan", -12039);

　　spellPut("xue", -11867);

　　spellPut("xun", -11861);

　　spellPut("ya", -11847);

　　spellPut("yan", -11831);

　　spellPut("yang", -11798);

　　spellPut("yao", -11781);

　　spellPut("ye", -11604);

　　spellPut("yi", -11589);

　　spellPut("yin", -11536);

　　spellPut("ying", -11358);

　　spellPut("yo", -11340);

　　spellPut("yong", -11339);

　　spellPut("you", -11324);

　　spellPut("yu", -11303);

　　spellPut("yuan", -11097);

　　spellPut("yue", -11077);

　　spellPut("yun", -11067);

　　spellPut("za", -11055);

　　spellPut("zai", -11052);

　　spellPut("zan", -11045);

　　spellPut("zang", -11041);

　　spellPut("zao", -11038);

　　spellPut("ze", -11024);

　　spellPut("zei", -11020);

　　spellPut("zen", -11019);

　　spellPut("zeng", -11018);

　　spellPut("zha", -11014);
spellPut("zhai", -10838);

　　spellPut("zhan", -10832);

　　spellPut("zhang", -10815);

　　spellPut("zhao", -10800);

　　spellPut("zhe", -10790);

　　spellPut("zhen", -10780);

　　spellPut("zheng", -10764);

　　spellPut("zhi", -10587);

　　spellPut("zhong", -10544);

　　spellPut("zhou", -10533);

　　spellPut("zhu", -10519);

　　spellPut("zhua", -10331);

　　spellPut("zhuai", -10329);

　　spellPut("zhuan", -10328);

　　spellPut("zhuang", -10322);

　　spellPut("zhui", -10315);

　　spellPut("zhun", -10309);

　　spellPut("zhuo", -10307);

　　spellPut("zi", -10296);

　　spellPut("zong", -10281);

　　spellPut("zou", -10274);

　　spellPut("zu", -10270);

　　spellPut("zuan", -10262);

　　spellPut("zui", -10260);

　　spellPut("zun", -10256);

　　spellPut("zuo", -10254);

　　}

　　/**

　　* 获得单个汉字的Ascii.

　　* @param cn char

　　* 汉字字符

　　* @return int

　　* 错误返回 0,否则返回ascii

　　public static int getCnAscii(char cn)

　　{

　　byte[] bytes = (String.valueOf(cn)).getBytes();

　　if(bytes == null || bytes.length > 2 || bytes.length <= 0){ //错误

　　return 0;

　　}

　　if(bytes.length == 1){ //英文字符

　　return bytes[0];

　　}

　　if(bytes.length == 2){ //中文字符

　　int hightByte = 256 + bytes[0];

　　int lowByte = 256 + bytes[1];

　　int ascii = (256 * hightByte + lowByte) - 256 * 256;

　　//System.out.println("ASCII=" + ascii);

　　return ascii;

　　}

　　return 0; //错误

　　}

　　/**

　　* 根据ASCII码到SpellMap中查找对应的拼音

　　* @param ascii int

　　* 字符对应的ASCII

　　* @return String

　　* 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,

　　否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.

　　public static String getSpellByAscii(int ascii)

　　{

　　if(ascii > 0 && ascii < 160){ //单字符

　　return String.valueOf((char)ascii);

　　}

　　if(ascii < -20319 || ascii > -10247){ //不知道的字符

　　return null;

　　}

　　Set keySet = spellMap.keySet();

　　Iterator it = keySet.iterator();

　　String spell0 = null;;

　　String spell = null;

　　int asciiRang0 = -20319;

　　int asciiRang;

　　while(it.hasNext()){

　　spell = (String)it.next();

　　Object valObj = spellMap.get(spell);

　　if(valObj instanceof Integer){

　　asciiRang = ((Integer)valObj).intValue();

　　if(ascii >= asciiRang0 && ascii < asciiRang){ //区间找到

　　return(spell0 == null) ? spell : spell0;

　　}

　　else{

　　spell0 = spell;

　　asciiRang0 = asciiRang;

　　}

　　return null;

　　}
/**

　　* 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换

　　* @param cnStr String

　　* 字符串

　　* @return String

　　* 转换成全拼后的字符串

　　public static String getFullSpell(String cnStr)

　　{

　　if(null == cnStr || "".equals(cnStr.trim())){

　　return cnStr;

　　}

　　char[] chars = cnStr.toCharArray();

　　StringBuffer retuBuf = new StringBuffer();

　　for(int i = 0,Len = chars.length;i < Len;i++){

　　int ascii = getCnAscii(chars);

　　if(ascii == 0){ //取ascii时出错

　　retuBuf.append(chars);

　　}

　　else{

　　String spell = getSpellByAscii(ascii);

　　if(spell == null){

　　retuBuf.append(chars);

　　}

　　else{

　　retuBuf.append(spell);

　　} // end of if spell == null

　　} // end of if ascii <= -20400

　　} // end of for

　　return retuBuf.toString();

　　}

　　public static String getFirstSpell(String cnStr)

　　{

　　return null;

　　}

　　public static void main(String[] args)

　　{

　　String str = null;

　　str = "谢海101普降喜雨";

　　System.out.println("Spell=" + CnToSpell.getFullSpell(str));

　　str = "张牙舞爪》。，";

　　System.out.println("Spell=" + CnToSpell.getFullSpell(str));

　　str = "□□□□，可耻下场。";

　　System.out.println("Spell=" + CnToSpell.getFullSpell(str));

　　str = "猪油，猪八戒。";

　　System.out.println("Spell=" + CnToSpell.getFullSpell(str));

　　}

帅子 2010-02-02 17:12 发表评论

如何应用Java的可变参数

帅子 — Wed, 17 Jun 2009 03:18:00 GMT

可变参数

Java 语言在 JDK1.5 中首次推出可变参数， variable arguments ，或简称 varargs 。这一新语言特征给软件开发人员在编写方法重载时提供了方便和灵活性。但可变参数的应用并不像想象的那么简单，使用时有其特殊要求和局限性。

12.7.1 重载的最好例子

读者朋友可能有这样的编程经历：在编写一个方法时，其参数随着程序运行的条件而变化，在编译期间无法确定。具体地讲，例如编写一个打印参加聚会 party 的程序，其中方法 printInvitation() 将根据作为参数的参加人姓名，打印邀请卡。但这个参数的数量事先并不确定。当然可以编写许多重载的方法来解决这个问题，如：

void printInvitation(String name);

void printInvitation(String name1, String name2);

void printInvitation(String name1, String name2, String name3);

...

问题是编写多少个重载的方法才可以解决给所有参加者打印邀请卡？也许需要改变您的程序设计，而使用数组或者链接表了。

应用可变参数可以方便、灵活地解决这类问题。例如：

void printInvitation(String...names) {

for (String name : names) {

makeCard(name); // 调用方法按照姓名打印邀请卡

System.out.println("Recording info: invitation card has been printed for " + name);

}

这里， (String...names) 便是可变参数。它包括从 0 到任意个相同类型的参数。在编译期间，这个可变参数将被转换为字符串数组形式，即：

void printInvitation(String[] names)

如下是调用这个方法的例子：

printInvitation(" 李刚 ", "David Smith");

printInvitation("Greg Wu", "Paul Nguyen", "Liu Wei", " 张新 ") ；

printInvitation(); // 无参数

当在无参数情况下调用这个方法时，将不执行任何这个方法中的代码。

如下是运行结果：

Recording info: invitation card has been printed for 李刚

Recording info: invitation card has been printed for David Smith

Recording info: invitation card has been printed for Greg Wu

Recording info: invitation card has been printed for Paul Nguyen

Recording info: invitation card has been printed for Liu Wei

Recording info: invitation card has been printed for 张新

12.7.2 怎样工作

可变参数也不神秘。实际上， JVM 将根据程序中调用这个方法时提供的参数数量，来装载和运行它。

可变参数的简单语法格式为：

methodName([argumentList], dataType...argumentName);

其中：

argumentList ——普通参数，可选项。

dataType ——数据类型或者类。自动转换成 dataType 代表的数组。

... —— Java 的操作符。表示 0 到多个。必须是 3 个点。

argumentName ——参数名。

注意，可变参数必须在最后。

下面是应用可变参数的更多例子：

public static int sumInts(int...numbers) { // 可变整数数组类型参数

int sum = 0;

for (int num : numbers)

sum +=num;

return sum;

}

再如：

public void totalTax(String name, double rate, double...amount) {
// 普通参数在前、可变参数在后

double total = 0.0,

tax = 0.0;

for (double amount : amounts)

total += amount;

tax = total * rate;

System.out.println("Name: " + name + "\nTotal: " + total + "\ntax: " + tax);

}

可变参数也可应用在构造器中。例如：

public class Supper {

public Supper(char...characters) {

...

}

在子类中，可以覆盖这个构造器，如：

class SubClass extends Supper {

public SubClass(char...characters) {

...

}

但无法在子类中调用超类的这个构造器。

更多信息可变参数可以用在构造器中，并可以覆盖。

12.7.3 可变参数方法重载

可以对具有可变参数的方法重载。如下例子：

void someMethod(int count, double...prices) {

// 语句体

...

}

void someMethod(double...prices) { // 重载

// 语句体

...

}

double someMethod(String...names) { // 重载

// 语句体

...

}

...

对方法someMethod()实行重载。对具有可变参数的方法重载遵循一般方法重载原则。

enum ColorType {

WHITE {String getDescription(){

return "有浅白、暗白、和亮白可选";

}

SILVER {String getDescription() {

return "有银白、银灰、纯银色可选";

}

BLACK {String getDescription() {

return "有深黑和浅黑可选";

}

};

abstract String getDescription();

}

enum PaymentType {

CASH("有10%特别优惠"),

CREDIT("接受所有信用卡"),

LOAN("贷款利息为.56%");

final private String payment;

private PaymentType(String payment) {

this. payment = payment;

}

public String getPayment() {

return payment;

}

另外，在SportCar中，根据用户的选择，加入了对跑车类型、颜色，以及付款方式的处理方法，并且利用可变参数。例如：

class SportCar {

SportCarType type; //创建

ColorType color;

PaymentType payment;

public SportCar (String...choices) { //可变参数

type = null; //初始化

color = null;

payment = null;

processInfo(choices); //调用处理信息方法

}

private void processInfo(String[] choices) {

if (choices.length == 1) { //处理跑车类型

processType(choices[0]);

}

else if (choices.length == 2) { //处理跑车类型和颜色

processType(choices[0]);

processColor(choices[1]);

}

else if (choices.length == 3) { //处理跑车类型、颜色和付款方式

processType(choices[0]);

processColor(choices[1]);

processPayment(choices[2]);

}

private void processType(String type) { //处理类型

if (type.equals("P"))

this.type = SportCarType.PORSCHE;

else if (type.equals("F"))

this.type = SportCarType.FERRARI;

else if(type.equals("J"))

this.type = SportCarType.JAGUAR;

}

...

这个类的驱动程序如下：

public class VarargsApp {

public static void main( String args[] ) {

SportCar yourCar = new SportCar("P"); //创建一个参数的对象

System.out.println("你要的跑车信息：\n" + yourCar + "\n");

SportCar myCar = new SportCar("J", "S"); //创建两个参数的对象

System.out.println("我要的跑车信息：\n" + myCar + "\n");

SportCar herCar = new SportCar("F", "B", "C");//创建三个参数的对象

System.out.println("她要的跑车信息：\n" + herCar + "\n");

}

运行结果如下：

你要的跑车信息：

制造国：德国

价格：$120,000.00

我要的跑车信息：

制造国：英国

价格：$110,000.00

有银白、银灰、纯银色可选

她要的跑车信息：

制造国: 意大利

价格：$150,000.00

有深黑和浅黑可选

有10%特别优惠

帅子 2009-06-17 11:18 发表评论

用JAVA实现文件分隔功能[转]

帅子 — Sat, 13 Jun 2009 07:31:00 GMT

以下是我写的几个用JAVA实现将.txt文件分隔成小文件的程序，供大家参考下
程序一：
/**
* 文件分隔
*/
package com.basic.io;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

/**
* @author Administrator
*
*/
public class FileSeparator {

    /**
     * 按字节分隔
     * @param sourceFileUrl 源文件路径如：c:/a.txt
     * @param targetFileUrl 目标文件路径文件夹(最好在盘符下，我没有创建文件夹)： c:/
     */
    public void separateFileByByte(String sourceFileUrl, String targetFileUrl) {
        File sourceFile = new File(sourceFileUrl);
        String sourceFileName = sourceFile.getName().split(".txt")[0]; //获得源文件名称
        try {
            FileInputStream fis = new FileInputStream(sourceFile); //源文件文件流
            int temp;
            FileOutputStream fos = null; //目标文件文件流
            int size = 0; //记录文件大小
            int countFile = 1; //子文件数目
            File targetFile = null;
            do {

                if (size % 100 == 0) {
                    String targetFileName = targetFileUrl + sourceFileName + countFile + ".txt"; //目标文件名称，以源文件名称加数据命名
                    targetFile = new File(targetFileName);
                    if (fos != null) {
                        fos.flush(); //刷新该流的缓冲
                        fos.close(); //关闭流
                    }
                    fos = new FileOutputStream(targetFile);
                    countFile++;
                }

                temp = fis.read(); //读文件
                size++;
                fos.write(temp); //写文件

            } while (fis.available()>0);    //判断源文件是否还有流，即有没有读完

            fis.close();
            fos.flush();
            fos.close();
            System.out.println("File separate End!" );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 按字符分隔
     * @param sourceFileUrl
     * @param targetFileUrl
     */
    public void separateFileByChar(String sourceFileUrl, String targetFileUrl) {
        File sourceFile = new File(sourceFileUrl);
        String sourceFileName = sourceFile.getName().split(".txt")[0]; //获得源文件名称
        try {
            FileReader fr = new FileReader(sourceFile); //源文件文件流
            System.out.println("encoding:" + fr.getEncoding());
            int temp;
            FileWriter fw = null; //目标文件文件流
            int size = 0; //记录文件大小
            int countFile = 1; //子文件数目
            File targetFile = null;
            do {

                if (size % 100 == 0) {
                    String targetFileName = targetFileUrl + sourceFileName + countFile + ".txt"; //目标文件名称，以源文件名称加数据命名
                    targetFile = new File(targetFileName);
                    if (fw != null) {
                        fw.flush(); //刷新该流的缓冲
                        fw.close();//关闭流
                    }
                    fw = new FileWriter(targetFile);
                    countFile++;
                }

                temp = fr.read();//读文件
                size++;
                fw.write(temp);//写文件

            } while (temp != -1);//判断源文件是否还有流，即有没有读完

            fr.close();
            fw.flush();
            fw.close();
            System.out.println("File separate End!" );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String sourceFileUrl = null;
        String targetFileUrl = null;
        //输入源文件路径
        System.out.println("Source File Url: \t");
        try {
            sourceFileUrl = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //输入目标文件路径
        System.out.println("\nTarget File Url: \t");
        try {
            targetFileUrl = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Source File: " + sourceFileUrl + "\nTarget File: " + targetFileUrl);
        FileSeparator fs = new FileSeparator();
        fs.separateFileByByte(sourceFileUrl, targetFileUrl);
    }

}
程序二：
/**
* 用缓冲流实现文件分隔
*/
package com.basic.io;

import java.io.*;
public class TestBufferStream {
  public static void main(String[] args) {
    try {
      BufferedReader br = new BufferedReader(new FileReader("c:/Java编码规范.txt"));
      BufferedWriter bw = null;
      String s = null; //单行内容
      int countLine = 0; //总行数
      int countFile = 1; //子文件数
      while((s=br.readLine())!=null){
        if (countLine % 50 == 0) {
            if (bw != null) {
                bw.flush();
                bw.close();
            }
            bw = new BufferedWriter(new FileWriter("c:/Java编码规范" + countFile + ".txt"));
            countFile++;
        }
        bw.write(s);
        bw.newLine();
        System.out.println(s);
        countLine++;
      }
      System.out.println("countLine:" + countLine);

      bw.close();
      if(countLine != 0){
          bw.flush();
          bw.close();

      }

    } catch (IOException e) { e.printStackTrace();}
  }
}
程序三：
/**
* 用字符流实现文件分隔　
*/
package com.basic.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
* @author Administrator
*
*/
public class TestFileReader {
    public static final int charSize = 1024;
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            FileReader fr = new FileReader("c:/Java编码规范.txt");
            FileWriter fw = null;
            char[] bfc = new char[charSize];
            int temp; //单个字符
            int countWord = 0; //字符数
            int countFile = 1; //子文件数
            while((temp=fr.read())!=-1){
              if (countWord % charSize == 0) {
                  fw = new FileWriter("c:/Java编码规范" + countFile + ".txt");
                  countFile++;
              }
              bfc[countWord] = (char)temp;

              if (countWord == charSize -1) {
                  fw.write(bfc);
                  fw.flush();
                  fw.close();
                  countWord = 0;
              }    else {
                  countWord++;
              }

            }
            fr.close();
            if (countWord > 0) {
                fw.write(bfc);
                fw.flush();
                fw.close();
            }

          } catch (IOException e) {
              e.printStackTrace();
          }
    }

}

帅子 2009-06-13 15:31 发表评论

Java Web应用程序增加入侵检测功能

帅子 — Wed, 01 Apr 2009 02:36:00 GMT

一、简介

在Java Web应用程中，特别是网站开发中，我们有时候需要为应用程序增加一个入侵检测程序来防止恶意刷新的功能，防止非法用户不断的往Web应用中重复发送数据。当然，入侵检测可以用很多方法实现，包括软件、硬件防火墙，入侵检测的策略也很多。在这里我们主要介绍的是Java Web应用程序中通过软件的方式实现简单的入侵检测及防御。

该方法的实现原理很简单，就是用户访问Web系统时记录每个用户的信息，然后进行对照，并根据设定的策略（比如：1秒钟刷新页面10次）判断用户是否属于恶意刷新。

我们的入侵检测程序应该放到所有Java Web程序的执行前，也即若发现用户是恶意刷新就不再继续执行Java Web中的其它部分内容，否则就会失去了意义。这就需要以插件的方式把入侵检测的程序置入Java Web应用中，使得每次用户访问Java Web，都先要到这个入侵检测程序中报一次到，符合规则才能放行。

Java Web应用大致分为两种，一种纯JSP（+Java Bean）方式，一种是基于框架（如Struts、EasyJWeb等）的。第一种方式的Java Web可以通过Java Servlet中的Filter接口实现，也即实现一个Filter接口，在其doFilter方法中插入入侵检测程序，然后再web.xml中作简单的配置即可。在基于框架的Web应用中，由于所有应用都有一个入口，因此可以把入侵检测的程序直接插入框架入口引擎中，使框架本身支持入侵检测功能。当然，也可以通过实现Filter接口来实现。

在Web框架中，已经置入了简单入侵检测的程序，因此，这里我们以Web框架为例，介绍具体的实现方法及源码，完整的代码可以在Web源码中找到。

在基于EasyJWeb的Java Web应用中，默认情况下你只要连续刷新页面次数过多，即会弹出如下的错误：

Web框架友情提示!:-):

您对页面的刷新太快,请等待60秒后再刷新页面!

二、用户访问信息记录UserConnect.java类

这个类是一个简单的Java Bean，主要代表用户的信息，包括用户名、IP、第一次访问时间、最后登录时间、登录次数、用户状态等。全部

代码如下：

package com.web;

import java.util.Date;
public class UserConnect {
private String userName;
private String ip;
private Date firstFailureTime;
private Date lastLoginTime;
private int failureTimes;//用户登录失败次数
private int status=0;//用户状态0表示正常,-1表示锁定
public int getFailureTimes() {
return failureTimes;
}
public void setFailureTimes(int failureTimes) {
this.failureTimes = failureTimes;
}
public Date getFirstFailureTime() {
return firstFailureTime;
}

public void setFirstFailureTime(Date firstFailureTime) {
this.firstFailureTime = firstFailureTime;
}

public String getIp() {
return ip;
}

public void setIp(String ip) {
this.ip = ip;
}

public Date getLastLoginTime() {
return lastLoginTime;
}

public void setLastLoginTime(Date lastLoginTime) {
this.lastLoginTime = lastLoginTime;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public int getStatus() {
return status;
}

public void setStatus(int status) {
this.status = status;
}

}
三、监控线程UserConnectManage.java类

这是入侵检测的核心部分，主要实现具体的入侵检测、记录、判断用户信息、在线用户的刷新等功能，并提供其它应用程序使用本组件的调用接口。

package com.web;

import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
/**
*
*

Title:用户入侵检测信息

Description:用于判断用户刷新情况检查，默认为10秒钟之内连续连接10次为超时

*/
public class UserConnectManage {
private static final Logger logger = (Logger) Logger.getLogger(UserConnectManage.class.getName());
private static int maxFailureTimes=10;//最大登录失败次数
private static long maxFailureInterval=10000;//毫秒，达到最大登录次数且在这个时间范围内
private static long waitInterval=60000;//失败后接受连接的等待时间，默认1分钟
private static int maxOnlineUser=200;//同时在线的最大数
private final static Map users=new HashMap();//使用ip+userName为key存放用户登录信息UserLoginAuth
private static Thread checkThread=null;
private static class CheckTimeOut implements Runnable{
private Thread parentThread;
public CheckTimeOut(Thread parentThread)
{
this.parentThread=parentThread;
synchronized(this){
if(checkThread==null){
checkThread= new Thread(this);
//System.out.println( "创建一个新线程！");
checkThread.start();
}
}
}
public void run() {
while(true)
{
if(parentThread.isAlive()){
try{
Thread.sleep(2000);
int i=0;
if(users.size() >maxOnlineUser)//当达到最大用户数时清除
{
synchronized(users){//执行删除操作
Iterator it=users.keySet().iterator();
Set set=new HashSet();
Date now=new Date();
while(it.hasNext())
{
Object key=it.next();
UserConnect user=(UserConnect)users.get(key);
if(now.getTime()-user.getFirstFailureTime().getTime() >maxFailureInterval)//删除超时的用户
{
set.add(key);
logger.info( "删除了一个超时的连接"+i);
i++;
}
}
if(i <5)//如果删除少于5个，则强行删除1/2在线记录，牺牲性能的情况下保证内存
{
int num=maxOnlineUser/2;
it=users.keySet().iterator();
while(it.hasNext() && i
{
set.add(it.next());
logger.info( "删除了一个多余的连接"+i);
i++;
}
}
users.keySet().removeAll(set);
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
else
{
break;
}
}
logger.info( "监视程序运行结束！");
}
}
//通过checkLoginValidate判断是否合法的登录连接，如果合法则继续，非法则执行
public static boolean checkLoginValidate(String ip,String userName)//只检查认证失败次数
{
boolean ret=true;
Date now=new Date();
String key=ip+ ":"+userName;
UserConnect auth=(UserConnect)users.get(key);
if(auth==null)//把用户当前的访问信息加入到users容器中
{
auth=new UserConnect();
auth.setIp(ip);
auth.setUserName(userName);
auth.setFailureTimes(0);
auth.setFirstFailureTime(now);
users.put(key,auth);
if(checkThread==null)new CheckTimeOut(Thread.currentThread());
}
else
{
if(auth.getFailureTimes() >maxFailureTimes)
{
//如果在限定的时间间隔内，则返回拒绝用户连接的信息
if((now.getTime()-auth.getFirstFailureTime().getTime())
{
ret=false;
auth.setStatus(-1);
}
else if(auth.getStatus()==-1 && (now.getTime()-auth.getFirstFailureTime().getTime()<(maxFailureInterval+waitInterval)))//重置计数器
{
ret=false;
}
else
{
auth.setFailureTimes(0);
auth.setFirstFailureTime(now);
auth.setStatus(0);
}
}
//登录次数加1
auth.setFailureTimes(auth.getFailureTimes()+1);
}
//System.out.println(key+ ":"+auth.getFailureTimes()+":"+ret+":"+(now.getTime()-auth.getFirstFailureTime().getTime()));
return ret;
}

public static void reset(String ip,String userName)//重置用户信息
{
Date now=new Date();
String key=ip+ ":"+userName;
UserConnect auth=(UserConnect)users.get(key);
if(auth==null)//把用户当前的访问信息加入到users容器中
{
auth=new UserConnect();
auth.setIp(ip);
auth.setUserName(userName);
auth.setFailureTimes(0);
auth.setFirstFailureTime(now);
users.put(key,auth);
}
else
{
auth.setFailureTimes(0);
auth.setFirstFailureTime(now);
}
}
public static void remove(String ip,String userName)//删除用户在容器中的记录
{
String key=ip+ ":"+userName;
users.remove(key);
}
public static void clear()//清空容器中内容
{
if(!users.isEmpty())users.clear();
}
public static long getMaxFailureInterval() {
return maxFailureInterval;
}

public static void setMaxFailureInterval(long maxFailureInterval) {
UserConnectManage.maxFailureInterval = maxFailureInterval;
}

public static int getMaxFailureTimes() {
return maxFailureTimes;
}

public static void setMaxFailureTimes(int maxFailureTimes) {
UserConnectManage.maxFailureTimes = maxFailureTimes;
}

public static int getMaxOnlineUser() {
return maxOnlineUser;
}

public static void setMaxOnlineUser(int maxOnlineUser) {
UserConnectManage.maxOnlineUser = maxOnlineUser;
}

public static long getWaitInterval() {
return waitInterval;
}

public static void setWaitInterval(long waitInterval) {
UserConnectManage.waitInterval = waitInterval;
}
四、调用接口

在需要进入侵检测判断的地方，直接使用UserConnectManage类中的checkLoginValidate方法即可。如Web的核心 Servletcom.web.ActionServlet 中调用UserConnectManage的代码：
if(!UserConnectManage.checkLoginValidate(request.getRemoteAddr(),"guest"))
{
info(request,response,new Exception("您对页面的刷新太快,请等待"+UserConnectManage.getWaitInterval()/1000+"秒后再刷新页面！"));
return;
}
五、总结

当然，这里提供的方法只是一个简单的实现示例，由于上面的用户信息是直接保存在内存中，若并发用户很大的时候的代码的占用，可以考虑引入数据库来记录用户的访问信息，当然相应的执行效率肯定用降低。上面介绍的实现中，入侵检测判断的策略也只有用户访问次数及时间间隔两个元素，您还可以根据你的实现情况增加其它的检测元素

帅子 2009-04-01 10:36 发表评论

如何使用log4j记录日志

帅子 — Tue, 31 Mar 2009 08:24:00 GMT

如何使用log4j记录日志
第一步：在工程中加入log4j所使用的jar文件
1:项目 > 属性：弹出项目的属性窗口
2:Java构建路径>?库>?添加外部JAR：弹出选择JAR的窗口
3:通过选择JAR的窗口，找到log4j-1.2.x.jar，并确认
4:回到项目的属性窗口，点击确定
第二步：创建log4j.properties文件
1:选择欲使用log4j的项目>?右键点击src >?新建>?其他：弹出选择向导窗口
2:在选择向导窗口中，选择常规?> 文件?> 下一步：弹出新建文件的窗口
3:在新建文件窗口中，输入文件名log4j.properties ? 完成：创建工作结束
第三步：使用log4j记录日志信息

import org.apache.log4j.Logger;

public class Log4j {
    public static void main(String[] args) {
   Logger logger = Logger.getLogger(AccpTeacherLog4j.class.getName());//获取日志记录器，这个记录器将负责控制日志信息
  try {
  logger.debug("设置教员的编号。");//使用Logger对象的debug、info方法输出日志信息
  } catch (IllegalArgumentException ex) {
  logger.info(ex.getMessage());//使用Logger对象的debug、info方法输出日志信息
   }
   }
}

第四步：编写log4j.properties文件，配置日志信息

### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender//日志信息将写到控制台
log4j.appender.stdout.Target=System.out//信息打印到System.out上
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %m%n//指定输出格式：显示日期和log信息

### 把日志信息输出到文件：accp.log ###
log4j.appender.file=org.apache.log4j.FileAppender//日志信息将写到文件中
log4j.appender.file.File=accp.log//指定日志输出的文件名
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %m%n//指定输出格式：显示日期，日志发生位置和日志信息

### 设置优先级别、以及输出源 ###
log4j.rootLogger=debug, stdout, file//设置优先级别为debug、
日志被输出到多个输出源

注：优先级从高到低分别是ERROR、WARN、INFO、DEBUG
在此处，如果优先级别设为info，那么使用debug方法打印的日志信息将不被输出

帅子 2009-03-31 16:24 发表评论

Tomcat上创建和发布Web应用

帅子 — Tue, 31 Mar 2009 08:15:00 GMT

本文详细介绍TOMCAT服务器上的应用，介绍如何在Tomcat上创建和发布Web应用。这里首先讲解Tomcat的目录结构以及Web应用的目录结构，接着介绍如何将HTML、Servlet、JSP和Tag Library部署到Web应用中，然后介绍把整个Web应用打包并发布的方法，最后介绍如何在Tomcat上配置虚拟主机。

本章侧重于讨论Web应用的结构和发布方法，所以没有对本章的Servlet和JSP的例子进行详细解释，关于Servlet和JSP的技术可以分别参考其它章节的内容。

2.1 Tomcat的目录结构

在Tomcat上发布Web应用之前，首先要了解Tomcat的目录结构。Tomcat的目录结构参见表2-1，这些目录都是的子目录。

表2-1 Tomcat的目录结构

目录	描述
/bin	存放在Windows平台以及Linux平台上启动和关闭Tomcat的脚本文件
/conf	存放Tomcat服务器的各种配置文件，其中最重要的配置文件是server.xml
/server	包含3个子目录: classes、lib和webapps
/server/lib	存放Tomcat服务器所需的各种JAR文件
/server/webapps	存放Tomcat自带的两个Web应用: admin应用和manager应用
/common/lib	存放Tomcat服务器以及所有 Web应用都可以访问的JAR文件
/shared/lib	存放所有Web应用都可以访问的JAR文件
/logs	存放Tomcat的日志文件
/webapps	当发布Web应用时，默认情况下把Web应用文件放于此目录下
/work	Tomcat把由JSP生成的 Servlet放于此目录下

从表2-1可以看出，在/server/lib目录、/common/lib和/shared/lib目录下都可以放JAR文件，它们的区别在于：

在/server/lib目录下的JAR文件只可被Tomcat服务器访问

在/shared/lib目录下的JAR文件可以被所有的Web应用访问，但不能被Tomcat服务器访问

在/common/lib目录下的JAR文件可以被Tomcat服务器和所有Web应用访问

此外，对于下面将要介绍的Java Web应用，在它的WEB-INF目录下，也可以建立lib子目录，在lib子目录下可以放各种JAR文件，这些JAR文件只能被当前Web应用访问。

在以上提到的lib目录下都只接受JAR文件，如果类压缩文件为ZIP文件，应该将它展开，重新打包为JAR文件再拷贝到lib目录中。如果直接将ZIP文件拷贝到lib目录，则会发现Tomcat服务器仍然找不到相关的类。打包命令参见2.2.8节。

2.2 创建和发布Web应用

Java Web应用由一组静态HTML页、Servlet、JSP和其他相关的class组成。每种组件在Web应用中都有固定的存放目录。Web应用的配置信息存放在web.xml文件中。在发布某些组件（如Servlet）时，必须在web.xml文件中添加相应的配置信息。

2.2.1 Web应用的目录结构

Web应用具有固定的目录结构，这里假定开发一个名为helloapp的Web应用。首先，应该在/webapps目录下创建这个Web应用的目录结构，参见表2-2。

表2-2 Web应用的目录结构

目录	描述
/helloapp	Web应用的根目录，所有的JSP和HTML文件都存放于此目录下
/helloapp/WEB-INF	存放Web应用的发布描述文件web.xml
/helloapp/WEB-INF/classes	存放各种class文件， Servlet类文件也放于此目录下
/helloapp/WEB-INF/lib	存放Web应用所需的各种JAR文件

例如，在这个目录下，可以存放JDBC驱动程序的JAR文件

从表2-2中，我们看到在classes以及lib子目录下，都可以存放Java类文件。在运行过程中，Tomcat的类装载器先装载classes目录下的类，再装载lib目录下的类。因此，如果两个目录下存在同名的类，classes目录下的类具有优先权。

本章介绍的helloapp应用的目录结构如图2-1所示，helloapp应用在Windows资源管理器中的展开如图2-2所示。

在helloapp应用中创建了如下组件：

HTML组件：index.htm

JSP组件：login.jsp和hello.jsp

Servlet组件：DispatcherServlet

这些组件之间的链接关系为：

index.htm→login.jsp→DispatcherServlet→hello.jsp

2.2.2 web.xml文件

Java Web应用通过一个基于XML的发布描述符文件来配置其发布信息，这个文件名为web.xml，它存放于WEB-INF子目录下。在附录B中将详细介绍web.xml的配置方法，在附录C中将介绍XML的基本知识。在web.xml文件中可包含如下配置信息：

Servlet的定义

Servlet的初始化参数

Servlet以及JSP的映射

安全域配置参数

welcome文件清单

资源引用

环境变量的定义

现在，创建一个默认的web.xml文件，并把这个文件放到WEB-INF目录中。

以上web.xml文件的第一行指定了XML的版本和字符编码，第二行DOCTYPE指定文档类型，接下来声明了一个元素，所有关于Web应用的配置元素都将加入到这个元素中。

2.2.3 在server.xml中加入元素

元素是/conf/server.xml中使用最频繁的元素，它代表了运行在上的单个Web应用。一个中可以有多个元素。每个Web应用必须有惟一的URL路径，这个URL路径在元素的path属性中设定。例如，在名为"localhost"的元素中加入如下元素：



…………

Context元素的各个属性的说明参见表2-3。

表2-3 Context元素的属性

属性	描述
path	指定访问该Web应用的URL入口
docBase	指定Web应用的文件路径，可以给定绝对路径，也可以给定相对于Host的appBase属性的相对路径（关于Host的appBase属性参见2.3节）。如果Web应用采用开放目录结构，则指定Web应用的根目录；如果Web应用是个WAR文件，则指定WAR文件的路径
reloadable	如果这个属性设为true， Tomcat服务器在运行状态下会监视在WEB-INF/classes 和WEB-INF/lib目录下class文件的改动。如果监测到有class文件被更新，服务器会自动重新加载Web应用

在开发阶段，将reloadable属性设为true，有助于调试Servlet和其他的class文件。但是由于这一功能会加重服务器的运行负荷，因此建议在Web应用的产品发布阶段，将这个属性设为false。

帅子 2009-03-31 16:15 发表评论

Eclipse快捷键指南

帅子 — Fri, 06 Feb 2009 00:51:00 GMT

作用域功能快捷键
全局查找并替换 Ctrl+F
文本编辑器查找上一个 Ctrl+Shift+K
文本编辑器查找下一个 Ctrl+K
全局撤销 Ctrl+Z
全局复制 Ctrl+C
全局恢复上一个选择 Alt+Shift+↓
全局剪切 Ctrl+X
全局快速修正 Ctrl1+1
全局内容辅助 Alt+/
全局全部选中 Ctrl+A
全局删除 Delete
全局上下文信息 Alt+？
Alt+Shift+?
Ctrl+Shift+Space
Java编辑器显示工具提示描述 F2
Java编辑器选择封装元素 Alt+Shift+↑
Java编辑器选择上一个元素 Alt+Shift+←
Java编辑器选择下一个元素 Alt+Shift+→
文本编辑器增量查找 Ctrl+J
文本编辑器增量逆向查找 Ctrl+Shift+J
全局粘贴 Ctrl+V
全局重做 Ctrl+Y

查看
作用域功能快捷键
全局放大 Ctrl+=
全局缩小 Ctrl+-

窗口
作用域功能快捷键
全局激活编辑器 F12
全局切换编辑器 Ctrl+Shift+W
全局上一个编辑器 Ctrl+Shift+F6
全局上一个视图 Ctrl+Shift+F7
全局上一个透视图 Ctrl+Shift+F8
全局下一个编辑器 Ctrl+F6
全局下一个视图 Ctrl+F7
全局下一个透视图 Ctrl+F8
文本编辑器显示标尺上下文菜单 Ctrl+W
全局显示视图菜单 Ctrl+F10
全局显示系统菜单 Alt+-

导航
作用域功能快捷键
Java编辑器打开结构 Ctrl+F3
全局打开类型 Ctrl+Shift+T
全局打开类型层次结构 F4
全局打开声明 F3
全局打开外部javadoc Shift+F2
全局打开资源 Ctrl+Shift+R
全局后退历史记录 Alt+←
全局前进历史记录 Alt+→
全局上一个 Ctrl+,
全局下一个 Ctrl+.
Java编辑器显示大纲 Ctrl+O
全局在层次结构中打开类型 Ctrl+Shift+H
全局转至匹配的括号 Ctrl+Shift+P
全局转至上一个编辑位置 Ctrl+Q
Java编辑器转至上一个成员 Ctrl+Shift+↑
Java编辑器转至下一个成员 Ctrl+Shift+↓
文本编辑器转至行 Ctrl+L

搜索
作用域功能快捷键
全局出现在文件中 Ctrl+Shift+U
全局打开搜索对话框 Ctrl+H
全局工作区中的声明 Ctrl+G
全局工作区中的引用 Ctrl+Shift+G

文本编辑
作用域功能快捷键
文本编辑器改写切换 Insert
文本编辑器上滚行 Ctrl+↑
文本编辑器下滚行 Ctrl+↓

文件
作用域功能快捷键
全局保存 Ctrl+X
Ctrl+S
全局打印 Ctrl+P
全局关闭 Ctrl+F4
全局全部保存 Ctrl+Shift+S
全局全部关闭 Ctrl+Shift+F4
全局属性 Alt+Enter
全局新建 Ctrl+N

项目
作用域功能快捷键
全局全部构建 Ctrl+B

源代码
作用域功能快捷键
Java编辑器格式化 Ctrl+Shift+F
Java编辑器取消注释 Ctrl+\
Java编辑器注释 Ctrl+/
Java编辑器添加导入 Ctrl+Shift+M
Java编辑器组织导入 Ctrl+Shift+O
Java编辑器使用try/catch块来包围未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。

运行
作用域功能快捷键
全局单步返回 F7
全局单步跳过 F6
全局单步跳入 F5
全局单步跳入选择 Ctrl+F5
全局调试上次启动 F11
全局继续 F8
全局使用过滤器单步执行 Shift+F5
全局添加/去除断点 Ctrl+Shift+B
全局显示 Ctrl+D
全局运行上次启动 Ctrl+F11
全局运行至行 Ctrl+R
全局执行 Ctrl+U

重构
作用域功能快捷键
全局撤销重构 Alt+Shift+Z
全局抽取方法 Alt+Shift+M
全局抽取局部变量 Alt+Shift+L
全局内联 Alt+Shift+I
全局移动 Alt+Shift+V
全局重命名 Alt+Shift+R
全局重做 Alt+Shift+Y

帅子 2009-02-06 08:51 发表评论

有效编写软件的75条建议(七)

帅子 — Fri, 01 Aug 2008 08:09:00 GMT

61.你们的每个人都了解项目的商业意义么？

      要。这是Vision的意思。别把项目只当成工作。有时候要想着自己是在为中国某某行业的信息化作先驱者，或者时不时的告诉team member，这个项目能够为某某某国家部门每年节省多少多少百万的纳税人的钱，这样就有动力了。平凡的事情也是可以有个崇高的目标的。

      62.产品各部分的界面和操作习惯一致么？

      要这样。要让用户觉得整个程序好像是一个人写出来的那样。

      63.有可以作为宣传亮点的Cool Feature么？

      要。这是增强团队凝聚力、信心的。而且，“一俊遮百丑”，有亮点就可以掩盖一些问题。这样，对于客户来说，会感觉产品从质量角度来说还是acceptable的。或者说，cool feature或者说亮点可以作为质量问题的一个事后弥补措施。

      64.尽可能缩短产品的启动时间要这样。

      软件启动时间（Start-Up time）是客户对性能好坏的第一印象。

      65.不要过于注重内在品质而忽视了第一眼的外在印象。

      程序员容易犯这个错误：太看重性能、稳定性、存储效率，但忽视了外在感受。而高层经理、客户正相反。这两方面要兼顾，协调这些是PM的工作。

      66.你们根据详细产品功能说明书做开发么？

      要这样。要有设计才能开发，这是必须的。设计文档，应该说清楚这个产品会怎么运行，应该采取一些讲故事的方法。设计的时候千万别钻细节，别钻到数据库、代码等具体实现里面去，那些是后面的事情，一步步来不能着急。

      67.开始开发和测试之前每个人都仔细审阅功能设计么？

      要做。Function Spec review是用来统一思想的。而且，review过以后形成了一致意见，将来再也没有人可以说“你看，当初我就是反对这么设计的，现在吃苦头了吧！”

      68.所有人都始终想着The Whole Image么？

      要这样。项目里面每个人虽然都只是在制造一片叶子，但每个人都应该知道自己在制造的那片叶子所在的树是怎么样子的。我反对软件蓝领，反对过分的把软件制造看成流水线、车间。参见第61条。

      69.Dev工作的划分是单纯纵向或横向的么？

      不能单纯的根据功能模块分，或者单纯根据表现层、中间层、数据库层分。我推荐这么做：首先根据功能模块分，然后每个“层”都有一个Owner来Review所有人的设计和代码，保证consistency。

      70.你们的程序员写程序设计说明文档么？

      要。不过我听说微软的程序员1999年以前也不写。所以说，写不写也不是绝对的，偷懒有时候也是可以的。参见第56条。

      71.你在招人面试时让他写一段程序么？

      要的。我最喜欢让人做字符串和链表一类的题目。这种题目有很多循环、判断、指针、递归等，既不偏向过于考算法，也不偏向过于考特定的API。


    72.你们有没有技术交流讲座？

    要的。每一两个礼拜搞一次内部的Tech Talk或者Chalk Talk吧。让组员之间分享技术心得，这笔花钱送到外面去培训划算。

    73.你们的程序员都能专注于一件事情么？

    要让程序员专注一件事。例如说，一个部门有两个项目和10个人，一种方法是让10个人同时参加两个项目，每个项目上每个人都花50%时间；另一种方法是5个人去项目A，5个人去项目B，每个人都100%在某一个项目上。我一定选后面一种。这个道理很多人都懂，但很多领导实践起来就把属下当成可以任意拆分的资源了。

    74.你们的程序员会夸大完成某项工作所需要的时间么？

    会的，这是常见的，尤其会在项目后期夸大做某个change所需要的时间，以次来抵制change。解决的方法是坐下来慢慢磨，磨掉程序员的逆反心理，一起分析，并把估算时间的颗粒度变小。

    75.尽量不要用Virtual Heads最好不要用Virtual Heads。

    Virtual heads意味着resource is not secure，shared resource会降低resource的工作效率，容易增加出错的机会，会让一心二用的人没有太多时间去review spec、review design。一个dedicated的人，要强过两个只能投入50%时间和精力的人。我是吃过亏的：7个part time的tester，发现的Bug和干的活，加起来还不如两个full-time的。参见第73条。73条是针对程序员的，75条是针对Resource Manager的。

帅子 2008-08-01 16:09 发表评论

有效编写软件的75条建议(六)

帅子 — Fri, 01 Aug 2008 08:08:00 GMT

51.你们是否随便抓一些人来做易用性测试？

      要这么做。自己看自己写的程序界面，怎么看都是顺眼的。这叫做审美疲劳——臭的看久了也就不臭了，不方便的永久了也就习惯了。

      52.你对自动测试的期望正确么？

      别期望太高。依我看，除了性能测试以外，还是暂时先忘掉“自动测试”吧，忘掉WinRunner和LoadRunner吧。对于国内的软件测试的现状来说，只能“矫枉必须过正”了。

      53.你们的性能测试是等所有功能都开发完才做的么？

      不能这样。性能测试不能被归到所谓的“系统测试”阶段。早测早改正，早死早升天。

      54.你注意到测试中的杀虫剂效应了么？

      虫子有抗药性，Bug也有。发现的新Bug越来越少是正常的。这时候，最好大家交换一下测试的area，或者用用看其他工具和手法，就又会发现一些新bug了。

      55.你们项目组中有人能说出产品的当前整体质量情况么？

      要有。当老板问起这个产品目前质量如何，Test Lead/Manager应该负责回答。

      56.你们有单元测试么？

      单元测试要有的。不过没有单元测试也不是不可以，我做过没有单元测试的项目，也做成功了——可能是侥幸，可能是大家都是熟手的关系。还是那句话，软件工程是非常实践、非常工程、非常灵活的一套方法，某些方法在某些情况下会比另一些方法好，反之亦然。

      57.你们的程序员是写完代码就扔过墙的么？

      大忌。写好一块程序以后，即便不做单元测试，也应该自己先跑一跑。虽然有了专门的测试人员，做开发的人也不可以一点测试都不做。微软还有Test Release Document的说法，程序太烂的话，测试有权踢回去。

      58.你们的程序中所有的函数都有输入检查么？

      不要。虽然说做输入检查是write secure code的要点，但不要做太多的输入检查，有些内部函数之间的参数传递就不必检查输入了，省点功夫。同样的道理，未必要给所有的函数都写注释。写一部分主要的就够了。

      59.产品有统一的错误处理机制和报错界面么？

      要有。最好能有统一的error message，然后每个error message都带一个error number。

      这样，用户可以自己根据error number到user manual里面去看看错误的具体描述和可能原因，就像SQL Server的错误那样。同样，ASP.NET也要有统一的Exception处理。可以参考有关的Application Block。

      60.你们有统一的代码书写规范么？

      要有。Code Convention很多，搞一份来发给大家就可以了。当然，要是有FxCop这种工具来检查代码就更好了。

帅子 2008-08-01 16:08 发表评论

有效编写软件的75条建议(五)

帅子 — Fri, 01 Aug 2008 08:07:00 GMT

41.通过Email进行所有正式沟通

       Email的好处是免得抵赖。但也要避免矫枉过正，最好的方法是先用电话和当面说，然后Email来确认。

       42.为项目组建立多个Mailing Group

       如果在AD+Exchange里面，就建Distribution List。比如，我会建ABC Project Core Team，ABC Project Dev Team，ABC Project All Testers，ABC Project Extended Team等等。这样发起Email来方便，而且能让该收到email的人都收到、不该收到不被骚扰。

       43.每个人都知道哪里可以找到全部的文档么？

       应该每个人都知道。这叫做知识管理（Knowledge Management）。最方便的就是把文档放在一个集中的File Share，更好的方法是用Sharepoint。

       44.你做决定、做变化时，告诉大家原因了么？

       要告诉大家原因。Empower team member的手段之一是提供足够的information，这是MSF一开篇的几个原则之一。的确如此，tell me why是人之常情，tell me why了才能有understanding。中国人做事喜欢搞限制，限制信息，似乎能够看到某一份文件的人就是有身份的人。大错特错。权威、权力，不在于是不是能access information/data，而在于是不是掌握资源。

       45.Stay agile and expect change要这样。

       需求一定会变的，已经写好的代码一定会被要求修改的。做好心理准备，对change不要抗拒，而是expect change。

      46.你们有没有专职的软件测试人员？

      要有专职测试。如果人手不够，可以peer test，交换了测试。千万别自己测试自己的。

      47.你们的测试有一份总的计划来规定做什么和怎么做么？

      这就是Test Plan。要不要做性能测试？要不要做Usability测试？什么时候开始测试性能？测试通过的标准是什么？用什么手段，自动的还是手动的？这些问题需要用TestPlan来回答。

      48.你是先写Test Case然后再测试的么？

      应该如此。应该先设计再编程、先test case再测试。当然，事情是灵活的。我有时候在做第一遍测试的同时补上test case。至于先test case再开发，我不喜欢，因为不习惯，太麻烦，至于别人推荐，那试试看也无妨。

      49.你是否会为各种输入组合创建测试用例？

      不要，不要搞边界条件组合。当心组合爆炸。有很多test case工具能够自动生成各种边界条件的组合——但要想清楚，你是否有时间去运行那么多test case。

      50.你们的程序员能看到测试用例么？

      要。让Dev看到Test Case吧。我们都是为了同一个目的走到一起来的：提高质量。

帅子 2008-08-01 16:07 发表评论

有效编写软件的75条建议(四)

帅子 — Fri, 01 Aug 2008 08:07:00 GMT

31.你们的项目组做每日编译么？

       当然要做。有三样东西是软件项目/产品开发必备的：1.bug management;2.source control;3.daily build。

       32.你们公司有没有积累一个项目风险列表？

       要。Risk Inventory。否则，下个项目开始的时候，又只能拍脑袋分析Risk了。

       33.设计越简单越好。

       设计时候多一句话，将来可能就带来无穷无尽的烦恼。应该从一开始就勇敢的砍。这叫scope management。

       34.尽量利用现有的产品、技术、代码千万别什么东西都自己Coding。

       BizTalk和Sharepoint就是最好的例子，有这两个作为基础，可以把起点提高很多。或者可以尽量多用现成的Control之类的。或者尽量用XML，而不是自己去Parse一个文本文件；尽量用RegExp，而不是自己从头操作字符串，等等等等。这就是“软件复用”的体现。

       35.你们会隔一段时间就停下来夯实代码么？

       要。最好一个月左右一次。传言去年年初Windows组在Stevb的命令下停过一个月增强安全。Btw，“夯”这个字念“hang”，第一声。

       36.你们的项目组每个人都写Daily Report么？

       要写。五分钟就够了，写10句话左右，告诉自己小组的人今天我干了什么。一则为了沟通，二则鞭策自己（要是游手好闲一天，自己都会不好意思写的）。

       37.你们的项目经理会发出Weekly Report么？

       要。也是为了沟通。内容包括目前进度，可能的风险，质量状况，各种工作的进展等。

       38.你们项目组是否至少每周全体开会一次？

       要。一定要开会。程序员讨厌开会，但每个礼拜开会时间加起来至少应该有4小时。包括team meeting, spec review meeting, bug triage meeting。千万别大家闷头写code。

       39.你们项目组的会议、讨论都有记录么？

       会前发meeting request和agenda，会中有人负责主持和记录，会后有人负责发meeting minutes，这都是effective meeting的要点。而且，每个会议都要形成agreements和action items。

       40.其他部门知道你们项目组在干什么么？

       要发一些Newsflash给整个大组织。Show your team’s value。否则，当你坐在电梯里面，其他部门的人问：“你们在干嘛”，你回答“ABC项目”的时候，别人全然不知，那种感觉不太好。

帅子 2008-08-01 16:07 发表评论

有效编写软件的75条建议(三)

帅子 — Fri, 01 Aug 2008 08:05:00 GMT

21.你们的程序员厌恶修改老的代码么？

       厌恶是正常的。解决方法是组织Code Review，单独留出时间来。XP也是一个方法。

       22.你们项目组有Team Morale Activity么？

       每个月都要搞一次，吃饭、唱歌、Outing、打球、开卡丁车等等，一定要有。不要省这些钱。

       23.你们项目组有自己的Logo么？

       要有自己的Logo。至少应该有自己的Codename。

       24.你们的员工有印有公司Logo的T-Shirt么？

       要有。能增强归属感。当然，T-Shirt要做的好看一些，最好用80支的棉来做。别没穿几次就破破烂烂的。

       25.总经理至少每月参加次项目组会议要的。

       要让team member觉得高层关注这个项目。

       26.你们是给每个Dev开一个分支么？

       反对。Branch的管理以及Merge的工作量太大，而且容易出错。

       27.有人长期不Check-In代码么？

       不可以。对大部分项目来说，最多两三天就应该Check-In。

       28.在Check-In代码时都填写注释了么？

       要写的，至少一两句话，比如“解决了Bug No.225”。如果往高处拔，这也算做“配置审计”的一部分。

       29.有没有设定每天Check-In的最后期限？

       要的，要明确Check-In Deadline。否则会Build Break。

       30.你们能把所有源码一下子编译成安装文件吗？

要的。这是每日编译（Daily Build）的基础。而且必须要能够做成自动的。

帅子 2008-08-01 16:05 发表评论

有效编写软件的75条建议(二)

帅子 — Fri, 01 Aug 2008 08:05:00 GMT

11.你们的进度表是否反映最新开发进展情况？

       应该反映。但是，应该用Baseline的方法来管理进度表：维护一份稳定的Schedule，再维护一份最新更改。Baseline的方法也应该用于其它的Spec。Baseline是变更管理里面的一个重要手段。

       12.你们的工作量是先由每个人自己估算的么？

       应该让每个人自己估算。要从下而上估算工作量，而不是从上往下分派。除非有其他原因，比如政治任务工期固定等。

       13.你们的开发人员从项目一开始就加班么？

       不要这样。不要一开始就搞疲劳战。从项目一开始就加班，只能说明项目进度不合理。当然，一些对日软件外包必须天天加班，那属于剥削的范畴。

       14.你们的项目计划中Buffer Time是加在每个小任务后面的么？

       不要。Buffer Time加在每个小任务后面，很容易轻易的就被消耗掉。Buffer Time要整段的加在一个Milestone或者checkpoint前面。

       15.值得再多花一些时间，从95%做到100%好值得，非常值得。

       尤其当项目后期人困马乏的时候，要坚持。这会给产品带来质的区别。

       16.登记新缺陷时，是否写清了重现步骤？

       要。这属于Dev和Test之间的沟通手段。面对面沟通需要，详细填写Repro Steps也需要。

       17.写新代码前会把已知缺陷解决么？

       要。每个人的缺陷不能超过10个或15个，否则必须先解决老的bug才能继续写新代码。

       18.你们对缺陷的轻重缓急有事先的约定么？

       必须有定义。Severity要分1、2、3，约定好：蓝屏和Data Lost算Sev 1，Function Error算Sev 2，界面上的算Sev 3。但这种约定可以根据产品质量现状适当进行调整。

       19.你们对意见不一的缺陷有三国会议么？

       必须要有。要有一个明确的决策过程。这类似于CCB(Change Control Board)的概念。

       20.所有的缺陷都是由登记的人最后关闭的么？

       Bug应该由Opener关闭。Dev不能私自关闭Bug。

帅子 2008-08-01 16:05 发表评论

有效编写软件的75条建议(-)

帅子 — Fri, 01 Aug 2008 08:04:00 GMT

本文给出了有效编写软件的75条建议，内容包括工具的使用、协调部门人员间配合、编程过程中的注意事项等。供大家参考！

       1.你们的项目组使用源代码管理工具了么？

       应该用。VSS、CVS、PVCS、ClearCase、CCC/Harvest、FireFly都可以。我的选择是VSS。

       2.你们的项目组使用缺陷管理系统了么？

       应该用。ClearQuest太复杂，我的推荐是BugZilla。

       3.你们的测试组还在用Word写测试用例么？

       不要用Word写测试用例（Test Case）。应该用一个专门的系统，可以是Test Manager，也可以是自己开发一个ASP.NET的小网站。主要目的是Track和Browse。

       4.你们的项目组有没有建立一个门户网站？

       要有一个门户网站，用来放Contact Info、Baselined Schedule、News等等。推荐Sharepoint Portal Server 2003来实现，15分钟就搞定。买不起SPS 2003可以用WSS(Windows Sharepoint Service)。

       5.你们的项目组用了你能买到最好的工具么？

       应该用尽量好的工具来工作。比如，应该用VS.NET而不是Notepad来写C#。用Notepad写程序多半只是一种炫耀。但也要考虑到经费，所以说是“你能买到最好的”。

       6.你们的程序员工作在安静的环境里么？

       需要安静环境。这点极端重要，而且要保证每个人的空间大于一定面积。

       7.你们的员工每个人都有一部电话么？

       需要每人一部电话。而且电话最好是带留言功能的。当然，上这么一套带留言电话系统开销不小。不过至少每人一部电话要有，千万别搞得经常有人站起来喊：“某某某电话”。《人件》里面就强烈谴责这种做法。

       8.你们每个人都知道出了问题应该找谁么？

       应该知道。任何一个Feature至少都应该有一个Owner，当然，Owner可以继续Dispatch给其他人。

       9.你遇到过有人说“我以为…”么？

       要消灭“我以为”。Never assume anything。

       10.你们的项目组中所有的人都坐在一起么？

       需要。我反对Virtual Team，也反对Dev在美国、Test在中国这种开发方式。能坐在一起就最好坐在一起，好处多得不得了。

帅子 2008-08-01 16:04 发表评论

排序链树搜索算法在GIS POI关键字搜索中的应用

帅子 — Thu, 31 Jul 2008 04:04:00 GMT

概念阐述

链树及其相关概念

本来，数据结构教科书中，不存在一种叫做“链树”的数据结构，用Goolge也搜索不到。这种数据结构，是为了在GIS系统中进行POI关键字高速搜索，在n叉树的基础上，改进的一种数据结构，为了论述方便，姑且称之为链树。
链树，就是在n叉树的基础上，给每个树节点(包括树根和叶子)，都挂接上一个链表而形成的数据结构。
下图就表示一棵典型的链树

图1

链树的2个显著特点是：
1. 某树节点所挂接的链表元素，为该树节点的所有子孙节点(如果有)所挂接的链表元素之集合(无重复节点)。
2. 链树的根结点，可以是一个虚拟节点，代表系统中所有实体节点的祖先。这样，就不必要形成链树森林了。图1的根结点就是一个虚拟节点，其余节点都为实体节点。

排序链树搜索算法

该算法是指，根据关键字序列，从链树根结点出发，在链树中路由，最终找到一个链树路径和关键字序列最大匹配的树节点，然后取其挂接链表的算法。
以图1所示之排序链树为例，假定每个树节点的关键字即为其上的标签字符，假如我们需要搜索的关键字序列为“ACI”,那么该算法的执行顺序为：
1.从根结点出发，查找关键字为‘A’的树节点。
根节点Root下有2个孩子，分别为‘A’和‘X’，因为排序链树节点的所有孩子都按一定规则排序，所以这一步可以使用二分查找来进行，假定Root有n个孩子，那么这一步所花时间为lgn.
2.在‘A’的所有孩子中查找关键字为‘C’的孩子。
同样用二分查找，假定‘A’有m个孩子，那么这一步所花时间为lgm。
3.在‘C’的所有孩子中查找关键字为‘I’的孩子。
同样使用二分查找，假定‘C’有p个孩子，那么这一步所花时间为lgp
综上，关键字序列为“ACI”的搜索时间为lgn+lgm+lgp。
根据链树的特点，有n>=k>=p，所以搜索长度为3的关键字序列的时间复杂度为O(3lgn)，推而广之，我们得到更一般的排序链树搜索算法复杂度:
假如关键字序列长度为k，系统中总的实体节点个数为n,那么在排序链树搜索算法的时间复杂度为O(klgn)。

关于POI

在GIS系统中，对于地图上的一个具有详细信息的点，我们称之为POI（Point Of Interest）。比如名称为“北京西单图书大厦”的POI,就包含了该地点的一系列详细信息，这些信息通常有:
   1.该POI的名称，这里是“西单图书大厦”
   2.该POI的经纬度
   3.该POI的地址
   4.该POI的类型
   5.该POI的描述信息
   6.该POI的电话号码
   7.该POI的网址
   8.该POI的照片
   9.该POI的音频，视频
   …...
通常，一个城市中，就存在千百万个这样的POI。其数据量是相当的巨大。

关于POI的关键字搜索

在GIS相关应用中，都会提供一种最基本的功能，就是根据用户输入的关键字，搜索到和该关键字相关的一系列POI，按照和用户输入字串匹配度由高到底的顺序，把这些POI呈现给用户。因为用户输入的关键字，可能和该POI的名称相关，也可能和该POI的地址，类型名称，描述信息，网址等字段相关。理论上，只要POI的某个字段，或者某几个字段的组合，和用户输入的关键字有关系，那么，这个POI就应该出现在搜索结果列表的合适位置上。
比如用户输入的关键字为“北大”，那么搜索出来的POI可能有:
  北大荒(名字中包含’北’，‘大’，且这2个字连在一起)
  北京大学(名字中包含’北’，‘大’，这2个关键字被隔开了，称之为跳字)
  北京邮电大学(名字中包含’北’，‘大’，跳字)
  大北窑(名字中包含‘北’,‘大’，但这2个关键字被颠倒了，称之为逆字)
  未名湖(地址中含有‘北‘，‘大’二字)
  ……
当然按照我们一般的思路，北京大学应该排在第一位，因为一般来说，北大指的就是它。所以GIS系统要求在本次搜索中，北京大学应该排在第一位。
为了简化问题，本文只限于对POI的名称这一字段进行关键字搜索。也就是说，只把名称字段和用户输入字串有关联的POI搜索出来。

如何在POI关键字搜索中应用链树搜索算法

如何在POI关键字搜索应用链树呢，我们举例来说。假定某城市中存在5个POI,其名称分别是:
  北京大学
  北京邮电大学
  大北窑
  未名湖
  北大荒
那么我们首先要做的工作就是建立排序链树，然后再依据排序链树，进行关键字搜索。

建立排序链树

建立排序链树的工作分成以下几步来做。
  1.分别给每个POI编号,指定其ID，如下
       北京大学(1)
       北京邮电大学(2)
       大北窑(3)
       未名湖(4)
       北大荒(5)
每个POI的详细信息，可以存在一个二进制文件(raw data)中，然后再建立一个索引文件，该文件包括5个索引条目，每个条目为一个POI在raw data文件中的偏移量(offset)与长度(size),该POI的索引条目序号(index)，即为该POI的ID，这样，根据该POI的ID,查询索引文件，可以得到其在raw data中的offset和size,进而获取其详细信息。
  2.建立一个虚拟节点Root,作为排序链树之根，把所有POI的ID链表挂接在Root上，这些ID按以空字符为关键字进行POI查询的呈现结果为序。

图2

可以看到，如果以空字符进行POI关键字查询，输出结果顺序为
      北大荒
      北京大学
      北京邮电大学
      大北窑
      未名湖
很明显，这是按拼音排序的。
  3.找出该城市所有POI名称中涉及到的字符集合。
在我们的例子中，这个集合包括为:{‘北’，‘大’，‘荒’，‘京’，‘学’，‘邮’，‘电’，‘窑’，‘未’，‘名’，‘湖’},共11个汉字。把该集合中的元素按字符的UNICODE编码大小排序，我们姑且假定排序后的顺序不变。
  4.把字符集合中的每一个字符都作为一个树节点之关键字，并且让该树节点成为Root之子。如下图

图3

接下来，我们要以每个孩子为根，建立一颗子链树，为了论述方便，本文只讲述以‘北’字为树根的这棵子链树，其他子链树，可以依此类推。
  5.对于图3中每个子节点，挂接上一个ID链表，这些ID所代表的POI的名称中，都包含了该树节点所对应的字符。而且这些ID按照以该字符为关键字进行POI查询的呈现结果顺序为序。例如‘北’字形成的链表如下:

图4

之所以挂接链表是5，1，2，3，是因为我们在以‘北’字进行POI关键字查询时，GIS系统要求我们的输出POI的列表顺序必须是:北大荒，北京大学，北京邮电大学，大北窑这个顺序。

  6.对于每一个根节点，构建其子节点列表。构建规则为
   a.子节点所代表字符，能和其父节点所代表字符，出现在同一个POI的名称中。
   b.子节点列表，按其所代表字符的UNICODE大小排序。
比如‘北’字，其子节点列表为:

图5

在这里，我们假定这几个字的UNICODE排序结果如上图所示。
大家可以看到，11个字符中，基本上所有字符都能和‘北’字组合，除了‘未’，‘名’，‘湖’这3个字符和‘北’字本身，当然，如果有个POI叫“北北 ”，那么‘北’字也会成为其本身的子节点。但是有一点是，父子节点的关键字可以相同，但是兄弟节点的关键字绝对不相同，他们是互斥的.
  7.结合父节点和每个子节点，形成每个子节点所挂接的ID链表。构建规则为：
  该ID链表所代表的POI列表，即为用户以链树路径作为关键字，查询出来的POI结果列表。
比如对于根为‘北’字的链树，到这一步的结果为:

图6

大家可以看到，对于路径“北大”，所挂接的ID链表为1，5，2，3，也就是
        北京大学
        北大荒
        北京邮电大学
        大北窑
这个顺序，也就是GIS系统所要求的输出顺序。
  8.按照以上规律，继续为第二层节点添加子节点。形成的高度为3的链树如下图所示

图7

从上图可以看到，颜色为红色的链树节点已经到达叶子，无法再向下伸展了。
  9.依此类推，还可以继续向下扩展链树。最终的链树深度为6,对应着名称最长的POI节点，也就是“北京邮电大学”，由于篇幅所限，就不再给出图示了。
至此，我们的排序链树已经建好了。关于链树的建立，还有几个地方要说明一下:
    a.关于ID链表的排序
ID链表的顺序，需要我们的POI数据处理程序按照一定的规则来实现，除了通用的一些规则外，还有些特定的简称数据要处理，比如“北大”所对应的POI列表，第一条通常应该是“北京大学”，而不是“北大荒”。
    b.关于排序链树的存储
为了加快搜索速度，排序链树森林中的冗余数据很多，所以实现者应该认真考虑文件存储格式，以便节约存储空间。

根据排序链树，按关键字搜索POI

建立了排序链树之后，我们就可以按排序链树搜索算法，来进行POI关键字查询了。例如用户如果输入的关键字为“北大”2字，先从Root根节点出发，根据关键字序列，逐级向下路由，得到查询结果1,5,2,3。然后根据这些POI ID,从raw data文件中检索出详细信息即可。因为采用了排序链树搜索算法，对于长度为k的关键字，在POI总量为n的情况下，POI关键字查询的时间复杂度为:
T = O(klgn)
比一般的时间复杂度为O(kn)的GIS POI关键字搜索算法，搜索速度有了较大的提升。

算法优劣分析

综上分析可知，采用排序链树搜索算法进行POI关键字查询，其优势在于：
    * 搜索时间少，时间复杂度为O(klgn)
    * 可以让用户边输入，边路由，边搜索，实现实时搜索的功能，对于采用ajax效果的Web GIS来说，犹为合适。
    * 此算法对通配符支持友好，比如用户输入的关键字串为“北大*”或者“北?荒”，此算法都能够比较容易的适应。
其主要劣势在于其ID链表的数据冗余度较大，而且建树过程比较复杂，对POI数据处理程序的要求比较高。但是因为这些工作都在Server端完成，在目前多核，巨量内存，集群的server端硬件条件下，应该都不是大问题。

作者信息

Jagie,软件开发爱好者,可以通过chen_cwf@163.com与他联系。本文来自于Jagie的google page:http://chencwf.googlepages.com/linktree

帅子 2008-07-31 12:04 发表评论

JSP使用POI读写Excel文件

帅子 — Tue, 25 Dec 2007 02:43:00 GMT

步骤详解
1、在Tomcat安装目录下的webapps目录下新建POI目录，在该目录中建立WEB-INF、并在WEB-INF中建立lib目录。
2、从http://jakarta.apache.org/poi/ 下载POI组件包，将其解压缩到硬盘，找到其中的poi-2.5.1-final-20040804.jar拷贝到应用程序的WEB-INF/lib目录下。
3、打开记事本软件，编写生成Excel文件的页面writeexcel.jsp，其代码如下：
<%@ page language="java"  contentType ="text/html;charset=gb2312" %>
<%@ page import= "java.util.*,org.apache.poi.hssf.usermodel.HSSFWorkbook,org.apache.poi.hssf.usermodel.HSSFSheet,org.apache.poi.hssf.usermodel.HSSFRow,org.apache.poi.hssf.usermodel.HSSFCell,java.io.* " %>
<%
    HSSFWorkbook wb  =   new  HSSFWorkbook();
    HSSFSheet sheet  =  wb.createSheet( " sheet1 " );
     HSSFRow row  =  sheet.createRow(( short )0);
    HSSFCell cell1  =  row.createCell(( short )0);
    HSSFCell cell2  =  row.createCell(( short )1);
    HSSFCell cell3  =  row.createCell(( short )2);
    cell1.setEncoding(( short )1);
    cell1.setCellType( 1 );
    cell2.setEncoding(( short )1);
    cell2.setCellType( 1 );
    cell3.setEncoding(( short )1);
    cell3.setCellType( 1 );
    cell1.setCellValue( " 测试 " );
    cell2.setCellValue( " 测试2 " );
    cell3.setCellValue( " 测试3 " );
     for  ( int i = 0 ; i < 4 ; i ++ )   {
         row  =  sheet.createRow(( short ) i  + 1 );
        cell1  =  row.createCell(( short )  0 );
        cell2  =  row.createCell(( short )  1 );
        cell3  =  row.createCell(( short )  2 );
        cell1.setEncoding(( short )1);
        cell1.setCellType( 1 );
        cell2.setEncoding(( short )1);
        cell2.setCellType( 1 );
        cell3.setEncoding(( short )1);
        cell3.setCellType( 1 );
        cell1.setCellValue( " ggg " );
        cell2.setCellValue( " 00000 " );
        cell3.setCellValue( " sun " );
    }
    String filename=application.getRealPath("/")+"test.xls";
    FileOutputStream fo=new FileOutputStream(filename);
    wb.write(fo);
    out.println("excel 文件生成，存放在"+filename);

%>
4、按下键盘上的【Ctrl】/【S】键,保存该文件，保存在“webapps\POI”目录下。
5、双击桌面上的IE浏览器图标，然后在浏览器的地址栏中输入http://127.0.0.1:8080/POI/writeexcel.jsp，按键盘上的“回车键
使用POI生成Excel文件
6、到该目录下打开生成的Excel文件
制作要点
在JSP页面中将数据转换成Excel格式是经常使用的一个功能。POI是Apache Jakarta组织的子项目，使用简单方便，功能强大，可以操作Excel、Word等文件。
POI组件包中提供了几个类来方便的操作Excel文档：
HSSFWorkbook类表示Excel文档中的Book；
HSSFSheet类表示Excel文档中的Sheet;
HSSFRow类表示Excel文档中的行；
HSSFCell类表示Excel文档中的单元格。
用POI生成一个新的Excel文件基本步骤如下：
1、创建新的Excel工作簿
HSSFWorkbook workbook = new HSSFWorkbook();
2、创建工作表
HSSFSheet sheet = workbook.createSheet();
3、在索引0的位置创建行（最顶端的行）
HSSFRow row = sheet.createRow((short)0);
4、在索引0的位置创建单元格（左上端）
HSSFCell cell = row.createCell((short) 0);
　　 5、定义单元格类型
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
6、在单元格中输入一些内容
cell.setCellValue("增加值");
7、新建一输出文件流并把相应的Excel 工作簿存盘
FileOutputStream fOut = new FileOutputStream(outputFile);
workbook.write(fOut);
fOut.flush();
程序关键代码解释
生成Excel文件的页面writeexcel.jsp片断代码：
<%
    //创建新的Excel工作簿
    HSSFWorkbook wb  =   new  HSSFWorkbook();
    //创建名称为sheet1的工作表
    HSSFSheet sheet  =  wb.createSheet( " sheet1 " );
    //在索引0的位置创建行
    HSSFRow row  =  sheet.createRow(( short )0);
    //在索引0的位置创建单元格
    HSSFCell cell1  =  row.createCell(( short )0);
    HSSFCell cell2  =  row.createCell(( short )1);
    HSSFCell cell3  =  row.createCell(( short )2);
    //设置每列的属性名
    cell1.setEncoding(( short )1);
    cell1.setCellType( 1 );
    cell2.setEncoding(( short )1);
    cell2.setCellType( 1 );
    cell3.setEncoding(( short )1);
    cell3.setCellType( 1 );
    cell1.setCellValue( " 测试 " );
    cell2.setCellValue( " 测试2 " );
    cell3.setCellValue( " 测试3 " );
    //循环生成每行中单元格中的值
     for  ( int i = 0 ; i < 4 ; i ++ )   {
         row  =  sheet.createRow(( short ) i  + 1 );
        cell1  =  row.createCell(( short )  0 );
        cell2  =  row.createCell(( short )  1 );
        cell3  =  row.createCell(( short )  2 );
        cell1.setEncoding(( short )1);
        cell1.setCellType( 1 );
        cell2.setEncoding(( short )1);
        cell2.setCellType( 1 );
        cell3.setEncoding(( short )1);
        cell3.setCellType( 1 );
        cell1.setCellValue( " ggg " );
        cell2.setCellValue( " 00000 " );
        cell3.setCellValue( " sun " );
    }
    //将生成的Excle表格保存
    String filename=application.getRealPath("/")+"test.xls";
    FileOutputStream fo=new FileOutputStream(filename);
    wb.write(fo);
    out.println("excel 文件生成，存放在"+filename);

%>

帅子 2007-12-25 10:43 发表评论

事务处理

帅子 — Thu, 20 Dec 2007 03:42:00 GMT

事务处理是企业应用需要解决的最主要的问题之一。J2EE通过JTA提供了完整的事务管理能力，包括多个事务性资源的管理能力。但是大部分应用都是运行在单一的事务性资源之上（一个数据库），他们并不需要全局性的事务服务。本地事务服务已然足够(比如JDBC事务管理）。
    本文并不讨论应该采用何种事务处理方式，主要目的是讨论如何更为优雅地设计事务服务。仅以JDBC事务处理为例。涉及到的DAO，Factory,Proxy,Decorator等模式概念，请阅读相关资料。
    也许你听说过，事务处理应该做在service层，也许你也正这样做，但是否知道为什么这样做？为什么不放在DAO层做事务处理。显而易见的原因是业务层接口的每一个方法有时候都是一个业务用例（User Case），它需要调用不同的DAO对象来完成一个业务方法。比如简单地以网上书店购书最后的确定定单为例，业务方法首先是调用BookDAO对象（一般是通过DAO工厂产生），BookDAO判断是否还有库存余量，取得该书的价格信息等，然后调用CustomerDAO从帐户扣除相应的费用以及记录信息，然后是其他服务（通知管理员等）。简化业务流程大概如此:
    注意,我们的例子忽略了连接的处理，只要保证同一个线程内取的是相同的连接即可（可用ThreadLocal实现）：

    首先是业务接口，针对接口，而不是针对类编程：

public interface BookStoreManager{
          public boolean buyBook(String bookId,int quantity)throws SystemException;
          ....其他业务方法
    }

    接下来就是业务接口的实现类??业务对象：

public class BookStoreManagerImpl implements BookStoreManager{
         public boolean buyBook(String bookId)throws SystemException{
              Connection conn=ConnectionManager.getConnection();//获取数据库连接
              boolean b=false;

              try{
                  conn.setAutoCommit(false);  //取消自动提交
                  BookDAO bookDAO=DAOFactory.getBookDAO();
                  CustomerDAO customerDAO=DAOFactory.getCustomerDAO();
                    //尝试从库存中取书
                  if(BookDAO.reduceInventory(conn,bookId,quantity)){
                       BigDecimal price=BookDAO.getPrice(bookId);  //取价格
                       //从客户帐户中扣除price*quantity的费用
                       b=
                       CustomerDAO.reduceAccount(conn,price.multiply(new BigDecimal(quantity));
                       ....
                       其他业务方法，如通知管理员，生成定单等.
                        ...
                       conn.commit();   //提交事务
                       conn.setAutoCommit(true);
                  }
               }catch(SQLException e){
                  conn.rollback();   //出现异常，回滚事务
                  con.setAutoCommit(true);
                  e.printStackTrace();
                  throws new SystemException(e);
               }
               return b;
         }
    }

    然后是业务代表工厂：

  public final class ManagerFactory {
      public static BookStoreManager getBookStoreManager() {
         return new BookStoreManagerImpl();
      }
   }

    这样的设计非常适合于DAO中的简单活动，我们项目中的一个小系统也是采用这样的设计方案，但是它不适合于更大规模的应用。首先，你有没有闻到代码重复的 bad smell？每次都要设置AutoCommit为false,然后提交，出现异常回滚，包装异常抛到上层，写多了不烦才怪，那能不能消除呢？其次，业务代表对象现在知道它内部事务管理的所有的细节，这与我们设计业务代表对象的初衷不符。对于业务代表对象来说，了解一个与事务有关的业务约束是相当恰当的，但是让它负责来实现它们就不太恰当了。再次，你是否想过嵌套业务对象的场景？业务代表对象之间的互相调用，层层嵌套，此时你又如何处理呢？你要知道按我们现在的方式，每个业务方法都处于各自独立的事务上下文当中(Transaction Context），互相调用形成了嵌套事务，此时你又该如何处理？也许办法就是重新写一遍，把不同的业务方法集中成一个巨无霸包装在一个事务上下文中。

    我们有更为优雅的设计来解决这类问题，如果我们把Transaction Context的控制交给一个被业务代表对象、DAO和其他Component所共知的外部对象。当业务代表对象的某个方法需要事务管理时，它提示此外部对象它希望开始一个事务，外部对象获取一个连接并且开始数据库事务。也就是将事务控制从service层抽离，当web层调用service层的某个业务代表对象时，返回的是一个经过Transaction Context外部对象包装（或者说代理）的业务对象。此代理对象将请求发送给原始业务代表对象，但是对其中的业务方法进行事务控制。那么，我们如何实现此效果呢？答案是JDK1.3引进的动态代理技术。动态代理技术只能代理接口，这也是为什么我们需要业务接口BookStoreManager的原因。
    首先，我们引入这个Transaction Context外部对象，它的代码其实很简单，如果不了解动态代理技术的请先阅读其他资料。



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import java.sql.Connection;

import com.strutslet.demo.service.SystemException;

public final class TransactionWrapper {

    /**
     * 装饰原始的业务代表对象，返回一个与业务代表对象有相同接口的代理对象
     */
    public static Object decorate(Object delegate) {
        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
                delegate.getClass().getInterfaces(), new XAWrapperHandler(
                        delegate));
    }

    //动态代理技术
    static final class XAWrapperHandler implements InvocationHandler {
        private final Object delegate;

        XAWrapperHandler(Object delegate) {
           this.delegate = delegate;
        }

        //简单起见，包装业务代表对象所有的业务方法
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            Object result = null;
            Connection con = ConnectionManager.getConnection();
            try {
                //开始一个事务
                con.setAutoCommit(false);
                //调用原始业务对象的业务方法
                result = method.invoke(delegate, args);
                con.commit();   //提交事务
                con.setAutoCommit(true);
            } catch (Throwable t) {
                //回滚
                con.rollback();
                con.setAutoCommit(true);
                throw new SystemException(t);
            }

            return result;
        }
    }
}

    正如我们所见，此对象只不过把业务对象需要事务控制的业务方法中的事务控制部分抽取出来而已。请注意，业务代表对象内部调用自身的方法将不会开始新的事务，因为这些调用不会传给代理对象。如此，我们去除了代表重复的味道。此时，我们的业务代表对象修改成：

public class BookStoreManagerImpl implements BookStoreManager {
    public boolean buyBook(String bookId)throws SystemException{
          Connection conn=ConnectionManager.getConnection();// 获取数据库连接
          boolean b=false;
          try{
              BookDAO bookDAO=DAOFactory.getBookDAO();
              CustomerDAO customerDAO=DAOFactory.getCustomerDAO();
              // 尝试从库存中取书
              if(BookDAO.reduceInventory(conn,bookId,quantity)){
                  BigDecimal price=BookDAO.getPrice(bookId);  // 取价格
                  // 从客户帐户中扣除price*quantity的费用
                  b=
                  CustomerDAO.reduceAccount(conn,price.multiply(new BigDecimal(quantity));
                  ....
                  其他业务方法，如通知管理员，生成定单等.
                  ...
              }
          }catch(SQLException e){
             throws new SystemException(e);
          }
          return b;
    }
    ....
}

    可以看到，此时的业务代表对象专注于实现业务逻辑，它不再关心事务控制细节，把它们全部委托给了外部对象。业务代表工厂也修改一下，让它返回两种类型的业务代表对象：

public final class ManagerFactory {
      //返回一个被包装的对象，有事务控制能力
      public static BookStoreManager getBookStoreManagerTrans() {
          return (BookStoreManager) TransactionWrapper
                  .decorate(new BookStoreManagerImpl());
      }
      //原始版本
      public static BookStoreManager getBookStoreManager() {
         return new BookStoreManagerImpl();
      }
      ......
   }

    我们在业务代表工厂上提供了两种不同的对象生成方法：一个用于创建被包装的对象，它会为每次方法调用创建一个新的事务；另外一个用于创建未被包装的版本，它用于加入到已有的事务(比如其他业务代表对象的业务方法)，解决了嵌套业务代表对象的问题。
   我们的设计还不够优雅，比如我们默认所有的业务代表对象的方法调用都将被包装在一个Transaction Context。可事实是很多方法也许并不需要与数据库打交道，如果我们能配置哪些方法需要事务声明，哪些不需要事务管理就更完美了。解决办法也很简单，一个XML配置文件来配置这些，调用时判断即可。说到这里，了解spring的大概都会意识到这不正是声明式事务控制吗？正是如此，事务控制就是AOP的一种服务，spring的声明式事务管理是通过AOP实现的。AOP的实现方式包括：动态代理技术，字节码生成技术（如CGLIB库），java代码生成（早期EJB采用），修改类装载器以及源代码级别的代码混合织入（aspectj)等。我们这里就是利用了动态代理技术，只能对接口代理；对类的动态代理可以使用cglib库。

帅子 2007-12-20 11:42 发表评论

提高byte的效率

帅子 — Thu, 20 Dec 2007 03:40:00 GMT

在网络编程中,我们经常要组建自己的网络协议,通常我们把数据按照协议组成byte数组,通过byte数组实现客户端与服务器端的通信,我们可能通过两种方法来组这个byte数组:
1、是通过ByteArrayOutputStream：
ByteArrayOutputStream baos=new ByteArrayOutputStream();
baos.write(data.getBytes());
byte [] ret = baos.toByteArray();
2、是通过ByteBuffer：
在使用ByteBuffer时，我们要使用一个小技巧：因为我们发送的数据长度是不固定的，所以我们不能给ByteBuffer分配固定的容量，如果分配固定的容易，一方面可能造成内存的浪费，另外一方面有可能我们写的数据会超出ByteBuffer的容量。所以我们在申请ByteBuffer空间时，先计算其数据长度：
     如果是byte,short,int,long等类型的数据我们都好计算；
    如果是String的话,我们先获取其getBytes()，然后计算其长度。
例子:

                byte [] bs=null;
                byte len = 0;
                try {
                        bs="直播员".getBytes("GBK");
                        len = (byte) bs.length;
                } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                        return result;
                }
                short datalen=(short) (2+4+4+1+bs.length+4+4+4+1+1);//后续数据长度
                ByteBuffer w_buff = ByteBuffer.allocate(datalen+2);//申请ByteBuffer
                //接下来往ByteBuffer填充数据
                w_buff.putShort(Short.reverseBytes(datalen));
                short c=0X0416;
                w_buff.putShort(Short.reverseBytes(c));//登录命令号
                w_buff.putInt(Integer.reverseBytes(111));
                w_buff.putInt(Integer.reverseBytes(2222));

                w_buff.put(len);//昵称的长度
                w_buff.put(bs);//昵称
                w_buff.putInt(Integer.reverseBytes(1));//等级
                w_buff.putInt(Integer.reverseBytes(1));//用户权限
                w_buff.putInt(Integer.reverseBytes(1));//用户头像
                byte sex=0;
                w_buff.put(sex);//用户性别
                byte age=20;
                w_buff.put(age);//用户年龄
                byte [] ret=w_buff.array();

我个人比较喜欢用第二种方法，因为它的效率比第一种要高出一到两倍呢。
而且第二种方法可以不用自己去把short,int,long等类型的数据转换成byte数组（这可是以麻烦的过程呀）。

帅子 2007-12-20 11:40 发表评论

全面解析JDBC <三>

帅子 — Wed, 21 Nov 2007 10:23:00 GMT

2. 数据库表结构

　　本实例中主要出现了三个数据库表，表名和字段分别如下所示：

　　计划采购表：jhcg_table

字段名称中文名称类型长度
Goods_no 物品编号 vchar 10
Goods_name 物品名称 Vchar 50
Amount 采购数量 Int
Price 采购单价 float
Gold 币种 Vchar 15
Units 单位 Vchar 10
Date 时间 Date
Remark 备注 vchar 100

　　库存统计表：kctj_table

字段名称中文名称类型长度
Goods_no 物品编号 Vchar 10
Goods_name 物品名称 Vchar 50
amount 库存数量 Int
Date 时间 Date

remark 备注 Vchar 100

　　实际采购表：sjcg_table

字段名称中文名称类型长度
Goods_no 物品编号 Vchar 10
Goods_name  物品名称  Vchar  50
Amount 采购数量 Int
Price  Price 采购单价  Float
Gold 币种 Vchar 15
Units 采购单位 Vchar 10
Date 时间 Date
Remark 备注 vchar 100

　　其中业务逻辑非常简单，即根据计划采购表和库存统计表生成实际采购表。同时，对各表完成数据库的增、删、改、查等通用操作。

　　3. JSP设计

　　① 插入操作

　　完成对数据库表的记录插入功能，其中计划采购表的插入主页面（insert_jhcg.htm）为：

图1 计划采购表插入主页面

　　insert_jhcg.htm将用户输入传送给demo_insert_jhcg.jsp，完成插入操作。改jsp文件的功能代码为：

＜html＞
＜body＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--execute sql statement--＞
＜%
String insGoodno = request.getParameter（"ed_jhcg_no"）；
String insGoodname = request.getParameter（"ed_jhcg_name"）；
int insAmount = （Integer.valueOf（request.getParameter（"ed_jhcg_amount"）））.intValue（）；
float insPrice = （Float.valueOf（request.getParameter（"ed_jhcg_price"）））.floatValue（）；
String insGold = request.getParameter（"ed_jhcg_gold"）；
String insUnit = request.getParameter（"ed_jhcg_unit"）；
String insRemark = request.getParameter（"ed_jhcg_remark"）；
String sqlStatement = "insert into jhcg_table（good_no，good_name，amount，
price，gold，unit，remark） values（"+"'"+insGoodno+"'"+"，"+"'"+insGoodname+"'"+"，
"+insAmount+"，"+insPrice+"，"+"'"+insGold+"'"+"，"+"'"+insUnit+"'"+"，"+"'"+
insRemark+"'"+"）"；
try{
DBBean.query（sqlStatement）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞
＜a href="demo_main.htm"＞Records inserted...Click here to return＜/a＞＜/p＞
＜/body＞
＜/html＞

　　② 查询操作

　　该查询主页面主要提供对三个数据库表的条件查询功能，如下图所示：

图2 查询主页面

　　query.htm将用户选择查询的数据库表和查询条件发送给demo_query.jsp，由jsp文件完成数据库查询操作和查询结果集的返回及显示，其功能代码如下：

＜html＞
＜body＞
＜%
String sqlStatement；
String sqlField = ""；
String whichTable = ""；
String whereClause = ""；
String queryNo = ""；
String queryName = ""；
%＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--prepare sql statement--＞
＜%
String queryRequest = request.getParameter（"rb_request"）；
//out.println（"queryRequest："+queryRequest）；
String whichCB = ""；
if （queryRequest.equals（"1"））{
whichCB = "ck_jhcg"；
whichTable = "jhcg_table"；
queryNo = request.getParameter（"ed_jhcg_no"）；
queryName = request.getParameter（"ed_jhcg_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}
}
if （queryRequest.equals（"2"））{
whichCB = "ck_kctj"；
whichTable = "kctj_table"；
queryNo = request.getParameter（"ed_kctj_no"）；
queryName = request.getParameter（"ed_kctj_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}

}
if （queryRequest.equals（"3"））{
whichCB = "ck_sjcg"；
whichTable = "sjcg_table"；
queryNo = request.getParameter（"ed_sjcg_no"）；
queryName = request.getParameter（"ed_sjcg_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}

}
String[] printTitle = request.getParameterValues（whichCB）；

%＞
＜!--create query sql statement--＞
＜%
sqlStatement = "select "；
for（int i = 0；i＜printTitle.length；i++）{
sqlField += printTitle[i]+"，"；
}
sqlStatement += sqlField.substring（0，sqlField.length（）-1）+" from "+whichTable；
if （!whereClause.equals（""））
sqlStatement += whereClause；
%＞
＜!--show query response--＞
＜%
try{
DBBean.query（sqlStatement）；
}catch（Exception e）{
out.println（"Database Error!"）；
}
int rows = DBBean.getRowcount（）；
int cols = DBBean.getColumncount（）；
%＞
＜Table align="center" width="80%" border=1＞
＜tr align=center＞
＜%
for（int i = 0；i ＜ printTitle.length；i++）{
out.println（"＜td＞＜b＞"）；
out.println（printTitle[i]）；
out.println（"＜/b＞＜/td＞"）；
}
%＞
＜/tr＞
＜%
for （int i = 0；i ＜ rows；i++）{
out.println（"＜tr＞"）；
for （int j = 0；j ＜ cols；j++）
out.println（"＜td＞"+DBBean.get（i，j）+"＜/td＞"）；
out.println（"＜/tr＞"）；
}
%＞
＜/Table＞
＜br＞
＜hr＞
＜a href="demo_main.htm"＞Click here to return＜/a＞＜/p＞
＜/body＞
＜/html＞

　　③ 生成实际采购表

　　生成数据库表是一个隐式操作，程序根据计划采购表和库存统计表的相应字段生成实际采购表，不需要用户的任何输入，其功能代码如下（demo_create.jsp）：

＜%@page import="Java.util.*"%＞
＜html＞
＜body＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--prepare sql statement--＞
＜%
int amount_jhcg，amount_kctj；
Vector updateRs = new Vector（）；
DBBean.query（"delete * from sjcg_table"）； //delete all old records in sjcg_table
DBBean.query（"select jhcg_table.good_no，jhcg_table.good_name，jhcg_table.amount，kctj_table.amount，jhcg_table.unit from jhcg_table left join kctj_table on kctj_table.good_no=jhcg_table.good_no"）；
int rows = DBBean.getRowcount（）；
int cols = DBBean.getColumncount（）；
for （int i = 0；i ＜ rows；i++）{
String record[] = new String[4]；
record[0] = DBBean.get（i，0）；
record[1] = DBBean.get（i，1）；
amount_jhcg = （Integer.valueOf（DBBean.get（i，2）））.intValue（）；
if （DBBean.get（i，3） == null） amount_kctj = 0；
else amount_kctj = （Integer.valueOf（DBBean.get（i，3）））.intValue（）；
record[2] = Integer.toString（amount_jhcg - amount_kctj）；
record[3] = DBBean.get（i，4）；
updateRs.addElement（record）；
}
for （int i = 0；i ＜ rows；i++）{
String insRecord[] = （String []）updateRs.elementAt（i）；
String insGoodno，insGoodname，insUnit，insAmount；
insGoodno = insRecord[0]；
insGoodname = insRecord[1]；
insAmount = insRecord[2]；
insUnit = insRecord[3]；
String sqlStatement = "insert into sjcg_table（good_no，good_name，amount，unit） values?quot;+"'"+insGoodno+"'"+"，"+"'"+insGoodname+"'"+"，"+insAmount+"，"+"'"+insUnit+"'"+"）"；
DBBean.query（sqlStatement）；
DBBean.query（"delete * from sjcg_table where amount＜=0"）；
}
%＞
＜a href="demo_main.htm"＞Database created...Click here to return＜/a＞＜/p＞
＜/body＞
＜/html＞

　　上述的开发工具综合应用介绍了基于Java开发电子商务应用系统的全过程，包括应用开发平台搭建、业务流程分析、JavaBean封装和JSP开发等内容，其中JSP开发中涉及到了通用SQL（查询和插入数据库表）和游标操作（生成实际采购表），基本可以完成任何网络数据库应用的需求。本实例基本上可以将前面介绍的基于Java的电子商务开发技术串接起来，指导读者进行电子商务应用开发。

如何在JSP中实现分页显示？

　　分页显示是Web数据库应用中经常需要遇到的问题，当用户的数据库查询结果远远超过了计算机屏幕的显示能力的时候，我们该如何合理的将数据呈现给用户呢？答案就是数据库分页显示，可以完美的解决上述问题。下面是一个数据库分页操作的通用实例，对任何数据库平台上的分页功能都有很好的借鉴意义。

＜%@ page contentType="text/html;charset=8859_1" %＞
＜%
//变量声明
Java.sql.Connection sqlCon; //数据库连接对象
Java.sql.Statement sqlStmt; //SQL语句对象
Java.sql.ResultSet sqlRst; //结果集对象

Java.lang.String strCon; //数据库连接字符串
Java.lang.String strSQL; //SQL语句

int intPageSize; //一页显示的记录数
int intRowCount; //记录总数
int intPageCount; //总页数
int intPage; //待显示页码
Java.lang.String strPage;

int i;

//设置一页显示的记录数
intPageSize = 2;

//取得待显示页码
strPage = request.getParameter("page");
if(strPage==null){//表明在QueryString中没有page这一个参数，此时显示第一页数据
intPage = 1;
}
else{//将字符串转换成整型
intPage = Java.lang.Integer.parseInt(strPage);
if(intPage＜1) intPage = 1;
}

//装载JDBC驱动程序
Java.sql.DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

//设置数据库连接字符串
strCon = "jdbc:oracle:thin:@linux:1521:ora4cweb";

//连接数据库
sqlCon = Java.sql.DriverManager.getConnection(strCon,"hzq","hzq");

//创建一个可以滚动的只读的SQL语句对象
sqlStmt = sqlCon.createStatement(Java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,Java.sql.ResultSet.CONCUR_READ_ONLY);

//准备SQL语句
strSQL = "select name,age from test";

//执行SQL语句并获取结果集
sqlRst = sqlStmt.executeQuery(strSQL);

//获取记录总数
sqlRst.last();
intRowCount = sqlRst.getRow();

//记算总页数
intPageCount = (intRowCount+intPageSize-1) / intPageSize;

//调整待显示的页码
if(intPage＞intPageCount) intPage = intPageCount;
%＞

＜html＞
＜head＞
＜meta http-equiv="Content-Type" content="text/html; charset=gb2312"＞
＜title＞JSP数据库操作例程 - 数据分页显示 - JDBC 2.0 - Oracle＜/title＞
＜/head＞

＜body＞

＜table border="1" cellspacing="0" cellpadding="0"＞
＜tr＞
＜th＞姓名＜/th＞
＜th＞年龄＜/th＞
＜/tr＞

＜%
if(intPageCount＞0){
//将记录指针定位到待显示页的第一条记录上
sqlRst.absolute((intPage-1) * intPageSize + 1);

//显示数据
i = 0;
while(i＜intPageSize && !sqlRst.isAfterLast()){
%＞
＜tr＞
＜td＞＜%=sqlRst.getString(1)%＞＜/td＞
＜td＞＜%=sqlRst.getString(2)%＞＜/td＞
＜/tr＞
＜%
sqlRst.next();
i++;
}
}
%＞

＜/table＞

第＜%=intPage%＞页  共＜%=intPageCount%＞页
  ＜%if(intPage＜intPageCount){%＞＜a href="jdbc20-oracle.jsp?page=＜%=intPage+1%＞"＞下一页
＜/a＞＜%}%＞  ＜%if(intPage＞1){%＞＜a href="jdbc20-oracle.jsp?page=＜%=intPage-1%＞"＞上一页＜/a＞＜%}%＞

＜/body＞
＜/html＞

＜%
//关闭结果集
sqlRst.close();

//关闭SQL语句对象
sqlStmt.close();

//关闭数据库
sqlCon.close();
%＞

附录：JDBC TM技术解析

　　1. JDBCTM的定义

　　JDBCTM 是一种用于执行 SQL 语句的 JavaTM API，它由一组用 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的API，使他们能够用纯 Java API 来编写数据库应用程序。

　　有了 JDBC，向各种关系数据库发送 SQL 语句就是一件很容易的事。换言之，有了 JDBC API，就不必为访问 Sybase 数据库专门写一个程序，为访问 Oracle 数据库又专门写一个程序，为访问 Informix 数据库又写另一个程序，等等。您只需用 JDBC API 写一个程序就够了它可向相应数据库发送 SQL 语句。而且，使用 Java 编程语言编写的应用程序，就无须去忧虑要为不同的平台编写不同的应用程序。将Java 和 JDBC 结合起来将使程序员只须写一遍程序就可让它在任何平台上运行。

　　Java 具有坚固、安全、易于使用、易于理解和可从网络上自动下载等特性，是编写数据库应用程序的杰出语言。所需要的只是 Java应用程序与各种不同数据库之间进行对话的方法。而 JDBC 正是作为此种用途的机制。

　　JDBC 扩展了 Java 的功能。例如，用 Java 和 JDBC API 可以发布含有 applet 的网页，而该 applet 使用的信息可能来自远程数据库企业也可以用 JDBC 通过 Intranet 将所有职员连到一个或多个内部数据库中（即使这些职员所用的计算机有 Windows、 Macintosh 和UNIX 等各种不同的操作系统）。随着越来越多的程序员开始使用Java 编程语言，对从 Java 中便捷地访问数据库的要求也在日益增加。

　　MIS 管理员们都喜欢 Java 和 JDBC 的结合，因为它使信息传播变得容易和经济。企业可继续使用它们安装好的数据库，并能便捷地存取信息，即使这些信息是储存在不同数据库管理系统上。新程序的开发期很短。安装和版本控制将大为简化。程序员可只编写一遍应用程序或只更新一次，然后将它放到服务器上，随后任何人就都可得到最新版本的应用程序。对于商务上的销售信息服务， Java 和JDBC 可为外部客户提供获取信息更新的更好方法。

　　2. JDBC 的用途

　　简单地说，JDBC 可做三件事：与数据库建立连接、发送 SQL 语句并处理结果。下列代码段给出了以上三步的基本示例：

Connection con = DriverManager.getConnection（"jdbc：odbc：wombat"，"login"，
"password"）；
Statement stmt = con.createStatement（）；
ResultSet rs = stmt.executeQuery（"SELECT a， b， c FROM Table1"）；
while （rs.next（）） {
int x = rs.getInt（"a"）；
String s = rs.getString（"b"）；
float f = rs.getFloat（"c"）；
}

　　上述代码对基于JDBC的数据库访问做了经典的总结，当然，在本小节的后续部分会对它做详尽的分析讲解。

　　3. JDBC API

　　JDBC 是个"低级"接口，也就是说，它用于直接调用 SQL 命令。在这方面它的功能极佳，并比其它的数据库连接 API 易于使用，但它同时也被设计为一种基础接口，在它之上可以建立高级接口和工具。高级接口是"对用户友好的"接口，它使用的是一种更易理解和更为方便的 API，这种API在幕后被转换为诸如 JDBC 这样的低级接口。

　　在关系数据库的"对象/关系"映射中，表中的每行对应于类的一个实例，而每列的值对应于该实例的一个属性。于是，程序员可直接对 Java 对象进行操作；存取数据所需的 SQL 调用将在"掩盖下"自动生成。此外还可提供更复杂的映射，例如将多个表中的行结合进一个 Java 类中。

　　随着人们对 JDBC 的兴趣日益增涨，越来越多的开发人员一直在使用基于 JDBC 的工具，以使程序的编写更加容易。程序员也一直在编写力图使最终用户对数据库的访问变得更为简单的应用程序。例如应用程序可提供一个选择数据库任务的菜单。任务被选定后，应用程序将给出提示及空白供填写执行选定任务所需的信息。所需信息输入应用程序将自动调用所需的 SQL 命令。在这样一种程序的协助下，即使用户根本不懂 SQL 的语法，也可以执行数据库任务。

　　4. JDBC与ODBC和其它API的比较

　　目前，Microsoft 的 ODBC API 可能是使用最广的、用于访问关系数据库的编程接口。它能在几乎所有平台上连接几乎所有的数据库。为什么 Java 不使用 ODBC？对这个问题的回答是：Java 可以使用 ODBC，但最好是在 JDBC 的帮助下以 JDBC-ODBC 桥的形式使用，这一点我们稍后再说。现在的问题已变成："为什么需要 JDBC"？答案是显然的：ODBC 不适合直接在 Java 中使用，因为它使用 C 语言接口。从Java 调用本地 C 代码在安全性、实现、坚固性和程序的自动移植性方面都有许多缺点。从 ODBC C API 到 Java API 的字面翻译是不可取的。例如，Java 没有指针，而 ODBC 却对指针用得很广泛（包括很容易出错的指针"void *"）。您可以将 JDBC 想象成被转换为面向对象接口的 ODBC，而面向对象的接口对 Java 程序员来说较易于接收。

　　ODBC 很难学。它把简单和高级功能混在一起，而且即使对于简单的查询，其选项也极为复杂。相反，JDBC 尽量保证简单功能的简便性，而同时在必要时允许使用高级功能。启用"纯 Java "机制需要象 JDBC 这样的 Java API。如果使用ODBC，就必须手动地将 ODBC 驱动程序管理器和驱动程序安装在每台客户机上。如果完全用 Java 编写 JDBC 驱动程序则 JDBC 代码在所有 Java 平台上（从网络计算机到大型机）都可以自动安装、移植并保证安全性。

　　总之，JDBC API 对于基本的 SQL 抽象和概念是一种自然的 Java 接口。它建立在 ODBC 上而不是从零开始。因此，熟悉 ODBC 的程序员将发现 JDBC 很容易使用。JDBC 保留了 ODBC 的基本设计特征；事实上，两种接口都基于 X/Open SQL CLI（调用级接口）。它们之间最大的区别在于：JDBC 以 Java 风格与优点为基础并进行优化，因此更加易于使用。

　　目前，Microsoft 又引进了 ODBC 之外的新 API： RDO、 ADO 和OLE DB。这些设计在许多方面与 JDBC 是相同的，即它们都是面向对象的数据库接口且基于可在 ODBC 上实现的类。但在这些接口中，我们未看见有特别的功能使我们要转而选择它们来替代 ODBC，尤其是在 ODBC 驱动程序已建立起较为完善的市场的情况下。它们最多也就是在 ODBC 上加了一种装饰而已。

　　5. JDBC对B/S和C/S模式的支持

　　JDBC API 既支持数据库访问的两层模型（C/S），同时也支持三层模型（B/S）。在两层模型中，Java applet或应用程序将直接与数据库进行对话。这将需要一个JDBC驱动程序来与所访问的特定数据库管理系统进行通讯。用户的SQL语句被送往数据库中，而其结果将被送回给用户。数据库可以位于另一台计算机上，用户通过网络连接到上面。这就叫做客户机/服务器配置，其中用户的计算机为客户机，提供数据库的计算机为服务器。网络可以是 Intranet（它可将公司职员连接起来），也可以是 Internet。

　　在三层模型中，命令先是被发送到服务的"中间层"，然后由它将SQL 语句发送给数据库。数据库对 SQL 语句进行处理并将结果送回到中间层，中间层再将结果送回给用户。MIS 主管们都发现三层模型很吸引人，因为可用中间层来控制对公司数据的访问和可作的的更新的种类。中间层的另一个好处是，用户可以利用易于使用的高级API，而中间层将把它转换为相应的低级调用。最后，许多情况下三层结构可提供一些性能上的好处。

　　到目前为止，中间层通常都用 C 或 C++ 这类语言来编写，这些语言执行速度较快。然而，随着最优化编译器（它把 Java 字节代码转换为高效的特定于机器的代码）的引入，用 Java 来实现中间层将变得越来越实际。这将是一个很大的进步，它使人们可以充分利用 Java 的诸多优点（如坚固、多线程和安全等特征）。JDBC 对于从Java的中间层来访问数据库非常重要。

　　6. SQL 的一致性

　　结构化查询语言（SQL）是访问关系数据库的标准语言。困难之处在于：虽然大多数的 DBMS （数据库管理系统）对其基本功能都使用了标准形式的 SQL，但它们却不符合最近为更高级的功能定义的标准 SQL 语法或语义。例如，并非所有的数据库都支持储存程序或外部连接，那些支持这一功能的数据库又相互不一致。人们希望 SQL 中真正标准的那部份能够进行扩展以包括越来越多的功能。但同时 JDBC API 又必须支持现有的 SQL。

　　JDBC API 解决这个问题的一种方法是允许将任何查询字符串一直传到所涉及的 DBMS 驱动程序上。这意味着应用程序可以使用任意多的 SQL 功能，但它必须冒这样的风险：有可能在某些 DBMS 上出错。事实上，应用程序查询甚至不一定要是 SQL，或者说它可以是个为特定的 DBMS 设计的 SQL 的专用派生物（例如，文档或图象查询）。

　　JDBC 处理 SQL 一致性问题的第二种方法是提供 ODBC 风格的转义子句，这将在后续部分中讨论。转义语法为几个常见的 SQL 分歧提供了一种标准的 JDBC 语法。例如，对日期文字和已储存过程的调用都有转义语法。

　　对于复杂的应用程序，JDBC 用第三种方法来处理 SQL 的一致性问题它利用 DatabaseMetaData 接口来提供关于 DBMS 的描述性信息，从而使应用程序能适应每个 DBMS 的要求和功能。

　　由于 JDBC API 将用作开发高级数据库访问工具和 API 的基础 API，因此它还必须注意其所有上层建筑的一致性。"符合JDBC标准TM" 代表用户可依赖的 JDBC 功能的标准级别。要使用这一说明，驱动程序至少必须支持 ANSI SQL-2 Entry Level（ANSI SQL-2 代表美国国家标准局 1992 年所采用的标准。Entry Level代表SQL功能的特定清单）。驱动程序开发人员可用 JDBC API 所带的测试工具包来确定他们的驱动程序是否符合这些标准。

　　"符合 JDBC 标准TM" 表示提供者的 JDBC 实现已经通过了JavaSoft 提供的一致性测试。这些一致性测试将检查 JDBC API中定义的所有类和方法是否都存在，并尽可能地检查程序是否具有SQL Entry Level 功能。当然，这些测试并不完全，而且 JavaSoft 目前也无意对各提供者的实现进行标级。但这种一致性定义的确可对JDBC实现提供一定的可信度。随着越来越多的数据库提供者、连接提供者、Internet 提供者和应用程序编程员对 JDBC API 的接受，JDBC 也正迅速成为 Java 数据库访问的标准。

帅子 2007-11-21 18:23 发表评论