vue项目中极验验证的使用代码示例

使用vue、react的项目获取数据、上传数据、注册、登陆等都是通过接口来完成的，接口很容易被人恶意调用，最容易被人恶意调用的接口就是注册、登陆类的接口，为了防止接口被恶意调用很多公司开发了出了很多的人机验证的工具，今天就来讲下极验验证在vue项目中的使用。

效果预览

1、遇到的问题

• 在项目中任何一个页面或vue组件都有可能需要使用到极验，并且极验在初始化时需要传递一些参数，要怎么做才能做到每一个组件都能很方便的使用极验呢？
• 极验应该在什么时候初始化？是组件一加载就初始化还是用户点击按钮后再初始化？
• 在多语言项目中，用户手动切换语言后的极验重置

2、代码分享

为了在多个页面或多个组件中都能方便的使用极验，我将极验初始化的相关代码写到了mixins中。这样做的好处是：方便在组件中获取极验相关的数据，以及调用极验相关api，如做重置、销毁等操作；缺点是：在同一个页面中无法在多个地方使用mixin，但这也是有解决方案的。

geetest-mixin.js

/*
 极验mixin
 */
// 导入极验官方给的代码
import gt from "../common/js/geetest/geetest.gt";
import {commonapi} from "../api/commonapi";
import {mapgetters} from "vuex";
// 自定义语言与极验语言对应表
const geetestlangmap = {
 "zh_cn": "zh-cn",
 "zh_tw": "zh-tw",
 "en_us": "en",
 "ja_jp": "ja",
 "ko_kr": "ko",
 "ru_ru": "ru"
};
console.log('gt',gt)
// 极验默认配置
const geetestoptions = {
 product: 'popup', // 极验展现形式 可选值有 float、popup、custom、bind
 width: '100%',
 lang: 'zh_cn',
 autoshow: true, // 当product为bind时，如果次参数为true，则在极验加载完成后立即显示极验弹窗
 area: null, // 极验绑定的元素，仅在 product为 custom、float、popup时需要传递
 autorefreshonlangchange: true, // 语言改变时是否自动刷新
};
export const geetestmixin = {
 data(){
  return {
   geetest: {
    geetestsuccessdata: null, // 极验用户行为操作成功后的数据
    geetestobj: null, // 极验对象
    geetestloading: false,
    geetestfatched: false, // 判断是否从服务器获取了极验数据
    showgeetest: false, // 是否使用极验
    sign: "", // 极验降级 用的签名
    geetestrestartcountmax: 5, // 极验重试最大此时
    count: 1,
    geetestoptions: {}
   }
  }
 },
 computed: {
  ...mapgetters(['get_lang'])
 },
 watch: {
  get_lang(lang){
   let options = this.geetest.geetestoptions;
   if(options.autorefreshonlangchange && this.geetest.geetestobj){
    this.initgeetest({
     ...options,
     lang: lang.code
    });
   }
  }
 },
 methods: {
  // 初始化极验
  initgeetest(options){
   if(!options || ({}).tostring.call(options) !== '[object object]'){
    console.error('initgeetest方法的参数options必须是一个对象！');
    return;
   }
   let newoptions = object.assign({}, geetestoptions, options);
   if((newoptions.product === 'popup' || newoptions.product === 'custom' || newoptions.product === 'float') && !newoptions.area){
    console.error('product为popup、custom、float时options参数中必须有area属性，area属性值可以为css选择器或dom元素！');
    return;
   }
   this.geetest.geetestoptions = newoptions;
   this._geetestregist_(newoptions);
  },
  // 重置极验
  geetestreset(cb){
   if(this.geetest.geetestobj){
    this.geetest.geetestsuccessdata = {};
    this.geetest.geetestobj.reset();
    if(typeof cb === 'function'){
     cb();
    }
   }else{
    console.error('极验不存在!');
   }
  },
  // 显示极验弹窗，此方法只有在product为bind时才有效
  geetestshow(){
   if(this.geetest.geetestobj){
    if(this.geetest.geetestoptions.product === 'bind'){
     this.geetest.geetestobj.verify();
    }else{
     console.error('极验的product值非bind，无法调用show！');
    }
   }else{
    console.error('极验不存在!');
   }
  },
  // 初始化极验，内部使用
  _initgeetestinternal_(data, options){
   let that = this;
   let geetest = this.geetest;

   window.initgeetest({
    // 以下 4 个配置参数为必须，不能缺少
    gt: data.gt,
    challenge: data.challenge,
    offline: !data.success, // 表示用户后台检测极验服务器是否宕机
    new_captcha: true, // 用于宕机时表示是新验证码的宕机
    product: options.product, // 产品形式，包括：float，popup，bind
    width: options.width,
    lang: geetestlangmap[options.lang]
   }, function (captchaobj) {
        if(geetest.geetestobj){
         try {
          // 如果之前已经初始化过了，则线将之前生成的dom移除掉
          geetest.geetestobj.destroy();
         }catch (e) {
          console.error('极验销毁失败', e);
         }
        }
    geetest.geetestobj = captchaobj;
    if((options.product === 'popup' || options.product === 'custom' || options.product === 'float')){
     captchaobj.appendto(options.area);
    }
    // 为bind模式时极验加载完成后自动弹出极验弹窗
    if(options.autoshow && options.product === 'bind'){
     captchaobj.onready(() => {
      captchaobj.verify();
     });
    }
    geetest.geetestsuccessdata = {};
    // 当用户操作后并且通过验证后的回调
    captchaobj.onsuccess(function () {
     let successdata = captchaobj.getvalidate();
     geetest.geetestsuccessdata = successdata;
     console.log('用户行为验证通过数据', successdata);
     /*
      这种方式不可采用，原因，作用域会被缓存
      if (typeof options.callback === 'function') {
       options.callback(successdata);
      }
      用户行为验证通过后调用回调函数
     */
     if(typeof that.ongeetestsuccess === 'function'){
      that.ongeetestsuccess(successdata);
     }
    });
    captchaobj.onerror(function (e) {
     console.error("极验出错了", e);
    });
    console.log('极验实例', captchaobj);
   });
  },
  // 调用接口，获取极验数据
  _geetestregist_(options){
   if(this.geetest.geetestloading){
    return;
   }
   this.geetest.geetestloading = true;
   commonapi.getgtcaptcha()
    .then(res => {
     let data = res.data;
     // tip 后台需要控制是否开启极验，因此需要判断 enable===true && success===1 才显示极限
     this.geetest.sign = data.sign;
     this.geetest.geetestfatched = true;
     if(typeof data.enable == "undefined" || (data.enable === true && data.success === 1)) {
      this.geetest.showgeetest = true;
     }else{
      this.geetest.showgeetest = false;
      this.geetest.geetestloading = false;
      /*// 如果极验禁用，则调用ondisablegeetest回调
      if(typeof options.ondisablegeetest === 'function'){
       options.ondisablegeetest();
      }*/
      // 如果极验禁用，则调用ondisablegeetest回调
      if(typeof this.ondisablegeetest === 'function'){
       this.ondisablegeetest();
      }
      return
     }
     this.geetest.geetestloading = false;
     this._initgeetestinternal_(data, options);
    })
    .catch((err) => {
     console.error('极验初始化失败', err);
     if(this.geetest.count > this.geetest.geetestrestartcountmax){
      this.geetest.geetestloading = false;
      return;
     }
     console.log('正在重试初始化极验！当前次数：' + this.geetest.count);
     this.geetest.count++;
     this._geetestregist_(options);
    });
  }
 },
 beforedestroy(){
  if(this.geetest.geetestobj){
   this.geetest.geetestobj.destroy();
  }
 }
};

geetest.gt.js

段代码可以不用关注，极验官网有

/* initgeetest 1.0.0
 * 用于加载id对应的验证码库，并支持宕机模式
 * 暴露 initgeetest 进行验证码的初始化
 * 一般不需要用户进行修改
 */
var gtinit = (function (global, factory) {
 "use strict";
 if (typeof module === "object" && typeof module.exports === "object") {
  // commonjs
  module.exports = global.document ?
   factory(global, true) :
   function (w) {
    if (!w.document) {
     throw new error("geetest requires a window with a document");
    }
    return factory(w);
   };
 } else {
  factory(global);
 }
})(typeof window !== "undefined" ? window : this, function (window, noglobal) {
 "use strict";
 if (typeof window === 'undefined') {
  throw new error('geetest requires browser environment');
 }
 var document = window.document;
 var math = window.math;
 var head = document.getelementsbytagname("head")[0];

 function _object(obj) {
  this._obj = obj;
 }

 _object.prototype = {
  _each: function (process) {
   var _obj = this._obj;
   for (var k in _obj) {
    if (_obj.hasownproperty(k)) {
     process(k, _obj[k]);
    }
   }
   return this;
  }
 };
 function config(config) {
  var self = this;
  new _object(config)._each(function (key, value) {
   self[key] = value;
  });
 }

 config.prototype = {
  api_server: 'api.geetest.com',
  protocol: 'http://',
  type_path: '/gettype.php',
  fallback_config: {
   slide: {
    static_servers: ["static.geetest.com", "dn-staticdown.qbox.me"],
    type: 'slide',
    slide: '/static/js/geetest.0.0.0.js'
   },
   fullpage: {
    static_servers: ["static.geetest.com", "dn-staticdown.qbox.me"],
    type: 'fullpage',
    fullpage: '/static/js/fullpage.0.0.0.js'
   }
  },
  _get_fallback_config: function () {
   var self = this;
   if (isstring(self.type)) {
    return self.fallback_config[self.type];
   } else if (self.new_captcha) {
    return self.fallback_config.fullpage;
   } else {
    return self.fallback_config.slide;
   }
  },
  _extend: function (obj) {
   var self = this;
   new _object(obj)._each(function (key, value) {
    self[key] = value;
   })
  }
 };
 var isnumber = function (value) {
  return (typeof value === 'number');
 };
 var isstring = function (value) {
  return (typeof value === 'string');
 };
 var isboolean = function (value) {
  return (typeof value === 'boolean');
 };
 var isobject = function (value) {
  return (typeof value === 'object' && value !== null);
 };
 var isfunction = function (value) {
  return (typeof value === 'function');
 };
 var callbacks = {};
 var status = {};
 var random = function () {
  return parseint(math.random() * 10000) + (new date()).valueof();
 };
 var loadscript = function (url, cb) {
  var script = document.createelement("script");
  script.charset = "utf-8";
  script.async = true;
  script.onerror = function () {
   cb(true);
  };
  var loaded = false;
  script.onload = script.onreadystatechange = function () {
   if (!loaded &&
    (!script.readystate ||
     "loaded" === script.readystate ||
     "complete" === script.readystate)) {

    loaded = true;
    settimeout(function () {
     cb(false);
    }, 0);
   }
  };
  script.src = url;
  head.appendchild(script);
 };
 var normalizedomain = function (domain) {
  return domain.replace(/^https?:\/\/|\/$/g, '');
 };
 var normalizepath = function (path) {
  path = path.replace(/\/+/g, '/');
  if (path.indexof('/') !== 0) {
   path = '/' + path;
  }
  return path;
 };
 var normalizequery = function (query) {
  if (!query) {
   return '';
  }
  var q = '?';
  new _object(query)._each(function (key, value) {
   if (isstring(value) || isnumber(value) || isboolean(value)) {
    q = q + encodeuricomponent(key) + '=' + encodeuricomponent(value) + '&';
   }
  });
  if (q === '?') {
   q = '';
  }
  return q.replace(/&$/, '');
 };
 var makeurl = function (protocol, domain, path, query) {
  domain = normalizedomain(domain);

  var url = normalizepath(path) + normalizequery(query);
  if (domain) {
   url = protocol + domain + url;
  }

  return url;
 };
 var load = function (protocol, domains, path, query, cb) {
  var tryrequest = function (at) {

   var url = makeurl(protocol, domains[at], path, query);
   loadscript(url, function (err) {
    if (err) {
     if (at >= domains.length - 1) {
      cb(true);
     } else {
      tryrequest(at + 1);
     }
    } else {
     cb(false);
    }
   });
  };
  tryrequest(0);
 };
 var jsonp = function (domains, path, config, callback) {
  if (isobject(config.getlib)) {
   config._extend(config.getlib);
   callback(config);
   return;
  }
  if (config.offline) {
   callback(config._get_fallback_config());
   return;
  }
  var cb = "geetest_" + random();
  window[cb] = function (data) {
   if (data.status === 'success') {
    callback(data.data);
   } else if (!data.status) {
    callback(data);
   } else {
    callback(config._get_fallback_config());
   }
   window[cb] = undefined;
   try {
    delete window[cb];
   } catch (e) {
   }
  };
  load(config.protocol, domains, path, {
   gt: config.gt,
   callback: cb
  }, function (err) {
   if (err) {
    callback(config._get_fallback_config());
   }
  });
 };
 var throwerror = function (errortype, config) {
  var errors = {
   networkerror: '网络错误'
  };
  if (typeof config.onerror === 'function') {
   config.onerror(errors[errortype]);
  } else {
   throw new error(errors[errortype]);
  }
 };
 var detect = function () {
  return !!window.geetest;
 };
 if (detect()) {
  status.slide = "loaded";
 }
 var initgeetest = function (userconfig, callback) {
  var config = new config(userconfig);
  if (userconfig.https) {
   config.protocol = 'https://';
  } else if (!userconfig.protocol) {
   config.protocol = window.location.protocol + '//';
  }
  jsonp([config.api_server || config.apiserver], config.type_path, config, function (newconfig) {
   var type = newconfig.type;
   var init = function () {
    config._extend(newconfig);
    callback(new window.geetest(config));
   };
   callbacks[type] = callbacks[type] || [];
   var s = status[type] || 'init';
   if (s === 'init') {
    status[type] = 'loading';
    callbacks[type].push(init);
    load(config.protocol, newconfig.static_servers || newconfig.domains, newconfig[type] || newconfig.path, null, function (err) {
     if (err) {
      status[type] = 'fail';
      throwerror('networkerror', config);
     } else {
      status[type] = 'loaded';
      var cbs = callbacks[type];
      for (var i = 0, len = cbs.length; i < len; i = i + 1) {
       var cb = cbs[i];
       if (isfunction(cb)) {
        cb();
       }
      }
      callbacks[type] = [];
     }
    });
   } else if (s === "loaded") {
    init();
   } else if (s === "fail") {
    throwerror('networkerror', config);
   } else if (s === "loading") {
    callbacks[type].push(init);
   }
  });
 };
 window.initgeetest = initgeetest;
 return initgeetest;
});

export default {
 gtinit
}

页面中使用

// 导入极验验证
import {geetestmixin} from "./geetest-mixin";
import {mapgetters} from "vuex";
import {commonapi} from "../api/commonapi";

export default {
 name: 'regist',
 mixins: [geetestmixin],
 data(){
  return {
   form: {
    ...表单数据
   },
   committing: false,
   errmsg: ' ',.
  }
 },
 methods: {
  // 提交注册数据
  submitregistdata(){
   ...你的业务逻辑
   /*if(this.geetest.showgeetest){
    // 如果没有geetest_challenge，则说明用户没有进行行为验证
    if(!this.geetest.geetestsuccessdata.geetest_challenge){
     this.errmsg = this.$t('formerror.geetest'); // 点击按钮进行验证
     return;
    }
   }*/
   this.errmsg = '';


   if(!this.geetest.geetestobj){
    /*
     如果this.geetest.geetestfatched==true，则说明已经加载过极验了
     如果this.geetest.showgeetest==false，则说明后台关闭极验了
     */
    if(this.geetest.geetestfatched && !this.geetest.showgeetest){
     //this.committing = true;
     this.commitdata();
    }else{
     this.initgeetest({
      product: 'bind',
      lang: this.get_lang.code,
     });
    }
   }else{
    if(this.geetest.showgeetest){
     this.geetestshow();
    }else{
     console.log('fasfsafsdfsd')
     //this.committing = true;
     this.commitdata();
    }
   }
  },
  // 提交数据
  commitdata(){
   if(this.committing){
    return;
   }
   this.committing = true;
   let data = {
    ...this.form
   };
   let geetestdata = {};
   // 获取极验数据
   if(this.geetest.showgeetest){
    geetestdata = {
     ...this.geetest.geetestsuccessdata,
     sign: this.geetest.sign
    }
   }
   if(!this.form.invitecode){
    delete data.invitecode;
   }
   commonapi.regist(data, geetestdata)
    .then(res => {
     this.committing = false;
     if(res.errcode === 0){
      ...你的业务逻辑
     }else{
     // 重置极验，使极验回到可操作状态
      this.geetestreset();
     }
    })
    .catch(() => {
     this.committing = false;
     // 重置极验，使极验回到可操作状态
     this.geetestreset();
    });
  },
  // 极验验证成功后回调
  ongeetestsuccess(){
   // 用户通过极验行为验证后做的操作
   this.commitdata();
  },
  // 极验被禁用后回调
  ondisablegeetest(){
   this.commitdata();
  }
 },
 computed: {
  ...mapgetters(['get_lang'])
 }
};

3、极验初始化时间问题

geetest-mixin.js设计的比较灵活，它可以允许你在任何时机初始化极验。但在项目中推荐在需要使用到的时候再初始化，1来可以节省流量；2来可以提升页面性能；3是最重要的一个点，在单页面应用程序中都是通过接口来访问数据的，而接口都有过期时间，如果组件初始化完成就立即初始化极验，而用户在接口过期后再去操作则会出现一些奇葩的bug

4、多语言项目中用户手动切换语言的问题

由于单页面应用程序切换语言后页面不会刷新，所以就会出现页面语言已经切换了，但极验还是使用的原来的语言。我的解决方案就是在用户切换语言后手动的刷新一下极验

{
 watch: {
  get_lang(lang){
   let options = this.geetest.geetestoptions;
   // 如果开启了语言切换自手动刷新极验，并且极验已经初始化了则刷新。如果极验都还没有初始化则可以不用去刷新
   if(options.autorefreshonlangchange && this.geetest.geetestobj){
    this.initgeetest({
     ...options,
     lang: lang.code
    });
   }
  }
 }
}

5、关于点击按钮时按钮loading效果的控制

如《效果预览》图中的获取验证码loading效果控制，可以通过geetest.geetestloading来进行判断

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。