HttpServletRequest req = (HttpServletRequest) request;

        int length = req.getContentLength();
        if (length > 0) {
            BufferedRequestWrapper bufferedRequest = new BufferedRequestWrapper(req,length);

            InputStream is = bufferedRequest.getInputStream();
            byte[] content = new byte[length];
           
            int pad = 0;
            while(pad < length){
                pad += is.read(content, pad, length);
            }

            request = bufferedRequest;
        }
        chain.doFilter(request, response);      
    }


BufferedRequestWrapper .java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class BufferedRequestWrapper extends HttpServletRequestWrapper {

    ByteArrayInputStream bais;

    BufferedServletInputStream bsis;

    byte[] buffer;

    public BufferedRequestWrapper(HttpServletRequest req,int length) throws IOException {
        super(req);
        // Read InputStream and store its content in a buffer.
        InputStream is = req.getInputStream();
        buffer = new byte[length];

        int pad = 0;
        while(pad < length){
            pad += is.read(buffer, pad, length);
        }
    }

    public ServletInputStream getInputStream() {
        try {
            // Generate a new InputStream by stored buffer
            bais = new ByteArrayInputStream(buffer);
            // Istantiate a subclass of ServletInputStream
            // (Only ServletInputStream or subclasses of it are accepted by the
            // servlet engine!)
            bsis = new BufferedServletInputStream(bais);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
        }
        return bsis;
    }

}




BufferedServletInputStream .java

import java.io.*;
import javax.servlet.ServletInputStream;

/*
 Subclass of ServletInputStream needed by the servlet engine.
 All inputStream methods are wrapped and are delegated to
 the ByteArrayInputStream (obtained as constructor parameter)!
 */
public class BufferedServletInputStream extends ServletInputStream {

    ByteArrayInputStream bais;

    public BufferedServletInputStream(ByteArrayInputStream bais) {
        this.bais = bais;
    }

    public int available() {
        return bais.available();
    }

    public int read() {
        return bais.read();
    }

    public int read(byte[] buf, int off, int len) {
        return bais.read(buf, off, len);
    }

}

    // Fill the message
    messageBodyPart.setText(body);

    mp.addBodyPart(messageBodyPart);

      /*发送附件*/
     if (file != null && file.length > 0) {
       //利用枚举器方便的遍历集合
         MimeBodyPart mbp = new MimeBodyPart(); 
//         File fileTmp = null;
         //得到数据源
//         FileDataSource fds = new FileDataSource(fileTmp);
         //得到附件本身并至入BodyPart
         mbp.setDataHandler(new DataHandler(new ByteArrayDataSource(file,"application/octet-stream")));
         //得到文件名同样至入BodyPart
         mbp.setFileName(MimeUtility.encodeWord(fileName,"GB2312",null));
         mp.addBodyPart(mbp);
     }
   
    //Multipart加入到信件
    msg.setContent(mp);

    msg.setRecipient(Message.RecipientType.TO, new InternetAddress(to));
    msg.setSubject(subject);

    msg.setHeader("X-Mailer", "personal Email Sender");
    msg.setSentDate(new Date());

    Transport transport = session.getTransport("smtp");

    //添加认证信息
    transport.connect(Constants.mailhost, Constants.user, Constants.pwd);
    transport.sendMessage(msg, msg.getRecipients(Message.RecipientType.TO));
    transport.close();
    return true;
  }

import java.io.*;
import javax.activation.*;

public class ByteArrayDataSource implements DataSource {
    /** * Data to write. */
    private byte[] _data;

    /** * Content-Type. */
    private String _type;

    /* Create a datasource from an input stream */
    public ByteArrayDataSource(InputStream is, String type) {
        _type = type;
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            int ch;

            // XXX : must be made more efficient by
            // doing buffered reads, rather than one byte reads
            while ((ch = is.read()) != -1)
                os.write(ch);
            _data = os.toByteArray();
        } catch (IOException ioe) {
        }
    }

    /* Create a datasource from a byte array */
    public ByteArrayDataSource(byte[] data, String type) {
        _data = data;
        _type = type;
    }

    /* Create a datasource from a String */
    public ByteArrayDataSource(String data, String type) {
        try {
            // Assumption that the string contains only ascii
            // characters ! Else just pass in a charset into this
            // constructor and use it in getBytes()
            _data = data.getBytes("iso-8859-1");
        } catch (UnsupportedEncodingException uee) {
        }
        _type = type;
    }

    public InputStream getInputStream() throws IOException {
        if (_data == null)
            throw new IOException("no data");
        return new ByteArrayInputStream(_data);
    }

    public OutputStream getOutputStream() throws IOException {
        throw new IOException("cannot do this");
    }

    public String getContentType() {
        return _type;
    }

    public String getName() {
        return "dummy";
    }
}

找出内存泄漏另一方法

程序有内存泄漏的第一个迹象通常是它抛出一个 OutOfMemoryError，或者因为频繁的垃圾收集而表现出糟糕的性能。幸运的是，垃圾收集可以提供能够用来诊断内存泄漏的大量信息。如果以 -verbose:gc 或者 -Xloggc 选项调用 JVM，那么每次 GC 运行时在控制台上或者日志文件中会打印出一个诊断信息，包括它所花费的时间、当前堆使用情况以及恢复了多少内存。记录 GC 使用情况并不具有干扰性，因此如果需要分析内存问题或者调优垃圾收集器，在生产环境中默认启用 GC 日志是值得的。

有工具可以利用 GC 日志输出并以图形方式将它显示出来，JTune 就是这样的一种工具（请参阅 参考资料）。观察 GC 之后堆大小的图，可以看到程序内存使用的趋势。对于大多数程序来说，可以将内存使用分为两部分：baseline 使用和 current load 使用。对于服务器应用程序，baseline 使用就是应用程序在没有任何负荷、但是已经准备好接受请求时的内存使用，current load 使用是在处理请求过程中使用的、但是在请求处理完成后会释放的内存。只要负荷大体上是恒定的，应用程序通常会很快达到一个稳定的内存使用水平。如果在应用程序已经完成了其初始化并且负荷没有增加的情况下，内存使用持续增加，那么程序就可能在处理前面的请求时保留了生成的对象。

图 1 显示  GC 之后应用程序堆大小随着时间的变化图。上升趋势是存在内存泄漏的警示信号。（在真实的应用程序中，坡度不会这么大，但是在收集了足够长时间的 GC 数据后，上升趋势通常会表现得很明显。）

确信有了内存泄漏后，下一步就是找出哪种对象造成了这个问题。所有内存分析器都可以生成按照对象类进行分解的堆快照。有一些很好的商业堆分析工具，但是找出内存泄漏不一定要花钱买这些工具 —— 内置的 hprof 工具也可完成这项工作。要使用 hprof 并让它跟踪内存使用，需要以 -Xrunhprof:heap=sites 选项调用 JVM。

清单 3 显示分解了应用程序内存使用的 hprof 输出的相关部分。（hprof 工具在应用程序退出时，或者用 kill -3 或在 Windows 中按 Ctrl+Break 时生成使用分解。）注意两次快照相比，Map.Entry、Task 和 int[] 对象有了显著增加。

请参阅 清单 3。

清单 4 展示了 hprof 输出的另一部分，给出了 Map.Entry 对象的分配点的调用堆栈信息。这个输出告诉我们哪些调用链生成了 Map.Entry 对象，并带有一些程序分析，找出内存泄漏来源一般来说是相当容易的。

TRACE 300446:
	java.util.HashMap$Entry.<init>(<Unknown Source>:Unknown line)
	java.util.HashMap.addEntry(<Unknown Source>:Unknown line)
	java.util.HashMap.put(<Unknown Source>:Unknown line)
	java.util.Collections$SynchronizedMap.put(<Unknown Source>:Unknown line)
	com.quiotix.dummy.MapLeaker.newTask(MapLeaker.java:48)
	com.quiotix.dummy.MapLeaker.main(MapLeaker.java:64)

1. 将你要传送的文件封装在DataHandler中，然后将DataHandler对象或DataHandler数组（多个文件传送的时候）作为客户端调用函数的参数（从客户端上传文件到服务器）Axis服务的返回类型（从服务器端下载文件到客户端）进行传输。

2. 还有一种方式是直接修改soap信封的内容，将附件信息加到soap信封中发送。

这里我们只讨论第一种方法，因为它实现起来非常简单。关于第二种方法在Axis包的webapps/attachments/TestRf.java中有详细的原码可以参考。

下面的例子是把文件从服务器端下载到客户端：

1.服务端程序：

假设传输多个文件：在服务器端将文件取出来，并将文件封装在DataHandler数组中。
代码如下：

 DataHandler[] ret = new DataHandler[totalFileNum];
 ... ...
 java.io.File myFile = new java.io.File(filePath);
 if(myFile.isFile() && myFile.canRead())
 {
  String fname = myFile.getAbsoluteFile().getCanonicalPath();
  DataHandler[0] = new DataHandler(new FileDataSource(fname));
 }
 ... ...

 return ret;

上面的代码将所有的文件封装在了DataHandler数组中，并返回。

2. 客户端的访问：

代码如下：
 Service service = new Service();
 Call call = (Call) service.createCall();

 URL myURL = new URL("http://192.168.0.26:8080/axis/servlet/AxisServlet");
 call.setTargetEndpointAddress(myURL); //设定服务的主机和位置
 call.setOperationName(new QName("urn:MyAttachServer","echoDir")); //设置要调用的服务的方法
 QName qnameAttachment = new QName("urn:MyAttachServer","DataHandler");

 call.registerTypeMapping(DataHandler.class, qnameAttachment, JAFDataHandlerSerializerFactory.class,JAFDataHandlerDeserializerFactory.class); //为附件（即DataHandler类）创建序列化生成器

 call.addParameter("source", XMLType.XSD_STRING ,ParameterMode.IN); //设置服务调用方法的传入参数类型
 call.setReturnType(XMLType.SOAP_ARRAY); //设置调用服务方法的返回类型，由于返回的是DataHandler数组，所以设置为SOAP_ARRAY类型
 javax.activation.DataHandler[] ret = (javax.activation.DataHandler[])call.invoke(new Object[]{null}); //调用方法

 for (i = 0; i < ret.length; ++i)
        {
            DataHandler recDH = ret[i];
            java.io.File receivedFile = new java.io.File(recDH.getName()); //文件生成
        }

3. 服务的部署：

注意：你要在部署的时候，定义DataHandler的序列化生成器。

  编写deploy.wsdd文件：

 <deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java" xmlns:ns1="urn:att_STC_Server" >
  <service name="urn:att_STC_Server" provider="java:RPC" >
    <parameter name="className" value="samples.att_STC.att_STC_Server"/>
    <parameter name="allowedMethods" value="echoDir"/>

 <typeMapping deserializer="org.apache.axis.encoding.ser.JAFDataHandlerDeserializerFactory"
   languageSpecificType="java:javax.activation.DataHandler" qname="ns1:DataHandler"
    serializer="org.apache.axis.encoding.ser.JAFDataHandlerSerializerFactory"
    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
  </service>

</deployment>

运行java org.apache.axis.client.AdminClient %* deploy.wsdd，部署服务。

主题: 使用Java实现CA(四)

    前面几篇文章已经把如何用Java实现一个CA基本上讲完了.但是他们都有一个特点,就是用户的信息都是在现场获取的,不能做申请和签发相分离.今天我们要讲述的是PKCS#10证书请求文件.它的作用就是可以使申请和签发相分离.

[返回顶部]

2004-05-28 16:46:12

主题: 使用Java实现CA(三)

    前几次我已经基本上把如何做CA所需要的基础知识讲得差不多了,今天直接讲如何用Java程序来实现一个CA应该就不是什么太困难的事情了.

2004-05-27 15:34:59

主题: 使用Java实现CA(二)

    昨天本来快写完了,结果不小心按了"tab"键,然后向按退格键,结果退到前一个页面了,然后全部都白写了,不爽.只好今天重新写了.

2004-05-25 21:23:52

主题: 使用Java实现CA(一)

    通过我昨天的文章大家应该已经清楚了,用Java写信息安全方面的程序需要做的准备工作.好了,现在假设你已经是一个对Java语言本身比较熟悉,能够用Java写一些程序的人,并且这些该下载的jar包已经下载好了,可以正式开工了.

2004-05-24 17:23:06

主题: 使用Java开发和信息安全相关的程序

    这里说的信息安全是相对于系统安全而言的,它更侧重于加密,解密,数字签名,验证,证书等等.而系统安全主要侧重于系统本身是否有安全漏洞,如常见的由于软件设计的不完善而导致的满天飞的缓冲区溢出等等.