Spring Boot：企业常用的Starter以及实现 - Go语言中文社区

Spring Boot：企业常用的Starter以及实现

 

目录

  •  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. <!--引入SpringBoot父依赖-->  
  2. <parent>  
  3.   <groupId>org.springframework.boot</groupId>  
  4.   <artifactId>spring-boot-starter-parent</artifactId>  
  5.   <version>2.0.5.RELEASE</version>  
  6.   <relativePath/>   
  7. </parent>  
  8. <!--编码与JAVA版本-->  
  9. <properties>  
  10.   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  11.   <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
  12.   <java.version>1.8</java.version> 
  13.  </properties> 

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

  1. <dependencies>  
  2.   <!--引入SpringBoot-WEB模块-->  
  3.   <dependency>  
  4.    <groupId>org.springframework.boot</groupId>  
  5.    <artifactId>spring-boot-starter-web</artifactId>  
  6.   </dependency>  
  7.  </dependencies> 

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

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

到了这里我们直接把他当成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. <parent>  
  2.   <groupId>org.springframework.boot</groupId>  
  3.   <artifactId>spring-boot-starter-parent</artifactId>  
  4.   <version>1.5.2.RELEASE</version>  
  5.  </parent>  
  6.  <dependencies>  
  7.         <!--引入WEB模块-->  
  8.   <dependency>  
  9.    <groupId>org.springframework.boot</groupId>  
  10.    <artifactId>spring-boot-starter-web</artifactId>  
  11.   </dependency>  
  12.          <!--引入JDBC模块-->  
  13.   <dependency>  
  14.    <groupId>org.springframework.boot</groupId>  
  15.    <artifactId>spring-boot-starter-jdbc</artifactId>  
  16.   </dependency>  
  17.          <!--引入数据库驱动-->  
  18.   <dependency>  
  19.    <groupId>mysql</groupId>  
  20.    <artifactId>mysql-connector-java</artifactId>  
  21.   </dependency>  
  22.   <dependency>  
  23.    <groupId>org.springframework.boot</groupId>  
  24.    <artifactId>spring-boot-starter-test</artifactId>  
  25.    <scope>test</scope>  
  26.   </dependency>  
  27.  </dependencies> 

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

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

使用方式：

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

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

@RestController

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

整合JSP

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

引入依赖：

  1. <parent>  
  2.     <groupId>org.springframework.boot</groupId>  
  3.     <artifactId>spring-boot-starter-parent</artifactId>  
  4.     <version>1.5.2.RELEASE</version>  
  5. </parent>  
  6. <dependencies>  
  7.     <!-- SpringBoot WEB组件 -->  
  8.     <dependency>  
  9.         <groupId>org.springframework.boot</groupId>  
  10.         <artifactId>spring-boot-starter-web</artifactId>  
  11.     </dependency>  
  12.     <!-- 整合JSP依赖 -->  
  13.     <dependency>  
  14.         <groupId>org.springframework.boot</groupId>  
  15.         <artifactId>spring-boot-starter-tomcat</artifactId>  
  16.     </dependency>  
  17.     <dependency>  
  18.         <groupId>org.apache.tomcat.embed</groupId>  
  19.         <artifactId>tomcat-embed-jasper</artifactId>  
  20.     </dependency>  
  21. </dependencies> 

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

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

整合JPA

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

添加依赖：

  1. <parent>  
  2.   <groupId>org.springframework.boot</groupId>  
  3.   <artifactId>spring-boot-starter-parent</artifactId>  
  4.   <version>1.5.2.RELEASE</version>  
  5.  </parent>  
  6.  <dependencies>  
  7.   <dependency>  
  8.    <groupId>org.springframework.boot</groupId>  
  9.    <artifactId>spring-boot-starter-web</artifactId>  
  10.   </dependency>  
  11.         <!--启动JPA组件-->  
  12.   <dependency>  
  13.    <groupId>org.springframework.boot</groupId>  
  14.    <artifactId>spring-boot-starter-data-jpa</artifactId>  
  15.   </dependency>  
  16.   <dependency>  
  17.    <groupId>org.springframework.boot</groupId>  
  18.    <artifactId>spring-boot-starter-test</artifactId>  
  19.    <scope>test</scope>  
  20.   </dependency>  
  21.   <dependency>  
  22.    <groupId>mysql</groupId>  
  23.    <artifactId>mysql-connector-java</artifactId>  
  24.   </dependency>  
  25.  </dependencies> 

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

Application.properties

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

实体类：Employee.java

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

EmployeeDao接口：

  1. public interface EmployeeDao extends JpaRepository<Employee, Integer>{  
  2. } 

EmployeeController.java:

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

整合MyBatis

引入依赖：

  1. <parent>  
  2.   <groupId>org.springframework.boot</groupId>  
  3.   <artifactId>spring-boot-starter-parent</artifactId>  
  4.   <version>1.5.2.RELEASE</version>  
  5.  </parent>  
  6.  <dependencies>  
  7.   <dependency> 
  8.     <groupId>org.springframework.boot</groupId>  
  9.    <artifactId>spring-boot-starter-web</artifactId>  
  10.   </dependency>  
  11.         <!--引入对JDBC的支持-->  
  12.   <dependency>  
  13.    <groupId>org.springframework.boot</groupId> 
  14.    <artifactId>spring-boot-starter-jdbc</artifactId>  
  15.   </dependency>  
  16.          <!--引入对logging的支持--> 
  17.    <dependency>  
  18.    <groupId>org.springframework.boot</groupId>  
  19.    <artifactId>spring-boot-starter-logging</artifactId>  
  20.   </dependency>  
  21.   <!-- SpringBoot MyBatis启动器 --> 
  22.    <dependency>  
  23.    <groupId>org.mybatis.spring.boot</groupId>  
  24.    <artifactId>mybatis-spring-boot-starter</artifactId>  
  25.    <version>1.2.2</version>  
  26.   </dependency>  
  27.   <dependency>  
  28.    <groupId>org.springframework.boot</groupId>  
  29.    <artifactId>spring-boot-starter-test</artifactId>  
  30.    <scope>test</scope>  
  31.   </dependency>  
  32.   <dependency>  
  33.    <groupId>mysql</groupId>  
  34.    <artifactId>mysql-connector-java</artifactId>  
  35.   </dependency> 
  36.   </dependencies> 

配置application.properties

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

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

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

AOP功能使用

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

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

任务调度

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

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

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

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

整合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. sudo yum install epel-release  
  3. sudo yum install erlang  
  4. sudo yum install socat 

下载RabbitMQ，并且安装

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

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

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

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

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

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

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

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

  1. rabbitmq-plugins enable rabbitmq_management 

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

整合RabbitMq

导入Maven依赖

  1. <!--SpringBoot2.x-->  
  2. <parent>  
  3.         <groupId>org.springframework.boot</groupId>  
  4.         <artifactId>spring-boot-starter-parent</artifactId>  
  5.         <version>2.1.4.RELEASE</version>  
  6.         <relativePath/> <!-- lookup parent from repository -->  
  7. </parent>  
  8. <!--设置JAVA版本-->  
  9. <properties>  
  10.         <java.version>1.8</java.version>  
  11. </properties>  
  12. <!--引入依赖-->  
  13. <dependencies>  
  14.   <!--启动RabbitmQ-->  
  15.         <dependency>  
  16.             <groupId>org.springframework.boot</groupId>  
  17.             <artifactId>spring-boot-starter-amqp</artifactId>  
  18.         </dependency>  
  19.   <!--启动WEB-->  
  20.         <dependency>  
  21.             <groupId>org.springframework.boot</groupId>  
  22.             <artifactId>spring-boot-starter-web</artifactId>  
  23.         </dependency>  
  24.   <!--启动TEST-->  
  25.         <dependency>  
  26.             <groupId>org.springframework.boot</groupId>  
  27.             <artifactId>spring-boot-starter-test</artifactId>  
  28.             <scope>test</scope>  
  29.         </dependency>  
  30. </dependencies> 

设置application.properties配置文件

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

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

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

创建生产者

  1. 
                            
                            版权声明：本文来源51CTO，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
    
                            原文链接：http://developer.51cto.com/art/202009/627370.htm
    
                            站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。
  • 发表于 2021-05-16 16:53:16
  • 阅读 ( 779 )
  • 分类：

你可能感兴趣的文章

精选的优质文章

0 条评论

请先 登录 后评论

官方社群

GO教程

推荐文章

猜你喜欢

随便看看

来源51CTO

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！