整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线：

最新HTML BroadcastChannel AP

最新HTML BroadcastChannel API简介

TML BroadcastChannel API

当前浏览器中只有Firefox38唯一能支持BroadcastChannel API(在编写本文的时间点)，而Firefox38官方宣称要到2015年5月份才会发布正式版本。这套新的API将会打开一个新的充满可能性的世界，解决我们已有的从postMessage API所继承过来的众多限制。

BroadcastChannel API作为WHATWG living HTML标准的一部分可以在这里进行详细信息查看。

什么是 BroadcastChannel API?

BroadcastChannel API 允许同一原始域和用户代理下的所有窗口,iFrames等进行交互。也就是说，如果用户打开了同一个网站的的两个标签窗口，如果网站内容发生了变化，那么两个窗口会同时得到更新通知。

还是不明觉厉？就拿Facebook作为例子吧，假如你现在已经打开了Facebook的一个窗口，但是你此时还没有登录，此时你又打开另外一个窗口进行登录，那么你就可以通知其他窗口/标签页去告诉它们一个用户已经登录了并请求它们进行相应的页面更新。

本质上说BroadcastChannel API 允许我们在我们不使用sockets和timers的情况下同样可以打造出一个能够自我感知状态变化的应用，这对于一个发布/订阅形式的系统效果尤佳。

BroadcastChannel API 实战进行时

创建一个新的 BroadcastChannel

创建一个新的BroadcastChannel API 是一个易如反掌的事情。你需要做的仅仅是把通道名称作为一个参数传给BroadcastChannel的构造函数然后把它的引用保存到一个变量上面而已。

<code>let cast=new BroadcastChannel('mychannel');</code>

发送一个消息通知

发送一个消息也是一个非常简单的事情，你只需要引用赋有了BroadcastChannel实例的变量(在本示例中就是上面的cast变量)然后调用其postMessage方法就可以了。

如果你对其他基于发布/订阅的系统很熟悉的话，如果你把postMessage这个成员方法称呼成event emitter也许会更合情合理。

postMessage方法做的漂亮的地方是你可以用它来发送任何东西。你可以发送一个对象，一个字串，随你便。只要订阅者可以意识到你要发送的是什么事件就行了，好好享受吧。

<code>myObj={someKey: 'Some value', anotherKey: 'Another value'};
cast.postMessage(myObj);</code>

不像一些更加小鲜肉级别的发布/订阅系统，“主题“是没有原生的实现支持的。意思就是说你并没有一个通道可以把“主题“广播到所有监听的订阅者手上。

但是，通过编写一些创造性的代码你还是可以模仿这种实现的，你可以使用对象来把“主题“作为对象的一个键，把消息内容作为另外一个键”data”来进行发送。

消息监听

“接收者“更通俗的叫法也许应该叫做”订阅者”。一个接收者会对如我们前面为一个特别通道所定义的BroadcastChannel通道引用变量所发射的事件进行消息监听。

<code>cast.onmessage=<span>function (e) {</span> 
    console.log(e); // This should print out the contents of the object we sent above
}</code>

关闭连接

假定你非常在意Javascript的性能且很介意资源消耗情况(特别是在使用手机的情况下)。 幸运的是在BroadcastChannel里面拥有一个内嵌的方法来让你关闭这些连接。

<code>cast.close; // Close our connection and let the garbage collection free up the memory that was used</code>

浏览器支持

如前所述，当前只有Firefox版本38会支持BroadcastChannel API。假定其他浏览器将很有可能也会紧紧追随的话，毕竟，这套API是非常有用的。那么对我们编写这方面的普通应用和游戏应用，我们将会如鱼得水(紧密的浏览器支持的出现)

要注意的是，从一个使用者的角度来看的话你(当前)是基本上好不到相关的技术支持的。但，这里有个浏览器插件可以让你现在就使用上BroadcastChannel API，然而，毕竟现在还没有浏览器真正实现该功能的支持，我们只有翘首以待了。

作者：天地会珠海分舵

微信公众号：TechGoGoGo

开发分布式高并发系统时有三把利器用来保护系统：缓存、降级、限流

缓存

缓存的目的是提升系统访问速度和增大系统处理容量

降级

降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开

限流

限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理

问题描述

1、某天A君突然发现自己的接口请求量突然涨到之前的10倍，没多久该接口几乎不可使用，并引发连锁反应导致整个系统崩溃。如何应对这种情况呢？生活给了我们答案：比如老式电闸都安装了保险丝，一旦有人使用超大功率的设备，保险丝就会烧断以保护各个电器不被强电流给烧坏。同理我们的接口也需要安装上“保险丝”，以防止非预期的请求对系统压力过大而引起的系统瘫痪，当流量过大时，可以采取拒绝或者引流等机制。整编：微信公众号，搜云库技术团队，ID：souyunku

2、缓存的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；而降级是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。

3、系统在设计之初就会有一个预估容量，长时间超过系统能承受的TPS/QPS阈值，系统可能会被压垮，最终导致整个服务不够用。为了避免这种情况，我们就需要对接口请求进行限流。

4、限流的目的是通过对并发访问请求进行限速或者一个时间窗口内的的请求数量进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待。

5、一般开发高并发系统常见的限流模式有控制并发和控制速率，一个是限制并发的总数量（比如数据库连接池、线程池），一个是限制并发访问的速率（如nginx的limitconn模块，用来限制瞬时并发连接数），另外还可以限制单位时间窗口内的请求数量（如Guava的RateLimiter、nginx的limitreq模块，限制每秒的平均速率）。其他还有如限制远程接口调用速率、限制MQ的消费速率。另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。

相关概念：

PV:

page view 页面总访问量，每刷新一次记录一次。

UV:

unique view 客户端主机访问，指一天内相同IP的访问记为1次。

QPS:

query per second,即每秒访问量。qps很大程度上代表了系统的繁忙度，没次请求可能存在多次的磁盘io，网络请求，多个cpu时间片，一旦qps超过了预先设置的阀值，可以考量扩容增加服务器，避免访问量过大导致的宕机。整编：微信公众号，搜云库技术团队，ID：souyunku

RT:

response time,每次请求的响应时间,直接决定用户体验性。

本文主要介绍应用级限流方法，分布式限流、流量入口限流（接入层如NGINX limitconn和limitreq 模块）。

应用级限流

一、控制并发数量

属于一种较常见的限流手段，在实际应用中可以通过信号量机制（如Java中的Semaphore）来实现。操作系统的信号量是个很重要的概念，Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

举个例子，我们对外提供一个服务接口，允许最大并发数为10，代码实现如下：

public class DubboService {
    private final Semaphore permit=new Semaphore(10, true);
    public void process(){
        try{            permit.acquire();            //业务逻辑处理
        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            permit.release();        }    }}

在以上代码中，虽然有30个线程在执行，但是只允许10个并发的执行。Semaphore的构造方法Semaphore(int permits) 接受一个整型的数字，表示可用的许可证数量。Semaphore(10)表示允许10个线程获取许可证，也就是最大并发数是10。Semaphore的用法也很简单，首先线程使用Semaphore的acquire()获取一个许可证，使用完之后调用release()归还许可证，还可以用tryAcquire()方法尝试获取许可证，信号量的本质是控制某个资源可被同时访问的个数，在一定程度上可以控制某资源的访问频率，但不能精确控制，控制访问频率的模式见下文描述。

二、控制访问速率

在工程实践中，常见的是使用令牌桶算法来实现这种模式，常用的限流算法有两种：漏桶算法和令牌桶算法。

漏桶算法

漏桶算法思路很简单，水（请求）先进入到漏桶里，漏桶以一定的速度出水，当水流入速度过大会直接溢出，可以看出漏桶算法能强行限制数据的传输速率。

对于很多应用场景来说，除了要求能够限制数据的平均传输速率外，还要求允许某种程度的突发传输。这时候漏桶算法可能就不合适了，令牌桶算法更为适合。

令牌桶算法

如图所示，令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务，令牌桶算法通过发放令牌，根据令牌的rate频率做请求频率限制，容量限制等。整编：微信公众号，搜云库技术团队，ID：souyunku

在Wikipedia上，令牌桶算法是这么描述的：

1、每过1/r秒桶中增加一个令牌。

2、桶中最多存放b个令牌，如果桶满了，新放入的令牌会被丢弃。

3、当一个n字节的数据包到达时，消耗n个令牌，然后发送该数据包。

4、如果桶中可用令牌小于n，则该数据包将被缓存或丢弃。

令牌桶控制的是一个时间窗口内通过的数据量，在API层面我们常说的QPS、TPS，正好是一个时间窗口内的请求量或者事务量，只不过时间窗口限定在1s罢了。以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。令牌桶的另外一个好处是可以方便的改变速度，一旦需要提高速率，则按需提高放入桶中的令牌的速率。

在我们的工程实践中，通常使用Google开源工具包Guava提供的限流工具类RateLimiter来实现控制速率，该类基于令牌桶算法来完成限流，非常易于使用，而且非常高效。如我们不希望每秒的任务提交超过1个

public static void main(String[] args) {    String start=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());    RateLimiter limiter=RateLimiter.create(1.0); // 这里的1表示每秒允许处理的量为1个    for (int i=1; i <=10; i++) {        double waitTime=limiter.acquire(i); // 请求RateLimiter, 超过permits会被阻塞        System.out.println("cutTime=" + System.currentTimeMillis() + " call execute:" + i + " waitTime:" + waitTime);    }    String end=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());    System.out.println("start time:" + start);    System.out.println("end time:" + end);}

首先通过RateLimiter.create(1.0);创建一个限流器，参数代表每秒生成的令牌数，通过limiter.acquire(i);来以阻塞的方式获取令牌，令牌桶算法允许一定程度的突发（允许消费未来的令牌），所以可以一次性消费i个令牌；当然也可以通过tryAcquire(int permits, long timeout, TimeUnit unit)来设置等待超时时间的方式获取令牌，如果超timeout为0，则代表非阻塞，获取不到立即返回，支持阻塞或可超时的令牌消费。

从输出来看，RateLimiter支持预消费，比如在acquire(5)时，等待时间是4秒，是上一个获取令牌时预消费了3个两排，固需要等待3*1秒，然后又预消费了5个令牌，以此类推。

RateLimiter通过限制后面请求的等待时间，来支持一定程度的突发请求(预消费)，在使用过程中需要注意这一点，Guava有两种限流模式，一种为稳定模式(SmoothBursty:令牌生成速度恒定，平滑突发限流)，一种为渐进模式(SmoothWarmingUp:令牌生成速度缓慢提升直到维持在一个稳定值，平滑预热限流) 两种模式实现思路类似，主要区别在等待时间的计算上。

SmoothBursty 模式：

RateLimiter limiter=RateLimiter.create(5); RateLimiter.create(5)表示桶容量为5且每秒新增5个令牌，即每隔200毫秒新增一个令牌；limiter.acquire()表示消费一个令牌，如果当前桶中有足够令牌则成功（返回值为0），如果桶中没有令牌则暂停一段时间，比如发令牌间隔是200毫秒，则等待200毫秒后再去消费令牌，这种实现将突发请求速率平均为了固定请求速率。

SmoothWarmingUp模式：

RateLimiter limiter=RateLimiter.create(5,1000, TimeUnit.MILLISECONDS);

创建方式：

RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)，permitsPerSecond表示每秒新增的令牌数，warmupPeriod表示在从冷启动速率过渡到平均速率的时间间隔。速率是梯形上升速率的，也就是说冷启动时会以一个比较大的速率慢慢到平均速率；然后趋于平均速率（梯形下降到平均速率）。可以通过调节warmupPeriod参数实现一开始就是平滑固定速率。整编：微信公众号，搜云库技术团队，ID：souyunku

放在Controller中用Jemter压测

注：RateLimiter控制的是速率，Samephore控制的是并发量。RateLimiter的原理就是令牌桶，它主要由许可发出的速率来定义，如果没有额外的配置，许可证将按每秒许可证规定的固定速度分配，许可将被平滑地分发，若请求超过permitsPerSecond则RateLimiter按照每秒 1/permitsPerSecond 的速率释放许可。注意:RateLimiter适用于单体应用，且RateLimiter不保证公平性访问。

使用上述方式使用RateLimiter的方式不够优雅，自定义注解+AOP的方式实现(适用于单体应用)，详细见下面代码：

自定义注解：

import java.lang.annotation.*;
/** * 自定义注解可以不包含属性，成为一个标识注解 */@Inherited@Documented@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)public @interface RateLimitAspect {
}

自定义切面类

import com.google.common.util.concurrent.RateLimiter;import com.test.cn.springbootdemo.util.ResultUtil;import net.sf.json.JSONObject;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Component;
import javax.servlet.ServletOutputStream;import javax.servlet.http.HttpServletResponse;import java.io.IOException;
@Component@Scope@Aspectpublic class RateLimitAop {
    @Autowired    private HttpServletResponse response;
    private RateLimiter rateLimiter=RateLimiter.create(5.0); //比如说，我这里设置"并发数"为5
    @Pointcut("@annotation(com.test.cn.springbootdemo.aspect.RateLimitAspect)")    public void serviceLimit() {
    }
    @Around("serviceLimit()")    public Object around(ProceedingJoinPoint joinPoint) {        Boolean flag=rateLimiter.tryAcquire();        Object obj=null;        try {            if (flag) {                obj=joinPoint.proceed();            }else{                String result=JSONObject.fromObject(ResultUtil.success1(100, "failure")).toString();                output(response, result);            }        } catch (Throwable e) {            e.printStackTrace();        }        System.out.println("flag=" + flag + ",obj=" + obj);        return obj;    }
    public void output(HttpServletResponse response, String msg) throws IOException {        response.setContentType("application/json;charset=UTF-8");        ServletOutputStream outputStream=null;        try {            outputStream=response.getOutputStream();            outputStream.write(msg.getBytes("UTF-8"));        } catch (IOException e) {            e.printStackTrace();        } finally {            outputStream.flush();            outputStream.close();        }    }}

测试controller

import com.test.cn.springbootdemo.aspect.RateLimitAspect;import com.test.cn.springbootdemo.util.ResultUtil;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;
@Controllerpublic class TestController {
    @ResponseBody    @RateLimitAspect    @RequestMapping("/test")    public String test(){        return ResultUtil.success1(1001, "success").toString();    }

压测结果：

三、控制单位时间窗口内请求数

某些场景下，我们想限制某个接口或服务 每秒/每分钟/每天 的请求次数或调用次数。例如限制服务每秒的调用次数为50，实现如下：

private LoadingCache < Long, AtomicLong > counter=CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.SECONDS).build(new CacheLoader < Long, AtomicLong > () {@    Override    public AtomicLong load(Long seconds) throws Exception {        return new AtomicLong(0);    }});public static long permit=50;public ResponseEntity getData() throws ExecutionException {    //得到当前秒    long currentSeconds=System.currentTimeMillis() / 1000;    if (counter.get(currentSeconds).incrementAndGet() > permit) {        return ResponseEntity.builder().code(404).msg("访问速率过快").build();    }    //业务处理}

到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器，应用级限流方式只是单应用内的请求限流，不能进行全局限流。因此我们需要分布式限流和接入层限流来解决这个问题。

分布式限流

自定义注解+拦截器+Redis实现限流 (单体和分布式均适用，全局限流)

自定义注解：

@Inherited@Documented@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)public @interface AccessLimit {
    int limit() default 5;  
    int sec() default 5;}

拦截器：

public class AccessLimitInterceptor implements HandlerInterceptor {
    @Autowired    private RedisTemplate<String, Integer> redisTemplate;  //使用RedisTemplate操作redis
    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {        if (handler instanceof HandlerMethod) {            HandlerMethod handlerMethod=(HandlerMethod) handler;            Method method=handlerMethod.getMethod();            if (!method.isAnnotationPresent(AccessLimit.class)) {                return true;            }            AccessLimit accessLimit=method.getAnnotation(AccessLimit.class);            if (accessLimit==null) {                return true;            }            int limit=accessLimit.limit();            int sec=accessLimit.sec();            String key=IPUtil.getIpAddr(request) + request.getRequestURI();            Integer maxLimit=redisTemplate.opsForValue().get(key);            if (maxLimit==null) {                redisTemplate.opsForValue().set(key, 1, sec, TimeUnit.SECONDS);  //set时一定要加过期时间            } else if (maxLimit < limit) {                redisTemplate.opsForValue().set(key, maxLimit + 1, sec, TimeUnit.SECONDS);            } else {                output(response, "请求太频繁!");                return false;            }        }        return true;    }
    public void output(HttpServletResponse response, String msg) throws IOException {        response.setContentType("application/json;charset=UTF-8");        ServletOutputStream outputStream=null;        try {            outputStream=response.getOutputStream();            outputStream.write(msg.getBytes("UTF-8"));        } catch (IOException e) {            e.printStackTrace();        } finally {            outputStream.flush();            outputStream.close();        }    }
    @Override    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }
    @Override    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }}

controller:

@Controller@RequestMapping("/activity")public class AopController {    @ResponseBody    @RequestMapping("/seckill")    @AccessLimit(limit=4,sec=10)  //加上自定义注解即可    public String test (HttpServletRequest request,@RequestParam(value="username",required=false) String userName){        //TODO somethings……        return   "hello world !";    }}

配置文件：

/*springmvc的配置文件中加入自定义拦截器*/<mvc:interceptors>   <mvc:interceptor>      <mvc:mapping path="/**"/>      <bean class="com.pptv.activityapi.controller.pointsmall.AccessLimitInterceptor"/>   </mvc:interceptor></mvc:interceptors>

访问效果如下，10s内访问接口超过4次以上就过滤请求，原理和计数器算法类似：

接入层限流

主要介绍nginx 限流，采用漏桶算法。

限制原理:可一句话概括为：“根据客户端特征，限制其访问频率”，客户端特征主要指IP、UserAgent等。使用IP比UserAgent更可靠，因为IP无法造假，UserAgent可随意伪造。整编：微信公众号，搜云库技术团队，ID：souyunku

用limit_req模块来限制基于IP请求的访问频率：

http://nginx.org/en/docs/http/ngxhttplimitreqmodule.html

也可以用tengine中的增强版：

http://tengine.taobao.org/documentcn/httplimitreqcn.html

1、并发数和连接数控制的配置：

nginx http配置：    #请求数量控制，每秒20个    limit_req_zone $binary_remote_addr zone=one:10m rate=20r/s;    #并发限制30个    limit_conn_zone $binary_remote_addr zone=addr:10m;
    server块配置    limit_req zone=one burst=5;    limit_conn addr 30;

2、ngxhttplimitconnmodule 可以用来限制单个IP的连接数：

ngxhttplimitconnmodule模块可以按照定义的键限定每个键值的连接数。可以设定单一 IP 来源的连接数。

并不是所有的连接都会被模块计数；只有那些正在被处理的请求（这些请求的头信息已被完全读入）所在的连接才会被计数。

http {    limit_conn_zone $binary_remote_addr zone=addr:10m;    ...    server {        ...        location /download/ {            limit_conn addr 1;        }

TML实现文件夹的上传和下载，前端如何用HTML5实现分片上传GB级大文件，网页中实现文件上传下载的三种解决方案(推荐)，HTML5实现文件批量上传组件，JQUERY 实现文件夹上传(保留目录结构)，B/S大文件上传支持断点上传，WebService 大文件上传,断点续传分片，HTML+AJAX实现上传大文件问题，用HTML实现本地文件的上传，HTML5实现大文件上传，HTML5实现大文件分片上传思路，利用HTML5分片上传超大文件思路，

WEBUPLOADER 支持 超大上G,多附件上传，JS 大文件分割/分片上传，

百度WEBUPLOADER上传视频等大文件，WEBUPLOAD组件实现文件上传功能和下载功能，JS大文件切片上传，断点续传实现DEMO，前端上传大文件的解决方案，前端上传大文件处理（切片、断点续传），前端大文件上传优化方案——分片上传，vue大文件上传解决方案，vue大文件上传解决方案10G，vue大文件上传解决方案50G，vue大文件上传解决方案100G，html5如何实现大文件断点续传、秒传，

java如何实现大文件断点续传、秒传，SpringBoot如何实现大文件断点续传、秒传，SpringMVC如何实现大文件断点续传、秒传，SpringCloud如何实现大文件断点续传、秒传，

webuploader如何实现大文件断点续传、秒传，百度webuploader如何实现大文件断点续传、秒传，html5实现大文件断点续传、秒传，vue如何实现大文件断点续传、秒传，前端如何实现大文件断点续传、秒传，JavaScript如何实现大文件断点续传、秒传，

html5大文件断点续传、秒传解决方案，html5大文件断点续传、加密上传解决方案，html5大文件断点续传、加密存储解决方案，html5大文件断点续传分片解决方案，html5大文件断点续传分块解决方案，html5大文件断点续传分割解决方案，html5大文件断点续传切割解决方案，

后端我们公司项目组选的是JAVA，因为公司有自己的产品，所以直接使用就行了，针对客户需求这块是进行扩展。

客户这边实际上要传的文件单个大小就有50G左右，所以需要支持断点续传和分片上传，并且要支持多线程上传，能够充分利用带宽资源。

之前在网上找过相关的资料，论坛里面也有网友交流过，还加过很多QQ群和微信群，但是结果都不太令人满意。

技术选型的话用的是jquery，也是一个企业内网系统，用的是之前公司的框架，只是进行功能扩展

分片网上讨论的很多，基本上全部都是用的HTML5的API，这个方案也不是不能用，但是在IE下面就不行了，兼容性差了点，并且也不能进行扩展，不能进行二次开发，限制性非常大，我们技术同事提的要求是需要提供产品完整源代码，

网上的文章全部都没有提供文件夹上传和续传的代码，也没有提供数据库操作的代码，

另外这块我们是要求必须提供产品完整源代码，因为后面我们需要自已来维护，同时是要求能够自主可控的

研发部门的同事调研过百度的webuploader这个组件，发现他实际上就是对Flash和HTML5进行了一个封装，本质还是调的HTML5的API，之前在项目中也用过，尝试过，但是最终都不太满意，一个是兼容性非常差，说的是兼容IE，但是在IE用的是Flash，在很多用户的电脑上用不了，卡顿崩溃发生的太频繁，文件上传的数量一多比如几千个，前端页面就开始卡了，用户体验非常差。这些问题研发部的同事都向百度反应过，但是百度webuploader那边一直没人回，基本上没人管，领导说要求付费提供技术支持，那边也是没人回，联系不上他们任何人。

webuploader这边连个开发人员都联系不到，这个是怎么回事？

用户上传的文件比较大，有20G左右，直接用HTML传的话容易失败，服务器也容易出错，需要分片，分块，分割上传。也就是将一个大的文件分成若干个小文件块来上传，另外就是需要实现秒传功能和防重复功能，秒传就是用户如果上传过这个文件，那么直接在数据库中查找记录就行了，不用再上传一次，节省时间，实现的思路是对文件做MD5计算，将MD5值保存到数据库，算法可以用MD5，或者CRC，或者SHA1，这个随便哪个算法都行。

切片的话还有一点就是在服务器上合并，一个文件的所有分片数据上传完后需要在服务器端进行合并操作。

视频教程：https://www.ixigua.com/7227314770696012322

导入项目：
导入到Eclipse：http://www.ncmem.com/doc/view.aspx?id=9da9c7c2b91b40b7b09768eeb282e647
导入到IDEA：http://www.ncmem.com/doc/view.aspx?id=9fee385dfc0742448b56679420f22162
springboot统一配置：http://www.ncmem.com/doc/view.aspx?id=7768eec9284b48e3abe08f032f554ea2

下载示例：

https://gitee.com/xproer/up6-jsp-eclipse/tree/6.5.40/

工程

NOSQL

NOSQL示例不需要任何配置，可以直接访问测试

创建数据表

选择对应的数据表脚本，这里以SQL为例

修改数据库连接信息

访问页面进行测试

文件存储路径

up6/upload/年/月/日/guid/filename

相关问题：
1.javax.servlet.http.HttpServlet错误
2.项目无法发布到tomcat
3.md5计算完毕后卡住
4.服务器找不到config.json文件

相关参考：

文件保存位置

源码工程文档：https://drive.weixin.qq.com/s?k=ACoAYgezAAw1dWofra

源码报价单：https://drive.weixin.qq.com/s?k=ACoAYgezAAwoiul8gl

OEM版报价单：https://drive.weixin.qq.com/s?k=ACoAYgezAAwuzp4W0a

产品源代码：https://drive.weixin.qq.com/s?k=ACoAYgezAAwbdKCskc
授权生成器：https://drive.weixin.qq.com/s?k=ACoAYgezAAwTIcFph1


在线咨询
上一篇：CSS文本属性，让你的段落更加美观，前端之路更进一步
下一篇：贵州紫云：《中小学德育学堂》进校园 利用互联网+夯实

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

推荐阅读
友情链接 石家庄看香高人 岑巩县 通许县 子长县 兴宁市 奇台县 都匀市 网站制作
Copyright © 2002-2019 雨点网络设计有限公司 版权所有   冀ICP备11025394号
联系电话：   E-mail：279303980@qq.com   www.hmttv.cn
主营业务：技术文章网站建设、网站定制、技术文章营销型网站建设、技术文章网站优化、技术文章微商城制作、三级分销系统开发
电话沟通
在线客服