SpringBoot第二集：注解与配置（2020最新最易懂）

2020最新SpringBoot第二集：基础注解/基础配置（2020最新最易懂）

一.Eclipse安装SpringBoot插件

　　Eclipse实现SpringBoot开发，为便于项目的快速构建，需要安装SpringBoot插件，在Eclipse的help--->Eclipse Marketplace里面搜索STS或Spring

　　（推荐在Spring官网直接下载程序包，其实这个程序包就是一个Eclipse【详情见附录】，该包中集成了SpringBoot组件。或者使用IDEA）

Eclipse右下角会显示安装进度：

安装完成后需要重启Eclipse

重启后验证：Eclipse上边工具栏选项点击Window——Preferences：可以看到如下图结果，就是OK了

Eclipse新建第一个SpringBoot工程。

项目工程显示区，右键New——Project...——搜索Spring

说明：上图中所有选择的依赖都会被直接构建加如pom.xml文件中。工程完成后结构如下图：

二.SpringBoot基础注解

1.注解说明

@SpringBootApplication 注解

　　查看源码可发现，@SpringBootApplication是一个复合注解，包含了@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan这三个注解。

　　这三个注解的作用分别为：

　　　　@SpringBootConfiguration：标注当前类是配置类，这个注解继承自@Configuration。会将当前类内中的一个或多个以@Bean注解标记的方法的实例加入到Srping容器中，并且实例名就是方法名。　　　　　

　　　 @EnableAutoConfiguration：是帮你实现自动装配的注解，这个注解会根据我们添加的组件依赖来完成一些默认配置。 SpringBoot工程启动时， 会运行类SpringFactoriesLoader，执行并加载MTA-INF/pringfactories中的配置依赖 ，通过SpringFactoriesLoader中的load方法， 以for循环的方式，一个一个加载。例如：我们做微服时会添加spring-boot-starter-web这个组件，SpringBoot会默认为工程配置springmvc 和Tomcat。如果希望：关闭自动装配，则需要手动配置: @SpringBootApplicatien(exclude = QuartzAuteConfiguration.class)这样就可以让SpringBoot取消自动装配Quartz

　　　　@ComponentScan：扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类，并将类实例纳入到Spring容器中进行管理。等价于<context:component-scan>的xml配置文件中的配置项。

@RestController注解

　　相当于@Controller+@ResponseBody两个注解的结合，返回JSON数据不需要在方法前面加@ResponseBody注解了，但使用@RestController这个注解，就不能返回jsp/html页面，视图解析器无法解析jsp/html页面。

@Bean

　　相当于Spring核心XML中的<bean  id =""  class=""></bean>配置，用于方法的上面，而不是类，意思是产生一个bean实例，并交给Spring管理。其中方法名对应id值，class对应返回值对象。@Bean(name="a")注解使用属性name时，则表示使用name属性值作为id值，不再使用方法名（这种方式优先级更高）。

@Configuration

　　指出该类是 Spring管理容器Beans配置的信息源，相当于XML中的<Beans>根标签，一般加在主类上。

2.案例演示（了解即可）

　　需求：使用@Configuration和@Bean实现POJO管理。

1.新建SpringBoot项目。

2.引入SpringBoot基本依赖。

3.引入Lombok依赖。

　　我们无需指定依赖jar的版本，SpringBoot默认配置并指定了依赖版本。（需要注意的是，记得要安装Lombok）

 1 <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">
 2   <modelVersion>4.0.0</modelVersion>
 3   <groupId>com.xsge</groupId>
 4   <artifactId>springboot_demo01</artifactId>
 5   <version>0.0.1-SNAPSHOT</version>
 6
 7   <!-- 引入SpringBoot核心父依赖 -->
 8   <parent>
 9     <groupId>org.springframework.boot</groupId>
10     <artifactId>spring-boot-starter-parent</artifactId>
11     <version>2.3.4.RELEASE</version>
12     <relativePath/>
13   </parent>
14
15   <dependencies>
16
17     <dependency>
18       <!-- 引入SpringBoot整合WEB依赖：内置Tomcat容器 -->
19       <groupId>org.springframework.boot</groupId>
20       <artifactId>spring-boot-starter-web</artifactId>
21     </dependency>
22
23       <!-- 引入SpringBoot整合test测试依赖 -->
24     <dependency>
25       <groupId>org.springframework.boot</groupId>
26       <artifactId>spring-boot-starter-test</artifactId>
27       <scope>test</scope>
28       <!-- 排除junit.vintage -->
29       <exclusions>
30         <exclusion>
31           <groupId>org.junit.vintage</groupId>
32           <artifactId>junit-vintage-engine</artifactId>
33         </exclusion>
34       </exclusions>
35     </dependency>
36
37     <!-- Lombok依赖 -->
38     <dependency>
39         <groupId>org.projectlombok</groupId>
40         <artifactId>lombok</artifactId>
41     </dependency>
42
43   </dependencies>
44
45   <!-- spring-boot打包插件 -->
46   <build>
47     <plugins>
48       <plugin>
49         <groupId>org.springframework.boot</groupId>
50         <artifactId>spring-boot-maven-plugin</artifactId>
51       </plugin>
52     </plugins>
53   </build>
54
55 </project>

4.新建启动类

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

5.编写实体类。

　　利用Lombok简化实体类封装代码。

　　@Slf4j：等同于创建日志对象：private final Logger logger = LoggerFactory.getLogger(XXX.class);一般上用在其他java类上

　　更多Lombok注解参考：

1 @Data　　// 添加get，set，toString，eq等
2 @NoArgsConstructor　　// 添加无参构造
3 @AllArgsConstructor　　// 添加全参构造
4 public class User {
5     private String name;
6     private String password;
7 }

6.编写Config配置类

　　在启动类所在包/子包下，新建包config。（注意@SpringBootApplication仅加载启动类当前包/子包中的所有资源）

 1 @Configuration    // 相当于Spring中<beans>根标签
 2 public class UserConfig {
 3     /**
 4      * @Bean 相当于Spring中bean标签。属性name等价于id值，没有name属性时，id值默认为方法名
 5      * 例如：
 6      * <bean id="" class=""></bean>当前方法名等价于id值，当前返回对象，等价于class值实例。
 7      */
 8     @Bean
 9     public User user() {
10         User user = new User("XSGE","123");
11         return user;
12     }
13 }

6.新建Controller。

　　在控制器中注入对象User，测试注解@Configuration/@Bean实现POJO管理

 1 @RestController    // 等价于@Controller和@ResponseBody
 2 public class AnnotationController {
 3
 4     // @Resource(name = "user") 指定name值寻找，
 5     @Autowired
 6     private User user;// 优先根据@Bean注解的name属性值注入对象，当找不到时再根据方法名寻找注入
 7
 8     @GetMapping("/testAnnotation")
 9     public User testAnnotation() {
10         return user;
11     }
12
13 }

7.启动工程，测试访问（略：参考第一集）。　　
　　访问地址：http://localhost:8080/testAnnotation

以上内容如果有兴趣的可以自己再深入学习，个人认为直接在实体类类名上，使用@Component注解，将类标注为Spring组件可能更快更方便！当然每个组件功能都不是儿戏，自然在某一点会凸显它的强大！

三.SpringBoot基础配置

　　在多数情况下，启动一个SpringBoot应用时，基本上无需做太多的配置，应用就能正常启动。但在大部分开发环境下，添加额外配置是无所避免的，比如自定义应用端口号、MQ的服务地址、缓存服务地址、数据库的配置等，都或多或少的需要一些外部的配置项。SpringBoot默认加载的全局配置文件名为application.properties或者application.yml（Spring官方推荐使用的格式是.yml格式，目前官网实例都是使用yml格式进行配置讲解的），应用工程启动时会自动加载此文件，无需手动引入，配置文件名称是固定的，放在src/main/resources根目录下。

　　配置文件在工程中的作用主要有两个：

1. 通过配置文件属性映射，结合注解方式为POJO属性赋值
2. 添加SpringBoot默认属性配置，将默认配置值转换为自定义配置（例如：修改默认端口号等）
   SpringBoot默认配置信息有哪些？点击这里（简称：不多，也就百八十个）

　　自定义全局配置文件格式可选：这是主文件，名称固定写法

• application.properties
  • 语法结构: key=value
• application.yml
• 语法结构: key:空格value

举例：applicaiton.yml

 1 # k=V
 2 #普通的key-value的编写语法
 3 name: xsge
 4 #value值还可以使用表达式
 5 uuid: ${random.uuid}     #随机UUID值
 6 intnum: ${random.int}    #随机int值  ${random.int(10)} 或 ${random.int[1024,65536]}
 7
 8 #对象的编写语法：假定有一个User对象
 9 user1:
10   name: xsge
11   age: 23
12
13 #对象的编写行内语法
14 user2: {name: xsge,age: 23}
15
16 #数组编写语法
17 pets:
18   - AA
19   - BB
20   - CC
21
22 #数组行内编写语法
23 array: [AA,BB,cc]

举例：application.properties

1 user.config.username=Tom
2 user.config.age=23

区别：

properties：属性名通过“点”来连接，通过“等号”来赋值，结构上相对比较单一，没有分层的感觉，但比较直接。

yml文件格式特点：通过“冒号”来分层，结构上多元化，有比较明显的层次感，还可以使用表达式。

　　1. yml文件， 会根据换行和缩进帮助咱们管理配置文件所在位置。
　　2. yml文件，相比properties更轻量级一 些
yml文件的劣势:
　　1.严格遵循换行和缩进。
　　2.在填写value时，一定要在冒号后面跟上空格。

1.自定义属性配置实现注入POJO属性值

　　1.简单型配置

　　SpringBoot支持自定义属性配置文件，并支持通过注解读取配置文件信息。

　　当我们创建一个SpringBoot项目的时候，系统默认会为我们在src/main/java/resources目录下创建一个application.properties（或手动新建）。个人习惯，我会将application.properties改为application.yml文件，两种文件格式都支持。

1. 新建POJO类

   1 @Data    // get,set
   2 @NoArgsConstructor    // 无参
   3 @AllArgsConstructor    // 有参
   4 @Component    // 交由Spring管理bean
   5 public class IDCard {
   6     // @Value("1111")  直接赋值
   7     @Value("${id.card}")// 获取配置文件属性赋值
   8     private String card;
   9 }

   Spring注解@Value("${id.card}")说明：表示从配置文件中获取属性名为id.card的值，并将值注入到POJO属性。

2. 在applicaiton.yml文件中添加自定义属性
   

   1 # 自定义属性
   2 id: #属性前缀
   3   card: 1111　　 #key - value格式

3. 编写Controller。
   

    1 @RestController    // 等价于Controller和ResponseBody（方法返回直接是一个JSON不能再返回页面）
    2 public class DemoController01 {
    3     @Autowired    // 自动注入对象
    4     private IDCard idcard;
    5
    6     @RequestMapping("/testIDCard")
    7     public IDCard testAnnotation() {
    8         return idcard;
    9     }
   10 }

4. 运行SpringBoot启动类，访问测试（略）
   访问地址：http://localhost:8080/testIDCard

　2.多属性配置

　　在属性非常多的情况下，可以定义一个和配置文件对应的POJO。

1. 在applicaiton.yml文件中添加自定义属性

    1 # 自定义IDCard属性
    2 id:
    3   card: 1111
    4
    5 # 自定义User属性
    6 user:
    7   name: xsge
    8   pwd: 123
    9   map: {a: AA,b: BB}
   10   list:
   11     - 111
   12     - 222
   13   idCard:
   14     #card: 1111
   15     #或者
   16     card: ${id.card}  # 表示获取上面一段配置的card的值

2. 新建POJO类
   在POJO类上通过注解@ConfigurationProperties(prefix="useg")指明属性的通用前缀，也标注了POJO属性与配置文件属性的绑定关系，通用前缀+属性名 和 配置文件的属性名是一一对应的。
   

    1 @Data
    2 @NoArgsConstructor
    3 @AllArgsConstructor
    4 @Component
    5 @ConfigurationProperties(prefix = "user")  // 标注在配置文件中，属性名的前缀
    6 public class User {
    7     private String name;
    8     private String pwd;
    9     private Map<String,String> map;
   10     private List<String> list;
   11     private IDCard idCard;
   12 }

3. 编写Controller
   

    1 @RestController    // 等价于Controller和ResponseBody（方法返回直接是一个JSON不能再返回页面）
    2 public class DemoController01 {
    3
    4     @Autowired    // 自动注入对象
    5     private User user;
    6
    7     @RequestMapping("/testUser")
    8     public User testUser() {
    9         return user;
   10     }
   11 }

4. 启动工程，访问测试（略）
   访问地址：http://localhost:8080/testUser

　3.自定义属性文件

　　上面介绍：我们都把配置文件写到application.yml中。有时我们不愿意把属性配置都写到application配置文件中，这时需要我们自定义配置文件，比如test.properties。怎么将这个配置文件信息赋予给一个POJO呢？

1. 定义多属性配置文件person.properties
   　　自定义的属性配置文件，就最好还是使用properties格式的文件，因为SpringBoot针对注解读取自定义属性配置文件的操作，暂时还并未提供加载yml格式文件的功能。（也就是说，使用注解方式加载属性配置文件时，SpringBoot可以通过手动配置识别properties格式的，还没不能识别自定义yml格式的）。特别提醒：我说的是注解方式

   1 person.uuid=12313213221321
   2 person.address=北京

2. 定义一个和配置文件对应的POJO。
   使用的注解说明：
   

   @Data：Lombok组件注解，简化POJO封装代码，省略get/set等
   @AllArgsConstructor：Lombok组件注解，提供全参构造
   @NoArgsConstructor：Lombok组件注解，提供无参构造
   @Component：Spring组件注解，标注为Spring组件，交由Spring容器管理POJO实例
   @ConfigurationProperties(prefix = "person")：Spring组件注解，绑定属性配置文件与实体类POJO的关系，并指定文件里配置的属性名前缀（前缀+POJO属性名 = 文件属性全名）
   @PropertySource("classpath:person.properties")：Spring组件注解，加载指定配置文件。暂时还无法加载yml格式的。

    1 @Data
    2 @AllArgsConstructor
    3 @NoArgsConstructor
    4 @Component    // 标准为Spring组件，将对象实例化交由Spring管理  <bean id="" class=""/>
    5 @ConfigurationProperties(prefix = "person")    // 标注配置文件属性的前缀（指定前缀+POJO属性的名字 == 配置文件属性全名）
    6 @PropertySource("classpath:person.properties")// 标准加载指定配置文件（无法加载yml格式）
    7 public class Person {
    8     private String uuid;
    9     private String address;
   10 }

3. 编写Controller
   

    1 @RestController    // 等价于Controller和ResponseBody（方法返回直接是一个JSON不能再返回页面）
    2 public class DemoController01 {
    3     @Autowired    // 自动注入对象
    4     private Person person;
    5
    6     @RequestMapping("/testPerson")
    7     public Person testPerson() {
    8         return person;
    9     }
   10 }

4. 运行SpringBoot启动类，访问测试

   访问地址：http://localhost:8080/testPerson

2.SpringBoot多环境配置

　　SpringBoot多环境配置，为开发者提供了更灵活的部署操作。我们可以随意自定义开发环境或部署环境，当然SpringBoot在启动时，默认只会加载命名为applicaiton的配置文件，如果存在其他格式命名的配置文件，在主文件中配置激活即可。

　　需求：设置多个开发环境，配置使用不同的服务端口启动项目。

　　命名规范格式：

• application-test.yml：测试环境
• application-dev.yml：开发环境
• application-prod.yml：生产环境

说明：

1.配置文件后缀，可选.yml 或 .properties

2.SpringBoot启动项目工程时，只会加载命名为application.yml 或 application.properties的文件，其他方式命名的文件加载需要在该主文件中配置激活。

根据需求实现简单案例演示：

1. 新增配置文件application.yml ， application-dev.yml ， application-test.yml

   application-test.yml ：测试环境配置文件（选择此环境须在默认文件中配置）　

   1 # 测试环境配置
   2 server:
   3   # 测试环境服务端口
   4   port: 8081
   5   servlet:
   6     # 测试环境web访问根路径
   7     context-path: /test

   application-dev.yml : 开发环境配置文件（选择此环境须在默认文件中配置）

   1 # 开发环境配置
   2 server:
   3   # 服务端口设置
   4   port: 8082
   5   servlet:
   6     # web访问根路径
   7     context-path: /dev

   application-prod.yml ： 部署环境配置文件（选择此环境须在默认文件中配置）

   1 # 部署环境配置
   2 server:
   3   # 服务端口设置
   4   port: 8083
   5   servlet:
   6     # web访问根路径
   7     context-path: /prod

   application.yml ： 主环境配置文件（SpringBoot默认加载）
   　　激活指定profile：
   　　　　A.在默认配置文件中指定 spring.profiles.active=dev/test/prod即可。
   　　　　B.打包SpringBoot工程，命令行运行，并激活指定的环境：Java  -jar  demo1.jar  --spring.profiles.active=dev；

    1 # 默认开发环境配置（将这个注释了下面配置启用其他环境）
    2 #server:
    3   # 服务端口设置
    4   #port: 80802
    5   #servlet:
    6     # web访问根路径
    7     #context-path: /
    8
    9 # 主环境配置
   10 spring:
   11   # 配置简介
   12   profiles:
   13     # 启用的配置项
   14     active:
   15       - test # SpringBoot会自动匹配前缀为applicaiton拼接指定字符的配置文件

2. 启动SpringBoot工程，查看控制台日志
   

附录

1.Spring Tool Suite工具使用

Spring Tool Suite是一个基于Eclipse的开发环境，可以自定义用于开发Spring应用程序。它提供了一个随时可用的环境来实现，调试，运行和部署Spring应用程序。换句话说, Spring Tool Suite是一个定制版的eclipse,为spring boot&cloud量身打造的工具，其核心还是javaee版本的eclipse，是一款免费的非常合适的开发工具。

访问Spring官网，导航栏找到Projiects——Spring Tools4，下载后解压文件

下载后文件：

解压文件：

解压后目录如下：将整个程序拷贝到指定的目录中（自己平时喜欢将软件安装在哪里，自己定）：

打开目录如下：

例如我的目录是在：D:\Program Files (x86)\Spring Tool Suite\sts-4.8.0.RELEASE

启动界面如下：

首次打开时与使用Eclipse相当，需要选择工程保存地址，自定义即可。

另外打开后，最好安装Eclipse用法方式配置一些必要信息。

工作空间编码/JDK/字体大小/Maven环境/Lombok插件安装等。

2.Banner彩蛋

　　Spring Boot项目在启动的时候会有一个默认的启动图案“Spring”标志Banner，我们可以把这个图案修改为自己想要的。在src/main/resources目录下新建banner.txt文件，然后将自己的图案黏贴进去即可。ASCII图案可通过推荐在线网站一键生成。

　　更多：

http://patorjk.com/software/taag　　　　　　文字转为本

http://www.network-science.de/ascii/　　　　文字转为本

　　https://www.degraeve.com/img2txt.php　　　图片转文本

3.配置文件加载问题

　　springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

　　　　–file:./config/

　　　　–file:./

　　　　–classpath:/config/

　　　　–classpath:/

　　优先级由高到底，高优先级的配置会覆盖低优先级的配置；

　　SpringBoot会从这四个位置全部加载主配置文件；互补配置；

　　注：日志配置，自己了解吧！点击这里