plupload.Uploader多文件上传

最新推荐文章于 2024-04-24 00:40:05 发布
最新推荐文章于 2024-04-24 00:40:05 发布
阅读量1.1k 收藏
点赞数
文章标签： json javascript c# ViewUI
原文链接：http://www.cnblogs.com/kexb/p/7782909.html
版权 
1.前台
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="CommonUpfile.aspx.cs" Inherits="HraWeb.ETL.CommonUpfile" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
    <title></title>
 <script type="text/javascript" src="/Scripts/plupload/js/plupload.full.min.js"></script>
   <style>
       #container{
           margin-left:100px;
       }
       button{
          width: 100px;
           height: 50px; 
           background-color: cornflowerblue;
       }
   </style>
</head>

<body style="font: 13px Verdana; background: #eee; color: #333">

<h1 style="margin-left:50px;">请选择要导入的文件</h1>

<p></p>

<div id="filelist"></div>
<br />

<div id="container">
    <button id="pickfiles" >浏览</button> &nbsp;&nbsp;&nbsp;
    <button id="uploadfiles" >上传的文件</button>
</div>

<br />
<pre id="console"></pre>


<script type="text/javascript">
    // Custom example logic
var uploader = new plupload.Uploader({
    runtimes: 'html5,flash,silverlight,html4',
    unique_names:true,
    multipart: true,
    multi_selection:true,
    chunk_size: '10mb',
    browse_button : 'pickfiles', // you can pass an id...
    container: document.getElementById('container'), // ... or DOM Element itself
    url: '/ETL/CommonUpfile.aspx?_method=upload&callBack=<%=Request["callBack"]%>',
    flash_swf_url: '/Scripts/plupload/js/Moxie.swf',
    silverlight_xap_url: '/Scripts/plupload/js/Moxie.xap',
    
    filters : {
        max_file_size : '1000mb'
        //,mime_types: [
        //    {title : "Image files", extensions : "jpg,gif,png"},
        //    {title : "Zip files", extensions : "zip"}
        //]
    },

    init: {
        PostInit: function() {
            document.getElementById('filelist').innerHTML = '';

            document.getElementById('uploadfiles').onclick = function () {
                alert("开始上传");
                uploader.start();
                return false;
            };
        },

        FilesAdded: function(up, files) {
            plupload.each(files, function(file) {
                document.getElementById('filelist').innerHTML += '<div id="' + file.id + '">' + file.name + ' (' + plupload.formatSize(file.size) + ') <b></b></div>';
            });
        },

        UploadProgress: function (up, file) {
           
            document.getElementById(file.id).getElementsByTagName('b')[0].innerHTML = '<span>' + file.percent + "%</span>";
        },

        Error: function (up, err) {
          
            document.getElementById('console').appendChild(document.createTextNode("\nError #" + err.code + ": " + err.message));
        },
        FileUploaded: function (up, file, res) {
           
           
            //res = JSON.parse(res.response);
            //art.dialog.close()
           
            //artDialog.open.origin.uploadCallBack(file.id,file.name);
           
        }
        , UploadComplete(up,files) {
            //alert("full");
            var fileArr = new Array();
            for (var i = 0; i < files.length; i++) {
                var f = new Object();
                f.id = files[i].id;
                f.name = files[i].name;
                fileArr.push(f);
                //alert(files[i].name+"...")
            }
            var fileObj = JSON.stringify(fileArr);
            $.post("CommonUpfile.aspx?_method=NewImportFile", { fileObj: fileObj }, function (data) {
                data = JSON.parse(data);
                $.messager.alert("导入完成",data.Message);
                artDialog.open.origin.dicCallback();
                art.dialog.close();
            });
        }
    }
});

uploader.init();
$("#console").hide();
</script>
   <form id="form1" runat="server">

    </form>
</body>

</html>

2.后台
using Contract.Domain;
using Contract.IService;
using Holworth.BatchingHosting.Interface;
using Holworth.Utility;
using SocketIM;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.ServiceModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace HraWeb.ETL
{
    public partial class CommonUpfile : Common.BasePage
    {
        private Contract.IService.IDaoService _dao; Contract.IService.IDaoService Dao { get { if (_dao == null) { _dao = ctx.GetObject("DaoService") as Contract.IService.IDaoService; } return _dao; } }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (Request["_method"] == "upload")
            {
                btn_UppLoad();
            }
            else if (Request["_method"] == "NewImportFile")
            {
                string fileObj = Request["fileObj"];
                string ipaddr = Holworth.Utility.HraUtility.ConfigurationManager.GetConfig("heartbeatservice", "/Config/ETL.config", HraUtility.IgnoreCase.Ignore);
                IHeartBeat channel = InvokeContext.CreateWCFServiceByURL<IHeartBeat>(ipaddr, "ws2007HttpBinding", null);
                ICommunicationObject communicationObject =
    (ICommunicationObject)channel;
               
                var dic = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(fileObj);
                Dictionary<string, string> idnames = new Dictionary<string, string>();
                foreach (var item in dic)
                {
                    var id = item.id.ToString().Replace("{", "").Replace("}", "");
                    var name = item.name.ToString().Replace("{", "").Replace("}", "");
                    idnames[id] = name.ToLower();

                }
                int i = 0;
                try
                {
                    channel.ClearOldFiles();
                    string root = Server.MapPath("~/upload");
                    var mapList = Dao.FindList<EtlDataMap>(new Framework.QueryInfo() { CustomSQL = "select a from EtlDataMap a" });
                  
                    var mapDict = mapList.ToDictionary(x => x.FileNameStart.ToLower());
                    string fileName = "";
                    idnames.AsParallel().ForAll(item =>
                    {
                        string ext = Path.GetExtension(item.Value);
                        string fileId = item.Key;
                        fileName = Path.Combine(root, fileId + ext);

                        try
                        {
                            SendFile(fileName, item.Value, mapDict[item.Value.Split('.')[0]].Id);
                            HttpMessages.Instance().PushMessage("导入" + item.Value + "成功");
                        }
                        catch (Exception ex)
                        {
                            HttpMessages.Instance().PushMessage("导入" + item.Value + "失败，因为：" + ex.Message);
                            Holworth.Utility.Logger.Fatal(ex);

                        }

                    });
                    HttpMessages.Instance().PushMessage("文件传输完毕");
                 
                    string mapIds = "";
                    foreach (var item in idnames)
                    {
                        mapIds += mapDict[item.Value.Split('.')[0]].Id + ",";
                    }
                    mapIds = mapIds.TrimEnd(',');
                    Dictionary<string, string> dic1 = new Dictionary<string, string>();
                    dic1["DataMap"] = string.Join(",", mapIds.Split(','));
                    dic1["FormId"] = Guid.NewGuid().ToString();
                    var s = Newtonsoft.Json.JsonConvert.SerializeObject(dic1);
                    try
                    {
                        channel.LoadEodFile(s, Guid.NewGuid().ToString());
                        communicationObject.Close();
                    }
                    catch (Exception ex)
                    {
                        communicationObject.Abort();
                    }

                    var message = new { Message = "导入成功,未导入的文件请查看文件是否在ETL中有定义！！！" };
                    Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(message));




                }
                catch (Exception ex)
                {
                    var message = new { ErrorCode = "-1", Message = "导入失败，因为" + ex.Message };
                    Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(message));
                    Holworth.Utility.Logger.Fatal(ex); ;
                }
                finally
                {
                    Response.End();
                }

            }

        }
        public void SendFile(string fileName, string fileNameStart, string mapId)
        {

            string ipaddr = Holworth.Utility.HraUtility.ConfigurationManager.GetConfig("heartbeatservice", "/Config/ETL.config", HraUtility.IgnoreCase.Ignore);
            IHeartBeat channel = InvokeContext.CreateWCFServiceByURL<IHeartBeat>(ipaddr, "ws2007HttpBinding", null);
            ICommunicationObject communicationObject =
(ICommunicationObject)channel;
            try
            {
               
                int maxBufferLength = 10 * 1024 * 1024;
                FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                long fileLen = fs.Length;                        // 文件长度
                long totalLen = fileLen;                            // 未读取部分
                int readLen = 0;                                // 已读取部分
                byte[] buffer = null;

                if (fileLen <= maxBufferLength)
                {            /* 文件可以一次读取*/
                    buffer = new byte[fileLen];
                    readLen = fs.Read(buffer, 0, (int)fileLen);
                    channel.Transfer(fileNameStart, buffer);
                }
                else
                {
                    /* 循环读取文件,并发送 */
                    while (totalLen != 0)
                    {

                        if (totalLen < maxBufferLength)
                        {
                            buffer = new byte[totalLen];
                            readLen = fs.Read(buffer, 0, Convert.ToInt32(totalLen));
                        }
                        else
                        {
                            buffer = new byte[maxBufferLength];
                            readLen = fs.Read(buffer, 0, maxBufferLength);
                        }
                        channel.Transfer(fileNameStart, buffer);
                        totalLen -= readLen;
                    }
                }
                fs.Flush();
                fs.Close();
                Dictionary<string, string> dic = new Dictionary<string, string>();
                dic["DataMap"] = string.Join(",", mapId.Split(','));
                dic["FormId"] = Guid.NewGuid().ToString();
                var s = Newtonsoft.Json.JsonConvert.SerializeObject(dic);
                //channel.LoadEodFile(s, Guid.NewGuid().ToString());
                communicationObject.Close();
            }
            catch (Exception ex)
            {
                communicationObject.Abort();
                Holworth.Utility.Logger.Fatal(ex);
                throw;
            }
            finally
            {
                //try
                //{
                //    File.Delete(fileName);
                //}
                //catch (Exception exx)
                //{
                //    Holworth.Utility.Logger.Fatal(exx);
                //}
            }
        }
        protected void btn_UppLoad()
        {
            int statuscode = 1;
            string message = string.Empty;
            string filepath = string.Empty;
            string root = Server.MapPath("~/upload");
            List<string> oldFiles = Net.GetFiles(root);
            //foreach (var item in oldFiles)
            //{
            //    if (File.Exists(item))
            //    {
            //        File.Delete(item);
            //    }
            //}
            //            string ipaddr = Holworth.Utility.HraUtility.ConfigurationManager.GetConfig("heartbeatservice", "/Config/ETL.config", HraUtility.IgnoreCase.Ignore);
            //            IHeartBeat channel = InvokeContext.CreateWCFServiceByURL<IHeartBeat>(ipaddr, "ws2007HttpBinding", null);
            //            ICommunicationObject communicationObject =
            //(ICommunicationObject)channel;
            try
            {
                //channel.InitDataNoInit();
                //communicationObject.Close();
                if (Request.Files != null && Request.Files.Count > 0)
                {
                    if (Request.Files.Count > 0)
                    {
                        try
                        {
                            string resourceDirectoryName = "upload";
                            string path = Server.MapPath("~/" + resourceDirectoryName);
                            if (!Directory.Exists(path))
                                Directory.CreateDirectory(path);

                            int chunk = Request.Params["chunk"] != null ? int.Parse(Request.Params["chunk"]) : 0; //获取当前的块ID，如果不是分块上传的。chunk则为0
                            string fileName = Request.Params["name"]; //这里写的比较潦草。判断文件名是否为空。
                                                                      //if (!fileName.Contains("qwert"))
                                                                      //{

                            //    fileName = $"{Path.GetFileName(fileName).Split('.')[0]}qwert.dat";
                            //}
                            string type = Request.Params["type"]; //在前面JS中不是定义了自定义参数multipart_params的值么。其中有个值是type:"misoft"，此处就可以获取到这个值了。获取到的type="misoft";

                            string ext = Path.GetExtension(fileName);
                            //fileName = string.Format("{0}{1}", Guid.NewGuid().ToString(), ext);
                            filepath = resourceDirectoryName + "/" + fileName;
                            fileName = Path.Combine(path, fileName);

                            //对文件流进行存储 需要注意的是 files目录必须存在（此处可以做个判断） 根据上面的chunk来判断是块上传还是普通上传 上传方式不一样 ，导致的保存方式也会不一样
                            FileStream fs = new FileStream(fileName, chunk == 0 ? FileMode.OpenOrCreate : FileMode.Append);
                            //write our input stream to a buffer
                            Byte[] buffer = null;
                            if (Request.ContentType == "application/octet-stream" && Request.ContentLength > 0)
                            {
                                buffer = new Byte[Request.InputStream.Length];
                                Request.InputStream.Read(buffer, 0, buffer.Length);
                            }
                            else if (Request.ContentType.Contains("multipart/form-data") && Request.Files.Count > 0 && Request.Files[0].ContentLength > 0)
                            {
                                buffer = new Byte[Request.Files[0].InputStream.Length];
                                Request.Files[0].InputStream.Read(buffer, 0, buffer.Length);
                            }

                            //write the buffer to a file.
                            if (buffer != null)
                                fs.Write(buffer, 0, buffer.Length);
                            fs.Close();

                            statuscode = 1;
                            message = "上传成功";

                        }
                        catch (Exception ex)
                        {
                            statuscode = -1001;
                            message = "保存时发生错误，请确保文件有效且格式正确";

                            Holworth.Utility.Logger.Fatal(ex.Message);
                        }
                    }
                    else
                    {
                        statuscode = -404;
                        message = "上传失败，未接收到资源文件";
                    }

                    string msg = "{\"statusCode\":\"" + statuscode + "\",\"message\":\"" + message + "\",\"filePath\":\"" + filepath + "\"}";
                    //Response.Write(msg);


                }
            }
            catch (Exception ex)
            {

                Holworth.Utility.Logger.Fatal(ex);
                // communicationObject.Abort();
            }
            finally
            {
                //Response.End();
            }

        }
        IEtlExcelService svc
        {
            get
            {
                return (IEtlExcelService)ctx.GetObject("EtlExcelService");
            }
        }

    }
}

 

转载于:https://www.cnblogs.com/kexb/p/7782909.html

weixin_34259159
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
文件上传并读取plupload与java后台的整合实例
12-26
文件上传并读取plupload与java后台的整合实例
前端上传组件Plupload使用指南
juziaixiao的博客
06-17 948
Plupload有以下功能和特点： 1、拥有多种上传方式：HTML5、flash、silverlight以及传统的。Plupload会自动侦测当前的环境，选择最合适的上传方式，并且会优先使用HTML5的方式。所以你完全不用去操心当前的浏览器支持哪些上传方式，Plupload会自动为你选择最合适的方式。 2、支持以拖拽的方式来选取要上传的文件 3、支持在前端压缩图片，即在图片文件还未上传之前就对它进行压缩 4、可以直接读取原生的文件数据，这样的好处就是例如可以在图片文件还未上传之前就能把它显示在页面上预览 5
Plupload上传插件详解，多实例上传
a281246240的专栏
04-08 6269
我们来看一个比较全的  Plupload  Demo charset="UTF-8"> Plupload使用指南 src="js/plupload.full.min.js"> id="browse">选择文件 id="start_upload">开始上传 //实例化一个plupl
【Plupload插件】基础使用教程
weixin_44707049的博客
04-13 5124
前言 Plupload是一款由著名的web编辑器TinyMCE团队开发的上传组件，简单易用且功能强大。 特点 拥有多种上传方式：HTML5、flash、silverlight以及传统的。Plupload会自动侦测当前的环境，选择最合适的上传方式，并且会优先使用HTML5的方式。所以你完全不用去操心当前的浏览器支持哪些上传方式，Plupload会自动为你选择最合适的方式。 支持以拖拽的方式来选取要上传的文件 支持在前端压缩图片，即在图片文件还未上传之前就对它进行压缩 可以直接读取原生的文件数据，这样的好处就
plupload文件上传插件使用
峪幽兰 的博客
03-07 867
官方文档：http://www.phpin.net/tools/plupload/ //实例化组件 //附件1上传路径 var dirFile1 = '/upload/htfj/rchtfj/${data.xshthtbh}/fj1/'; var uploader1 = new plupload.Uploader({ runtimes: 'html5,flash,silverlight,ht...
Plupload 上传控件使用指南
weixin_30457551的博客
08-26 1118
本文转载至(感谢原作者分享)：http://www.cnblogs.com/2050/p/3913184.html#plupload_doc2 我之前写过一篇文章《文件上传利器SWFUpload使用指南》，里面介绍了上传组件SWFUpload的使用方法，但现在随着html5技术的逐渐推广和普及，再去使用以flash为上传手段的SWFUpload显然就有点过时了，毕竟html5原生的就给我们提...
PLUpload文件上传的使用
热门推荐
点滴
07-08 2万+
简单而且实用的大（多）文件前端上传组件PlUpload
thinkphp5 框架结合plupload实现图片批量上传功能示例
12-18
本文实例讲述了thinkphp5 框架结合plupload实现图片批量上传功能。分享给大家供大家参考，具体如下： 在extend目录下新增目录uploader，并新建类Uploads <?php namespace uploader; class Uploads { public ...
基于SpringBoot的文件上传系统，前后端分离，单文件上传，多文件上传，大文件上传，断点续传，文件秒传，图片上传
06-14
基于SpringBoot的文件上传系统，前后端分离，单文件上传，多文件上传，大文件上传，断点续传，文件秒传，图片上传 项目经过严格测试，确保可以运行！ 采用前后端分离的方式进行开发，实现了几种常用的文件上传功能...
OneupUploaderBundle：此Symfony捆绑包提供了服务器实现，用于使用FineUploader，jQuery File Uploader，YUI3 Uploader，Uploadify，FancyUpload，MooUpload，Plupload或Dropzone处理单个和多个文件上传。 功能包括分块上传，孤儿院，Gaufrette和Flysystem支持
02-05
您选择的前端库处理的多个文件上传 分块上传 支持： / /本地文件系统 提供一个孤儿院，用于清理孤立的文件 从PHP 5.4开始支持 全面测试 文献资料 文档的入口点可以在文件Resources/docs/index.md 升级说明 3.0.0版...
Plupload-Global-Uploader:创建一个全局上传器的实验，不同的上传上下文可以使用各种放置区（即 FileDrops）“挂钩”。 这是一个使用 AngularJS 的
07-13
在 AngularJS 中使用 Plupload 作为全局上传器 （在） 我多年来一直在使用 ，并取得了巨大的成功。 但是，在大多数情况下，我在一对一的上下文中使用它。 意思是，一个上下文，一个上传者。 虽然这是有效的，但它要求用户在执行上传时保持在相同的上下文中。 作为一个实验，我想看看我是否可以打破这种范式并使用单个全局上传器。 然后，在每个上下文中，我不是创建一个实际的上传器实例，而是创建一个“挂钩”全局上传器的 dropzone。 这样，用户可以在（单页）应用程序中移动，同时在后台上传所选文件。 在这个实验中，我有一个全局上传器和两个不同的部分。 每个部分都有自己的放置区，用于将文件发送到全局上传器。 然后，用户可以在上传部分特定文件的同时在部分之间导航。
Plupload多文件上传(调整后)
01-22
之前有下过其他人struts2版本的文件上传，但是在上传大于2M的文件时出现了错误。 之后找到了另外一个Servlet文件，和之前下载的代码整理之后，传上来让大家参考。
http-uploader:您可以使用可恢复文件上传服务通过 HTTP 上传任意大小的文件
06-01
您可以使用可恢复文件上传服务通过 HTTP 上传任何大小的文件。 一段时间以来，由于我有这个想法，我曾多次尝试构建 VCU。 使用 Plone/Zope 后端和 Silverlight 小程序作为客户端的两个版本。 对于这些版本，还创建...
plupload插件上传总结(分片上传，php后端处理）
Stonelalala的博客
04-01 6459
plupload插件官方地址：plupload官方网站 参数，方法，设置说明文档地址：配置文档 前端 使用方法： <!-- 引入plupload文件 --> <!-- moxie用来生成图片缩略图 --> <script src="./plupload/js/moxie.js"></script> <script src="./pl...
vue中使用Plupload分片上传
weixin_52484354的博客
12-30 1084
vue中使用Plupload分片上传
前端 -＞ Plupload 一个Web浏览器上的界面友好的文件上传模块
rod0320的博客
12-14 394
文章目录方法列表：属性集合：事件集合:（up为uploader缩写） 方法列表： Uploader(setting)：创建实例的构造方法 var uploader = new plupload.Uploader({ runtimes : 'gears,html5,flash',browse_button : 'button_id' }); bind(event, function[, scope])：绑定事件 uploader.bind('Init', function(up) { alert('
Java面试八股之marshalling和demarshalling
u012151345的博客
04-21 487
Marshalling（序列化）是将内存中的对象状态转化为适合传输或存储的格式（如字节流、JSON、XML），以便进行网络通信、持久化存储或跨平台/语言交互操作。- JSON、XML绑定库：如Jackson、Gson（JSON）和JAXB、XMLBeans（XML），实现对象与数据格式的互转。- 第三方库：如protobuf、Avro、Jackson、Gson，提供更灵活、高效的解决方案。3. 优化性能，减少传输量、提升速度，合理设计降低CPU和内存使用。2. 保证数据安全，通过加密、压缩、校验等手段。
文本文件转JSON格式
最新发布
星霜笔记
04-24 185
资源￥https://kdocs.cn/l/crzS58nUMuN2。资源https://kdocs.cn/l/crzS58nUMuN2。每一行文字与链接用￥分割。
Kubernetes JSONpath如何使用？
duansamve的博客
04-21 365
你可以使用 JSONPath 表达式来组合多个字段，并自定义输出格式。这条命令将返回 Pod 名称和 IP 地址，它们之间用制表符（\t）分隔，每个 Pod 的信息占一行。
plupload 所有文件*.*
08-31
Plupload支持上传所有类型的文件，包括任何扩展名的文件。你可以使用通配符*.*来表示所有文件类型。<span class="em">1</span><span class="em">2 #### 引用[.reference_title] - *1* [plupload-2.3.4 最新js文件]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值