java读取PI数据库测点值

Java读取PI数据库测点值

最近公司组织培训PI数据库，在听课之余试验了一下java直接读取PI数据库。

1.安装数据库。

安装osi,启动PIPerfMon_Basic.bat,使用processbook绘制一个趋势图，加入几个例

子测点，如“CDT158”,如图：

2.Piapi简介

利用PIAPI直接操作PI,安装PI数据库后会有一个piapi32.dll,提供了.net读取的接口。

3.Jnative简介

川ative是一种能够使Java语言使调用DLL的一种技术，对JNI进行了封装。我们将下载

的jnative.jar解压后,有一个jNativeCpp.dll,将其拷入C:\windows\system32下，并将

jnative.jar加载到我们项目中来。准备工作就绪。

4.程序读取。

要点记录：

1.阅读API。打开PISystem->aboutPISDK->ViewHelp,即可看到api文档。

PI数据库的数据分别存储在Snapshot或者Archive中，一个是快照一个是档案文

件，这样做是为了方便PI数据库对数据进行压缩,那么自然对数据库的读取也分为对

Snapshot和Archive读取.snapshot和archive的值都是用PIValue的形式表

示的，PIValue对象包括了数值和时间。

其中Pi的api中，用到最多的函数组是timefunctions、archivefunctions、snapshot

functions»timefunctions包含很多对时间处理的函数；archivefunctions包含了对档

案文件的读写的函数；snapshotfunctions包含了对快照的读取函数。

2.时间处理。

.net调用piapi传入时间类型时，是将.net的Date类型转为int数组，并可以直接将

int数组传入方法。Java使用时间类型稍微复杂一些，需要调用pitmjntsec方法，该

方法帮助如下：

PIVOIDpitm_intsec(

int32PIPTR*timedate,

int32timearray[6]);

Returns

None

Arguments

timedate(returned)

PItimestamp

timearray(passed)

表示该方法2个参数，第一个是一个int型数组(指针)，第二个参数是一个int型

数组。第一个参数是返回参数，第二个参数是传入参数。

注意，传入int32timearray⑹参数时，必须使用Pointer模拟指针,并且,循环设置

数组元素时，注意pointer.setlntAt(intoffset,intvalue),offset的下标，比如第一个元素

是0,第二个元素不是1,要看int占几个字节，int在。Net中占4个字节，所以第二个

元素是4,第三个元素是8。这是java调用.net时，传入和读取数组时需要注意的事项。

3.Java与。Net类型匹配。

Api里的除字符串外的指针类型，对应jnative的pointer。

Api里的int>float等基本类型和String类型，在java中必须指定类型(Type.INT)

Api里的date,是用int口表示的，详见上条。

4.传值与返回值。

Jnative对象调用invoke后会有返回，对照api,一般返回值是调用状态。如果要查询一

个测点值，返回值是通过传入的pointer对象读取出来的。

源代码如下:

importjava・text.ParseException;

importjava,text.SimpleDateFormat;

importjava・util.Calendar;

importjava.util.Date;

importjava・util.regex.Matcher;

importjava.util.regex.Pattern;

importorg.xvolks.jnative.JNative;

importorg•xvolks.jnative.Type;

importorg.xvolks.jnative.exceptions.NativeException;

importorg.xvolks,jnative.pointers.Pointer;

importorg.xvolks,jnative.pointers.memory.HeapMemoryBlock;

importorg.xvolks.jnative.pointers.memory.MemoryBlock;

importorg.xvolks•jnative.pointers.memory.MemoryBlockFactory;

★★

*Java通过jnative调用pi实时数据库dll类库piapi32.dll获取tag标签数据

*

★/

publicclassPlClientUtil{

privatestaticPlClientUtilpiClientUtil=newPlClientUtil();

publicstaticvoidmain(String[]args){

//PlClientUtil.getPlClientUtil().getTimeFromlnt("");

//PlClientUtil.getPlClientUtil().getTagValue(npicompress_Compressi

onRatio_CALCT,);

//PlClientUtil.getPlClientUtil().getTagValueByTime(nCDT158H,n2012-

05-17;

//PlClientUtil.getPIClientUtil().getTagValuesByTimeToTime(HCDT

11,n

158“，“2012-05-1711:11:ll,,2012-05-1718:00:00z2);

PlClientUtil.getPIClientUtil().getTagMaxValue("CDT158”，“2012-0

nH

5-17ll:ll:llz2012-05-1718:00:00”)；

//PlClientUtil.getPIClientUtil().getTimeSecint(1);

//PlClientUtil.getPIClientUtil().getPiTime("“);

//PlClientUtil.getPIClientUtil().getTimelntSec(n2012-03-03

12:00:00°);

)

publicstaticPlClientUtilgetPIClientUtil(){

returnpiClientUtil;

)

privatePlClientUtil(){

try(

//*********************连接p[数据库

*★★★*************★*★******//

//

***★*****★*****★*★★★*★***★*****★*★*★*****★*****★*★★★*★****//

JNativemessageBox=newJNative(npiapi32.dlln,

“piujsetservernode“);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0,Type.STRING,”")；//月艮

务器ip

messageBox.invoke();

System.out.printIn(npiut_setservernode:H+messageBox.getRetValAsInt

0)；

}catch(NativeExceptione){

//TODOAuto-generatedcatchblock

e,printStackTrace();

}catch(IllegalAccessExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

)

*获取tag最新值

*@paramtagName

*©return

*/

publicfloatgetTagValue(StringtagName){

try(

JNativemessageBox=newJNative(npiapi32.dlln,

,Tpipt_findpoinf*);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0rType.STRING,tagName);

Pointerp=newPointer(newHeapMemoryBlock(1024));

messageBox.setParameter(1,p);

messageBox.invoke();

intptld=p.getAsInt(0);

if(0==messageBox.getRetValAsInt()){

System.out.printIn(”测点id:n+ptld);

n1

messageBox=newJNative(piapi32.dll'z

npisn_getsnapshotn);

messageBox.setRetVal(Type.工NT);

messageBox.setParameter(0,Type.INTZ""+ptld);

Pointerpp=newPointer(newHeapMemoryBlock(1024));

messageBox.setParameter(1zpp);

messageBox.setParameter(2ZnewPointer(new

HeapMemoryBlock(1024)));

//messageBox.setParameter(3,newPointer(new

HeapMemoryBlock(1024)));

//messageBox.setParameter(4,newPointer(new

HeapMemoryBlock(1024)));

messageBox.invoke();

if(0==messageBox.getRetValAsInt()){

System,out.printin(tagName+”测点

值：n+pp.getAsFloat(0));

returnpp.getAsFloat(0);

)

}else{

System.out.printIn("查询测点失败”);

}

}catch(NativeExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}catch(IllegalAccessExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

returnOF;

*获取测点制定时间点的值

*@paramtagName

*@return

*/

publicfloatgetTagValueByTime(StringtagName,Stringtime){

try(

n

JNativemessageBox=newJNative(piapi32.dll"z

npipt_findpoint11);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0,Type.STRING,tagName);

Pointerp=newPointer(newHeapMemoryBlock(8));

messageBox.setParameter(lzp);

messageBox.invoke();

intptld=p.getAsInt(0);

if(0==messageBox.getRetValAsInt()){

System,out.printIn(“测点id:n4-ptlci);

messageBox=newJNative(npiapi32.dll",npiar_valueH);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0zType.工NT,""+ptld);

Pointerpp=newPointer(newHeapMemoryBlock(1024));

Pointerpp_status=newPointer(new

HeapMemoryBlock(1024));

messageBox.setParameter(lzgetTimelntSec(time));

messageBox.setParameter(2,Type.工NT,3+"”);

messageBox.setParameter(3,pp);

messageBox.setParameter(4zpp_status);

messageBox.invoke();

if(0==messageBox.getRetValAsInt()){

System,out.printIn(tagName+”测点

值："+pp.getAsFloat(0));

System,out.printin(tagName+f,status

值：n+pp_status.getAsInt(0));

returnpp.getAsFloat(0);

}else{

System,out.printin(tagName+”查询返回

值:n+messageBox.getRetValAsInt());

)

}else{

System.out.printin("查询测点失败”);

)

}catch(NativeExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}catch(IllegalAccessExceptione){

//TODOAuto-generatedcatchblock

e,printStackTrace();

)

returnOF;

)

*查询测点某时间段内最小值

*©paramtagName

*@paramtimel

*©paramtime2

*/

publicvoidgetTagMinValue(StringtagName,StringtimelfString

time2){

intcode=1;

this.getTagValuesByTimeToTime(tagName,timelztime2zcode);

)

**

*查询测点某时间段内最大值

*@paramtagName

*@paramtimel

*©paramtime2

*/

publicvoidgetTagMaxValue(StringtagName,StringtimelyString

time2){

intcode=2;

this.getTagValuesByTimeToTime(tagName,timelztime2zcode);

)

/**

*查询测点某时间段内平均值

*@paramtagName

*@paramtimel

*©paramtime2

*/

publicvoidgetTagAvgValue(StringtagName,StringtimelzString

time2){

intcode=5;

this.getTagValuesByTimeToTime(tagName,timel,time2,code);

)

/**

*

火@paramtagName

*@return

*/

publicvoidgetTagValuesByTimeToTime(StringtagName,String

timel,Stringtime2zintcode){

try(

nn

JNativemessageBox=newJNative(piapi32.dllr

"pipt_findpoinf1);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0,Type.STRING,tagName);

Pointerp=newPointer(newHeapMemoryBlock(1024));

messageBox.setParameter(1,p);

messageBox.invoke();

intptld=p.getAsInt(0);

if(0==messageBox.getRetValAsInt()){

System.out.printIn(“测点id:H+ptId);

messageBox=newJNative(npiapi32.dll'*,

npiar_summaryf,);

messageBox.setRetVal(Type.INT);

//下面开始设置参数

messageBox.setParameter(0zType.INTZ""+ptld);

Pointerp_startTime=this.getTimeIntSec(timel);

Pointerp_endTime=this.getTimelntSec(time2);

Pointerp_retVal=newPointer(newHeapMemoryBlock(8));

Pointerp_pctGood=newPointer(new

HeapMemoryBlock(8));

messageBox.setParameter(1,p_startTime);

messageBox.setParameter(2,p_endTime);

messageBox.setParameter(3,p_retVal);

messageBox.setParameter(4zp_pctGood);

nn

messageBox.setParameter(5,Type.INTzcode+);

messageBox.invoke();

if(0==messageBox.getRetValAsInt()){

System.out.printin(tagName+”测点返回

值：n+p_retVal.getAsFloat(0));

}else{

System.out.printIn(tagName+”查询状态

值:n+messageBox.getRetValAsInt());

)

}else{

System.out.printIn("查询测点失败");

)

}catch(NativeExceptione){

e.printStackTrace();

}catch(IllegalAccessExceptione){

e.printStackTrace();

)

)

/**

*将时间串转换为int

*格式：11-Aug-1718:00:00

*@paramtime

*@return

*/

publicintgetPiTime(Stringtime){

//获取时间点

try(

Stringtt=time;

Pointerpointer=new

Pointer(MemoryBlockFactory.createMemoryBlock(8));

H

JNativemessageBox=newJNative(piapi32.dll"z

npitm_parsetimen);

messageBox.setRetVal(Type.工NT);

messageBox.setParameter(0zType.STRING,tt);

messageBox.setParameter(1rType•工NT,"0");

messageBox.setParameter(2,pointer);

messageBox.invoke();

if(0==messageBox.getRetValAsInt()){

System.out.printIn("执行成功,getPiTime结果是:“+

pointer.getAsInt(0));

returnpointer.getAsInt(0);

}else{

System.out.printIn("执行失败");

return0;

)

}catch(NativeExceptione){

e.printStackTrace();

return0;

}catch(IllegalAccessExceptione){

e,printStackTrace();

return0;

}

)

*将整数转换为时间，同上方法互逆

*©paramtime

*@return

*/

publicStringgetTimeFromlnt(inttime){

try{

Pointerpointer=new

Pointer(MemoryBlockFactory.createMemoryBlock(8));

H

JNativemessageBox=newJNative(piapi32.dll"z

npitm_formtimen);

messageBox.setRetVal(Type.INT);

messageBox.setParameter(0,

Type.工NT,this.getPiTime(”“)+"");

messageBox.setParameter(1,pointer);

messageBox.setParameter(2z19);

messageBox.invoke();

System,out.printIn("结果是："+pointer.getAsString());

returnpointer.getAsString();

}catch(NativeExceptione){

e.printStackTrace();

}catch(IllegalAccessExceptione){

e.printStackTrace();

}

return

)

/**

*将P工日期转为数组型

*©paramtime

*©return

*/

publicint[]getTimeSecint(inttime){

int[]time_arrays=newint[6];

try(

Pointerpointer=new

Pointer(MemoryBlockFactory.createMemoryBlock(4*

time_arrays.length));

JNativemessageBox=newJNative(Hpiapi32.dllH,

Hpitm_secintn);

messageBox.setParameter(0,

Type•工NT,this.getTimelntSec(n2012-05-17

ll:ll:lln).getAsInt(0)+nn);

messageBox.setParameter(1,pointer);

messageBox.invoke();

for(inti=0;i<time_arrays.length;i++){

time_arrays[i]=pointer.getAsInt(i*4);

}

returntime_arrays;

}catch(NativeExceptione){

e.printStackTrace();

}catch(IllegalAccessExceptione){

e.printStackTrace();

}

returnnull;

)

/**

*将日期转为数组型，与pitm_secint互相逆

*@paramtime

*©return

*/

publicPointergetTimelntSec(Stringtime){

PIDatedate=PIDate.getPIDate(time);

try(

inttime_array[]=newint[]{date.getMonth(),date.getDay(),

date,getYear(),date.getHour(),date.getMinutes(),

date.getSeconds()};

Pointerpointer=new

Pointer(MemoryBlockFactory.createMemoryBlock(8));

Pointerpointer_array=new

Pointer(MemoryBlockFactory.createMemoryBlock(time_array.length*4))

r

Hn

JNativemessageBox=newJNative(piapi32.dllz

upitm_intsecn);

/**这种方法也可以

pointer_array.setlntAt(0,2012);

pointer_array.setIntAt(4,5);

pointer_array.setlntAt(8,16);

pointer_array.setlntAt(12,21);

pointer_array.setlntAt(16,33);

pointer_array.setlntAt(20,33);

**/

//初始化数组

for(inti=0;i<time_array.length;i++){

pointer_array.setlntAt(4*i,time_array[i]);

}

messageBox.setParameter(0,pointer);

messageBox.setParameter(1,pointer_array);

messageBox.invoke();

System.out.printin(ngetTimeIntSec=n+pointer.getAsInt(0));

returnpointer;

}catch(NativeExceptione){

e.printStackTrace();

}catch(IllegalAccessExceptione){

e,printStackTrace();

)

returnnull;

)

/**

*不能直接返回

*@paramtime

*©return

*/

publicintgetTimelntSecForlnt(Stringtime){

PIDatedate=PIDate.getPIDate(time);

try(

inttime_array[]=newint[]{date.getMonth(),date.getDay(),

date.getYear(),date.getHour(),date.getMinutes(),

date,getSeconds()};

Pointerpointer=new

Pointer(MemoryBlockFactory.createMemoryBlock(8));

Pointerpointer_array=new

Pointer(MemoryBlockFactory.createMemoryBlock(time_array.length*4))

r

JNativemessageBox=newJNative(Hpiapi32.dll*',

Hpitm_intsecn);

//初始化数组

for(inti=0;i<time_array.length;i++){

pointer_array.setlntAt(4*iztime_array[i]);

)

messageBox.setParameter(0zpointer);

messageBox.setParameter(1,pointer_array);

messageBox.invoke();

System.out.printIn(ngetTimeIntSec="+pointer.getAsInt(0));

returnpointer.getAsInt(0);

}catch(NativeExceptione){

e.printStackTrace();

}catch(IllegalAccessExceptione){

e.printStackTrace();

}

return0;

时间工具类:

importjava.util.regex.Matcher;

importjava.utiI.regex.Pattern;

publicclassPIDate{

privateintyear;

privateintmonth;

privateintday;

privateinthour;

privateintminutes;

privateintseconds;

publicintgetYear(){

returnyear;

)

publicvoidsetYear(intyear){

this.year=year;

)

publicintgetMonth(){

returnmonth;

}

publicvoidsetMonth(intmonth){

this.month=month;

)

publicintgetDayO{

returnday;

)

publicvoidsetDay(intday){

this.day=day;

)

publicintgetHour(){

returnhour;

publicvoidsetHour(inthour){

this.hour=hour;

)

publicintgetMinutes(){

returnminutes;

)

publicvoidsetMinutes(intminutes){

this.minutes=minutes;

)

publicintgetSeconds(){

returnseconds;

)

publicvoidsetSeconds(intseconds){

this.seconds=seconds;

)

publicstaticPIDategetPIDate(Stringtime){

Patternp=Ppile("(\\d{4})-(\\d{l.2})-(\\d{l/2})

(\\d{l,2}):(\\d{lz2)):(\\d{l,2})")；

Matcherm=p.matcher(time);

PIDatedate=newPIDate();

if(m.find()){

/*System.out.println("H期:"+m.group());

System.out.println("^:n+m.group(l));

System.out.printin("月:"+m.group(2));

System.out.println("日:"+m.group(3));

System.out.println("时:”+m.group⑷)；

System.out.printin(“分:“+m.group(5));

System.out.printin(”秒:“+m.group⑹);*/

date.setYear(lnteger.parselnt(m.group(l)));

date.setMonth(lnteger.parselnt(m.group(2)));

date.setDay(lnteger.parselnt(m.group(3)));

date.setHour(lnteger.parselnt(m.group(4)));

date.setMinutes(lnteger.parselnt(m.group(5)));

date.setSeconds(lnteger.parselnt(m.group(6)));

)

returndate;

)

}

附录资料：

java处理高并发高负载类网站的优化方法

java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数

据Java高负载数据）

-:高并发高负载类网站关注点之数据库

没错,首先是数据库，这是大多数应用所面临的首个尤其是的应

SPOFoWeb2.0

用，数据库的响应是首先要解决的。一般来说MySQL是最常用的，可能最初是

一个mysql主机,当数据增加到100万以上，那么，MySQL的效能急剧下降。

常用的优化措施是M-S（主-从）方式进行同步复制，将查询和操作和分别在不

同的服务器上进行操作。我推荐的是M-M-Slaves方式，2个主Mysql,多个

Slaves,需要注意的是，虽然有2个Master，但是同时只有1个是Active,我

们可以在一定时候切换。之所以用个，是保证不会又成为系统的

2MMSPOFo

Slaves可以进一步负载均衡，可以结合LVS,从而将select操作适当的平衡到不

同的slaves上。以上架构可以抗衡到一定量的负载，但是随着用户进一步增加，

你的用户表数据超过1千万这时那个M变成了SPOF。你不能任意扩充Slaves,

否则复制同步的开销将直线上升，怎么办？我的方法是表分区，从业务层面上进

行分区。最简单的，以用户数据为例。根据一定的切分方式，比如id,切分到

不同的数据库集群去。

全局数据库用于meta数据的查询。缺点是每次查询，会增加一次，比如你要查

一个用户nightsailer,你首先要到全局数据库群找到nightsailer对应的cluster

id,然后再到指定的cluster找到nightsailer的实际数据。每个cluster可以用

m-m方式，或者m-m-slaves方式。这是一个可以扩展的结构，随着负载的增

加，你可以简单的增加新的mysqlcluster进去。

需要注意的是：1、禁用全部autojncrement的字段2、id需要采用通用的算

法集中分配3、要具有比较好的方法来监控mysql主机的负载和服务的运行状

态。如果你有30台以上的mysql数据库在跑就明白我的意思了。4、不要使用

持久性链接（不要用pconnect），相反,使用sqlrelay这种第三方的数据库链接

池，或者干脆自己做，因为php4中mysql的链接池经常出问题。二：高并发

高负载网站的系统架构之HTML静态化

其实大家都知道，效率最高、消耗最小的就是纯静态化，所以我们尽可能使我们

的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方

法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于

是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻

频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布

系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限管

理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS

是必不可少的。除了门户和信息发布类型的网站，对于交互性要求很高的社

区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、

文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像

Mop的大杂炮就是使用了这样的策略，网易社区等也是如此。同时，html

静态化也是某些缓存策略使用的手段,对于系统中频繁使用数据库查询但是内容

更新很小的应用，可以考虑使用html静态化来实现，比如论坛中论坛的公用

设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中,

这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这部分内

容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求高并发。

网站HTML静态化解决方案当一个Servlet资源请求到达WEB服务器之后我们

会填充指定的JSP页面来响应请求：

HTTP请求一Web服务器一Servlet-业务逻辑处理一访问数据一填充JSP一响

应请求

HTML静态化之后：

HTTP请求--Web服务器Servlet--HTML—响应请求

静态访求如下

Servlet:

publicvoiddoGet(HttpServletRequestrequest,HttpServletResponse

response)throwsServletException,lOException

{if(request.getParameterCchapterId")!=null){String

chapterFileName=

"bookChapterRead_"+request.getParameterCchapterId")+".html";

Stringch叩terFilePath=getServletContext().getRealPath(7")+

chapterFileName;FilechapterFile=new

File(chapterFilePath);if(chapterFile.exists()){response.sendRedirect

(ch叩terFileName);return;}〃如果有这个文件就告诉浏览器转

向INovelChapterBiznovelChapterBiz=new

NovelChapterBizImpl();Novelchapternovelchapter=

novelChapterBiz.searchNovelChapterById(Integer.parseInt(request.getP

arameterCchapterld")));//章节信息intlastPageld=

novelChapterBiz.searchLastCHapterId(novelChapter.getNovelId().getId(),

novelChapter.getId());intnextPageld=

novelChapterBiz.searchNextChapterId(novelChapter.getNovelId().getId(),

novelChapter.getId());request.setAttribute("novelChapter",

novelchapter);request.setAttribute("lastPageld",

lastPageld);request.setAttribute("nextPageld",

nextPageld);new

CreateStaticHTMLPage().createStaticHTMLPage(request,response,

getServletContext(),chapterFileName,chapterFilePath,

VbookRead.jsp");}}生成HTML静态页面的类：

packagecom.jb.y2t034.thefifth.web.servlet;import

java.io.ByteArrayOutputStream;import

java.io.FileOutputStream;importjava.io.IOException;import

java.io.OutputStreamWriter;importjava.io.Printwriter;import

javax.servlet.RequestDispatcher;import

javax.servlet.ServletContext;import

javax.servlet.ServletException;import

javax.servlet.ServletOutputStream;import

javax.servlet.http.HttpServletRequest;import

javax.servlet.http.HttpServletResponse;import

javax.servlet.http.HttpServletResponseWrapper;/***创建HTML静态页

面*功能：创建HTML静态页面*时间：2009年1011日*地点:home*

@authormavk**/publicclassCreateStaticHTMLPage{/***牛

成静态HTML页面的方法*@paramrequest请求对象*@param

response响应对象*@paramservletContextServlet上下文*

@paramfileName文件名称*@paramfileFullPath文件完整路径*

@paramjspPath需要生成静态文件的JSP路径(相对即可)*@throws

lOException*@throwsServletException*/publicvoid

createStaticHTMLPage(HttpServletRequestrequest,

HttpServletResponseresponse,ServletContextservletContext,String

fileName,StringfileFullPath,StringjspPath)throwsServletException,

IOException{response.setContentType("text/html;charset=gb231

2");〃设置HTML结果流编码(即HTML文件编码)RequestDispatcher

rd=servletContext.getRequestDispatcher(jspPath);//得至UJSP资

源finalByteArrayOutputStreambyteArrayOutputStream=new

ByteArrayOutputStream();//用于从ServletOutputStream中接收资

源finalServletOutputStreamservletOuputStream=new

ServletOutputStream(){//用于从HttpServletResponse中接收资

源publicvoidwrite(byte[]b,intoff,int

len){byteArrayOutputStream.write(b,off,

len);}publicvoidwrite(int

b){byteArrayOutputStream.write(b);}};f

inalPrintWriterprintwriter=newPrintWriter(new

OutputStreamWriter(byteArrayOutputStream));〃