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注解

  相当于@[email protected]两个注解的结合,返回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="//maven.apache.org/POM/4.0.0" xmlns:xsi="//www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="//maven.apache.org/POM/4.0.0 //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.启动工程,测试访问(略:参考第一集)。  
  访问地址://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启动类,访问测试(略)
    访问地址://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. 启动工程,访问测试(略)
    访问地址://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启动类,访问测试

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

  更多:

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

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

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

 3.配置文件加载问题

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

    –file:./config/

    –file:./

    –classpath:/config/

    –classpath:/

  优先级由高到底,高优先级的配置会覆盖低优先级的配置;

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

  注:日志配置,自己了解吧!点击这里