2006年3月13日

把这个类放到和hibernate.cfg.xml一个目录下,编译执行,注意把需要的包(dom4j)引进去

操作xml基本上就这么东西,你仔细看看,很简单的

import java.io.File;
import java.io.FileOutputStream;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class HiberCFG {

 /**
  * @param args
  */
 
 public void readXML(){
  try{
   String fname="hibernate.cfg.xml";
   SAXReader reader=new SAXReader();
   Document document=reader.read(new File(fname));
   Element root=document.getRootElement();
   List list=root.selectNodes("/hibernate-configuration/session-factory/property");
   for(Iterator it=list.iterator();it.hasNext();){
    Node node=(Node)it.next();
    if(node.valueOf("@name").equals("hibernate.connection.url")){
     //原url
     String url=node.getText(); 
     System.out.println(url);
     //IP地址前的部分
     String a1=url.substring(0,url.indexOf("//")+2);     
     System.out.println(a1);
     //IP地址后部分
     String a2=url.substring(url.indexOf(":",(url.indexOf("//")+2)),url.length());
     System.out.println(a2);
     
     String newIP="192.168.0.1";
     
     //修改后的url
     String newUrl=a1+newIP+a2;
     System.out.println(newUrl);
     
     //将新url替换
     node.setText(newUrl);
     
     
    }
   }
   
   
   //将文件保存
   String indent="  ";//缩进符号
   boolean newLines=true;// 是否产生新行(即一个元素一行)
   XMLWriter writer=new XMLWriter(new FileOutputStream(fname),new org.dom4j.io.OutputFormat(indent,newLines,"utf-8"));
   writer.write(document);
      writer.flush();
      writer.close();
      System.out.println("成功");
  }
  catch(Exception ex){
   System.out.println("失败");
   ex.printStackTrace();
   
  }
  
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  HiberCFG h=new HiberCFG();
  h.readXML();

 }

}

posted @ 2006-03-13 13:59 丁丁 阅读(730) | 评论 (2)编辑 收藏


2005年12月29日

1.Duplicated Code

  代码重复几乎是最常见的异味了。他也是Refactoring的主要目标之一。代码重复往往来自于copy-and-paste的编程风格。与他相对应OAOO是一个好系统的重要标志。

  2.Long method

  它是传统结构化的“遗毒”。一个方法应当具有自我独立的意图,不要把几个意图放在一起。

  3.Large Class

  大类就是你把太多的责任交给了一个类。这里的规则是One Class One Responsibility.

  4.Divergent Change

  一个类里面的内容变化率不同。某些状态一个小时变一次,某些则几个月一年才变一次;某些状态因为这方面的原因发生变化,而另一些则因为其他方面的原因变一次。面向对象的抽象就是把相对不变的和相对变化相隔离。把问题变化的一方面和另一方面相隔离。这使得这些相对不变的可以重用。问题变化的每个方面都可以单独重用。这种相异变化的共存使得重用非常困难。

  5.Shotgun Surgery

  这正好和上面相反。对系统一个地方的改变涉及到其他许多地方的相关改变。这些变化率和变化内容相似的状态和行为通常应当放在同一个类中。

  6.Feature Envy

  对象的目的就是封装状态以及与这些状态紧密相关的行为。如果一个类的方法频繁用get 方法存取其他类的状态进行计算,那么你要考虑把行为移到涉及状态数目最多的那个类。

  7.Data Clumps

  某些数据通常像孩子一样成群玩耍:一起出现在很多类的成员变量中,一起出现在许多方法的参数中,这些数据或许应该自己独立形成对象。

  8.Primitive Obsession

  面向对象的新手通常习惯使用几个原始类型的数据来表示一个概念。譬如对于范围,他们会使用两个数字。对于Money,他们会用一个浮点数来表示。因为你没有使用对象来表达问题中存在的概念,这使得代码变的难以理解,解决问题的难度大大增加。好的习惯是扩充语言所能提供原始类型,用小对象来表示范围、金额、转化率、邮政编码等等。

  9.Switch Statement

  基于常量的开关语句是OO 的大敌,你应当把他变为子类、state或strategy.

  10. Parallel Inheritance Hierarchies

  并行的继承层次是shotgun surgery的特殊情况。因为当你改变一个层次中的某一个类时,你必须同时改变另外一个层次的并行子类。

  11. Lazy Class

  一个干活不多的类。类的维护需要额外的开销,如果一个类承担了太少的责任,应当消除它。

  12. Speculative Generality

  一个类实现了从未用到的功能和通用性。通常这样的类或方法唯一的用户是testcase.不要犹豫,删除它。

  13. Temporary Field

  一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立一个对象来持有这样的孤儿属性,把只和他相关的行为移到该类。最常见的是一个特定的算法需要某些只有该算法才有用的变量。

  14. Message Chain

  消息链发生于当一个客户向一个对象要求另一个对象,然后客户又向这另一对象要求另一个对象,再向这另一个对象要求另一个对象,如此如此。这时,你需要隐藏分派。

  15. Middle Man

  对象的基本特性之一就是封装,而你经常会通过分派去实现封装。但是这一步不能走得太远,如果你发现一个类接口的一大半方法都在做分派,你可能需要移去这个中间人。

  16. Inappropriate Intimacy

  某些类相互之间太亲密,它们花费了太多的时间去砖研别人的私有部分。对人类而言,我们也许不应该太假正经,但我们应当让自己的类严格遵守禁欲主义。

  17. Alternative Classes with Different Interfaces

  做相同事情的方法有不同的函数signature,一致把它们往类层次上移,直至协议一致。

  18. Incomplete Library Class

  要建立一个好的类库非常困难。我们大量的程序工作都基于类库实现。然而,如此广泛而又相异的目标对库构建者提出了苛刻的要求。库构建者也不是万能的。有时候我们会发现库类无法实现我们需要的功能。而直接对库类的修改有非常困难。这时候就需要用各种手段进行Refactoring.

  19. Data Class

  对象包括状态和行为。如果一个类只有状态没有行为,那么肯定有什么地方出问题了。

  20. Refused Bequest

  超类传下来很多行为和状态,而子类只是用了其中的很小一部分。这通常意味着你的类层次有问题。

  21. Comments

  经常觉得要写很多注释表示你的代码难以理解。如果这种感觉太多,表示你需要Refactoring。

posted @ 2005-12-29 09:20 丁丁 阅读(349) | 评论 (0)编辑 收藏


2005年11月9日

发于心而成于意
胜于博而止于精
法乎天地
以归这大道
用以八方 
皆近乎至善
可言美亦

posted @ 2005-11-09 14:48 丁丁 阅读(210) | 评论 (0)编辑 收藏

在测试eqhi的网页中,发现文本框的内容会被手机缓存,查找相关的资料

试过在header中增加一些控制Cache的参数还是不行

posted @ 2005-11-09 13:39 丁丁 阅读(437) | 评论 (0)编辑 收藏


2005年11月3日

本例子使用了jspsmart组件进行上传,这里可以免费下载该组件www.jspsmart.com
下载解压后,将jar包复制到 \WEB-INF\lib 目录后重启服务器,jspsmart即可正常使用了

1、uploadimage.jsp

<%@ page contentType="text/html;charset=gb2312" language="java" import="java.io.*,java.awt.Image,java.awt.image.*,com.sun.image.codec.jpeg.*,
java.sql.*,com.jspsmart.upload.*,java.util.*,cn.oof.database.*,cn.oof.house.*"%>
<%
SmartUpload mySmartUpload =new SmartUpload();
long file_size_max=4000000;
String fileName2="",ext="",testvar="";
String url="uploadfile/images/";      //应保证在根目录中有此目录的存在
//初始化
mySmartUpload.initialize(pageContext);
//只允许上载此类文件
try {
 mySmartUpload.setAllowedFilesList("jpg,gif");
//上载文件
 mySmartUpload.upload();
} catch (Exception e){
%>
  <SCRIPT language=javascript>
  alert("只允许上传.jpg和.gif类型图片文件");
  window.location='upfile.jsp';
  </script>
<%
}
try{

    com.jspsmart.upload.File myFile = mySmartUpload.getFiles().getFile(0);
    if (myFile.isMissing()){%>
   <SCRIPT language=javascript>
   alert("请先选择要上传的文件");
   window.location='upfile.jsp';
   </script>
    <%}
    else{
      //String myFileName=myFile.getFileName(); //取得上载的文件的文件名
   ext= myFile.getFileExt();      //取得后缀名
   int file_size=myFile.getSize();     //取得文件的大小 
   String saveurl="";
   if(file_size<file_size_max){
    //更改文件名,取得当前上传时间的毫秒数值
    Calendar calendar = Calendar.getInstance();
    String filename = String.valueOf(calendar.getTimeInMillis());
    saveurl=request.getRealPath("/")+url;
    saveurl+=filename+"."+ext;          //保存路径
    myFile.saveAs(saveurl,mySmartUpload.SAVE_PHYSICAL);
    //out.print(filename);
//-----------------------上传完成,开始生成缩略图-------------------------   
    java.io.File file = new java.io.File(saveurl);        //读入刚才上传的文件
    String newurl=request.getRealPath("/")+url+filename+"_min."+ext;  //新的缩略图保存地址
    Image src = javax.imageio.ImageIO.read(file);                     //构造Image对象
    float tagsize=200;
    int old_w=src.getWidth(null);                                     //得到源图宽
    int old_h=src.getHeight(null);  
    int new_w=0;
    int new_h=0;                            //得到源图长
    int tempsize;
    float tempdouble;
    if(old_w>old_h){
     tempdouble=old_w/tagsize;
    }else{
     tempdouble=old_h/tagsize;
    }
    new_w=Math.round(old_w/tempdouble);
    new_h=Math.round(old_h/tempdouble);//计算新图长宽
    BufferedImage tag = new BufferedImage(new_w,new_h,BufferedImage.TYPE_INT_RGB);
    tag.getGraphics().drawImage(src,0,0,new_w,new_h,null);       //绘制缩小后的图
    FileOutputStream newimage=new FileOutputStream(newurl);          //输出到文件流
    JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(newimage);      
    encoder.encode(tag);                                               //近JPEG编码
     newimage.close();   

   }
   else{
    out.print("<SCRIPT language='javascript'>");
    out.print("alert('上传文件大小不能超过"+(file_size_max/1000)+"K');");
    out.print("window.location='upfile.jsp;'");
    out.print("</SCRIPT>");
   }
  }
}catch (Exception e){

e.toString();

}
%>

2 upload.htm
<html>
<head>
<title>请选择上传的图片</title>
</head>
<body>
<table border="0" align="center" cellpadding="0" cellspacing="0">
  <tr>
    <td height="45" align="center" valign="middle"><form action="uploadimage.jsp" method="post" enctype="multipart/form-data" name="form1">
请选择上传的图片
    <input type="file" name="file">
<input type="submit" name="Submit" value="上传">
    </form></td>
  </tr>
</table>
</body>
</html>

posted @ 2005-11-03 23:02 丁丁 阅读(2515) | 评论 (3)编辑 收藏

这段时间过的真无聊,程序员的日子好无聊呀

posted @ 2005-11-03 22:58 丁丁 阅读(189) | 评论 (0)编辑 收藏


2005年10月24日

J2EE项目10大风险
避免本文所列之10J2EE风险,确保企业级Java项目成功
作者:Humphrey Sheil
翻译:Blueski

说明:
本文已在51CMM网站《中国系统分析员》杂志第3期刊载。
原文在 http://www.javaworld.com/javaworld/jw-03-2001/jw-0330-ten.html
摘要
当你开始着手组织一个企业级Java项目的时候,就如同开始同时轮回地扔好几个魔术小球: 业主关系处理、持续而漫长的设计开发过程,以及保持健全与完整性,等等。每一个“小球”都会带来其固有的风险,有些显而易见,有些则不易发现。尽管如此,所有这些风险都是完全可以避免的。本文作者Humphrey Sheil分析了威胁到企业级Java项目成功的10大风险, 并一一列出了风险规避的策略方法。

在过去这段时期里,我担任过程序员、高级设计师以及架构设计师等工作,见识过很优秀的企业级Java项目,也见识过不好的,甚至很"丑陋"的项目。有时候我会自己问自己,为什么一个项目可以取得成功,而另一个却走向失败?很难定义出某种规则或标准来表明各个不同的项目应该如何成功,J2EE项目也并不例外。但与此相反的是,我们可以从各个角度和层次上去考察项目失败的原因,如果很好地避开了这些风险,项目就可以取得成功。在本文中,我将提出排名前10位的企业级Java项目风险,供读者参考。
在各种各样的风险中,有些风险只是延缓了项目的进度,有些带来了一些不必要的工作,而另一些则会把成功的可能性彻底地消除。不过,如果预先有了足够的准备和清醒的认识,那么并没有不可避免的事情。这好比如果你是一名旅行者,你清楚地知道前面的道路在什么方向,做了充分的准备,又有一位清楚知道哪里有危险的向导,这样就会比较顺利地到达自己的目的地。
本文采用了以下结构来描述风险: 
·         风险名称:风险的标题(使用粗体)
·         项目阶段:在哪个项目阶段会发生风险情况
·         影响阶段:会影响到以后的哪些阶段
·         症状:    风险产生时的症状
·         规避方案:如何规避风险或者把其对项目的影响降低到最小程度
·         备注:    风险相关的补充说明和提示
通过对企业级Java项目的仔细考察,本文将J2EE项目过程分解为以下几个阶段:
·         提供商选择: 在开始你的J2EE项目之前,要选择最合适的提供商,从应用服务器到开发工具组合,一直至工作期间享用的咖啡的厂商。:) 
·         设计: 在遵照一系列严格的规范和软件工程方法的前提下,可以开始进行足够充分的设计,然后再很自然地进入开发阶段。在开发之前,要周全地考虑好正在做什么,以及如何往下做的问题。另外,我使用了一些设计模板来确信在进入开发之前,已经想到了所有的问题和可能的解决方案。但是,我有时也在该阶段做一些编码,有时候这样做可以回答一些问题,有效地判断出性能上和模块划分上的问题。 
·         开发: 也就是程序开发阶段,选择一些好的开发工具,进行精良的设计等等,在这个阶段将显示其优越性,并且可以给开发带来很大的帮助。 
·         稳定性/负载测试:在该阶段,系统架构师和项目经理应该冻结住产品特性,并把焦点放在质量以及产品参数(允许的并发用户数量,故障恢复情况,等等)上。质量和性能在该阶段应得到足够的重视。当然,最好应该避免在前阶段写出不良的运行缓慢的代码而到本阶段来作很多的修改。
·         成熟期:这不是一个真正的项目阶段,而是一个固定的准备阶段。过去潜伏的错误(来自于糟糕的设计和开发、错误的厂商选择)可能出现并影响你的系统。
图1 由于各种原因而受到影响的项目阶段
 
OK,以下让我们进入 top 10 项目风险!
 

风险1:没有真正理解 Java, EJB, J2EE

这个问题可以分解为3个部分,以便于分析。
描述: 没有真正理解Java
项目阶段:开发
影响阶段:设计、稳定性测试、成熟期
对系统性能的影响:可维护性、可扩展性、性能
症状:
·         重复开发了JDK核心API中的功能或类
·         不懂得以下列表中的某些项(这只是一些主题或者实际例子而已):
o        垃圾收集器 (train, generational, incremental, synchronous, asynchronous)
o        对象在何时能被进行垃圾收集 -- dangling references
o        使用的继承机制及其权衡
o        over-riding和over-loading方法
o        为什么java.lang.String (在这里用你所中意的类代替) 提供的性能不好
o        Java中的pass-by参考语义和EJB中pass-by值的语义的比较
o        使用 == 或者使用equals() 方法 for nonprimitives
o        在不同平台上Java线程的运行顺序方式(例如是否是抢先方式的)
o        新线程和本地线程的比较
o        Hotspot技术(以及为什么旧的性能调整技术降低了Hotspot 的优化效果)
o        JIT,以及什么时候好的JIT变得不好(未安装的JAVA编译器,以及你的代码运行得刚够良好)
o        API搜集
o        RMI
规避方案:
你需要不断改进Java方面的知识,尤其是深入了解Java的优势和不足之处。Java的存在价值已经远不止是一种语言,理解平台(JDK及工具等)也是同样重要的。具体地说,你应该是经过认证的Java程序员,如果你不是的话,也许你有时会为还有那么多不知道的内容而感到惊讶。另外,你可以加入Java的邮件列表。以前我曾加盟过的每一个公司都加入了这样的邮件列表,从同行中学到技术,这将是你最好的资源。
备注:
如果你或者你的团队中的成员不真正了解编程语言和平台,怎么还能保持成功的希望呢?强干的Java程序员之于EJB和J2EE,就象是鸭子之于水一样。与此相反,比较弱的、没有经验的程序员只能开发出质量低劣的J2EE应用程序。
描述: 没有真正理解EJB
项目阶段:
设计
影响阶段:
开发、稳定化
对系统的影响:
维护
症状:
·         EJB在第一次被调用后没有再被使用到(尤其是stateless session bean)
·         没有重复利用价值的EJB
·         不理解开发者要做什么,容器提供什么
·         EJB没有依照规范定义(fire线程, 加载了本地库,试图执行I/O,等等)
解决方案:
要改进关于EJB方面的知识,可以找一个周末来阅读EJB规范 (1.1版有314页),然后阅读2.0规范(524页!),这样可以了解到1.1没有定义到的而在2.0规范中补充的内容。EJB开发者从18.1及18.2章节开始阅读是比较合适的。
备注:
不要从提供商的角度去看EJB,要确切地知道规范所支持的标准EJB模型和基于这些模型的特殊应用之间的区别。这也会有助于你迁移到别的提供商的时候所用。
描述: 没有真正理解J2EE
项目阶段:
设计
影响阶段:
开发
对系统的影响:
维护、扩展性、性能
症状:
·         "Everything is an EJB"的设计方式
·         用手工事务管理取代了容器-提供的机制
·         自定义方式的安全处理 -- J2EE平台在企业级计算中,从表示逻辑到后台处理,已具有最完整的集成安全架构;但很少用到其全部功能。
解决方案:
学习J2EE的关键组件,并且了解它们的优缺点,依次用它们替代每一个服务;“知识就是力量”在这里是行之有效的。
备注:
只有知识能够弥补这些问题。好的Java开发者会成为好的EJB开发者,此后也应逐渐成为J2EE得道高手。Java和J2EE知识掌握得越多,设计和开发工作就会越出色。在设计阶段一切都会有条不紊。

风险2: 过度设计(Over-engineering) (采用 EJB或者不采用EJB) 
项目阶段:
设计
影响的项目阶段:
开发
对系统的影响:
维护、扩展性、性能
症状:
·         过于庞大的EJB
·         开发者无法解释EJB做什么,以及其间的联系
·         无法重复使用的EJB、组件或者服务
·         EJB启动了新的事务,而该事务本该由一个已存在的EJB启动
·         为了安全,把数据分离级别定得太高
解决方案:
过度工程化的解决之道直接来自于极限编程 (XP)方法:用最小的设计和编程来满足需求,除此之外别无它干。除非你需要明确知道今后可能的需求,如将来的负载要求,或者系统在最高负载下的表现,否则大可不必为系统将来的情况做太多考虑或猜测。另外,J2EE平台已经定义了可伸缩性及出错恢复等特性,可以让服务器系统为你进行处理。
在最小的系统中,只包含一个个小组件,这些组件只做一件事,只要把这些要求做到的进行实现,系统稳定性就已经得到了提高,而且,你的系统的可维护性会变得很强,在未来要增加功能以满足新的需求也将变得容易。
备注:
除了上面所列方案之外,可以推行设计模式 -- 它们可以显著地改进你的系统设计。EJB模型本身也广泛使用了设计模式。例如,每个EJB所带的Home 接口就是Finder和Factory模式的实例。EJB的remote接口扮演了一种实际bean实现的代理,并且对于提供容器的能力也是至关重要的,这些容器截取调用信号并提供诸如透明(transparent)负载均衡的服务。忽视设计模式也是危险的一部分。
我常提到要反对的另外一种危险是:仅仅是为了使用EJB而使用EJB。在你的应用中的某一部分可能并不需要EJB,甚至你的整个应用都不需要。这是过度工程化所走的极端,而且我确实也目睹了一些良好的servlet和JavaBean应用被重构为EJB,而这样做并没有很好的技术上的理由。

风险3: 没有将业务规则和逻辑表现形式相分离
项目阶段:
设计
影响的项目阶段:
开发
对系统的影响:
维护、扩展性、性能
症状:
·         过于庞大、没有边际的JSP程序
·         在业务逻辑改变的时候必须修改JSP
·         在要求改变界面显示的时候需要修改并重新配置EJB和其它后台组件
规避方案:
J2EE平台使你有机会将表示逻辑和导航控制相分离,进而与业务规则相分离。这被称为模式2结构。
备注:
可以使用具有一致性的设计来进行用户界面框架的连接。(例如可以使用taglib),这将帮助你避免逻辑分离的问题。有许多现成的好的方法可供选择。对每一个分别进行评估,然后采用最合适的框架。

风险4: 没有在开发环境中进行适当的配置
项目阶段:
开发
影响的项目阶段:
稳定化、并发、成熟期
对系统的影响:
你的权衡
症状:
·         经过多日或数周的时间才能过渡到成熟系统
·         风险存在与过渡期,带有很多不确定性,有些主要的功能场景没有被测试到
·         实际系统中的数据和开发、测试中的数据不同
·         无法在开发者机器上进行组建
·         应用行为在开发、稳定化及产品环境中各不相同
规避方案:
解决之道是忠实地在开发环境中配置实际的环境,让开发所用环境接近于要实施产品的环境。如果未来环境是JDK 1.2.2及Solaris 7,那么不要在JDK 1.3及Red Hat Linux上进行开发。对于所用的应用服务器也是如此。同样,要快速地看一下产品数据库中的数据,并将这样的数据用于测试。不要依赖于人工创建的数据。如果产品数据很敏感,则要使之变得不敏感,然后把它配置起来。开发中未能预期到的产品数据将对以下过程产生破坏:
·         数据检验规则
·         系统测试行为
·         系统组件构建(特别地包括:EJB-EJB以及EJB-数据库)
最为糟糕的是,这样还可能产生异常、空指针,以及你从没见过的问题。
备注:
开发人员常把安全性问题放到稳定化阶段才开始解决。要防止这样的陷阱产生,你也可以花费同样多的时间在业务逻辑中改进安全性。
成熟期是一个复杂的过程,其中充满了技术性问题和非技术性问题。你可能会陷于想不到的一大堆问题中,这就是成熟化所意味的一切。开发及稳定化环境过程为你提供了制造更多这样的问题,以及发现这样的问题的地方,不断去做,就可以大大减少风险。
你做的工程越多,你就越能了解什么是可行的,什么是不可行的。你可以对工程问题进行记录,以避免同样的错误重复发生。

风险5: 选择了错误的提供商
项目阶段:
提供商选择
影响阶段:
设计、开发、稳定化/负载测试,成熟化
对系统的影响:
可伸缩性、性能、可维护性及稳定性
症状:
·         开发人员要使用更多的时间来处理工具方面的问题,而不是很有成效地使用这些工具
·         为了应付已知的和未知的问题,而不得不进行显著的系统重新设计
·         在不同的工具之间很难进行集成(应用服务器与IDE工具,IDE工具与调试器,源码控制与合成工具,等等)
·         对于IDE工具和调试器等,开发人员往往排斥它们,而推崇自己所喜欢的工具
规避方案:
为了避免风险5,你需要一个很好的提供商选择过程,风险10的规避也适用于此。
要真正衡量一种IDE工具是否最合适的方法是真正地进行使用。而唯一来评估一种J2EE应用的方法是建立一种概念试验来进行证明,在试验中要包含你的应用框架。事实上,你也不希望在花费了3个月时间进行了培训和开发后,在使用时又发现一些bug。
假设在开发到一半的时候,突然发现你的工具集有问题,那么你早应该知道,有些工具确实比另一些更重要。如果你所选的应用服务器不能充分满足你的需要,你只好修改原先的设定。如果IDE不好,则需要设置最低限度的代码标准,并让开发人员任意选择他们认为最为有效的工具。
备注:
要真正了解到哪一个供应商对一项特殊的任务来说最合适,其实并不是一件一次性决定的事情。你需要不断地跟踪与评估这个市场。例如,在过去的一年里我用过4种不同的IDE工具,这取决于我使用了什么样的应用服务器、平台,是否使用EJB等。

风险6: 不了解你的提供商
项目阶段:
提供商选择
影响阶段:
提供商选择阶段后面的所有阶段:设计、开发、稳定化/负载测试、成熟化
对系统的影响:
可维护性、可伸缩性、性能
症状:
·         开发所用周期超过了最坏预测的周期1/3以上
·         提供商已经提供了某项功能,但开发者在不知道的情况下重新进行了该项功能的开发
规避方案:
为了规避这样的风险,你可以尽可能地订阅提供商的网上资源,例如邮件列表、新闻组、版本信息(尤其是其中的bug修复补丁的说明等),你能从中得到无法估量之多的收获。
一旦你已经选定了提供商,那么立即就要投资进行培训,并且尽可能赶在项目启动以前。然后,逐渐在团队中建立起对此提供商的认识及信任。试着建立几个EJB并部署一下,再用你的表示层技术 (Swing GUI, JSP等)来调用它们。如果你既要搭建开发环境,又要同时在实现项目目标,就会产生一些不必要的冲突。实际上,我也见到过一直没有进行构建过程的情况:“我们没有时间。”因此,这些工作必须提早进行。有些人会说:“我们的计划中没有为我们提供这些时间。”我的回答是:“你的计划中并没有不给你时间使你不这么做啊。”
备注:
在J2EE世界里,各提供商产品的技术兼容性究竟如何?让我们看一下IBM和BEA的具体分析吧。两者都分别在各自的应用服务器中支持EJB 1.1。那么,实际上BEA WebLogic 5.1和IBM WebSphere 3.5究竟有多少相似之处呢?
1.        BEA WebLogic和IBM WebSphere的系统配置和管理方式几乎完全不同。
2.        IBM在WebSphere中采用了全面的GUI环境,而与之相对的是,BEA 在WebLogic中提供一整套命令行。
3.        IBM WebSphere使用IIOP来和CORBA异常进行通讯,这些异常对程序员来说是可见的;WebLogic根本没有CORBA构造,而缺省使用t3协议。
4.        WebSphere和Visual Age衔接紧密,而WebLogic是IDE无关的,实际上,你几乎可以使用任何的开发工具。
由此可见,差异还是相当多。如果你是一种应用服务器的专家,并不意味着你就是所有应用服务器的专家。这种区别体现在IDE,debugger,build工具,配置管理等等方面。具备某提供商的某项特殊工具的使用经验,可以在评估该提供商的竞争对手产品时具有一些便利。但是,不要奢望在不同产品之间进行无缝的转移或衔接。因此,你不得不花费足够多的时间在熟练掌握这些工具上。

风险7: 设计中没有充分考虑到可伸缩性和产品性能
项目阶段:
设计
受影响的项目阶段:
开发、负载测试及成熟化
对系统的影响:
可伸缩性、性能、可维护性
症状:
·         无法忍受的速度缓慢
·         系统给服务器端增加的沉重负担,而无法利用到一些聚簇技术。
规避方案:
把精力集中于性能和可伸缩性方面的需求,明确开发中要达到的性能指标。如果你需要每秒50个事务,而你的EJB设计只能提供40个,那么你就需要考虑替代方案,诸如存储过程,批处理,或者重新考虑OLTP的设计。
尽可能让你的提供商加入进来,他们应该非常清楚其产品的强项和弱处在哪里,然后给你提供最直接的帮助。
备注:
本风险与风险2 (over-engineering)似乎有些冲突。实际上,两者相互影响。 我对风险2给出的解决方案是,只在绝对必要的情况下才进行构建。而对与性能和可伸缩性,你要预先划分好什么是必须要做的。
如果你实现就识别出系统需要非常强的可伸缩性,并把它作为一个比较关键的需求,那么你首先需要选择一个带有很强的簇支持及事务型缓存的应用服务器。另外,你应把业务对象设计为EJB,从而可以充分利用服务器架构的优势。 XP也没有问题,你仍然是只做绝对必要的工作。
我把这样的观点看作是一种检查和平衡的方法。我们只需要最简单可能性的系统,该系统只提供客户所需要的功能与行为即可。

风险8: 陈旧的开发过程
项目阶段:
开发
影响阶段:
稳定化,成熟化
对系统的影响:
可维护性、代码质量
症状:
·         项目计划看上去似乎类似于瀑布模型: “首先草构设计,然后在一个很长的周期里进行开发。”
·         由于不存在构建(build)过程,每次构建都象是噩梦
·         构建的日期等于损失开发的日期,因为什么也没有做成
·         在集成以前组件没有分别被充分地测试过,而集成测试意味着将2个不稳定的组件放在一起,然后查看堆栈里的跟踪结果。
规避方案:
好的软件方法学将提高你的软件生命期。此前我已经提到XP方法,你可以在网上找到很多这方面的资料。
备注:
JUnit可以用来进行单元测试,Ant工具可以进行编译与构建,这2种工具都对XP方法有很好的支持。

风险9: 没有好的架构方式
项目阶段:
开发
影响阶段:
开发、稳定化、成熟期
对系统的影响:
可维护性、可伸缩性、代码质量
症状:
·         在代码中使用了很多次的核心库中发现Bug。
·         没有建立日志标准 -- 于是系统的输出很难读取或者解析。
·         不良的不一致的异常处理。在有些站点中我们甚至可以看到,出错信息直接暴露给了最终用户,例如在用户在他的购物车核帐时发送一条SQLException堆栈跟踪信息,用户接着会怎么做?打电话给数据库管理员要求对primary key约束进行修补吗?
以下任务已经被开发者以各种方式处理了无数次了,这些都有必要放在任何构架设计的第一批目标中。 
·         日志
·         异常处理
·         与资源的连接(数据库,名字服务等)
·         构建JSP页
·         数据合法性检查
规避方案:
我是一个轻方法学的信徒和实践者。我在JavaWorld 上的第一篇文章 -- "Frameworks Save the Day" -- 就是研讨在企业Java环境中的架构。即使你已经开始开发了,此时考虑一下架构仍然是值得的。可能你不得不忍受一下重构带来的异常处理和日志处理,但从长远来看还是值得的,这样即省时间又省钱。
备注:
让我们想一下在构架中基于组件开发的可重用性的不同等级。第一级别是plumbing,具有0.9以上的可重用比例,也就是说,有90%的项目可以对它重复利用。 服务定义得越详细,重用比例就越低。换句话说,我需要构建一个会计服务,但要提供这些资源与用法的管理,以便于其它50%项目中可以对它们进行重复利用。但是对那些项目来说,能得到这些资源,那真是太好了!

风险10: 项目计划和设计基于市场效应,而脱离了技术现实
备注: 不断有新人加入到Java/EJB的开发领域中来,不理解Java的人数一般比想象中还要多。
项目阶段:
所有阶段都会受到影响,包括提供商的选择
影响阶段:
所有阶段都会受到影响
对系统的影响:
可维护性、可扩展性、设计质量、代码质量
症状:
·         轻率地进行技术决策,认为EJB只是为了便携式处理的方便
·         选择提供商的时候没有随即进行产品的试用
·         在项目的生命周期内还需要更换工具
规避方案:
不要轻易相信项目外部的任何人的看法,这些人可能已经有一些既得利益,不要相信提供商的说法(除非你早已经了解),也不要相信白皮书。如果你要取得来自真实世界的关于应用服务器的建议,可以在网上取得。你还可以下载这些工具进行评估,用它们做一些原型,并运行一下其中的样例。(好的提供商都有这样的样例)。
总的来说,为你的项目选择最好的提供商及工具需要时间,而你可能没有太多的时间。你可以把选择范围限制在3-4个对象,然后用一周时间进行比较和检验。最后从中选出比较满意的工具和产品。
备注:
如果你缺少J2EE经验,则可能会在项目前期就产生问题。在前期所确定的决策会影响整个过程,并进而影响项目的成功。好的J2EE咨询专家将能够帮助你选择好的提供商,并为设计和开发刻划出一个好的构形。

仅仅只有这10项风险吗?

10只是一个特定的数字,显然,还有更多更多的风险会存在。只是我可以保证的是,如果你克服了所列的各项风险,那么你的项目会有出色的表现并已打好了成功的基础。
还有一项需要注意,即没有任何东西可以代替经验和计划。如果你没有经验,那么一定要想办法取得并积累。千万不要一边做项目一边进行培训。在开发之前要预先做好充分的准备,最好是在设计以前就进行准备。可以让你的团队接受Java/J2EE顾问的指导,并确保这样的指导能够传递到整个其他的团队成员。
最后,还有必要提到以下几点:
·         软件工程的外界影响
·         什么时候进行单元测试,什么时候进行集成测试?
·         设计模式
·         异常处理
结论
总的说来,以上10大风险是你在企业级Java项目开发过程中将面对的主要困难。我也相信在你的旅程中一定还有更多的陷阱,但我比较确信的是我所提到的风险已经涵盖了主要的问题。最后让我们按照优先级重新列举一下10大风险: 
1.        没有真正理解Java, 没有真正理解EJB, 没有真正理解J2EE
2.        过度设计(Over-engineering) 
3.        没有将业务规则和逻辑表现形式相分离
4.        没有在开发环境中进行适当的配置
5.        选择了错误的提供商
6.        不了解你的提供商
7.        设计中没有充分考虑到可伸缩性和产品性能
8.        陈旧的开发过程
9.        没有好的架构方式
10.     项目计划和设计基于市场效应,而脱离了技术现实
最后,让我祝你好运! 

译后记:
我基本上没有做过J2EE项目,但仍有足够勇气翻译这样的文章。在国内软件公司里,极端情况下也许到处都是风险,这样也就无所谓风险了。对于选择J2EE技术路线,自然会有J2EE特有的风险,因此本文中的风险往往也是特别针对J2EE项目的。另外,对于J2EE项目,我们不应该忽视的一点是,其技术上的风险会更大一些。
 

posted @ 2005-10-24 09:25 丁丁 阅读(304) | 评论 (0)编辑 收藏


2005年10月21日

import java.lang.*;
import java.util.*;
import java.io.*;
import java.net.*;

public class SinoDetect {

    static final int GB2312 = 0;
    static final int GBK = 1;
    static final int HZ = 2;
    static final int BIG5 = 3;
    static final int EUC_TW = 4;
    static final int ISO_2022_CN = 5;
    static final int UTF8 = 6;
    static final int UNICODE = 7;
    static final int ASCII = 8;
    static final int OTHER = 9;

    static final int TOTAL_ENCODINGS = 10;


    // Frequency tables to hold the GB, Big5, and EUC-TW character
    // frequencies
    int GBFreq[][];
    int GBKFreq[][];
    int Big5Freq[][];
    int EUC_TWFreq[][];
    //int UnicodeFreq[94][128];

    public static String[] nicename;
    public static String[] codings;


    public SinoDetect() {
 // Initialize the Frequency Table for GB, Big5, EUC-TW
 GBFreq = new int[94][94];
 GBKFreq = new int[126][191];
 Big5Freq = new int[94][158];
 EUC_TWFreq = new int[94][94];

 codings = new String[TOTAL_ENCODINGS];
 codings[GB2312] = "GB2312";
 codings[GBK] = "GBK";
 codings[HZ] = "HZ";
 codings[BIG5] = "BIG5";
 codings[EUC_TW] = "CNS11643";
 codings[ISO_2022_CN] = "ISO2022CN";
 codings[UTF8] = "UTF8";
 codings[UNICODE] = "Unicode";
 codings[ASCII] = "ASCII";
 codings[OTHER] = "OTHER";

 nicename = new String[TOTAL_ENCODINGS];
 nicename[GB2312] = "GB2312";
 nicename[GBK] = "GBK";
 nicename[HZ] = "HZ";
 nicename[BIG5] = "Big5";
 nicename[EUC_TW] = "CNS 11643";
 nicename[ISO_2022_CN] = "ISO 2022-CN";
 nicename[UTF8] = "UTF-8";
 nicename[UNICODE] = "Unicode";
 nicename[ASCII] = "ASCII";
 nicename[OTHER] = "OTHER";

 initialize_frequencies();
    }


  public static void main(String argc[])
  {
   SinoDetect sinodetector;
   int result = OTHER;

   argc = new String[1];
   //argc[0] = "c:\\chinesedata\\codeconvert\\voaunit.txt";
    argc[0] = "中文";
   sinodetector = new SinoDetect();
   if (argc[0].startsWith("http://") == true)
   {
     try {
      result = sinodetector.detectEncoding(new URL(argc[0]));
     }
     catch (Exception e) {
      System.err.println("Bad URL " + e.toString());
     }
   } else {
     //result = sinodetector.detectEncoding(new File(argc[0]));
      result = sinodetector.detectEncoding(argc[0].getBytes());
   }
   System.out.println(nicename[result]);
  }


    /** Function  :  detectEncoding
       Aruguments:  URL
       Returns   :  One of the encodings from the Encoding enumeration
       (GB2312, HZ, BIG5, EUC_TW, ASCII, or OTHER)
       Description: This function looks at the URL contents
       and assigns it a probability score for each encoding type.
       The encoding type with the highest probability is returned.
    */

    public int detectEncoding(URL testurl) {
 byte[] rawtext = new byte[10000];
 int bytesread = 0, byteoffset = 0;
 int guess = OTHER;
 InputStream chinesestream;

 try {
     chinesestream = testurl.openStream();

     while ((bytesread = chinesestream.read(rawtext, byteoffset, rawtext.length - byteoffset)) > 0) {
  byteoffset += bytesread;
     };
     chinesestream.close();
     guess = detectEncoding(rawtext);


 }
 catch (Exception e) {
     System.err.println("Error loading or using URL " + e.toString());
     guess = OTHER;
 }

 return guess;
    }

    /** Function  :  detectEncoding
       Aruguments:  File
       Returns   :  One of the encodings from the Encoding enumeration
       (GB2312, HZ, BIG5, EUC_TW, ASCII, or OTHER)
       Description: This function looks at the file
       and assigns it a probability score for each encoding type.
       The encoding type with the highest probability is returned.
    */

    public int detectEncoding(File testfile) {
 FileInputStream chinesefile;
 byte[] rawtext;

 rawtext = new byte[(int)testfile.length()];
 try {
     chinesefile = new FileInputStream(testfile);
     chinesefile.read(rawtext);
 }
 catch (Exception e) {
     System.err.println("Error: " + e);
 }

 return detectEncoding(rawtext);
    }

 

    /** Function  :  detectEncoding
       Aruguments:  byte array
       Returns   :  One of the encodings from the Encoding enumeration
       (GB2312, HZ, BIG5, EUC_TW, ASCII, or OTHER)
       Description: This function looks at the byte array
       and assigns it a probability score for each encoding type.
       The encoding type with the highest probability is returned.
    */

    public int detectEncoding(byte[] rawtext) {
 int[] scores;
 int index, maxscore = 0;
 int encoding_guess = OTHER;

 scores = new int[TOTAL_ENCODINGS];

 // Assign Scores
 scores[GB2312]      = gb2312_probability(rawtext);
 scores[GBK]         = gbk_probability(rawtext);
 scores[HZ]          = hz_probability(rawtext);
 scores[BIG5]        = big5_probability(rawtext);
 scores[EUC_TW]      = euc_tw_probability(rawtext);
 scores[ISO_2022_CN] = iso_2022_cn_probability(rawtext);
 scores[UTF8]        = utf8_probability(rawtext);
 scores[UNICODE]     = utf16_probability(rawtext);
 scores[ASCII]       = ascii_probability(rawtext);
 scores[OTHER]       = 0;

 // Tabulate Scores
 for (index = 0; index < TOTAL_ENCODINGS; index++) {
     if (scores[index] > maxscore) {
  encoding_guess = index;
  maxscore = scores[index];
     }
 }

 // Return OTHER if nothing scored above 50
 if (maxscore <= 50) {
     encoding_guess = OTHER;
 }

 return encoding_guess;
    }

 


    /* Function:  gb2312_probability
       Argument:  pointer to byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses GB-2312 encoding
    */

    int gb2312_probability(byte[] rawtext) {
 int i, rawtextlen = 0;

 int dbchars = 1, gbchars = 1;
 long gbfreq = 0, totalfreq = 1;
 float rangeval = 0, freqval = 0;
 int row, column;

 // Stage 1:  Check to see if characters fit into acceptable ranges

 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen-1; i++) {
     //System.err.println(rawtext[i]);
     if (rawtext[i] >= 0) {
  //asciichars++;
     } else {
  dbchars++;
  if ((byte)0xA1 <= rawtext[i] && rawtext[i] <= (byte)0xF7 &&
      (byte)0xA1 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xFE)
      {
   gbchars++;
   totalfreq += 500;
   row = rawtext[i] + 256 - 0xA1;
   column = rawtext[i+1] + 256 - 0xA1;
   if (GBFreq[row][column] != 0) {
       gbfreq += GBFreq[row][column];
   } else if (15 <= row && row < 55) {
       gbfreq += 200;
   }

      }
  i++;
     }
 }
 rangeval = 50 * ((float)gbchars/(float)dbchars);
 freqval = 50 * ((float)gbfreq/(float)totalfreq);

 return (int)(rangeval + freqval);
    }


    /* Function:  gb2312_probability
       Argument:  pointer to byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses GB-2312 encoding
    */

    int gbk_probability(byte[] rawtext) {
 int i, rawtextlen = 0;

 int dbchars = 1, gbchars = 1;
 long gbfreq = 0, totalfreq = 1;
 float rangeval = 0, freqval = 0;
 int row, column;

 // Stage 1:  Check to see if characters fit into acceptable ranges
 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen-1; i++) {
     //System.err.println(rawtext[i]);
     if (rawtext[i] >= 0) {
  //asciichars++;
     } else {
  dbchars++;
  if ((byte)0xA1 <= rawtext[i] && rawtext[i] <= (byte)0xF7 &&   // Original GB range
      (byte)0xA1 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xFE)
      {
   gbchars++;
   totalfreq += 500;
   row = rawtext[i] + 256 - 0xA1;
   column = rawtext[i+1] + 256 - 0xA1;

   //System.out.println("original row " + row + " column " + column);
   if (GBFreq[row][column] != 0) {
       gbfreq += GBFreq[row][column];
   } else if (15 <= row && row < 55) {
       gbfreq += 200;
   }

      }
  else if ((byte)0x81 <= rawtext[i] && rawtext[i] <= (byte)0xFE &&   // Extended GB range
    (((byte)0x80 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xFE) ||
     ((byte)0x40 <= rawtext[i+1] && rawtext[i+1] <= (byte)0x7E)))
      {
   gbchars++;
   totalfreq += 500;
   row = rawtext[i] + 256 - 0x81;
   if (0x40 <= rawtext[i+1] && rawtext[i+1] <= 0x7E) {
       column = rawtext[i+1] - 0x40;
   } else {
       column = rawtext[i+1] + 256 - 0x80;
   }
   //System.out.println("extended row " + row + " column " + column + " rawtext[i] " + rawtext[i]);
   if (GBKFreq[row][column] != 0) {
       gbfreq += GBKFreq[row][column];
   }
  }
  i++;
     }
 }
 rangeval = 50 * ((float)gbchars/(float)dbchars);
 freqval = 50 * ((float)gbfreq/(float)totalfreq);

 // For regular GB files, this would give the same score, so I handicap it slightly
 return (int)(rangeval + freqval) - 1;
    }

 

    /* Function:  hz_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses HZ encoding
    */

    int hz_probability(byte[] rawtext) {
 int i, rawtextlen;
 int hzchars = 0, dbchars = 1;
 long hzfreq = 0, totalfreq = 1;
 float rangeval = 0, freqval = 0;
 int hzstart = 0, hzend = 0;
 int row, column;

 rawtextlen = rawtext.length;

 for (i = 0; i < rawtextlen; i++) {
     if (rawtext[i] == '~') {
  if (rawtext[i+1] == '{') {
      hzstart++;
      i+=2;
      while (i < rawtextlen - 1) {
   if (rawtext[i] == 0x0A || rawtext[i] == 0x0D) {
       break;
   } else if (rawtext[i] == '~' && rawtext[i+1] == '}') {
       hzend++;
       i++;
       break;
   } else if ((0x21 <= rawtext[i] && rawtext[i] <= 0x77) &&
       (0x21 <= rawtext[i+1] && rawtext[i+1] <= 0x77)) {
       hzchars+=2;
       row = rawtext[i] - 0x21;
       column = rawtext[i+1] - 0x21;
       totalfreq += 500;
       if (GBFreq[row][column] != 0) {
    hzfreq += GBFreq[row][column];
       } else if (15 <= row && row < 55) {
    hzfreq += 200;
       }
   } else if ((0xA1 <= rawtext[i] && rawtext[i] <= 0xF7) &&
       (0xA1 <= rawtext[i+1] && rawtext[i+1] <= 0xF7)) {
       hzchars+=2;
       row = rawtext[i] + 256 - 0xA1;
       column = rawtext[i+1] + 256 - 0xA1;
       totalfreq += 500;
       if (GBFreq[row][column] != 0) {
    hzfreq += GBFreq[row][column];
       } else if (15 <= row && row < 55) {
    hzfreq += 200;
       }
   }
   dbchars+=2;
   i+=2;
      }
  } else if (rawtext[i+1] == '}') {
      hzend++;
      i++;
  } else if (rawtext[i+1] == '~') {
      i++;
  }
     }

 }

 if (hzstart > 4) {
     rangeval = 50;
 } else if (hzstart > 1) {
     rangeval = 41;
 } else if (hzstart > 0) { // Only 39 in case the sequence happened to occur
     rangeval = 39;        // in otherwise non-Hz text
 } else {
     rangeval = 0;
 }
 freqval = 50 * ((float)hzfreq/(float)totalfreq);

 return (int)(rangeval + freqval);
    }

 


    /** Function:  big5_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses Big5 encoding
    */

    int big5_probability(byte[] rawtext) {
 int score = 0;
 int i, rawtextlen = 0;
 int dbchars = 1, bfchars = 1;
 float rangeval = 0, freqval = 0;
 long bffreq = 0, totalfreq = 1;
 int row, column;

 // Check to see if characters fit into acceptable ranges

 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen-1; i++) {
     if (rawtext[i] >= 0) {
  //asciichars++;
     } else {
  dbchars++;
  if ((byte)0xA1 <= rawtext[i] && rawtext[i] <= (byte)0xF9 &&
      (((byte)0x40 <= rawtext[i+1] && rawtext[i+1] <= (byte)0x7E) ||
       ((byte)0xA1 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xFE)))
      {
   bfchars++;
   totalfreq += 500;
   row = rawtext[i] + 256 - 0xA1;
   if (0x40 <= rawtext[i+1] && rawtext[i+1] <= 0x7E) {
       column = rawtext[i+1] - 0x40;
   } else {
       column = rawtext[i+1] + 256 - 0x61;
   }
   if (Big5Freq[row][column] != 0) {
       bffreq += Big5Freq[row][column];
   } else if (3 <= row && row <= 37) {
       bffreq += 200;
   }
      }
  i++;
     }
 }
 rangeval = 50 * ((float)bfchars/(float)dbchars);
 freqval = 50 * ((float)bffreq/(float)totalfreq);

 return (int)(rangeval + freqval);
    }

 

    /* Function:  euc_tw_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses EUC-TW (CNS 11643) encoding
    */

    int euc_tw_probability(byte[] rawtext) {
 int i, rawtextlen = 0;
 int dbchars = 1, cnschars = 1;
 long cnsfreq = 0, totalfreq = 1;
 float rangeval = 0, freqval = 0;
 int row, column;

 // Check to see if characters fit into acceptable ranges
 // and have expected frequency of use

 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen-1; i++) {
     if (rawtext[i] >= 0) { // in ASCII range
  //asciichars++;
     } else {  // high bit set
  dbchars++;
  if (i + 3 < rawtextlen && (byte)0x8E == rawtext[i] &&
      (byte)0xA1 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xB0 &&
      (byte)0xA1 <= rawtext[i+2] && rawtext[i+2] <= (byte)0xFE &&
      (byte)0xA1 <= rawtext[i+3] && rawtext[i+3] <= (byte)0xFE) { // Planes 1 - 16

      cnschars++;
      //System.out.println("plane 2 or above CNS char");
      // These are all less frequent chars so just ignore freq
      i+=3;
  } else if ((byte)0xA1 <= rawtext[i] && rawtext[i] <= (byte)0xFE && // Plane 1
      (byte)0xA1 <= rawtext[i+1] && rawtext[i+1] <= (byte)0xFE)
      {
   cnschars++;
   totalfreq += 500;
   row = rawtext[i] + 256 - 0xA1;
   column = rawtext[i+1] + 256 - 0xA1;
   if (EUC_TWFreq[row][column] != 0) {
       cnsfreq += EUC_TWFreq[row][column];
   } else if (35 <= row && row <= 92) {
       cnsfreq += 150;
   }
   i++;
      }
     }
 }

 rangeval = 50 * ((float)cnschars/(float)dbchars);
 freqval = 50 * ((float)cnsfreq/(float)totalfreq);

 return (int)(rangeval + freqval);
    }

 

    /* Function:  iso_2022_cn_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses ISO 2022-CN encoding
       WORKS FOR BASIC CASES, BUT STILL NEEDS MORE WORK
    */

    int iso_2022_cn_probability(byte[] rawtext) {
 int i, rawtextlen = 0;
 int dbchars = 1, isochars = 1;
 long isofreq = 0, totalfreq = 1;
 float rangeval = 0, freqval = 0;
 int row, column;

 // Check to see if characters fit into acceptable ranges
 // and have expected frequency of use

 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen-1; i++) {
     if (rawtext[i] == (byte)0x1B && i+3 < rawtextlen) { // Escape char ESC
  if (rawtext[i+1] == (byte)0x24 && rawtext[i+2] == 0x29 &&
      rawtext[i+3] == (byte)0x41) {  // GB Escape  $ ) A
      i += 4;
      while (rawtext[i] != (byte)0x1B) {
   dbchars++;
   if ((0x21 <= rawtext[i] && rawtext[i] <= 0x77) &&
       (0x21 <= rawtext[i+1] && rawtext[i+1] <= 0x77)) {
       isochars++;
       row = rawtext[i] - 0x21;
       column = rawtext[i+1] - 0x21;
       totalfreq += 500;
       if (GBFreq[row][column] != 0) {
    isofreq += GBFreq[row][column];
       } else if (15 <= row && row < 55) {
    isofreq += 200;
       }
       i++;
   }
   i++;
      }
  } else if (i+3 < rawtextlen &&
      rawtext[i+1] == (byte)0x24 && rawtext[i+2] == (byte)0x29 &&
      rawtext[i+3] == (byte)0x47) {
      // CNS Escape $ ) G
      i+=4;
      while (rawtext[i] != (byte)0x1B) {
   dbchars++;
   if ((byte)0x21 <= rawtext[i] && rawtext[i] <= (byte)0x7E &&
       (byte)0x21 <= rawtext[i+1] && rawtext[i+1] <= (byte)0x7E)
       {
    isochars++;
    totalfreq += 500;
    row = rawtext[i] - 0x21;
    column = rawtext[i+1] - 0x21;
    if (EUC_TWFreq[row][column] != 0) {
        isofreq += EUC_TWFreq[row][column];
    } else if (35 <= row && row <= 92) {
        isofreq += 150;
    }
    i++;
       }
   i++;
      }
  }
  if (rawtext[i] == (byte)0x1B && i+2 < rawtextlen &&
      rawtext[i+1] == (byte)0x28 && rawtext[i+2] == (byte)0x42) { // ASCII:  ESC ( B
      i+=2;
  }
     }
 }
 rangeval = 50 * ((float)isochars/(float)dbchars);
 freqval = 50 * ((float)isofreq/(float)totalfreq);

 //System.out.println("isochars dbchars isofreq totalfreq " + isochars + " " + dbchars + " " + isofreq + " " + totalfreq + " " + rangeval + " " + freqval);

 return (int)(rangeval + freqval);
 //return 0;
    }

 

    /* Function:  utf8_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses UTF-8 encoding of Unicode
    */

    int utf8_probability(byte[] rawtext) {
 int score = 0;
 int i, rawtextlen = 0;
 int goodbytes = 0, asciibytes = 0;

 // Maybe also use UTF8 Byte Order Mark:  EF BB BF

 // Check to see if characters fit into acceptable ranges
 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen; i++) {
     if ((rawtext[i] & (byte)0x7F) == rawtext[i]) {  // One byte
  asciibytes++;
  // Ignore ASCII, can throw off count
     } else if (-64 <= rawtext[i] && rawtext[i] <= -33 && // Two bytes
         i+1 < rawtextlen &&
         -128 <= rawtext[i+1] && rawtext[i+1] <= -65) {
  goodbytes += 2;
  i++;
     } else if (-32 <= rawtext[i] && rawtext[i] <= -17 && // Three bytes
         i+2 < rawtextlen &&
         -128 <= rawtext[i+1] && rawtext[i+1] <= -65 &&
         -128 <= rawtext[i+2] && rawtext[i+2] <= -65) {
  goodbytes += 3;
  i+=2;
     }
 }

 if (asciibytes == rawtextlen) { return 0; }

 score = (int)(100 * ((float)goodbytes/(float)(rawtextlen-asciibytes)));

 // If not above 98, reduce to zero to prevent coincidental matches
 // Allows for some (few) bad formed sequences
 if (score > 98) {
     return score;
 } else if (score > 95 && goodbytes > 30) {
     return score;
 } else {
     return 0;
 }

    }


    /* Function:  utf16_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses UTF-16 encoding of Unicode, guess based on BOM
       // NOT VERY GENERAL, NEEDS MUCH MORE WORK
    */

    int utf16_probability(byte[] rawtext) {
 //int score = 0;
 //int i, rawtextlen = 0;
 //int goodbytes = 0, asciibytes = 0;

 if (((byte)0xFE == rawtext[0] && (byte)0xFF == rawtext[1]) ||  // Big-endian
     ((byte)0xFF == rawtext[0] && (byte)0xFE == rawtext[1])) {  // Little-endian
     return 100;
 }

 return 0;

 /* // Check to see if characters fit into acceptable ranges
 rawtextlen = rawtext.length;
 for (i = 0; i < rawtextlen; i++) {
     if ((rawtext[i] & (byte)0x7F) == rawtext[i]) {  // One byte
  goodbytes += 1;
  asciibytes++;
     } else if ((rawtext[i] & (byte)0xDF) == rawtext[i]) { // Two bytes
  if (i+1 < rawtextlen &&
      (rawtext[i+1] & (byte)0xBF) == rawtext[i+1]) {
      goodbytes += 2;
      i++;
  }
     } else if ((rawtext[i] & (byte)0xEF) == rawtext[i]) { // Three bytes
  if (i+2 < rawtextlen &&
      (rawtext[i+1] & (byte)0xBF) == rawtext[i+1] &&
      (rawtext[i+2] & (byte)0xBF) == rawtext[i+2]) {
      goodbytes += 3;
      i+=2;
  }
     }
 }

 score = (int)(100 * ((float)goodbytes/(float)rawtext.length));

 // An all ASCII file is also a good UTF8 file, but I'd rather it
 // get identified as ASCII.  Can delete following 3 lines otherwise
 if (goodbytes == asciibytes) {
     score = 0;
 }

 // If not above 90, reduce to zero to prevent coincidental matches
 if (score > 90) {
     return score;
 } else {
     return 0;
     } */

    }

 

    /* Function:  ascii_probability
       Argument:  byte array
       Returns :  number from 0 to 100 representing probability
       text in array uses all ASCII
       Description:  Sees if array has any characters not in
       ASCII range, if so, score is reduced
    */

    int ascii_probability(byte[] rawtext) {
 int score = 70;
 int i, rawtextlen;

 rawtextlen = rawtext.length;

 for (i = 0; i < rawtextlen; i++) {
     if (rawtext[i] < 0) {
  score = score - 5;
     } else if (rawtext[i] == (byte)0x1B) { // ESC (used by ISO 2022)
  score = score - 5;
     }
 }

 return score;
    }

 

    void initialize_frequencies() {
 int i, j;

 for (i = 0; i < 93; i++) {
     for (j = 0; j < 93; j++) {
  GBFreq[i][j] = 0;
     }
 }

 for (i = 0; i < 126; i++) {
     for (j = 0; j < 191; j++) {
  GBKFreq[i][j] = 0;
     }
 }

 for (i = 0; i < 93; i++) {
     for (j = 0; j < 157; j++) {
  Big5Freq[i][j] = 0;
     }
 }

 for (i = 0; i < 93; i++) {
     for (j = 0; j < 93; j++) {
  EUC_TWFreq[i][j] = 0;
     }
 }

 GBFreq[20][35] = 599; GBFreq[49][26] = 598;
 GBFreq[41][38] = 597; GBFreq[17][26] = 596;
 GBFreq[32][42] = 595; GBFreq[39][42] = 594;
 GBFreq[45][49] = 593; GBFreq[51][57] = 592;
 GBFreq[50][47] = 591; GBFreq[42][90] = 590;
 GBFreq[52][65] = 589; GBFreq[53][47] = 588;
 GBFreq[19][82] = 587; GBFreq[31][19] = 586;
 GBFreq[40][46] = 585; GBFreq[24][89] = 584;
 GBFreq[23][85] = 583; GBFreq[20][28] = 582;
 GBFreq[42][20] = 581; GBFreq[34][38] = 580;
 GBFreq[45][9] = 579; GBFreq[54][50] = 578;
 GBFreq[25][44] = 577; GBFreq[35][66] = 576;
 GBFreq[20][55] = 575; GBFreq[18][85] = 574;
 GBFreq[20][31] = 573; GBFreq[49][17] = 572;
 GBFreq[41][16] = 571; GBFreq[35][73] = 570;
 GBFreq[20][34] = 569; GBFreq[29][44] = 568;
 GBFreq[35][38] = 567; GBFreq[49][9] = 566;
 GBFreq[46][33] = 565; GBFreq[49][51] = 564;
 GBFreq[40][89] = 563; GBFreq[26][64] = 562;
 GBFreq[54][51] = 561; GBFreq[54][36] = 560;
 GBFreq[39][4] = 559; GBFreq[53][13] = 558;
 GBFreq[24][92] = 557; GBFreq[27][49] = 556;
 GBFreq[48][6] = 555; GBFreq[21][51] = 554;
 GBFreq[30][40] = 553; GBFreq[42][92] = 552;
 GBFreq[31][78] = 551; GBFreq[25][82] = 550;
 GBFreq[47][0] = 549; GBFreq[34][19] = 548;
 GBFreq[47][35] = 547; GBFreq[21][63] = 546;
 GBFreq[43][75] = 545; GBFreq[21][87] = 544;
 GBFreq[35][59] = 543; GBFreq[25][34] = 542;
 GBFreq[21][27] = 541; GBFreq[39][26] = 540;
 GBFreq[34][26] = 539; GBFreq[39][52] = 538;
 GBFreq[50][57] = 537; GBFreq[37][79] = 536;
 GBFreq[26][24] = 535; GBFreq[22][1] = 534;
 GBFreq[18][40] = 533; GBFreq[41][33] = 532;
 GBFreq[53][26] = 531; GBFreq[54][86] = 530;
 GBFreq[20][16] = 529; GBFreq[46][74] = 528;
 GBFreq[30][19] = 527; GBFreq[45][35] = 526;
 GBFreq[45][61] = 525; GBFreq[30][9] = 524;
 GBFreq[41][53] = 523; GBFreq[41][13] = 522;
 GBFreq[50][34] = 521; GBFreq[53][86] = 520;
 GBFreq[47][47] = 519; GBFreq[22][28] = 518;
 GBFreq[50][53] = 517; GBFreq[39][70] = 516;
 GBFreq[38][15] = 515; GBFreq[42][88] = 514;
 GBFreq[16][29] = 513; GBFreq[27][90] = 512;
 GBFreq[29][12] = 511; GBFreq[44][22] = 510;
 GBFreq[34][69] = 509; GBFreq[24][10] = 508;
 GBFreq[44][11] = 507; GBFreq[39][92] = 506;
 GBFreq[49][48] = 505; GBFreq[31][46] = 504;
 GBFreq[19][50] = 503; GBFreq[21][14] = 502;
 GBFreq[32][28] = 501; GBFreq[18][3] = 500;
 GBFreq[53][9] = 499; GBFreq[34][80] = 498;
 GBFreq[48][88] = 497; GBFreq[46][53] = 496;
 GBFreq[22][53] = 495; GBFreq[28][10] = 494;
 GBFreq[44][65] = 493; GBFreq[20][10] = 492;
 GBFreq[40][76] = 491; GBFreq[47][8] = 490;
 GBFreq[50][74] = 489; GBFreq[23][62] = 488;
 GBFreq[49][65] = 487; GBFreq[28][87] = 486;
 GBFreq[15][48] = 485; GBFreq[22][7] = 484;
 GBFreq[19][42] = 483; GBFreq[41][20] = 482;
 GBFreq[26][55] = 481; GBFreq[21][93] = 480;
 GBFreq[31][76] = 479; GBFreq[34][31] = 478;
 GBFreq[20][66] = 477; GBFreq[51][33] = 476;
 GBFreq[34][86] = 475; GBFreq[37][67] = 474;
 GBFreq[53][53] = 473; GBFreq[40][88] = 472;
 GBFreq[39][10] = 471; GBFreq[24][3] = 470;
 GBFreq[27][25] = 469; GBFreq[26][15] = 468;
 GBFreq[21][88] = 467; GBFreq[52][62] = 466;
 GBFreq[46][81] = 465; GBFreq[38][72] = 464;
 GBFreq[17][30] = 463; GBFreq[52][92] = 462;
 GBFreq[34][90] = 461; GBFreq[21][7] = 460;
 GBFreq[36][13] = 459; GBFreq[45][41] = 458;
 GBFreq[32][5] = 457; GBFreq[26][89] = 456;
 GBFreq[23][87] = 455; GBFreq[20][39] = 454;
 GBFreq[27][23] = 453; GBFreq[25][59] = 452;
 GBFreq[49][20] = 451; GBFreq[54][77] = 450;
 GBFreq[27][67] = 449; GBFreq[47][33] = 448;
 GBFreq[41][17] = 447; GBFreq[19][81] = 446;
 GBFreq[16][66] = 445; GBFreq[45][26] = 444;
 GBFreq[49][81] = 443; GBFreq[53][55] = 442;
 GBFreq[16][26] = 441; GBFreq[54][62] = 440;
 GBFreq[20][70] = 439; GBFreq[42][35] = 438;
 GBFreq[20][57] = 437; GBFreq[34][36] = 436;
 GBFreq[46][63] = 435; GBFreq[19][45] = 434;
 GBFreq[21][10] = 433; GBFreq[52][93] = 432;
 GBFreq[25][2] = 431; GBFreq[30][57] = 430;
 GBFreq[41][24] = 429; GBFreq[28][43] = 428;
 GBFreq[45][86] = 427; GBFreq[51][56] = 426;
 GBFreq[37][28] = 425; GBFreq[52][69] = 424;
 GBFreq[43][92] = 423; GBFreq[41][31] = 422;
 GBFreq[37][87] = 421; GBFreq[47][36] = 420;
 GBFreq[16][16] = 419; GBFreq[40][56] = 418;
 GBFreq[24][55] = 417; GBFreq[17][1] = 416;
 GBFreq[35][57] = 415; GBFreq[27][50] = 414;
 GBFreq[26][14] = 413; GBFreq[50][40] = 412;
 GBFreq[39][19] = 411; GBFreq[19][89] = 410;
GBFreq[29][91] = 409; GBFreq[17][89] = 408;
GBFreq[39][74] = 407; GBFreq[46][39] = 406;
GBFreq[40][28] = 405; GBFreq[45][68] = 404;
GBFreq[43][10] = 403; GBFreq[42][13] = 402;
GBFreq[44][81] = 401; GBFreq[41][47] = 400;
GBFreq[48][58] = 399; GBFreq[43][68] = 398;
GBFreq[16][79] = 397; GBFreq[19][5] = 396;
GBFreq[54][59] = 395; GBFreq[17][36] = 394;
GBFreq[18][0] = 393; GBFreq[41][5] = 392;
GBFreq[41][72] = 391; GBFreq[16][39] = 390;
GBFreq[54][0] = 389; GBFreq[51][16] = 388;
GBFreq[29][36] = 387; GBFreq[47][5] = 386;
GBFreq[47][51] = 385; GBFreq[44][7] = 384;
GBFreq[35][30] = 383; GBFreq[26][9] = 382;
GBFreq[16][7] = 381; GBFreq[32][1] = 380;
GBFreq[33][76] = 379; GBFreq[34][91] = 378;
GBFreq[52][36] = 377; GBFreq[26][77] = 376;
GBFreq[35][48] = 375; GBFreq[40][80] = 374;
GBFreq[41][92] = 373; GBFreq[27][93] = 372;
GBFreq[15][17] = 371; GBFreq[16][76] = 370;
GBFreq[51][12] = 369; GBFreq[18][20] = 368;
GBFreq[15][54] = 367; GBFreq[50][5] = 366;
GBFreq[33][22] = 365; GBFreq[37][57] = 364;
GBFreq[28][47] = 363; GBFreq[42][31] = 362;
GBFreq[18][2] = 361; GBFreq[43][64] = 360;
GBFreq[23][47] = 359; GBFreq[28][79] = 358;
GBFreq[25][45] = 357; GBFreq[23][91] = 356;
GBFreq[22][19] = 355; GBFreq[25][46] = 354;
GBFreq[22][36] = 353; GBFreq[54][85] = 352;
GBFreq[46][20] = 351; GBFreq[27][37] = 350;
GBFreq[26][81] = 349; GBFreq[42][29] = 348;
GBFreq[31][90] = 347; GBFreq[41][59] = 346;
GBFreq[24][65] = 345; GBFreq[44][84] = 344;
GBFreq[24][90] = 343; GBFreq[38][54] = 342;
GBFreq[28][70] = 341; GBFreq[27][15] = 340;
GBFreq[28][80] = 339; GBFreq[29][8] = 338;
GBFreq[45][80] = 337; GBFreq[53][37] = 336;
GBFreq[28][65] = 335; GBFreq[23][86] = 334;
GBFreq[39][45] = 333; GBFreq[53][32] = 332;
GBFreq[38][68] = 331; GBFreq[45][78] = 330;
GBFreq[43][7] = 329; GBFreq[46][82] = 328;
GBFreq[27][38] = 327; GBFreq[16][62] = 326;
GBFreq[24][17] = 325; GBFreq[22][70] = 324;
GBFreq[52][28] = 323; GBFreq[23][40] = 322;
GBFreq[28][50] = 321; GBFreq[42][91] = 320;
GBFreq[47][76] = 319; GBFreq[15][42] = 318;
GBFreq[43][55] = 317; GBFreq[29][84] = 316;
GBFreq[44][90] = 315; GBFreq[53][16] = 314;
GBFreq[22][93] = 313; GBFreq[34][10] = 312;
GBFreq[32][53] = 311; GBFreq[43][65] = 310;
GBFreq[28][7] = 309; GBFreq[35][46] = 308;
GBFreq[21][39] = 307; GBFreq[44][18] = 306;
GBFreq[40][10] = 305; GBFreq[54][53] = 304;
GBFreq[38][74] = 303; GBFreq[28][26] = 302;
GBFreq[15][13] = 301; GBFreq[39][34] = 300;
GBFreq[39][46] = 299; GBFreq[42][66] = 298;
GBFreq[33][58] = 297; GBFreq[15][56] = 296;
GBFreq[18][51] = 295; GBFreq[49][68] = 294;
GBFreq[30][37] = 293; GBFreq[51][84] = 292;
GBFreq[51][9] = 291; GBFreq[40][70] = 290;
GBFreq[41][84] = 289; GBFreq[28][64] = 288;
GBFreq[32][88] = 287; GBFreq[24][5] = 286;
GBFreq[53][23] = 285; GBFreq[42][27] = 284;
GBFreq[22][38] = 283; GBFreq[32][86] = 282;
GBFreq[34][30] = 281; GBFreq[38][63] = 280;
GBFreq[24][59] = 279; GBFreq[22][81] = 278;
GBFreq[32][11] = 277; GBFreq[51][21] = 276;
GBFreq[54][41] = 275; GBFreq[21][50] = 274;
GBFreq[23][89] = 273; GBFreq[19][87] = 272;
GBFreq[26][7] = 271; GBFreq[30][75] = 270;
GBFreq[43][84] = 269; GBFreq[51][25] = 268;
GBFreq[16][67] = 267; GBFreq[32][9] = 266;
GBFreq[48][51] = 265; GBFreq[39][7] = 264;
GBFreq[44][88] = 263; GBFreq[52][24] = 262;
GBFreq[23][34] = 261; GBFreq[32][75] = 260;
GBFreq[19][10] = 259; GBFreq[28][91] = 258;
GBFreq[32][83] = 257; GBFreq[25][75] = 256;
GBFreq[53][45] = 255; GBFreq[29][85] = 254;
GBFreq[53][59] = 253; GBFreq[16][2] = 252;
GBFreq[19][78] = 251; GBFreq[15][75] = 250;
GBFreq[51][42] = 249; GBFreq[45][67] = 248;
GBFreq[15][74] = 247; GBFreq[25][81] = 246;
GBFreq[37][62] = 245; GBFreq[16][55] = 244;
GBFreq[18][38] = 243; GBFreq[23][23] = 242;

posted @ 2005-10-21 19:50 丁丁 阅读(2025) | 评论 (0)编辑 收藏

摘自:http://www.j2eesp.com


一、安装篇 

  jspSmartUpload是由www.jspsmart.com网站开发的一个可免费使用的全功能的文件上传下载组件,适于嵌入执行上传下载操作的JSP文件中。该组件有以下几个特点: 

1、使用简单。在JSP文件中仅仅书写三五行JAVA代码就可以搞定文件的上传或下载,方便。 

2、能全程控制上传。利用jspSmartUpload组件提供的对象及其操作方法,可以获得全部上传文件的信息(包括文件名,大小,类型,扩展名,文件数据等),方便存取。 

3、能对上传的文件在大小、类型等方面做出限制。如此可以滤掉不符合要求的文件。 

4、下载灵活。仅写两行代码,就能把Web服务器变成文件服务器。不管文件在Web服务器的目录下或在其它任何目录下,都可以利用jspSmartUpload进行下载。 

5、能将文件上传到数据库中,也能将数据库中的数据下载下来。这种功能针对的是MYSQL数据库,因为不具有通用性,所以本文不准备举例介绍这种用法。 

  jspSmartUpload组件可以从www.jspsmart.com网站上自由下载,压缩包的名字是jspSmartUpload.zip。下载后,用WinZip或WinRAR将其解压到Tomcat的webapps目录下(本文以Tomcat服务器为例进行介绍)。解压后,将webapps/jspsmartupload目录下的子目录Web-inf名字改为全大写的WEB-INF,这样一改jspSmartUpload类才能使用。因为Tomcat对文件名大小写敏感,它要求Web应用程序相关的类所在目录为WEB-INF,且必须是大写。接着重新启动Tomcat,这样就可以在JSP文件中使用jspSmartUpload组件了。 

  注意,按上述方法安装后,只有webapps/jspsmartupload目录下的程序可以使用jspSmartUpload组件,如果想让Tomcat服务器的所有Web应用程序都能用它,必须做如下工作: 

1.进入命令行状态,将目录切换到Tomcat的webapps/jspsmartupload/WEB-INF目录下。 

2.运行JAR打包命令:jar cvf jspSmartUpload.jar com 

(也可以打开资源管理器,切换到当前目录,用WinZip将com目录下的所有文件压缩成jspSmartUpload.zip,然后将jspSmartUpload.zip换名为jspSmartUpload.jar文件即可。) 

3.将jspSmartUpload.jar拷贝到Tomcat的shared/lib目录下。 

二、相关类说明篇 

㈠ File类 

  这个类包装了一个上传文件的所有信息。通过它,可以得到上传文件的文件名、文件大小、扩展名、文件数据等信息。 

  File类主要提供以下方法: 

1、saveAs作用:将文件换名另存。 

原型: 

public void saveAs(java.lang.String destFilePathName) 

或 

public void saveAs(java.lang.String destFilePathName, int optionSaveAs) 

其中,destFilePathName是另存的文件名,optionSaveAs是另存的选项,该选项有三个值,分别是SAVEAS_PHYSICAL,SAVEAS_VIRTUAL,SAVEAS_AUTO。SAVEAS_PHYSICAL表明以操作系统的根目录为文件根目录另存文件,SAVEAS_VIRTUAL表明以Web应用程序的根目录为文件根目录另存文件,SAVEAS_AUTO则表示让组件决定,当Web应用程序的根目录存在另存文件的目录时,它会选择SAVEAS_VIRTUAL,否则会选择SAVEAS_PHYSICAL。 

例如,saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)执行后若Web服务器安装在C盘,则另存的文件名实际是c:\upload\sample.zip。而saveAs("/upload/sample.zip",SAVEAS_VIRTUAL)执行后若Web应用程序的根目录是webapps/jspsmartupload,则另存的文件名实际是webapps/jspsmartupload/upload/sample.zip。saveAs("/upload/sample.zip",SAVEAS_AUTO)执行时若Web应用程序根目录下存在upload目录,则其效果同saveAs("/upload/sample.zip",SAVEAS_VIRTUAL),否则同saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)。 

建议:对于Web程序的开发来说,最好使用SAVEAS_VIRTUAL,以便移植。 

2、isMissing 

作用:这个方法用于判断用户是否选择了文件,也即对应的表单项是否有值。选择了文件时,它返回false。未选文件时,它返回true。 

原型:public boolean isMissing() 

3、getFieldName 

作用:取HTML表单中对应于此上传文件的表单项的名字。 

原型:public String getFieldName() 

4、getFileName 

作用:取文件名(不含目录信息) 

原型:public String getFileName() 

5、getFilePathName 

作用:取文件全名(带目录) 

原型:public String getFilePathName 

6、getFileExt 

作用:取文件扩展名(后缀) 

原型:public String getFileExt() 

7、getSize 

作用:取文件长度(以字节计) 

原型:public int getSize() 

8、getBinaryData 

作用:取文件数据中指定位移处的一个字节,用于检测文件等处理。 

原型:public byte getBinaryData(int index)。其中,index表示位移,其值在0到getSize()-1之间。 

㈡ Files类 

  这个类表示所有上传文件的集合,通过它可以得到上传文件的数目、大小等信息。有以下方法: 

1、getCount 

作用:取得上传文件的数目。 

原型:public int getCount() 

2、getFile 

作用:取得指定位移处的文件对象File(这是com.jspsmart.upload.File,不是java.io.File,注意区分)。 

原型:public File getFile(int index)。其中,index为指定位移,其值在0到getCount()-1之间。 

3、getSize 

作用:取得上传文件的总长度,可用于限制一次性上传的数据量大小。 

原型:public long getSize() 

4、getCollection 

作用:将所有上传文件对象以Collection的形式返回,以便其它应用程序引用,浏览上传文件信息。 

原型:public Collection getCollection() 

5、getEnumeration 

作用:将所有上传文件对象以Enumeration(枚举)的形式返回,以便其它应用程序浏览上传文件信息。 

原型:public Enumeration getEnumeration() 

㈢ Request类 

  这个类的功能等同于JSP内置的对象request。只所以提供这个类,是因为对于文件上传表单,通过request对象无法获得表单项的值,必须通过jspSmartUpload组件提供的Request对象来获取。该类提供如下方法: 

1、getParameter 

作用:获取指定参数之值。当参数不存在时,返回值为null。 

原型:public String getParameter(String name)。其中,name为参数的名字。 

2、getParameterValues 

作用:当一个参数可以有多个值时,用此方法来取其值。它返回的是一个字符串数组。当参数不存在时,返回值为null。 

原型:public String[] getParameterValues(String name)。其中,name为参数的名字。 

3、getParameterNames 

作用:取得Request对象中所有参数的名字,用于遍历所有参数。它返回的是一个枚举型的对象。 

原型:public Enumeration getParameterNames() 

㈣ SmartUpload类这个类完成上传下载工作。 

A.上传与下载共用的方法: 

只有一个:initialize。 

作用:执行上传下载的初始化工作,必须第一个执行。 

原型:有多个,主要使用下面这个: 

public final void initialize(javax.servlet.jsp.PageContext pageContext) 

其中,pageContext为JSP页面内置对象(页面上下文)。 

B.上传文件使用的方法: 

1、upload 

作用:上传文件数据。对于上传操作,第一步执行initialize方法,第二步就要执行这个方法。 

原型:public void upload() 

2、save 

作用:将全部上传文件保存到指定目录下,并返回保存的文件个数。 

原型:public int save(String destPathName) 

和public int save(String destPathName,int option) 

其中,destPathName为文件保存目录,option为保存选项,它有三个值,分别是SAVE_PHYSICAL,SAVE_VIRTUAL和SAVE_AUTO。(同File类的saveAs方法的选项之值类似)SAVE_PHYSICAL指示组件将文件保存到以操作系统根目录为文件根目录的目录下,SAVE_VIRTUAL指示组件将文件保存到以Web应用程序根目录为文件根目录的目录下,而SAVE_AUTO则表示由组件自动选择。 

注:save(destPathName)作用等同于save(destPathName,SAVE_AUTO)。 

3、getSize 

作用:取上传文件数据的总长度 

原型:public int getSize() 

4、getFiles 

作用:取全部上传文件,以Files对象形式返回,可以利用Files类的操作方法来获得上传文件的数目等信息。 

原型:public Files getFiles() 

5、getRequest 

作用:取得Request对象,以便由此对象获得上传表单参数之值。 

原型:public Request getRequest() 

6、setAllowedFilesList 

作用:设定允许上传带有指定扩展名的文件,当上传过程中有文件名不允许时,组件将抛出异常。 

原型:public void setAllowedFilesList(String allowedFilesList) 

其中,allowedFilesList为允许上传的文件扩展名列表,各个扩展名之间以逗号分隔。如果想允许上传那些没有扩展名的文件,可以用两个逗号表示。例如:setAllowedFilesList("doc,txt,,")将允许上传带doc和txt扩展名的文件以及没有扩展名的文件。 

7、setDeniedFilesList 

作用:用于限制上传那些带有指定扩展名的文件。若有文件扩展名被限制,则上传时组件将抛出异常。 

原型:public void setDeniedFilesList(String deniedFilesList) 

其中,deniedFilesList为禁止上传的文件扩展名列表,各个扩展名之间以逗号分隔。如果想禁止上传那些没有扩展名的文件,可以用两个逗号来表示。例如:setDeniedFilesList("exe,bat,,")将禁止上传带exe和bat扩展名的文件以及没有扩展名的文件。 

8、setMaxFileSize 

作用:设定每个文件允许上传的最大长度。 

原型:public void setMaxFileSize(long maxFileSize) 

其中,maxFileSize为为每个文件允许上传的最大长度,当文件超出此长度时,将不被上传。 

9、setTotalMaxFileSize 

作用:设定允许上传的文件的总长度,用于限制一次性上传的数据量大小。 

原型:public void setTotalMaxFileSize(long totalMaxFileSize) 

其中,totalMaxFileSize为允许上传的文件的总长度。



1、setContentDisposition 

作用:将数据追加到MIME文件头的CONTENT-DISPOSITION域。jspSmartUpload组件会在返回下载的信息时自动填写MIME文件头的CONTENT-DISPOSITION域,如果用户需要添加额外信息,请用此方法。 

原型:public void setContentDisposition(String contentDisposition) 

其中,contentDisposition为要添加的数据。如果contentDisposition为null,则组件将自动添加"attachment;",以表明将下载的文件作为附件,结果是IE浏览器将会提示另存文件,而不是自动打开这个文件(IE浏览器一般根据下载的文件扩展名决定执行什么操作,扩展名为doc的将用word程序打开,扩展名为pdf的将用acrobat程序打开,等等)。 

2、downloadFile 

作用:下载文件。 

原型:共有以下三个原型可用,第一个最常用,后两个用于特殊情况下的文件下载(如更改内容类型,更改另存的文件名)。 

① public void downloadFile(String sourceFilePathName) 

其中,sourceFilePathName为要下载的文件名(带目录的文件全名) 

② public void downloadFile(String sourceFilePathName,String contentType) 

其中,sourceFilePathName为要下载的文件名(带目录的文件全名),contentType为内容类型(MIME格式的文件类型信息,可被浏览器识别)。 

③ public void downloadFile(String sourceFilePathName,String contentType,String destFileName) 

其中,sourceFilePathName为要下载的文件名(带目录的文件全名),contentType为内容类型(MIME格式的文件类型信息,可被浏览器识别),destFileName为下载后默认的另存文件名。 

三、文件上传篇 

㈠ 表单要求 

对于上传文件的FORM表单,有两个要求: 

1、METHOD应用POST,即METHOD="POST"。 

2、增加属性:ENCTYPE="multipart/form-data" 

下面是一个用于上传文件的FORM表单的例子: 



<FORM METHOD="POST" ENCTYPE="multipart/form-data" 
ACTION="/jspSmartUpload/upload.jsp">
<INPUT TYPE="FILE" NAME="MYFILE">
<INPUT TYPE="SUBMIT">
</FORM>
 


㈡ 上传的例子 

1、上传页面upload.html 

本页面提供表单,让用户选择要上传的文件,点击"上传"按钮执行上传操作。 

页面源码如下: 

<!--
    文件名:upload.html
作  者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
-->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>文件上传</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<p> </p>
<p align="center">上传文件选择</p>
<FORM METHOD="POST" ACTION="jsp/do_upload.jsp"
ENCTYPE="multipart/form-data">
<input type="hidden" name="TEST" value="good">
  <table width="75%" border="1" align="center">
    <tr> 
      <td><div align="center">1、 
          <input type="FILE" name="FILE1" size="30">
        </div></td>
    </tr>
    <tr> 
      <td><div align="center">2、 
          <input type="FILE" name="FILE2" size="30">
        </div></td>
    </tr>
    <tr> 
      <td><div align="center">3、 
          <input type="FILE" name="FILE3" size="30">
        </div></td>
    </tr>
    <tr> 
      <td><div align="center">4、 
          <input type="FILE" name="FILE4" size="30">
        </div></td>
    </tr>
    <tr> 
      <td><div align="center">
          <input type="submit" name="Submit" value="上传它!">
        </div></td>
    </tr>
  </table>
</FORM>
</body>
</html>
 


2、上传处理页面do_upload.jsp 

本页面执行文件上传操作。页面源码中详细介绍了上传方法的用法,在此不赘述了。 

页面源码如下: 

<%--
文件名:do_upload.jsp
作  者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
--%>
<%@ page contentType="text/html; charset=gb2312" language="java" 
import="java.util.*,com.jspsmart.upload.*" errorPage="" %>
<html>
<head>
<title>文件上传处理页面</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body>
<%
// 新建一个SmartUpload对象
SmartUpload su = new SmartUpload();
// 上传初始化
su.initialize(pageContext);
// 设定上传限制
// 1.限制每个上传文件的最大长度。
// su.setMaxFileSize(10000);
// 2.限制总上传数据的长度。
// su.setTotalMaxFileSize(20000);
// 3.设定允许上传的文件(通过扩展名限制),仅允许doc,txt文件。
// su.setAllowedFilesList("doc,txt");
// 4.设定禁止上传的文件(通过扩展名限制),禁止上传带有exe,bat,
jsp,htm,html扩展名的文件和没有扩展名的文件。
// su.setDeniedFilesList("exe,bat,jsp,htm,html,,");
// 上传文件
su.upload();
// 将上传文件全部保存到指定目录
int count = su.save("/upload");
out.println(count+"个文件上传成功!<br>");

// 利用Request对象获取参数之值
out.println("TEST="+su.getRequest().getParameter("TEST")
+"<BR><BR>");

// 逐一提取上传文件信息,同时可保存文件。
for (int i=0;i<su.getFiles().getCount();i++)
{
com.jspsmart.upload.File file = su.getFiles().getFile(i);

// 若文件不存在则继续
if (file.isMissing()) continue;

// 显示当前文件信息
out.println("<TABLE BORDER=1>");
out.println("<TR><TD>表单项名(FieldName)</TD><TD>"
+ file.getFieldName() + "</TD></TR>");
out.println("<TR><TD>文件长度(Size)</TD><TD>" + 
file.getSize() + "</TD></TR>");
out.println("<TR><TD>文件名(FileName)</TD><TD>" 
+ file.getFileName() + "</TD></TR>");
out.println("<TR><TD>文件扩展名(FileExt)</TD><TD>" 
+ file.getFileExt() + "</TD></TR>");
out.println("<TR><TD>文件全名(FilePathName)</TD><TD>"
+ file.getFilePathName() + "</TD></TR>");
out.println("</TABLE><BR>");

// 将文件另存
// file.saveAs("/upload/" + myFile.getFileName());
// 另存到以WEB应用程序的根目录为文件根目录的目录下
// file.saveAs("/upload/" + myFile.getFileName(), 
su.SAVE_VIRTUAL);
// 另存到操作系统的根目录为文件根目录的目录下
// file.saveAs("c:\\temp\\" + myFile.getFileName(), 
su.SAVE_PHYSICAL);

}
%>
</body>
</html>
 


四、文件下载篇 

1、下载链接页面download.html 

页面源码如下: 

<!--
文件名:download.html
作  者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
-->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>下载</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>
<body>
<a href="jsp/do_download.jsp">点击下载</a>
</body>
</html>
 


2、下载处理页面do_download.jsp do_download.jsp展示了如何利用jspSmartUpload组件来下载文件,从下面的源码中就可以看到,下载何其简单。 

源码如下: 

<%@ page contentType="text/html;charset=gb2312" 
import="com.jspsmart.upload.*" %><%
// 新建一个SmartUpload对象
SmartUpload su = new SmartUpload();
// 初始化
su.initialize(pageContext);
// 设定contentDisposition为null以禁止浏览器自动打开文件,
//保证点击链接后是下载文件。若不设定,则下载的文件扩展名为
//doc时,浏览器将自动用word打开它。扩展名为pdf时,
//浏览器将用acrobat打开。
su.setContentDisposition(null);
// 下载文件
su.downloadFile("/upload/如何赚取我的第一桶金.doc");
%>
 


注意,执行下载的页面,在Java脚本范围外(即<% ... %>之外),不要包含HTML代码、空格、回车或换行等字符,有的话将不能正确下载。不信的话,可以在上述源码中%><%之间加入一个换行符,再下载一下,保证出错。因为它影响了返回给浏览器的数据流,导致解析出错。 

3、如何下载中文文件 

jspSmartUpload虽然能下载文件,但对中文支持不足。若下载的文件名中有汉字,则浏览器在提示另存的文件名时,显示的是一堆乱码,很扫人兴。上面的例子就是这样。(这个问题也是众多下载组件所存在的问题,很少有人解决,搜索不到相关资料,可叹!) 

为了给jspSmartUpload组件增加下载中文文件的支持,我对该组件进行了研究,发现对返回给浏览器的另存文件名进行UTF-8编码后,浏览器便能正确显示中文名字了。这是一个令人高兴的发现。于是我对jspSmartUpload组件的SmartUpload类做了升级处理,增加了toUtf8String这个方法,改动部分源码如下: 

public void downloadFile(String s, String s1, String s2, int i)
throws ServletException, IOException, SmartUploadException
    {
if(s == null)
    throw new IllegalArgumentException("File ''" + s +
    "'' not found (1040).");
if(s.equals(""))
    throw new IllegalArgumentException("File ''" + s +
    "'' not found (1040).");
if(!isVirtual(s) && m_denyPhysicalPath)
    throw new SecurityException("Physical path is
    denied (1035).");
if(isVirtual(s))
    s = m_application.getRealPath(s);
java.io.File file = new java.io.File(s);
FileInputStream fileinputstream = new FileInputStream(file);
long l = file.length();
boolean flag = false;
int k = 0;
byte abyte0[] = new byte[i];
if(s1 == null)
    m_response.setContentType("application/x-msdownload");
else
if(s1.length() == 0)
    m_response.setContentType("application/x-msdownload");
else
    m_response.setContentType(s1);
m_response.setContentLength((int)l);
m_contentDisposition = m_contentDisposition != null ?
m_contentDisposition : "attachment;";
if(s2 == null)
    m_response.setHeader("Content-Disposition", 
    m_contentDisposition + " filename=" + 
    toUtf8String(getFileName(s)));
else
if(s2.length() == 0)
    m_response.setHeader("Content-Disposition", 
    m_contentDisposition);
else
    m_response.setHeader("Content-Disposition", 
    m_contentDisposition + " filename=" + toUtf8String(s2));
while((long)k < l)
{
    int j = fileinputstream.read(abyte0, 0, i);
    k += j;
    m_response.getOutputStream().write(abyte0, 0, j);
}
fileinputstream.close();
    }

    /**
     * 将文件名中的汉字转为UTF8编码的串,以便下载时能正确显示另存的文件名.
     * 纵横软件制作中心雨亦奇2003.08.01
     * @param s 原文件名
     * @return 重新编码后的文件名
     */
    public static String toUtf8String(String s) {
StringBuffer sb = new StringBuffer();
for (int i=0;i<s.length();i++) {
    char c = s.charAt(i);
    if (c >= 0 && c <= 255) {
sb.append(c);
    } else {
byte[] b;
try {
    b = Character.toString(c).getBytes("utf-8");
} catch (Exception ex) {
    System.out.println(ex);
    b = new byte[0];
}
for (int j = 0; j < b.length; j++) {
    int k = b[j];
    if (k < 0) k += 256;
    sb.append("%" + Integer.toHexString(k).
    toUpperCase());
}
    }
}
return sb.toString();
    }
 


注意源码中粗体部分,原jspSmartUpload组件对返回的文件未作任何处理,现在做了编码的转换工作,将文件名转换为UTF-8形式的编码形式。UTF-8编码对英文未作任何处理,对中文则需要转换为%XX的形式。toUtf8String方法中,直接利用Java语言提供的编码转换方法获得汉字字符的UTF-8编码,之后将其转换为%XX的形式。 

将源码编译后打包成jspSmartUpload.jar,拷贝到Tomcat的shared/lib目录下(可为所有WEB应用程序所共享),然后重启Tomcat服务器就可以正常下载含有中文名字的文件了。另,toUtf8String方法也可用于转换含有中文的超级链接,以保证链接的有效,因为有的WEB服务器不支持中文链接。 

小结:jspSmartUpload组件是应用JSP进行B/S程序开发过程中经常使用的上传下载组件,它使用简单,方便。现在我又为其加上了下载中文名字的文件的支持,真个是如虎添翼,必将赢得更多开发者的青睐。

posted @ 2005-10-21 18:09 丁丁 阅读(436) | 评论 (0)编辑 收藏


仅列出标题  

posts - 9, comments - 6, trackbacks - 0, articles - 1

Copyright © 丁丁