文件的下载

 

 

 

下载服务器资源文件 ajax 实现原理一样
       
   I：首先了解Stream 结果类型          

                Struts 专门为文件下载提供了一种 Stream 结果类型. 在使用一个 Stream 结果时, 不必准备一个 JSP 页面.

               Stream 结果类型可以设置如下参数: 
               contentType：被下载的文件的 MIME 类型。默认值为 text/plain
               contentLength：被下载的文件的大小，以字节为单位
               contentDisposition： 可以设置下载文件名的ContentDispositon 响应头，默认值为 inline，通常设置为如下格式：                     attachment;filename="document.pdf".

               inputName：Action 中提供的文件的输入流。默认值为 inputStream
               bufferSize：文件下载时缓冲区的大小。默认值为 1024
               allowCaching ：文件下载时是否允许使用缓存。默认值为 true
               contentCharSet：文件下载时的字符编码。    
               Stream 结果类型的参数可以在 Action 以属性的方式覆盖
       
  
   <action name= "down_*" class ="actions.down" method= "{1}">
               <result name= "download_success" type="stream" >
              <param name="contentDisposition" >attachment;filename="my.jpg" </param>
                    <param name="contentType" >image/ jpeg</ param>
                    <param name="bufferSize" >102400 </param>
                    <param name="inputName" >inputStream </param>
               </result>
 </action>
                 
       public class down extends ActionSupport {

     // 下载资源文件
     private InputStream inputStream;

     public InputStream getInputStream() {
           return inputStream ;
     }

     public String download() throws Exception {
          String name = "d:/Hydrangeas.jpg";
          File fs = new File(name);
           inputStream = new FileInputStream(fs);
           return "download_success" ;
     }
}               
从StreamResult 源码中可以看到下载实现的过程和参数设置
                   
public class StreamResult extends StrutsResultSupport {
 
    public static final String DEFAULT_PARAM = "inputName";
    protected String contentType = "text/plain" ;
    protected String contentLength;
    protected String contentDisposition = "inline" ;
    protected String contentCharSet ;
    protected String inputName = "inputStream" ;
    protected InputStream inputStream;
    protected int bufferSize = 1024;
    protected boolean allowCaching = true;

以上都有默认的值 但可以在配置文件中进行参数配置
   public StreamResult(InputStream in) {
        this.inputStream = in;
    }
 
    public boolean getAllowCaching() {
        return allowCaching ;
    }
 
    public void setAllowCaching(boolean allowCaching) {
        this.allowCaching = allowCaching;
    }
 
    public int getBufferSize() {
        return (bufferSize );
    }
 
    public void setBufferSize(int bufferSize) {
        this.bufferSize = bufferSize;
    }
 
    public String getContentType() {
        return (contentType );
    }
 
    public void setContentType(String contentType) {
        this.contentType = contentType;
    }

    
    public String getContentLength() {
        return contentLength ;
    }
 
    public void setContentLength(String contentLength) {
        this.contentLength = contentLength;
    }
 
    public String getContentDisposition() {
        return contentDisposition ;
    }
 
    public void setContentDisposition(String contentDisposition) {
        this.contentDisposition = contentDisposition;
    }
 
    public String getContentCharSet() {
        return contentCharSet ;
    }
 
    public void setContentCharSet(String contentCharSet) {
        this.contentCharSet = contentCharSet;
    }
 
    public String getInputName() {
        return (inputName );
    }
 
    public void setInputName(String inputName) {
        this.inputName = inputName;
    }
 
 
    protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
 
                
        //设置配置文件参数 
        resolveParamsFromStack(invocation.getStack(), invocation);
     
        OutputStream oOutput = null;

        try {
                     //  inputName：Action 中提供的文件的输入流。默认值为 inputStream
            if (inputStream == null) {
               //从action中获取到输入流 
                inputStream = (InputStream) invocation.getStack().findValue(conditionalParse(inputName , invocation));
            }
 
            // Find the Response in context
            HttpServletResponse oResponse = (HttpServletResponse) invocation.getInvocationContext().get(HTTP_RESPONSE );

           contentType：被下载的文件的 MIME 类型。默认值为 text/plain
                      contentCharSet：文件下载时的字符编码。   
            if (contentCharSet != null && ! contentCharSet.equals("" )) {
                oResponse.setContentType(conditionalParse(contentType , invocation)+";charset=" +contentCharSet );
            }
            else {
                oResponse.setContentType(conditionalParse(contentType , invocation));
            }

            // contentLength：被下载的文件的大小，以字节为单位
            if (contentLength != null) {
                String _contentLength = conditionalParse(contentLength , invocation);
                int _contentLengthAsInt = -1;
                try {
                    _contentLengthAsInt = Integer.parseInt(_contentLength);
                    if (_contentLengthAsInt >= 0) {
                        oResponse.setContentLength(_contentLengthAsInt);
                    }
                }
                catch(NumberFormatException e) {
                   
                }
            } 
            // contentDisposition： 可以设置下载文件名的ContentDispositon 响应头，默认值为 inline
            if (contentDisposition != null) {
                oResponse.addHeader("Content-Disposition" , conditionalParse(contentDisposition , invocation));
            }

            //   allowCaching ：文件下载时是否允许使用缓存。默认值为 true
 
               
            if (!allowCaching ) {
                oResponse.addHeader( "Pragma", "no-cache");
                oResponse.addHeader( "Cache-Control", "no-cache");
            }

            // Get the outputstream
            oOutput = oResponse. getOutputStream();
  
            // Copy input to output
            if (LOG .isDebugEnabled()) {
           LOG.debug("Streaming to output buffer +++ START +++");
            }
              //  bufferSize：文件下载时缓冲区的大小。默认值为 1024
            byte[] oBuff = new byte[ bufferSize];
            int iSize;

            while (-1 != (iSize = inputStream.read(oBuff))) {
                oOutput.write(oBuff, 0, iSize);
            }
            
            // Flush
            oOutput.flush();
        }
        finally {
            if (inputStream != null) inputStream.close();
            if (oOutput != null) oOutput.close();
        }
    }

    //设置配置文件的参数 到成员变量中
protected void resolveParamsFromStack(ValueStack stack, ActionInvocation invocation) {
        String disposition = stack.findString("contentDisposition" );
        if (disposition != null) {
            setContentDisposition(disposition);
        }

        String contentType = stack.findString("contentType" );
        if (contentType != null) {
            setContentType(contentType);
        }

        String inputName = stack.findString( "inputName");
        if (inputName != null) {
            setInputName(inputName);
        }

        String contentLength = stack.findString("contentLength" );
        if (contentLength != null) {
            setContentLength(contentLength);
        }

        Integer bufferSize = (Integer) stack.findValue("bufferSize" , Integer.class);
        if (bufferSize != null) {
            setBufferSize(bufferSize.intValue());
        }

        if (contentCharSet != null ) {
            contentCharSet = conditionalParse(contentCharSet , invocation);
        }
        else {
            contentCharSet = stack.findString("contentCharSet" );
        }
    }

}