品优购-SpringBoot

 

 

 

 

品优购电商系统开发

第14章

SpringBoot框架与短信解决方案

 

 

 

 

 

 

传智播客.黑马程序员

 

 

 

 

课程目标

目标1：掌握Spring Boot框架的搭建方法

目标2：能够使用阿里大于发送短信

目标3：运用SpringBoot、阿里大于和ActiveMQ 开发短信微服务

目标4：完成品优购用户注册功能（短信验证码认证）

1.Spring Boot入门

1.1什么是Spring Boot

Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。

虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring 用 XML 配置，而且是很多 XML 配置。Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML 配置。Spring 3.0 引入了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML。所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。

除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

Spring Boot 让这一切成为了过去。

    Spring Boot 是 Spring 社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于 Spring 的应用程序和服务，让更多人的人更快的对 Spring 进行入门体验，为 Spring 生态系统提供了一种固定的、约定优于配置风格的框架。

Spring Boot 具有如下特性：

（1）为基于 Spring 的开发提供更快的入门体验

（2）开箱即用，没有代码生成，也无需 XML 配置。同时也可以修改默认值来满足特定的需求。

（3）提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

（4）Spring Boot 并不是不对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

1.2 Spring Boot入门小Demo

1.2.1起步依赖

创建Maven工程 springboot_demo（打包方式jar） 

在pom.xml中添加如下依赖

<parent>     <groupId>org.springframework.bootgroupId>     <artifactId>spring-boot-starter-parentartifactId> <version>1.4.0.RELEASEversion>   parent>    <dependencies>     <dependency>         <groupId>org.springframework.bootgroupId>         <artifactId>spring-boot-starter-webartifactId>     dependency>   dependencies>

我们会惊奇地发现，我们的工程自动添加了好多好多jar包

     ........

而这些jar包正式我们做开发时需要导入的jar包。因为这些jar包被我们刚才引入的spring-boot-starter-web所引用了，所以我们引用spring-boot-starter-web后会自动把依赖传递过来。

1.2.2变更JDK版本

我们发现默认情况下工程的JDK版本是1.6 ,而我们通常用使用1.7的版本，所以我们需要在pom.xml中添加以下配置

<properties>       <java.version>1.7java.version>   properties>

添加后更新工程，会发现版本已经变更为1.7

1.2.3引导类

只需要创建一个引导类 .

package cn.itcast.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application {     public static void main(String[] args) {        SpringApplication.run(Application.class, args);     } }

简单解释一下，@SpringBootApplication其实就是以下三个注解的总和

@Configuration： 用于定义一个配置类

@EnableAutoConfiguration ：Spring Boot会自动根据你jar包的依赖来自动配置项目。

@ComponentScan： 告诉Spring 哪个packages 的用注解标识的类 会被spring自动扫描并且装入bean容器。

我们直接执行这个引导类，会发现控制台出现的这个标识

你能不能看出来上边这个图是什么东西？

1.2.4 Spring MVC实现Hello World输出

我们现在开始使用spring MVC框架，实现json数据的输出。如果按照我们原来的做法，需要在web.xml中添加一个DispatcherServlet的配置，再添加一个spring的配置文件，配置文件中需要添加如下配置

scan base-package="cn.itcast.demo.controller" />                "true">         "com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">            "supportedMediaTypes" value="application/json"/>           "features">                           WriteMapNullValue               WriteDateUseDateFormat

但是我们用SpringBoot，这一切都省了。我们直接写Controller类

package cn.itcast.demo.controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloWorldController {     @RequestMapping("/info")     public String info(){        return "HelloWorld";         }      }

我们运行启动类来运行程序

在浏览器地址栏输入 http://localhost:8080/info 即可看到运行结果

1.2.5修改tomcat启动端口

在src/main/resources下创建application.properties

server.port=8088

重新运行引导类。地址栏输入

http://localhost:8088/info

1.2.6读取配置文件信息

在src/main/resources下的application.properties 增加配置

url=http://www.itcast.cn

我要在类中读取这个配置信息，修改HelloWorldController 

@Autowired     private Environment env;       @RequestMapping("/info")     public String info(){          return "HelloWorld~~"+env.getProperty("url");     }

1.2.7热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间，能不能在我修改代码后不重启就能生效呢？可以，在pom.xml中添加如下配置就可以实现这样的功能，我们称之为热部署。

<dependency>          <groupId>org.springframework.bootgroupId>          <artifactId>spring-boot-devtoolsartifactId>      dependency>

赶快试试看吧，是不是很爽。

1.3 Spring Boot与ActiveMQ整合

1.3.1使用内嵌服务

（1）在pom.xml中引入ActiveMQ起步依赖

<dependency>     <groupId>org.springframework.bootgroupId>     <artifactId>spring-boot-starter-activemqartifactId> dependency>

（2）创建消息生产者

/**  * 消息生产者  * @author Administrator  */ @RestController public class QueueController {     @Autowired     private JmsMessagingTemplate jmsMessagingTemplate;       @RequestMapping("/send")     public void send(String text){          jmsMessagingTemplate.convertAndSend("itcast", text);     } }

（3）创建消息消费者

@Component public class Consumer {     @JmsListener(destination="itcast")     public void readMessage(String text){          System.out.println("接收到消息："+text);     }   }

测试：启动服务后，在浏览器执行

http://localhost:8088/send.do?text=aaaaa

即可看到控制台输出消息提示。Spring Boot内置了ActiveMQ的服务，所以我们不用单独启动也可以执行应用程序。

1.3.2使用外部服务

在src/main/resources下的application.properties增加配置, 指定ActiveMQ的地址

spring.activemq.broker-url=tcp://192.168.25.135:61616

运行后，会在activeMQ中看到发送的queue

1.3.3发送Map信息

（1）修改QueueController.java

@RequestMapping("/sendmap")     public void sendMap(){          Map map=new HashMap<>();          map.put("mobile", "13900001111");          map.put("content", "恭喜获得10元代金券");                jmsMessagingTemplate.convertAndSend("itcast_map",map);     }

（2）修改Consumer.java

@JmsListener(destination="itcast_map")     public void readMap(Map map){          System.out.println(map);          }

 

2.短信发送平台-阿里大于

2.1阿里大于简介

      阿里大于是阿里云旗下产品，融合了三大运营商的通信能力，通过将传统通信业务和能力与互联网相结合，创新融合阿里巴巴生态内容，全力为中小企业和开发者提供优质服务阿里大于提供包括短信、语音、流量直充、私密专线、店铺手机号等个性化服务。通过阿里大于打通三大运营商通信能力，全面融合阿里巴巴生态，以开放API及SDK的方式向开发者提供通信和数据服务，更好地支撑企业业务发展和创新服务。

2.2准备工作

2.2.1注册账户

首先我们先进入“阿里大于”  www.alidayu.com  （https://dayu.aliyun.com/）

注册账号后，再在手机下载“阿里云”应用，登陆，然后进行在线实名认证。

2.2.2登陆系统

使用刚才注册的账号进行登陆。

点击进入控制台

点击使用短信服务

 

3.2.3申请签名

 

 

3.2.4申请模板

 

 

 

3.2.5创建accessKey

3.3 SDK安装

从阿里云通信官网上下载Demo工程

解压后导入Eclipce

红线框起来的两个工程就是阿里云通信的依赖jar源码，我们将其安装到本地仓库

（删除aliyun-java-sdk-core的单元测试类）

本地jar包安装后 alicom-dysms-api工程引入依赖

<dependencies>     <dependency>          <groupId>com.aliyungroupId>          <artifactId>aliyun-java-sdk-dysmsapiartifactId>          <version>1.0.0-SNAPSHOTversion>     dependency>     <dependency>          <groupId>com.aliyungroupId>          <artifactId>aliyun-java-sdk-coreartifactId>          <version>3.2.5version>     dependency> dependencies>

红叉消失了 :-)

3.4发送短信测试

（1）打开SmsDemo

替换下列几处代码

这个accessKeyId和accessSecret到刚才申请过的

手机号，短信签名和模板号

模板参数

number是我们申请模板时写的参数

执行main方法我们就可以在手机收到短信啦

 

3.短信微服务

3.1需求分析

构建一个通用的短信发送服务（独立于品优购的单独工程），接收activeMQ的消息（MAP类型）  消息包括手机号（mobile）、短信模板号（template_code）、签名（sign_name）、参数字符串（param ）

3.2代码实现

3.2.1工程搭建

（1）创建工程itcast_sms （JAR工程），POM文件引入依赖 

<properties>       <java.version>1.7java.version>   properties>   <parent>     <groupId>org.springframework.bootgroupId>     <artifactId>spring-boot-starter-parentartifactId>     <version>1.4.0.RELEASEversion>   parent>    <dependencies>     <dependency>         <groupId>org.springframework.bootgroupId>         <artifactId>spring-boot-starter-webartifactId>     dependency>     <dependency>         <groupId>org.springframework.bootgroupId>         <artifactId>spring-boot-starter-activemqartifactId>     dependency>     <dependency>          <groupId>com.aliyungroupId>          <artifactId>aliyun-java-sdk-dysmsapiartifactId>          <version>1.0.0-SNAPSHOTversion>      dependency>      <dependency>          <groupId>com.aliyungroupId>          <artifactId>aliyun-java-sdk-coreartifactId>          <version>3.2.5version>      dependency>   dependencies>

（2）创建引导类

package cn.itcast.sms; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application {     public static void main(String[] args) {          SpringApplication.run(Application.class, args);     } }

（3）创建配置文件application.properties

server.port=9003 spring.activemq.broker-url=tcp://192.168.25.135:61616 accessKeyId=不告诉你 accessKeySecret=不告诉你

3.2.2短信工具类

参照之前的短信demo创建短信工具类

package cn.itcast.sms; import com.aliyuncs.DefaultAcsClient; import com.aliyuncs.IAcsClient; import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsRequest; import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsResponse; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse; import com.aliyuncs.exceptions.ClientException; import com.aliyuncs.profile.DefaultProfile; import com.aliyuncs.profile.IClientProfile; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.env.Environment; import org.springframework.stereotype.Component; /**  * 短信工具类  * @author Administrator  *  */ @Component public class SmsUtil {       //产品名称:云通信短信API产品,开发者无需替换     static final String product = "Dysmsapi";     //产品域名,开发者无需替换     static final String domain = "dysmsapi.aliyuncs.com";         @Autowired     private Environment env;       // TODO 此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)         /**      * 发送短信      * @param mobile 手机号      * @param template_code 模板号      * @param sign_name 签名      * @param param 参数      * @return      * @throws ClientException      */     public SendSmsResponse sendSms(String mobile,String template_code,String sign_name,String param) throws ClientException {       String accessKeyId =env.getProperty("accessKeyId");         String accessKeySecret = env.getProperty("accessKeySecret");             //可自助调整超时时间         System.setProperty("sun.net.client.defaultConnectTimeout", "10000");         System.setProperty("sun.net.client.defaultReadTimeout", "10000");           //初始化acsClient,暂不支持region化         IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);         DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);         IAcsClient acsClient = new DefaultAcsClient(profile);           //组装请求对象-具体描述见控制台-文档部分内容         SendSmsRequest request = new SendSmsRequest();         //必填:待发送手机号         request.setPhoneNumbers(mobile);         //必填:短信签名-可在短信控制台中找到         request.setSignName(sign_name);         //必填:短信模板-可在短信控制台中找到         request.setTemplateCode(template_code);         //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为         request.setTemplateParam(param);           //选填-上行短信扩展码(无特殊需求用户请忽略此字段)         //request.setSmsUpExtendCode("90997");           //可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者         request.setOutId("yourOutId");           //hint 此处可能会抛出异常，注意catch         SendSmsResponse sendSmsResponse = acsClient.getAcsResponse(request);           return sendSmsResponse;     }       public  QuerySendDetailsResponse querySendDetails(String mobile,String bizId) throws ClientException {     String accessKeyId =env.getProperty("accessKeyId");         String accessKeySecret = env.getProperty("accessKeySecret");         //可自助调整超时时间         System.setProperty("sun.net.client.defaultConnectTimeout", "10000");         System.setProperty("sun.net.client.defaultReadTimeout", "10000");         //初始化acsClient,暂不支持region化         IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);         DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);         IAcsClient acsClient = new DefaultAcsClient(profile);         //组装请求对象         QuerySendDetailsRequest request = new QuerySendDetailsRequest();         //必填-号码         request.setPhoneNumber(mobile);         //可选-流水号         request.setBizId(bizId);         //必填-发送日期 支持30天内记录查询，格式yyyyMMdd         SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");         request.setSendDate(ft.format(new Date()));         //必填-页大小         request.setPageSize(10L);         //必填-当前页码从1开始计数         request.setCurrentPage(1L);         //hint 此处可能会抛出异常，注意catch         QuerySendDetailsResponse querySendDetailsResponse = acsClient.getAcsResponse(request);         return querySendDetailsResponse;     } }

3.2.3消息监听类

创建SmsListener.java

package cn.itcast.sms; import java.util.Map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jms.annotation.JmsListener; import org.springframework.stereotype.Component; import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse; import com.aliyuncs.exceptions.ClientException; /**  * 消息监听类  * @author Administrator  */ @Component public class SmsListener {     @Autowired     private SmsUtil smsUtil;         @JmsListener(destination="sms")     public void sendSms(Map map){                try {              SendSmsResponse response = smsUtil.sendSms(                       map.get("mobile"),                       map.get("template_code"),                       map.get("sign_name"),                       map.get("param")  );                                    System.out.println("Code=" + response.getCode());                  System.out.println("Message=" + response.getMessage());                  System.out.println("RequestId=" + response.getRequestId());                  System.out.println("BizId=" + response.getBizId());                   } catch (ClientException e) {              e.printStackTrace();                   }            } }

3.3代码测试

修改springboot-demo  的QueueController.java

@RequestMapping("/sendsms")     public void sendSms(){          Map map=new HashMap<>();          map.put("mobile", "13900001111");          map.put("template_code", "SMS_85735065");           map.put("sign_name", "黑马");          map.put("param", "{\"number\":\"102931\"}");          jmsMessagingTemplate.convertAndSend("sms",map);     }

启动itcast_sms

启动springboot-demo

地址栏输入：http://localhost:8088/sendsms.do

观察控制台输出

随后短信也成功发送到你的手机上

4.用户注册

4.1需求分析

完成用户注册功能

4.2工程搭建

4.2.1用户服务接口层

（1）创建pinyougou-user-interface（jar）

（2）引入pojo依赖

4.2.2用户服务实现层

（1）创建pinyougou-user-service（war）

（2）引入spring  dubbox   activeMQ相关依赖，引入依赖（ pinyougou-user-interface  pinyougou-dao  pinyougou-common），运行端口为9006

（3）添加web.xml 

（4）创建Spring 配置文件applicationContext-service.xml 和applicationContent-tx.xml

<dubbo:protocol name="dubbo" port="20886" />     <dubbo:annotation package="com.pinyougou.user.service.impl" />      <dubbo:application name="pinyougou-user-service"/>      <dubbo:registry address="zookeeper://192.168.25.135:2181"/>

4.2.3用户中心WEB层

创建war工程  pinyougou-user-web 我们将注册功能放入此工程

（1）添加web.xml

（2）引入依赖pinyougou-user-interface 、spring相关依赖（参照其它web工程）,tomcat运行端口9106

（3）添加spring配置文件

（4）拷贝静态原型页面register.html 及相关资源

4.3基本注册功能实现

4.3.1生成和拷贝代码

4.3.2后端服务实现层

修改pinyougou-user-service的UserServiceImpl.java

/**      * 增加      */     @Override     public void add(TbUser user) {          user.setCreated(new Date());//创建日期          user.setUpdated(new Date());//修改日期          String password = DigestUtils.md5Hex(user.getPassword());//对密码加密          user.setPassword(password);          userMapper.insert(user);          }

 

4.3.3前端控制层

修改userController.js

//控制层 app.controller('userController' ,function($scope,$controller   ,userService){        //注册     $scope.reg=function(){                if($scope.entity.password!=$scope.password)  {              alert("两次输入的密码不一致，请重新输入");                         return ;         }                 userService.add( $scope.entity  ).success(              function(response){                   alert(response.message);              }                 );                   }    });

4.3.4修改页面

修改页面register.html ，引入js

<script type="text/javascript" src="plugins/angularjs/angular.min.js">script> <script type="text/javascript" src="js/base.js">script>   <script type="text/javascript" src="js/service/userService.js">script> <script type="text/javascript" src="js/controller/userController.js">script>

指令

<body ng-app="pinyougou" ng-controller="userController" >

绑定表单

"sui-form form-horizontal">          "control-group">              "control-label">用户名：              "controls">                   "text" placeholder="请输入你的用户名" ng-model="entity.username" class="input-xfat input-xlarge">                                "control-group">                 "inputPassword" class="control-label">登录密码：              "controls">                   "password" placeholder="设置登录密码" ng-model="entity.password" class="input-xfat input-xlarge">                                "control-group">              "inputPassword" class="control-label">确认密码：              "controls">                                "password" placeholder="再次确认密码" ng-model="password" class="input-xfat input-xlarge">                                "control-group">                   "control-label">手机号：                   "controls">                   "text" placeholder="请输入你的手机号" ng-model="entity.phone" class="input-xfat input-xlarge">                                     "control-group">                   "inputPassword" class="control-label">短信验证码：                   "controls">                       "text" placeholder="短信验证码" class="input-xfat input-xlarge">  "#">获取短信验证码                                     "control-group">                   "inputPassword" class="control-label">                         "controls">                   "m1" type="checkbox" value="2" checked="">同意协议并注册《品优购用户协议》                                     "control-group">              "control-label">              "controls btn-reg">                   "sui-btn btn-block btn-xlarge btn-danger" ng-click="reg()" target="_blank">完成注册

4.4 注册判断短信验证码

4.4.1实现思路

点击页面上的”获取短信验证码”连接，向后端传递手机号。后端随机生成6位数字作为短信验证码，将其保存在redis中（手机号作为KEY），并发送到短信网关。

用户注册时，后端根据手机号查询redis中的验证码与用户填写的验证码是否相同，如果不同则提示用户不能注册。

4.4.2生成验证码

（1）修改pinyougou-user-interface工程UserService.java  ，增加方法

/**      * 生成短信验证码      * @return      */     public void createSmsCode(String phone);

（2）修改pinyougou-user-service工程的UserServiceImpl.java

@Autowired     private RedisTemplate redisTemplate;      /**      * 生成短信验证码      */     public void createSmsCode(String phone){          //生成6位随机数          String code =  (long) (Math.random()*1000000)+"";          System.out.println("验证码："+code);          //存入缓存          redisTemplate.boundHashOps("smscode").put(phone, code);          //发送到activeMQ ....     }

（3）在 pinyougou-common  添加工具类PhoneFormatCheckUtils.java，用于验证手机号

（4）修改pinyougou-user-web的UserController.java

/**      * 发送短信验证码      * @param phone      * @return      */     @RequestMapping("/sendCode")     public Result sendCode(String phone){          //判断手机号格式          if(!PhoneFormatCheckUtils.isPhoneLegal(phone)){              return new Result(false, "手机号格式不正确");          }                 try {              userService.createSmsCode(phone);//生成验证码              return new Result(true, "验证码发送成功");          } catch (Exception e) {              e.printStackTrace();              return new Result(true, "验证码发送失败");          }            }

 

1. pinyougou-user-web的userService.js

//发送验证码     this.sendCode=function(phone){          return $http.get("../user/sendCode.do?phone="+phone);     }

 

1. pinyougou-user-web的userController.js

//发送验证码     $scope.sendCode=function(){          if($scope.entity.phone==null){              alert("请输入手机号！");              return ;          }                 userService.sendCode($scope.entity.phone).success(              function(response){                   alert(response.message);                                             }                          );     }

1. 修改页面register.html

<a ng-click="sendCode()" >获取短信验证码a>

 

4.4.3用户注册判断验证码

（1）修改pinyougou-user-interface的UserService.java

/**      * 判断短信验证码是否存在      * @param phone      * @return      */     public boolean  checkSmsCode(String phone,String code);

（2）修改pinyougou-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）修改pinyougou-user-web的UserController.java

/**      * 增加      * @param user      * @return      */     @RequestMapping("/add")     public Result add(@RequestBody TbUser user,String smscode){          boolean checkSmsCode = userService.checkSmsCode(user.getPhone(), smscode);          if(checkSmsCode==false){              return new Result(false, "验证码输入错误！");                     }                try {              userService.add(user);              return new Result(true, "增加成功");          } catch (Exception e) {              e.printStackTrace();              return new Result(false, "增加失败");          }     }

1. 修改pinyougou-user-web的userService.js

//增加     this.add=function(entity,smscode){          return  $http.post('../user/add.do?smscode='+smscode ,entity );     }

1. 修改pinyougou-portal-web 的UserController.java

//保存     $scope.reg=function(){                              userService.add( $scope.entity, $scope.smscode  ).success(              function(response){                                 alert(response.message);              }                 );                   }

（6）修改页面，绑定变量

"text" placeholder="短信验证码" ng-model="smscode" class="input-xfat input-xlarge">  "#" ng-click="sendCode()">获取短信验证码

 

4.4.4短信验证码发送到手机

（1）在pinyougou-user-service添加配置文件applicationContext-activemq.xml

<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">          <property name="brokerURL" value="tcp://192.168.25.135:61616"/>      bean>           <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">                <property name="targetConnectionFactory" ref="targetConnectionFactory"/>      bean>               <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">                    <property name="connectionFactory" ref="connectionFactory"/>      bean>                <bean id="smsDestination" class="org.apache.activemq.command.ActiveMQQueue">          <constructor-arg value="sms"/>      bean>

 

（2）修改pinyougou-user-service的UserServiceImpl.java

@Autowired     private JmsTemplate jmsTemplate;      @Autowired     private Destination smsDestination;         @Value("${template_code}")     private String template_code;         @Value("${sign_name}")     private String sign_name;         /**      * 生成短信验证码      */     public void createSmsCode(final String phone){              //生成6位随机数          final String code =  (long) (Math.random()*1000000)+"";          System.out.println("验证码："+code);          //存入缓存          redisTemplate.boundHashOps("smscode").put(phone, code);          //发送到activeMQ               jmsTemplate.send(smsDestination, new MessageCreator() {                      @Override              public Message createMessage(Session session) throws JMSException {                   MapMessage mapMessage = session.createMapMessage();                               mapMessage.setString("mobile", phone);//手机号                   mapMessage.setString("template_code", "SMS_85735065");//模板编号                   mapMessage.setString("sign_name", "黑马");//签名                                   Map m=new HashMap<>();                   m.put("number", code);                                   mapMessage.setString("param", JSON.toJSONString(m));//参数                   return mapMessage;              }          });                  }

（3）在pinyougou-common的properties目录下创建配置文件sms.properties

template_code=SMS_85735065 sign_name=\u9ED1\u9A6C

 

 

 

 

 

 

附录A.  Spring Boot应用启动器

spring Boot应用启动器基本的一共有44种，具体如下：

1）spring-boot-starter 
这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。

2）spring-boot-starter-actuator 
帮助监控和管理应用。

3）spring-boot-starter-amqp 
通过spring-rabbit来支持AMQP协议（Advanced Message Queuing Protocol）。

4）spring-boot-starter-aop 
支持面向方面的编程即AOP，包括spring-aop和AspectJ。

5）spring-boot-starter-artemis 
通过Apache Artemis支持JMS的API（Java Message Service API）。

6）spring-boot-starter-batch 
支持Spring Batch，包括HSQLDB数据库。

7）spring-boot-starter-cache 
支持Spring的Cache抽象。

8）spring-boot-starter-cloud-connectors 
支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。

9）spring-boot-starter-data-elasticsearch 
支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。

10）spring-boot-starter-data-gemfire 
支持GemFire分布式数据存储，包括spring-data-gemfire。

11）spring-boot-starter-data-jpa 
支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、hibernate。

12）spring-boot-starter-data-MongoDB 
支持MongoDB数据，包括spring-data-mongodb。

13）spring-boot-starter-data-rest 
通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。

14）spring-boot-starter-data-solr 
支持Apache Solr搜索平台，包括spring-data-solr。

15）spring-boot-starter-freemarker 
支持FreeMarker模板引擎。

16）spring-boot-starter-groovy-templates 
支持Groovy模板引擎。

17）spring-boot-starter-hateoas 
通过spring-hateoas支持基于HATEOAS的RESTful Web服务。

18）spring-boot-starter-hornetq 
通过HornetQ支持JMS。

19）spring-boot-starter-integration 
支持通用的spring-integration模块。

20）spring-boot-starter-jdbc 
支持JDBC数据库。

21）spring-boot-starter-jersey 
支持Jersey RESTful Web服务框架。

22）spring-boot-starter-jta-atomikos 
通过Atomikos支持JTA分布式事务处理。

23）spring-boot-starter-jta-bitronix 
通过Bitronix支持JTA分布式事务处理。

24）spring-boot-starter-mail 
支持javax.mail模块。

25）spring-boot-starter-mobile 
支持spring-mobile。

26）spring-boot-starter-mustache 
支持Mustache模板引擎。

27）spring-boot-starter-Redis 
支持Redis键值存储数据库，包括spring-redis。

28）spring-boot-starter-security 
支持spring-security。

29）spring-boot-starter-social-facebook 
支持spring-social-facebook

30）spring-boot-starter-social-linkedin 
支持pring-social-linkedin

31）spring-boot-starter-social-twitter 
支持pring-social-twitter

32）spring-boot-starter-test 
支持常规的测试依赖，包括JUnit、Hamcrest、Mockito以及spring-test模块。

33）spring-boot-starter-thymeleaf 
支持Thymeleaf模板引擎，包括与Spring的集成。

34）spring-boot-starter-velocity 
支持Velocity模板引擎。

35）spring-boot-starter-web 
S支持全栈式Web开发，包括Tomcat和spring-webmvc。

36）spring-boot-starter-websocket 
支持WebSocket开发。

37）spring-boot-starter-ws 
支持Spring Web Services。

Spring Boot应用启动器面向生产环境的还有2种，具体如下：

1）spring-boot-starter-actuator 
增加了面向产品上线相关的功能，比如测量和监控。

2）spring-boot-starter-remote-shell 
增加了远程ssh shell的支持。

最后，Spring Boot应用启动器还有一些替换技术的启动器，具体如下：

1）spring-boot-starter-jetty 
引入了Jetty HTTP引擎（用于替换Tomcat）。

2）spring-boot-starter-log4j 
支持Log4J日志框架。

3）spring-boot-starter-logging 
引入了Spring Boot默认的日志框架Logback。

4）spring-boot-starter-tomcat 
引入了Spring Boot默认的HTTP引擎Tomcat。

5）spring-boot-starter-undertow 
引入了Undertow HTTP引擎（用于替换Tomcat）。

附录B.  Spring Boot 配置文件application.properties

#########COMMON SPRING BOOT PROPERTIES ######========CORE PROPERTIES=========== #SPRING CONFIG (ConfigFileApplicationListener)   spring.config.name= # config file name (default to 'application') spring.config.location= # location of config file   #PROFILES spring.profiles= # comma list of active profiles   #APPLICATION SETTINGS (SpringApplication) spring.main.sources= spring.main.web-environment= # detect by default spring.main.show-banner=true spring.main....= # see class for all properties   #LOGGING logging.path=/var/logs logging.file=myapp.log logging.config=   #IDENTITY (ContextIdApplicationContextInitializer) spring.application.name= spring.application.index=   #EMBEDDED SERVER CONFIGURATION (ServerProperties) server.port=8080 server.address= # bind to a specific NIC server.session-timeout= # session timeout in seconds server.context-path= # the context path, defaults to '/' server.servlet-path= # the servlet path, defaults to '/' server.tomcat.access-log-pattern= # log pattern of the access log server.tomcat.access-log-enabled=false # is access logging enabled server.tomcat.protocol-header=x-forwarded-proto # ssl forward headers server.tomcat.remote-ip-header=x-forwarded-for server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp) server.tomcat.background-processor-delay=30; # in seconds server.tomcat.max-threads = 0 # number of threads in protocol handler server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding   #SPRING MVC (HttpMapperProperties) http.mappers.json-pretty-print=false # pretty print JSON http.mappers.json-sort-keys=false # sort keys spring.mvc.locale= # set fixed locale, e.g. enUK spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy spring.mvc.message-codes-resolver-format= # PREFIXERRORCODE / POSTFIXERROR_CODE spring.view.prefix= # MVC view prefix spring.view.suffix= # ... and suffix spring.resources.cache-period= # cache timeouts in headers sent to browser spring.resources.add-mappings=true # if default mappings should be added   #THYMELEAF (ThymeleafAutoConfiguration) spring.thymeleaf.prefix=classpath:/templates/ spring.thymeleaf.suffix=.html spring.thymeleaf.mode=HTML5 spring.thymeleaf.encoding=UTF-8 spring.thymeleaf.content-type=text/html # ;charset= is added spring.thymeleaf.cache=true # set to false for hot refresh   #FREEMARKER (FreeMarkerAutoConfiguration) spring.freemarker.allowRequestOverride=false spring.freemarker.allowSessionOverride=false spring.freemarker.cache=true spring.freemarker.checkTemplateLocation=true spring.freemarker.contentType=text/html spring.freemarker.exposeRequestAttributes=false spring.freemarker.exposeSessionAttributes=false spring.freemarker.exposeSpringMacroHelpers=false spring.freemarker.prefix= spring.freemarker.requestContextAttribute= spring.freemarker.settings.*= spring.freemarker.suffix=.ftl spring.freemarker.templateEncoding=UTF-8 spring.freemarker.templateLoaderPath=classpath:/templates/ spring.freemarker.viewNames= # whitelist of view names that can be resolved   #GROOVY TEMPLATES (GroovyTemplateAutoConfiguration) spring.groovy.template.allowRequestOverride=false spring.groovy.template.allowSessionOverride=false spring.groovy.template.cache=true spring.groovy.template.configuration.*= # See Groovy's TemplateConfiguration spring.groovy.template.contentType=text/html spring.groovy.template.prefix=classpath:/templates/ spring.groovy.template.suffix=.tpl spring.groovy.template.templateEncoding=UTF-8 spring.groovy.template.viewNames= # whitelist of view names that can be resolved   #VELOCITY TEMPLATES (VelocityAutoConfiguration) spring.velocity.allowRequestOverride=false spring.velocity.allowSessionOverride=false spring.velocity.cache=true spring.velocity.checkTemplateLocation=true spring.velocity.contentType=text/html spring.velocity.dateToolAttribute= spring.velocity.exposeRequestAttributes=false spring.velocity.exposeSessionAttributes=false spring.velocity.exposeSpringMacroHelpers=false spring.velocity.numberToolAttribute= spring.velocity.prefix= spring.velocity.properties.*= spring.velocity.requestContextAttribute= spring.velocity.resourceLoaderPath=classpath:/templates/ spring.velocity.suffix=.vm spring.velocity.templateEncoding=UTF-8 spring.velocity.viewNames= # whitelist of view names that can be resolved   #INTERNATIONALIZATION (MessageSourceAutoConfiguration) spring.messages.basename=messages spring.messages.cacheSeconds=-1 spring.messages.encoding=UTF-8   #SECURITY (SecurityProperties) security.user.name=user # login username security.user.password= # login password security.user.role=USER # role assigned to the user security.require-ssl=false # advanced settings ... security.enable-csrf=false security.basic.enabled=true security.basic.realm=Spring security.basic.path= # /** security.headers.xss=false security.headers.cache=false security.headers.frame=false security.headers.contentType=false security.headers.hsts=all # none / domain / all security.sessions=stateless # always / never / if_required / stateless security.ignored=false   #DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties) spring.datasource.name= # name of the data source spring.datasource.initialize=true # populate using data.sql spring.datasource.schema= # a schema (DDL) script resource reference spring.datasource.data= # a data (DML) script resource reference spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql) spring.datasource.continueOnError=false # continue even if can't be initialized spring.datasource.separator=; # statement separator in SQL initialization scripts spring.datasource.driverClassName= # JDBC Settings... spring.datasource.url= spring.datasource.username= spring.datasource.password= spring.datasource.max-active=100 # Advanced configuration... spring.datasource.max-idle=8 spring.datasource.min-idle=8 spring.datasource.initial-size=10 spring.datasource.validation-query= spring.datasource.test-on-borrow=false spring.datasource.test-on-return=false spring.datasource.test-while-idle= spring.datasource.time-between-eviction-runs-millis= spring.datasource.min-evictable-idle-time-millis= spring.datasource.max-wait-millis=   #MONGODB (MongoProperties) spring.data.mongodb.host= # the db host spring.data.mongodb.port=27017 # the connection port (defaults to 27107) spring.data.mongodb.uri=mongodb://localhost/test # connection URL spring.data.mongo.repositories.enabled=true # if spring data repository support is enabled   #JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration) spring.jpa.properties.*= # properties to set on the JPA connection spring.jpa.openInView=true spring.jpa.show-sql=true spring.jpa.database-platform= spring.jpa.database= spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors spring.jpa.hibernate.naming-strategy= # naming classname spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled   #SOLR (SolrProperties}) spring.data.solr.host=http://127.0.0.1:8983/solr spring.data.solr.zkHost= spring.data.solr.repositories.enabled=true # if spring data repository support is enabled   #ELASTICSEARCH (ElasticsearchProperties}) spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch) spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated; if not specified starts a client node) spring.data.elasticsearch.local=true # if local mode should be used with client nodes spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is enabled   #FLYWAY (FlywayProperties) flyway.locations=classpath:db/migrations # locations of migrations scripts flyway.schemas= # schemas to update flyway.initVersion= 1 # version to start migration flyway.prefix=V flyway.suffix=.sql flyway.enabled=true flyway.url= # JDBC url if you want Flyway to create its own DataSource flyway.user= # JDBC username if you want Flyway to create its own DataSource flyway.password= # JDBC password if you want Flyway to create its own DataSource   #LIQUIBASE (LiquibaseProperties) liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml liquibase.contexts= # runtime contexts to use liquibase.default-schema= # default database schema to use liquibase.drop-first=false liquibase.enabled=true   #JMX spring.jmx.enabled=true # Expose MBeans from Spring   #ABBIT (RabbitProperties) spring.rabbitmq.host= # connection host spring.rabbitmq.port= # connection port spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111) spring.rabbitmq.username= # login user spring.rabbitmq.password= # login password spring.rabbitmq.virtualhost= spring.rabbitmq.dynamic=   #REDIS (RedisProperties) spring.redis.host=localhost # server host spring.redis.password= # server password spring.redis.port=6379 # connection port spring.redis.pool.max-idle=8 # pool settings ... spring.redis.pool.min-idle=0 spring.redis.pool.max-active=8 spring.redis.pool.max-wait=-1   #ACTIVEMQ (ActiveMQProperties) spring.activemq.broker-url=tcp://localhost:61616 # connection URL spring.activemq.user= spring.activemq.password= spring.activemq.in-memory=true # broker kind to create if no broker-url is specified spring.activemq.pooled=false   #HornetQ (HornetQProperties) spring.hornetq.mode= # connection mode (native, embedded) spring.hornetq.host=localhost # hornetQ host (native mode) spring.hornetq.port=5445 # hornetQ port (native mode) spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar) spring.hornetq.embedded.serverId= # auto-generated id of the embedded server (integer) spring.hornetq.embedded.persistent=false # message persistence spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled) spring.hornetq.embedded.queues= # comma separate queues to create on startup spring.hornetq.embedded.topics= # comma separate topics to create on startup spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)   #JMS (JmsProperties) spring.jms.pub-sub-domain= # false for queue (default), true for topic   #SPRING BATCH (BatchDatabaseInitializer) spring.batch.job.names=job1,job2 spring.batch.job.enabled=true spring.batch.initializer.enabled=true spring.batch.schema= # batch schema to load   #AOP spring.aop.auto= spring.aop.proxy-target-class=   #FILE ENCODING (FileEncodingApplicationListener) spring.mandatory-file-encoding=false   #SPRING SOCIAL (SocialWebAutoConfiguration) spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own   #SPRING SOCIAL FACEBOOK (FacebookAutoConfiguration) spring.social.facebook.app-id= # your application's Facebook App ID spring.social.facebook.app-secret= # your application's Facebook App Secret   #SPRING SOCIAL LINKEDIN (LinkedInAutoConfiguration) spring.social.linkedin.app-id= # your application's LinkedIn App ID spring.social.linkedin.app-secret= # your application's LinkedIn App Secret   #SPRING SOCIAL TWITTER (TwitterAutoConfiguration) spring.social.twitter.app-id= # your application's Twitter App ID spring.social.twitter.app-secret= # your application's Twitter App Secret   #SPRING MOBILE SITE PREFERENCE (SitePreferenceAutoConfiguration) spring.mobile.sitepreference.enabled=true # enabled by default   #SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration) spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default spring.mobile.devicedelegatingviewresolver.normalPrefix= spring.mobile.devicedelegatingviewresolver.normalSuffix= spring.mobile.devicedelegatingviewresolver.mobilePrefix=mobile/ spring.mobile.devicedelegatingviewresolver.mobileSuffix= spring.mobile.devicedelegatingviewresolver.tabletPrefix=tablet/ spring.mobile.devicedelegatingviewresolver.tabletSuffix=   ######========ACTUATOR PROPERTIES===========   #MANAGEMENT HTTP SERVER (ManagementServerProperties) management.port= # defaults to 'server.port' management.address= # bind to a specific NIC management.contextPath= # default to '/'   #ENDPOINTS (AbstractEndpoint subclasses) endpoints.autoconfig.id=autoconfig endpoints.autoconfig.sensitive=true endpoints.autoconfig.enabled=true endpoints.beans.id=beans endpoints.beans.sensitive=true endpoints.beans.enabled=true endpoints.configprops.id=configprops endpoints.configprops.sensitive=true endpoints.configprops.enabled=true endpoints.configprops.keys-to-sanitize=password,secret endpoints.dump.id=dump endpoints.dump.sensitive=true endpoints.dump.enabled=true endpoints.env.id=env endpoints.env.sensitive=true endpoints.env.enabled=true endpoints.health.id=health endpoints.health.sensitive=false endpoints.health.enabled=true endpoints.info.id=info endpoints.info.sensitive=false endpoints.info.enabled=true endpoints.metrics.id=metrics endpoints.metrics.sensitive=true endpoints.metrics.enabled=true endpoints.shutdown.id=shutdown endpoints.shutdown.sensitive=true endpoints.shutdown.enabled=false endpoints.trace.id=trace endpoints.trace.sensitive=true endpoints.trace.enabled=true   #MVC ONLY ENDPOINTS endpoints.jolokia.path=jolokia endpoints.jolokia.sensitive=true endpoints.jolokia.enabled=true # when using Jolokia endpoints.error.path=/error   #JMX ENDPOINT (EndpointMBeanExportProperties) endpoints.jmx.enabled=true endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot' endpoints.jmx.unique-names=false endpoints.jmx.enabled=true endpoints.jmx.staticNames=   #JOLOKIA (JolokiaProperties) jolokia.config.*= # See Jolokia manual   #REMOTE SHELL shell.auth=simple # jaas, key, simple, spring shell.command-refresh-interval=-1 shell.command-path-pattern= # classpath:/commands/, classpath:/crash/commands/ shell.config-path-patterns= # classpath:/crash/ shell.disabled-plugins=false # don't expose plugins shell.ssh.enabled= # ssh settings ... shell.ssh.keyPath= shell.ssh.port= shell.telnet.enabled= # telnet settings ... shell.telnet.port= shell.auth.jaas.domain= # authentication settings ... shell.auth.key.path= shell.auth.simple.user.name= shell.auth.simple.user.password= shell.auth.spring.roles=   #GIT INFO spring.git.properties= # resource ref to generated git info properties file