189 8069 5689

SpringBoot：企业常用的Starter以及实现

目录

十年的怀宁网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都全网营销的优势是能够根据用户设备显示端的尺寸不同，自动调整怀宁建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联公司从事“怀宁网站设计”,“怀宁网站推广”以来，每个客户项目都认真落实执行。

  •  SpringBoot简介
  •  SpringBoot运行
  •  SpringBoot目录结构
  •  整合JdbcTemplate
  •  @RestController
  •  整合JSP
  •  整合JPA
  •  整合MyBatis
  •  AOP功能使用
  •  任务调度
  •  整合RabbitMq
  •  整合邮件发送

SpringBoot简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

Spring Boot的主要优点：

1、为所有Spring开发者更快的入门

2、开箱即用，提供各种默认配置来简化项目配置

3、内嵌式容器简化Web项目

4、没有冗余代码生成和XML配置的要求

在下面的代码中只要有一定基础会发现这写代码实例非常简单对于开发者来说几乎是“零配置”。

SpringBoot运行

开发工具：jdk8，IDEA,STS，eclipse（需要安装STS插件）这些都支持快速启动SpringBoot工程。我这里就不快速启动了，使用maven工程。学习任何一项技术首先就要精通HelloWord，那我们来跑个初体验。

首先只用maven我们创建的maven工程直接以jar包的形式创建就行了，首先我们来引入SpringBoot的依赖

首先我们需要依赖SpringBoot父工程，这是每个项目中必须要有的。

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.   org.springframework.boot 
    4. 
  
  
  
  4.   spring-boot-starter-parent 
    5. 
  
  
  
  5.   2.0.5.RELEASE 
    6. 
  
  
  
  6.     
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.   UTF-8 
    11. 
  
  
  
  11.   UTF-8 
    12. 
  
  
  
  12.   1.8
    13. 
  
  
  
  13.  
    14.

我们启动WEB模块当然必须要引入WEB模块的依赖

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.    
    3. 
  
  
  
  3.    
    4. 
  
  
  
  4.    org.springframework.boot 
    5. 
  
  
  
  5.    spring-boot-starter-web 
    6. 
  
  
  
  6.    
    7. 
  
  
  
  7.  
    8.

我们需要编写一个SpringBoot启动类，SpringbootFirstExperienceApplication.java

 
 
 
    
  
  
  
  1. @SpringBootApplication 
    2. 
  
  
  
  2. public class SpringbootFirstExperienceApplication { 
    3. 
  
  
  
  3.  public static void main(String[] args) { 
    4. 
  
  
  
  4.   SpringApplication.run(SpringbootFirstExperienceApplication.class, args); 
    5. 
  
  
  
  5.  } 
    6. 
  
  
  
  6. }
    7.

到了这里我们直接把他当成SpringMVC来使用就行了，不过这里默认是不支持JSP官方推荐使用模板引擎，后面会写到整合JSP。这里我就不写Controller了。

@SpringBootApplication：之前用户使用的是3个注解注解他们的main类。分别是@Configuration,@EnableAutoConfiguration,@ComponentScan。由于这些注解一般都是一起使用，spring boot提供了一个统一的注解@SpringBootApplication。

注意事项：我们使用这个注解在不指定扫描路径的情况下，SpringBoot只能扫描到和SpringbootFirstExperienceApplication同包或子包的Bean；

SpringBoot目录结构

SpringBoot目录结构# 在src/main/resources中我们可以有几个文件夹：

templates：用来存储模板引擎的，Thymeleaf，FreeMarker，Velocity等都是不错的选择。

static：存储一些静态资源，css,js等

public：在默认SpringBoot工程中是不生成这个文件夹的，但是在自动配置中我们可以有这个文件夹用来存放公共的资源（html等）

application.properties:这个文件名字是固定的，SpringBoot启动会默认加载这些配置在这里面可以配置端口号，访问路径，数据库连接信息等等。这个文件非常重要，当然官方中推出了一个yml格式这是非常强大的数据格式。

整合JdbcTemplate

引入依赖：

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.   org.springframework.boot 
    3. 
  
  
  
  3.   spring-boot-starter-parent 
    4. 
  
  
  
  4.   1.5.2.RELEASE 
    5. 
  
  
  
  5.   
    6. 
  
  
  
  6.   
    7. 
  
  
  
  7.          
    8. 
  
  
  
  8.    
    9. 
  
  
  
  9.    org.springframework.boot 
    10. 
  
  
  
  10.    spring-boot-starter-web 
    11. 
  
  
  
  11.    
    12. 
  
  
  
  12.           
    13. 
  
  
  
  13.    
    14. 
  
  
  
  14.    org.springframework.boot 
    15. 
  
  
  
  15.    spring-boot-starter-jdbc 
    16. 
  
  
  
  16.    
    17. 
  
  
  
  17.           
    18. 
  
  
  
  18.    
    19. 
  
  
  
  19.    mysql 
    20. 
  
  
  
  20.    mysql-connector-java 
    21. 
  
  
  
  21.    
    22. 
  
  
  
  22.    
    23. 
  
  
  
  23.    org.springframework.boot 
    24. 
  
  
  
  24.    spring-boot-starter-test 
    25. 
  
  
  
  25.    test 
    26. 
  
  
  
  26.    
    27. 
  
  
  
  27.  
    28.

配置application.properties，虽然说是“零配置”但是这些必要的肯定要指定，否则它怎么知道连那个数据库？

 
 
 
    
  
  
  
  1. spring.datasource.url=jdbc:mysql://localhost:3306/mybatis 
    2. 
  
  
  
  2. spring.datasource.username=root 
    3. 
  
  
  
  3. spring.datasource.password=root 
    4. 
  
  
  
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    5.

使用方式：

 
 
 
    
  
  
  
  1. @Service 
    2. 
  
  
  
  2. public class EmployeeService { 
    3. 
  
  
  
  3.  @Autowired 
    4. 
  
  
  
  4.  private JdbcTemplate jdbcTemplate; 
    5. 
  
  
  
  5.  public boolean saveEmp(String name,String email,String gender){ 
    6. 
  
  
  
  6.   String sql = "insert into tal_employee values(null,?,?,?)"; 
    7. 
  
  
  
  7.   int result = jdbcTemplate.update(sql, name,email,gender); 
    8. 
  
  
  
  8.   System.out.println("result : " + result); 
    9. 
  
  
  
  9.   return result > 0 ? true:false; 
    10. 
  
  
  
  10.  } 
    11. 
  
  
  
  11. } 
    12. 
 
 
 
 
 
 
    
  
  
  
  1. @RestController 
    2. 
  
  
  
  2. public class EmployeeController { 
    3. 
  
  
  
  3.  @Autowired 
    4. 
  
  
  
  4.  private EmployeeService employeeService; 
    5. 
  
  
  
  5.  @RequestMapping("/save") 
    6. 
  
  
  
  6.  public String insert(String name,String email,String gender){ 
    7. 
  
  
  
  7.   boolean result = employeeService.saveEmp(name, email, gender); 
    8. 
  
  
  
  8.   if(result){
    9. 
  
  
  
  9.     return "success"; 
    10. 
  
  
  
  10.   } 
    11. 
  
  
  
  11.   return "error"; 
    12. 
  
  
  
  12.  } 
    13. 
  
  
  
  13. }
    14.

这里我们直接返回一个文本格式。

@RestController

在上面的代码中我们使用到这个注解修改我们的Controller类而是不使用@Controller这个注解，其实中包含了@Controller，同时包含@ResponseBody既然修饰在类上面那么就是表示这个类中所有的方法都是@ResponseBody所以在这里我们返回字符串在前台我们会以文本格式展示，如果是对象那么它会自动转换成json格式返回。

整合JSP

在创建整合JSP的时候指定要选WAR，一定要选WAR。

引入依赖：

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.     org.springframework.boot 
    3. 
  
  
  
  3.     spring-boot-starter-parent 
    4. 
  
  
  
  4.     1.5.2.RELEASE 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.      
    8. 
  
  
  
  8.      
    9. 
  
  
  
  9.         org.springframework.boot 
    10. 
  
  
  
  10.         spring-boot-starter-web 
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.      
    13. 
  
  
  
  13.      
    14. 
  
  
  
  14.         org.springframework.boot 
    15. 
  
  
  
  15.         spring-boot-starter-tomcat 
    16. 
  
  
  
  16.      
    17. 
  
  
  
  17.      
    18. 
  
  
  
  18.         org.apache.tomcat.embed 
    19. 
  
  
  
  19.         tomcat-embed-jasper 
    20. 
  
  
  
  20.      
    21. 
  
  
  
  21.

然后我们只需要配置试图解析器路径就可以了。

 
 
 
    
  
  
  
  1. #配置试图解析器前缀 
    2. 
  
  
  
  2. spring.mvc.view.prefix=/WEB-INF/views/ 
    3. 
  
  
  
  3. #配置试图解析器后缀 
    4. 
  
  
  
  4. spring.mvc.view.suffix=.jsp
    5.

整合JPA

同样的整合JPA我们只需要启动我们SpringBoot已经集成好的模块即可。

添加依赖：

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.   org.springframework.boot 
    3. 
  
  
  
  3.   spring-boot-starter-parent 
    4. 
  
  
  
  4.   1.5.2.RELEASE 
    5. 
  
  
  
  5.   
    6. 
  
  
  
  6.   
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8.    org.springframework.boot 
    9. 
  
  
  
  9.    spring-boot-starter-web 
    10. 
  
  
  
  10.    
    11. 
  
  
  
  11.          
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13.    org.springframework.boot 
    14. 
  
  
  
  14.    spring-boot-starter-data-jpa 
    15. 
  
  
  
  15.    
    16. 
  
  
  
  16.    
    17. 
  
  
  
  17.    org.springframework.boot 
    18. 
  
  
  
  18.    spring-boot-starter-test 
    19. 
  
  
  
  19.    test 
    20. 
  
  
  
  20.    
    21. 
  
  
  
  21.    
    22. 
  
  
  
  22.    mysql 
    23. 
  
  
  
  23.    mysql-connector-java 
    24. 
  
  
  
  24.    
    25. 
  
  
  
  25.  
    26.

启动JPA组件后直接配置数据库连接信息就可以使用JPA功能。

Application.properties

 
 
 
    
  
  
  
  1. spring.datasource.url=jdbc:mysql://localhost:3306/mybatis 
    2. 
  
  
  
  2. spring.datasource.username=root 
    3. 
  
  
  
  3. spring.datasource.password=root 
    4. 
  
  
  
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    5.

实体类：Employee.java

 
 
 
    
  
  
  
  1. @Table(name="tal_employee") 
    2. 
  
  
  
  2. @Entity 
    3. 
  
  
  
  3. public class Employee implements Serializable{ 
    4. 
  
  
  
  4.  @Id
    5. 
  
  
  
  5.  @GeneratedValue(strategy = GenerationType.AUTO) 
    6. 
  
  
  
  6.  private Integer id; 
    7. 
  
  
  
  7.  @Column(name="last_Name") 
    8. 
  
  
  
  8.  private String lastName; 
    9. 
  
  
  
  9.  private String email; 
    10. 
  
  
  
  10.  private String gender;
    11. 
  
  
  
  11.  //get set 省略 
    12. 
  
  
  
  12. }
    13.

EmployeeDao接口：

 
 
 
    
  
  
  
  1. public interface EmployeeDao extends JpaRepository{ 
    2. 
  
  
  
  2. }
    3.

EmployeeController.java:

 
 
 
    
  
  
  
  1. @Controller 
    2. 
  
  
  
  2. public class EmployeeController { 
    3. 
  
  
  
  3.  @Autowired 
    4. 
  
  
  
  4.  private EmployeeDao employeeDao; 
    5. 
  
  
  
  5.  @ResponseBody
    6. 
  
  
  
  6.  @RequestMapping("/emps") 
    7. 
  
  
  
  7.  public List getEmployees(){ 
    8. 
  
  
  
  8.   List employees = employeeDao.findAll(); 
    9. 
  
  
  
  9.   System.out.println(employees); 
    10. 
  
  
  
  10.   return employees; 
    11. 
  
  
  
  11.  } 
    12. 
  
  
  
  12. }
    13.

整合MyBatis

引入依赖：

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.   org.springframework.boot 
    3. 
  
  
  
  3.   spring-boot-starter-parent 
    4. 
  
  
  
  4.   1.5.2.RELEASE 
    5. 
  
  
  
  5.   
    6. 
  
  
  
  6.   
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8.     org.springframework.boot 
    9. 
  
  
  
  9.    spring-boot-starter-web 
    10. 
  
  
  
  10.    
    11. 
  
  
  
  11.          
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13.    org.springframework.boot
    14. 
  
  
  
  14.    spring-boot-starter-jdbc 
    15. 
  
  
  
  15.    
    16. 
  
  
  
  16.          
    17. 
  
  
  
  17.     
    18. 
  
  
  
  18.    org.springframework.boot 
    19. 
  
  
  
  19.    spring-boot-starter-logging 
    20. 
  
  
  
  20.    
    21. 
  
  
  
  21.   
    22. 
  
  
  
  22.     
    23. 
  
  
  
  23.    org.mybatis.spring.boot 
    24. 
  
  
  
  24.    mybatis-spring-boot-starter 
    25. 
  
  
  
  25.    1.2.2 
    26. 
  
  
  
  26.    
    27. 
  
  
  
  27.    
    28. 
  
  
  
  28.    org.springframework.boot 
    29. 
  
  
  
  29.    spring-boot-starter-test 
    30. 
  
  
  
  30.    test 
    31. 
  
  
  
  31.    
    32. 
  
  
  
  32.    
    33. 
  
  
  
  33.    mysql 
    34. 
  
  
  
  34.    mysql-connector-java 
    35. 
  
  
  
  35.   
    36. 
  
  
  
  36.   
    37.

配置application.properties

 
 
 
    
  
  
  
  1. spring.datasource.url=jdbc:mysql://localhost:3306/mybatis 
    2. 
  
  
  
  2. spring.datasource.username=root 
    3. 
  
  
  
  3. spring.datasource.password=root 
    4. 
  
  
  
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver 
    5. 
  
  
  
  5. ##############datasource classpath 数据连接池地址##############
    6. 
  
  
  
  6. #spring.datasource.type=com.alibaba.druid.pool.DruidDataSource 
    7. 
  
  
  
  7. #指定我们的mapper.xml位置
    8. 
  
  
  
  8.  mybatis.mapper-locations=classpath:com/simple/springboot/mybatis/dao/mapper/*.xml 
    9. 
  
  
  
  9. #entity.class 指定我们实体类所在包位置 
    10. 
  
  
  
  10. mybatis.type-aliases-package=com.simple.springboot.mybatis.entity
    11.

当然这里还有很多属性如果想要使用可以参考官方文档。到了这里其他就不写了，把他当作SSM使用就ok。

注意事项：在我们的Dao层接口中一定要在类上加上注解@Mapper否则无法扫描到。

AOP功能使用

在我们SpringBoot中使用AOP非常简单。

 
 
 
    
  
  
  
  1. package com.simple.springboot.aop; 
    2. 
  
  
  
  2. import org.aspectj.lang.ProceedingJoinPoint;
    3. 
  
  
  
  3. import org.aspectj.lang.annotation.After; 
    4. 
  
  
  
  4. import org.aspectj.lang.annotation.AfterThrowing; 
    5. 
  
  
  
  5. import org.aspectj.lang.annotation.Around; 
    6. 
  
  
  
  6. import org.aspectj.lang.annotation.Aspect; 
    7. 
  
  
  
  7. import org.aspectj.lang.annotation.Before; 
    8. 
  
  
  
  8. import org.aspectj.lang.annotation.Pointcut; 
    9. 
  
  
  
  9. import org.springframework.stereotype.Component; 
    10. 
  
  
  
  10. @Aspect 
    11. 
  
  
  
  11. @Component 
    12. 
  
  
  
  12. public class SpringBootAspect { 
    13. 
  
  
  
  13.  /** 
    14. 
  
  
  
  14.   * 定义一个切入点 
    15. 
  
  
  
  15.   * @author:SimpleWu 
    16. 
  
  
  
  16.   * @Date:2018年10月12日 
    17. 
  
  
  
  17.   */ 
    18. 
  
  
  
  18.  @Pointcut(value="execution(* com.simple.springboot.util.*.*(..))") 
    19. 
  
  
  
  19.  public void aop(){} 
    20. 
  
  
  
  20.  /** 
    21. 
  
  
  
  21.   * 定义一个前置通知 
    22. 
  
  
  
  22.   * @author:SimpleWu 
    23. 
  
  
  
  23.   * @Date:2018年10月12日 
    24. 
  
  
  
  24.   */ 
    25. 
  
  
  
  25.  @Before("aop()") 
    26. 
  
  
  
  26.  public void aopBefore(){ 
    27. 
  
  
  
  27.   System.out.println("前置通知 SpringBootAspect....aopBefore"); 
    28. 
  
  
  
  28.  } 
    29. 
  
  
  
  29.  /** 
    30. 
  
  
  
  30.   * 定义一个后置通知 
    31. 
  
  
  
  31.   * @author:SimpleWu 
    32. 
  
  
  
  32.   * @Date:2018年10月12日 
    33. 
  
  
  
  33.   */ 
    34. 
  
  
  
  34.  @After("aop()") 
    35. 
  
  
  
  35.  public void aopAfter(){ 
    36. 
  
  
  
  36.   System.out.println("后置通知  SpringBootAspect....aopAfter"); 
    37. 
  
  
  
  37.  } 
    38. 
  
  
  
  38.  /** 
    39. 
  
  
  
  39.   * 处理未处理的JAVA异常 
    40. 
  
  
  
  40.   * @author:SimpleWu 
    41. 
  
  
  
  41.   * @Date:2018年10月12日 
    42. 
  
  
  
  42.   */ 
    43. 
  
  
  
  43.  @AfterThrowing(pointcut="aop()",throwing="e") 
    44. 
  
  
  
  44.  public void exception(Exception e){
    45. 
  
  
  
  45.    System.out.println("异常通知 SpringBootAspect...exception .." + e); 
    46. 
  
  
  
  46.  } 
    47. 
  
  
  
  47.  /** 
    48. 
  
  
  
  48.   * 环绕通知 
    49. 
  
  
  
  49.   * @author:SimpleWu 
    50. 
  
  
  
  50.   * @throws Throwable  
    51. 
  
  
  
  51.   * @Date:2018年10月12日 
    52. 
  
  
  
  52.   */ 
    53. 
  
  
  
  53.  @Around("aop()") 
    54. 
  
  
  
  54.  public void around(ProceedingJoinPoint invocation) throws Throwable{ 
    55. 
  
  
  
  55.   System.out.println("SpringBootAspect..环绕通知 Before"); 
    56. 
  
  
  
  56.   invocation.proceed(); 
    57. 
  
  
  
  57.   System.out.println("SpringBootAspect..环绕通知 After"); 
    58. 
  
  
  
  58.  }
    59. 
  
  
  
  59.  }
    60.

任务调度

SpringBoot已经集成好一个调度功能。

 
 
 
    
  
  
  
  1. @Component 
    2. 
  
  
  
  2. public class ScheduledTasks { 
    3. 
  
  
  
  3.  private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss"); 
    4. 
  
  
  
  4.   /** 
    5. 
  
  
  
  5.   * 任务调度，每隔5秒执行一次 
    6. 
  
  
  
  6.   * @author:SimpleWu 
    7. 
  
  
  
  7.   * @Date:2018年10月12日 
    8. 
  
  
  
  8.   */ 
    9. 
  
  
  
  9.  @Scheduled(fixedRate = 1000)
    10. 
  
  
  
  10.      public void reportCurrentTime() { 
    11. 
  
  
  
  11.         System.out.println("现在时间：" + dateFormat.format(new Date())); 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13. }
    14.

然后启动的时候我们必须要在主函数类上加上注解：@EnableScheduling（翻译过来就是开启调度）

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.  * SpringBoot使用任务调度 
    3. 
  
  
  
  3.  * @EnableScheduling标注程序开启任务调度 
    4. 
  
  
  
  4.  * @author :SimpleWu 
    5. 
  
  
  
  5.  * @Date:2018年10月12日 
    6. 
  
  
  
  6.  */ 
    7. 
  
  
  
  7. @SpringBootApplication 
    8. 
  
  
  
  8. @EnableScheduling 
    9. 
  
  
  
  9. public class App { 
    10. 
  
  
  
  10.  public static void main(String[] args) { 
    11. 
  
  
  
  11.   SpringApplication.run(App.class, args); 
    12. 
  
  
  
  12.  } 
    13. 
  
  
  
  13. }
    14.

整合RabbitMq

安装RabbitMq 由于RabbitMQ依赖Erlang， 所以需要先安装Erlang。

 
 
 
    
  
  
  
  1. sudo yum install -y make gcc gcc-c++ m4 openssl openssl-devel ncurses-devel unixODBC unixODBC-devel java java-devel 
    2. 
  
  
  
  2. sudo yum install epel-release 
    3. 
  
  
  
  3. sudo yum install erlang 
    4. 
  
  
  
  4. sudo yum install socat
    5.

下载RabbitMQ，并且安装

 
 
 
    
  
  
  
  1. sudo wget http://www.rabbitmq.com/releases/rabbitmq-server/v3.6.15/rabbitmq-server-3.6.15-1.el7.noarch.rpm 
    2. 
  
  
  
  2. sudo yum install rabbitmq-server-3.6.15-1.el7.noarch.rpm
    3.

进入cd /etc/rabbitmq/ 创建vim rabbitmq.config

 
 
 
    
  
  
  
  1. [{rabbit, [{loopback_users, []}]}].
    2.

这里的意思是开放使用，rabbitmq默认创建的用户guest，密码也是guest，这个用户默认只能是本机访问，localhost或者127.0.0.1，从外部访问需要添加上面的配置。如果没有找到清除日志

 
 
 
    
  
  
  
  1. rm rabbit\@rabbit@localhost-sasl.log
    2.

最好还是直接sudo rabbitmqctl set_user_tags root administrator ，给root用户赋值管理员权限 RabbitMQ,基本操作

 
 
 
    
  
  
  
  1. # 添加开机启动RabbitMQ服务 
    2. 
  
  
  
  2. systemctl enable rabbitmq-server.service 
    3. 
  
  
  
  3. # 查看服务状态 
    4. 
  
  
  
  4. systemctl status  rabbitmq-server.service 
    5. 
  
  
  
  5. # 启动服务 
    6. 
  
  
  
  6. systemctl start rabbitmq-server.service 
    7. 
  
  
  
  7. # 停止服务 
    8. 
  
  
  
  8. systemctl stop rabbitmq-server.service 
    9. 
  
  
  
  9. # 查看当前所有用户 
    10. 
  
  
  
  10. rabbitmqctl list_users 
    11. 
  
  
  
  11. # 查看默认guest用户的权限 
    12. 
  
  
  
  12. rabbitmqctl list_user_permissions guest 
    13. 
  
  
  
  13. # 由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户 
    14. 
  
  
  
  14. rabbitmqctl delete_user guest 
    15. 
  
  
  
  15. # 添加新用户 
    16. 
  
  
  
  16. rabbitmqctl add_user username password 
    17. 
  
  
  
  17. # 设置用户tag 
    18. 
  
  
  
  18. rabbitmqctl set_user_tags username administrator
    19. 
  
  
  
  19.  # 赋予用户默认vhost的全部操作权限 
    20. 
  
  
  
  20. rabbitmqctl set_permissions -p / username ".*" ".*" ".*" 
    21. 
  
  
  
  21. # 查看用户的权限 
    22. 
  
  
  
  22. rabbitmqctl list_user_permissions username
    23.

如果只从命令行操作RabbitMQ，多少有点不方便。幸好RabbitMQ自带了web管理界面，只需要启动插件便可以使用。

 
 
 
    
  
  
  
  1. rabbitmq-plugins enable rabbitmq_management
    2.

访问: http://服务器IP:15672

整合RabbitMq

导入Maven依赖

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.         org.springframework.boot 
    4. 
  
  
  
  4.         spring-boot-starter-parent 
    5. 
  
  
  
  5.         2.1.4.RELEASE 
    6. 
  
  
  
  6.           
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.         1.8 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.    
    15. 
  
  
  
  15.          
    16. 
  
  
  
  16.             org.springframework.boot 
    17. 
  
  
  
  17.             spring-boot-starter-amqp 
    18. 
  
  
  
  18.          
    19. 
  
  
  
  19.    
    20. 
  
  
  
  20.          
    21. 
  
  
  
  21.             org.springframework.boot 
    22. 
  
  
  
  22.             spring-boot-starter-web 
    23. 
  
  
  
  23.          
    24. 
  
  
  
  24.    
    25. 
  
  
  
  25.          
    26. 
  
  
  
  26.             org.springframework.boot 
    27. 
  
  
  
  27.             spring-boot-starter-test 
    28. 
  
  
  
  28.             test 
    29. 
  
  
  
  29.          
    30. 
  
  
  
  30.

设置application.properties配置文件

 
 
 
    
  
  
  
  1. spring.application.name=springboot-rabbitmq 
    2. 
  
  
  
  2. #RabbitMq所在服务器IP 
    3. 
  
  
  
  3. spring.rabbitmq.host=192.168.197.133 
    4. 
  
  
  
  4. #连接端口号 
    5. 
  
  
  
  5. spring.rabbitmq.port=5672
    6. 
  
  
  
  6. #用户名 
    7. 
  
  
  
  7. spring.rabbitmq.username=root 
    8. 
  
  
  
  8. #用户密码 
    9. 
  
  
  
  9. spring.rabbitmq.password=123456 
    10. 
  
  
  
  10. # 开启发送确认 
    11. 
  
  
  
  11. spring.rabbitmq.publisher-confirms=true 
    12. 
  
  
  
  12. # 开启发送失败退回 
    13. 
  
  
  
  13. spring.rabbitmq.publisher-returns=true 
    14. 
  
  
  
  14. spring.rabbitmq.virtual-host=/
    15.

创建RabbitMq队列初始化类，初始化队列

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.  * @author SimpleWu 
    3. 
  
  
  
  3.  * @Date 2019-05-17 
    4. 
  
  
  
  4.  * 该类初始化队列 
    5. 
  
  
  
  5.  */ 
    6. 
  
  
  
  6. @Configuration 
    7. 
  
  
  
  7. public class RabbitMqInitialization { 
    8. 
  
  
  
  8.     /** 
    9. 
  
  
  
  9.      * 创建队列 队列名字为SayQueue 
    10. 
  
  
  
  10.      * @return 
    11. 
  
  
  
  11.      */ 
    12. 
  
  
  
  12.     @Bean 
    13. 
  
  
  
  13.     public Queue SayQueue() { 
    14. 
  
  
  
  14.         return new Queue("SayQueue"); 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16. }
    17.

创建生产者

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.  * @author SimpleWu 
    3. 
  
  
  
  3.  * @Date 2019-05-17 
    4. 
  
  
  
  4.  * 生产者 
    5. 
  
  
  
  5.  */ 
    6. 
  
  
  
  6. @Component 
    7. 
  
  
  
  7. public class SayProducer { 
    8. 
  
  
  
  8.     @Autowired 
    9. 
  
  
  
  9.     private RabbitTemplate rabbitTemplate;
    10. 
  
  
  
  10.     public void send(String name){ 
    11. 
  
  
  
  11.         String sendMsg = "hello:    " + name + "   " + new Date(); 
    12. 
  
  
  
  12.   //指定队列 
    13. 
  
  
  
  13.         this.rabbitTemplate.convertAndSend("SayQueue", sendMsg); 
    14. 
  
  
  
  14.     } 
    15. 
  
  
  
  15. }
    16.

创建消费者 @RabbitListener:当监听到队列 SayQueue 中有消息时则会进行接收并处理 @RabbitHandler :标注在类上面表示当有收到消息的时候，就交给 @RabbitHandler 的方法处理，具体使用哪个方法处理，根据 MessageConverter 转换后的参数类型

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.  * @author SimpleWu 
    3. 
  
  
  
  3.  * @Date 2019-05-17 
    4. 
  
  
  
  4.  * 消费者 
    5. 
  
  
  
  5.  * queues 指定监听的队列 
    6. 
  
  
  
  6.  */ 
    7. 
  
  
  
  7. @Component 
    8. 
  
  
  
  8. @RabbitListener(queues = "SayQueue") 
    9. 
  
  
  
  9. public class SayConsumer { 
    10. 
  
  
  
  10.     @RabbitHandler 
    11. 
  
  
  
  11.     public void process(String hello) { 
    12. 
  
  
  
  12.         System.out.println("SayConsumer  : " + hello); 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. }
    15.

创建接口进行测试

 
 
 
    
  
  
  
  1. @RestController 
    2. 
  
  
  
  2. public class SayController {
    3. 
  
  
  
  3.     @Autowired 
    4. 
  
  
  
  4.     private SayProducer sayProducer; 
    5. 
  
  
  
  5.     @RequestMapping("/send/{name}") 
    6. 
  
  
  
  6.     public String send(@PathVariable String name){ 
    7. 
  
  
  
  7.         sayProducer.send(name); 
    8. 
  
  
  
  8.         return "Send Succcess SimpleWu"; 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. }
    11.

启动类就用IDEA默认生成的就好了。http://10.192.132.22:8080/send/First 发送请求 消费者接受消息:SayConsumer : hello: First Tue May 07 17:57:02 CST 2019 注：在传输对象时一定要序列化

整合邮件发送

导入依赖

 
 
 
    
  
  
  
  1.  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  org.springframework.boot 
    4. 
  
  
  
  4.  spring-boot-starter-mail 
    5. 
  
  
  
  5.

配置Propert
本文题目：SpringBoot：企业常用的Starter以及实现
文章网址：http://cdxtjz.cn/article/ccoicse.html

其他资讯