手机验证码登录

最新推荐文章于 2024-09-17 09:32:35 发布
最新推荐文章于 2024-09-17 09:32:35 发布
阅读量600 收藏 1
点赞数
文章标签： 数据库 java
原文链接：https://yq.aliyun.com/articles/603429
版权

手机验证登录分为三个API接口，分别为：获取图片验证码、获取手机短信验证码、登录。


1.获取图片验证码：通过工具类生成图片验证码，将随机验证码的数字保存到session中，将图片验证码转为base64码放到对应的entity字段里。


2.获取手机短信验证码：判断手机号不能为空、手机号的格式、手机号在数据中必须存在，定义6位随机数做为短信验证码，先将验证码保存到redis中（60秒时效），


然后再发送到对应的手机号中。


3.登录：首先检验随机验证码、短信验证码不能为空，从session中获取随机验证码进行校验（验证码忽略大小写），


校验成功后就开始继续从session获取短信验证码并做校验，短信验证码验证成功后就开始进入到系统并修改登录次数、登录时间、获取下载数、个人信息等。



package com.chinamobile.cmss.share.controller;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.chinamobile.cmss.dto.CmssSmsLoginDto;
import com.chinamobile.cmss.share.service.ICmssSmsLoginService;
import com.web.response.ResponseDto;
import com.web.response.ResponseUtil;

/**
 * 手机短信验证登录
 * @author yaohongan
 *
 */

@RestController
@RequestMapping(value = "/smsLogin")
public class CmssSMSLoginController {

    /**
     * 日志
     */
    private final Logger log = Logger.getLogger(CmssSMSLoginController.class);

    @Autowired
    private ICmssSmsLoginService smsLoginService;

    /**
     * 获取随机验证码
     * @param code
     * @return
     */
    @GetMapping("/getValidationCode")
    public ResponseDto getValidationCode(final CmssSmsLoginDto sms, final HttpServletRequest request,
            final HttpServletResponse response) throws Exception {

        return ResponseUtil.wrapSuccess(smsLoginService.getValidationCode(sms, request, response));
    }

    /**
     * 获取短信验证码
     * @param code
     * @return
     */
    @PostMapping("/getSendSmsValidationCode")
    public ResponseDto getSendSmsValidationCode(@RequestBody final CmssSmsLoginDto sms) {

        smsLoginService.getSendSmsValidationCode(sms);
        return ResponseUtil.wrapSuccess();
    }

    /**
     * 登录
     * @param sms
     * @return
     */
    @PostMapping("/login")
    public ResponseDto smsLogin(@RequestBody final CmssSmsLoginDto sms, final HttpServletRequest request,
            final HttpServletResponse resp) {

        final Map<String, Object> returnMap = smsLoginService.login(sms, request, resp);
        return ResponseUtil.wrapSuccess(returnMap);
    }
}

service 接口层 



package com.chinamobile.cmss.share.service;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.chinamobile.cmss.dto.CmssSmsLoginDto;

public interface ICmssSmsLoginService {

    /** 获取随机验证码 **/
    CmssSmsLoginDto getValidationCode(CmssSmsLoginDto sms, HttpServletRequest request, HttpServletResponse response)
            throws Exception;

    /** 获取短信验证码 **/
    void getSendSmsValidationCode(final CmssSmsLoginDto sms);

    /** 登录 **/
    Map<String, Object> login(CmssSmsLoginDto sms, final HttpServletRequest request, final HttpServletResponse resp);

    /** 登录后的操作 **/
    Map<String, Object> validateLogin(final String cryptogramMobilePhone, final HttpServletRequest request,
            final HttpServletResponse resp);
}
service 实现层 

package com.chinamobile.cmss.share.service.impl;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.base.service.BaseService;
import com.base.util.mapper.JsonMapper;
import com.chinamobile.cmss.constants.CommonConstants;
import com.chinamobile.cmss.dto.CmssSmsLoginDto;
import com.chinamobile.cmss.dto.ValidateDto;
import com.chinamobile.cmss.share.dao.CmssPortalUserDao;
import com.chinamobile.cmss.share.entity.PortalUser;
import com.chinamobile.cmss.share.exception.CmssSmsLoginException;
import com.chinamobile.cmss.share.exception.LoginExceptionEnum;
import com.chinamobile.cmss.share.service.ICmssSmsLoginService;
import com.chinamobile.cmss.share.service.IPermissionService;
import com.chinamobile.cmss.share.utils.ValidateCodeUtil;
import com.share.page.buss.PortalUserPage;
import com.share.utils.ShareJedis;
import com.web.exception.BusinessException;

@Service("cmssSmsLoginService")
public class CmssSmsLoginServiceImpl extends BaseService<T> implements ICmssSmsLoginService {

    /** 日志 **/
    private final Logger log = Logger.getLogger(CmssSmsLoginServiceImpl.class);

    @Resource
    private ShareJedis shareJedis;

    @Value("${smsCodePrescription}")
    private Integer smsCodePrescription;

    @Autowired
    private CmssPortalUserDao<T> dao;

    @Autowired
    private CmssBatchSmsService batchSmsService;

    @Autowired
    private CmssPortalUserService<PortalUser> cmssPortalUserService;

    @Autowired
    private IPermissionService permissionService;

    // 用户下载总次数redis键值前缀
    // redis里key：userDownloadTimes:pdf:${userId},userId为当前用户登录ID
    private final static String KEY_PREFIX = "userDownloadTimes:";

    @Override
    public CmssPortalUserDao<T> getDao() {

        return dao;
    }

    /**
     * 获取随机验证码
     * @throws IOException
     */
    @Override
    public CmssSmsLoginDto getValidationCode(final CmssSmsLoginDto sms, final HttpServletRequest request,
            final HttpServletResponse response) throws Exception {

        final HttpSession session = request.getSession();
        // 直接调用静态方法，返回验证码对象
        final ValidateDto v = ValidateCodeUtil.getRandomCode();
        if (v != null) {
            // 将验证码值保存session
            session.setAttribute("validate", v.getValue());
            log.info("验证码是：" + v.getValue());
            // 保存图片二维码的base64码
            sms.setCode(v.getBase64Str());
        }
        return sms;
    }

    /**
     * 获取短信验证码
     */
    @Override
    public void getSendSmsValidationCode(final CmssSmsLoginDto sms) {

        // 手机号码不能为空
        if (StringUtils.isEmpty(sms.getPhone())) {
            throw new BusinessException(CmssSmsLoginException.PHONE_EMPTY);
        }
        // 判断手机号格式
        if (!sms.getPhone().matches("^1\\d{10}$")) {
            throw new BusinessException(CmssSmsLoginException.PHONE_EXIST);
        }
        // 校验手机号是否存在
        // 去数据库查询手机号
        final PortalUserPage portalUser = new PortalUserPage();
        portalUser.setPhone(sms.getPhone());
        final List<T> portalUserList = dao.queryByList(portalUser);
        if (portalUserList.size() == 0) {
            throw new BusinessException(CmssSmsLoginException.ACCOUNT_NOT_EXIST);
        }

        final String phone = sms.getPhone();
        sms.setSmsCode(String.valueOf((new Random().nextInt(899999) + 100000)));
        // 将短信验证码存储到redis,时效是1分钟
        shareJedis.setex(phone, sms.getSmsCode(), smsCodePrescription);
        // 发送手机验证码
        batchSmsService.sendSmsValidationCode(phone, sms.getSmsCode());
        log.info("短信验证发送成功,发送时间{" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "},手机号{"
                + sms.getPhone() + "},验证码{" + sms.getSmsCode() + "}");

    }

    /**
     * 短信验证登录
     */
    @Override
    public Map<String, Object> login(final CmssSmsLoginDto sms, final HttpServletRequest request,
            final HttpServletResponse resp) {

        // 短信验证码不能为空
        if (StringUtils.isEmpty(sms.getSmsCode())) {
            throw new BusinessException(CmssSmsLoginException.SMS_AUTHENTICATION_CODE_NOT_EXISTS);
        }
        // 随机验证码不能为空
        if (StringUtils.isEmpty(sms.getCode())) {
            throw new BusinessException(CmssSmsLoginException.VERIFICATION_CODE_EMPTY);
        }
        final HttpSession session = request.getSession();
        final String sessionValidate = (String) session.getAttribute("validate");
        // 验证随机验证码
        // 忽略验证码大小写
        if (!StringUtils.equalsIgnoreCase(sms.getCode(), sessionValidate)) {
            throw new BusinessException(CmssSmsLoginException.VERIFICATION_CODE_ERROR);
        }
        // 验证短信验证码
        // 根据手机号码取短信验证码
        final String smsCode = shareJedis.get(sms.getPhone());
        // 如果验证码为空就是超时
        if (StringUtils.isEmpty(smsCode)) {
            throw new BusinessException(CmssSmsLoginException.SMS_AUTHENTICATION_CODE_OVERTIME);
        }
        // 校验短信验证码是否匹配
        if (!smsCode.equals(sms.getSmsCode())) {
            throw new BusinessException(CmssSmsLoginException.SMS_AUTHENTICATION_CODE_ERROR);
        }
        String cryptogramMobilePhone = "";
        PortalUser pu = new PortalUser();
        final PortalUserPage pup = new PortalUserPage();
        pup.setPhone(sms.getPhone());
        final List<PortalUser> ls = cmssPortalUserService.getUserByPhone(pup);
        if (ls != null && ls.size() > 0) {
            pu = ls.get(0);
            if (CommonConstants.PORTAL_USER_STATUS.UNCHECKED_USER_STATUS.equals(pu.getStatus())) {

                throw new BusinessException(LoginExceptionEnum.UNCHECKED_USER);
            }
            if (CommonConstants.PORTAL_USER_STATUS.UNAVALIDATE.equals(pu.getStatus())) {

                throw new BusinessException(LoginExceptionEnum.UNAVALIDATE);
            }
            if (CommonConstants.PORTAL_USER_STATUS.AUTH_FAILED.equals(pu.getStatus())) {

                throw new BusinessException(LoginExceptionEnum.AUTH_FAILED);
            }
            cryptogramMobilePhone = pu.getEncryptPhone();
            shareJedis.setPortalUserInfo(cryptogramMobilePhone, pu);
        }
        final Map<String, Object> returnMap = validateLogin(cryptogramMobilePhone, request, resp);
        return returnMap;
    }

    /**
     * 登录后的操作
     * @param cryptogramMobilePhone
     * @param request
     * @param resp
     * @return
     */
    @Override
    public Map<String, Object> validateLogin(final String cryptogramMobilePhone, final HttpServletRequest request,
            final HttpServletResponse resp) {

        final Map<String, Object> returnMap = new HashMap<>();

        final PortalUser currentUser = shareJedis.getPortalUserInfo(PortalUser.class, cryptogramMobilePhone);
        log.info("long in currentUser : ========" + currentUser);

        if (null != currentUser) {
            // 取用户应用渠道
            final String uuid = UUID.randomUUID().toString().replace("-", "");
            request.getSession(true).setAttribute("JSESSIONID", uuid);
            // 登录后，对用户进行积分计算，存入缓存
            shareJedis.portalUserLoginWithMsg(currentUser.getId().longValue());
            request.getSession(true).setAttribute("session_user", currentUser);
            // 将用户应用渠道放到head中
            // resp.setHeader("channel_code", channelCode);
            // 将用户记录放到session中，并放到head中
            resp.setHeader("User-Info", new JsonMapper().toJson(currentUser));
            cmssPortalUserService.updateLoginInfo(currentUser);
            if (currentUser.getLoginCount() != null) {
                currentUser.setLoginCount(currentUser.getLoginCount() + 1);
            } else {
                currentUser.setLoginCount(1);
            }
            final String index = cmssPortalUserService.getUserIndex(currentUser.getId());
            currentUser.setIndex(index);
            returnMap.put("userInfo", currentUser);
            final Integer permission = permissionService.getPermissionLevel(currentUser);
            returnMap.put("permission", permission);
            returnMap.put("provProdTitle",
                    permissionService.getProvProductTitle(permission, currentUser.getCompanyId(), currentUser));
            returnMap.put("companyId", currentUser.getCompanyId());

            final String redisKey = KEY_PREFIX + currentUser.getId();
            if (shareJedis.exists(redisKey)) {
                returnMap.put("userDownloadTimes", shareJedis.get(redisKey));
            } else {
                returnMap.put("userDownloadTimes", 0);
            }
        } else {
            log.info("Login error [" + cryptogramMobilePhone + "]");
            throw new BusinessException(LoginExceptionEnum.ACCOUNT_NOT_EXIST);
        }

        return returnMap;

    }

}

图片验证码工具类 

package com.chinamobile.cmss.share.utils;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;

import org.apache.commons.lang3.RandomUtils;

import com.alibaba.druid.util.Base64;
import com.chinamobile.cmss.dto.ValidateDto;

/**
 *
 * @ClassName: ValidateCodeUtil
 * @Description: 验证码生成工具类
 * @author yaohongan
 */
public class ValidateCodeUtil {

    private static ValidateDto validateDto = null; // 验证码类，用于最后返回此对象，包含验证码图片base64和真值

    private static Random random = new Random(); // 随机类，用于生成随机参数

    private static String randString = "0123456789abcdefghijkmnpqrtyABCDEFGHIJLMNQRTY";// 随机生成字符串的取值范围

    private static int width = 80; // 图片宽度

    private static int height = 34; // 图片高度

    private static int StringNum = 4; // 字符的数量

    private static int lineSize = 40; // 干扰线数量

    // 将构造函数私有化 禁止new创建
    private ValidateCodeUtil() {

        super();
    }

    /**
     * 获取随机字符,并返回字符的String格式
     * @param index (指定位置)
     * @return
     */
    private static String getRandomChar(final int index) {

        // 获取指定位置index的字符，并转换成字符串表示形式
        return String.valueOf(randString.charAt(index));
    }

    /**
     * 获取随机指定区间的随机数
     * @param min (指定最小数)
     * @param max (指定最大数)
     * @return
     */
    private static int getRandomNum(final int min, final int max) {

        return RandomUtils.nextInt(min, max);
    }

    /**
     * 获得字体
     * @return
     */
    private static Font getFont() {

        return new Font("Fixedsys", Font.CENTER_BASELINE, 25); // 名称、样式、磅值
    }

    /**
     * 获得颜色
     * @param fc
     * @param bc
     * @return
     */
    private static Color getRandColor(int frontColor, int backColor) {

        if (frontColor > 255) {
            frontColor = 255;
        }
        if (backColor > 255) {
            backColor = 255;
        }

        final int red = frontColor + random.nextInt(backColor - frontColor - 16);
        final int green = frontColor + random.nextInt(backColor - frontColor - 14);
        final int blue = frontColor + random.nextInt(backColor - frontColor - 18);
        return new Color(red, green, blue);
    }

    /**
     * 绘制字符串,返回绘制的字符串
     * @param g
     * @param randomString
     * @param i
     * @return
     */
    private static String drawString(final Graphics g, String randomString, final int i) {

        final Graphics2D g2d = (Graphics2D) g;
        g2d.setFont(getFont()); // 设置字体
        g2d.setColor(new Color(random.nextFloat(), random.nextFloat(), random.nextFloat()));// 设置颜色
        final String randChar = String.valueOf(getRandomChar(random.nextInt(randString.length())));
        randomString += randChar; // 组装
        final int rot = getRandomNum(5, 10);
        g2d.translate(random.nextInt(3), random.nextInt(3));
        g2d.rotate(rot * Math.PI / 180);
        g2d.drawString(randChar, 13 * i, 20);
        g2d.rotate(-rot * Math.PI / 180);
        return randomString;
    }

    /**
     * 绘制干扰线
     * @param g
     */
    private static void drawLine(final Graphics g) {

        // 起点(x,y) 偏移量x1、y1
        final int x = random.nextInt(width);
        final int y = random.nextInt(height);
        final int xl = random.nextInt(13);
        final int yl = random.nextInt(15);
        g.setColor(new Color(random.nextFloat(), random.nextFloat(), random.nextFloat()));
        g.drawLine(x, y, x + xl, y + yl);
    }

    /**
     *
     * @MethodName: getRandomCode
     * @Description: 生成Base64图片验证码
     * @param key
     * @return String 返回base64
     */
    public static ValidateDto getRandomCode() {

        validateDto = validateDto == null ? new ValidateDto() : validateDto;

        // BufferedImage类是具有缓冲区的Image类,Image类是用于描述图像信息的类
        final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
        final Graphics g = image.getGraphics();// 获得BufferedImage对象的Graphics对象
        g.fillRect(0, 0, width, height);// 填充矩形
        g.setFont(new Font("Times New Roman", Font.ROMAN_BASELINE, 18));// 设置字体
        g.setColor(getRandColor(110, 133));// 设置颜色
        // 绘制干扰线
        for (int i = 0; i <= lineSize; i++) {
            drawLine(g);
        }
        // 绘制字符
        String randomString = "";
        for (int i = 1; i <= StringNum; i++) {
            randomString = drawString(g, randomString, i);
            validateDto.setValue(randomString);
        }

        g.dispose();// 释放绘图资源
        ByteArrayOutputStream bs = null;
        try {
            bs = new ByteArrayOutputStream();
            ImageIO.write(image, "png", bs);// 将绘制得图片输出到流
            final String imgsrc = Base64.byteArrayToBase64(bs.toByteArray());
            validateDto.setBase64Str(imgsrc);
        } catch (final Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bs.close();
            } catch (final IOException e) {
                e.printStackTrace();
            } finally {
                bs = null;
            }
        }
        return validateDto;
    }

}

验证码entity 

package com.chinamobile.cmss.dto;

import java.io.Serializable;

/**
 *
 * @ClassName: ValidateDto
 * @Description: 验证码类
 * @author yaohongan
 */
public class ValidateDto implements Serializable {

    private static final long serialVersionUID = 1L;

    private String Base64Str; // Base64 值

    private String value; // 验证码值

    public String getBase64Str() {

        return Base64Str;
    }

    public void setBase64Str(final String base64Str) {

        Base64Str = base64Str;
    }

    public String getValue() {

        return value;
    }

    public void setValue(final String value) {

        this.value = value;
    }
}

发送短信代码 

package com.chinamobile.cmss.share.service.impl;

import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.ServletContext;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;

import com.base.util.mapper.JsonMapper;
import com.chinamobile.cmss.share.entity.CmssDict;
import com.chinamobile.cmss.share.entity.CmssLogAccess;
import com.chinamobile.cmss.share.entity.CmssOperationsUser;
import com.chinamobile.cmss.share.entity.CmssSmsRedisEntity;
import com.chinamobile.cmss.share.entity.PortalUser;
import com.share.utils.ShareJedis;

import freemarker.template.Configuration;
import freemarker.template.Template;
/**
 *
 * @ClassName: BatchSmsService
 * @Description: 批量发送短信
 * @author zhangle
 *
 */
@SuppressWarnings("boxing")
@Service("cmssBatchSmsService")
public class CmssBatchSmsService {
    /**
     * 发送短信验证码
     * @param portalUser
     */
    public void sendSmsValidationCode(final String phone, final String smsCode) {

        final WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        final ServletContext servletContext = webApplicationContext.getServletContext();
        final Configuration cfg = new Configuration();

        cfg.setServletContextForTemplateLoading(servletContext, "/WEB-INF/templates");

        final Map<String, Object> content = new HashMap<String, Object>(16);

        content.put("smsCode", smsCode);
        content.put("smsTime", smsTime);

        Template t;
        try {
            t = cfg.getTemplate("new_user_sms.ftl", "utf-8");
            final StringWriter writer = new StringWriter();

            t.process(content, writer);

            final String smsContent = writer.toString();
            // log.info("=======================smsContent: "+smsContent);
            sendShortMessage(smsContent, Arrays.asList(new String[] { phone }));

        } catch (final Exception e) {
            log.info("用户手机号为[" + phone + "]发送短信失败！", e);
        }

    }
}




weixin_33836223
关注
html手机验证码登录页面代码,htmlunit 模拟登录 数字验证码(示例代码)
weixin_32098487的博客
06-03 1468
使用htmlunit的好处有两点,相比httpclient,htmlunit是对浏览器的模拟,比如你定位一个按钮,就可以执行click()方法,此外不需要象在httpclient中一样编写复杂的代码,如一堆request header还有一大堆请求参数,你只需要填写用户名,密码,验证码即可,就象在使用一个没有界面的浏览器,当然更重要的是htmlunit对js的支持设置极其简单1.添加maven的h...
验证码登录系统
12-26
验证码登录。图形验证码，算术验证码，已连结数据库。
【Spring Security系列】如何用Spring Security集成手机验证码登录？五分钟搞定！
c18213590220的博客
09-17 1726
这篇文章将详细介绍如何利用Spring Security来实现手机验证码的注册和登录功能，帮助你在短时间内搞定这一需求。
手机号验证码登录
t194978的博客
11-11 1077
3.注册or登录，不同的场景，阿里云短信发送，文案不同；且注册时，判断用户是否已经注册，查看用户表是否存在，根据手机号码查询，且存下的手机号码也是。6.缓存验证码，过期时间为60s（过期后验证码输入依然可用），后续验证正确性时，先取缓存，再根据手机号查询表。5.落地，发送记录落表，后续验证正确性，状态包含未使用 已使用，输入正确及标记为已使用。需要手机号，获取验证码除了登录，还可能是注册的场景，不同的类型需要加以区分。1.验证码正确性，先取缓存验证码，再根据手机号查询验证码记录表。1.手机号验证码登录。
unity c#手机短信验证码登陆注册
10-25
unity c#，实现手机号短信验证码登录注册功能，文中已写好代码，可直接替换自己的id和密钥后直接使用，注册地址在文中，内容包含，第三方短信验证码平台的接口代码，已写好，具体验证码调用接口代码，已写好，直接...
JAVA手机发送验证码登录案例
01-22
本案例借助的是秒嘀云平台开发的手机验证码登录案例，输入手机号，点击发送验证码，手机会收到一个验证码，详细教程在压缩包的文档里面，文档里面有我的扣扣，遇到问题可以加我。
Spring Security实现验证码登录功能
08-25
"Spring Security实现验证码登录功能" Spring Security是Java应用程序安全性框架，广泛应用于Web应用程序的身份验证、授权和访问控制。验证码登录功能是Spring Security中的一个重要组件，主要用于防止自动化程序...
在 Spring Security 中定义多种登录方式，比如邮箱、手机验证码登录
xxxzzzqqq_的博客
03-21 3746
自定义认证方式总体来说还是很简单的；需要从头重写的也就三个类，然后就是将其配置到Spring Security 中。如果需要再自定义手机号验证码登录，按照上述流程再走一遍就行。其实也是 copy 一份，然后进行小幅度的修改即可。
登录验证码
09-25
纯小脚本实现了字母+数字登录验证码，随机验证码!
手机短信验证码登录
小米队长的博客
06-12 1007
2、点击发送验证码，弹出防盗刷验证弹框，防盗刷使用第三方服务，具体逻辑参考服务提供方的接口文档。3、通过弹框验证，发送验证码按钮文案改为120秒倒计时。倒计时期间不允许点击。5、验证码有效期为180秒，重新发送后，上个验证码自动失效。①不正确，显示错误提示：验证码错误，请重新输入。1、手机号输入框，默认提示文案：请输入手机号。2、验证码输入框，默认提示文案：请输入验证码。5、点击协议、政策，新开页面，进入对应页面。1、判断时间：输入框有输入数据，失去焦点时。7、点击注册，当前页面打开，进入注册页面。
通过手机号实现验证码登录
weixin_64182439的博客
04-20 630
这是简单的通过验证码实现登录，但是有一个前提要去阿里云注册短信发送功能。
手机验证码登录jmeter
最新发布
10-12
手机验证码登录通常涉及到用户通过短信或应用内置服务接收一次性验证码，然后输入到网站或应用程序中完成身份验证的过程。在JMeter中模拟这种场景，你需要设置一个HTTP请求来发送手机号码获取验证码，并另一个HTTP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值