精华内容
下载资源
问答
  • JAVA 操作防抖(非RxJava方案)

    千次阅读 2018-07-14 11:02:26
    JAVA 操作防抖,在手机网络状态变化时发生了重复调用,因此需要进行防抖。本打算用RxJava方案的,发现没必要那么麻烦,就找了个现成的类修改了下,发现确实还比较好用,代码如下。package com.xxx.xxx; import java...
    JAVA 操作防抖,在手机网络状态变化时发生了重复调用,因此需要进行防抖。
    本打算用RxJava方案的,发现没必要那么麻烦,就找了个现成的类修改了下,发现确实还比较好用,代码如下。
    package com.xxx.xxx;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 操作防抖
     * @param <T> 参数类型
     */
    public class Debouncer<T> {
        private final ScheduledExecutorService sched = Executors.newScheduledThreadPool(1);
        private final ConcurrentHashMap<T, TimerTask> delayedMap = new ConcurrentHashMap<T, TimerTask>();
        private final Callback<T> callback;
        private final int interval;
    
        public interface Callback<T> {
            void call(T param);
        }
    
        public Debouncer(Callback<T> c, int interval) {
            this.callback = c;
            this.interval = interval;
        }
    
        public void call(T param) {
            TimerTask task = new TimerTask(param);
    
            TimerTask prev;
            do {
                prev = delayedMap.putIfAbsent(param, task);
                if (prev == null)
                    sched.schedule(task, interval, TimeUnit.MILLISECONDS);
            }
            while (prev != null && !prev.extend()); // Exit only if new task was added to map, or existing task was extended successfully
        }
    
        public void terminate() {
            sched.shutdownNow();
        }
    
        // The task that wakes up when the wait time elapses
        private class TimerTask implements Runnable {
            private final T param;
            private long dueTime;
            private final Object lock = new Object();
    
            public TimerTask(T param) {
                this.param = param;
                extend();
            }
    
            public boolean extend() {
                synchronized (lock) {
                    if (dueTime < 0) // Task has been shutdown
                        return false;
                    dueTime = System.currentTimeMillis() + interval;
                    return true;
                }
            }
    
            public void run() {
                synchronized (lock) {
                    long remaining = dueTime - System.currentTimeMillis();
                    if (remaining > 0) { // Re-schedule task
                        sched.schedule(this, remaining, TimeUnit.MILLISECONDS);
                    } else { // Mark as terminated and invoke callback
                        dueTime = -1;
                        try {
                            callback.call(param);
                        } finally {
                            delayedMap.remove(param);
                        }
                    }
                }
            }
        }
    }


    调用:

        private Debouncer<String> debouncer = new Debouncer(new Debouncer.Callback<String>(){
            @Override
            public void call(String param) {
                System.out.println("call with param:" + param);
            }
        }, 500);
    
    debouncer.call("参数A");

    展开全文
  • java script 防抖和节流

    2021-07-01 17:55:04
    防抖:就是一定时间内,只会执行最后一次任务。 节流:就是一定时间内,只执行一次。 防抖 防抖函数的封装使用 节流 节流函数的封装使用 防抖 <button id="debounce">点我防抖!</button>...

    文章目录

    概念

             防抖:就是一定时间内,只会执行最后一次任务。

             节流:就是一定时间内,只执行一次。

    防抖

             防抖函数的封装使用

    节流

             节流函数的封装使用

    防抖

    <button id="debounce">点我防抖!</button>
    
    $('#debounce').on('click', debounce());
    
    function debounce() {
        let timer;
        // 闭包
        return function () {
            clearTimeout(timer);
            timer = setTimeout(() => {
                // 需要防抖的操作...
                console.log("防抖成功!");
            }, 500);
        }
    }
    

    函数防抖的应用场景,最常见的就是页面滚动条监听的例子,来进行解析:

    let timer;
    window.onscroll = function () {
        clearTimeout(timer);
        timer = setTimeout(function () {
            //滚动条位置
            let scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
            console.log('滚动条位置:' + scrollTop);
        }, 200)
    }
    

    防抖函数的封装使用

    /**
     * 防抖函数
     * @param fn 事件触发的操作
     * @param delay 多少毫秒内连续触发事件,不会执行
     * @returns {Function}
     */
    function debounce(fn,delay) {
        let timer = null;
        return function () {
            let self = this,
                args = arguments;
            timer && clearTimeout(timer);
            timer = setTimeout(function () {
                fn.apply(self,args);
            },delay);
        }
    }
    
    window.onscroll = debounce(function () {
        let scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
        console.log('滚动条位置:' + scrollTop);
    },200)
    

    节流

    <button id="throttle">点我节流!</button>
    
    $('#throttle').on('click', throttle());
    
    function throttle(fn) {
        let flag = true;
        // 闭包
        return function () {
            if (!flag) {
                return;
            }
            flag = false;
            setTimeout(() => {
                console.log("节流成功!");
                flag = true;
            }, 1000);
        };
    }
    

    函数节流应用的实际场景,根据文本框中输入的内容自动请求后台数据

    节流函数的封装使用

    <input type="text" value="" id="input">
    
    $('#input').on('keyup', throttle(function () {
        console.log($(this).val());
        // ajax后台请求....
    }, 1000));
    
    /**
     * 节流函数
     * @param fn 事件触发的操作
     * @param delay 间隔多少毫秒需要触发一次事件
     */
    function throttle(fn, delay) {
        let flag = true;
        return function () {
            let self = this,
                args = arguments;
            if (!flag) {
                return;
            }
            flag = false;
            setTimeout(() => {
                fn.apply(self, args);
                flag = true;
            }, delay);
        }
    }
    

    展开全文
  • JAVA中如何实现Debounce去抖,防止频繁调用 1. 概述 在JS中有很好的Debounce库,可以用来去抖,防止一个接口在短时间内频繁调用,可以抑制住相关的调用。 最近翻阅了下JAVA相关资料,但是没找到一个简单的可以...

    在JAVA中如何实现Debounce去抖,防止频繁调用


    1. 概述

    在JS中有很好的Debounce库,可以用来去抖,防止一个接口在短时间内频繁调用,可以抑制住相关的调用。

    最近翻阅了下JAVA相关资料,但是没找到一个简单的可以用于去抖的类。为此,我专门封装了一个简单的去抖实用类,可以轻松地实现Debounce相关的功能SimpleDebounceCallable类。

    http://www.easysb.cn/2019/04/310.html
    

    2. SimpleDebounceCallable使用

    为解决此问题,我专门封装了SimpleDebounceCallable类,具体可以参考第三节实现部门。其使用方法有两种,下面分别介绍下。

    2.1 自动debounce抑制

    自动监测是否处于抑制状态,如果不是就会调用函数。

    // 定义成员表变量或者静态变量, 设置抑制时间 5秒
    private final SimpleDebounceCallable<Integer> debounce = new SimpleDebounceCallable<>(1000 * 5);
    .....
    
    String key = "hello-call"
    Optional<Integer> ret = debounce.debounce(() -> {
      int c = 0;
      (处理代码)....
      
      return c;
    }, key);
    

    如果只提供给唯一的地方调用,那么我就不需要用key来区分,可以直接用默认的key即可,如下:

    // 定义成员表变量或者静态变量, 设置抑制时间 5秒
    private final SimpleDebounceCallable<Integer> debounce = new SimpleDebounceCallable<>(1000 * 5);
    .....
    
    // 此时不需要key,直接用默认的即可
    Optional<Integer> ret = debounce.debounce(() -> {
      int c = 0;
      (处理代码)....
      
      return c;
    });
    

    2.2 主动debounce抑制

    主动监测是否处于抑制状态,然后觉得是否去调用函数。

    // 定义成员表变量或者静态变量, 设置抑制时间 5秒
    private final SimpleDebounceCallable<Integer> debounce = new SimpleDebounceCallable<>(1000 * 5); 
    
    ...
    
    String key = "hello-call"
    if (debounce.tick(key) > 0) {
        Optional<Integer> ret = debounce.debounce(() -> {
          int c = 0;
          (处理代码)....
    
          return c;
        });
    }
    

    如果只提供给唯一的地方调用,那么我就不需要用key来区分,可以直接用默认的key即可,如下:

    // 定义成员表变量或者静态变量, 设置抑制时间 5秒
    private final SimpleDebounceCallable<Integer> debounce = new SimpleDebounceCallable<>(1000 * 5);
    ...
    
    // 此时不需要key,直接用默认即可
    if (debounce.tick() > 0) {
        Optional<Integer> ret = debounce.debounce(() -> {
          int c = 0;
          (处理代码)....
    
          return c;
        });
    }
    

    3. SimpleDebounceCallable实现

    接口Ticking的定义如下:

    // http://www.easysb.cn/2019/04/310.html
    
    public interface Ticking {
        int tick();
    }
    

    SimpleDebounceCallable的具体实现如下:

    // http://www.easysb.cn/2019/04/310.html
    
    @Slf4j
    public class SimpleDebounceCallable<T> implements Ticking {
        final private static String DEFAULT_KEY = "__default";
        final private static String REMOVE_TIMEOUT_KEY = "__clear_time_out";
        // default timeout is 10 minutes
        final private static long DEFAULT_TIMEOUT = DateTimeUtils.MS_PER_MINUTE * 10;
    
        final private Map<String, Long> lastTickTimeMap = Maps.newConcurrentMap();
    
        @Setter
        @Getter
        private long timeout = 0;
    
    
        public SimpleDebounceCallable() {
            this(DEFAULT_TIMEOUT);
        }
    
        public SimpleDebounceCallable(long timeout) {
            this.timeout = timeout;
        }
    
        @Override
        public int tick() {
            return replaceIfTimeout(DEFAULT_KEY) ? 1 : 0;
        }
    
        public int tick(String key) {
            return replaceIfTimeout(key) ? 1 : 0;
        }
    
        private boolean replaceIfTimeout(String key) {
            boolean replace = false;
            synchronized (lastTickTimeMap) {
                if (isExpiredValue(lastTickTimeMap.get(key))) {
                    lastTickTimeMap.put(key, System.currentTimeMillis());
                    replace = true;
                }
            }
            return replace;
        }
    
        private boolean isExpiredValue(Long val) {
            return val == null || Math.abs(System.currentTimeMillis() - val.longValue()) >= timeout;
        }
    
        private void removeTimeoutItems() {
            if (MapUtils.isEmpty(lastTickTimeMap)) {
                return;
            }
            synchronized (lastTickTimeMap) {
                Iterator<Map.Entry<String, Long>> iterator = lastTickTimeMap.entrySet().iterator();
                while (iterator.hasNext()) {
                    if (isExpiredValue(iterator.next().getValue())) {
                        iterator.remove();
                    }
                }
            }
        }
    
        /**
         * debounce to execute specified lambda function
         *
         * @param callable lambda function to be call if available
         * @return Optional<T>
         */
        public Optional<T> debounce(Callable<T> callable) {
            try {
                if (replaceIfTimeout(REMOVE_TIMEOUT_KEY)) {
                    removeTimeoutItems();
                }
                return Optional.ofNullable(callable.call());
            } catch (Exception e) {
                log.error("debounce", e);
            }
            return Optional.empty();
        }
    
        public Optional<T> debounce(Callable<T> callable, String key) {
            return replaceIfTimeout(key) ? debounce(callable) : Optional.empty();
        }
    }
    
    
    展开全文
  • 防抖和节流

    2019-07-31 22:11:53
    1、防抖:就是规定在一段时间内,事件只执行一次,如果在规定的时间里面,再次触发该事件,那么将会重新计时 2、例子:老师告诉学生们,如果在一个星期内不会上课睡觉,就奖励一颗棒棒糖,如果在这段时间内,有人...

    1、防抖:就是规定在一段时间内,事件只执行一次,如果在规定的时间里面,再次触发该事件,那么将会重新计时
    2、例子:老师告诉学生们,如果在一个星期内不会上课睡觉,就奖励一颗棒棒糖,如果在这段时间内,有人违规了,那么就从这一刻开始重新计时,过一个星期就可以领到棒棒糖了
    3、代码示例如下:
    function  debounce(fn,wait) {
        let timer = null
        return function() {
            clearTimeout(timer)  //如果在规定事件再被触发,就会清空,然后重新计时
            timer = setTimeout(() => {
                fn.apply(this,arguments)
            },wait)
        }
    }

    function  test() {
        console.log("hello")
    }

    let  testid = document.getElementById("test")

    //给点击元素绑定事件

    window.addEventListener('click',debounce(test,1000))


    1、节流:规定在一段时间内执行一次
    2、例子:老师告诉学生们,一周内在课堂上只允许放一次影片观看,如果在这一周内观看了一次影片,那么接下来学生观看电影的请求,老师都不会答应的

    3、代码示例如下
    function throttle(fn,wait) {
        let ishas = true   //定义一个标志,在这段时间是否被允许
          return function () {
          if (ishas){
            ishas = false  //一旦事件被执行,立刻赋值为false,这个变量是一个闭包,所以在这段时间内一旦有一个事件被执行,就永远显示为false,防止这段时间内被执行多次事件
            setTimeout( () => {
                fn.apply(this,arguments)
                ishas = true  //事件执行完毕,重新赋值为true
            },wait)
        }else{
            return
        }
          }
    }

    function  test() {
        console.log("hello")
    }

    let  testid = document.getElementById("test")

    //给点击元素绑定事件

    window.addEventListener('click',throttle(test,2000))

    展开全文
  • 下载;npm ilodash 引入: import{debounce}from'lodash' 使用: debounce (async function(){ //需要做防抖的代码写这 },200),
  • java使用自定义注解+AOP解决服务端防止前端快速点击,导致多次访问接口,造成数据冗余或者错误 项目描述: 项目中,可能会碰到前端快速点击按钮,导致多次访问同意接口,导致产生错误数据,所以建议采用自定义注解+...
  • 节流、防抖

    2020-11-07 21:27:59
    节流、防抖 节流和防抖的理解 节流:当一个事件持续触发时,我们期望降低事件触发的频率,事件处理函数还是会触发多次。比如在移动端手机浏览器对onscroll事件不能实时触发,就是在内部做了节流处理。 防抖:当一个...
  • java swing 防抖机制

    2019-10-03 00:20:44
    我们产品的 操作台(workbench) 是一个java swing程序.有一个event handler的代码如下: public void actionPerformed(ActionEvent e) { // 做耗时的工作, 如插入数据库 } 现在的一个问题在于, 如果用户连续...
  • java编写的窗体抖动

    2012-08-27 17:53:18
    java语言编写模仿QQ中的窗体抖动,代码精简巧妙
  • 搞清楚节流和防抖

    2019-05-05 08:08:57
    节流(throttle)和防抖(debounce)是前端面试中非常高频的一道面试题,在实际项目开发中,也有很多实用场景,最后一次梳理这两个概念。 节流 规定在一个单位时间内,只能触发一次函数,如果这个单位时间内触发多次...
  • java之awt防抖

    2016-03-30 19:52:28
    public void update(Graphics g){ //...尽管现在已经很少人使用AWT,用swing或者其他框架,偶尔写点小游戏还是需要的,哈哈,java还是没有c#那样擅长桌面程序。 将上述方法放在主类内即可。所谓的双缓冲!!!!!
  • 1、Redis 是什么?都有哪些使用场景? Redis 是一个使用 C 语言开发的高速缓存数据库。 Redis 使用场景: ... 缓存近期热帖;...Redis 不依赖 CPU,其瓶颈最有可能是机器内存或者网络带宽,并不是说多线程就一定比单线程...
  • 防抖函数 debounce 指的是某个函数在某段时间内,无论触发了多少次回调,都只执行最后一次。假如我们设置了一个等待时间 3 秒的函数,在这 3 秒内如果遇到函数调用请求就重新计时 3 秒,直至新的 3 秒内没有函数调用...
  • Android RxJava应用:功能防抖

    千次阅读 2017-12-20 09:42:54
    前言 Rxjava,由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点,深受各大 Android开发者的欢迎。 如果还不了解RxJava,请看文章...今天,我将为大家带来 Rxjava创建操作符的常见开发应用场景:功能防抖需求 ,
  • javaScript——函数防抖

    2021-01-03 18:21:00
    函数防抖什么是函数防抖函数防抖代码 什么是函数防抖 函数防抖代码 //普通写法 var timer = null; var timerFunc = ()=>{ console.log(移动时间:+new Date().getTime()); } function moveFunc(){ if(null != ...
  • 防抖和节流 实现代码

    2020-04-13 10:28:29
    防抖(debounce) 所谓防抖,就是指触发事件后在 n 秒内函数只能执行一次,如果在 n 秒内又触发了事件,则会重新计算函数执行时间。(通俗的讲就是在触发点击事件后,如果用户再次点击了,我们会清空之前的定时器,...
  • js/JavaScript防抖处理

    2020-09-19 18:30:22
    为什么要js做防抖处理:当表单提交时,如果用户点击了好多次,后台很容易提交多次数据;搜索不做防抖,将请求多次数据;监听输入框输入时,如果监听值变化就请求数据的话,也会...
  • # Import numpy and OpenCV import numpy as np import cv2 def fixBorder(frame): s = frame.shape # Scale the image 4% without moving the center T = cv2.getRotationMatrix2D((s[1] / 2, s[0] / 2), 0, ...
  • 防抖功能

    2014-11-07 12:32:36
    最早推出防抖概念的是日本尼康公司,在1994年推出了具有减震(VR)技术的袖珍相机。次年,日本佳能公司推出世界上第一支带有图像稳定器的镜头EOS 75~300mm f/4~5.6 IS,其中IS是影像稳定系统(Image ...
  • 防抖节流

    2021-01-25 19:03:52
    防抖和节流是在很多都会见到的东西 特别是在登录注册等等请求服务器的场景下。 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content=...
  • 防抖和节流 1.什么是防抖 防抖:顾明思议,一次只有单一的请求,我们举个例子,例如:喜欢打王者荣耀的朋友都知道,我打王者荣耀好家伙没血了,我要回城,这个时候我点击一次,就开始我的进度条回城,但是中途万一不...
  • /** * @description: * @param {*} fn * @param {*} time * @param {*} type 1表示立即执行,其他表示非立即执行 * @return {*} */ function fangdou(fn, time, type){ if(type == 1...
  • 节流与防抖

    2021-08-10 11:41:31
    节流-throttle 节流的意思是,规定时间内,只触发一次。比如我们设定500ms,在这个时间内,无论... 防抖-debounce 防抖的意思是,在连续的操作中,无论进行了多长时间,只有某一次的操作后在指定的时间内没有再操...
  • 图像视频防抖

    万次阅读 2015-11-18 15:52:07
    视频防抖 该项技术关键字挺多的,但作用都是去除视频拍摄过程中轻微抖动造成的图像模糊。 Anti-Shake,Shake-proof, imagestabilization都是这个意思,image stabilization是由canon最先开始这么称呼的,Anti-shake...
  • 面试的时候我们经常会问别人是理解什么是节流和防抖,严格的可能要求你写出节流和防抖函数,这里我们抛开loadsh工具库手写节流和防抖 1.节流函数throttle // 节流方案1,每delay的时间执行一次,通过开关控制 ...
  • 1. Kotlin 扩展函数实现防抖(Kotlin) 1.1创建ViewExtension.kt文件: fun <T : View> T.withTrigger(delay: Long = 800): T { triggerDelay = delay return this } /*** * 点击事件的View扩展 * @param ...
  • 防抖与节流 3.1 防抖:一定时间内,频繁触发事件,只执行最后一次(在规定时间内每次触发都要重新计时) 案例: <!DOCTYPE ...
  • 事件循环防抖

    2021-01-09 03:20:40
    //简单版 function debounce(fn) { let isExecuted = false; return function () { if (!isExecuted) { isExecuted = true; new Promise((resolve, reject) => { fn(); reso...
  • 彩色图像处理包括图像的一系列处理 滤波 防抖 灰度等
  • 前端防抖与节流

    2021-06-22 01:20:33
    前端工作中免不了会用到防抖和节流,但是之前总容易搞混防抖和节流的定义,所以今天就来梳理一下防抖和节流的区别,以及如何使用的,什么时候应该用防抖,什么时候应该用节流。问题描述什么是前端防抖和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,936
精华内容 774
关键字:

java防抖

java 订阅