Java结合uniapp实现验证码功能的示例详解

 更新时间:2024年07月25日 08:47:29   作者:码农研究僧  
UniApp 是一个基于 Vue.js 的跨平台应用开发框架,允许开发者使用统一的代码库来构建多平台应用,这篇文章将给大家介绍Java结合uniapp实现验证码功能,文中通过详细的代码示例讲解的非常详细,需要的朋友可以参考下

本次的Demo主要以图片验证码的方式输入和接收

初始界面如下:

改造之后的界面如下:

1. Java

引入验证码

<!-- 验证码 -->
<dependency>
    <groupId>com.github.whvcse</groupId>
    <artifactId>easy-captcha</artifactId>
</dependency>

设置验证码的key以及image

下方的redisTemplate 为RedisTemplate<String, Object> redisTemplate

@GetMapping("/oauth/captcha")
public Kv captcha() {
	SpecCaptcha specCaptcha = new SpecCaptcha(130, 48, 5);
	String verCode = specCaptcha.text().toLowerCase();
	String key = StringUtil.randomUUID();
	// 存入redis并设置过期时间为30分钟
	redisTemplate.opsForValue().setEx(CacheNames.CAPTCHA_KEY + key, verCode, Duration.ofMinutes(30));
	// 将key和base64返回给前端
	return Kv.create().set("key", key).set("image", specCaptcha.toBase64());
}

其中Kv为我的工具类,对应的create()其实是new一个对象而已

2. uniapp

验证码处理:

refreshCode 方法用于获取新的验证码图片,并更新 captchaImg
点击验证码图片会触发 refreshCode 方法,用户可以获取新的验证码以便重新输入

登录逻辑:

在 login 方法中,首先检查用户名、密码和验证码是否为空。如果为空,则通过 uni.$u.toast 提示用户
将密码使用 MD5 加密后,与用户名和其他参数一起发送到服务器进行登录验证
登录成功后,使用 uni.$store.commit 保存 token,并存储当前时间到本地存储中,然后跳转到主页面

响应式布局:

根据屏幕的宽高比例调整登录框的位置和宽度,确保在不同设备上都有良好的显示效果

错误处理:

使用 uni.$u.toast 提示用户登录失败的原因,以便可以进行必要的调整

其中的图片还有路径等细节 ,可放置个人的东西

对应的小程序界面如下:

<template>
	<view style="width: 100%; height: 100vh;">
		<image src="../../static/cloud.jpg" :style="topstyle" class="app_content_top"></image>
		<view class="login_box" :style="loginBoxClass">
			<view style="text-align: center; margin-top: 3%; margin-bottom: 2%;">
				<image src="../../static/logo.png" class="logo"></image>
			</view>
			<view class="title"><text>码农研究僧的小程序</text></view>
			<view style="width: 90%; margin-left: 5%;">
				<view class="equipment_input">
					<u--input
						clearable
						v-model="username"
						placeholder="请输入账号"
						prefixIcon="account"
						prefixIconStyle="font-size: 22px; color: #909399"
					></u--input>
				</view>
				<view class="equipment_input">
					<u--input
						clearable
						v-model="password"
						placeholder="请输入密码"
						prefixIcon="lock"
						password
						prefixIconStyle="font-size: 22px; color: #909399"
					></u--input>
				</view>
				<view class="equipment_input">
					<u--input
						clearable
						v-model="captcha"
						placeholder="请输入验证码"
						prefixIcon="account"
						prefixIconStyle="font-size: 22px; color: #909399"
					></u--input>
					<image :src="captchaImg" @click="refreshCode" class="captcha"></image>
				</view>
			</view>
			<view style="text-align: center; margin-top: 5%;">
				<u-button style="width: 90%; margin-left: 5%; margin-bottom: 5%;" type="primary" :plain="true" :hairline="true" text="细边" @click="login">登录</u-button>
			</view>
		</view>
		<view style="text-align: center; margin-top: 70%;">
			<text>Copyright 2024 - 码农研究僧.</text>
		</view>
	</view>
</template>

js方法如下:

<script>
	import w_md5 from "../../js_sdk/zww-md5/w_md5.js";
	import { getCaptcha } from "../../api/auth.js";
	
	export default {
		data() {
			return {
				captchaImg: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
				captcha: '',
				username: '',
				password: '',
				topstyle: {
					height: 0,
				},
				loginBoxClass: {},
			};
		},
		created() {
			this.refreshCode();
		},
		mounted() {
			this.topstyle.height = uni.getSystemInfoSync().screenHeight + 'px';
			if (uni.getSystemInfoSync().screenWidth > uni.getSystemInfoSync().screenHeight) {
				this.loginBoxClass = {
					'margin-top': '5%',
					'width': '60%',
					'margin-left': '20%',
				};
			}
		},
		methods: {
			refreshCode() {
				getCaptcha().then(res => {
					this.captchaImg = res.data.image;
				});
			},
			login() {
				if (!this.username) {
					uni.$u.toast('请输入账号!');
					return;
				}
				if (!this.password) {
					uni.$u.toast('请输入密码!');
					return;
				}
				if (!this.captcha) {
					uni.$u.toast('请输入验证码!');
					return;
				}
				const password = w_md5.hex_md5_32(this.password);
				uni.$u.http.post('/manong/oauth/token', {
					grant_type: 'password',
					username: this.username,
					password: password,
					scope: 'all',
					tenantId: '000000'
				}, {
					header: {
						'Content-Type': 'application/x-www-form-urlencoded',
						'Tenant-Id': '000000'
					}
				}).then(res => {
					const data = res.data;
					uni.$store.commit('updateToken', data);
					uni.setStorageSync('tokenDateTime', new Date().getTime());
					uni.$u.toast('登录成功!');
					uni.switchTab({
						url: "../index/index",
					});
				}).catch(err => {
					uni.$u.toast('登录失败,请重试!');
				});
			}
		}
	};
</script>

布局如下:

<style lang="scss" scoped>
	.app_content_top {
		z-index: -1;
		position: absolute;
		top: 0;
		left: 0;
		width: 100%;
		height: 100vh;
	}
	.login_box {
		border-radius: 2%;
		box-shadow: -4px 5px 10px rgba(0, 0, 0, 0.5);
		background-color: $uni-bg-color;
		width: 90%;
		margin-top: 30%;
		margin-left: 5%;
	}
	.title {
		font-size: $uni-img-size-base;
		text-align: center;
		margin-top: 2%;
		margin-bottom: 2%;
	}
	.equipment_input {
		margin-top: 1%;
		margin-bottom: 1%;
		border-bottom: 1px solid #d1d1d1;
	}
	.logo {
		left: 50%;
		transform: translateX(-50%);
		width: 200rpx;
		height: 200rpx;
		border-radius: 50%;
		background-color: #eeeeee;
	}
	.captcha {
		height: 150rpx;
	}
</style>

补充两个引入的js文件

获取后端验证码的js文件:

const http = uni.$u.http
export const getCaptcha = () => http.get('/manong/oauth/captcha')

md5加密

let w_md5 = {}
function hex_md5(string,bit) {
    function md5_RotateLeft(lValue, iShiftBits) {
        return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
    }
    function md5_AddUnsigned(lX, lY) {
        var lX4, lY4, lX8, lY8, lResult;
        lX8 = (lX & 0x80000000);
        lY8 = (lY & 0x80000000);
        lX4 = (lX & 0x40000000);
        lY4 = (lY & 0x40000000);
        lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
        if (lX4 & lY4) {
            return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
        }
        if (lX4 | lY4) {
            if (lResult & 0x40000000) {
                return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
            } else {
                return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
            }
        } else {
            return (lResult ^ lX8 ^ lY8);
        }
    }
    function md5_F(x, y, z) {
        return (x & y) | ((~x) & z);
    }
    function md5_G(x, y, z) {
        return (x & z) | (y & (~z));
    }
    function md5_H(x, y, z) {
        return (x ^ y ^ z);
    }
    function md5_I(x, y, z) {
        return (y ^ (x | (~z)));
    }
    function md5_FF(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_GG(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_HH(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_II(a, b, c, d, x, s, ac) {
        a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
        return md5_AddUnsigned(md5_RotateLeft(a, s), b);
    };
    function md5_ConvertToWordArray(string) {
        var lWordCount;
        var lMessageLength = string.length;
        var lNumberOfWords_temp1 = lMessageLength + 8;
        var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
        var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
        var lWordArray = Array(lNumberOfWords - 1);
        var lBytePosition = 0;
        var lByteCount = 0;
        while (lByteCount < lMessageLength) {
            lWordCount = (lByteCount - (lByteCount % 4)) / 4;
            lBytePosition = (lByteCount % 4) * 8;
            lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
            lByteCount++;
        }
        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
        lBytePosition = (lByteCount % 4) * 8;
        lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
        lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
        lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
        return lWordArray;
    };
    function md5_WordToHex(lValue) {
        var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
        for (lCount = 0; lCount <= 3; lCount++) {
            lByte = (lValue >>> (lCount * 8)) & 255;
            WordToHexValue_temp = "0" + lByte.toString(16);
            WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
        }
        return WordToHexValue;
    };
    function md5_Utf8Encode(string) {
        string = string.replace(/\r\n/g, "\n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
            var c = string.charCodeAt(n);
            if (c < 128) {
                utftext += String.fromCharCode(c);
            } else if ((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            } else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }
        }
        return utftext;
    };
    var x = Array();
    var k, AA, BB, CC, DD, a, b, c, d;
    var S11 = 7, S12 = 12, S13 = 17, S14 = 22;
    var S21 = 5, S22 = 9, S23 = 14, S24 = 20;
    var S31 = 4, S32 = 11, S33 = 16, S34 = 23;
    var S41 = 6, S42 = 10, S43 = 15, S44 = 21;
    string = md5_Utf8Encode(string);
    x = md5_ConvertToWordArray(string);
    a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
    for (k = 0; k < x.length; k += 16) {
        AA = a; BB = b; CC = c; DD = d;
        a = md5_FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
        d = md5_FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
        c = md5_FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
        b = md5_FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
        a = md5_FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
        d = md5_FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
        c = md5_FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
        b = md5_FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
        a = md5_FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
        d = md5_FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
        c = md5_FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
        b = md5_FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
        a = md5_FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
        d = md5_FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
        c = md5_FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
        b = md5_FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
        a = md5_GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
        d = md5_GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
        c = md5_GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
        b = md5_GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
        a = md5_GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
        d = md5_GG(d, a, b, c, x[k + 10], S22, 0x2441453);
        c = md5_GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
        b = md5_GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
        a = md5_GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
        d = md5_GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
        c = md5_GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
        b = md5_GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
        a = md5_GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
        d = md5_GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
        c = md5_GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
        b = md5_GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
        a = md5_HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
        d = md5_HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
        c = md5_HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
        b = md5_HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
        a = md5_HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
        d = md5_HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
        c = md5_HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
        b = md5_HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
        a = md5_HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
        d = md5_HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
        c = md5_HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
        b = md5_HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
        a = md5_HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
        d = md5_HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
        c = md5_HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
        b = md5_HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
        a = md5_II(a, b, c, d, x[k + 0], S41, 0xF4292244);
        d = md5_II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
        c = md5_II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
        b = md5_II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
        a = md5_II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
        d = md5_II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
        c = md5_II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
        b = md5_II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
        a = md5_II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
        d = md5_II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
        c = md5_II(c, d, a, b, x[k + 6], S43, 0xA3014314);
        b = md5_II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
        a = md5_II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
        d = md5_II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
        c = md5_II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
        b = md5_II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
        a = md5_AddUnsigned(a, AA);
        b = md5_AddUnsigned(b, BB);
        c = md5_AddUnsigned(c, CC);
        d = md5_AddUnsigned(d, DD);
    }
    if(bit==32){
        return (md5_WordToHex(a) + md5_WordToHex(b) + md5_WordToHex(c) + md5_WordToHex(d)).toLowerCase();
    }
    return (md5_WordToHex(b) + md5_WordToHex(c)).toLowerCase();
}
//16位小写
w_md5.hex_md5_16 = function (string) { 
	return hex_md5(string,16); 
}
//16位大写
w_md5.hex_md5_16Upper = function (string) { 
	return  hex_md5(string,16).toUpperCase(); 
}
//32位小写
w_md5.hex_md5_32 = function (string) { 
	return hex_md5(string,32); 
}
//32位大写
w_md5.hex_md5_32Upper = function (string) { 
	return hex_md5(string,32).toUpperCase(); 
}
export default w_md5

到此这篇关于Java结合uniapp实现验证码功能的示例详解的文章就介绍到这了,更多相关Java uniapp验证码内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • Java数据结构之KMP算法详解以及代码实现

    Java数据结构之KMP算法详解以及代码实现

    KMP算法是一种改进的字符串匹配算法,核心是利用之前的匹配失败时留下的信息,选择最长匹配长度直接滑动,从而减少匹配次数。本文主要介绍了KMP算法的原理与实现,需要的可以参考一下
    2022-12-12
  • Classloader隔离技术在业务监控中的应用详解

    Classloader隔离技术在业务监控中的应用详解

    这篇文章主要为大家介绍了Classloader隔离技术在业务监控中的应用详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-08-08
  • servlet实现用户登录小程序

    servlet实现用户登录小程序

    这篇文章主要为大家详细介绍了servlet实现用户登录的小程序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-05-05
  • Java Red5服务器实现流媒体视频播放

    Java Red5服务器实现流媒体视频播放

    这篇文章主要介绍了Java Red5服务器实现流媒体视频播放,对视频播放感兴趣的同学,可以参考下
    2021-04-04
  • mybatis plus常用注解的具体使用

    mybatis plus常用注解的具体使用

    本文主要介绍了mybatis plus常用注解的具体使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-04-04
  • Java常量池详解

    Java常量池详解

    下面小编就为大家带来一篇浅谈java常量池。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2021-09-09
  • Java 实现定时任务的三种方法

    Java 实现定时任务的三种方法

    这篇文章主要介绍了Java 实现定时任务的三种方法,帮助大家更好的理解和学习使用Java,感兴趣的朋友可以了解下
    2021-03-03
  • Mybatis的核心配置文件使用方法

    Mybatis的核心配置文件使用方法

    Mybatis的核心配置文件有两个,一个是全局配置文件,它包含了会深深影响Mybatis行为的设置和属性信息;一个是映射文件,它很简单,让用户能更专注于SQL代码,本文主要介绍了Mybatis的核心配置文件使用方法,感兴趣的可以了解一下
    2023-11-11
  • @RequestBody时第二个字母大写,映射不到的解决

    @RequestBody时第二个字母大写,映射不到的解决

    这篇文章主要介绍了@RequestBody时第二个字母大写,映射不到的解决方式,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-07-07
  • IDEA配置jdk环境变量的方法

    IDEA配置jdk环境变量的方法

    这篇文章主要介绍了IDEA配置jdk环境变量的方法,本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-04-04

最新评论