SpringBoot入门到精通（二）：注解与配置_uuid注解springboot

基础注解/基础配置

一.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 <!-- Lombok依赖 -->
2 <dependency>
3     <groupId>org.projectlombok</groupId>
4     <artifactId>lombok</artifactId>
5 </dependency>

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.propertiesapplication.yml
  • 语法结构: key=value
• • 语法结构: 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

说明：属性配置文件注入POJO时，一般没有什么问题，但如果使用IDEA则会报红，须引入以下依赖，实际不添加也不影响

<!-- SpringBoot整合属性配置文件注入POJO依赖 --> <dependency> 　　<groupId>org.springframework.boot</groupId> 　　<artifactId>spring-boot-configuration-processor</artifactId> 　　<optional>true</optional> </dependency>

　3.自定义属性文件

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

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

   1 person.uuid=${random.uuid}
   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

 结论:
●配置ym|和配置properties都可以获取到值，强烈推荐yml
●如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用一下@value(...)
●如果说，我们专门编写了一个JavaBean来和配置文件进行映射，就直接使用@configurationProperties, 不要犹豫!

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
   

   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图案可通过推荐在线网站一键生成。

　　更多：

       Text to ASCII Art Generator (TAAG)　　　　　　文字转为本

       ASCII Generator　　　　文字转为本

　　IMG2TXT: ASCII Art Made Easy!　　　图片转文本
当然SpringBoot也能自动识别图片加载显示，只需要将图片命名为banner.xx然后将其放入资源根目录下即可。

 3.配置文件加载问题

1.配置文件地址问题

　　默认配置文件放在哪合适呢？

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

　　　　–file:./config/　　　　项目根路径下/config包中

　　　　–file:./　　　　　　　项目根路径下

　　　　–classpath:/config/　 项目根路径下/src/main/resources/config路径下

　　　　–classpath:/　　　　 项目根路径下/src/main/resources/根路径下

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

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

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

2.默认配置文件加强

　　SpringBoot启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件，SpringBoot除了支持多文件配置多环境外，还支持一个文件多环境。

　　一个配置文件，实现多个环境配置。YML语法允许使用“---”三个连续横杠来分割多环境配置(如下)。

 1 # 主环境配置
 2 spring:
 3   # 配置简介
 4   profiles:
 5     # 启用的配置项
 6     active: 
 7      - test # 指定启用的环境名字  
 8 
 9 ---
10 # 测试环境配置
11 server:
12   # 测试环境服务端口
13   port: 8081
14 spring: 
15   # 配置环境名字
16   profiles: test
17 
18 ---
19 
20 # 开发环境配置
21 server:
22   # 服务端口设置
23   port: 8082
24 spring: 
25   # 配置环境名字
26   profiles: dev