第九章
消息队列及短信发送平台
优就业.JAVA教研室
学习目标
- 了解常见的MQ产品
- 了解RabbitMQ的5种消息模型
- 会使用SpringBoot整合AMQP
- 短信发送平台
- 短信服务
- 用户注册
一、介绍
1.消息队列（MQ）
1.1 什么是消息队列
消息队列，即MQ，Message Queue。
消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。
如果以后有其它系统也依赖商品服务的数据，同样监听消息即可，商品服务无需任何代码修改。
1.2 AMQP和JMS
MQ是消息通信的模型，并不是具体实现。现在实现MQ的有两种主流方式：AMQP、JMS。
两者间的区别和联系：
- JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
- JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
- JMS规定了两种消息模型；而AMQP的消息模型更加丰富
1.3 常见MQ产品
- ActiveMQ：基于JMS
- RabbitMQ：基于AMQP协议，erlang语言开发，稳定性好
- RocketMQ：基于JMS，阿里巴巴产品，目前交由Apache基金会
- Kafka：分布式消息系统，高吞吐量
2. RabbitMQ
RabbitMQ是基于AMQP的一款消息管理系统
官方教程：http://www.rabbitmq.com/getstarted.html
3. 五种消息模型
RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。
但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。
二、RabbitMQ安装
1 docker镜像下载
docker pull rabbitmq:management
注意：如果docker pull rabbitmq 后面不带management，启动rabbitmq后是无法打开管理界面的，所以我们要下载带management插件的rabbitmq.
2.查看docker镜像
docker images
3.创建rabbitmq容器
docker run -di -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management
4.访问管理界面
访问管理界面的地址就是 http://192.168.188.128:15672，可以使用默认的账户登录，用户名和密码都guest
三、SpringBoot整合AMQP
1. 简单队列模式（Queue）
RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把邮件放在邮箱里时，你可以确定邮差先生最终会把邮件发送给你的收件人。 在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。
RabbitMQ与邮局的主要区别是它不处理纸张，而是接受，存储和转发数据消息的二进制数据块。****
P（producer/ publisher）：生产者，一个发送消息的用户应用程序。
C（consumer）：消费者，消费和接收有类似的意思，消费者是一个主要用来等待接收消息的用户应用程序
队列（红色区域）：RabbitMQ内部类似于邮箱的一个概念。虽然消息流经RabbitMQ和你的应用程序，但是它们只能存储在队列中。队列只受主机的内存和磁盘限制，实质上是一个大的消息缓冲区。许多生产者可以发送消息到一个队列，许多消费者可以尝试从一个队列接收数据。
总之：
生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。
我们将用SpringBoot编写两个程序;发送单个消息的生产者，以及接收消息并将其打印出来的消费者。
我们将调用我们的消息发布者（发送者）Send和我们的消息消费者（接收者）Recv。发布者将连接到RabbitMQ，发送一条消息，然后退出。
1.1 导入依赖
pom.xml 代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.9.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.offcn</groupId>
<artifactId>spring-amqp-demo01</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-amqp-demo01</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
1.2 修改配置文件
application.yml，代码如下
spring:
rabbitmq:
host: 192.168.188.128
port: 5672
username: guest
password: guest
1.3 创建配置类
package com.offcn.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class SimpleQueueConfig {
/**
* 定义简单队列名
*/
private String simpleQueue = "spring.test.queue";
@Bean
public Queue simpleQueue() {
return new Queue(simpleQueue);
}
}
注意：Queue不要导错包
1.4 发送端
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/")
public void send() {
for(int i=0;i<5;i++) {
rabbitTemplate.convertAndSend("spring.test.queue", "简单队列消息"+i);
}
}
}
1.5 接收端
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ReceiveListener {
@RabbitListener(queues= "spring.test.queue")
public void recieve(String message) {
System.out.println(message);
}
}
1.6 输出
访问http://localhost:8080/
控制台输出
2.work消息模型
工作队列或者竞争消费者模式
创建一个工作队列，在多个工作者之间分配耗时任务。
工作队列，又称任务队列。主要思想就是避免执行资源密集型任务时，必须等待它执行完成。相反我们稍后完成任务，我们将任务封装为消息并将其发送到队列。 在后台运行的工作进程将获取任务并最终执行作业。当你运行许多工人时，任务将在他们之间共享，但是一个消息只能被一个消费者获取。
这个概念在Web应用程序中特别有用，因为在短的HTTP请求窗口中无法处理复杂的任务。
接下来我们来模拟这个流程：
P：生产者：任务的发布者
C1：消费者，领取任务并且完成任务，假设完成速度较快
C2：消费者2：领取任务并完成任务，假设完成速度慢
面试题：避免消息堆积？
1） 采用workqueue，多个消费者监听同一队列。
2）接收到消息以后，而是通过线程池，异步消费。
2.1 创建配置类
@Configuration
public class WorkQueueConfig {
/**
* 队列名.
*/
private final String work = "work_queue";
@Bean
public Queue workQueue() {
return new Queue(work);
}
}
2.2 发送端
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/")
public void send() {
for (int i = 0; i < 50; i++) {
String message = "工作队列消息" + i;
rabbitTemplate.convertAndSend("work_queue", message);
}
}
}
这里我们循环发送50条消息
2.3 接收端
@Component
public class ReceiveListener {
@RabbitListener(queues = "work_queue")
public void recieve1(String message) {
System.out.println("listener1:" + message);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@RabbitListener(queues = "work_queue")
public void recieve2(String message) {
System.out.println("listener2:" + message);
}
}
我们在消费者1里设置延时时间，模式消费耗时
2.4 输出
访问http://localhost:8080/
控制台输出
可以发现，两个消费者各自消费了25条消息，而且各不相同，这就实现了任务的分发，并且平均分配。
2.5 能者多劳
刚才的实现有问题吗？
- 消费者1比消费者2的效率要低，一次任务的耗时较长
- 然而两人最终消费的消息数量是一样的
- 消费者2大量时间处于空闲状态，消费者1一直忙碌
现在的状态属于是把任务平均分配，正确的做法应该是消费越快的人，消费的越多。
怎么实现呢？
我们可以设置每次只处理一个信息，告诉RabbitMQ一次不要向消费端发送多于一条消息。 或者换句话说，不要向消费端发送新消息，直到它处理并确认了前一个消息。 相反，它会将其分派给不是处于忙碌状态的下一个消费端。
修改配置文件，如下：
再次运行程序，效果如下：
3. 发布者订阅者模式（Publish/Subscribe）
在之前的模式中，我们创建了一个工作队列。 工作队列背后的假设是：每个任务只被传递给一个工作人员。 在这一部分，我们将做一些完全不同的事情 - 我们将会传递一个信息给多个消费者。 这种模式被称为“发布/订阅”。
解读：
1、1个生产者，多个消费者
2、每一个消费者都有自己的一个队列
3、生产者没有将消息直接发送到队列，而是发送到了交换机
4、每个队列都要绑定到交换机
5、生产者发送的消息，经过交换机到达队列，实现一个消息被多个消费者获取的目的
X（Exchanges）：交换机一方面：接收生产者发送的消息。另一方面：知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
Exchange类型有以下几种：
Fanout：广播，将消息交给所有绑定到交换机的队列
Direct：定向，把消息交给符合指定routing key 的队列
Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
我们这里先学习
Fanout：即广播模式
Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！
3.1 创建配置类
@Configuration
public class FanoutQueueConfig {
/**
* 声明队列名
*/
private final String fanout1 = "fanout_queue_1";
private final String fanout2 = "fanout_queue_2";
/**
* 声明交换机的名字.
*/
private final String fanoutExchange = "fanoutExchange";
//声明队列1
@Bean
public Queue fanoutQueue1(){
return new Queue(fanout1);
}
//声明队列2
@Bean
public Queue fanoutQueue2(){
return new Queue(fanout2);
}
//声明交换机
@Bean
public FanoutExchange exchange(){
return new FanoutExchange(fanoutExchange);
}
//绑定交换机到队列1
@Bean
public Binding bindingQueue1(){
return BindingBuilder.bind(fanoutQueue1()).to(exchange());
}
//绑定交换机到队列2
@Bean
public Binding bindingQueue2(){
return BindingBuilder.bind(fanoutQueue2()).to(exchange());
}
}
3.2 发送端
package com.offcn.controller;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/")
public void send() {
for (int i = 0; i < 5; i++) {
String message = "订阅模式消息" + i;
rabbitTemplate.convertAndSend("fanoutExchange", "", message);
}
}
}
注意：发送消息有三个参数，中间参数为路由key。
3.3 接收端
package com.offcn.listener;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ReceiveListener {
@RabbitListener(queues = "fanout_queue_1")
public void recieve1(String message) {
System.out.println("listener1:" + message);
}
@RabbitListener(queues = "fanout_queue_2")
public void recieve2(String message) {
System.out.println("listener2:" + message);
}
}
3.3 输出
访问 http://localhost:8080/
输出
控制台打印 ，发现两个绑定了不同队列的消费者都接受到了同一条消息
查看RabbitMq 服务器：
4.路由模式（Direct）
有选择性的接收消息
在订阅模式中，生产者发布消息，所有消费者都可以获取所有消息。
在路由模式中，我们将添加一个功能 - 只能订阅一部分消息。 例如，我们只能将重要的错误消息引导到日志文件（以节省磁盘空间），同时仍然能够在控制台上打印所有日志消息。
但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
在Direct模型下，队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在向Exchange发送消息时，也必须指定消息的routing key。
P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息
4.1 创建配置类
@Configuration
public class DirectQueueConfig {
/**
* 声明队列名.
*/
private final String direct1 = "direct_queue_1";
private final String direct2 = "direct_queue_2";
/**
* 声明交换机的名字.
*/
private final String directExchange = "directExchange";
//队列1
@Bean
public Queue directQueue1(){
return new Queue(direct1);
}
//队列2
@Bean
public Queue directQueue2(){
return new Queue(direct2);
}
//交换机
@Bean
public DirectExchange directExchange(){
return new DirectExchange(directExchange);
}
//绑定队列1到交换机
@Bean
public Binding bindingDirectExchange1(){
return BindingBuilder.bind(directQueue1()).to(directExchange()).with("update");
}
//绑定队列2到交换机
@Bean
public Binding bindingDirectExchange2(){
return BindingBuilder.bind(directQueue2()).to(directExchange()).with("add");
}
}
4.2 发送端
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/send01")
public void sendMessageA() {
for (int i = 0; i < 5; i++) {
String message = "路由模式--routingKey=update消息" + i;
System.out.println("我是生产信息的：" + message);
rabbitTemplate.convertAndSend("directExchange", "update", message);
}
}
@RequestMapping("/send02")
public void sendMessageB() {
for (int i = 0; i < 5; i++) {
String message = "路由模式--routingKey=add消息" + i;
System.out.println("我是生产信息的：" + message);
rabbitTemplate.convertAndSend("directExchange", "add", message);
}
}
}
4.3 接收端
@Component
public class ReceiveListener {
@RabbitListener(queues = "direct_queue_1")
public void recieve1(String message) {
System.out.println("listener1:" + message);
}
@RabbitListener(queues = "direct_queue_2")
public void recieve2(String message) {
System.out.println("listener2:" + message);
}
}
4.4 输出
访问http://localhost:8080/send01
访问http://localhost:8080/send02
5. 主题模式（Topic）
Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！
Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
通配符规则：
#：匹配一个或多个词
*：匹配不多不少恰好1个词
举例：
audit.#：能够匹配audit.irs.corporate 或者 audit.irs
audit.*：只能匹配audit.irs
在这个例子中，我们将发送所有描述动物的消息。消息将使用由三个字（两个点）组成的routing key发送。路由关键字中的第一个单词将描述速度，第二个颜色和第三个种类：“<speed>.<color>.<species>”。
我们创建了三个绑定：Q1绑定了绑定键“* .orange.*”，Q2绑定了“*.*.rabbit”和“lazy.＃”。
Q1匹配所有的橙色动物。
Q2匹配关于兔子以及懒惰动物的消息。
5.1 创建配置类
@Configuration
public class TopicQueueConfig {
/**
* 声明队列名.
*/
private final String topic1 = "topic_queue_1";
private final String topic2 = "topic_queue_2";
/**
* 声明交换机的名字.
*/
private final String topicExchange = "topicExchange";
/**
* 声明队列.
*
* @return
*/
@Bean
public Queue topicQueue1() {
return new Queue(topic1);
}
@Bean
public Queue topicQueue2() {
return new Queue(topic2);
}
/**
* 声明路由交换机.
*
* @return
*/
@Bean
public TopicExchange topicExchange() {
return new TopicExchange(topicExchange);
}
//绑定队列到交换机--支持通配符路由key
@Bean
public Binding bindingTopicExchange1(){
return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("topic.keyA");
}
//绑定队列到交换机--支持通配符路由key
@Bean
public Binding bindingTopicExchange2(){
return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("topic.#");
}
}
5.2 发送端
package com.offcn.controller;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/send01")
public void send01() {
for (int i = 0; i < 5; i++) {
String message = "通配符模式--routingKey=topic.keyA消息" + i;
System.out.println("我是生产信息的：" + message);
rabbitTemplate.convertAndSend("topicExchange", "topic.keyA", message);
}
}
@RequestMapping("/send02")
public void send02(){
for (int i = 0; i < 5; i++) {
String message = "通配符模式--routingKey=topic.#消息" + i;
System.out.println("我是生产信息的：" + message);
rabbitTemplate.convertAndSend("topicExchange", "topic.keyD.keyE", message);
}
}
}
5.3 接收端
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ReceiveListener {
@RabbitListener(queues = "topic_queue_1")
public void recieve1(String message) {
System.out.println("listener1:" + message);
}
@RabbitListener(queues = "topic_queue_2")
public void recieve2(String message) {
System.out.println("listener2:" + message);
}
}
5.4 输出
访问http://localhost:8080/send01
输出，发现两个消费者都能消费
访问http://localhost:8080/send02
输出，发现只有消费者2 可以消费
查看RabbitMq 服务器：
四、短信发送平台-106三网短信
1 106三网短信
山东鼎信（Decent）——专业106短信平台，短信验证码API接口调用，可免费试用短信接口，让APP、网站、小程序快速实现短信注册、短信认证，短信登陆、密码找回短信、支付认证短信、通知短信，提供短信验证码、短信通知服务直连短信通道，3s必达，99%到达率，可辅助人脸识别进行验证，7x24小时技术服务。提供验证码传递下发短信服务，三网合一的高质量专用通道，金融级安全保护。
2 准备工作
2.1购买“106三网短信”
首先我们先进入“阿里云” https://www.aliyun.com/
搜索 106三网短信
点击进入
说明：进入时请认准 官方logo
进行购买
购买之后，自动进入订单列表
注意：免费试用只有5次。
2.2进行测试
此时，目标手机就可以查收到短信。
2.3 通过Java代码测试
参考：
package com.offcn.sms;
import java.util.HashMap;
import java.util.Map;
import com.offcn.user.utils.HttpUtils;
import org.apache.http.HttpResponse;
public class SmsTest {
public static void main(String[] args) {
String host = "http://dingxin.market.alicloudapi.com";
String path = "/dx/sendSms";
String method = "POST";
String appcode = "f44b943718534....504b8e01f393"; // 输入自己的appcode
Map<String, String> headers = new HashMap<String, String>();
// 最后在header中的格式(中间是英文空格)为Authorization:APPCODE 83359fd73fe94948385f570e3c139105
headers.put("Authorization", "APPCODE " + appcode);
Map<String, String> querys = new HashMap<String, String>();
querys.put("mobile", "177xxxx8520"); // 输入正确的手机号码
querys.put("param", "code:123456");
querys.put("tpl_id", "TP1711063");
Map<String, String> bodys = new HashMap<String, String>();
try {
/**
* 重要提示如下: HttpUtils请从
* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
* 下载
*
* 相应的依赖请参照
* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
*/
HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
System.out.println(response.toString());
// 获取response的body
// System.out.println(EntityUtils.toString(response.getEntity()));
//{"return_code":"00000","order_id":"ALY1549881237643456814"}
} catch (Exception e) {
e.printStackTrace();
}
}
}
HttpUtils安装
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.2.1</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpcore</artifactId>
<version>4.2.1</version>
</dependency>
五 短信服务
1 需求分析
构建一个短信发送服务，接收RabbitMQ的消息（MAP类型），采用简单队列模式 、消息包括手机号（mobile）、参数字符串（param ）
2 工程搭建
（1） 创建工程dongyimai-sms-service （WAR工程），POM文件引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>dongyimai-service</artifactId>
<groupId>com.offcn</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>dongyimai-sms-service</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.15</version>
</dependency>
</dependencies>
</project>
(2) 创建配置文件 application.yml
server:
port: 9006
spring:
application:
name: sms
rabbitmq:
host: 192.168.188.128
port: 5672
username: guest
password: guest
sms:
appcode: b6972XXXXXXXfc0cdb62c48 #使用自己的AppCode
tpl_id: TP1711063 # 默认模板
(3)创建配置类
package com.offcn.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class SimpleQueueConfig {
/**
* 定义简单队列名
*/
private String simpleQueue = "dongyimai.sms.queue";
@Bean
public Queue simpleQueue() {
return new Queue(simpleQueue);
}
}
(3) 短信工具类
参照之前的短信demo创建短信工具类，并将HttpUtils.java拷贝到com.offcn.util目录下
package com.offcn.sms.utils;
import com.offcn.uitls.HttpUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class SmsUtil {
//注入短信发送相关参数：appcode
@Value("${sms.appcode}")
private String appcode;
//注入模板编号
@Value("${sms.tpl_id}")
private String tpl_id;
//定义短信发送主机地址
private String host="http://dingxin.market.alicloudapi.com";
//接口访问路径
private String path="/dx/sendSms";
//请求方法
private String method="POST";
//编写一个短信发送方法
public String smsSend(String mobile,String code){
//创建一个Map封装请求头数据
Map<String,String> headers=new HashMap<>();
//首先在请求封装身份验证appcode
headers.put("Authorization","APPCODE "+appcode);
//创建一个map封装请求参数
Map<String, String> querys=new HashMap<>();
//需发送的手机号码
querys.put("mobile",mobile);
//设置模板变量参数
querys.put("param","code:"+code);
//设置模板编号
querys.put("tpl_id",tpl_id);
//创建一个map封装body
Map<String, String> bodys=new HashMap<>();
//调用HttpUtils发出短信发送请求
try {
HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
//获取响应状态码
int statusCode = response.getStatusLine().getStatusCode();
//判断状态码是否等于200
if(statusCode==200){
//获取响应结果封装对象
HttpEntity entity = response.getEntity();
//把响应结果封装对象转换为字符串
String responseStr = EntityUtils.toString(entity, "UTF-8");
return responseStr;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
(4) 消息监听类
创建SmsListener.java
package com.offcn.listener;
import com.offcn.utils.SmsUtil;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class SmsListener {
@Autowired
private SmsUtil smsUtil;
@RabbitListener(queues = "dongyimai.sms.queue")
public void getMessage(Map<String,String> map) throws Exception {
if (map == null) {
return;
}
String mobile = map.get("mobile");
String code = map.get("code");
// 发送短信
smsUtil.sendSms(mobile,code);
}
}
(5) 测试短信发送
找到上面编写的消息发送测试程序，修改如下
@RestController
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/")
public void send() {
Map<String, String> map = new HashMap<>();
map.put("mobile", "186XXXX9365");
map.put("code", "9999");
rabbitTemplate.convertAndSend("dongyimai.sms.queue", map);
}
}
注意修改发送队列为目前短信监听队列
(6) 测试短信发送
启动dongyimai-sms-service
观察控制台输出
随后短信也成功发送到你的手机上
六 用户注册
1 需求分析
完成用户注册功能
2 工程搭建
2.1 用户服务实现层
（1）在dongyiami-service-api创建dongyimai-user-service-api，导入Pojo，如图：
（2）在dongyimai-service下创建dongyimai-user-service，pom.xml引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>dongyimai-service</artifactId>
<groupId>com.offcn</groupId>
<version>0.0.1</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>dongyimai-user-service</artifactId>
<!--依赖-->
<dependencies>
<dependency>
<groupId>com.offcn</groupId>
<artifactId>dongyimai-user-service-api</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</project>
从代码生成器拷贝相关代码：
(3）添加配置文件application.yml
server:
port: 9007
spring:
application:
name: user
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/dongyimaidb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username: root
password: 123456
redis:
host: 192.168.188.128
port: 6379
rabbitmq:
host: 192.168.188.128
port: 5672
username: guest
password: guest
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
feign:
hystrix:
enabled: true
# 配置sql打印日志
logging:
level:
com.offcn: debug
2.2 后端服务实现层
修改dongyimai-user-service的UserServiceImpl.java
/**
* 增加User
* @param user
*/
@Override
public void add(User user){
user.setCreated(new Date());//创建日期
user.setUpdated(new Date());//修改日期
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
String password= passwordEncoder.encode(user.getPassword());
user.setPassword(password);
this.save(user);
}
注意：BCryptPasswordEncoder加密后的密码串长度过大，把数据表tb_user的password字段长度调整为128位
3 注册判断短信验证码
3.1实现思路
点击页面上的”获取短信验证码”连接，向后端传递手机号。后端随机生成6位数字作为短信验证码，将其保存在redis中（手机号作为KEY），并发送到短信网关。
用户注册时，后端根据手机号查询redis中的验证码与用户填写的验证码是否相同，如果不同则提示用户不能注册。
3.2生成验证码
（1）修改dongyimai-user-service工程UserService.java ，增加方法
/**
* 生成短信验证码
* @return
*/
public void createSmsCode(String phone);
（2）修改dongyimai-user-service工程的UserServiceImpl.java
/**
* 生成短信验证码
*
* @param phone
* @return
*/
@Override
public void createSmsCode(String phone) {
System.out.println("验证码:"+code);
//把验证码存储到redis
redisTemplate.opsForValue().set(mobile,code);
//设置redis验证码有效期
redisTemplate.expire(mobile,5, TimeUnit.MINUTES);
//发送短信稍后处理
}
（3）在 dongyimai-common 添加工具类PhoneFormatCheckUtils.java（资源\工具类），用于验证手机号
（4）新增模块dongyimai-user-service的UserController.java
/**
* 发送短信验证码
* @param phone
* @return
*/
@GetMapping("/sendCode")
public Result sendCode(String phone){
//判断手机号格式
if(!PhoneFormatCheckUtils.isPhoneLegal(phone)){
return new Result(false, StatusCode.ERROR,"手机号格式不正确");
}
try {
userService.createSmsCode(phone);//生成验证码
return new Result(true,StatusCode.OK, "验证码发送成功");
} catch (Exception e) {
e.printStackTrace();
return new Result(false,StatusCode.ERROR, "验证码发送失败");
}
}
(5)、编写主启动类
package com.offcn.user;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
@MapperScan("com.offcn.user.dao")
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class,args);
}
}
3.3用户注册判断验证码
（1）修改dongyimai-user-service的UserService.java，增加方法
/**
* 判断短信验证码是否存在
* @param phone
* @return
*/
public boolean checkSmsCode(String phone,String code);
（2）修改dongyimai-user-service的 UserServiceImpl.java
/**
* 判断验证码是否正确
*/
public boolean checkSmsCode(String phone,String code){
//得到缓存中存储的验证码
String sysCode = (String) redisTemplate.boundHashOps("smscode").get(phone);
if(sysCode==null){
return false;
}
if(!sysCode.equals(code)){
return false;
}
return true;
}
（3）修改dongyimai-user-service的UserController.java 的add方法
/**
* 增加
* @param user
* @return
*/
@PostMapping("/add")
public Result add(@RequestBody User user,String smscode){
boolean checkSmsCode = userService.checkSmsCode(user.getPhone(), smscode);
if(checkSmsCode==false){
return new Result(false,StatusCode.ERROR ,"验证码输入错误！");
}
try {
userService.add(user);
return new Result(true,StatusCode.OK, "增加成功");
} catch (Exception e) {
e.printStackTrace();
return new Result(false,StatusCode.ERROR, "增加失败");
}
}
3.4短信验证码发送到手机
修改dongyimai-user-service的依赖，引入RabbitMQ所需依赖包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
（1）修改dongyimai-user-service的UserServiceImpl.java
@Autowired
private RabbitTemplate rabbitTemplate;
测试1，短信验证码发送：
http://localhost:9007/user/sendCode?phone=13881221311
测试2：用户注册
