Web开发--上传文件

最新推荐文章于 2023-02-14 15:59:25 发布
最新推荐文章于 2023-02-14 15:59:25 发布
阅读量661 收藏 1
点赞数
分类专栏： web开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhy5261302/article/details/53884130
版权

最近有个项目要求做到通过web方式在线更新一款嵌入式（snmp agent）设备的应用程序。所以做了以下调试，然后权衡利弊后选择第三种方式

这里介绍三种方式实现web上传文件：

*1. 使用插件*
下面这个连接介绍了十种插件。但是由于官方下载的插件例子都是php作为后台处理脚本，我做的嵌入式应用是不支持PHP的，只能支持C和shell。
http://www.chinaz.com/free/2013/0409/298937.shtml
upload.html

<html>
<head>
<title>My Uploadify Implementation</title>

<link rel="stylesheet" type="text/css" href="commJS/uploadify/uploadify.css" />
<script type="text/javascript" src="commJS/jquery-1.8.2.min.js"></script>
<script type="text/javascript" src="commJS/uploadify/jquery.uploadify.js"></script>
<script type="text/javascript" src="commJS/uploadify/jquery.uploadify.min.js"></script>
<script type="text/javascript">
        $(function() {
            $('#file_upload').uploadify({
                'swf'      : 'commJS/uploadify/uploadify.swf',
                'uploader' : 'commJS/uploadify/uploadify.php',
                'script': 'commJS/uploadify/uploadify.sh', 
                'fileTypeDesc':'Image Files',
                'fileTypeExts':'*.jpg;*.jpeg;*.gif;*.png;*.bmp',
                'buttonText' : 'BROWSE...',
                 'debug' : true,
                 'auto'                 : true, //是否自动上传,   
                 'cancelImage' : 'commJS/uploadify/uploadify-cancel.png',
                 //修改formData数据   
                'onUploadStart' : function(file) {
                    $("#file_upload").uploadify("settings", "someOtherKey", 2);   
                },

                 //上传成功   
                'onUploadSuccess' : function(file, data,
                        response) {
                        alert(file.name + ' | ' + response + ':' + data);   
                    },
                 'onUploadComplete' : function(file) {
                                    alert('The file ' + file.name + ' finished processing.');   
                                }
                // Your options here
            });
        });
</script>
</head>
<body>
    <input type="file" name="file_upload" id="file_upload" />
</body>
</html>

PHP:

<?php
/*
Uploadify
Copyright (c) 2012 Reactive Apps, Ronnie Garcia
Released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
*/

// Define a destination
$targetFolder = '/uploads'; // Relative to the root

$verifyToken = md5('unique_salt' . $_POST['timestamp']);

if (!empty($_FILES) && $_POST['token'] == $verifyToken) {
    $tempFile = $_FILES['Filedata']['tmp_name'];
    $targetPath = $_SERVER['DOCUMENT_ROOT'] . $targetFolder;
    $targetFile = rtrim($targetPath,'/') . '/' . $_FILES['Filedata']['name'];

    // Validate the file type
    $fileTypes = array('jpg','jpeg','gif','png'); // File extensions
    $fileParts = pathinfo($_FILES['Filedata']['name']);

    if (in_array($fileParts['extension'],$fileTypes)) {
        move_uploaded_file($tempFile,$targetFile);
        echo '1';
    } else {
        echo 'Invalid file type.';
    }
}
?>

*2. 使用Post方式*
经过测试发现这种方式一次只能传送3KB大小的文件，而我要上传的文件有5M左右，所以此方式感觉行不通，或者可以修改代码实现分段上传；但是感觉实现起来太麻烦就放弃了。
参考：代码做了一下修改以实现文件成功上传。
http://www.justwinit.cn/post/6314/
http://wenku.baidu.com/link?url=XDk_VErYp8H-y4Rjw8a5g832FDEK6U0N-P_PrMSn_BCdCKTuHszrTM06xVOuos41olCNAyIXLMC_0lJrSDH6_uQgzeTRmS8CxUS1X-Xesju

upload.html

<FORM METHOD="POST" id="form1" name="form1" ENCTYPE="multipart/form-data" ACTION="cgi-bin/setUpgrade.cgi">
select file：<INPUT TYPE="FILE" NAME="FILE1" id="FILE1"><INPUT TYPE="button" onclick="upload_file()" VALUE="上传" ><br>
<center>
<div id="uploadInfo"></div>
</center>
</FORM>

setUpgrade.c

#include   <stdio.h> 
#include   <stdlib.h> 
#include   <string.h> 
#include   <ctype.h> 
#include   <fcntl.h> 

#include <volcfg.h>
#include <shmram.h>
#include <volmibvar.h>
#include <s_share.h>
#include <cgi.h>
#include <gsemaphore.h>
#include <volSNTPTask.h>


#define UPLOAD_PATH "/root/upgrade.tar.gz"  //"../htdocs/ac483/ac483_bak"

void fit(char *,unsigned size);

int   main(int   argc,   char   *argv[]) 
{ 
    printf("Content-Type:text/html\n\n");     
    char   *pMethod   =   getenv("REQUEST_METHOD");
    //printf("pMethod=%s\n",pMethod); 
    if(pMethod   ==   NULL   ||   *pMethod   ==   0) 
    { 
        printf("No   Any   Method!\n"); 
        return   0; 
    } 

    if(strcmp(pMethod,   "GET")   ==   0) 
        return   1; 

    if(strcmp(pMethod,   "POST")   ==   0) 
    { 
        char   *pCntLen   =   getenv("CONTENT_LENGTH"); 
        //printf("pCntLen=%s\n",pCntLen);
        if(!pCntLen) 
        { 
            printf("Can't   get   Content_Length!\n"); 
            return   0; 
        } 
        if(*pCntLen   ==   0) 
        { 
            printf("Can't   get   Content_Length!\n"); 
            return   0; 
        } 
        int   StrLen   =   atoi(pCntLen);
        // printf("StrLen=%d\n",StrLen); 
        if(StrLen   <=   0) 
        { 
            printf("String   Length   <=   0\n"); 
            return   0; 
        } 
        //char *ph = getenv("CONTENT_TYPE");
        //printf("ph=%s\n",ph);

        char *readstr=(char   *)malloc(StrLen+1);
        fread(readstr,StrLen,1,stdin);
        // printf("readstr=%s\n",readstr);
        int n=0;
        int firstLineMark=0;
        int firstLineCount=0;
        int headCount=0;
        while(n<4)
        {
            if(*(readstr++)=='\n')
            {
                firstLineMark++;
                n++;
            }
            if(firstLineMark==0)
            {
                firstLineCount++;
            }
            headCount++;

        }

        StrLen = StrLen-headCount;
        fit(readstr,13);
        /*if(strcmp(readstr,ACHEAD)!=0)
        {
            printf("<SCRIPT language=JavaScript>alert('file format not support!');javascript:history.go(-1)</SCRIPT>");

            return 0;
        }
        */
        FILE *fp;
        if((fp=fopen(UPLOAD_PATH,"wb"))==NULL)
        {
            printf("error open file\n");
            return 0;
        }
        fwrite(readstr+13,StrLen-13-firstLineCount-5,1,fp);
        fclose(fp);
        printf("<SCRIPT language=JavaScript>alert('congratulations!');javascript:history.go(-1)</SCRIPT>");

    } 
    return   0; 
}   
void fit(char *string,unsigned size)
{
    if(strlen(string)>size)
        *(string+size)='\0';
}

*3. 使用websocket方式上传文件*
文件上传过程：先建立sock连接，web client通过sock发送要上传的文件名字，收到服务器返回的ACK后就开始发送文件，每次发送1KB并等待服务器返回ACK后发送下1KB直到全部发送完成，最后发送Send success。
web界面参考了下面的连接
http://www.cnblogs.com/tianma3798/p/5852527.html
服务器端则参考了下面的连接：对于服务器程序有两个地方我是建议修改的，一个是每次调用analyData();函数的时候要先释放掉前一次占用的内存空间（加入代码 if(payloadData !=NULL) free(payloadData); ）；二是response(); 中的
if(!data ) //这里还是个野指针。
{
return;
}
改为
if(!message) // data 改为 message
{
return;
}
http://blog.csdn.net/xxdddail/article/details/19070149

**

Code：

**
upload.html

<html>

    <head>
        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />

    </head>
<body>
    <div >
        <div >
            <div >Block read the file:</div>
            <div  id="bodyOne">
                <input type="file" value="Browse..." id="file"  multiple/>
                <input type="button" onclick="upgrade()"  value="Upgrade"/><br />
            </div>
        </div>
    </div>
</body>
    <script type="text/javascript">

    //封装 单个文件上传实例
    (function () {
        var ip_addr = document.location.hostname;
        var url = 'ws://'+ip_addr+":8000";
        //指定上传文件,创建上传操作对象
        function uploadOperate(file) {
            var _this = this;
            this.reader = new FileReader();//读取文件对象
            this.step = 1024 * 1;//每次读取文件字节数
            this.curLoaded = 0; //当前读取位置
            this.file = file;   //当前文件对象
            this.enableRead = true; //指定是否可读取,
            this.total = file.size;  //当前文件总大小
            this.startTime = new Date(); //开始读取时间
            //创建显示
            this.createItem();
            this.initWebSocket(function () {
                _this.bindReader();
            });
            console.info('file size:' + this.total);
        }
        uploadOperate.prototype = {
            //绑定读取事件
            bindReader: function () {
                var _this = this;
                var reader = this.reader;
                var ws = this.ws;
                if (_this.curLoaded <= 0)
                {
                    ws.send(_this.file.name);
                    console.log('----ws.send(_this.file.name);...');
                }
                reader.onload = function (e) {
                    //判断是否能再次读取
                    if (_this.enableRead == false) return;
                    //根据当前缓冲区 控制读取速度
                    if (ws.bufferedAmount >= _this.step * 20) {
                        setTimeout(function () {
                            _this.loadSuccess(e.loaded);
                        }, 5);
                        console.info('----wait...');
                    } else {
                        _this.loadSuccess(e.loaded);
                    }
                }
                //开始读取
                //_this.readBlob();
            },
            //读取成功,操作处理
            loadSuccess: function (loaded) {
                var _this = this;
                var ws = _this.ws;
                //使用WebSocket 将二进制输出上传到服务器
                var blob = _this.reader.result;

                ws.send(blob);//send to server
                console.log('----ws.send(blob);...');

                //当前发送完成,继续读取
                _this.curLoaded += loaded;
                if (_this.curLoaded < _this.total) {

                } else {
                    //发送读取完成
                    ws.send('Send success.');
                    console.log('----ws.send(\'Send success.\');...');
                    //读取完成
                    console.log('Total upload:' + _this.curLoaded + ',Total time:' + (new Date().getTime() - _this.startTime.getTime()) / 1000);
                }
                //显示进度等
                _this.showProgress();
            },
            //创建显示项
            createItem: function () {
                var _this = this;
                var blockquote = document.createElement('blockquote');
                var abort = document.createElement('input');
                abort.type = 'button';
                abort.value = 'Pause';
                abort.onclick = function () {
                    _this.stop();
                };
                blockquote.appendChild(abort);

                var containue = document.createElement('input');
                containue.type = 'button';
                containue.value = 'Continue';
                containue.onclick = function () {
                    _this.containue();
                };
                blockquote.appendChild(containue);

                var progress = document.createElement('progress');
                progress.style.width = '400px';
                progress.max = 100;
                progress.value = 0;
                blockquote.appendChild(progress);
                _this.progressBox = progress;

                var status = document.createElement('p');
                status.id = 'Status';
                blockquote.appendChild(status);
                _this.statusBox = status;

                document.getElementById('bodyOne').appendChild(blockquote);
            },
            //显示进度
            showProgress: function () {
                var _this = this;
                var percent = (_this.curLoaded / _this.total) * 100;
                _this.progressBox.value = percent;
                _this.statusBox.innerHTML = percent;
            },
            //执行读取文件
            readBlob: function () {
                var blob = this.file.slice(this.curLoaded, this.curLoaded + this.step);
                this.reader.readAsArrayBuffer(blob);
            },
            //中止读取
            stop: function () {
                this.enableRead = false;
                this.reader.abort();
                console.log('Stop read,curLoaded:' + this.curLoaded);
            },
            //继续读取
            containue: function () {
                this.enableRead = true;
                this.readBlob();
                console.log('Continue read,curLoaded:' + this.curLoaded);
            },
            //初始化 绑定创建连接
            initWebSocket: function (onSuccess) {
                var _this = this;
                var ws = this.ws = new WebSocket(url); //初始化上传对象
                ws.onopen = function () {// 三次握手---horsen
                    console.log('connect creat success');
                    if (onSuccess)
                        onSuccess();
                }
                ws.onmessage = function (e) {
                    var data = e.data;
                    if (isNaN(data) == false) {
                        console.log('Sever receive success:' + data);
                    } else {
                        console.log(data);
                        _this.readBlob();-----------------------------收到服务器返回的ok，才发送下一个数据
                    }
                }
                ws.onclose = function (e) {
                    //中止读取
                    _this.stop();
                    console.log('connect is broken');
                }
                ws.onerror = function (e) {
                    //中止读取
                    _this.stop();
                    console.log('Exception occurs:' + e.message);
                }
            }
        };
        window.uploadOperate = uploadOperate;
    })();
    </script>
    <script type="text/javascript">
    //var fileBox = document.getElementById('file');
    //  fileBox.onChange = function () {
        function upgrade() {
            var fileBox = document.getElementById('file');
            var files = fileBox.files;
            for (var i = 0; i < files.length; i++) {
                var file = files[i];
                var operate = new uploadOperate(file);
            }
        }
  </script>

</html>

uploadserver.c

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
#include   <fcntl.h> 

#include <volcfg.h>
#include <shmram.h>
#include <volmibvar.h>
#include <s_share.h>
#include <cgi.h>
#include <gsemaphore.h>
#include <volSNTPTask.h>

#include "base64.h"  
#include "sha1.h"  
#include "intLib.h"  

#define UPLOAD_PATH "/root/"

#define REQUEST_LEN_MAX 1024*10 
#define DEFEULT_SERVER_PORT 8000  
#define WEB_SOCKET_KEY_LEN_MAX 256  
#define RESPONSE_HEADER_LEN_MAX 1024  
#define LINE_MAX 256  

#if(1)
void shakeHand(int connfd,const char *serverKey);  
char * fetchSecKey(const char * buf);  
char * computeAcceptKey(const char * buf);  
char * analyData(const char * buf,const int bufLen, int* datalen);  
char * packData(const char * message,unsigned long * len);  
void response(const int connfd,const char * message);  
int saveFile(FILE **fp,char* buf,int length);


#endif

int main(int argc, char *argv[])  
{  
    struct sockaddr_in servaddr, cliaddr;  
    socklen_t cliaddr_len;  
    int listenfd, connfd;  
    char buf[REQUEST_LEN_MAX]; 
    char tempbuf[32]={"\0"};
    char *data;  
    char str[INET_ADDRSTRLEN];  
    char *secWebSocketKey;  
    int i,n,datalength,datalengthAll=0;  
    int connected=0;//0:not connect.1:connected.  
    int port= DEFEULT_SERVER_PORT;  

    FILE *fp;

    if(argc>1)  
    {  
        port=atoi(argv[1]);  
    }  
    if(port<=0||port>0xFFFF)  
    {  
        printf("Port(%d) is out of range(1-%d)\n",port,0xFFFF);  
        return;  
    }  
    listenfd = socket(AF_INET, SOCK_STREAM, 0);  

    bzero(&servaddr, sizeof(servaddr));  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
    servaddr.sin_port = htons(port);  

    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));  

    listen(listenfd, 20);  

    printf("Listen %d\nAccepting connections ...\n",port);  
    cliaddr_len = sizeof(cliaddr);  
    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);  
    printf("From %s at PORT %d\n",  
        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),  
        ntohs(cliaddr.sin_port));  

    while (1)  
    {  

        memset(buf,0,REQUEST_LEN_MAX);  
        //printf("--------read..-------------\n");  
        n = read(connfd, buf, REQUEST_LEN_MAX);   
        if(0==n) break; 

        if(0==connected)  
        {  
            //printf("read:%d\n%s\n",n,buf);  
            secWebSocketKey=computeAcceptKey(buf);    
            shakeHand(connfd,secWebSocketKey);  
            connected=1;  
            continue;  
        }  

        //printf("******************data analy*****************\n");  

        data=analyData(buf,n,&datalength); 
        fflush(stdout);
        datalengthAll += datalength;
        //printf("reveice size:%d\r",datalengthAll);

        if(memcmp(data,"Send success.",13)==0) {
            printf("Receive success!\n"); 
            sprintf(tempbuf,"%d",datalengthAll);
            response(connfd,tempbuf);
            sleep(2);
            break;
        }

        saveFile(&fp,data,datalength);

        response(connfd,"ACK\n");

    }

    fclose(fp);
    close(connfd);  

}  

#if(1)
int saveFile(FILE **fp,char* buf,int length){
    int res=0;
    if(*fp==NULL){
        char sfile[64]={"\0"};
        sprintf(sfile,"%s%s",UPLOAD_PATH,buf);

        if(access(sfile,R_OK) == 0){// if file have exist ,remove it.
            if(unlink(sfile)<0){
                printf("unlink %s error !\n",sfile);
                return 0;
            }
        }
        printf("sfile:%s--buflen(%d)!\n",sfile,strlen(buf));
        if((*fp=fopen(sfile,"wb"))==NULL)// creat a file.
        {
            printf("error open file %s\n",sfile);
            return 0;
        }
        printf("saveFile creat file %s success! %d  !\n",sfile,length);
        return 1;
    }

    res= fwrite(buf,length,1,*fp);
    //printf("res=%d---length=%d--\n",res,length);//debug-----------------
    return length;
}
/*******************************************************/
char * fetchSecKey(const char * buf)  
{  
    char *key;  
    char *keyBegin;  
    char *flag="Sec-WebSocket-Key: ";  
    int i=0, bufLen=0;  

    key=(char *)malloc(WEB_SOCKET_KEY_LEN_MAX);  
    memset(key,0, WEB_SOCKET_KEY_LEN_MAX);  
    if(!buf)  
    {  
        return NULL;  
    }  

    keyBegin=strstr(buf,flag);  
    if(!keyBegin)  
    {  
        return NULL;  
    }  
    keyBegin+=strlen(flag);  

    bufLen=strlen(buf);  
    for(i=0;i<bufLen;i++)  
    {  
        if(keyBegin[i]==0x0A||keyBegin[i]==0x0D)  
        {  
            break;  
        }  
        key[i]=keyBegin[i];  
    }  

    return key;  
}  

char * computeAcceptKey(const char * buf)  
{  
    char * clientKey;  
    char * serverKey;   
    char * sha1DataTemp;  
    char * sha1Data;  
    short temp;  
    int i,n;  
    const char * GUID="258EAFA5-E914-47DA-95CA-C5AB0DC85B11";  


    if(!buf)  
    {  
        return NULL;  
    }  
    clientKey=(char *)malloc(LINE_MAX);  
    memset(clientKey,0,LINE_MAX);  
    clientKey=fetchSecKey(buf);  

    if(!clientKey)  
    {  
        return NULL;  
    }  


    strcat(clientKey,GUID);  

    sha1DataTemp=sha1_hash(clientKey);  
    n=strlen(sha1DataTemp);  


    sha1Data=(char *)malloc(n/2+1);  
    memset(sha1Data,0,n/2+1);  

    for(i=0;i<n;i+=2)  
    {        
        sha1Data[i/2]=htoi(sha1DataTemp,i,2);      
    }   

    serverKey = base64_encode(sha1Data, strlen(sha1Data));   

    return serverKey;  
}  

void shakeHand(int connfd,const char *serverKey)  
{  
    char responseHeader [RESPONSE_HEADER_LEN_MAX];  

    if(!connfd)  
    {  
        return;  
    }  

    if(!serverKey)  
    {  
        return;  
    }  

    memset(responseHeader,'\0',RESPONSE_HEADER_LEN_MAX);  

    sprintf(responseHeader, "HTTP/1.1 101 Switching Protocols\r\n");  
    sprintf(responseHeader, "%sUpgrade: websocket\r\n", responseHeader);  
    sprintf(responseHeader, "%sConnection: Upgrade\r\n", responseHeader);  
    sprintf(responseHeader, "%sSec-WebSocket-Accept: %s\r\n\r\n", responseHeader, serverKey);  

    printf("Response Header:%s\n",responseHeader);  

    write(connfd,responseHeader,strlen(responseHeader));  
}  

/***********************************************************************/
char * analyData(const char * buf,const int bufLen, int* datalen)  
{  
    char * data;  
    char fin, maskFlag,masks[4];  
    static char * payloadData=NULL;  
    char temp[8];  
    unsigned long n, payloadLen=0;  
    unsigned short usLen=0;  
    int i=0;   

    if(payloadData !=NULL) free(payloadData);// 释放上次读取数据的内存空间，数据已经保存到文件里面去了

    if (bufLen < 2)   
    {  
        return NULL;  
    }  

    fin = (buf[0] & 0x80) == 0x80; // 1bit，1表示最后一帧    
    if (!fin)  
    {  
        return NULL;// 超过一帧暂不处理   
    }  

    maskFlag = (buf[1] & 0x80) == 0x80; // 是否包含掩码    
    if (!maskFlag)  
    {  
        return NULL;// 不包含掩码的暂不处理  
    }  

    payloadLen = buf[1] & 0x7F; // 数据长度   
    if (payloadLen == 126)  
    {        
        memcpy(masks,buf+4, 4);        
        payloadLen =(buf[2]&0xFF) << 8 | (buf[3]&0xFF);    
        payloadData=(char *)malloc(payloadLen);  
        memset(payloadData,0,payloadLen);  
        memcpy(payloadData,buf+8,payloadLen);  
    }  
    else if (payloadLen == 127)  
    {  
        memcpy(masks,buf+10,4);    
        for ( i = 0; i < 8; i++)  
        {  
            temp[i] = buf[9 - i];  
        }   

        memcpy(&n,temp,8);    
        payloadData=(char *)malloc(n);   
        memset(payloadData,0,n);   
        memcpy(payloadData,buf+14,n);//toggle error(core dumped) if data is too long.  
        payloadLen=n;      
    }  
    else  
    {     
        memcpy(masks,buf+2,4);      
        payloadData=(char *)malloc(payloadLen);  
        memset(payloadData,0,payloadLen);  
        memcpy(payloadData,buf+6,payloadLen);   
    }  

    for (i = 0; i < payloadLen; i++)  
    {  
        payloadData[i] = (char)(payloadData[i] ^ masks[i % 4]);  
    }  

    //printf("data(%d):%s\n",(int)payloadLen,payloadData);  
    *datalen = (int)payloadLen;
    return payloadData;  
}  

char *  packData(const char * message,unsigned long * len)  
{  
    char * data=NULL;  
    unsigned long n;  

    n=strlen(message);  
    if (n < 126)  
    {  
        data=(char *)malloc(n+2);  
        memset(data,0,n+2);      
        data[0] = 0x81;  
        data[1] = n;  
        memcpy(data+2,message,n);  
        *len=n+2;  
    }  
    else if (n < 0xFFFF)  
    {  
        data=(char *)malloc(n+4);  
        memset(data,0,n+4);  
        data[0] = 0x81;  
        data[1] = 126;  
        data[2] = (n>>8 & 0xFF);  
        data[3] = (n & 0xFF);  
        memcpy(data+4,message,n);      
        *len=n+4;  
    }  
    else  
    {  

        // 暂不处理超长内容    
        *len=0;  
    }  


    return data;  
}  

void response(int connfd,const char * message)  
{  
    char * data;  
    unsigned long n=0;  
    int i;  
    if(!connfd)  
    {  
        return;  
    }  

    if(!message)  // data 改为 message
    {  
        return;  
    }  
    data=packData(message,&n);   

    if(!data||n<=0)  
    {  
        printf("data is empty!\n");  
        return;  
    }   

    write(connfd,data,n);  

}  
#endif
horsen_duan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring-web-5.3.6 jar包.rar
07-26
这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类， 包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。 spring的核心类，提供了核心HTTP...
网页文件上传
PCA_的博客
04-30 1410
文件上传，也称为upload,是指将本地图片、视频、音频等文件上传到服务器上，可以供其他用户浏览或下载的过程。 文件上传在项目中应用非常广泛，我们经常发微博、发微信朋友圈都用到了文件上传功能。 文件上传时，对页面的form表单有如下要求： ●method:="post" 采用post方式提交数据 enctype="multipart/form-data" 采用multipart格式上传文件 ● type="file" 使用inputi的file控件上传 + 举例： <form method="post
Asp.net 操作webclient上传文件无法上传的解决方案
技术至上
05-11 1523
因为项目中要使用ajax上传图片文件，又无法找到合适的jquery插件，只有自己动手写一个。思路如下：1.用js取得文件的完全路径2.ajax传到后台3.使用webclient的uploadfile上传文件。一切视乎没有问题了，但是实际开发中，本机测试没有任何问题，但是部署后却总是找不到上传的文件，调试代码后发现无法访问客户端路径的文件，无论是更改iis权限还是文件夹权限都无法改变
文件上传-SpringBoot实现
qq_34020761的博客
12-01 3095
应用开发过程中，文件上传是一个基础的扩展功能，它的目的就是让大家共享我们上传的文件资源。
Web上传大文件的三种解决方案
weixin_45525177的博客
02-14 678
HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工作正在进行之中，而且HTTP-NG(Next Generation of HTTP)的建议已经提出。(5)无状态：HTTP协议是无状态协议。前言：因自己负责的项目(jetty内嵌启动的SpringMvc)中需要实现文件上传，而自己对java文件上传这一块未接触过，且对 Http 协议较模糊，故这次采用渐进的方式来学习文件上传的原理与实践。
【JavaWeb】文件的上传
wang_qiu_hao的博客
10-11 5550
文件上传：将本地的文件通过流写入到服务器的过程。
Flask Web开发入门之文件上传（八）
01-20
本章我们介绍Flask Web开发中涉及的文件上传模块 定义后台接收处理逻辑 # http://flask.pocoo.org/docs/0.12/patterns/fileuploads/ @app.route('/upload', methods=['POST']) def upload_file(): if ...
longbill2.rar_WEB开发_PHP-PERL_
08-11
可以在线后台文件管理网站的文件及目录，功能强大！！更神奇的是，这么多功能的一个系统居然只由一个文件构成（包括图片）！！功能:1.上传2.新建3.在线升级4.超级安全的身份认证系统
PHP与Web页面交互 -文件上传和下载.ppt
06-05
* PHP与Web页面交互 -----文件上传和下载 课程内容 文件上传 文件下载 一、文件上传 文件上传从本质上讲，就是将表单数据的一部分提交到服务器端。只是因为其数据类型（字节流或二进制流）不一样，从而导致在服务器...
java web文件上传-下载-查看操作.docx
09-29
java web 文件操作是日常开发解决的问题，主要是针对解决文件的上传下载、查看操作。
使用Erlang和Yaws开发REST式的服务
04-15
使用Erlang和Yaws开发REST式的服务.详细分析如何使用Erlang和yaws开发REST的服务，有实例
Linux下通过cgi将HTML页面输入内容写入txt文件
07-23
文档内容为linux下通过cgi将html页面的输入内容写入到txt文本文件的小案例，可供初学者参考
Agent技术简介文档
08-29
（一） 背景知识 在开发Agent软件之前，需熟悉以下内容： （1） SNMP协议，MIB，ASN.1 SNMP子集，BER编码规则； （2） UDP协议，无连接Socket编程； （3） ATM UNI，AAL5； （4） VxWorks的多任务机制和消息队列机制，及两者的编程； （5） WRS WindNet软件包的使用和扩展； （6） Tornado系列开发和调试工具。
web开发文件上传
10-08
主要实现ajax上传文件图片的js文件，简单好用，跨域传可以自己修改js文件就可以
Java web开发——文件的上传和下载
随笔记
07-28 4013
打个广告，帮朋友卖点东西，东西超便宜的哟【衣服鞋子等】，厂家直接出货，绝对低于市场价！！！一般都比市场价便宜3—7折【都是牌子货】，如果您感兴趣，可以扫描屏幕下方的二维码，感谢关注！！！ 微信 一、文件上传 1、概述 实现web开发中的文件上传功能，需完成如下二步操作： 在web页面中添加上传输入项 在servlet中读取上传文件的数据，并保存到本地硬盘中。 2、在web...
linux大纲资料.txt
最新发布
04-23
linux
银行秒杀系统 第十三服创比赛项目.zip
04-23
银行秒杀系统 第十三服创比赛项目
单页登录源码 login登录页源码 html源码.zip
04-23
单页登录源码 login登录页源码 html源码
理性力学 陈至达.pdf
04-23
理性力学 陈至达.pdf
drawio web font -csdn
07-25
为了解决这个问题，drawio 开发了自己的字体，即 drawio Web Font。它是一套特定的字体文件，可以在 web 上加载和使用。通过使用 drawio Web Font，用户在协作编辑和展示图表时，不再受设备或操作系统字体限制的影响...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

horsen_duan

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值