实现邮箱注册及发送邮件验证码功能

用邮箱注册账号是一个很常见的功能，下面就详细讲讲如何实现。

Step1 前置工作

首先要准备一个邮箱，用作发件人地址，由于是在程序中使用这个邮箱，所以需要做一些设置，才能实现用代码发送邮件的功能。以腾讯企业邮箱为例，首先登录发件人的邮箱，点击「设置」进入如下界面：

往下拖动界面，找到下图红框中的配置，全部勾选上，然后「保存更改」：

在上图中，可以发现在「设置方法」板块下，官方已经对发送服务器作了说明，这些信息很重要，会在代码配置中用到。接下来获取授权码，或者叫「客户端专用密码」，这是邮箱出于安全考虑而生成的一种码，用于替代真正的登录密码在代码中使用，防止密码泄露。腾讯企业邮箱无法直接生成授权码，需要先绑定微信：

绑定微信成功后才会出现「生成新密码」的按钮，点击即可拿到授权码：

以上过程对于其他类型的邮箱也是一样，大同小异，可能设置位置或命名不一样，但是类似的功能都是有的。另外补充一点，就是腾讯企业邮箱的实际登录密码可以在代码中直接用，不需要用授权码，我也是在后续的测试中发现，具体原因还有待研究。

Step2 代码实现

1 引入邮件依赖

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-mail</artifactId>
</dependency>

2 添加邮件配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
spring:
  mail:
    host: smtp.exmail.qq.com
    port: 465
    username: ally@iskyfly.com
    password: ********  # 授权码，也可尝试用登录密码
    protocol: smtp
    default-encoding: UTF-8
    properties:
      mail:
        smtp:
          auth: true
          ssl:
            enable: true
            socketFactory:
              class: com.sun.mail.util.MailSSLSocketFactory
              fallback: false
          starttls:
            enable: true
            required: true

3 编写邮件实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import org.springframework.web.multipart.MultipartFile;

import java.util.Date;

@Data
public class MailVo {

    private String id; // 邮件id
    private String from; // 邮件发送人
    private String to; // 邮件接收人
    private String subject; // 邮件主题
    private String text; // 邮件内容
    private Date sentDate; // 发送时间
    private String cc; // 抄送 carbon copy
    private String bcc; // 密送 blind carbon copy
    private String status; // 状态
    private String error; // 报错信息
    @JsonIgnore
    private MultipartFile[] multipartFiles; // 邮件附件

}

4 编写邮件工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.Date;
import java.util.Objects;

@Service
public class EmailUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(EmailUtils.class);

    @Value("${spring.mail.username}")
    private String emailFrom;

    @Autowired
    private JavaMailSenderImpl mailSenderImpl;

    @Async
    public MailVo sendMail(MailVo mailVo) {
        try {
            // 1.检测邮件
            checkMail(mailVo);
            // 2.构建、发送邮件
            buildAndSendMimeMail(mailVo);
            // 3.保存邮件
            return saveMail(mailVo);
        } catch (Exception e) {
            LOGGER.error("Send mail occurs ex: {}", e.getMessage(), e);
            mailVo.setStatus("fail");
            mailVo.setError(e.getMessage());
            return mailVo;
        }
    }

    // 检测邮件信息
    private void checkMail(MailVo mailVo) {
        if (StringUtils.isEmpty(mailVo.getTo())) {
            throw new RuntimeException("邮件收信人不能为空");
        }
        if (StringUtils.isEmpty(mailVo.getSubject())) {
            throw new RuntimeException("邮件主题不能为空");
        }
        if (StringUtils.isEmpty(mailVo.getText())) {
            throw new RuntimeException("邮件内容不能为空");
        }
    }

    // 构建邮件信息
    private void buildAndSendMimeMail(MailVo mailVo) {
        try {
            // true 表示支持复杂类型
            MimeMessageHelper messageHelper = new MimeMessageHelper(mailSenderImpl.createMimeMessage(), true);
            // 邮件发信人
            messageHelper.setFrom(emailFrom);
            // 邮件收信人
            messageHelper.setTo(mailVo.getTo().split(","));
            // 邮件主题
            messageHelper.setSubject(mailVo.getSubject());
            // 邮件内容
            messageHelper.setText(mailVo.getText(), true);
            // 抄送
            if (!StringUtils.isEmpty(mailVo.getCc())) {
                messageHelper.setCc(mailVo.getCc().split(","));
            }
            // 密送
            if (!StringUtils.isEmpty(mailVo.getBcc())) {
                messageHelper.setCc(mailVo.getBcc().split(","));
            }
            // 添加邮件附件
            if (mailVo.getMultipartFiles() != null) {
                for (MultipartFile multipartFile : mailVo.getMultipartFiles()) {
                    messageHelper.addAttachment(multipartFile.getOriginalFilename(), multipartFile);
                }
            }
            // 发送时间
            if (Objects.nonNull(mailVo.getSentDate())) {
                mailVo.setSentDate(new Date());
                messageHelper.setSentDate(mailVo.getSentDate());
            }
            // 正式发送邮件
            mailSenderImpl.send(messageHelper.getMimeMessage());
            mailVo.setStatus("ok");
        } catch (Exception e) {
            // 发送失败
            LOGGER.error("Build and send mail occurs ex: {}", e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    // 保存邮件
    private MailVo saveMail(MailVo mailVo) {
        // 将邮件保存到数据库...
        return mailVo;
    }
    
    // 生成 6 位的随机验证码
    public String randomCode() {
        StringBuilder str = new StringBuilder();
        Random random = new SecureRandom();
        for (int i = 0; i < 6; i++) {
            str.append(random.nextInt(10));
        }
        return str.toString();
    }

}

格式校验工具类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.shiro.util.StringUtils;

public class ValidatorUtil {

    public static final String ACCOUNT_PATTERN = "^[a-zA-Z](\\S{5,17})$";
    public static final String PASSWORD_PATTERN = "\\S{6,18}";
    public static final String EMAIL_PATTERN = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";

	private ValidatorUtil() {
	}
    
     /**
	 * 校验账号格式
	 */
	public static boolean isAccount(String account) {
		return Pattern.matches(ACCOUNT_PATTERN, account);
	}
    
     /**
	 * 校验密码格式
	 */
	public static boolean isPassword(String password) {
		return Pattern.matches(PASSWORD_PATTERN, password);
	}

	/**
	 * 校验邮箱格式
	 */
	public static boolean isMailbox(String mailbox) {
		if (!StringUtils.hasText(mailbox)) {
			return false;
		}
		return Pattern.matches(EMAIL_PATTERN, mailbox);
	}
}

5 常量定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 登录类型
public static final Integer AUTH_USERNAME = 1; // 用户名授权登录
public static final Integer AUTH_PHONE = 2; // 电话授权登录
public static final Integer AUTH_EMAIL = 3; // 邮箱授权登录
// Redis Key
public static final String REDIS_PHONE_VERIFY_CODE_PERIFX = "app:verifycode:phone:";// 短信验证码Key
public static final String REDIS_EMAIL_VERIFY_CODE_PERIFX = "app:verifycode:email:";// 邮箱验证码Key
// 邮箱验证码类型
public static final String EMAIL_TYPE_LOGIN = "0"; // 登录
public static final String EMAIL_TYPE_REGISTER = "1"; // 注册
public static final String EMAIL_TYPE_FORGET_PASSWORD = "2"; // 忘记密码
public static final String EMAIL_TYPE_CHANGE_PASSWORD = "3"; // 修改密码
public static final String EMAIL_TYPE_BIND_NEW_MAILBOX = "4"; // 绑定新邮箱
public static final String EMAIL_TYPE_UNREGISTER = "5"; // 注销账号

6 Controller 接口

着重看三个接口：/send-email、/register-by-mailbox 和 /verify，其他接口是为了注册、登录流程的完整性而贴上来，清楚来龙去脉才更容易理解，部分代码会因为没引入依赖而报错，但是不影响理解逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
@RestController
@RequestMapping("/account")
public class AccountController {
    
    private static final Logger LOGGER = LoggerFactory.getLogger(AccountController.class);

    @Autowired
	private IUserService userService;
    
	@Autowired
	private ResourceConfig resourceConfig;

	@Autowired
	private RedisTemplate<String, String> redisTemplate;

	@Autowired
	private EmailUtils emailUtils;

	@Autowired
	private IAppUserAuthsService appUserAuthsService;

	@Autowired
	private IAppUserService appUserService;

	/**
	 * 登录
	 */
	@PostMapping("/login")
	public ClientResponse userLogin(@RequestHeader(value = "language", required = false) String language,
									@RequestParam Map<String, String> params) {
		RequestBase request = JSON.parseObject(JSON.toJSONString(params), RequestBase.class);
		LoginResponse response = new LoginResponse();
		String userId = "";

		// 用户名（手机号/邮箱也是放 username 里），密码登陆
		if (StringUtils.isNotBlank(request.getUsername()) && StringUtils.isNotBlank(request.getPassword())) {
			AppUserAuths auth = new AppUserAuths();
			auth.setIdentify(request.getUsername());
			auth.setCredential(EncryptAES.EncoderByMd5(request.getPassword()));
			auth.setIdentifyType(BeanConst.AUTH_USERNAME);
			List<AppUserAuths> authList = appUserAuthsService.selectAppUserAuthsList(auth);
			if (authList.isEmpty()) {
				auth.setIdentifyType(BeanConst.AUTH_PHONE);
				authList = appUserAuthsService.selectAppUserAuthsList(auth);
				if (authList.isEmpty()) {
                    auth.setIdentifyType(BeanConst.AUTH_EMAIL);
                    authList = appUserAuthsService.selectAppUserAuthsList(auth);
                 }
			}
			if (authList.isEmpty()) {
				LOGGER.info("list is null");
				return new ClientResponse(AppConstant.CODE_ENUM.USER_INFO_ERR, language);
			}
			userId = authList.get(0).getUserId();
		}
		if (userId == null) {
			return new ClientResponse(AppConstant.CODE_ENUM.USER_INFO_ERR, language);
		}
		if (StringUtils.isBlank(language)) {
			language = redisTemplate.opsForValue().get(BeanConst.APP_USER_LANGUAGE + userId);
		}
        
		// 查询用户是否存在
		User find = userService.queryUserInfoById(userId);
		if (find == null) {
			LOGGER.info("user info is null, user ID: {}", userId);
			return new ClientResponse(AppConstant.CODE_ENUM.USER_INFO_ERR, language);
		}
		if (find.getLocked() != null && AppConstant.LockType.LOCKED == find.getLocked()) {
			return new ClientResponse(AppConstant.CODE_ENUM.DISABLE_LOGIN, language);
		}
        
		// 判断用户有效信息
		Date date = new Date();
		if (date.compareTo(find.getEffectTime()) < 0) {
			return new ClientResponse(AppConstant.CODE_ENUM.PERMISSION_DENIED.getValue(),
					I18nUtil.get("CLIENT_RESPONSE.USER_NOT_REACHED_EFFECTIVE_TIME", language));
		}
		Calendar instance = Calendar.getInstance();
		instance.setTime(find.getFailureTime());
		if (instance.get(Calendar.YEAR) != 1970 && date.compareTo(find.getFailureTime()) >= 0) {
			return new ClientResponse(AppConstant.CODE_ENUM.PERMISSION_DENIED.getValue(),
					I18nUtil.get("CLIENT_RESPONSE.USER_HAS_EXPIRED", language));
		}

		// 是否需要刷新token
		String token = TokenUtils.makeToken(userId);

		// 填充用户信息
		response.setToken(token);
		response.setOpenid(userId);
		response.setIs_admin("0");

		if (find.getRoleId() != null) {
			response.setIs_admin(BeanConst.ROLE_ID_APP_USER_ROLE_MAPPING.get(find.getRoleId()));
		}
		response.setUsername(find.getAccount());
		response.setNike(find.getUsername());

		// 填充用户头像
		if (find.getAvatar() != null) {
			String avatar = resourceConfig.getImageUploadUrl() + find.getAvatar();
			response.setAvatar(avatar);
		}
		response.setPhone(PhoneUtils.replaceCityCode(find.getTelNum()));
		response.setMailbox(find.getEmail());

		redisTemplate.opsForValue().set(BeanConst.REDIS_ROBOT_USER_INFO + userId, JSON.toJSONString(response));

		return new ClientResponse(AppConstant.CODE_ENUM.SUCCESS, language, response);
	}

	/**
	 * 注册第一步，校验用户名和密码
	 */
	@PostMapping("/verify-username-and-password")
	public ClientResponse verifyUserPhone(@RequestHeader(value = "language", required = false) String language,
										  @RequestParam Map<String, String> params) {
		RequestBase request = JSON.parseObject(JSON.toJSONString(params), RequestBase.class);
		AppUserAuths userAuth = new AppUserAuths();
		if (StringUtils.isNotBlank(request.getUsername())) {
			// 校验账号格式
			if (!ValidatorUtil.isAccount(request.getUsername())) {
				return new ClientResponse(AppConstant.CODE_ENUM.USERNAME_VERIFICATION_FAILED, language);
			}
			// 校验密码格式
			if (!ValidatorUtil.isPassword(request.getPassword())) {
				return new ClientResponse(AppConstant.CODE_ENUM.PASSWORD_VERIFICATION_FAILED, language);
			}
			// 校验账号是否存在
			boolean appCheckAccount = appUserService.appCheckAccount(request.getUsername());
			if (!appCheckAccount) {
				LOGGER.info("account: {} is exist", request.getUsername());
				return new ClientResponse(AppConstant.CODE_ENUM.USERNAME_ALREADY_EXISTS, language);
			}
		}
		return new ClientResponse(AppConstant.CODE_ENUM.SUCCESS, language);
	}

	/**
	 * 校验邮件验证码
	 */
	@PostMapping("/verify")
	public ClientResponse verify(@RequestHeader(value = "language", required = false) String language,
								 @RequestParam Map<String, String> params) {
		RequestBase request = JSON.parseObject(JSON.toJSONString(params), RequestBase.class);
		// 验证码的长度必须是6位
		if (StringUtils.isNotBlank(request.getVerifycode())
                && request.getVerifycode().length() != 6) {
			return new ClientResponse(AppConstant.CODE_ENUM.VERIFY_DIGITS_ERROR, language);
		}
		LOGGER.info("Verify email: {}, type: {}, verifyCode: {}",
                request.getMailbox(), request.getType(), request.getVerifycode());
        
		String type = request.getType();
		if (StringUtils.isNotBlank(request.getMailbox())) {
             if (!verifyCodeInEmail(request.getMailbox(), type, request.getVerifycode())) {
                 return new ClientResponse(AppConstant.CODE_ENUM.VERIFY_ERROR, language);
             }
        }
		return new ClientResponse(AppConstant.CODE_ENUM.SUCCESS, language);
	}

	/**
	 * 发送邮箱验证码
	 */
	@PostMapping("/send-email")
	public ClientResponse sendEmail(@RequestHeader(value = "language", required = false) String language,
									@RequestParam Map<String, String> params) {
		RequestBase request = JSON.parseObject(JSON.toJSONString(params), RequestBase.class);
		String emailTo = request.getMailbox();
		String verifyCode = "";

		if (StringUtils.isNotBlank(emailTo)) {
			if (!ValidatorUtil.isMailbox(emailTo)) {
				return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_PATTERN_FAIL, language);
			}
			if (StringUtils.isBlank(request.getType())) {
				return new ClientResponse(AppConstant.CODE_ENUM.BAD_PARAMETER, language);
			}
			// 登录 和 忘记密码 验证码验证
			if (request.getType().contentEquals(BeanConst.EMAIL_TYPE_LOGIN)
					|| request.getType().contentEquals(BeanConst.EMAIL_TYPE_FORGET_PASSWORD)) {
				AppUserAuths auth = new AppUserAuths();
				auth.setIdentify(emailTo);
				auth.setIdentifyType(BeanConst.AUTH_EMAIL);
				List<AppUserAuths> list = appUserAuthsService.selectAppUserAuthsList(auth);
				if (list.isEmpty()) {
					return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_NOT_EXIST_ERROR, language);
				}
			}
			// 用户注册 修改账号绑定的邮箱
			if (request.getType().contentEquals(BeanConst.EMAIL_TYPE_REGISTER)
					|| request.getType().contentEquals(BeanConst.EMAIL_TYPE_BIND_NEW_MAILBOX)) {
				AppUserAuths auth = new AppUserAuths();
				auth.setIdentify(emailTo);
				auth.setIdentifyType(BeanConst.AUTH_EMAIL);
				List<AppUserAuths> list = appUserAuthsService.selectAppUserAuthsList(auth);
				if (!list.isEmpty()) {
					return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_ALREADY_EXISTS, language);
				}
			}
			// 修改密码,限制只有本机才能发
			if (request.getType().contentEquals(BeanConst.EMAIL_TYPE_CHANGE_PASSWORD)
					|| request.getType().contentEquals(BeanConst.EMAIL_TYPE_UNREGISTER)) {
				if (StringUtils.isBlank(request.getOpenid())) {
					return new ClientResponse(AppConstant.CODE_ENUM.BAD_PARAMETER.getValue(),
							I18nUtil.get("CLIENT_RESPONSE.PLEASE_ENTER_USER_INFORMATION", language));
				}
				AppUserAuths auth = new AppUserAuths();
				auth.setIdentify(emailTo);
				auth.setIdentifyType(BeanConst.AUTH_EMAIL);
				auth.setUserId(request.getOpenid());
				List<AppUserAuths> list = appUserAuthsService.selectAppUserAuthsList(auth);
				if (list.isEmpty()) {
					return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_NOT_BOUND_ACCOUNT, language);
				}
			}
			verifyCode = emailUtils.randomCode();
			redisTemplate.opsForValue().set(BeanConst.REDIS_EMAIL_VERIFY_CODE_PERIFX + emailTo + ":" + request.getType(), verifyCode, 5, TimeUnit.MINUTES);

			MailVo mailVo = new MailVo();
			mailVo.setTo(emailTo);
			mailVo.setSubject("Verification Email of Guo");
			mailVo.setText("Verification code：" + verifyCode);
			if ("fail".equals(emailUtils.sendMail(mailVo).getStatus())) {
				return new ClientResponse(AppConstant.CODE_ENUM.FAILED.getValue(),
						I18nUtil.get("CLIENT_RESPONSE.EMAIL_SEND_FAILURE", language));
			}
		}
		return new ClientResponse(AppConstant.CODE_ENUM.SUCCESS, language, verifyCode);
	}

	/**
	 * 注册第二步，用邮箱注册
	 */
	@PostMapping("/register-by-mailbox")
	public ClientResponse registerByMailbox(@RequestHeader(value = "language", required = false) String language,
											@RequestParam Map<String, String> params) {
		RequestBase request = JSON.parseObject(JSON.toJSONString(params), RequestBase.class);
		if (StringUtils.isBlank(request.getVerifycode())) {
			return new ClientResponse(AppConstant.CODE_ENUM.BAD_PARAMETER, language);
		}
		// 校验账号格式
		if (!ValidatorUtil.isAccount(request.getUsername())) {
			return new ClientResponse(AppConstant.CODE_ENUM.USERNAME_VERIFICATION_FAILED, language);
		}
		// 校验密码格式
		if (!ValidatorUtil.isPassword(request.getPassword())) {
			return new ClientResponse(AppConstant.CODE_ENUM.PASSWORD_VERIFICATION_FAILED, language);
		}

		String mailbox = request.getMailbox();
		// 校验邮箱格式
		if (!ValidatorUtil.isMailbox(mailbox)) {
			return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_PATTERN_FAIL, language);
		}
		// 校验账号是否存在
		boolean appCheckAccount = appUserService.appCheckAccount(request.getUsername());
		if (!appCheckAccount) {
			LOGGER.info("account: {} is exist", request.getUsername());
			return new ClientResponse(AppConstant.CODE_ENUM.ACCOUNT_REGISTERED, language);
		}
		// 校验邮箱是否存在
		AppUserAuths auth = new AppUserAuths();
		auth.setIdentify(mailbox);
		auth.setIdentifyType(BeanConst.AUTH_EMAIL);
		List<AppUserAuths> list = appUserAuthsService.selectAppUserAuthsList(auth);
		if (!list.isEmpty()) {
			return new ClientResponse(AppConstant.CODE_ENUM.EMAIL_ALREADY_EXISTS, language);
		}

		// 验证码长度固定6位
		if (StringUtils.isNotBlank(request.getVerifycode()) && request.getVerifycode().length() != 6) {
			return new ClientResponse(AppConstant.CODE_ENUM.VERIFY_DIGITS_ERROR, language);
		}
		// 验证码是否过期
		if (!verifyCodeInEmail(mailbox, BeanConst.EMAIL_TYPE_REGISTER , request.getVerifycode())) {
			return new ClientResponse(AppConstant.CODE_ENUM.VERIFY_ERROR, language);
		}

		// 用户信息注册
		User user = new User();
		user.setAccount(request.getUsername());
		user.setUsername(request.getUsername());
		user.setPassword(request.getPassword());
		user.setEmail(mailbox);
		user.setRoleId(BeanConst.TOOL_SOFTWARE_ROLE_ID);

		Date date = new Date();
		// 填充生效日期
		user.setEffectTime(new Timestamp(System.currentTimeMillis()));
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.YEAR, 10);
		user.setFailureTime(new Timestamp(calendar.getTimeInMillis()));

		Timestamp time = new Timestamp(System.currentTimeMillis());
		user.setRegisterTime(time);
		user.setLastOnline(time);

		Integer appUserRegister = appUserService.appUserRegister(user);
		if (appUserRegister <= 0) {
			return new ClientResponse(AppConstant.CODE_ENUM.FAILED, language);
		}

		LoginResponse response = new LoginResponse();
		String token = TokenUtils.makeToken(user.getUserId());
		//返回信息给app
		response.setOpenid(user.getUserId());
		response.setToken(token);
		response.setIs_admin("0");
		response.setMailbox(user.getEmail());
		response.setUsername(user.getAccount());

		return new ClientResponse(AppConstant.CODE_ENUM.SUCCESS, language, response);
	}
    
    /**
	 * 验证邮箱验证码是否正确
	 * @param mailbox 地址
	 * @param type 邮箱验证码类型，EMAIL_TYPE_xxx 变量
	 * @param code 验证码
	 */
	private boolean verifyCodeInEmail(String mailbox, String type, String code) {
		LOGGER.info("verifyCodeInEmail type: {}, code: {}, mailbox: {}", type, code, mailbox);
		String emailCode = redisTemplate.opsForValue().get(BeanConst.REDIS_EMAIL_VERIFY_CODE_PERIFX + mailbox + ":" + type);
		if (StringUtils.equals(emailCode, code)) {
			redisTemplate.delete(BeanConst.REDIS_EMAIL_VERIFY_CODE_PERIFX + mailbox + ":" + type);
			return true;
		}
		return false;
	}
	
}

（完）

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

不积跬步<br/><br/>无以至千里<br/><br/>不积小流<br/><br/>无以成江海