基于spring boot的邮箱验证码注册功能 - 后端代码

已于 2023-05-16 12:25:14 修改
阅读量2.1k 收藏 7
点赞数 5
文章标签： spring boot java 数据库
于 2023-04-28 16:43:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxwyhzy/article/details/130429179
版权

文章目录

基于spring boot的邮箱验证码注册功能

代码地址

1. 后端项目

1.1 数据库创建

CREATE TABLE `user`  (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '昵称',
  `userAccount` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '登录账号',
  `avatarUrl` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '头像',
  `gender` tinyint(1) NULL DEFAULT NULL COMMENT '性别',
  `userPassword` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '密码',
  `phone` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '电话',
  `email` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '邮箱',
  `userStatus` int NOT NULL DEFAULT 0 COMMENT '用户状态：0正常',
  `createTime` datetime NULL DEFAULT NULL COMMENT '创建时间，数据插入时间',
  `updateTime` datetime NULL DEFAULT NULL COMMENT '更新时间，数据更新时间',
  `isDelete` tinyint NOT NULL DEFAULT 0 COMMENT '是否删除：0未删除',
  `role` int NOT NULL DEFAULT 0 COMMENT '0普通用户：1管理员',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

1.2 项目创建

在这里插入图片描述

在这里插入图片描述

这几个文件都可以删掉
在这里插入图片描述

1.3 前期准备

1.3.1 依赖安装

<!--mysql连接驱动     我的mysql版本是8.0.30-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
</dependency>
<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>
<!--阿里巴巴数据库连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

<!--redis启动依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--fastjson依赖    Redis使用FastJson序列化-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.33</version>
</dependency>

<!--工具类-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

1.3.2 工具类准备

统一响应类+状态码枚举类
@Data
public class Result<T> implements Serializable {
    private Integer code;
    private String msg;
    private T data;

    public Result() {

    }

    public static Result ResultOk(Object data){
        Result result = setCodeEnum(CodeEnum.SUCCESS);
        if(data!=null) {
            result.setData(data);
        }
        return result;
    }
    public static Result ResultOk(){
        Result result = setCodeEnum(CodeEnum.SUCCESS);;
        return result;
    }
    public static Result error(){
        Result result = setCodeEnum(CodeEnum.ERROR);;
        return result;
    }
    public static Result error(String msg){
        Result result = setCodeEnum(CodeEnum.ERROR);
        result.setMsg(msg);
        return result;
    }

    public static Result setCodeEnum(CodeEnum enums){
        Result result = new  Result();
        result.setCode(enums.getCode());
        result.setMsg(enums.getMsg());
        return result;
    }
    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}
public enum CodeEnum {
    // 成功
    SUCCESS(200, "操作成功"),
    // 失败
    ERROR(400,"操作失败");
    int code;
    String msg;

    CodeEnum(int code, String errorMessage) {
        this.code = code;
        this.msg = errorMessage;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}
redis工具类+配置类

使用redis存放 邮箱验证码

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
    {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     * 
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }

    /**
     * 更新redis文章浏览量
     * @param key 哪一个哈希结构
     * @param hKey 哈希表里哪一个数据
     * @param v 更改值
     */
    public void incrementCacheMapValue(String key,String hKey,long v){
        redisTemplate.boundHashOps(key).increment(hKey, v);
    }
}

/**
 * Redis使用FastJson序列化
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
{

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    static
    {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }

    public FastJsonRedisSerializer(Class<T> clazz)
    {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz);
    }


    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

1.4 代码编写

1.4.1 user表相关代码

新建domain包，在domain包中新建entity包再在entity 中创建user实体类

/**
 * (User)表实体类
 * @author makejava
 * @since 2023-04-28 14:23:28
 */
@SuppressWarnings("serial")
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User  {
    // 用户id@TableId
    @TableId(value = "id" ,type = IdType.AUTO)
    private Long id;
    // 昵称
    private String username;
    // 登录账号
    private String useraccount;
    // 头像
    private String avatarurl;
    // 性别
    private Integer gender;
    // 密码
    private String userpassword;
    // 电话
    private String phone;
    // 邮箱
    private String email;
    // 用户状态：0正常
    private Integer userstatus;
    // 创建时间，数据插入时间
    private Date createtime;
    // 更新时间，数据更新时间
    private Date updatetime;
    // 是否删除：0未删除
    private Integer isdelete;
    // 0普通用户：1管理员
    private Integer role;
}

新建mapper包创建UserMapper类

/**
 * (User)表数据库访问层
 *
 * @author makejava
 * @since 2023-04-28 14:23:25
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {

}

新建service和其实现类

/**
 * (User)表服务接口
 *
 * @author makejava
 * @since 2023-04-28 14:23:32
 */
public interface UserService extends IService<User> {
	
}

/**
 * (User)表服务实现类
 *
 * @author makejava
 * @since 2023-04-28 14:23:33
 */
@Service()
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

1.4.2 控制层(controller)

新建controller包新建UserController类,定义用户注册的请求

@RestController // 适用于编写restful风格的api，返回值默认为json类型
@RequestMapping("/user")
public class UserController {
   // 注册
}

@RestController // 适用于编写restful风格的api，返回值默认为json类型
@RequestMapping("/email")
public class EmailController {
    // 发送验证码
}

1.4.3 发送验证码功能实现

1.4.3.1 获取授权码

要实现邮箱服务需要邮箱授权码，QQ邮箱获取方式如下：
在这里插入图片描述

1.4.3.2 配置yml文件
server:
  port: 8888
spring:
  mail:
    host: smtp.qq.com
    protocol: smtp
    default-encoding: UTF-8
    username: 2791517764@qq.com
    password: *********** # 填上面生成的授权码
    test-connection: true
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true
            required: true
    port: 587
1.4.3.3 新建一个数据传输类ToEmail

在domain包下新建dto包,在dto包下创建ToEmail

package com.hzy.usercenter.domain.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
 * @title: ToEmail
 * @Author zxwyhzy
 * @Date: 2023/4/28 14:47
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ToEmail implements Serializable {
    /**
     * 邮件接收方
     */
    private String to;
    /**
     * 邮件主题
     */
    private String subject;
    /**
     * 邮件内容
     */
    private String content;
}
1.4.3.4 新建EmailService和其实现类
public interface EmailService {
    /**
     *  发送验证码
     * @param toEmail 邮箱数据传输类
     * @return
     */
    Result commonEmail(ToEmail toEmail);
}

@Service
public class EmailServiceImpl implements EmailService {
    @Autowired
    private JavaMailSender mailSender;
    @Value("${spring.mail.username}")
    private String from;
    @Autowired
    private UserService userService;
    public Result commonEmail(ToEmail toEmail) {
        // userService.isEmailNull(toEmail) 判断该邮箱是否已注册
        if (userService.isEmailNull(toEmail)) {
            //创建简单邮件消息
            SimpleMailMessage message = new SimpleMailMessage();
            //谁发的
            message.setFrom(from);
            //谁要接收
            message.setTo(toEmail.getTo());
            //邮件标题
            message.setSubject(toEmail.getSubject());
            //邮件内容
            message.setText(toEmail.getContent());
            try {
                mailSender.send(message);

                return Result.ResultOk(toEmail.getTo());
            } catch (MailException e) {
                e.printStackTrace();
                return Result.error("发送失败");
            }
        }
        return Result.error("该邮箱已注册");
    }
}

实现isEmailNull()

public interface UserService extends IService<User> {
    /**
     *  判断邮箱是否注册
     * @return true|false
     */
    boolean isEmailNull(ToEmail toEmail);
}

    @Override
    public boolean isEmailNull(ToEmail toEmail) {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getEmail,toEmail.getTo());
        long count = count(queryWrapper);
        if (count <1 )
            return true;
        return false;
    }
1.4.3.5 修改EmailController
@RestController
@RequestMapping("/mail")
public class EmailController {
    @Autowired
    private RedisCache redisCache;
    @Autowired
    EmailService emailService = new EmailServiceImpl();
    @PostMapping
    public Result SendMail(@RequestBody ToEmail toEmail){
        toEmail.setSubject("注册验证码");
        // RandomStringUtils  commons-lang3引进的工具类
        String yzm = RandomStringUtils.randomNumeric(6);
        toEmail.setContent(yzm);
        redisCache.setCacheObject(toEmail.getTo(),yzm);
        // 验证码6分钟内有效
        redisCache.expire(toEmail.getTo(),60*10);
        return emailService.commonEmail(toEmail);
    }
}
1.4.3.6 测试

在这里插入图片描述

在这里插入图片描述

数据库添加邮箱为2791517764@qq.com的数据在这里插入图片描述
在这里插入图片描述

1.4.4 注册功能实现

1.4.4.1 新建一个请求数据接收类，接收注册数据
/**
 *  接收前端注册参数
 * @title: UserRegisterRequest
 * @Author zxwyhzy
 * @Date: 2023/4/28 15:43
 * @Version 1.0
 */
@Data
public class UserRegisterRequest {
    // 用户名
    private String userAccount;
    // 密码
    private String userPassword;
    // 确认密码
    private String checkPassword;
    // 验证码
    private String code;
    // 邮箱
    private String email;
}
1.4.4.2 UserController添加注册接口
@RestController // 适用于编写restful风格的api，返回值默认为json类型
@RequestMapping("/user")
public class UserController {
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private UserService userService;

    @PostMapping("/register")
    public Result userRegister(@RequestBody UserRegisterRequest user){
        if (null == user) return Result.error("参数不能为空");
        String yzm = redisCache.getCacheObject(user.getEmail());
        if (user.getCode()!=null && user.getCode().equals(yzm)){
            return userService.userRegister(user);
        }
        return Result.error("验证码错误");
    }
}
1.4.4.3 UserService及其实现类实现注册功能
public interface UserService extends IService<User> {
    /**
     *  用户注册
     * @param user 注册参数
     * @return 是否注册功能 或失败原因
     */
    Result userRegister(UserRegisterRequest user);
}

@Service()
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    private static final String SALT = "zy";
    @Override
    public Result userRegister(UserRegisterRequest user) {
        // 虽然前端也会判断，但是有绕过前端直接发送请求的可能
        if (StringUtils.isAnyBlank(user.getUserAccount(),
                user.getUserPassword(),
                user.getCheckPassword())){
            return Result.error("用户名或密码为空");
        }
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUseraccount,user.getUserAccount());
        long count = count(queryWrapper);
        if (count > 0 ) return Result.error("用户名以存在");
        if (user.getUserPassword().equals(user.getCheckPassword())){
            User register = new User();
            register.setUseraccount(user.getUserAccount());
            // 加密
            String password = DigestUtils.md5DigestAsHex((SALT + user.getUserPassword()).getBytes());
            register.setUserpassword(password);
            boolean save = save(register);
            if (!save){
                return Result.error("注册失败");
            }
            return Result.ResultOk("注册成功");
        }
        return Result.error("两次输入的密码不一致");
    }
}
1.4.4.4 测试

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

zyqaq412
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot实现邮箱注册
ljrgtdxh_777的博客
04-17 1897
在BuaaMap的产品设计中，综合考虑安全性、易用性等，用户需以自己的邮箱为唯一标识注册账户。因此，后端必须支持邮箱发送、验证功能来实现这一需求。具体来说，用户在注册我们产品的账号时，需要经过以下流程：在该流程中，后端参与的部分有发送验证码，和处理注册请求时验证码验证。整个邮箱模块实现分为两部分：邮箱Util类、Service类的实现与验证码存储、验证。我的设计思路是Service提供邮件发送功能，而对于项目本身来说，Util调用Service发送具体场景下的验证码邮件。发送验证码后，后端在Redis缓存中
springboot+vue实现招聘平台(系统),邮箱验证码注册验证.zip
03-26
【标题】"springboot+vue实现招聘平台(系统),邮箱验证码注册验证.zip"是一个结合了Spring Boot后端框架和Vue.js前端框架的项目，用于构建一个招聘平台。在这个平台上，用户可以通过邮箱验证来完成注册过程，增加了...
基于SpringBoot实现邮箱验证码注册
kurtosis的博客
06-13 2916
基于SpringBoot实现邮箱验证码注册，向邮箱发送随机验证码， 收到用户输入验证码进行校验完成注册。
SpringBoot 通过邮箱发送验证码
最新发布
yxixiOvo的博客
05-27 247
步骤：登录QQ -->进入邮箱-->设置-->账号-->找到服务状态并开启。欧克，至此通过QQ邮箱发送验证码就完成了。2.点击账号 找到服务 点击开启服务。此为学习成果，如有不足，欢迎补充！通过postman 发送请求。这里直接展示业务层的代码。
springboot实现邮箱验证码功能
YXXXYX的博客
04-08 3685
邮箱验证码是一个常见的功能，常用于邮箱绑定、修改密码等操作上，这里我演示一下如何使用springboot实现验证码的发送功能；这里用qq邮箱进行演示，其他都差不多；
SpringBoot整合邮箱验证码实现用户注册
admin_2022的博客
06-07 1780
SpringBoot整合邮箱验证码实现用户注册
Spring boot 整合邮件实现验证码注册功能
yuluo的博客
10-13 612
效果展示： 邮箱授权码 QQ邮箱为例设置 -> 账户 -> 生成授权码 DTO Service 接口 实现类
spring boot+mybatis学习资源共享平台系统代码
04-20
后端：SpringBoot+Mybatis-Plus+logback+Elasticsearch+Redis+MySQL+Jwt+smtp+阿里云OSS 前端：WebPack+VueJs+Ant Design+axios 2.1 公共成果展示 系统登录账号密码和邮箱验证码均可登录 2.2 超管成果展示 超管主...
Spring boot+vue3+element plus实现后台管理系统
07-04
前后端分离项目，Spring boot作为后端，vue框架实现前端，后端整合swagger3测试工具，jwt实现验证码生成，awt生成图形验证码，整合邮箱验证，使用mybatis-generator自动生成实体类以及mapper，设置有拦截器验证登录...
基于vue+springboot+mybatis+邮箱注册验证+docker实现员工工资系统
06-19
该系统是基于现代Web开发技术栈构建的，主要利用Vue.js作为前端框架，SpringBoot作为后端服务框架，MyBatis作为数据访问层组件，并且整合了邮箱验证功能以及Docker容器化部署。以下是这些技术在系统中的应用及重要性...
SpringBoot项目实现QQ邮箱注册
bianmy1的博客
07-21 541
使用SpringBoot项目实现邮箱发送功能
JAVA后端开发--注册
weixin_41603934的博客
05-11 1252
后端开发： 前三部分已经可以通过接口传递给前端了，对于前端开发工程师而言，他们怎么把这个数据展示，咱们已经不用关注这个细节了。写到最后写到form表单就行了。前后端连接的技术。js或者query，Ajax。 导入基础jar包 5.在properties文件中配置数据库的连接源信息 创建实体类的基类 1.实现一个接口，再定义私有化的属性 2.私有属性的Getter和Setter部分 3.equals() and hashCode()方法自动生成出来 4.toString()方法 创建用户的实体类 需要
Springboot整合Mail进行邮箱验证码注册
吉屋安的博客
09-05 555
ApiResponse是响应结果的数据类型，其中ResponseCode.SUCCESS表示成功状态码，"验证码已发送"是结果消息的内容。这一行是声明一个公共的静态方法（public static method），名称为generateCode，返回类型为字符串（String），其中有一个参数，名称为length，表示生成的验证码的长度。这三行代码设置邮件主题和内容，然后使用调用EmailService的sendMail方法将邮件发送给指定的邮箱(mail.email)，以及验证码的message。
SpringBoot利用邮箱注册(发送验证码)
qq_52288555的博客
12-01 2696
使用邮箱发送验证码功能 提示：本人用的是QQ邮箱,其他邮箱方式类似 文章目录使用邮箱发送验证码功能一、开启POP3/SMTP服务1.进入QQ邮箱,点击设置2.选中账户3.然后一直往下划,找到图片中POP3/SMTP服务,点击开启(注意开启后会收到一个授权码，一定要好好保存，在appliction.properties配置中会用到)二、加入依赖 和 配置application.yml文件1.在pom.xml文件中引入依赖2.application.yml文件加入相关配置三 .创建Mail 控制层 和业务层1
基于SpringBoot的邮箱验证码-以QQ邮箱为例
qq_63704334的博客
06-09 1238
基于springboot框架的qq邮箱验证码发送，操作简单，易上手
实现邮箱注册（JavaWeb）
weixin_48693154的博客
11-17 1827
如何实现邮箱注册用户（JavaWeb）
Springboot实现邮箱验证码注册、找回密码和登录功能
热门推荐
Aiwin的博客
11-08 1万+
Springboot实现邮箱验证码注册、找回密码(三分钟有效)和Cookie免登录、加密记住我功能
【SpringBoot】| 邮箱发送验证码，你会了吗？
狮子也疯狂的博客
03-28 7345
但是对于程序员来说，或许我们更加感兴趣的是如何来实现它，但是一般这种经过三大运营商的操作，都是需要付费的，所以咱们今天来讲一种它的平替——使用QQ邮箱来发送和接收验证码。由于SpringBoot的Starter模块也为此提供了自动化配置，所以在引入了spring-boot-starter-mail依赖之后，会根据配置文件中的内容去创建JavaMailSender实例，因此我们可以直接在需要使用的地方直接@Autowired来引入邮件发送对象。好了，今天的分享结束，咱们下期见。），复制授权码备用。
电商spring boot后端代码
11-28
电商spring boot后端代码是一种用于构建电商网站后台服务的java框架。它基于spring框架，提供了快速开发和部署的能力。通过使用spring boot，开发人员可以快速搭建电商网站的后端系统，实现用户注册登录、商品管理、订单处理、支付结算等功能。 在电商spring boot后端代码中，通常会包含一些核心的模块和功能。比如用户模块，用于管理用户信息和权限控制；商品模块，用于管理商品信息和库存；订单模块，用于处理用户下单和订单状态管理；支付模块，用于接入第三方支付平台实现交易结算；运营模块，用于管理广告推广和促销活动等。 在实际开发中，开发人员会根据电商网站的需求，编写各种业务逻辑和数据处理的代码。比如，实现用户注册时的表单验证和信息存储；实现商品搜索和推荐算法；实现订单状态跟踪和数据统计分析等。 电商spring boot后端代码的优势在于它的高效性和灵活性。开发人员可以利用spring boot的自动配置和依赖管理功能，快速搭建一个稳定、可扩展的后端系统。同时，由于spring boot基于java语言和spring框架，能够很好地支持各种数据库和第三方服务的集成，满足电商网站复杂的业务需求。 总的来说，电商spring boot后端代码是一种适用于快速开发和部署电商网站的java框架，它能够帮助开发人员构建稳定、高效的后台服务，实现电商网站的各种功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值