精华内容
下载资源
问答
  • 下面小编就为大家分享一篇Android 快速实现防止网络重复请求&按钮重复点击的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇在vue中使用防抖和节流,防止重复点击或重复上拉加载实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 本篇文章主要介绍了Android 防止多次重复点击的三种方法的示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 下面小编就为大家带来一篇Android之有效防止按钮多次重复点击的方法(必看篇)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1.直接添加工程中即可使用. 2.在需要使用的地方 引入头文件即可. 3.在持续更新中,因为按钮重复点击可能会引起其他操作bug,如拍照按钮无法点击之类的问题, 目前只能发先一个解决一个.
  • 电脑鼠标动作重复点击能够帮助你自动重复点击鼠标,适用于挂课等
  • Android防快速重复点击

    2018-09-26 16:55:18
    Android防快速重复点击,防止多次重复点击导致多个相同的界面
  • 限制button在三秒内不可重复点击(三秒可自定义),防止用户重复点击导致软件崩溃或其他情况的出现。
  • 判断重复点击JS

    2014-04-25 18:16:53
    判断2秒内重复点击JS
  • 优雅的处理重复点击;转载的文章对应的代码。
  • 防止NET按钮重复点击方法 自己写的 很适用
  • Android处理按钮重复点击事件

    千次阅读 2019-04-23 18:13:21
    如果不处理按钮重复点击,就会造成一系列的问题,因此,防止按钮多次点击,是Android开发中一个很重要的技术手段。 处理方案 方案一:每个按钮点击事件中,记录点击时间,判断是否超过点击时间间隔 private long...

    前言

    在Android APP中,按钮的点击随处可见,比如:页面跳转,请求服务器等等!如果不处理按钮重复点击,就会造成一系列的问题,因此,防止按钮多次点击,是Android开发中一个很重要的技术手段。

    处理方案

    方案一:每个按钮点击事件中,记录点击时间,判断是否超过点击时间间隔

    private long mLastClickTime = 0;
    public static final long TIME_INTERVAL = 1000L;
    private Button btTest;
    private void initView() {
        btTest = findViewById(R.id.bt_test);
        btTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                long nowTime = System.currentTimeMillis();
                if (nowTime - mLastClickTime > TIME_INTERVAL) {
                    // do something
                    mLastClickTime = nowTime;
                } else {
                    Toast.makeText(MainActivity.this, "不要重复点击", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    此方法虽然可以解决按钮的重复点击问题,但是会导致重复代码太多。

    方案二:在方案一的基础上进行封装,以接口回调的方式处理点击事件

    方案三:使用Rxjava处理重复点击

    public class RxView {
        public static int intervalTime;
    
        /**
         * 设置点击间隔时间
         *
         * @param intervalTime
         * @return
         */
        public static void setIntervalTime(int intervalTime) {
            RxView.intervalTime = intervalTime;
        }
    
        /**
         * 防止重复点击
         *
         * @param target 目标view
         * @param action 监听器
         */
        public static void setOnClickListeners(final OnRxViewClickListener<View> action, @NonNull View... target) {
            for (View view : target) {
                RxView.onClick(view).throttleFirst(intervalTime == 0 ? 1000 : intervalTime, TimeUnit.MILLISECONDS).subscribe(new Consumer<View>() {
                    @Override
                    public void accept(@io.reactivex.annotations.NonNull View view) throws Exception {
                        action.onRxViewClick(view);
                    }
                });
            }
        }
    
        /**
         * 监听onclick事件防抖动
         *
         * @param view
         * @return
         */
        @SuppressLint("RestrictedApi")
        @CheckResult
        @NonNull
        private static Observable<View> onClick(@NonNull View view) {
            checkNotNull(view, "view == null");
            return Observable.create(new ViewClickOnSubscribe(view));
        }
    
        /**
         * onclick事件防抖动
         * 返回view
         */
        private static class ViewClickOnSubscribe implements ObservableOnSubscribe<View> {
            private View view;
    
            public ViewClickOnSubscribe(View view) {
                this.view = view;
            }
    
            @Override
            public void subscribe(@io.reactivex.annotations.NonNull final ObservableEmitter<View> e) throws Exception {
                checkUiThread();
    
                View.OnClickListener listener = new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (!e.isDisposed()) {
                            e.onNext(view);
                        }
                    }
                };
                view.setOnClickListener(listener);
            }
        }
    
        /**
         * A one-argument action. 点击事件转发接口
         *
         * @param <T> the first argument type
         */
        public interface OnRxViewClickListener<T> {
            /**
             * 点击事件
             *
             * @param view
             */
            void onRxViewClick(View view);
        }
    }
    
    public class Preconditions {
        public static void checkArgument(boolean assertion, String message) {
            if (!assertion) {
                throw new IllegalArgumentException(message);
            }
        }
    
        public static <T> T checkNotNull(T value, String message) {
            if (value == null) {
                throw new NullPointerException(message);
            }
            return value;
        }
    
        public static void checkUiThread() {
            if (Looper.getMainLooper() != Looper.myLooper()) {
                throw new IllegalStateException(
                        "Must be called from the main thread. Was: " + Thread.currentThread());
            }
        }
    
        private Preconditions() {
            throw new AssertionError("No instances.");
        }
    }

    使用方法:

    1、在需要加点击事件的类中实现RxView.OnRxViewClickListener接口

    2、设置点击时间和添加点击事件

    RxView.setIntervalTime(2000);
    RxView.setOnClickListeners(this, rx_view);

    3、事件处理在接口的实现方法中进行处理即可

    @Override
    public void onRxViewClick(View view) {
        switch (view.getId()) {
            case R.id.rx_view:
                LogUtil.e("点击了");
                break;
            default:
                break;
        }
    }

    此方案响应式地处理按钮点击,利用rxjava的操作符,来防止重复点击,相较于方案一、方案二来说,此方法更为优雅一些。

    思考:以上三种方案,无论哪一种,都对原有点击事件有很大的侵入性,要么你需要往Click事件中加方法,要么你需要替换整个Click事件,那么,有没有一种方式,可以在不改动原有逻辑的情况下,又能很好地处理按钮的重复点击呢?这就是我们的方案四。

    方案四:更为优雅的处理方式-----AOP切面编程

    一、如何使用AOP来解决重复点击问题?

    1.引入Aspectj

    Android 上使用AOP编程,一般使用Aspectj这个库,站在巨人的肩膀上,沪江已经开源了Aspectj的Gradle插件,方便我们使用Aspectj。

    • 在项目根目录下的build.gradle中,添加依赖
    dependencies {
       
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0'
    
      
    }
    • 在app或其他module目录下的build.gradle中,添加以下代码:
    apply plugin: 'android-aspectjx'
    
    dependencies {
      implementation 'org.aspectj:aspectjrt:1.8.13'
    }

    注意:如果aspectjx是在module或者library中引入依赖,则在app的build.gradle也需要添加依赖,要不就在使用module或者library中的aop注解就无法生效。(具体原因还未发现)

    2、添加一个自定义注解

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public  @interface AopOnclick {
        /**
         * 点击间隔时间
         */
        long value() default 1000;
    }

    3、封装一个重复点击判断工具类

    public class AopClickUtil {
        /**
         * 最近一次点击的时间
         */
        private static long mLastClickTime;
        /**
         * 最近一次点击的控件ID
         */
        private static int mLastClickViewId;
    
        /**
         * 是否是快速点击
         *
         * @param v  点击的控件
         * @param intervalMillis  时间间期(毫秒)
         * @return  true:是,false:不是
         */
        public static boolean isFastDoubleClick(View v, long intervalMillis) {
            int viewId = v.getId();
    //        long time = System.currentTimeMillis();
            long time = SystemClock.elapsedRealtime();
            long timeInterval = Math.abs(time - mLastClickTime);
            if (timeInterval < intervalMillis && viewId == mLastClickViewId) {
                return true;
            } else {
                mLastClickTime = time;
                mLastClickViewId = viewId;
                return false;
            }
        }
    }

    4、编写Aspect AOP处理类

    @Aspect
    public class AopClickAspect {
    
        /**
         * 定义切点,标记切点为所有被@AopOnclick注解的方法
         * 注意:这里com.freak.aop.AopOnclick需要替换成
         * 你自己项目中AopOnclick这个类的全路径
         */
        @Pointcut("execution(@com.freak.httpmanage.aop.AopOnclick * *(..))")
        public void methodAnnotated() {}
    
        /**
         * 定义一个切面方法,包裹切点方法
         */
        @Around("methodAnnotated()")
        public void aroundJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
            // 取出方法的参数
            View view = null;
            for (Object arg : joinPoint.getArgs()) {
                if (arg instanceof View) {
                    view = (View) arg;
                    break;
                }
            }
            if (view == null) {
                return;
            }
            // 取出方法的注解
            MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
            Method method = methodSignature.getMethod();
            if (!method.isAnnotationPresent(AopOnclick.class)) {
                return;
            }
           AopOnclick aopOnclick = method.getAnnotation(AopOnclick.class);
            // 判断是否快速点击
            if (!AopClickUtil.isFastDoubleClick(view, aopOnclick.value())) {
                // 不是快速点击,执行原方法
                joinPoint.proceed();
            }
        }
    }

    二、使用方法

    只需要在点击事件的方法上面加入@AopOnclick注解,则就可以处理点击事件重复的问题,代码如下:

    @AopOnclick(5000)
    public void aop(View view) {
        LogUtil.e("点击了");
    }

     

    aop.setOnClickListener(new View.OnClickListener() {
        @AopOnclick
        @Override
        public void onClick(View v) {
            Log.e(TAG, "点击了");
        }
    });

    @AopOnclick注解后面加入值,代表的是设置点击的间隔时间,默认是1000毫秒。

    总结:以上四种方案,对比之后,方案四是最为简单粗暴,一个注解就解决了问题。当然,处理方法的选择也就看个人的需求了。

    参考文章:

    https://github.com/sososeen09/android-blog-demos/tree/master/aop-tech

    https://www.jianshu.com/p/c66f4e3113b3

    展开全文
  • 在项目中,由于网络问题,不知道这个按钮被点击了几次,为了防止这一问题发生,下面小编写了一段实例代码给大家详解android解决按钮重复点击问题,对android按钮重复点击相关知识,感兴趣的朋友一起学习吧
  • jquery 防止重复点击提交

    千次阅读 2019-05-18 17:25:51
    jquery 防止重复点击提交 在项目中常常会使用到点击事件,当此点击事件与后端有交互时 ,或是网络不是很顺畅,用户多次点击事件会产生意想不到的效果,导致用户体验差;针对重复点击事件,笔者也曾经遇到过,在此,...

    jquery 防止重复点击提交

    在项目中常常会使用到点击事件,当此点击事件与后端有交互时 ,或是网络不是很顺畅,用户多次点击事件会产生意想不到的效果,导致用户体验差;针对重复点击事件,笔者也曾经遇到过,在此,分享 jquery 防止重复点击提交 的解决方案。

    方法一: 使用 css 禁用属性 —— disable

    该方法只能点击一次,若想再次点击需要页面重新进行了加载或者跳转;

    <form action="/login" method="post">
        <input type="text" name="username" />
        <input type="password" name="password" />
        <input type="submit" id="submitBtn"  value="登录" />
    </form>
    
    <script>
    	$(function(){
    		$('#submitBtn').on('click‘,function(){
    				$(this).attr('disabled',true); //点击后就禁用,若想再次点击需刷新页面;
    				$(this).val('登录中...');  //此处设置 value 值给以提示
    				this.form.submit();
    		});
    	});
    </script>
    
    方法二: 使用 jquery 中 one() 方法

    同样是上面 Html 例子,也是只可点击一次;再次点击需要页面重新进行了加载或者跳转;该方式是将绑定 on 方法 改为 one 方法 ,如下:

    <script>
    	$(function(){
    		$('#submitBtn').one('click‘,function(){
    				$(this).attr('disabled',true); //点击后就禁用,若想再次点击需刷新页面;
    				$(this).val('登录中...');  //此处设置 value 值给以提示
    				this.form.submit();
    		});
    	});
    </script>
    
    方法三: 针对 ajax 请求方式

    异步请求更好的适应用户的体验,为防止多次提交,可在提交前做处理;

    $(function () {
        $('#submitBtn').click(function () {
            //1.先进行表单验证
            //......
            //2.异步提交
            $.ajax({
                url: url+'/login',
                data: $('form').serialize(),
                type: 'post',
                beforeSend: function () {
                    //3.设置提交按钮失效,以实现防止按钮重复点击
                    $(this).attr('disabled', true);
                    //4.给用户提示
                    $(this).val('登录中...');
                },
                complete: function () {
                    //5.提交完成后按钮重新设置有效
                    $(this).removeAttr('disabled');
                },
                success: function(data){
                    if (data === 'ok') {
                        alert('登录成功!');
                        //做逻辑处理
                        //......
                    } else {
                        alert('登录失败,请重新登录!');
                    }
                }
            }); 
        });
    });
    

    以上三种方法为个人总结,当然还有其它方式 防止重复点击提交 ;再此就不在叙述,愿各位可以参考,也可以活动一个脑细胞,自己设计一种方式,可以在下方评论给予以分享!

    展开全文
  • RxJava防重复点击原理

    千次阅读 2019-02-28 15:09:14
    使用RxJava实现View防重复点击功能比较简单 fun View.noDoubleClick(action: Action1&amp;amp;amp;lt;Void&amp;amp;amp;gt;) { @Suppress(&amp;amp;quot;DEPRECATION&amp;amp;quot;) RxView....

    (代码基于rxbinding-1.0.1)
    使用RxJava实现View防重复点击功能比较简单

    fun View.noDoubleClick(action: Action1<Void>) {
        @Suppress("DEPRECATION")
        RxView.clicks(this)
                .throttleFirst(400, TimeUnit.MILLISECONDS)
                .subscribe(action, Action1 { t -> t.printStackTrace() })
    }
    

    它的原理是什么呢?
    首先看RxView.clicks(View)

    @CheckResult @NonNull
    public static Observable<Void> clicks(@NonNull View view) {
      checkNotNull(view, "view == null");
      return Observable.create(new ViewClickOnSubscribe(view));
    }
    

    只是将View封装在ViewClickOnSubscribe里,看下ViewClickOnSubscribe

    final class ViewClickOnSubscribe implements Observable.OnSubscribe<Void> {
      final View view;
    
      ViewClickOnSubscribe(View view) {
        this.view = view;
      }
    
      @Override public void call(final Subscriber<? super Void> subscriber) {
           // ...省略不相干代码
    
        View.OnClickListener listener = new View.OnClickListener() {
          @Override public void onClick(View v) {
            if (!subscriber.isUnsubscribed()) {
              subscriber.onNext(null);
            }
          }
        };
       // ...省略不相干代码
        view.setOnClickListener(listener);
      }
    }
    

    只是设置了View的OnClickListener,点击时这个listener对subscriber进行了调用。
    看下传入的subscriber,

    .throttleFirst(400, TimeUnit.MILLISECONDS)
                .subscribe(action, Action1 { t -> t.printStackTrace() })
    

    是经过throttleFirst的action,看下throttleFirst(long windowDuration, TimeUnit unit)

    public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
        return throttleFirst(windowDuration, unit, Schedulers.computation());
    }
    

    直接调用了它的重名函数

    public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
        return lift(new OperatorThrottleFirst<T>(skipDuration, unit, scheduler));
    }
    

    主要代码应该在OperatorThrottleFirst里,果然,记录了每次onNext()执行的时间戳,若本次call执行的时间与上次执行onNext()的时间差值小于限定值,则不会调用onNext()。

    public final class OperatorThrottleFirst<T> implements Operator<T, T> {
    
        final long timeInMilliseconds;
        final Scheduler scheduler;
    
        public OperatorThrottleFirst(long windowDuration, TimeUnit unit, Scheduler scheduler) {
            this.timeInMilliseconds = unit.toMillis(windowDuration);
            this.scheduler = scheduler;
        }
    
        @Override
        public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
            return new Subscriber<T>(subscriber) {
    
                private long lastOnNext = -1;
    
                @Override
                public void onStart() {
                    request(Long.MAX_VALUE);
                }
    
                @Override
                public void onNext(T v) {
                    long now = scheduler.now();
                    if (lastOnNext == -1 || now < lastOnNext || now - lastOnNext >= timeInMilliseconds) {
                        lastOnNext = now;
                        subscriber.onNext(v);
                    }
                }
    
                @Override
                public void onCompleted() {
                    subscriber.onCompleted();
                }
    
                @Override
                public void onError(Throwable e) {
                    subscriber.onError(e);
                }
    
            };
        }
    }
    

    使用RxJava实现防重复点击,代码可阅读性和维护都变得简单,但也有劣势,增加了很多无用对象的创建。

    展开全文
  • JS原生点击按钮防重复点击效果

    千次阅读 2019-05-10 11:56:39
    JS原生利用异步实现简单的防重复点击 使用场景: 项目中涉及后台交互的按钮,例如:确认转账、提交认证等等;第一次点击正常提交,但是如果在后台请求还没有返回的情况下,用户点击要给与适当的提示,如果后台数据返回...

    JS原生利用异步实现简单的防重复点击

    使用场景:
    项目中涉及后台交互的按钮,例如:确认转账、提交认证等等;第一次点击正常提交,但是如果在后台请求还没有返回的情况下,用户点击要给与适当的提示,如果后台数据返回了之后,又可以根据业务需求再次执行

    • HTML
    <button id="subBtn">确认转账</button>
    
    • JS
    var boo = true;
    $("#subBtn").click(function () {
         //异步更新Boo为false,但是此处不会立即执行
         setTimeout(function () { boo = false }, 0)
         if (boo) {
             $("#subBtn").addClass("disabledStyle")
             $.ajax({
                 type: "post",
                 url: '请求地址',
                 contentType: '',
                 data: '',
                 dataType: '',
                 success: function (data) {
                     boo = true
                     $("#subBtn").removeClass("disabledStyle")
                 },
                 error: function () {
                     boo = true
                     $("#subBtn").removeClass("disabledStyle")
                 }
             })
         }else{
             alert("正在提交请稍等...")
         }
     })
    

    思路:
    用一个变量的布尔值来控制是否执行后台的请求;对于这个变量的要求是:等到第一次请求发出之后调整变量的值,等到请求有结果之后再次变量过来,保证下次的正常提交。

    1:定义一个全局变量boo来控制时候执行ajax请求(true表示继续执行,false表示上一次请求还没有结束,给与适当的提示);

    2:setTimeout(function(){},0} ,执行到该倒计时并不会立即执行,因为该方法属于异步执行,不管第二个参数的时间是多少,都会等待同步执行完成之后才会继续执行;(可以参考异步操作中的定时器

    3:等到请求回来之后再改变boo为true,保证下次正然可以正常提交。

    **上边代码涉及的class“disabledStyle”是为了在视觉上有一个提示;当然我们也可以通过判断disabledStyle这个class是否存在(hasClass()),来判断是否执行ajax程序,可以达到一样的效果

    展开全文
  • * ListView / RecyclerView item 防止重复点击处理方案 */ public abstract class OnNoDoubleClickListener implements View.OnClickListener { // 0.9秒内防止多次点击 public static final int MIN_CLICK_...
  • 防止重复点击的Button按钮(自定义控件),很不错的额
  • js防止重复点击或者点击过快方法

    万次阅读 多人点赞 2018-08-03 13:44:47
    js防止重复点击或者点击过快方法 1.html &lt;button type="button" data-val="0"&gt;00000&lt;/button&gt; &lt;button type="button" data-val="1"...
  • 今天小编就为大家分享一篇解决layer.confirm快速点击重复触发事件的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 前端重复点击重复请求的解决方法

    千次阅读 2020-07-02 18:16:10
     在之前的项目中使用原生js写前端经常会遇到重复请求的问题,即一次请求还没有执行完毕,用户又点击了一次,这样重复请求会造成后台数据异常。又比如在查询数据的时候,点击了一次查询,还在处理数据的时候,用户又...
  • react防重复点击方法

    千次阅读 2018-10-11 15:24:08
    React 防重复点击方法、原理 原理:在请求数据一旦开始,直到本次请求结束之前,不能进行下一次点击,否则给与相应的提示 state中的初始设置: state={ bool:true, } 点击事件设置: btn_click = async () =&gt...
  • 拦截鼠标频繁重复点击事件

    千次阅读 2018-11-08 17:30:12
    1.频繁重复点击只执行最后一次点击事件 /** * 300毫秒内拦截重复点击 * @param {ObjectElement} el 元素对象 * @param {Function} fn 点击后运行的函数 */ function scienceClick(el, fn) { el.timer = null; ...
  • 当用户点击按钮或控件时,如果响应比较慢,往往会重复点击,另外也会存在用户故意反复快速点击的情况,这种时候就会多次触发点击事件造成非期望的结果。如何解决或避免这个问题呢?一般来说有两种情况。 1、点击事件...
  • Android防止重复点击,支持点击事件OnClick(View v)重复点击,直接调用方法就可以了。
  • vue 指令式防止重复点击

    千次阅读 2020-04-24 13:01:05
    防止按钮重复点击vue 自定义全局指令 // 防重复点击(指令实现) vue.directive('resetClick', { inserted (el, binding) { el.addEventListener('click', () => { if (!el.disabled) { el.disabled = true s...
  • 防止重复点击可以添加一个开关,让这个开关默认为true,第一次点击将其变为false,点击事件的执行需要判断这个开关是否为true,为true执行,false不执行。例子如下: var isclick = true; function fn(){ if...
  • vue防止按钮重复点击提交

    千次阅读 2020-01-18 09:21:04
    <Form-Item class="formBtn"> <i-button type="primary" @click="handleSubmit('formInline')" class="confirm" :disabled="isDisable">登录</i-button> <...methods:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421,431
精华内容 168,572
关键字:

重复点击