BlogJava-碧螺春-文章分类-java&jsp

java 收集

yuyi — Thu, 23 Mar 2006 01:46:00 GMT

摘要: JSP内建对象 J2EE — 作者: LiuYi @ 2005-09-28, 13:28 ① out - javax.servlet.jsp.jspWriter out对象用于把结果输出到网页上。方法：1. void clear() ; 清除输出缓冲... 阅读全文

yuyi 2006-03-23 09:46 发表评论

Oracle数据库性能优化技术

yuyi — Wed, 08 Jun 2005 06:14:00 GMT

摘要： Oracle数据库是当前应用最广泛的大型数据库之一，而其性优化直接关系到系统的运行效率。本文以数据库性能优化的基本原则为出发点，阐述了在数据库设计阶段如何避免竞争和如何优化数据访问，在数据库运行阶段如何从操作系统和数据库实例级别上调整内存和I/O来达到数据库性能优化的各种技术。

　　关键词：Oracle数据库；性能优化；内存；I/O

　　1. 引言

　　随着网络应用和电子商务的不断发展，各个站点的访问量越来越大，数据库规模也随之不断的扩大，数据库系统的性能问题就越来越突出，因此，如何对数据库进行调优至关重要：如何使用有限的计算机系统资源为更多的用户服务？如何保证用户的响应速度和服务质量？这些问题都属于服务器性能优化的范畴。

　　作为全球第一大数据库厂商，Oracle数据库在国内外获得了诸多成功应用，据统计，全球93%的上市.COM公司、65家"财富全球100强"企业不约而同地采用Oracle数据库来开展电子商务。我国很多企业、政府单位及电子商务网站也采用了Oracle作为数据库服务器。Oracle数据库服务器是高度可优化的软件产品，经常性的调整可以优化应用系统的性能，防止出现系统瓶颈。

　　数据库性能优化的基本原则就是：通过尽可能少的磁盘访问获得所需要的数据。要评价数据库的性能，需要在数据库调节前后比较其评价指标：响应时间和吞吐量之间的权衡、数据库的可用性、数据库的命中率以及内存的使用效率，以此来衡量调节措施的效果和指导调整的方向。

　　对Oracle数据库进行性能调整时，应当按照一定的顺序进行，因为系统在前面步骤中进行的调整可以避免后面的一些不必要调整或者代价很大的调整。一般来说可以从两个阶段入手：

　　1、设计阶段：对其逻辑结构和物理结构进行优化设计，使之在满足需求条件的情况下,系统性能达到最佳，系统开销达到最小；

　　2、数据库运行阶段：采取操作系统级、数据库级的一些优化措施来使系统性能最佳；

　　2. 在系统设计开发阶段调整数据库

　　为了充分利用Oracle数据库的功能特性，在设计信息系统时，数据库设计人员需要根据业务情况（如访问量或客户端数量）和现有资源状况（如数据库服务器的配置）考虑系统结构和数据库的逻辑结构的设计：

　　2.1调整应用程序结构设计。

　　即应用程序采用的是传统的C/S两层体系结构，还是B/W/D三层体系结构。不同的应用程序体系结构要求的数据库资源是不同的。

　　2.2恰当使用分区、索引及存档功能。

　　如果某种业务的数据量增长非常快，可以考虑存放该业务的数据库表是否使用Oracle数据库的分区功能；对于经常访问的数据库表是否需要建立索引；对于经常访问但是当业务流程完成后不再变动的数据可采用放入历史档案的方法来实现应用系统中访问尽可能少的数据量。

　　2.3恰当编写访问数据的SQL语句。

　　良好的SQL语句可以被数据库重复使用而减少分析时间；恰当的使用索引可使访问的数据块大大减少从而减少响应时间。应用程序的执行最终将归结为数据库中的SQL语句执行，因此SQL语句的执行效率决定了Oracle数据库的性能。Oracle公司推荐使用Oracle语句优化器（Oracle Optimizer）和行锁管理器（row-level manager）来调整优化SQL语句。

　　2.4调整硬盘I/O

　　这一步是在信息系统开发之前完成的。数据库管理员可以将组成同一个表空间的数据文件放在不同的硬盘上，做到硬盘之间I/O负载均衡。在磁盘比较富裕的情况下还应该遵循以下原则：

　　将表和索引分开；

　　创造用户表空间，与系统表空间（system）分开磁盘；

　　创建表和索引时指定不同的表空间；

　　创建回滚段专用的表空间，防止空间竞争影响事务的完成；

　　创建临时表空间用于排序操作，尽可能的防止数据库碎片存在于多个表空间中。

　　2.5确定数据块大小和存储参数。

　　由于数据库的块大小在数据库创建以后就不能在修改（除非重建数据库），因此为了减少数据链接和行迁移，又提高磁盘空间的利用率，在设计数据库时要确定合适的数据块大小和存储参数。通常我们是根据样例数据确定数据块大小，而根据业务现状和未来发展趋势确定存储参数。

3. 在数据库运行阶段调整数据库

　　数据库运行阶段调整数据库包括两个方面：操作系统级的调整；数据库级的调整。

　　3.1 操作系统级的调整

　　实施操作系统级调整的主要目的是减少内存交换，减少分页，使SGA(System Globle Area)可留驻内存。

　　3.1.1减少内存交换

　　内存交换（swapping）可能会造成很大的内存开销，应将它最小化。运行在Solaris Unix操作系统上的Oracle数据库，可利用vmstat或sar命令来检查交换，查看到系统级内存和硬盘I/O的使用情况，调整unix数据缓冲池的大小、每个进程所能使用的内存大小等参数。

　　 vmstat命令

　　它报告Solaris上的进程、虚拟内存、磁盘、分页和CPU的活动情况。下面命令将显示系统每5秒钟做的事情的概要：
% vmstat 5

　　 sar命令

　　用于监控交换、分页、磁盘和CPU活动。下面命令用于每10秒显示10次分页活动的概要：
% sar -p 10 10

　　若系统内存交换较多，且需要节省内存，可采用以下措施：

　　1）避免运行不必要的系统daemon进程或应用程序进程；

　　2）在不明显影响数据块命中率的前提下减少数据库缓冲区的数量，以释放一些内存；

　　3）减少UNIX文件缓冲区的数量（特别是在使用裸设备时）。

　　3.1.2控制分页

　　少量的内存分页不会太显著地影响系统的性能，因为应用程序不必全部放在内存中。但是分页过多将会造成系统性能下降。为了检测过多的分页，可在快速响应或空闲期间运行测量，并与响应迟缓时的测量进行比较。可通过以下办法来解决：

　　使用vmstat或sar -p监控分页；

　　　安装更多的内存；

　　　将一些工作移到另一系统中；

　　　配置系统核心使用更少的内存；

　　　保持SGA在单个共享内存段中。

　　3.1.3使SGA(System Globle Area)留驻内存

　　SGA是对数据库数据进行快速访问的一个系统全局区，若SGA本身需要频繁地进行释放、分配，则不可能达到快速访问数据的目的，因此，要求SGA驻留内存。这时，我们可以重新配置UNIX核心，调整一些操作系统参数以达到增加共享内存的目的。

　　3.2 数据库级的调整

　　每一个Oracle实例都是由一组Oracle后台进程和SGA的一个内存区组成的。这组后台进程会自动的读写数据库的数据文件，因此，数据库性能可以被这些因素所影响：SGA各部分的分配是否合理，使用效率是否正常；I/O和锁竞争是否较多。

　　3.2.1 SGA的分配及使用效率

　　分配给每个实例的内存，即SGA的使用效率如何，会大大影响数据库系统的性能。SGA由下列部分组成：共享池、数据块缓冲区、重做日志缓冲区、大池组成。

　　l 共享池（Shared pool）

　　共享池存放库缓存（存储共享SQL和PL/SQL区）和数据字典缓存（数据库对象信息）以及会话期间信息（对于MTS）。由于这些信息是应用程序需要经常访问的，因此这些信息需要保持高的命中率。可以通过以下语句来确认共享池数据的命中率：

　　库缓存：

select gethitratio from v$librarycache 应大于90%
select sum(reloads)/sum(pins) from v$librarycache 应小于1%

　　数据字典缓存：

select sum(getmisses)/sum(gets) from v$rowcache 应小于15%

　　由于程序设计人员的水平参差不齐，可能存在大的匿名块，这会导致SQL不能重用，因此需要找出大的匿名块以转换为存储过程达到重用：

select * from v$sqlarea where command_type=47 and length(sql_text)>500

　　而对于一些应用系统非常频繁使用的SQL对象如存储过程、函数、包等，可以通过钉在内存中的方式来防止由于共享池太小被移出：

exec dbms_shared_pool.keep(对象名)

　　数据块缓冲区（Db block buffer）：

　　数据块缓冲区存放用户所经常访问的数据文件的数据块内容以及用户修改的数据内容。数据库把数据文件里的内容读到内存中，下次需要时直接从内存中读取，从而减少了磁盘的I/O和响应时间。当然，一般只在比较小的数据表（如常用代码表）才缓存到内存中。

　　由于数据快缓冲区中不可能存放所有的数据，因此可使用LRU算法来确定移出哪些数据块，但又尽量保证有较高的数据命中率。

　　查看数据块命中率的SQL语句为：

select 1-(phy.value/(cur.value+con.value)) from v$sysstat cur,v$sysstat con,v$sysstat phy
where cur.name='db block gets' and con.name='consistent gets'
and phy.name='physical gets'

　　如果这个命中率小于0.85，就要考虑为数据块缓冲区分配更多的内存了。

　　重做日志缓冲区（Log buffer）：

　　重做日志缓冲区存放从用户内存区复制来的每个DML或DDL语句的重做条目。如果这个缓冲区分配太小会导致没有足够的空间来放重做条目而等待。

　　3.2.2 I/O和资源竞争

　　由于有众多的进程要写数据文件，因此需要通过I/O调整来解决I/O瓶颈问题。如果在设计阶段有效地考虑了表空间的合理分配，就能有效地在一定程度上减少I/O竞争。在数据库运行时，由于数据的动态增长，原来分配给表或索引的空间已经用完，Oracle会自动分配空间给这些数据库对象。而这个动态分配会对系统性能有所影响，所以要求：

　　避免动态空间管理

　　表空间的本地化管理，以减少与数据字典表空间的磁盘竞争。

　　在系统设计和试运行阶段数据量相对较小，效率低下的SQL可能并不会影响系统响应时间，但当系统数据量增长到一定程度时，需要在系统运行时监控并找出是哪些SQL不能有效使用索引或缺少索引，并进行相应调整：建立索引；修改SQL写法。

　　另外，在Oracle中，需要采用一些机制来保证数据库对象在使用期间的稳定性和数据的一致性，如使用锁存器(latch)、锁(lock)等。因此争用和这些机制相关的资源会影响数据库的性能。为了减少这种资源竞争，可以通过调整数据库的相关初始化参数（如db_block_lru_latches、dml_locks）来减少资源的争用，优化数据库性能。

　　4. 一些常用的性能优化手段和工具

　　Oracle数据库系统提供了一些工具和脚本来获取数据库的性能指标和优化的方法。如使用utlbstat.sql和utlestat.sql脚本获取一段时间内数据库的内存、磁盘I/O等的情况；使用动态性能视图和数据字典视图来获取命中率和系统等待事件等信息。当然，也可以使用Oracle Enterprise Manager图形化工具来监控。

　　5. 结束语

　　Oracle数据库的性能调整相当重要，但难度也较大。数据库管理员需要综合运用上面介绍的规律，在数据库建立时，就能根据应用的需要合理设计分配表空间以及存储参数、内存使用初始化参数，对以后的数据库性能有很大的益处。只有认真分析Oracle运行过程当中出现的各种性能问题，才能保证Oracle数据库高效可靠地运行。还需要指出的是：数据库的性能调整是一个系统工程，涉及的方面很多，不能仅仅根据一个时间点的情况就断定数据库运行性能的好与坏。如何有效地进行调整，数据库管理员需要经过反反复复的过程。这些都需要在大量的实践工作中不断地积累经验，从而更好地进行数据库的调优。

yuyi 2005-06-08 14:14 发表评论

sax解析xml文档-jdom解析文档

yuyi — Mon, 06 Jun 2005 06:33:00 GMT

sax解析
**********************************************************************************
package test;

import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import java.io.*;

public class SaxTest extends DefaultHandler {

// 重载DefaultHandler类的方法
// 以拦截SAX事件通知。
//
// 关于所有有效事件，见org.xml.sax.ContentHandler
//
public void startDocument() throws SAXException {
//System.out.println( "SAX Event: START DOCUMENT" );
}

public void endDocument() throws SAXException {
//System.out.println( "SAX Event: END DOCUMENT" );
}

    public void startElement(String namespaceURI,
                             String localName,
                             String qName,
                             Attributes attr) throws SAXException {
        System.out.print("<" + localName);

// 如果有属性，我们也一并打印出来．．．
for (int i = 0; i < attr.getLength(); i++) {

            System.out.print(" " + attr.getLocalName(i) + "='" +attr.getValue(i)+"'");
        }
        System.out.print(">");
    }

    public void endElement(String namespaceURI,
                           String localName,
                           String qName) throws SAXException {
        System.out.print("    }

public void characters(char[] ch, int start, int length) throws
SAXException {

        try {
            OutputStreamWriter outw = new OutputStreamWriter(System.out);
            outw.write(ch, start, length);
            outw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }

}

public static void main(String[] argv) {

System.out.println("Example1 SAX Events:");
try {

// SAXParserFactory spFactory = SAXParserFactory.newInstance();
// SAXParser sParser = spFactory.newSAXParser();

// 建立SAX 2解析器．．．
XMLReader xr = XMLReaderFactory.createXMLReader(
"org.apache.xerces.parsers.SAXParser");

// 安装ContentHandler．．．
xr.setContentHandler(new SaxTest());

// 解析文件．．．
xr.parse(new InputSource(
new FileReader("c:\\DeviceTable.xml")));

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

JDOM解析
***********************************************************************************
package test;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import java.util.List;
import java.util.*;

/**
* @author kingwong
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class TestJDOM2 {
public static void main(String[] args){
SAXBuilder sb = new SAXBuilder();
    try
    {
     Document doc = sb.build("c:\\DeviceTable.xml");
Element root = doc.getRootElement();
List list=root.getChildren();
getchildren(list);

String str1 = root.getAttributeValue("comment");
System.out.println("Root Element's comment attribute is : " + str1);
// String str2 = root.getChild("NeCode").getAttributeValue("sss");
// System.out.println("NeCode Element's sss attribute is : " + str2);
// String str3 = root.getChildText("name");
// System.out.println("name Element's content is :" + str3);
// String str4 = root.getChild("contact").getChildText("telephone");
// System.out.println("contact Element's telephone subelement content is : " + str4 + "\n");
// Element inputElement = root.getChild("contact");
// inputElement.addContent(new Element("email").setAttribute("value","wanghua@cyberobject.com"));

XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat());
// String outStr = xmlOut.outputString(root);

//     System.out.println(outStr);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}

private static void getchildren(List list) {
    Iterator iter = list.iterator();
    while (iter.hasNext()) {
        Element item = (Element) iter.next();
        System.out.println("***<"+item.getName()+">"+item.getValue()+"");
        if(item.getChildren().size()!=0){
            getchildren(item.getChildren());
        }else{
//            System.out.println("###"+item.getName()+"没有子节点！！");
        }
    }
}
}

yuyi 2005-06-06 14:33 发表评论

Java加密技术(转载)

yuyi — Tue, 17 May 2005 08:58:00 GMT

第1章基础知识

1.1. 单钥密码体制
单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。

通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全性,在公开的计算机网络上安全地传送和保管密钥是一个严峻的问题，并且如果在多用户的情况下密钥的保管安全性也是一个问题。

单钥密码体制的代表是美国的DES

1.2. 消息摘要
一个消息摘要就是一个数据块的数字指纹。即对一个任意长度的一个数据块进行计算，产生一个唯一指印（对于SHA1是产生一个20字节的二进制数组）。

消息摘要有两个基本属性：

两个不同的报文难以生成相同的摘要
难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要
代表：美国国家标准技术研究所的SHA1和麻省理工学院Ronald Rivest提出的MD5

1.3. Diffie-Hellman密钥一致协议
密钥一致协议是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。

先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥

代表：指数密钥一致协议(Exponential Key Agreement Protocol)

1.4. 非对称算法与公钥体系
1976年，Dittie和Hellman为解决密钥管理问题，在他们的奠基性的工作"密码学的新方向"一文中，提出一种密钥交换协议，允许在不安全的媒体上通过通讯双方交换信息，安全地传送秘密密钥。在此新思想的基础上，很快出现了非对称密钥密码体制，即公钥密码体制。在公钥体制中，加密密钥不同于解密密钥，加密密钥公之于众，谁都可以使用；解密密钥只有解密人自己知道。它们分别称为公开密钥（Public key）和秘密密钥（Private key）。

迄今为止的所有公钥密码体系中，RSA系统是最著名、最多使用的一种。RSA公开密钥密码系统是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是来自于这三位发明者的姓的第一个字母

1.5. 数字签名
所谓数字签名就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。　

在数字签名中有重要作用的数字指纹是通过一类特殊的散列函数（HASH函数）生成的，对这些HASH函数的特殊要求是：

接受的输入报文数据没有长度限制；
对任何输入报文数据生成固定长度的摘要（数字指纹）输出
从报文能方便地算出摘要；
难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要；
两个不同的报文难以生成相同的摘要

代表：DSA

第2章在JAVA中的实现

2.1. 相关
Diffie-Hellman密钥一致协议和DES程序需要JCE工具库的支持,可以到 http://java.sun.com/security/index.html 下载JCE,并进行安装。简易安装把 jce1.2.1\lib 下的所有内容复制到 %java_home%\lib\ext下,如果没有ext目录自行建立,再把jce1_2_1.jar和sunjce_provider.jar添加到CLASSPATH内,更详细说明请看相应用户手册

2.2. 消息摘要MD5和SHA的使用
使用方法:

首先用生成一个MessageDigest类,确定计算方法

java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");

添加要进行计算摘要的信息

alga.update(myinfo.getBytes());

计算出摘要

byte[] digesta=alga.digest();

发送给其他人你的信息和摘要

其他人用相同的方法初始化,添加信息,最后进行比较摘要是否相同

algb.isEqual(digesta,algb.digest())

计算Java日期－－学习怎样创建和使用日期

yuyi — Thu, 14 Apr 2005 10:36:00 GMT

概要

不管你是处理财务交易还是计划着下一步的行动，你都要知道怎样在Java中建立，使用和显示日期。这需要你简单的查阅一下相应类的API参考：一个日期可以创建3个相关类的对象。这篇文章告诉你你想要知道的内容。

Java统计从1970年1月1日起的毫秒的数量表示日期。也就是说，例如，1970年1月2日，是在1月1日后的86，400，000毫秒。同样的，1969年12月31日是在1970年1月1日前86，400，000毫秒。Java的Date类使用long类型纪录这些毫秒值.因为long是有符号整数，所以日期可以在1970年1月1日之前，也可以在这之后。Long类型表示的最大正值和最大负值可以轻松的表示290，000，000年的时间，这适合大多数人的时间要求。

Date 类

   Date类可以在java.util包中找到，用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时刻的对象。getTime()方法返回Date对象的long值。在下面的程序中，我使用Date()构造函数创建一个表示程序运行时刻的对象，并且利用getTime()方法找到这个日期代表的毫秒数量：

import java.util.*;

public class Now {
   public static void main(String[] args) {
      Date now = new Date();
      long nowLong = now.getTime();
      System.out.println("Value is " + nowLong);
   }
}

当我运行这个程序后，我得到972,568,255,150.快速确认一下这个数字，起码在一个合理的范围：它不到31年，这个数值相对1970年1月1日到我写这篇文章的时间来说，是合理的。计算机是这个毫秒值表示时间，人们可不愿意说" 我将在996,321,998,34见到你。"幸运的是，Java提供了一个转换Date对象到字符串的途径，表示成传统的形式。我们在下一节讨论DateFormat类，它直观的建立日期字符串。
DateFormat类
DateFormat类的一个目标是建立一个人们能够识别的字符串。然而，因为语言的差别，不是所有的人希望看到严格的相同格式的日期。法国人更喜欢看到"25 decembre 2000,",但是美国人习惯看到"December 25,2000."所以一个DateFormat的实例创建以后，这个对象包含了日期的显示格式的信息。如果使用用户电脑区域设置缺省的格式，你可以象下面那样，创建DateFormat对象，使用getDateInstance()方法：

DateFormat df = DateFormat.getDateInstance();

DateFormat类在java.text包中可以找到。

转换成字符串

你可以使用format()方法转换Date对象为一个字符串。下面的示例程序说明了这个问题：

import java.util.*;
import java.text.*;

public class NowString {
   public static void main(String[] args) {
      Date now = new Date();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(now);
      System.out.println("Today is " + s);
   }
}

在上面的代码中，展示了没有参数，使用缺省格式的getDateInstance()方法。Java还提供了几个选择日期格式，你可以通过使用重载的getDateInstance(int style)获得。出于方便的原因，DateFormat提供了几种预置的常量，你可以使用这些常量参数。下面是几个SHORT, MEDIUM, LONG, 和FULL类型的示例：

import java.util.*;
import java.text.*;

public class StyleDemo {
   public static void main(String[] args) {
      Date now = new Date();

      DateFormat df =  DateFormat.getDateInstance();
      DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
      DateFormat df2 = DateFormat.getDateInstance(DateFormat.MEDIUM);
      DateFormat df3 = DateFormat.getDateInstance(DateFormat.LONG);
      DateFormat df4 = DateFormat.getDateInstance(DateFormat.FULL);
      String s =  df.format(now);
      String s1 = df1.format(now);
      String s2 = df2.format(now);
      String s3 = df3.format(now);
      String s4 = df4.format(now);

      System.out.println("(Default) Today is " + s);
      System.out.println("(SHORT)   Today is " + s1);
      System.out.println("(MEDIUM)  Today is " + s2);
      System.out.println("(LONG)    Today is " + s3);
      System.out.println("(FULL)    Today is " + s4);
   }
}

程序输出如下：

(Default) Today is Nov 8, 2000
(SHORT)   Today is 11/8/00
(MEDIUM)  Today is Nov 8, 2000
(LONG)    Today is November 8, 2000
(FULL)    Today is Wednesday, November 8, 2000

同样的程序，在我的电脑上使用缺省设置运行后，改变区域设置为瑞典，输出如下：

(Default) Today is 2000-nov-08
(SHORT)   Today is 2000-11-08
(MEDIUM)  Today is 2000-nov-08
(LONG)    Today is den 8 november 2000
(FULL)    Today is den 8 november 2000

从这里，你能看到，瑞典的月份不是大写的（虽然November还是november）.还有，LONG和FULL版本在瑞典语中是一样的，但是美国英语却不同。另外，有趣的是，瑞典语单词的星期三,onsdag，没有包含在FULL日期里，英语却包括。
注意你能够使用getDateInstance()方法改变DateFormat实例的语种；但是，在上面的例子中，是通过改变Windows98的控制面板的区域设置做到的。不同的地方的区域设置不同，结果就不同，这样有好处，也有不足，Java程序员应该了解这些。一个好处是Java程序员可以只写一行代码就可以显示日期，而且世界不同地区的电脑运行同样的程序会有不用的日期格式。但是这也是一个缺点，当程序员希望显示同一种格式的时--这也有可取之处，举例来说，在程序中混合输出文本和日期，如果文本是英文，我们就不希望日期格式是其他的格式，象德文或是西班牙文。如果程序员依靠日期格式编程，日期格式将根据运行程序所在电脑的区域设置不用而不同。

解析字符串

通过parse()方法，DateFormat能够以一个字符串创立一个Date对象。这个方法能抛出ParseException异常，所以你必须使用适当的异常处理技术。下面的例子程序通过字符串创建Date对象：

import java.util.*;
import java.text.*;

public class ParseExample {
   public static void main(String[] args) {
      String ds = "November 1, 2000";
      DateFormat df = DateFormat.getDateInstance();
      try {
         Date d = df.parse(ds);
      }
      catch(ParseException e) {
         System.out.println("Unable to parse " + ds);
      }
   }
}

在创建一个任意的日期时parse()方法很有用。我将通过另一种方法创建一个任意得日期。同时，你将看到怎样进行基本日期计算，例如计算90天后的另一天。你可以使用GregorianCalendar类来完成这个任务。
GregorianCalendar类
创建一个代表任意日期的一个途径使用GregorianCalendar类的构造函数，它包含在java.util包中：

GregorianCalendar(int year, int month, int date)

注意月份的表示，一月是0，二月是1，以此类推，是12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY, FEBRUARY,等等。所以，创建Wilbur 和 Orville制造第一架动力飞机的日期（December 17, 1903），你可以使用：

GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);

出于清楚的考虑，你应该使用前面的形式。但是，你也应该学习怎样阅读下面的短格式。下面的例子同样表示December 17,1903（记住，在短格式中，11表示December）

GregorianCalendar firstFlight = new GregorianCalendar(1903, 11, 17);

在上一节中，你学习了转换Date对象到字符串。这里，你可以做同样的事情；但是首先，你需要将GregorianCalendar对象转换到Date。要做到这一点，你可以使用getTime()方法，从它得父类Calendar继承而来。GetTime()方法返回GregorianCalendar相应的Date对象。你能够创建GregorianCalendar对象，转换到Date对象，得到和输出相应的字符串这样一个过程。下面是例子：

import java.util.*;
import java.text.*;

public class Flight {

   public static void main(String[] args) {
      GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);
      Date d = firstFlight.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("First flight was " + s);
   }
}

有时候创建一个代表当前时刻的GregorianCalendar类的实例是很有用的。你可以简单的使用没有参数的GregorianCalendar构造函数，象这样：

GregorianCalendar thisday = new GregorianCalendar();

一个输出今天日期的例子程序，使用GregorianCalendar对象：

import java.util.*;
import java.text.*;

class Today {
   public static void main(String[] args) {
      GregorianCalendar thisday = new GregorianCalendar();
      Date d = thisday.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("Today is " + s);
   }
}

注意到，Date()构造函数和GregorianCalendar()构造函数很类似：都创建一个对象，条件简单，代表今天。

日期处理

GregorianCalendar类提供处理日期的方法。一个有用的方法是add().使用add()方法，你能够增加象年，月数，天数到日期对象中。要使用add()方法，你必须提供要增加的字段，要增加的数量。一些有用的字段是DATE, MONTH, YEAR, 和 WEEK_OF_YEAR。下面的程序使用add()方法计算未来80天的一个日期。在Jules的<环球80天>是一个重要的数字，使用这个程序可以计算Phileas Fogg从出发的那一天1872年10月2日后80天的日期：

import java.util.*;
import java.text.*;

public class World {
   public static void main(String[] args) {
      GregorianCalendar worldTour = new GregorianCalendar(1872, Calendar.OCTOBER, 2);
      worldTour.add(GregorianCalendar.DATE, 80);
      Date d = worldTour.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("80 day trip will end " + s);
   }
}

这个例子是想象的，但在一个日期上增加天数是一个普遍的操作：影碟可以租3天，图书馆可以借书21天，商店经常需要将购买的物品在30天内卖出。下面的程序演示了使用年计算：

import java.util.*;
import java.text.*;

public class Mortgage {
   public static void main(String[] args) {
      GregorianCalendar mortgage = new GregorianCalendar(1997, Calendar.MAY, 18);
      mortgage.add(Calendar.YEAR, 15);
      Date d = mortgage.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("15 year mortgage amortized on " + s);    }
}

    add()一个重要的副作用是它改变的原来的日期。有时候，拥有原始日期和修改后的日期很重要。不幸的是，你不能简单的创建一个GregorianCalendar对象，设置它和原来的相等（equal）。原因是两个变量指向同一个Date()对象地址。如果Date对象改变，两个变量就指向改变后的日期对象。代替这种做法，应该创建一个新对象。下面的程序示范了这种做法：

import java.util.*;
import java.text.*;

public class ThreeDates {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      GregorianCalendar gc2 = gc1;
      GregorianCalendar gc3 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      //Three dates all equal to January 1, 2000

      gc1.add(Calendar.YEAR, 1);
      file://gc1 and gc2 are changed

      DateFormat df = DateFormat.getDateInstance();

      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      Date d3 = gc3.getTime();

      String s1 = df.format(d1);
      String s2 = df.format(d2);
      String s3 = df.format(d3);

      System.out.println("gc1 is " + s1);
      System.out.println("gc2 is " + s2);
      System.out.println("gc3 is " + s3);
   }
}

    程序运行后，gc1和gc2被变成2001年（因为两个对象指向同一个Date，而Date已经被改变了）。对象gc3指向一个单独的Date，它没有被改变。
计算复习日期
在这节，你将看到一个依据现实世界的例子。这个详细的程序计算过去一个具体的日期。例如，你阅读这篇文章，你想要记住一个印象深刻的知识点。如果你没有照片一样的记忆力，你就要定期的复习这些新资料，这将帮助你记住它。关于复习系统，Kurt Hanks 和 Gerreld L. Pulsipher在他们的< Five Secrets to Personal Productivity个人能力的5个秘密>中有讨论，建议看过第一眼后马上回顾一下，然后是1天后，1个星期后，1个月后，3个月后，1年后。我的这篇文章，你要马上回顾一下，从现在算起，再就是明天，然后是1个星期，1个月，3个月，1年后。我们的程序将计算这些日期。
这个程序非常有用的，它将是PIM(Personal Information Manager个人信息管理器)的一个组成部分，并将确定复习时间。在下面的程序中，getDates()方法对一个返回日期数组（复习日期）的电子软件很有用。另外，你可以返回单独的一个日期，使用getFirstDay(),getOneDay(),getOneWeek(),getOnMonth()和getOneYear().当时间范围超出这个PIM的ReviewDates的计算范围时ReviewDates类演示了怎样计算时间段。现在，你可以容易的修改它用来处理你需要的时间段，象图书馆借书，录影带租赁和抵押计算。首先，ReviewDates类显示在下面：

import java.util.*;
import java.text.*;

public class ReviewDates {
   private GregorianCalendar firstDay, oneDay, oneWeek, oneMonth, oneQuarter, oneYear;
   final int dateArraySize = 6;

   ReviewDates(GregorianCalendar gcDate) {
      int year = gcDate.get(GregorianCalendar.YEAR);
      int month = gcDate.get(GregorianCalendar.MONTH);
      int date = gcDate.get(GregorianCalendar.DATE);

      firstDay = new GregorianCalendar(year, month, date);
      oneDay = new GregorianCalendar(year, month, date);
      oneWeek = new GregorianCalendar(year, month, date);
      oneMonth = new GregorianCalendar(year, month, date);
      oneQuarter = new GregorianCalendar(year, month, date);
      oneYear = new GregorianCalendar(year, month, date);

      oneDay.add(GregorianCalendar.DATE, 1);
      oneWeek.add(GregorianCalendar.DATE, 7);
      oneMonth.add(GregorianCalendar.MONTH, 1);
      oneQuarter.add(GregorianCalendar.MONTH, 3);
      oneYear.add(GregorianCalendar.YEAR, 1);
   }

   ReviewDates() {
      this(new GregorianCalendar());
   }

   public void listDates() {
      DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
      Date startDate = firstDay.getTime();
      Date date1 = oneDay.getTime();
      Date date2 = oneWeek.getTime();
      Date date3 = oneMonth.getTime();
      Date date4 = oneQuarter.getTime();
      Date date5 = oneYear.getTime();

      String ss =  df.format(startDate);
      String ss1 = df.format(date1);
      String ss2 = df.format(date2);
      String ss3 = df.format(date3);
      String ss4 = df.format(date4);
      String ss5 = df.format(date5);

      System.out.println("Start date is " + ss);
      System.out.println("Following review dates are:");
      System.out.println(ss1);
      System.out.println(ss2);
      System.out.println(ss3);
      System.out.println(ss4);
      System.out.println(ss5);
      System.out.println();
   }

   public GregorianCalendar[] getDates() {
      GregorianCalendar[] memoryDates = new GregorianCalendar[dateArraySize];
      memoryDates[0] = firstDay;
      memoryDates[1] = oneDay;
      memoryDates[2] = oneWeek;
      memoryDates[3] = oneMonth;
      memoryDates[4] = oneQuarter;
      memoryDates[5] = oneYear;
      return memoryDates;
   }

   public GregorianCalendar getFirstDay() {
      return this.firstDay;
   }

   public GregorianCalendar getOneDay() {
      return this.oneDay;
   }

   public GregorianCalendar getOneWeek() {
      return this.oneWeek;
   }

   public GregorianCalendar getOneMonth() {
      return this.oneMonth;
   }

   public GregorianCalendar getOneQuarter() {
      return this.oneQuarter;
   }

   public GregorianCalendar getOneYear() {
      return this.oneYear;
   }
}

下面是使用ReviewDates类列出复习日期的例子程序：

import java.util.*;

public class ShowDates {
   public static void main(String[] args) {
      ReviewDates rd = new ReviewDates();
      rd.listDates();

      GregorianCalendar gc = new GregorianCalendar(2001, Calendar.JANUARY, 15);
      ReviewDates jan15 = new ReviewDates(gc);
      jan15.listDates();
   }
}

总结

这篇文章介绍了关于日期处理的3个重要的类：Date,DateFormat,GregorianCalendar.这些类让你创建日期，转换成字符串，和计算日期基本元素。处理Java中的日期问题，这篇文章只是冰山一角。可是，我在这里介绍的类和方法不仅仅是你学习高级技术的跳板，这些类和方法本身就可以处理很多通常的日期相关的任务

yuyi 2005-04-14 18:36 发表评论

WTC介绍

yuyi — Wed, 09 Mar 2005 06:30:00 GMT

BEA公司的TUXEDO，WEBLOGIC作为最优秀的中间件产品,在银行、电信、金融等行业广泛使用，通常采用TUXEDO实现系统的核心业务，用WEBLOGIC做为系统扩展到INTERNET的平台，实现电子商务，由WEBLOGIC调用TUXEDO上的服务，所以TUXEDO与WEBLOGIC之间的互连经常遇到。 egT^
下面通过一个例子介绍TUXEDO与WEBLOGIC通过WTC进行连接的配置方法。 R
©WhiteLand -- Welcome WhiteLand　　q?csm,
WEBLOGIC与TUXEDO的互连有两中方式，通过JOLT或通过WTC(WEBLOGIC TUXEDO CONNECTOR)。它们都是BEA的产品，WTC不仅能让WEBLOGIC调用TUXEDO中的SERVICE，而且能让TUXEDO调用WEBLOGIC中的EJB;而JOLT只能让WEBLOGIC调用TUXEDO. 但JOLT可以使TUXEDO与WEBSPERE等其他应用 LLpe0
服务器相连，而WTC只能用于WEBLOGIC与TUXEDO之间进行互连。 :whK
©WhiteLand -- Welcome WhiteLand　　/),&p
一、WTC说明 ~
(1)WEBLOIGIC5.1无法通过WTC与TUXEDO连接. H,\
(2)WEBLOGIC6.0与TUXEDO连接时,要安装WTC软件包. FCU;
(3)WTC已集成在在EBLOGIC6.1中,只要配置一下就可以了,不用单独安装WTC软件包. {@B6$9
(4)目前WTC只支持TUXEDO6.5,TUXEDO8.0两个版本,不支持TUXEDO7.1版本. U
(5)目前WTC有两个版本, Windows版本支持2000/NT,UNIX为统一版本. 7r
(6)WTC可从http://commerce.bea.com/downloads/tuxedo.jsp下载,目前的版本为1.0. ?
©WhiteLand -- Welcome WhiteLand　　)kNlr`
二、WTC安装过程 nwhk
(1) WEBLOGIC与TUXEDO必须先安装好. .dGv
(2)WTC要求在JAVA环境下安装，可在命令行下，运行weblogic主目录下config/EXAMPLE/setEnv.sh(NT/2000下为setenv.cmd)配置JAVA环境 ^KXG/.
(3)在DOS命令行下执行安装程序WTC_10_win.exe。按提示操作就可以. S=
注意:如果在WINDOW下安装，到COPY文件那一步时，不会执行，但提示安装成功，实际是假的。所以应在DOS命令行下安装. b_#
©WhiteLand -- Welcome WhiteLand　　k4F
三、WTC配置说明 MxP?
TUXEDO与WEBLOGIC之间通过DOMAIN方式实现互相调用，在这个例子中有两个DOMAIN：TUXEDO所在的DOMAIN名为TDOM1， WEBLOGIC所在的 DOMAIN名为TDOM2。TDOM1上有TOUPPER它是一个TUXEDO SERVEICE，TDOM2上有TOLOWER它是一个EJB， h12%
下面以WTC安装带的例子simpapp(在WTC安装目录的examples/wtc/atmi/simpapp下)说明配置过程: K
TUXEO版本: TUXEDO65 _CvUrJ
WEBLOGIC版本: WEBLOGIC6.0 ]`[ri
TUXEO安装目录: D:\TUXEDO65 Ww^cV'
WEBLOGIC安装目录: D:\WEBLOGIC {_y
操作系统: WIN2000 N|
例子目录: D:\SIMPAPP(把WTC安装目录的examples/wtc/atmi/simpapp目录COPY到D:\SIMPAPP) cX6#
服务器名: DEMOSERVER 6_
WTC安装目录: D:\WEBLOGIC\WTC1.0 n
©WhiteLand -- Welcome WhiteLand　　NSU3$%
四、TUXEDO要做的配置 #s
(1)修改D:\SIMPAPP\SETENV.CMD为: om
set TUXDIR=d:\tuxedo65 CBkf9
set WSNADDR=//DEMOSERVER:8888 A-<}T+
set APPDIR=d:\simpapp *FYw5!
set PATH=%TUXDIR%\bin;%APPDIR%;%PATH% @~p/*
set TUXCONFIG=%APPDIR%\tuxconfig Us9
set BDMCONFIG=%APPDIR%/dbmconfig Me
©WhiteLand -- Welcome WhiteLand　　o/
(2)修改D:\SIMPAPP\UBBDOMAIN为: \t6AMI
*RESOURCES *4-TZ
IPCKEY 123456 8>f=
DOMAINID simpapp n`Fpw
MASTER simple _8
MAXACCESSERS 10 (}
MAXSERVERS 5 c,AC8E
MAXSERVICES 10 ;5
MODEL SHM 3
LDBAL N Ed1<
©WhiteLand -- Welcome WhiteLand　　:0-J
*MACHINES LpBCe
DEMOSERVER LMID=simple L^dO'g
APPDIR="d:\simpapp" )!lN
TUXCONFIG="d:\simpapp\tuxconfig" 2h'{U6
TUXDIR="d:\tuxedo65" JbDP
©WhiteLand -- Welcome WhiteLand　　z|K0
*GROUPS Y^'!
GROUP1 e
LMID=simple GRPNO=1 OPENINFO=NONE f
©WhiteLand -- Welcome WhiteLand　　#z>
*SERVERS oz<3)f
DEFAULT: S
CLOPT="-A" a#FUJ
©WhiteLand -- Welcome WhiteLand　　! )-w
simpserv SRVGRP=GROUP1 SRVID=1 ~..PWQ
©WhiteLand -- Welcome WhiteLand　　aXE-t
*SERVICES ";mQ2
TOUPPER \`u
©WhiteLand -- Welcome WhiteLand　　la~4
(3)修改D:\SIMPAPP\DOM1CONFIG: UC/~
修改dom1config，加入TLOG的路径和AUDITLOG的路径。然后修改TDOM1的NWADDR="IP:PORT"为TUXEDO的IP和端口，TDOM2的 Y^>A8
NWADDR="IP:PORT"为WEBLOGIC的IP和端口。 ]p!Z{
©WhiteLand -- Welcome WhiteLand　　nn'!0
*DM_RESOURCES n
VERSION=U22 _)".$
*DM_LOCAL_DOMAINS C-
TDOM1 GWGRP=GROUP2 )(^_&
TYPE=TDOMAIN Sp
DOMAINID="TDOM1" @dJ^0
BLOCKTIME=20 5Q~-L
MAXDATALEN=56 i
MAXRDOM=89 e~;u!
TLOG="d:\simpapp\TLOG" F&
AUDITLOG="d:\simpapp\AUDITLOG" EC3/2z
©WhiteLand -- Welcome WhiteLand　　1JJ@S&
*DM_REMOTE_DOMAINS 5i~
TDOM2 TYPE=TDOMAIN {0Xb:Q
DOMAINID="TDOM2" x.
©WhiteLand -- Welcome WhiteLand　　SL7
*DM_TDOMAIN ZD#
TDOM1 NWADDR="//DEMOSERVER:9998" 84}
TDOM2 NWADDR="//DEMOSERVER:9999" 0|
©WhiteLand -- Welcome WhiteLand　　[
*DM_REMOTE_SERVICES B
TOLOWER RDOM="TDOM2" #h_`
©WhiteLand -- Welcome WhiteLand　　qVeMeW
(4) tmloadcf -y ubbdomain X1
(5) mloadcf -y dom1config 6
(6)buildserver -o simpserv -f simpserv.c -s TOUPPER 6zw>sA
(7)将examples/wtc/atmi/simpapp/simpserv下的tolower.c 拷贝到D:\SIMPAPP，并执行buildclinet -v -f tolower.c -o tolower w;01Y
©WhiteLand -- Welcome WhiteLand　　M
五、WEBLOGIC要做的配置 Z9&^i
(1)修改weblogic目录下config/examples/setExamplesEnv.cmd及startExamplesServer.cmd,在CLASSPATH中加入： 3z*5.
d:\weblogic\wtc1.0\lib/jatmi.jar。执行setExamplesEnv.cmd }H`6g]
(2)修改bdmconfig.xml m:
修改中的:[WTC installation directory]\weblogic\wtc\gwt\wtc_config_1_0.dtd(WLS60) S
修改TDOM1和TDOM2的NWADDR和TUXEDO中的dom1config中的一致 ;
如果tuxedo为6.5版本则在中加入Yes如果为TUXEOD8.0则不需要。 X
(3)修改后的bdmconfig.xml内容如下： rB}
0
©WhiteLand -- Welcome WhiteLand　　EIMS,Q
GnPm|>
©WhiteLand -- Welcome WhiteLand　　m
H
5:d-DP
^
0wh
Coolio d0a
TDOM2 oa
TDOMAIN Ou&+m
NONE xEetD5
ON_DEMAND @\58
30 b][B&
//DEMOSERVER:9999 r&58d
!
Yes 6p384
|
OPj
TDOM2 psQY/
TDOM1 [
TDOMAIN vZ-
//DEMOSERVER:9998 Q
4]QCoZ
R!QI
AILhgP
LocalAccessPoint="TDOM2"> Qp
tuxedo.services.TOLOWERHome +F
6cM^4?
[\(Mx
ResourceName="TOUPPER" Ecv>
LocalAccessPoint="TDOM2" X:
RemoteAccessPointList="TDOM1"> f
600 `Uo$
LS{
v0W2#L

©WhiteLand -- Welcome WhiteLand　　Yxc
(4)执行java weblogic.wtc.gwt.WTCValidateCF bdmconfig.xml监测xml是否正确。 ;4
(5)在D:\SIMPAPP下执行build命令,然后在D:\weblogic\wtc1.0\examples\simpserv下执行build命令 0N4|_m
(6)启动welogic |K2g
(7)察看wtc_tolower.jar、wtc_toupper.jar是否deploy成功 axv
(8)建立一个WEBLOGIC StartUp Class: ]^
classname为 weblogic.wtc.gwt.WTCStartup 参数为BDMCONFIG=D:\SIMPAPP\bdmconfig.xml,并设置其TARGET为EXAMPLESERVER !MM%!8
(9)建立一个WEBLOGIC ShutDown Class: Qq3?>v
classname为weblogic.wtc.gwt.WTCShutdown,并设置其TARGET为EXAMPLESERVER Gc~X!i
(10)重新启动weblogic,并注意WEBLOGIC的启动日志看StartUp Class启动过程是否成功,失败会报错,成功没有提示信息 +91(g*
如果失败没有检查config.xml中是否为 X
@
H5@
©WhiteLand -- Welcome WhiteLand　　}w_bU
六、启动tuxedo =~
©WhiteLand -- Welcome WhiteLand　　Ck8(5G
七、运行例子 'w(M,a
在d:/simpapp下执行run.cmd,这是WEBLOGIC 做CLIENT端调用Toupper ejb，由Toupper ejb调用TUXEDO的SERVICE：TOUPPER z
在d:/simpapp下执行run.cmd，这是TUXEDO做CLIENT端调用WEBLOGIC中的Tolower ejb，
©WhiteLand -- Welcome WhiteLand　　F
八、如果是WEBLOGIC6.1 d6F]
TUXEDO的配置不变 \93O2
WEBLOGIC中从(2)开始配置.其中:DMCONFIG.XML中的,因为WEBLOGIC6.1中找不到wtc_config_1_0.dtd,可从WEBLOGIC6.1拷贝一个到WEBLOGIC6.1的安装目录下: &
如D:\WEBLOGIC6.1,并在DMCONFIG.XML指定它的路径 82{
I7]GE
©WhiteLand -- Welcome WhiteLand　　Kb871
九、失败处理 ]/PL
如果失败,可设置weblogic.wtc.gwt.WTCStartup的跟踪选项，即把它的参数设置为： BDMCONFIG=D:\simpapp\bdmconfig.xml,TraceLevel=20000 am:+7U
并请查看WEBLOGIC,TUXEDO的日志.做相应的处理。

yuyi 2005-03-09 14:30 发表评论

java日期时间处理

yuyi — Tue, 08 Mar 2005 03:17:00 GMT

摘要: Java统计从1970年1月1日起的毫秒的数量表示日期。也就是说，例如，1970年1月2日，是在1月1日后的86，400，000毫秒。同样的，1969年12月31日是在1970年1月1日前86，400，000毫秒。Java的Date类使用long类型纪录这些毫秒值.因为long是有符号整数，所以日期可以在1970年1月1日之前，也可以在这之后。Long类型表示的最大正值和最大负值可以轻松的表示29... 阅读全文

yuyi 2005-03-08 11:17 发表评论

jspSmartUpload

yuyi — Thu, 03 Feb 2005 03:28:00 GMT

一、安装篇

　　jspSmartUpload是由http://www.jspsmart.com网站开发的一...幸韵录父鎏氐悖?/a>

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

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

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

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

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

　　jspSmartUpload组件可以从 http://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为允许上传的文件的总长度。

jsp 上传图片并生成缩位图或者加水印
有些网站　　动网，　上传图片后加给加上自己的字（是在图片上加的）

　请问在JSP里如何实现？？
//添加水印,filePath 源图片路径， watermark 水印图片路径
public static boolean createMark(String filePath,String watermark) {
ImageIcon imgIcon=new ImageIcon(filePath);
Image theImg =imgIcon.getImage();
ImageIcon waterIcon=new ImageIcon(watermark);
Image waterImg =waterIcon.getImage();
int width=theImg.getWidth(null);
int height= theImg.getHeight(null);
BufferedImage bimage = new BufferedImage(width,height, BufferedImage.TYPE_INT_RGB);
Graphics2D g=bimage.createGraphics( );
g.setColor(Color.red);
g.setBackground(Color.white);
g.drawImage(theImg, 0, 0, null );
g.drawImage(waterImg, 100, 100, null );
g.drawString("12233",10,10); //添加文字
g.dispose();
try{
FileOutputStream out=new FileOutputStream(filePath);
JPEGImageEncoder encoder =JPEGCodec.createJPEGEncoder(out);
JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bimage);
param.setQuality(50f, true);
encoder.encode(bimage, param);
out.close();
}catch(Exception e){ return false; }
return true;
}

/////////////////范例////////////////////
package package;

import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;

public class upload
{

private static String newline = "\n";
private String uploadDirectory;
private String ContentType;
private String CharacterEncoding;

public upload()
{
uploadDirectory = ".";
ContentType = "";
CharacterEncoding = "";
}

private String getFileName(String s)
{
int i = s.lastIndexOf("\\");
if(i < 0 || i >= s.length() - 1)
{
i = s.lastIndexOf("/");
if(i < 0 || i >= s.length() - 1)
return s;
}
return s.substring(i + 1);
}

public void setUploadDirectory(String s)
{
uploadDirectory = s;
}

public void setContentType(String s)
{
ContentType = s;
int i;
if((i = ContentType.indexOf("boundary=")) != -1)
{
ContentType = ContentType.substring(i + 9);
ContentType = "--" + ContentType;
}
}

public void setCharacterEncoding(String s)
{
CharacterEncoding = s;
}

public String uploadFile(HttpServletRequest httpservletrequest)
throws ServletException, IOException
{
String s = null;
setCharacterEncoding(httpservletrequest.getCharacterEncoding());
setContentType(httpservletrequest.getContentType());
s = uploadFile(httpservletrequest.getInputStream());
return s;
}

public String uploadFile(ServletInputStream servletinputstream)
throws ServletException, IOException
{
String s = null;
String s1 = null;
byte abyte0[] = new byte[4096];
byte abyte1[] = new byte[4096];
int ai[] = new int[1];
int ai1[] = new int[1];
String s2;
while((s2 = readLine(abyte0, ai, servletinputstream, CharacterEncoding)) != null)
{
int i = s2.indexOf("filename=");
if(i >= 0)
{
s2 = s2.substring(i + 10);
if((i = s2.indexOf("\"")) > 0)
s2 = s2.substring(0, i);
break;
}
}
s1 = s2;
if(s1 != null && !s1.equals("\""))
{
s1 = getFileName(s1);
String s3 = readLine(abyte0, ai, servletinputstream, CharacterEncoding);
if(s3.indexOf("Content-Type") >= 0)
readLine(abyte0, ai, servletinputstream, CharacterEncoding);
File file = new File(uploadDirectory, s1);
FileOutputStream fileoutputstream = new FileOutputStream(file);
while((s3 = readLine(abyte0, ai, servletinputstream, CharacterEncoding)) != null)
{
if(s3.indexOf(ContentType) == 0 && abyte0[0] == 45)
break;
if(s != null)
{
fileoutputstream.write(abyte1, 0, ai1[0]);
fileoutputstream.flush();
}
s = readLine(abyte1, ai1, servletinputstream, CharacterEncoding);
if(s == null || s.indexOf(ContentType) == 0 && abyte1[0] == 45)
break;
fileoutputstream.write(abyte0, 0, ai[0]);
fileoutputstream.flush();
}
byte byte0;
if(newline.length() == 1)
byte0 = 2;
else
byte0 = 1;
if(s != null && abyte1[0] != 45 && ai1[0] > newline.length() * byte0)
fileoutputstream.write(abyte1, 0, ai1[0] - newline.length() * byte0);
if(s3 != null && abyte0[0] != 45 && ai[0] > newline.length() * byte0)
fileoutputstream.write(abyte0, 0, ai[0] - newline.length() * byte0);
fileoutputstream.close();
}
return s1;
}

private String readLine(byte abyte0[], int ai[], ServletInputStream servletinputstream, String s)
{
ai[0] = servletinputstream.readLine(abyte0, 0, abyte0.length);
if(ai[0] == -1)
return null;
break MISSING_BLOCK_LABEL_27;
Object obj;
obj;
return null;
if(s == null)
return new String(abyte0, 0, ai[0]);
return new String(abyte0, 0, ai[0], s);
obj;
return null;
}

}

JSP页：

<%@page contentType="text/html;charset=gb2312" import="package.upload"%>
<%
String Dir = "c:\dir\upload";
String fn="";
upload upload = new upload();
upload.setUploadDirectory(Dir);
fn=upload.uploadFile(request);
%>

随机图片名称
<%
mySmartUpload.initialize(pageContext);
mySmartUpload.service(request,response);
mySmartUpload.upload();
String fn=mySmartUpload.getFiles().getFile(0).getFileName();
mySmartUpload.save("upload/"); //文件保存的目录为upload
out.println("已经成功上传了文件，请查看这里");
%>
上面的程序可以上传图片，不过只能上传gif或者JPG图片。
而且保存图片在upload文件夹下面，要想GIF或Jpg图片的名称变为年+月+日+随机数.gif或年+月+日+随机数.jpg
只允许上传jpg或gif图片，在客户端用javaScript控制要好些。
变图片名称可用如下代码：自己看看就明白了。:
//得到实际路径

String realPath = this.masRequest.getRequest().getRealPath("/");
String userPhotoPath = realPath + "images\\UserPhoto\\";
userPhotoPath = MasString.replace(userPhotoPath,"\\","\\\\");
if (!file.getFileName().trim().equals(""))
{
//根据系统时间生成文件名
Date nowTime = new Date();
emp_Photo = userPhotoPath + String.valueOf(nowTime.getTime()) +"."+ file.getFileExt();
file.saveAs(emp_Photo);
System.out.println("file.saveAs() = " + "OK!!!");
}

yuyi 2005-02-03 11:28 发表评论

在JSP中使用JavaMail

yuyi — Thu, 03 Feb 2005 03:20:00 GMT

你希望在jsp中建立一个邮件发送收取工具吗？下面将介绍的就是在jsp中建立一个邮件发送收取工具。在这篇文章中你可以了解到JavaMail API的一些要点以及如何在JSP中使用它。本文中还包括了在JSP中使用JavaMail的实例。JavaMail是JSP应用软件中相当强大的API。

阅读这篇文章需要对JSP、JavaBeans和JavaMail有一定的初步了解。当然，有关于JavaMail的知识你可以通过阅读这篇文章来获得。如果你对于以上三项一无所知，但你所使用的服务器支持JSP和JavaMail的话，你可以仅仅通过复制/粘贴来使用它们。

什么是JavaMail

JavaMail是Sun发布的用来处理email的API。它可以方便地执行一些常用的邮件传输。

虽然JavaMail是Sun的API之一，但它目前还没有被加在标准的java开发工具包中（Java Development Kit），这就意味着你在使用前必须另外下载JavaMail文件。除此以外，你还需要有Sun的JavaBeans Activation Framework （JAF）。JavaBeans Activation Framework的运行很复杂，在这里简单的说就是JavaMail的运行必须得依赖于它的支持。在Windows 2000下使用需要指定这些文件的路径，在其它的操作系统上也类似。

接下来要讲解的是这篇指南的最难理解的部分。

这篇指南包括三部分：HTML表格、关于JavaMail、JavaMail和JSP的结合。

第一部分：HTML表格

第一部分提供了一个最基本的基于HTML的email发送收取程序的例子。第二部分则讲述JavaMail的工作原理。第三部分则介绍将JavaMail加入JSP，创建一个基本的email发送收取程序。

划分组件

JSP最重要的特性是能将整个网页划分成一些细小的组件。这里使用的组件包括：

●一个用来将email的信息发送给JSP的HTML表格；

●一个JSP页面用来处理和发送信件。

第一步，就是创建一个HTML表格用来给JSP页面发送信息。你可以将以下的HTML代码复制到你的电脑上：

用来发送email的HTML源代码

以上这段程序将创建一个包含email基本信息（例如：收件地址、发送地址、主题和内容）的文件。当然你可以根据你自己的需要来决定这个文件包含那些信息。

这个HTML文件的使用有两点要求：第一点是生成的文件必须发送给接下来将介绍的程序使用。在这个例子中就是sendmail.jsp，但在你使用时，必须用这个文件在系统里的URL来代替它；第二点是必须有空间来允许用户发送email。

第二部分将对JavaMail的特征进行一些分析，为在第三部分创建JSP程序作准备。所以接下来我们将学习JavaMail。

第二部分：关于JavaMail

文档的使用

下载的JavaMail API中带的文档是很有用的。你可以在JavaMail下的/docs/javadocs/index.html找到它。第二部分主要将分析邮件程序的组件。你可以通过阅读文档来获得更多这方面的信息。

组件发送邮件需要使用JavaMail，它使对邮件的操作变得简单易用。

属性对象

JavaMail需要创建一个格式为"mail.smtp.host"的文件用来发送信息。

Properties props = new Properties ();

props.put("mail.smtp.host", "smtp.jspinsider.com"); 对话对象

所有的基于JavaMail的程序都至少需要一个或全部的对话目标。

Session sendMailSession;

sendMailSession = Session.getInstance(props, null);

传输

邮件的传输只有送出或受到两种状态。JavaMail将这两种不同状态描述为传输和储存。传输将送出邮件，而储存将收取邮件。

Transport transport;

transport = sendMailSession.getTransport("smtp");

使用JavaMail能为我们节约大量的时间。JavaMail能代替所有的SMTP的工作。

注意：JavaMail并不能完全的支持所有的邮件发送收取工作。它目前仅支持IMAP、SMTP和POP3，除此以外你只有等待新的JavaMail版本或自己开发协议。

信息对象

信息对象将把你所发送的邮件真实的反映出来。

Message newMessage = new MimeMessage(sendMailSession);

这就是我们所需要的全部四个对象。下一步将是如何将对象加入到JSP中。

第三部分：JavaMail和JSP的结合

创建JSP

下面我们将开始将他们结合在一起。最重要的一点是要确认根据页面指示分类。还要记得在邮件上标注java.util.date。

<%@ page

import= " javax.mail.*, javax.mail.internet.*, javax.activation.*, java.util.*"

%>

其次，创建邮件发送的确认信息。确认信息可以是任意的，一般常用"你的邮件已经发送出去了（Your mail has been sent）。"

信息是如何创建和发送的

我们在第二部分里已经讨论过信息对象的创建。我们下面将对信息进行操作。这就和设置信息对象的属性一样简单。你可以通过下面的程序来实现这项操作。

newMessage.setFrom(new InternetAddress(request.getParameter("from")));

newMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(request.getParameter("to")));

newMessage.setSubject(request.getParameter("subject"));

newMessage.setSentDate(new Date());

newMessage.setText(request.getParameter("text"));

现在将开始发送信息。通过JavaMail来实现它非常简单。

transport.send(newMessage);

将所有的组件结合在一起

现在所有的组件都已经齐全了。现在将它们都放在JSP里面。要注意每一个错误信息，并将它反馈给用户。代码如下，你可以通过复制它们直接使用：

Sample JSP email Utility Using JavaMail

<%@ page

import=" javax.mail.*, javax.mail.internet.*, javax.activation.*,java.util.*"

%>

JSP meets JavaMail, what a sweet combo.

<%

try{

Properties props = new Properties();

Session sendMailSession;

Store store;

Transport transport;

sendMailSession = Session.getInstance(props, null);

props.put("mail.smtp.host", "smtp.jspinsider.com");

Message newMessage = new MimeMessage(sendMailSession);

newMessage.setFrom(new InternetAddress(request.getParameter("from")));

newMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(request.getParameter("to")));

newMessage.setSubject(request.getParameter("subject"));

newMessage.setSentDate(new Date());

newMessage.setText(request.getParameter("text"));

transport = sendMailSession.getTransport("smtp");

transport.send(newMessage);

%>

Your mail has been sent.

<%

}

catch(MessagingException m)

{

out.println(m.toString());

}

%>

你会很快体会到JavaMail的方便之处，JSP和JavaMail将是未来的希望。

文件/图片上传
package uploadfile;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.FileOutputStream;
import java.io.*;
import java.util.Hashtable;
import java.util.*;

public class FileUploadBean {

private String savePath=null; //文件上传保存的路径
private String contentType=""; //内容类型
private String charEncode=null; //字符编码
private String boundary=""; //分界线
private String fileName=null; //本地文件名字
private Hashtable dic=new Hashtable(); //用于保存"元素名--元素值"对
private int totalSize=0; //上传文件总大小
private String path=""; //保存文件的路径
private String newFileName=""; //存入随机产生的文件名

///////////////////////////////////////////////////
//设置文件上传保存的路径
public void setSavePath(String s) {
s=path+s;
savePath=s;
System.out.println("上传路径："+savePath);
}

///////////////////////////////////////////////////
//取文件上传保存的路径
public String getSavePath() {
return savePath;

}

////////////////////////////////////////////////////
//设置文件名字,也可以为它命名,暂时先用它原来的名字
public void setFileName(String s) {
int pos=s.indexOf("\"; filename=\"");
if (pos>0) {
s=s.substring(pos+13,s.length()-3); //去 " 和 crlf
pos=s.lastIndexOf("\\");
if (pos<0)
pos=s.lastIndexOf("/");
if (pos<0)
fileName=s;
fileName=s.substring(pos+1);
}
}

////////////////////////////////////////////////////
//取得文件名
public String getFileName() {
System.out.println("得到文件名"+newFileName);
return newFileName;

}
///////////////////////////
//以时间为种子数产生新文件名
public String getNewFileName() {
int pos=0; //.的位置
long seed=0; //随机种子数
String ext=""; //存入文件扩展名
System.out.println("upload file name："+fileName);
pos=fileName.lastIndexOf(".");
ext=fileName.substring(pos); //得到扩展名
seed=new Date().getTime();
Random rand=new Random(seed);//以时间为种子产生随机数作为文件名
newFileName=Long.toString(Math.abs(rand.nextInt()))+ext; //生成文件名
System.out.println("new file name:"+newFileName);
return newFileName;

}
//////////////////////////////////////////////////////
//设置字符的编码方式
public void setCharEncode(HttpServletRequest req) {
charEncode=req.getCharacterEncoding();
}

/////////////////////////////////////////////////
//设置得ContentType
public void setBoundary(HttpServletRequest req) {
//传递的参数值类似"multipart/form-data; boundary=---------------------------7d21441a30013c"
//传过来的分界线比实际显示在上传数据中的要多两个"--"

boundary=req.getContentType();
//System.out.println("boundary"+boundary);
int pos=boundary.indexOf("boundary=");
//加上这两个"--"
boundary="--"+boundary.substring(pos+9);

}

////////////////////////////////////////////////////
//取得ContentType
public String getBoundary(){
//返回值类似"-----------------------------7d21441a30013c"
return boundary;
}

/////////////////////////////////////////////
//设置ContentType
public void setContentType(String s) {
int pos =s.indexOf(": ");
if (pos!=-1)
contentType=s.substring(pos+2);
}

////////////////////////////////////////////
//取得ContentType
public String getContentType() {
return contentType;
}

/////////////////////////////////////////////
//初始化
public void init(HttpServletRequest req) {
setCharEncode(req);
setBoundary(req);

}

////////////////////////////////////////////////////
//取哈希表中的数据
public String getFieldValue(String s) {
String temp="";
if(dic.containsKey(s)) //判断表中是否存在s键,不判断则返回nullpointerException
{
temp=(String)dic.get(s);
temp=temp.trim();
}else
temp="";
return temp;
}

////////////////////////////////////////////////
////用指定的编码方式生成字符串
public String newLine(byte oneLine[],int sp,int i,String charEncode)
throws java.io.UnsupportedEncodingException {
sp=0; // start position
String lineStr=null;
if (charEncode!=null) {
return lineStr=new String(oneLine,sp,i,charEncode); //用指定的编码方式生成字符串
}
else {
return lineStr=new String(oneLine,sp,i);
}
}

///////////////////////////////////////////////
//得到上传文件的大小
public int getTotalSize() {
return totalSize/1000;
}
///////////////////////////////////////
//删除指定路径的文件
public boolean delFiles(String fn) //fn为要删除的文件名，不包括路径
{
try
{
File file=new File(savePath+fn);
System.out.println(savePath+fn);
if(file.exists())
{
file.delete();
System.out.println(file.getPath()+"delete file successfully!");
return true;
}else
{
System.out.println("the file is not existed!");
return true;
}
}catch(Exception e)
{
System.out.println(e.toString());
return false;
}
}

////////////////////////////////////////////////
//文件列表
public String[] listFiles(String fp)
{
String[] lf=null;
try{
savePath=path+fp;
File file=new File(savePath);
lf=file.list(new DirFilter());
for(int i=0;iSystem.out.println(lf[i]);
}catch(Exception e){ e.printStackTrace();}
return lf;
}
/////////////////////////////////////////////////
//开始上传文件
public boolean doUpload(HttpServletRequest req)
throws java.io.IOException {

String fieldValue=""; //表单元素值
String fieldName=""; //表单元名称
int pos=-1; //临时变量,用于记录位置
int pos2=-1; //临时变量,用于记录位置
String lineStr=null; //用oneLine[]生成的每行字符串
byte oneLine[] =new byte[4096]; //用于每次读取的数据
FileOutputStream fos=null; //文件输出流
init(req); //初始化
ServletInputStream sis=req.getInputStream();
int i=sis.readLine(oneLine,0,oneLine.length); //返回实际读取的字符数,并把数据写到oneLine中
while (i!=-1) {
lineStr=newLine(oneLine,0,i,charEncode); //生成字符串
if (lineStr.indexOf(getBoundary()+"--")>=0)
break;

if (lineStr.startsWith("Content-Disposition: form-data; name=\"")) {
//分离数据,因为表单元素也一并上传,还有其它数据,对我们有用的只是
//文件的内容,表单元素及表单元素对应的值
if (lineStr.indexOf("\"; filename=\"")>=0) { //是文件输入域
//设置文件名
setFileName(lineStr);
if (!fileName.equals("")) { //如果文件名为空则跳过

//提取表单元素名称及表单元素对应的值
pos=lineStr.indexOf("name=\"");
pos2=lineStr.indexOf("\"; filename=\"");
//表单元素名字
fieldName=lineStr.substring(pos+6,pos2);
//表单元素值
fieldValue=lineStr.substring(pos2+13,lineStr.length()-3);
//加入哈希表中
dic.put(fieldName,fieldValue);
sis.readLine(oneLine,0,oneLine.length); //读取的数据类似"Content-Type: text/plain"
sis.readLine(oneLine,0,oneLine.length); //空行
//建立文件输出
fos=new FileOutputStream(new File(getSavePath(),getNewFileName()));
//开始读上传文件数据
i=sis.readLine(oneLine,0,oneLine.length);
while(i!=-1) {
totalSize=i+totalSize;
lineStr=newLine(oneLine,0,i,charEncode);
if (lineStr.indexOf(getBoundary())>=0)
break; //表明这个文件区的数据读取完毕
fos.write(oneLine,0,i);
i=sis.readLine(oneLine,0,oneLine.length);
}//end while
fos.close();
}//end if (!getFileName().equals(""))
}
else { //非文件输入域
pos=lineStr.indexOf("name=\"");
//表单元素名字
fieldName=lineStr.substring(pos+6,lineStr.length()-3);
//读空行
sis.readLine(oneLine,0,oneLine.length);
//这行含有元素值,如里元素值为空,则这行也是空行,也要读的
String temp="";
i=sis.readLine(oneLine,0,oneLine.length);
while(i!=-1)
{
temp=newLine(oneLine,0,i,charEncode);
if (temp.indexOf(getBoundary())>=0)
break;
fieldValue=fieldValue+temp;
i=sis.readLine(oneLine,0,oneLine.length);
}
//加入哈希表中
dic.put(fieldName,fieldValue);
fieldValue="";
}
}
i=sis.readLine(oneLine,0,oneLine.length);
}//end while

sis.close();

return true;
} //end doUpload

//////////////////////////
//清空Hashtable
public void clearDic() {
dic.clear();
if (dic.isEmpty()) {
System.out.println("empty");
}
else {
System.out.println("not empty");
}

}
//////////////////////////////////
//测试用的主函数
public static void main(String args[])
{
String[] fileList=null;
try{
FileUploadBean fub=new FileUploadBean();
fileList=fub.listFiles("/avatars/");
for(int i=0;iSystem.out.println(fileList[i]);

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

}

///////////////////////////////////
////文件目录过滤内部类
class DirFilter implements FilenameFilter {

public boolean accept(File dir, String name) { //dir为目录名，name 为包含路径的文件名

File f = new File(dir,name); //生成文件对象
if(f.isDirectory())
return false;
return true;
}
}

yuyi 2005-02-03 11:20 发表评论

在jsp中使用smartupload组件上传文件

yuyi — Thu, 03 Feb 2005 03:17:00 GMT

jsp对上传文件的支持不象php中支持的那么好，直接做成了函数，也不象asp中要通过组件才能实现。jsp中可以通过javabean来实现。但是我们没有必要自己去写一个上载的bean，在网上已经有了很多成型的技术，smartupload就是其中的一个。但是smartupload是将文件先读到服务器的内存中，所以上传太大的文件（超过100兆）有可能会出问题，也算是一个美中不足吧：）

先说一下提交的页面，smartupload组件要求用字节流的方式来提交

再来看一下接收的页面，我们把文件上传到服务器以后就直接把它再存入数据库中：upload.jsp

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<%@ page import="com.jspsmart.upload.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
//实例化上载bean
com.jspsmart.upload.SmartUpload mySmartUpload=new com.jspsmart.upload.SmartUpload();
//初始化
mySmartUpload.initialize(pageContext);
//设置上载的最大值
mySmartUpload.setMaxFileSize(500 * 1024*1024);
//上载文件
mySmartUpload.upload();
//循环取得所有上载的文件
for (int i=0;i//取得上载的文件
com.jspsmart.upload.File myFile = mySmartUpload.getFiles().getFile(i);
if (!myFile.isMissing())
{
//取得上载的文件的文件名
String myFileName=myFile.getFileName();
//取得不带后缀的文件名
String suffix=myFileName.substring(0,myFileName.lastIndexOf('.'));
//取得后缀名
String ext= mySmartUpload.getFiles().getFile(0).getFileExt();
//取得文件的大小
int fileSize=myFile.getSize();
//保存路径
String aa=getServletContext().getRealPath("/")+"jsp\\";
String trace=aa+myFileName;
//取得别的参数
String explain=(String)mySmartUpload.getRequest().getParameter("text");
String send=(String)mySmartUpload.getRequest().getParameter("send");
//将文件保存在服务器端
myFile.saveAs(trace,mySmartUpload.SAVE_PHYSICAL);
//下面的是将上载的文件保存到数据库中
//将文件读到流中
java.io.File file = new java.io.File(trace);
java.io.FileInputStream fis = new java.io.FileInputStream(file);
out.println(file.length());
//打开数据库
ResultSet result=null;
String mSql=null;
PreparedStatement prestmt=null;
DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
DbaObj.OpenConnection();
//将文件写到数据库中
mSql="insert into marklist (markname,password,marksize,markdate,MarkBody) values (?,?,?,?,?)";
prestmt =DbaObj.Conn.prepareStatement(mSql);
prestmt.setString(1, "aaa1");
prestmt.setString(2, "0000");
prestmt.setInt(3, fileSize);
prestmt.setString(4, DbaObj.GetDateTime());
prestmt.setBinaryStream(5,fis,(int)file.length());
DbaObj.Conn.setAutoCommit(true) ;
prestmt.executeUpdate();
DbaObj.Conn.commit();
out.println(("上载成功！！！").toString());
}
else
{ out.println(("上载失败！！！").toString()); }
}//与前面的if对应
%>

再说一下下载，下载分两种情况1。从数据库直接下载2。从服务器上下载

先说从数据库直接下载的情形：就是把输入流从数据库里读出来，然后转存为文件

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.sql.*"%>
<%@ page import="java.io.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
int bytesum=0;
int byteread=0;
//打开数据库
ResultSet result=null;
String Sql=null;
PreparedStatement prestmt=null;
DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
DbaObj.OpenConnection();
//取得数据库中的数据
Sql="select * from t_local_zhongzhuan ";
result=DbaObj.ExecuteQuery(Sql);
result.next();

//将数据库中的数据读到流中
InputStream inStream=result.getBinaryStream("content");
FileOutputStream fs=new FileOutputStream( "c:/dffdsafd.doc");

byte[] buffer =new byte[1444];
int length;
while ((byteread=inStream.read(buffer))!=-1)
{
out.println("

"+byteread+"

");
bytesum+=byteread;
System.out.println(bytesum);

fs.write(buffer,0,byteread);
}
%>

再说从服务器上下载的情形：

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.io.*" %>
<%
String fileName = "zsc104.swf".toString();
f//读到流中
InputStream inStream=new FileInputStream("c:/zsc104.swf");
//设置输出的格式
response.reset();
response.setContentType("bin");
response.addHeader("Content-Disposition","attachment; filename=\"" + fileName + "\"");
//循环取出流中的数据
byte[] b = new byte[100];
int len;
while((len=inStream.read(b)) >0)
response.getOutputStream().write(b,0,len);
inStream.close();
%>

缩略图实现，将图片(jpg,gif,bmp等等)真实的变成想要的大小
import java.io.*;
import java.util.*;
import com.sun.image.codec.jpeg.*;
import java.awt.image.*;
import java.awt.*;
import java.net.*;
import java.applet.*;
import java.sql.*;
//缩略图类，
//本java类能将jpg图片文件，进行等比或非等比的大小转换。
//具体使用方法
//s_pic(大图片路径,生成小图片路径,大图片文件名,生成小图片文名,生成小图片宽度,生成小图片高度,是否等比缩放(默认为true))
public class Small_pic{
String InputDir; //输入图路径
String OutputDir; //输出图路径
String InputFileName; //输入图文件名
String OutputFileName; //输出图文件名
int OutputWidth=80; //默认输出图片宽
int OutputHeight=80; //默认输出图片高
int rate=0;
boolean proportion=true; //是否等比缩放标记(默认为等比缩放)

public Small_pic(){
//初始化变量
InputDir="";
OutputDir="";
InputFileName="";
OutputFileName="";
OutputWidth=80;
OutputHeight=80;
rate=0;
}

public void setInputDir(String InputDir){
this.InputDir=InputDir;
}

public void setOutputDir(String OutputDir){
this.OutputDir=OutputDir;
}

public void setInputFileName(String InputFileName){
this.InputFileName=InputFileName;
}

public void setOutputFileName(String OutputFileName){
this.OutputFileName=OutputFileName;
}

public void setOutputWidth(int OutputWidth){
this.OutputWidth=OutputWidth;
}

public void setOutputHeight(int OutputHeight){
this.OutputHeight=OutputHeight;
}

public void setW_H(int width,int height){
this.OutputWidth=width;
this.OutputHeight=height;
}

public String s_pic(){
BufferedImage image;
String NewFileName;
//建立输出文件对象
File file = new File(OutputDir+OutputFileName);
FileOutputStream tempout =null;
try{
tempout= new FileOutputStream(file);
}catch(Exception ex){
System.out.println(ex.toString());
}
Image img=null;
Toolkit tk=Toolkit.getDefaultToolkit();
Applet app=new Applet();
MediaTracker mt = new MediaTracker(app);
try {
img=tk.getImage(InputDir+InputFileName);
mt.addImage(img, 0);
mt.waitForID(0);
}catch(Exception e) {
e.printStackTrace();
}

if(img.getWidth(null)==-1){
System.out.println(" can't read,retry!"+"
");
return "no";
}else{
int new_w;
int new_h;
if (this.proportion==true) //判断是否是等比缩放.
{
//为等比缩放计算输出的图片宽度及高度
double rate1=((double)img.getWidth(null))/(double)OutputWidth+0.1;
double rate2=((double)img.getHeight(null))/(double)OutputHeight+0.1;
double rate=rate1>rate2?rate1:rate2;
new_w=(int)(((double)img.getWidth(null))/rate);
new_h=(int)(((double)img.getHeight(null))/rate);
}
else{
new_w=OutputWidth; //输出的图片宽度
new_h=OutputHeight; //输出的图片高度
}
BufferedImage buffImg = new BufferedImage(new_w,new_h,BufferedImage.TYPE_INT_RGB);

Graphics g = buffImg.createGraphics();

g.setColor(Color.white);
g.fillRect(0,0,new_w,new_h);

g.drawImage(img,0,0,new_w,new_h,null);
g.dispose();

JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(tempout);
try{
encoder.encode(buffImg);
tempout.close();
}catch(IOException ex){
System.out.println(ex.toString());
}
}
return "ok";
}

public String s_pic(String InputDir,String OutputDir,String InputFileName,String OutputFileName){
//输入图路径
this.InputDir=InputDir;
//输出图路径
this.OutputDir=OutputDir;
//输入图文件名
this.InputFileName=InputFileName;
//输出图文件名
this.OutputFileName=OutputFileName;
return s_pic();
}

public String s_pic(String InputDir,String OutputDir,String InputFileName,String OutputFileName,int width,int height,boolean gp){
//输入图路径
this.InputDir=InputDir;
//输出图路径
this.OutputDir=OutputDir;
//输入图文件名
this.InputFileName=InputFileName;
//输出图文件名
this.OutputFileName=OutputFileName;
//设置图片长宽
setW_H(width,height);
//是否是等比缩放标记
this.proportion=gp;
return s_pic();
}
public static void main(String [] a)
{
//s_pic(大图片路径,生成小图片路径,大图片文件名,生成小图片文名,生成小图片宽度,生成小图片高度)
Small_pic mypic =new Small_pic();
System.out.println(
mypic.s_pic("E:\\JAVA\\J2EEDatum\\王亮jsp资料\\缩图例子\\personal\\",
"E:\\JAVA\\J2EEDatum\\酒剑仙jsp资料\\缩图例子\\personal\\",
"1.jpg","new1.jpg",80,80,true)
);
}

yuyi 2005-02-03 11:17 发表评论

jsp初学大全

yuyi — Thu, 03 Feb 2005 03:15:00 GMT

测试环境为 jdk1.2.2　jswdk-1.0　winnt4.0中文版。

1。java是大小写敏感的，用过其他编程语言的人最容易犯这个错误，尤其是刚上手的时候。我刚开始调试jsp的时50%以上的编译错误是都是因为这个。

2。java的调用过程都是要加括号的，一开始比较容易忽视，如title=request.getParameter(\"title\").trim();

3。jsp中对应asp中的request.form()和request.querystring()的解决方法。
jsp中取得参数没有form和queryString之分，都是通过request.getParameter(\"XXXX\")来取得。虽然jsp也有request.getQueryString()方法，但测试结果是 test.jsp?id=1&page=20　得到 id=1&page=20。
　如果url和form有相同的参数名称呢？下面是一段测试代码：

name都是id，结果是url的参数优先得到，jsp的这种处理方式和asp相比我觉的各有所长。

4。头疼的汉字处理问题。
在其他的文章里曾说到在中文NT环境下如下语句输出会得到乱码，
<%=\"你好\"%> 及 out.print(\"你好\");等。解决方法是只要对字符串变量进行编码就可以得到正确结果,如下代码可以得到正确的输出：
<%　String title=\"你好\";
　byte[] tmpbyte=title.getBytes(\"ISO8859_1\");
　title=new String(tmpbyte);
　out.print(title); %>
或者<%=title%>

关于sql语句汉字问题，例句为 select * from test where title=\'谁是傻瓜\'
在jdbc-odbc驱动下连db2，不管是原句还是对sql语句进行编码后都死活通不过。
换了ibm的jdbc直接驱动后，对sql语句编码后程序可以通过。

这个问题的产生大概是中文NT的原因，在其他环境下可能就没汉字处理问题了，据说ibm的web sphere对中文支持的很好，这也给jsp的开发带来一定的通用性问题。据说对字符串编码是一种通用的解决方法，不过没有这么多环境来测试。

5。在asp中经常使用到字符串判断语句如 if state=\"真是傻瓜\" then.....
　在java中String变量不是一个简单的变量而是一个类实例，不同的方法会得到不同的结果
a.
String　str1=\"我是傻瓜\";
String　str2=\"我是傻瓜\"; (or String　str2=\"我是\"+\"傻瓜\"; )
if (str1==str2)
　out.print(\"yes\");
else　
　out.print(\"no\");
结果是\"yes\"。
大概是编译优化，str1,str2指向同一个类实例；

b.
String str1,str2,str3;
str1=\"我是傻瓜\";
str2=\"我是\";
str3=str2+\"傻瓜\";
if (str1==str3)
　out.print(\"yes\");
else
　out.print(\"no\");
结果是\"no\"。

String str1=new String(\"我是傻瓜\");
String str2=new String(\"我是傻瓜\");
if (str1==str2)
　out.print(\"yes\");
else
　out.print(\"no\");
结果是\"no\"。

String str1=new String(\"我是傻瓜\");
String str2=new String(\"我是傻瓜\");
if (str1.compareTo(str2)==0)
　out.print(\"yes\");
else
　out.print(\"no\");
结果是\"yes\"。

所以在jsp中判断字符串要使用compareTo方法，用惯传统语言还真一下子适应不过来，熟悉java的朋友应该没这个问题。

6。如何判断数据库为空？
　 result = stmt.executeQuery(sql);
　 if (result.next())
　　　......
　 result执行后游标出于一个未明的状态，不能进行状态判断，也不能取值，一定要next()一下才可以用。
　

7。在jsp中实现分页。
page是关键字，不能当变量。
conn.jsp
<%
　　String sDBDriver = \"COM.ibm.db2.jdbc.app.DB2Driver\";
　　String sConnStr = \"jdbc:db2:faq\";
　　Connection conn = null;
　　Statement stmt = null;
　　ResultSet rs=null;
　　　 try {
　　　　　　　 Class.forName(sDBDriver);　　
　　}
　　　 catch(java.lang.ClassNotFoundException e)　　 {
　　　　out.print(\"faq(): \" + e.getMessage());
　　}
　　
　　try{
　　　 conn = DriverManager.getConnection(sConnStr,\"wsdemo\",\"wsdemo1\");　　　　
　　　 stmt = conn.createStatement();
　　}catch(SQLException e){
　　　　out.print(e.toString());
　　}
%>

query.jsp

<%@ page language=\"java\" import=\"java.sql.*\"　%>
<%@ page contentType=\"text/html; charset=gb2312\" %>
<%@ include file=\"conn.jsp\" %>
<%
.......
int pages=0;
int pagesize=10;
ResultSet result = null;
ResultSet rcount = null;

pages = new Integer(request.getParameter(\"pages\")).intValue();

if (pages>0)
{

String sql=\" state=\'我不傻\'\";
int count=0;
try {
rcount = stmt.executeQuery(\"SELECT count(id) as id from user where \"+sql);
catch(SQLException ex) {
　out.print(\"aq.executeQuery: \" + ex.getMessage());
　}
if(rcount.next())
　count = rcount.getInt(\"id\");
rcount.close();

if (count>0)
{
sql=\"select * from user where　\"+sql;
try {
result = stmt.executeQuery(sql);
　　}
catch(SQLException ex) {
　out.print(\"aq.executeQuery: \" + ex.getMessage());
　}

int i;
String name;
//　result.first();
//　result.absolute((pages-1)*pagesize);
//　此方法jdbc2.0支持。编译通过，但执行不过，不知是不是跟驱动有关，只好用下面的笨办法。
for(i=1;i<=(pages-1)*pagesize;i++)
　result.next();
for(i=1;i<=pagesize;i++) {
　if (result.next()) {
　name=result.getString(\"name\");
　out.print(name);
　}
result.close();
int n= (int)(count/pagesize);
if (n*pagesizeif (n>1)
{
for(i=1;i<=n;i++)
　 out.print(\"\"+i+\" \");
}
}
}
%>

现在有好多初学jsp的网友经常会问数据库怎么连接啊，怎么老出错啊？所以我集中的在这写篇文章供大家参考，其实这种把数据库逻辑全部放在jsp里未必是好的做法，但是有利于初学者学习，所以我就这样做了，当大家学到一定程度的时候，可以考虑用MVC的模式开发。在练习这些代码的时候，你一定将jdbc的驱动程序放到服务器的类路径里，然后要在数据库里建一个表test,有两个字段比如为test1，test2，可以用下面SQL建
create table test(test1 varchar(20),test2 varchar(20)
然后向这个表写入一条测试纪录
那么现在开始我们的jsp和数据库之旅吧。
一、jsp连接Oracle8/8i/9i数据库（用thin模式）
testoracle.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为你的数据库的SID
String user="scott";
String password="tiger";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

二、jsp连接Sql Server7.0/2000数据库
testsqlserver.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";
//pubs为你的数据库的
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

三、jsp连接DB2数据库
testdb2.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample";
//sample为你的数据库名
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

四、jsp连接Informix数据库
testinformix.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

五、jsp连接Sybase数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/tsdata";
//tsdata为你的数据库名
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

六、jsp连接MySQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

七、jsp连接PostgreSQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>

<%Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/soft"
//soft为你的数据库名
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>

yuyi 2005-02-03 11:15 发表评论

To:	From:
Subject:
Message: