手机验证码注册(springcloud+rabbitMQ+redis+微服务+Alibaba短信发送)

注册

技术：springcloud+rabbitMQ+redis+微服务+短信发送

前置准备：

启动mq：docker start mq

​ 浏览器访问192.168.88.130:15672：

启动nacos：

​ 在nacos的bin目录下输入cmd：startup.cmd -m standalone：

看到这两个面板说明启动成功。

注册流程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gQTQpgZW-1638519397073)(C:UsersqAppDataRoamingTyporatypora-user-imagesimage-20211203155402604.png)]

前端：

main.js

import Vue from 'vue'
import VueRouter from 'vue-router'
import Home from '../views/Home.vue'

Vue.use(VueRouter)

const routes = [
  {
    path: '/',
    name: 'Home',
    component: Home
  },
  {
    path: '/about',
    name: 'about',
    component: () => import('../views/about.vue')
  },
  {
    path: '/login',
    name: 'Login',
    component: () => import('../views/Login.vue')
  },
  {
    path: '/reg',
    name: 'reg',
    component: () => import('../views/Register.vue')
  }
]

const router = new VueRouter({
  mode: 'history',
  base: process.env.base_URL,
  routes
})

export default router

Register.vue

后端： jwt-parent父模块: pom.xml:

    4.0.0
    
        jwt-common
        jwt-pojo
        goods-search
        user-service
        jwt-auth
        jwt-gateway
        sms-consumer
    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.9.RELEASE
         
    
    com.czxy
    jwt-parent
    0.0.1-SNAPSHOT
    pom
    jwt-parent
    Demo project for Spring Boot
    
        UTF-8
        UTF-8
        1.8
        Hoxton.SR10
        2.1.1
        1.2.3
        1.1.9
        8.0.23
        1.2.3
        0.7.0
        2.9.6
        1.18.18
    

    
    
        
            
            
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring-cloud.version}
                pom
                import
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                2.2.6.RELEASE
                pom
                import
            
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                ${mybatis.starter.version}
            
            
            
                tk.mybatis
                mapper-spring-boot-starter
                ${mapper.starter.version}
            
            
                com.github.pagehelper
                pagehelper-spring-boot-starter
                ${pageHelper.starter.version}
            
            
            
                com.alibaba
                druid-spring-boot-starter
                ${druid.starter.version}
            
            
                mysql
                mysql-connector-java
                ${mysql.version}
            
            
                io.jsonwebtoken
                jjwt
                ${jjwt.version}
            
            
            
                joda-time
                joda-time
                ${joda-time.version}
            
            
                org.springframework.boot
                spring-boot-starter
            

            
                org.springframework.boot
                spring-boot-starter-test
            
            
                org.projectlombok
                lombok
                ${lombok.version}
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

jwt-common模块： 随机六位验证码util：

package com.czxy.util;

import java.util.Random;


public class RandomUtil {
    public static String code(){
        Random random = new Random();
        String code = "";
        for (int i=0;i<6;i++){
            code+= random.nextInt(10);//产生0-9的随机验证码
        }
        return code;
    }
}

user-service模块: pom.xml

    4.0.0
    
        com.czxy
        jwt-parent
        0.0.1-SNAPSHOT
    
    user-service
    jar
    user-service
    Demo project for Spring Boot

    
        
            com.czxy
            jwt-pojo
            0.0.1-SNAPSHOT
        

        
            com.czxy
            jwt-common
            0.0.1-SNAPSHOT
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            mysql
            mysql-connector-java
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-config
        
        
            tk.mybatis
            mapper-spring-boot-starter
            2.0.2
        
        
            mysql
            mysql-connector-java
        
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        

    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

bootstrap.yml:

spring:
  application:
    name: userservice
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_user1?useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  profiles:
    active: dev
  cloud:
    nacos:
      server-addr: localhost:8848
      config:
        file-extension: yaml
  rabbitmq:
    host: 192.168.88.130 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码
  redis:
    host: localhost
    port: 6379
    database: 0
    jedis:
      pool:
        max-idle: 8
        min-idle: 0
        max-active: 8
server:
  port: 8000

启动类：

package com.czxy.user;


import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class UserService01Application {
    public static void main(String[] args) {
        SpringApplication.run(UserService01Application.class, args);
    }
    @Bean
    public Queue createSmsQueue(){
        return new Queue("sms.queue");
    }

}

mapper.UserMapper类:

package com.czxy.user.mepper;

import tk.mybatis.mapper.common.Mapper;
import com.czxy.pojo.User;

@org.apache.ibatis.annotations.Mapper
public interface UserMapper extends Mapper {
}

service.UserService接口：

package com.czxy.user.service;

import com.czxy.pojo.User;

public interface UserService {
    void insert(User user);
}

service.impl.UserServiceImpl实现接口：

package com.czxy.user.service.impl;

import com.czxy.pojo.User;
import com.czxy.user.mepper.UserMapper;
import com.czxy.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


@Service
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public void insert(User user) {
        userMapper.insert(user);
    }
}

web.UserController类：

package com.czxy.user.web;

import com.czxy.pojo.User;
import com.czxy.user.service.UserService;
import com.czxy.util.RandomUtil;
import com.czxy.vo.baseResult;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.TimeUnit;


@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private UserService userService;
    @Autowired
    private StringRedisTemplate redisTemplate;

    @PostMapping
    public baseResult addUser(@RequestBody User user) {
        System.out.println("新增用户信息：" + user);
        return baseResult.ok("ok");
    }

    
    // xxxx/sendSms?phone=17602128959
    @GetMapping("/sendSms")
    public baseResult sendSMS(String phone) {
//       1 产生随机码6位
        String code = RandomUtil.code();
        System.out.println(phone);
        //拼接消息内容
        String msg = phone + "%%%%%%" + code;
        System.out.println(msg);

//       2 保存到rabbitMQ中
        rabbitTemplate.convertAndSend("sms.queue", msg);
//       3 保存到redis中
        redisTemplate.opsForValue().set(phone, code, 1, TimeUnit.MINUTES);
//       4 返回发送成功
        return baseResult.ok("成功");
    }

    @PostMapping("/regist")
    public baseResult regist(@RequestBody User user) {
        // 1 根据手机号码去redis中取出验证码
        String redisCode = redisTemplate.opsForValue().get(user.getMobile());
        //2 验证码不存在，注册直接失败
        if (redisCode == null) {
            return baseResult.error("失败");
        }
        //3 验证码存在，比较验证码
        if (user.getCode().equals(redisCode)) {
//            验证码通过，比较两次密码是否一次
            if (user.getPassword().equals(user.getRepassword())) {
                //4 如果密码一致，注册成功，移除redis中的验证码
                System.out.println("注册成功，保存到数据库" + user);
                userService.insert(user);
                redisTemplate.delete(user.getMobile());
                return baseResult.ok("注册成功" + user);
            }

        }

        return baseResult.error("失败");
    }

}

jwt-gateway模块(filter过滤)：

bootstrap.yml

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos地址
    gateway:
      routes: # 网关路由配置
        - id: goods-service # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
          uri: lb://goods-service # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
            - Path=/search/** # 这个是按照路径匹配，只要以/user/开头就符合要求
        - id: user-service
          uri: lb://userservice
          predicates:
            - Path=/user/**
        - id: auth-service
          uri: lb://authservice
          predicates:
            - Path=/auth/**
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true #  解决options请求被拦截问题
        corsConfigurations:
          '[
@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class);
    }
}

sms-consumer模块(消费验证码)： pom.xml

    
        jwt-parent
        com.czxy
        0.0.1-SNAPSHOT
    
    4.0.0

    sms-consumer

    
        8
        8
    
    
        
        
            com.aliyun
            aliyun-java-sdk-core
            4.5.3
        
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
    

application.yml:

server:
  port: 20000
spring:
  rabbitmq:
    host: 192.168.88.130 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

启动类：

package com.czxy.sms;

import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;




@SpringBootApplication
public class SmsConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(SmsConsumerApplication.class);
    }

    @Bean
    public Queue createSmsQueue(){
        return new Queue("sms.queue");
    }
}

发送短信Util类：

package com.czxy.sms.util;
import com.aliyuncs.CommonRequest;
import com.aliyuncs.CommonResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;


public class AliyunSendSmsUtil {
    
    public static void send(String to, String code) {
        String accessKeyId="LTAI5t8Kz6URnpkiRkJPtjGs";
        String accessSecret = "Xv7U1NfgEAD5Of6dQzSS9VuxBUjlEi";


        DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessSecret);
        IAcsClient client = new DefaultAcsClient(profile);

        CommonRequest request = new CommonRequest();
        request.setSysMethod(MethodType.POST);
        request.setSysDomain("dysmsapi.aliyuncs.com");
        request.setSysVersion("2017-05-25");
        request.setSysAction("SendSms");
        request.putQueryParameter("RegionId", "cn-hangzhou");
        request.putQueryParameter("PhoneNumbers", to);
        request.putQueryParameter("SignName", "老袁a洗脚6");
        request.putQueryParameter("TemplateCode", "SMS_85550034");
        request.putQueryParameter("TemplateParam", "{"code":""+code+""}");
        try {
            CommonResponse response = client.getCommonResponse(request);
            System.out.println(response.getData());
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (ClientException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
//        AliyunSendSmsUtil.send("17602128959","12396");
    }

}

SmsListener监听类：

package com.czxy.sms.listener;

import com.czxy.sms.util.AliyunSendSmsUtil;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SmsListener {

    @RabbitListener(queues = "sms.queue")
    public void listenerWorkQueue1(String msg) throws Exception{
        String[] vals = msg.split("%%%%%%");
        AliyunSendSmsUtil.send(vals[0],vals[1]);
        System.out.println("sms接收到的消息:【"+msg+"】发送成功");
    }
}