美食社交APP项目--用户注册

最新推荐文章于 2024-07-04 14:45:53 发布
最新推荐文章于 2024-07-04 14:45:53 发布
阅读量111 收藏
点赞数
分类专栏： 美食社交项目(Java微服务) Java实战项目 JAVA 文章标签： 美食 redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kaka_csdn14/article/details/130592035
版权

写在开局 : 本篇文章 和 美食社交的认证授权中心同步, 实现简单功能:
[用户登录与注册], 同时附上认证授权的文章地址:认证授权文章链接

1. 发送验证码

1.2 Redis 配置类
package com.itkaka.diners.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisTemplateConfiguration {

    /**
     * redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置key和value的序列化规则
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}
1.3 公共枚举类
package com.itkaka.commons.constant;

import lombok.Getter;

@Getter
public enum RedisKeyConstant {

    verify_code("verify_code:", "验证码"),

    private String key;
    private String desc;

    RedisKeyConstant(String key, String desc) {
        this.key = key;
        this.desc = desc;
    }

}
1.4 Service业务层代码
package com.itkaka.diners.service;

import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.itkaka.commons.constant.RedisKeyConstant;
import com.itkaka.commons.utils.AssertUtil;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * 发送验证码业务逻辑层
 */
@Service
public class SendVerifyCodeService {

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 发送验证码
     *
     * @param phone
     */
    public void send(String phone) {
        // 检查非空
        AssertUtil.isNotEmpty(phone, "手机号不能为空");
        // 根据手机号查询是否已生成验证码，已生成直接返回
        if (!checkCodeIsExpired(phone)) {
            return;
        }
        // 生成 6 位验证码
        String code = RandomUtil.randomNumbers(6);
        // 调用短信服务发送短信（忽略）
        // 发送成功，将 code 保存到 Redis，失效时间 60s
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        redisTemplate.opsForValue().set(key, code, 60, TimeUnit.SECONDS);
    }

    /**
     * 根据手机号查询是否已生成验证码
     *
     * @param phone
     * @return
     */
    private boolean checkCodeIsExpired(String phone) {
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        String code = redisTemplate.opsForValue().get(key);
        return StrUtil.isBlank(code) ? true : false;
    }

    /**
     * 根据手机号获取验证码
     *
     * @param phone
     * @return
     */
    public String getCodeByPhone(String phone) {
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        return redisTemplate.opsForValue().get(key);
    }

}
1.5 Controller控制层代码
package com.itkaka.diners.controller;

import com.itkaka.commons.model.domain.ResultInfo;
import com.itkaka.commons.utils.ResultInfoUtil;
import com.itkaka.diners.service.SendVerifyCodeService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * 发送验证码控制层
 */
@RestController
public class SendVerifyCodeController {

    @Resource
    private HttpServletRequest request;

    @Resource
    private SendVerifyCodeService sendVerifyCodeService;

    /**
     * 发送验证码
     *
     * @param phone
     * @return
     */
    @GetMapping("send")
    public ResultInfo<String> send(String phone) {
        sendVerifyCodeService.send(phone);
        return ResultInfoUtil.buildSuccess("发送成功", request.getServletPath());
    }

}
1.6 网关设置

白名单放行发送验证码接口

server:
  port: 80 # 端口

spring:
  application:
    name: fs_gateway # 应用名
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启配置注册中心进行路由功能
          lower-case-service-id: true # 将服务名称转小写
      routes:
        - id: fs_diners
          uri: lb://fs_diners
          predicates:
            - Path=/diners/**
          filters:
            - StripPrefix=1

        - id: fs_oauth
          uri: lb://fs_oauth
          predicates:
            - Path=/auth/**
          filters:
            - StripPrefix=1



secure:
  ignore:
    urls: # 配置白名单路径
      - /actuator/**
      - /auth/oauth/**
      - /diners/signin
      - /diners/send

# 配置 Eureka Server 注册中心
eureka:
  instance:
    # 开启 ip 注册
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${server.port}
  client:
    service-url:
      defaultZone: http://localhost:8090/eureka/

# 配置日志
logging:
  pattern:
    console: '%d{2100-01-01 13:14:00.666} [%thread] %-5level %logger{50} - %msg%n'
1.7 测试

访问：http://localhost/diners/send?phone=12311112222
返回结果：

{
  "code": 1,
  "message": "Successful.",
  "path": "发送成功",
  "data": "/send"
}

image.png

2. 注册

2.1 是否已注册
2.1.1 Mapper持久层
package com.itkaka.diners.mapper;

import com.itkaka.commons.model.dto.DinersDTO;
import com.itkaka.commons.model.pojo.Diners;
import com.itkaka.commons.model.vo.ShortDinerInfo;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 食客 Mapper
 */
public interface DinersMapper {

    /**
     * 根据手机号查询食客信息
     *
     * @param phone
     * @return
     */
    @Select("select id, username, phone, email, is_valid " +
            " from t_diners where phone = #{phone}")
    Diners selectByPhone(@Param("phone") String phone);

    /**
     * 根据用户名查询食客信息
     *
     * @param username
     * @return
     */
    @Select("select id, username, phone, email, is_valid " +
            " from t_diners where username = #{username}")
    Diners selectByUsername(@Param("username") String username);

    /**
     * 新增食客信息
     *
     * @param dinersDTO
     * @return
     */
    @Insert("insert into " +
            " t_diners (username, password, phone, roles, is_valid, create_date, update_date) " +
            " values (#{username}, #{password}, #{phone}, \"ROLE_USER\", 1, now(), now())")
    int save(DinersDTO dinersDTO);

    /**
     * 根据 ID 集合查询食客信息
     *
     * @param ids
     * @return
     */
    @Select("<script> " +
            " select id, nickname, avatar_url from t_diners " +
            " where is_valid = 1 and id in " +
            " <foreach item='id' collection='ids' open='(' separator=',' close=')'> " +
            " #{id} " +
            " </foreach> " +
            " </script>")
    List<ShortDinerInfo> findByIds(@Param("ids") String[] ids);

}
2.1.2 Service
package com.itkaka.diners.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.crypto.digest.DigestUtil;
import com.itkaka.commons.constant.ApiConstant;
import com.itkaka.commons.model.domain.ResultInfo;
import com.itkaka.commons.model.dto.DinersDTO;
import com.itkaka.commons.model.pojo.Diners;
import com.itkaka.commons.model.vo.ShortDinerInfo;
import com.itkaka.commons.utils.AssertUtil;
import com.itkaka.commons.utils.ResultInfoUtil;
import com.itkaka.diners.config.OAuthClientConfiguration;
import com.itkaka.diners.config.OAuthClientConfiguration;
import com.itkaka.diners.mapper.DinersMapper;
import com.itkaka.diners.model.domain.OAuthDinerInfo;
import com.itkaka.diners.model.vo.LoginDinerInfo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.http.client.support.BasicAuthenticationInterceptor;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * 食客服务业务逻辑层
 */
@Service
public class DinersService {

    @Resource
    private RestTemplate restTemplate;

    @Value("${service.name.fs_oauth-server}")
    private String oauthServerName;

    @Resource
    private OAuthClientConfiguration oAuthClientConfiguration;

    @Resource
    private DinersMapper dinersMapper;

    @Resource
    private com.itkaka.diners.service.SendVerifyCodeService sendVerifyCodeService;

    /**
     * 登录
     *
     * @param account  账号信息：用户名或手机或邮箱
     * @param password 密码
     * @param path     请求路径
     * @return
     */
    public ResultInfo signIn(String account, String password, String path) {
        // 参数校验
        AssertUtil.isNotEmpty(account, "请输入登录账户");
        AssertUtil.isNotEmpty(password, "请输入登录密码");
        // 构建请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        // 构建请求体
        MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
        body.add("username", account);
        body.add("password", password);
        body.setAll(BeanUtil.beanToMap(oAuthClientConfiguration));
        // 设置Authorization
        HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(body, headers);
        // 设置BasicAuthorization
        restTemplate.getInterceptors().add(
                new BasicAuthenticationInterceptor(oAuthClientConfiguration.getClientId(),
                        oAuthClientConfiguration.getSecret())
        );
        // 发送请求
        ResponseEntity<ResultInfo> result = restTemplate.postForEntity(oauthServerName + "oauth/token",
                entity, ResultInfo.class);
        // 处理返回结果
        AssertUtil.isTrue(result.getStatusCode() != HttpStatus.OK, "登录失败！");
        ResultInfo resultInfo = result.getBody();
        if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
            // 登录失败
            resultInfo.setData(resultInfo.getMessage());
            return resultInfo;
        }
        OAuthDinerInfo dinerInfo = BeanUtil.fillBeanWithMap((LinkedHashMap) resultInfo.getData(),
                new OAuthDinerInfo(), false);
        LoginDinerInfo loginDinerInfo = new LoginDinerInfo();
        loginDinerInfo.setToken(dinerInfo.getAccessToken());
        loginDinerInfo.setNickname(dinerInfo.getNickname());
        loginDinerInfo.setAvatarUrl(dinerInfo.getAvatarUrl());
        return ResultInfoUtil.buildSuccess(path, loginDinerInfo);
    }

    /**
     * 校验手机号是否已注册
     *
     * @param phone
     */
    public void checkPhoneIsRegistered(String phone) {
        AssertUtil.isNotEmpty(phone, "手机号不能为空");
        Diners diners = dinersMapper.selectByPhone(phone);
        AssertUtil.isTrue(diners == null, "该手机号未注册");
        AssertUtil.isTrue(diners.getIsValid() == 0, "该用户已锁定，请先解锁");
    }

    /**
     * 用户注册
     *
     * @param dinersDTO
     * @param path
     * @return
     */
    public ResultInfo register(DinersDTO dinersDTO, String path) {
        // 参数非空校验
        String username = dinersDTO.getUsername();
        AssertUtil.isNotEmpty(username, "请输入用户名");
        String password = dinersDTO.getPassword();
        AssertUtil.isNotEmpty(username, "请输入密码");
        String phone = dinersDTO.getPhone();
        AssertUtil.isNotEmpty(username, "请输入手机号");
        String verifyCode = dinersDTO.getVerifyCode();
        AssertUtil.isNotEmpty(username, "请输入验证码");
        // 获取验证码
        String code = sendVerifyCodeService.getCodeByPhone(phone);
        // 验证码是否已过期
        AssertUtil.isNotEmpty(code, "验证码已过期，请重新发送");
        // 校验验证码一致性
        AssertUtil.isTrue(!dinersDTO.getVerifyCode().equals(code),
                "验证码不一致，请重新输入");
        // 验证用户名是否已注册
        Diners diners = dinersMapper.selectByUsername(username.trim());
        AssertUtil.isTrue(diners != null, "用户名已存在，请重新输入");
        // 注册
        // 密码加密
        dinersDTO.setPassword(DigestUtil.md5Hex(password.trim()));
        dinersMapper.save(dinersDTO);
        // 自动登录
        return signIn(username.trim(), password.trim(), path);
    }

    /**
     * 根据食客 ID 集合查询食客信息
     *
     * @param ids 主键 id 集合，多个以逗号分隔，逗号之间不用空格
     * @return
     */
    public List<ShortDinerInfo> findByIds(String ids) {
        AssertUtil.isNotEmpty(ids);
        String[] idArr = ids.split(",");
        List<ShortDinerInfo> dinerInfos = dinersMapper.findByIds(idArr);
        return dinerInfos;
    }

}
2.1.3 Controller
package com.itkaka.diners.controller;

import com.itkaka.commons.model.domain.ResultInfo;
import com.itkaka.commons.model.dto.DinersDTO;
import com.itkaka.commons.model.vo.ShortDinerInfo;
import com.itkaka.commons.utils.ResultInfoUtil;
import com.itkaka.diners.service.DinersService;
import io.swagger.annotations.Api;
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.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * 食客服务控制层
 */
@RestController
@Api(tags = "食客相关接口")
public class DinersController {

    @Resource
    private DinersService dinersService;

    @Resource
    private HttpServletRequest request;

    /**
     * 登录
     *
     * @param account
     * @param password
     * @return
     */
    @GetMapping("signin")
    public ResultInfo signIn(String account, String password) {
        return dinersService.signIn(account, password, request.getServletPath());
    }

    /**
     * 校验手机号是否已注册
     *
     * @param phone
     * @return
     */
    @GetMapping("checkPhone")
    public ResultInfo checkPhone(String phone) {
        dinersService.checkPhoneIsRegistered(phone);
        return ResultInfoUtil.buildSuccess(request.getServletPath());
    }

    /**
     * 用户注册
     *
     * @param dinersDTO
     * @return
     */
    @PostMapping("register")
    public ResultInfo register(@RequestBody DinersDTO dinersDTO) {
        return dinersService.register(dinersDTO, request.getServletPath());
    }

    /**
     * 根据食客 ID 集合查询食客信息
     *
     * @param ids 主键 id 集合，多个以逗号分隔，逗号之间不用空格
     * @return
     */
    @GetMapping("findByIds")
    public ResultInfo<List<ShortDinerInfo>> findByIds(String ids) {
        List<ShortDinerInfo> dinerInfos = dinersService.findByIds(ids);
        return ResultInfoUtil.buildSuccess(request.getServletPath(), dinerInfos);
    }

}
2.1.4 网关配置

放行校验手机号接口

secure:
ignore:
 urls: # 配置白名单路径
  - /actuator/**
  - /auth/oauth/**
  - /diners/signin
  - /diners/send
  - /diners/checkPhone

测试
访问：http://localhost/diners/checkPhone?phone=12311112222
返回结果（已注册）：

{
  "code": 1,
  "message": "Successful.",
  "path": "/checkPhone",
  "data": null
}

返回结果 （未注册）

{
  "timestamp": "2020-11-15T10:16:23.815+00:00",
  "status": 500,
  "error": "Internal Server Error",
  "message": "",
  "path": "/checkPhone"
}
2.2 全局异常处理
package com.itkaka.diners.handler;

import com.itkaka.commons.exception.ParameterException;
import com.itkaka.commons.model.domain.ResultInfo;
import com.itkaka.commons.utils.ResultInfoUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;

@RestControllerAdvice // 将输出的内容写入 ResponseBody 中
@Slf4j
public class GlobalExceptionHandler {

    @Resource
    private HttpServletRequest request;

    @ExceptionHandler(ParameterException.class)
    public ResultInfo<Map<String, String>> handlerParameterException(ParameterException ex) {
        String path = request.getRequestURI();
        ResultInfo<Map<String, String>> resultInfo =
                ResultInfoUtil.buildError(ex.getErrorCode(), ex.getMessage(), path);
        return resultInfo;
    }

    @ExceptionHandler(Exception.class)
    public ResultInfo<Map<String, String>> handlerException(Exception ex) {
        log.info("未知异常：{}", ex);
        String path = request.getRequestURI();
        ResultInfo<Map<String, String>> resultInfo = ResultInfoUtil.buildError(path);
        return resultInfo;
    }

}

测试

{
  "code": 0,
  "message": "该手机号未注册",
  "path": "/checkPhone",
  "data": null
}
2.3 完成注册
2.3.1 DTO (数据传输对象)
package com.itkaka.commons.model.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

@Getter
@Setter
@ApiModel(description = "注册用户信息")
public class DinersDTO implements Serializable {

    @ApiModelProperty("用户名")
    private String username;
    @ApiModelProperty("密码")
    private String password;
    @ApiModelProperty("手机号")
    private String phone;
    @ApiModelProperty("验证码")
    private String verifyCode;
    
}
2.3.2 Mapper


    /**
     * 根据用户名查询食客信息
     */
    @Select("select id, username, phone, email, is_valid " +
            " from t_diners where username = #{username}")
    Diners selectByUsername(@Param("username") String username);

    /**
     * 新增食客信息
     */
    @Insert("insert into " +
            " t_diners (username, password, phone, roles, is_valid, create_date, update_date) " +
            " values (#{username}, #{password}, #{phone}, \"ROLE_USER\", 1, now(), now())")
    int save(DinersDTO dinersDTO);
2.3.3 Service

SendVerifyCodeService.java

package com.itkaka.diners.service;

import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.itkaka.commons.constant.RedisKeyConstant;
import com.itkaka.commons.utils.AssertUtil;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * 发送验证码业务逻辑层
 */
@Service
public class SendVerifyCodeService {

    @Resource
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 发送验证码
     *
     * @param phone
     */
    public void send(String phone) {
        // 检查非空
        AssertUtil.isNotEmpty(phone, "手机号不能为空");
        // 根据手机号查询是否已生成验证码，已生成直接返回
        if (!checkCodeIsExpired(phone)) {
            return;
        }
        // 生成 6 位验证码
        String code = RandomUtil.randomNumbers(6);
        // 调用短信服务发送短信（忽略）
        // 发送成功，将 code 保存到 Redis，失效时间 60s
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        redisTemplate.opsForValue().set(key, code, 60, TimeUnit.SECONDS);
    }

    /**
     * 根据手机号查询是否已生成验证码
     *
     * @param phone
     * @return
     */
    private boolean checkCodeIsExpired(String phone) {
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        String code = redisTemplate.opsForValue().get(key);
        return StrUtil.isBlank(code) ? true : false;
    }

    /**
     * 根据手机号获取验证码
     *
     * @param phone
     * @return
     */
    public String getCodeByPhone(String phone) {
        String key = RedisKeyConstant.verify_code.getKey() + phone;
        return redisTemplate.opsForValue().get(key);
    }

}

DinersService.java

package com.itkaka.diners.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.crypto.digest.DigestUtil;
import com.itkaka.commons.constant.ApiConstant;
import com.itkaka.commons.model.domain.ResultInfo;
import com.itkaka.commons.model.dto.DinersDTO;
import com.itkaka.commons.model.pojo.Diners;
import com.itkaka.commons.model.vo.ShortDinerInfo;
import com.itkaka.commons.utils.AssertUtil;
import com.itkaka.commons.utils.ResultInfoUtil;
import com.itkaka.diners.config.OAuthClientConfiguration;
import com.itkaka.diners.config.OAuthClientConfiguration;
import com.itkaka.diners.mapper.DinersMapper;
import com.itkaka.diners.model.domain.OAuthDinerInfo;
import com.itkaka.diners.model.vo.LoginDinerInfo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.http.client.support.BasicAuthenticationInterceptor;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * 食客服务业务逻辑层
 */
@Service
public class DinersService {

    @Resource
    private RestTemplate restTemplate;

    @Value("${service.name.fs_oauth-server}")
    private String oauthServerName;

    @Resource
    private OAuthClientConfiguration oAuthClientConfiguration;

    @Resource
    private DinersMapper dinersMapper;

    @Resource
    private com.itkaka.diners.service.SendVerifyCodeService sendVerifyCodeService;

    /**
     * 登录
     *
     * @param account  账号信息：用户名或手机或邮箱
     * @param password 密码
     * @param path     请求路径
     * @return
     */
    public ResultInfo signIn(String account, String password, String path) {
        // 参数校验
        AssertUtil.isNotEmpty(account, "请输入登录账户");
        AssertUtil.isNotEmpty(password, "请输入登录密码");
        // 构建请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        // 构建请求体
        MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
        body.add("username", account);
        body.add("password", password);
        body.setAll(BeanUtil.beanToMap(oAuthClientConfiguration));
        // 设置Authorization
        HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(body, headers);
        // 设置BasicAuthorization
        restTemplate.getInterceptors().add(
                new BasicAuthenticationInterceptor(oAuthClientConfiguration.getClientId(),
                        oAuthClientConfiguration.getSecret())
        );
        // 发送请求
        ResponseEntity<ResultInfo> result = restTemplate.postForEntity(oauthServerName + "oauth/token",
                entity, ResultInfo.class);
        // 处理返回结果
        AssertUtil.isTrue(result.getStatusCode() != HttpStatus.OK, "登录失败！");
        ResultInfo resultInfo = result.getBody();
        if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
            // 登录失败
            resultInfo.setData(resultInfo.getMessage());
            return resultInfo;
        }
        OAuthDinerInfo dinerInfo = BeanUtil.fillBeanWithMap((LinkedHashMap) resultInfo.getData(),
                new OAuthDinerInfo(), false);
        LoginDinerInfo loginDinerInfo = new LoginDinerInfo();
        loginDinerInfo.setToken(dinerInfo.getAccessToken());
        loginDinerInfo.setNickname(dinerInfo.getNickname());
        loginDinerInfo.setAvatarUrl(dinerInfo.getAvatarUrl());
        return ResultInfoUtil.buildSuccess(path, loginDinerInfo);
    }

    /**
     * 校验手机号是否已注册
     *
     * @param phone
     */
    public void checkPhoneIsRegistered(String phone) {
        AssertUtil.isNotEmpty(phone, "手机号不能为空");
        Diners diners = dinersMapper.selectByPhone(phone);
        AssertUtil.isTrue(diners == null, "该手机号未注册");
        AssertUtil.isTrue(diners.getIsValid() == 0, "该用户已锁定，请先解锁");
    }

    /**
     * 用户注册
     *
     * @param dinersDTO
     * @param path
     * @return
     */
    public ResultInfo register(DinersDTO dinersDTO, String path) {
        // 参数非空校验
        String username = dinersDTO.getUsername();
        AssertUtil.isNotEmpty(username, "请输入用户名");
        String password = dinersDTO.getPassword();
        AssertUtil.isNotEmpty(username, "请输入密码");
        String phone = dinersDTO.getPhone();
        AssertUtil.isNotEmpty(username, "请输入手机号");
        String verifyCode = dinersDTO.getVerifyCode();
        AssertUtil.isNotEmpty(username, "请输入验证码");
        // 获取验证码
        String code = sendVerifyCodeService.getCodeByPhone(phone);
        // 验证码是否已过期
        AssertUtil.isNotEmpty(code, "验证码已过期，请重新发送");
        // 校验验证码一致性
        AssertUtil.isTrue(!dinersDTO.getVerifyCode().equals(code),
                "验证码不一致，请重新输入");
        // 验证用户名是否已注册
        Diners diners = dinersMapper.selectByUsername(username.trim());
        AssertUtil.isTrue(diners != null, "用户名已存在，请重新输入");
        // 注册
        // 密码加密
        dinersDTO.setPassword(DigestUtil.md5Hex(password.trim()));
        dinersMapper.save(dinersDTO);
        // 自动登录
        return signIn(username.trim(), password.trim(), path);
    }

    /**
     * 根据食客 ID 集合查询食客信息
     *
     * @param ids 主键 id 集合，多个以逗号分隔，逗号之间不用空格
     * @return
     */
    public List<ShortDinerInfo> findByIds(String ids) {
        AssertUtil.isNotEmpty(ids);
        String[] idArr = ids.split(",");
        List<ShortDinerInfo> dinerInfos = dinersMapper.findByIds(idArr);
        return dinerInfos;
    }

}
2.3.4 Controller
   /**
     * 用户注册
     *
     * @param dinersDTO
     * @return
     */
    @PostMapping("register")
    public ResultInfo register(@RequestBody DinersDTO dinersDTO) {
        return dinersService.register(dinersDTO, request.getServletPath());
    }
2.3.5 网关配置

放行注册接口

secure:
ignore:
 urls: # 配置白名单路径
  - /actuator/**
  - /auth/oauth/**
  - /diners/signin
  - /diners/send
  - /diners/checkPhone
  - /diners/register
2.3.6 测试

先访问：http://localhost/diners/checkPhone?phone=12311113333
返回结果：

{
  "code": 0,
  "message": "该手机号未注册",
  "path": "/checkPhone",
  "data": null
      }

再访问：http://localhost/diners/send?phone=12311113333
返回结果（Redis 查看验证码）：

{
  "code": 1,
  "message": "Successful.",
  "path": "发送成功",
  "data": "/send"
}

再访问：http://localhost/diners/register
请求参数：

{
  "username": "zhangsan",
  "password": "123456",
  "phone": "12311113333",
  "verifyCode": "833275"
}

返回结果:

{
  "code": 1,
  "message": "Successful.",
  "path": "/register",
  "data": {
    "nickname": null,
    "token": "4323c187-5ffa-4e45-a3a3-e7cdff32145d",
    "avatarUrl": null
 }
}

image.png
在这里插入图片描述
这是用户登录注册流程图,该图借鉴来源: 哈喽沃德先生的主页 -->哈喽沃德先生主页 ,可以在CSDN,知乎等平台搜索即可;

👉 💕美好的一天，从现在开始，大家一起努力！后续更新持续更新，码字不易，麻烦大家小手一点 , 点赞或关注 , 感谢大家的支持！！ 🌙

JavacKaka
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
美食社交app ui 模板 foodybite .xd素材下载
04-20
【美食社交app UI模板Foodybite.xd素材下载】是一个为开发者和设计师提供的资源，用于构建专注于美食分享的社交应用程序的用户界面。这个模板是由Adobe XD设计的，它是一款流行的用户体验设计工具，允许设计师们创建...
美食餐饮app登录注册 ui .fig素材下载
04-20
总的来说，这款"美食餐饮app登录注册 ui .fig"素材为开发者和设计师提供了构建高效、美观登录注册页面的基础，结合Figma的工具特性，可以进一步优化和完善设计，打造出满足用户需求的美食餐饮应用。
recipe-app-api
03-18
8. **认证与授权**：可能包含用户注册、登录、权限控制相关的代码，比如JWT（JSON Web Tokens）或OAuth2。 9. **测试**：`tests.py`或类似文件中包含了测试用例，确保API的功能正确无误。 10. **Dockerfile**：...
Realtime-pizza-order-app
03-30
1. **用户注册与登录**：用户可以通过邮箱或社交媒体账号注册并登录，应用需要进行身份验证和安全性管理。 2. **菜单浏览**：应用应展示多种披萨口味、大小和配料供用户选择，同时提供详细的披萨图片和价格信息。 ...
参考资料-“四川美食”安卓应用程序APP-产品开发策划书.zip
02-15
“四川美食”APP旨在为用户提供全面、详尽的四川地方美食信息，包括菜谱分享、餐厅推荐、美食活动以及烹饪教程等，旨在弘扬川菜文化，满足用户对美食探索的需求。通过安卓平台的开发，我们期望能覆盖广泛的用户群体...
WCCI 2024开幕，横滨圣地巡礼，畅游动漫与美食的世界
ConferenceEye的博客
07-01 433
这里不仅有美丽的海滨风光，还有繁华的商业区和丰富的文化活动，吸引着来自世界各地的游客。我们的特约小编在会议的间隙，游览了这座迷人的城市，体验了其独特的魅力和美丽风光，其中部分照片拍摄于“招待会提供了一个轻松愉悦的环境，让与会者们在享受美食的同时，也能够交流思想，分享一天的会议心得，增进彼此的了解。结束一天的会议后，特约小编在WCCI 2024的欢迎招待会上得以放松身心，沉浸在东道国日本的热情款待中。值得注意的是，中国科学院的曾毅教授发表了一个引人注目的演讲，他阐述了。（FUZZ-IEEE）和。
Redis数据迁移-RedisShake
青春年少不知疼的博客
06-28 458
redis-shake是阿里云Redis团队开源的用于Redis数据迁移和数据过滤的工具。一、基本功能redis-shake它支持解析、恢复、备份、同步四个功能恢复restore：将RDB文件恢复到目的redis数据库。备份dump：将源redis的全量数据通过RDB文件备份起来。解析decode：对RDB文件进行读取，并以json格式解析存储。同步sync：支持源redis和目的redis的数据同步，支持全量和增量数据的迁移，支持单节点、主从版、集群版之间的互相同步。
NoSQL之Redis
煤五千的博客
06-28 1107
康门!
如何深刻理解Redis的底层原理？Redis的运行机制是什么?如何优化Redis提供更高效服务
zhang9880000的博客
06-28 955
客户端在操作的时候，会产生具有不同事件类型的socket，Redis通过事件循环机制不断地检查每个连接的状态，当有事件发生时，就会触发回调。Redis将传入的每条数据首先存入内存中，这样可以显著减少对持久存储的访问时间，从而提高数据检索性能，由于Redis基于内存操作，CPU不是性能瓶颈，机器的内存和宽带才是Redis的瓶颈。3. IO多路复用机制：Redis利用非阻塞的IO多路复用技术（如epoll/select/kqueue等），在单线程中轮询多个socket，从而能够同时处理多个客户端的请求。
Redis-分布式锁（基本原理和不同实现方式对比）
小丁的博客
07-01 504
多个线程都能看到相同的结果，注意：这个地方说的可见性并不是并发编程中指的内存可见性，只是说多个进程之间都能感知到变化的意思。，只要大家使用的是同一把锁，那么我们就能锁住线程，不让线程进行，让程序串行执行，这就是分布式锁的核心思路。那么分布式锁他应该满足一些什么样的条件呢？：程序不易崩溃，时时刻刻都保证较高的可用性。：互斥是分布式锁的最基本的条件，使得程序。：安全也是程序中必不可少的一环。常见的分布式锁有三种。
Springboot下使用Redis管道(pipeline)进行批量操作
weixin_45817985的博客
06-29 621
Springboot下使用Redis管道(pipeline)进行批量操作
Redis快速入门
abfwaaf的博客
06-28 732
llen key。
Redis-Redis可视化工具Redis Insight下载及安装
最新发布
努力搬砖，顶峰相见
07-04 269
Redis可视化工具Redis Insight下载及安装
Redis 7.x 系列【14】数据类型之流（Stream）
记录知识、锤炼自我
07-01 1029
消息队列：是指把要传输的数据（消息）放在队列中，用队列机制来实现消息传递，生产者产生消息并把消息放入队列，然后由消费者去处理。消费者可以到指定队列拉取消息，或者订阅相应的队列，由服务端给其推送消息。
什么是Redis?|介绍与使用及特点浅记
米的
07-02 3648
Redis（Remote Dictionary Server）是一种基于内存、支持持久化的键值对存储系统，具有丰富的数据结构和高性能的特性。它不仅可以作为数据库，还可以作为缓存和消息中间件使用。Redis是单线程模型，但利用IO多路复用技术以及高效的内存管理，使其在高并发场景下表现优异。
用Docker搭建分布式 Redis 的方法
qq_40592590的博客
07-04 334
docker.redis
Redis优化之持久化
zx52306的博客
07-01 659
在web服务器中，高可用是指服务器可以正常访问的时间，衡量的标准是在多长时间内可以提供正常服务（99.9%、99.99%、99.999%等）。 但是在Redis语境中，高可用的含义似乎要宽泛一些，除了保证提供正常服务（如主从分离、快速容灾技术），还需要考虑数据容量的扩展、数据安全不会丢失等。在Redis中，实现高可用的技术主要包括持久化、主从复制、哨兵和Cluster集群，下面分别说明它们的作用，以及解决了什么样的问题。持久化：持久化是最简单的高可用方法(有时甚至不被归为高可用的手段)，主要作用是数据备份，
Redis 中的通用命令(命令的返回值、复杂度、注意事项及操作演示）
Shine0115的博客
07-01 972
而 Redis 经常是用作缓存，是替 Mysql 冲锋陷阵的，万一 Redis 被Keys*给阻塞住了，此时其他的查询 Redis 的操作也就超时了，那么所有的查询请求就会给到 Mysql 上，此时突然一大波请求来到给到Mysql，就有可能给Mysql一个措手不及，给 Mysql 也搞挂了，此时就出现大问题了，如果没有及时的发现及时的恢复的话，会出现很大的问题！**时间复杂度：**O(k) ，注意这个k不是所有的数据，而是因为它是可以查看多个key是否存在的，所以这个k是指定的 key 的数量。
Redis组建哨兵模式
草莓甜甜圈的博客
07-02 236
从172.17.60.130、172.17.60.129。先模拟一下挂掉 redis 主节点。主172.17.60.131。
uni-app app项目埋点
05-24
3. 统计用户登录/注册：可以通过监听登录/注册事件，上报用户的登录/注册信息。 4. 统计错误日志：可以在应用中监听错误信息，上报错误信息，以便于及时修复应用中存在的问题。 5. 统计网络请求：可以监听网络请求...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值