zoukankan      html  css  js  c++  java

  • 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 <!-- 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.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

    说明：属性配置文件注入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
       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 Suitests-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　　　图片转文本
    当然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
     
  • 相关阅读:
    项目进度管理-PMBook 第六章
    项目范围管理-PMBook 第五章
    PMBook 中的开发生命周期
    项目整合管理-PMBook 第四章
    PMP 学习心得
    二维码的来源和生活应用
    package main 红色波浪线
    JS中监听事件的几种方法
    PEP8规范
    RestFul API 规范
  • 原文地址：https://www.cnblogs.com/xsge/p/13881594.html
Copyright © 2011-2022 走看看