struts2实现带进度条的文件上传

最新推荐文章于 2018-06-24 00:06:47 发布
最新推荐文章于 2018-06-24 00:06:47 发布
阅读量4k 收藏 3
点赞数 1
分类专栏： struts2 文章标签： struts2 文件上传

原理：

利用Ajax在客户端一直查询服务器端的上传进度，取得进度的状态文本信息(xml,json格式的文本等),然后利用JS解析，显示在前台。

在Struts2. 0中，框架事先已经定义一种监听器：ProgressListener（进度监听器），里面有一个update(long readedBytes, long totalBytes, int currentItem)方法,其中，readedBytes是已经上传到服务器的位数，而totalBytes是上传文件总位数.当文件已二进制的方式上传时，每上传一部分数据，就会调用这个方法一次。故要实现监听进度，必须实现这个接口，并实现update方法，在update方法中保存这个进度到session。当客服端需要进度的信息时，只需要访问某个action，在这个action中读取session中保存的进度状态就可以了.

上传文件可大致分为两个阶段:1. 上传到服务器上，在临时目录中 2.从临时目录中把文件移到指定目录(由自己写的action处理),而struts2.的监听器只监听

第一阶段实现：

第一步：

    实现ProgressListener接口，实现update( )方法，详情见action包中的FileUploadListener.java 文件，里面有一个自定义的类：State ，它描述的是进度的状态，详情请看State注释。Update方法要做的就是不断地更新session中的state对象

 

第二步:

   将监听器注入到struts2.0的MultiPartRequest封装类中，客户端发送request到服务器，struts2.0会将request封装成MultiPartRequest。因此必须将监听器注入到MultiPartRequest中。只需要在MultiPartRequest中加入以下两句：

 

FileUploadListener progressListener = new FileUploadListener(servletRequest);

upload.setProgressListener(progressListener);//添加自己的监听器

 

所以重新写一个新类MyMultiPartRequest代替MultiPartRequest ，代码与org.apache.struts2.dispatcher.multipart.MultiPartRequest 一样，在方法

private List<FileItem> parseRequest(HttpServletRequest servletRequest, String saveDir)  中加入监听器.

 

   在struts.xml中重新指定MultiPartRequest:

 <bean type="org.apache.struts2.dispatcher.multipart.MultiPartRequest" name="requestParser"

        class="action.MyMultiPartRequest" scope="default" optional="true" />

  <constant name="struts.multipart.handler" value="requestParser" />

到这里，基本完成大部分工作.

附录：

State.java

public class State {
    	private long readedBytes = 0L;
   	private long totalBytes = 0L;
   	private int currentItem = 0;
   	private int rate=0;
        	public long getReadedBytes() {
		return readedBytes;
	}
	
	public void setReadedBytes(long readedBytes) {
		this.readedBytes = readedBytes;
	}
	
	public long getTotalBytes() {
		return totalBytes;
	}
	
	public void setTotalBytes(long totalBytes) {
		this.totalBytes = totalBytes;
	}
	public int getCurrentItem() {
		return currentItem;
	}
	
	public void setCurrentItem(int currentItem) {
		this.currentItem = currentItem;
	}

	public int getRate() {
		return rate;
	}
	public void setRate(int rate) {
		this.rate = rate;
	}
}

FileUploadListener.java 

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.commons.fileupload.ProgressListener;
import cn.com.order.model.State;

public class FileUploadListener implements ProgressListener {
	private HttpSession session;
	public FileUploadListener(HttpServletRequest request) {
		session = request.getSession();
		State state = new State();
		session.setAttribute("state", state);
	}
	@Override
	public void update(long readedBytes, long totalBytes, int currentItem) {
	
		System.out.println("update:" + readedBytes + ";" + totalBytes + ";" + (int)(((float)readedBytes/(float) 	？			totalBytes)*100) + ";" + currentItem);
		State state = (State) session.getAttribute("state");
		state.setReadedBytes(readedBytes);
		state.setTotalBytes(totalBytes);
		state.setCurrentItem(currentItem);
	}
}

MyMultipartRequest.java

import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.struts2.StrutsConstants;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.struts2.dispatcher.multipart.MultiPartRequest;

public class MyMultiPartRequest implements MultiPartRequest{
    static final Logger LOG = LoggerFactory.getLogger(MultiPartRequest.class);
    
    // maps parameter name -> List of FileItem objects
    protected Map<String,List<FileItem>> files = new HashMap<String,List<FileItem>>();

    // maps parameter name -> List of param values
    protected Map<String,List<String>> params = new HashMap<String,List<String>>();

    // any errors while processing this request
    protected List<String> errors = new ArrayList<String>();
    
    protected long maxSize;

    @Inject(StrutsConstants.STRUTS_MULTIPART_MAXSIZE)
    public void setMaxSize(String maxSize) {
        this.maxSize = Long.parseLong(maxSize);
    }

    /**
     * Creates a new request wrapper to handle multi-part data using methods adapted from Jason Pell's
     * multipart classes (see class description).
     *
     * @param saveDir        the directory to save off the file
     * @param request the request containing the multipart
     * @throws java.io.IOException  is thrown if encoding fails.
     */
    public void parse(HttpServletRequest request, String saveDir) throws IOException {
        try {
            processUpload(request, saveDir);
        } catch (FileUploadException e) {
            LOG.warn("Unable to parse request", e);
            errors.add(e.getMessage());
        }
    }

    private void processUpload(HttpServletRequest request, String saveDir) throws FileUploadException, UnsupportedEncodingException {
        for (FileItem item : parseRequest(request, saveDir)) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Found item " + item.getFieldName());
            }
            if (item.isFormField()) {
                processNormalFormField(item, request.getCharacterEncoding());
            } else {
                processFileField(item);
            }
        }
    }

    private void processFileField(FileItem item) {
        LOG.debug("Item is a file upload");

        // Skip file uploads that don't have a file name - meaning that no file was selected.
        if (item.getName() == null || item.getName().trim().length() < 1) {
            LOG.debug("No file has been uploaded for the field: " + item.getFieldName());
            return;
        }

        List<FileItem> values;
        if (files.get(item.getFieldName()) != null) {
            values = files.get(item.getFieldName());
        } else {
            values = new ArrayList<FileItem>();
        }

        values.add(item);
        files.put(item.getFieldName(), values);
    }

    private void processNormalFormField(FileItem item, String charset) throws UnsupportedEncodingException {
        LOG.debug("Item is a normal form field");
        List<String> values;
        if (params.get(item.getFieldName()) != null) {
            values = params.get(item.getFieldName());
        } else {
            values = new ArrayList<String>();
        }

        // note: see http://jira.opensymphony.com/browse/WW-633
        // basically, in some cases the charset may be null, so
        // we're just going to try to "other" method (no idea if this
        // will work)
        if (charset != null) {
            values.add(item.getString(charset));
        } else {
            values.add(item.getString());
        }
        params.put(item.getFieldName(), values);
    }

    private List<FileItem> parseRequest(HttpServletRequest servletRequest, String saveDir) throws FileUploadException {
        DiskFileItemFactory fac = createDiskFileItemFactory(saveDir);
        ServletFileUpload upload = new ServletFileUpload(fac);
        upload.setSizeMax(maxSize);
        /*自己新建监听器*/
        FileUploadListener progressListener = new FileUploadListener(servletRequest);
        upload.setProgressListener(progressListener);//添加自己的监听器
        
        return upload.parseRequest(createRequestContext(servletRequest));
    }

    private DiskFileItemFactory createDiskFileItemFactory(String saveDir) {
        DiskFileItemFactory fac = new DiskFileItemFactory();
        // Make sure that the data is written to file
        fac.setSizeThreshold(0);
        if (saveDir != null) {
            fac.setRepository(new File(saveDir));
        }
        return fac;
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFileParameterNames()
     */
    public Enumeration<String> getFileParameterNames() {
        return Collections.enumeration(files.keySet());
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getContentType(java.lang.String)
     */
    public String[] getContentType(String fieldName) {
        List<FileItem> items = files.get(fieldName);

        if (items == null) {
            return null;
        }

        List<String> contentTypes = new ArrayList<String>(items.size());
        for (FileItem fileItem : items) {
            contentTypes.add(fileItem.getContentType());
        }

        return contentTypes.toArray(new String[contentTypes.size()]);
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFile(java.lang.String)
     */
    public File[] getFile(String fieldName) {
        List<FileItem> items = files.get(fieldName);

        if (items == null) {
            return null;
        }

        List<File> fileList = new ArrayList<File>(items.size());
        for (FileItem fileItem : items) {
            File storeLocation = ((DiskFileItem) fileItem).getStoreLocation();
            if(fileItem.isInMemory() && storeLocation!=null && !storeLocation.exists()) {
                try {
                    storeLocation.createNewFile();
                } catch (IOException e) {
                    if(LOG.isErrorEnabled()){
                        LOG.error("Cannot write uploaded empty file to disk: " + storeLocation.getAbsolutePath(),e);
                    }
                }
            }
            fileList.add(storeLocation);
        }

        return fileList.toArray(new File[fileList.size()]);
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFileNames(java.lang.String)
     */
    public String[] getFileNames(String fieldName) {
        List<FileItem> items = files.get(fieldName);

        if (items == null) {
            return null;
        }

        List<String> fileNames = new ArrayList<String>(items.size());
        for (FileItem fileItem : items) {
            fileNames.add(getCanonicalName(fileItem.getName()));
        }

        return fileNames.toArray(new String[fileNames.size()]);
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFilesystemName(java.lang.String)
     */
    public String[] getFilesystemName(String fieldName) {
        List<FileItem> items = files.get(fieldName);

        if (items == null) {
            return null;
        }

        List<String> fileNames = new ArrayList<String>(items.size());
        for (FileItem fileItem : items) {
            fileNames.add(((DiskFileItem) fileItem).getStoreLocation().getName());
        }

        return fileNames.toArray(new String[fileNames.size()]);
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getParameter(java.lang.String)
     */
    public String getParameter(String name) {
        List<String> v = params.get(name);
        if (v != null && v.size() > 0) {
            return v.get(0);
        }

        return null;
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getParameterNames()
     */
    public Enumeration<String> getParameterNames() {
        return Collections.enumeration(params.keySet());
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getParameterValues(java.lang.String)
     */
    public String[] getParameterValues(String name) {
        List<String> v = params.get(name);
        if (v != null && v.size() > 0) {
            return v.toArray(new String[v.size()]);
        }

        return null;
    }

    /* (non-Javadoc)
     * @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getErrors()
     */
    public List getErrors() {
        return errors;
    }

    /**
     * Returns the canonical name of the given file.
     *
     * @param filename  the given file
     * @return the canonical name of the given file
     */
    private String getCanonicalName(String filename) {
        int forwardSlash = filename.lastIndexOf("/");
        int backwardSlash = filename.lastIndexOf("\\");
        if (forwardSlash != -1 && forwardSlash > backwardSlash) {
            filename = filename.substring(forwardSlash + 1, filename.length());
        } else if (backwardSlash != -1 && backwardSlash >= forwardSlash) {
            filename = filename.substring(backwardSlash + 1, filename.length());
        }

        return filename;
    }

    /**
     * Creates a RequestContext needed by Jakarta Commons Upload.
     *
     * @param req  the request.
     * @return a new request context.
     */
    private RequestContext createRequestContext(final HttpServletRequest req) {
        return new RequestContext() {
            public String getCharacterEncoding() {
                return req.getCharacterEncoding();
            }

            public String getContentType() {
                return req.getContentType();
            }

            public int getContentLength() {
                return req.getContentLength();
            }

            public InputStream getInputStream() throws IOException {
                InputStream in = req.getInputStream();
                if (in == null) {
                    throw new IOException("Missing content in the request");
                }
                return req.getInputStream();
            }
        };
    }
}

UploadAction.java

import java.io.*;

import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class FileProgressUploadAction extends ActionSupport{
    	private File file;
   	private String fileFileName;
   	private String fileContentType;
	public File getFile() {
		return file;
	}
	
	public void setFile(File file) {
		this.file = file;
	}
    

	public String getFileFileName() {
		return fileFileName;
	}

	public void setFileFileName(String fileFileName) {
		this.fileFileName = fileFileName;
	}

	public String getFileContentType() {
		return fileContentType;
	}

	public void setFileContentType(String fileContentType) {
		this.fileContentType = fileContentType;
	}
    
	@Override
	public String execute(){
	   
	   try {
		   System.out.println("file:"+file);
		   InputStream is=new FileInputStream(file);
		   String root=ServletActionContext.getRequest().getRealPath("/upload");
		   System.out.println("root:"+root);
		   
		   System.out.println("name:"+this.fileFileName);
		   System.out.println("type:"+this.fileContentType);
		   File destFile=new File(root,this.fileFileName);
		   
		   OutputStream os=new FileOutputStream(destFile);	
		   
		   byte [] b=new byte[1024*1024*10];
		   int length=0;		  		   
		   while(true){
			     length=is.read(b);
			     if(length<0)
			    	 break;
		    	 os.write(b,0,length);			    	 
		   }		    

		   is.close();
		   os.close();
	   }catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
	   }
	  return "success";
   }
}

ProgressAction.java(更新进度条进度的Action)注：jsp使用setInterval用Ajax技术定时访问该Action，就可以定时获取到上传进度

import org.apache.struts2.ServletActionContext;
import javax.servlet.http.HttpSession;

import com.opensymphony.xwork2.ActionSupport;

public class FileProgressAction extends ActionSupport{
	private State state;
		
    public State getState() {
		return state;
	}

	public void setState(State state) {
		this.state = state;
	}


	@Override
    public String execute() throws Exception {
    	// TODO Auto-generated method stub
		HttpSession session=ServletActionContext.getRequest().getSession();
		this.state=(State)session.getAttribute("state");		
		if(state==null){
			System.out.println("action is null");
			state=new State();
			state.setCurrentItem(0);
		}else{
			
			Double a=Double.parseDouble(state.getReadedBytes()+"");
			Double b=Double.parseDouble(state.getTotalBytes()+"");			
			double result=a/b*100;
			state.setRate((int)result);
			System.out.println("action:"+state.getRate());
		}
		return "success";
    }
}

Upload.jsp(Ajax文件上传)需要下载ajaxfileupload.js,jquery-ui.js（显示进度条）插件

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>文件上传</title>
<link rel="stylesheet" href="js/jquery-ui-1.9.2.css" />  
<script src="js/jquery-1.8.3.js"></script>  
<script src="js/jquery-ui-1.9.2.js"></script>  
<script type="text/javascript" src="js/ajaxfileupload.js"></script>
<script type="text/javascript">
var time = 0;
function ajaxFileUpload()
{
	$( "#progressbar" ).progressbar({      
		 value: 0  
	});
	time = window.setInterval(progress,1000);
	$.ajaxFileUpload
	(
		{
			url:'hello.action',
			secureuri:false,
			fileElementId:'fileToUpload',//fileToUpload是input file 标签的id值
			dataType: 'multipart/form-data',
			success: function (data, status)
			{
				if(typeof(data.error) != 'undefined')
				{
					if(data.error != '')
					{
						alert(data.error);
					}else
					{
						alert(data.msg);
					}
				}
			},
			error: function (data, status, e)
			{
				alert(e);
			}
		}
	)
	return false;
}

function progress(){
	$.ajax({
		url:"progress.action",
		dataType: 'json',
		success:function(data){
			$("#loading").html(data.state.rate);
			$( "#progressbar" ).progressbar({      
				 value: data.state.rate   
			});
			if(data.state.rate == 100){
				clearInterval(time);
			}
		},
		error:function(){
			alert("error");
		}
	});
}
</script>
</head>
<body>	
	<form name="form" action="" method="POST" enctype="multipart/form-data">
	
		<input type="file" id="fileToUpload" name="fileToUpload"/>
		<input type="text" name="username"/>
		<input type="button" value="上传" οnclick="ajaxFileUpload()"/>
	</form>
	<div id="progressbar"></div>
</body>
</html>






 

 

码农wind
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
struts2带进度条上传文件
03-08
用struts2 写了个文件上传 有进度显示 可能比较烂 不喜勿喷
Struts2 文件上传进度条的实现实例代码
08-30
Struts2 文件上传进度条的实现是一个常见的需求，特别是在处理大文件上传时，为了提供良好的用户体验，进度条能够显示文件上传的状态，让用户了解文件传输的进度。以下将详细讲解如何在Struts2框架中实现这一功能。 ...
Struts2上传文件进度条
qq_36772604的博客
06-24 520
    这几天由于需要开始着手实现Struts上传文件的进度条，中途参考了许多大佬的文章，折腾了好几天终于是给弄出来了。就想写篇博客给记录一下免得自己又忘了。在实现的过程中遇到了不少bug，不过幸好没放弃。不多说，直接开始！解决方案的基本思路是这样的：　　在Form提交上传文件同时，使用AJAX周期性地从Action轮询上传状态信息　　然后，根据此信息更新进度条和相关文字，及时反映文件传输状态  ...
struts2文件上传带进度条（一）
做一只快乐的猿
06-01 1511
实现功能的思路： 1，得到文件上传的进度 2，在页面上显示上传的进度，这就需要不断去读取文件上传的进度 在实现这个功能的时候，首先要认识到，struts2是怎么处理上传的文件的， struts2也用到了它，那么，到底该怎么找到是哪个类对文件上传进行处理呢？ 首先想到的是在配置文件里面找到拦截文件上传的类，在struts2默认的配置文件里， <bean type="org.apac
struts2实现文件上传进度条（前端JS+Java）(自我整理)
风过留痕
06-15 3229
struts2实现文件上传进度条（前端JS+Java）(自我整理)
Struts2实现文件上传并显示实时进度
想成为工程师的码农
07-18 3823
我们为了改善用户界面，通常会在处理量大或者是网络速度较慢的时候，给用户显示一个处理进度，让用户心理有底，增强用户等待结果的耐心，以改善用户体验。为了达到这个效果，通常做法有两大类：简单等待和真实的处理进度，本文着重讨论第二种方法的实现。   1)简单的等待界面：这种做法之所以说简单，就是在用法发送了处理命令后，立即在页面的某个地方替换一个waiting的图片，比如一个转圈的GIF，一张Load
struts2_uploadify带进度条的多文件上传下载
04-25
总之，这个项目实例为使用Struts2和Uploadify实现带进度条的多文件上传及下载功能提供了一个基础模板，对于学习和实践此类功能的开发者来说是一个有价值的参考。通过深入研究和理解这个项目的代码，可以提升对Struts...
easyUi+jquery+common-file-upload +struts2带进度条的文件上传DEMO
06-08
基于eclipse + easyUi1.2.6+common-fileupload + struts2实现带进度条的文件上传DEMO，具体效果跟思路可见我的博客：http://blog.csdn.net/jun55xiu/article/details/22042279
struts2带进度条文件上传
07-23
1.struts2 带进度条文件上传 源码 2.源码中有lib 下载后部署马上就能用 3.代码中有详细的注释信息 4.对关键点有详细的解释说明 5.如果谁用起来觉得有问题可在评论留言，留联系方式，我会联系你的 6.非常感谢原创作者...
uploadify3与struts2结合实现有进度条文件上传实例
01-04
这是根据uploadify3 2结合struts2搭建的文件上传环境 可以直接导入eclipse运行 每步实现基本都加了注释 以下是我碰到的问题： 1 判断session是否失效 本实例没测试这个问题 但在工作项目中碰到了 但原因在这里...
struts2上传文件进度条显示
12-27
struts2上传文件进度条显示，里面有详细的代码
Struts2文件上传进度条显示
12-21
参考文章地址： http://blog.csdn.net/garryyrc/article/details/5499113 http://www.telio.be/blog/2006/01/06/ajax-upload-progress-monitor-for-commons-fileupload-example
java struts2实现文件上传进度条显示
04-21
java struts2实现文件上传进度条显示
EasyUI和Struts上传文件的例子
06-29
EasyUI和Struts相结合，上传文件，其中带进度条，JRE1.7才可以用
struts2文件上传(带进度条)
andy
07-22 232
struts2（ssh）带进度条文件上传 http://download.csdn.net/source/2351768 ssh2(struts2+spring2.5+hibernate3.3+ajax)带进度条文件上传（封装成标签） http://yale.iteye.com/blog/464132 struts2上传文件,显示进度条 http://blog.csdn.net/tom_...
【原创】论struts2上传文件进度条
garryyrc的专栏
04-18 9935
    最近在做一个文件上传中显示进度条的功能，也在网上搜了下例子还挺多的包括JSP版和SERVLET版的。这几个版本都比较好实现，但是struts2版本的进度条非常少，有个把例子但是也运行不了。但是公司用的又是S2，开始按照JSP版的弄了一个晚上还是无法实现。无奈之下只能睡觉了，睡觉的时候想到了S2文件的上传到action开始执行这一步的时候其实文件已经在服务器上了，action要做的就是将
struts2下实现上传文件进度条
liumengcheng的专栏
05-19 1294
首先用EasyUI做界面：
Struts2文件上传进度条实现详解与教程
在Struts2框架中实现文件上传显示进度条是一个常见的需求，尤其是在处理大文件上传时，用户希望能够直观地了解上传进度。本文将深入探讨如何利用Struts2的内部机制来实现这一功能。首先，我们需要理解Struts2中负责...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值