• SpringBoot:@SpringBootApplication作用、配置文件等（动力）

    目录：

    （1）springboot简单功能：

    （2）@SpringBootApplication的作用

    （3）springboot项目的配置文件：

           * 3.1使用properties配置文件 

           * 3.2使用yml配置文件:

    （4）多配制文件的使用

    （5）SpringBoot的自定义配置

          * 5.1 @Value读取数据

          * 5.2@ConfigurationProperties将配置文件数据有影射为Java对象

    （1）springboot简单功能：

    SpringBoot项目内置了tomcat就不用手动配置了，现在写的Controller，不用在写中央调度器了，是因为SpringBoot框架已经把Spring的有关东西都已经配置好了，项目中已经有了，所有就不用写那些复杂的东西了，直接写业务逻辑就可以了：

     

    编写控制器HelloSpringBoot ：

    1. package com.bjpowernod.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6.  
    7. @Controller
    8. public class HelloSpringBoot {
    9.  
    10.     @RequestMapping("/hello")
    11.     @ResponseBody //把String返回值当做数据来用返回给浏览器，
    12.     public String helloSplringBoot(){
    13.         return "欢迎使用SpringBoot框架";
    14.     }
    15. }

    运行项目点击Application中的main方法：

    从中可以看到内嵌的tomcat服务器已经启动了 ，通过端口号8080，可以访问刚才写的Controller

     

     在浏览器输入地址：http://localhost:8080/hello

     

    （2）@SpringBootApplication的作用

    SpringBoot项目里面都有一个类Application类（名字自定义的），里面包含一个主方法，不管你做的是web项目还是非web项目都是通过主方法来启动的

    这个类上面有一个注解：@SpringBootApplication：是一个复合注解

     

     

     

     Student：

    1. package com.bjpowernod.vo;
    2.  
    3. public class Student {
    4. }

    Application：主启动类：

    @SpringBootConfiguration注解可以当做配置文件来用，可以创建对象

    1. package com.bjpowernod;
    2.  
    3. import com.bjpowernod.vo.Student;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.springframework.context.annotation.Bean;
    7.  
    8. @SpringBootApplication
    9. public class Application {
    10.  
    11.     public static void main(String[] args) {
    12.         SpringApplication.run(Application.class, args);
    13.     }
    14.  
    15.     //这个类具有注解Configuration注解的功能，可以声明对象注入到容器中
    16.     @Bean
    17.     public Student myStudent(){
    18.         return new Student();
    19.     }
    20.  
    21. }

    @CompopnentScan注解会扫描@CompopnentScan所在类的包和子包，所以把主类放在主包之下，其他类放在主包的子包中的，这个规则是默认的可以打破，但是不建议，所以说不用做特殊的声明就可以找到程序中各种各样的注解

    在写Controller控制类的时候里面有注解@Controller、@RequestMapping、但是在程序中并没有声明主键扫描器，正是因为主类的@SpringBootApplication注解：@ComponentScan的作用

    （3）springboot项目的配置文件：

     

    application.properties :是配置文件：我们要用到的各种配置和项目的各种配置都是在这个项目中来实现的

    有两种格式：

              一种以proplerties结尾

             一种以yml结尾

    这两种格式表达的内容是一样的只是格式上有所区别而已，推荐用yml的

    3.1使用properties配置文件 

      

    控制器BootController： 

    1. package com.bjpowernode.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6.  
    7. @Controller
    8. public class BootController {
    9.     @RequestMapping("/hello")
    10.     @ResponseBody //不使用视图，希望返回值String作为数据给浏览器
    11.     public String doSome(){
    12.         return "hello SpringBoor应用,设置端口，上下文路径";
    13.     }
    14. }

    MyApplication：主启动类：

    1. package com.bjpowernode;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. @SpringBootApplication
    7. public class MyApplication {
    8.     public static void main(String[] args) {
    9.         SpringApplication.run(MyApplication.class,args);
    10.     }
    11. }

    配置文件application.properties:通过配置文件设置端口号，和上下文访问路径

    1. #设置端口号
    2. server.port=8082
    3. #设置访问应用的上下文路径，contextpath
    4. server.servlet.context-path=/myboot

    可以观察到tomcat服务器的端口号，上下文访问路径发生改变：

     在浏览器通过地址：http://localhost:8082/myboot/hello

     

    3.2使用yml配置文件:

     

    yml:不是通过键=值得方式，而是键： 值 ，中间有空格 yml有层级关系：

    创建application.yml:

    1. server:
    2.   port: 8083
    3.   servlet:
    4.     context-path: /myboot2

     删除application.properties:

    配置文件的优先级：application.properties>application.yml>appllication.yaml

    运行主启动类：发现使用了yml的配置问价

     在浏览器访问：

     

    如果项目中有两个配置文件，默认使用application.properties的：

    配置文件的优先级：application.properties>application.yml>appllication.yaml

     

    （4）多配制文件的使用

     

     

     

    控制类：BootController：

    1. package com.bjpowernode.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6.  
    7. @Controller
    8. public class BootController {
    9.     @RequestMapping("/hello")
    10.     @ResponseBody //不使用视图，希望返回值String作为数据给浏览器
    11.     public String doSome(){
    12.         return "hello SpringBoot多环境配置";
    13.     }
    14. }

    主启动类：Application：

    1. package com.bjpowernode;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. @SpringBootApplication
    7. public class Application {
    8.  
    9.     public static void main(String[] args) {
    10.         SpringApplication.run(Application.class, args);
    11.     }
    12.  
    13. }

    生产环境配置文件：application-dev.yml:

    1. #开发环境的配置文件
    2. server:
    3.   port: 8081
    4.   servlet:
    5.     context-path: /mydev

     测试环境配置文件：application-test.yml:

    1. #测试环境使用的配置文件
    2. server:
    3.   port: 9001
    4.   servlet:
    5.     context-path: /mytest

    上线环境配置文件：application-test.yml:

    1. #项目上线使用的配置文件
    2. server:
    3.   port: 9002
    4.   servlet:
    5.     context-path: /myonline

    文件创建完成了告诉应用007-springboot-multi-environment项目，使用哪一个配置文件，默认先读取的是application.properties:在里面设置

    1. #激活使用按那个配置文件
    2. spring.profiles.active=dev

    点击主启动类：运行的是application-dev.yml

     在浏览器输网址：

     更换环境appllication.properties:

    1. #激活使用按那个配置文件
    2. #使用dev
    3. #spring.profiles.active=dev
    4.  
    5. #使用test环境
    6. spring.profiles.active=test

    服务器更换了测试环境 

     

     这里面application.properties可以使用application.yml:

    （5）SpringBoot的自定义配置

     

    我们从配置文件中来获取数据，

    5.1 @Value读取数据

    配置文件：application.pro[erties:

    1. #配置端口号
    2. server.port=8082
    3. #设置上下文路径 context-path
    4. server.servlet.context-path=/myboot
    5.  
    6. #自定义key=value
    7. school.name=动力节点
    8. school.website=www.bjpowernode.com
    9. school.address=北京的大兴区
    10.  
    11. site=www.baidu.com

    控制器：HelloController：

    1. package com.bjpowernode.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.ResponseBody;
    7.  
    8. @Controller
    9. public class HelloController {
    10.     //声明属性，使用注解读取数据
    11.     @Value("${server.port}")
    12.     private Integer port;
    13.  
    14.     @Value("${server.servlet.context-path}")
    15.     private String contextPath;
    16.  
    17.     @Value("${school.name}")
    18.     private String name;
    19.  
    20.     @Value("${site}")
    21.     private String site;
    22.  
    23.     //读取配置文件中的数据
    24.     @RequestMapping("/data")
    25.     @ResponseBody
    26.     public String queryData(){
    27.         return name+",site="+site+",项目的访问地址="+contextPath+",使用的端口="+port;
    28.     }
    29. }

    主启动类Application：

    1. package com.bjpowernode;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. @SpringBootApplication
    7. public class Application {
    8.  
    9.     public static void main(String[] args) {
    10.         SpringApplication.run(Application.class, args);
    11.     }
    12.  
    13. }

    启动项目：

     浏览器运行：

     5.2@ConfigurationProperties将配置文件数据有影射为Java对象

    SchoolInfo：用这个对象来接收配置文件中特定的属性，需要使用一个注解@ConfigurationProperties

    1. package com.bjpowernode.vo;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4. import org.springframework.stereotype.Component;
    5.  
    6. @Component //注解创建此类的对象
    7. @ConfigurationProperties(prefix = "school")  //告诉框架去配置文件找school开头的，把相同的名字赋值给相同的属性 profix代表前缀，配置文件中所有school开头的
    8. public class SchoolInfo {
    9.     private String name;
    10.  
    11.     private String website;
    12.  
    13.     private String address;
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public String getWebsite() {
    24.         return website;
    25.     }
    26.  
    27.     public void setWebsite(String website) {
    28.         this.website = website;
    29.     }
    30.  
    31.     public String getAddress() {
    32.         return address;
    33.     }
    34.  
    35.     public void setAddress(String address) {
    36.         this.address = address;
    37.     }
    38.  
    39.     @Override
    40.     public String toString() {
    41.         return "SchoolInfo{" +
    42.                 "name='" + name + '\'' +
    43.                 ", website='" + website + '\'' +
    44.                 ", address='" + address + '\'' +
    45.                 '}';
    46.     }
    47. }

    加上了注解@ConfigurationProperties后，可以在pom.xml中加上依赖，来处理这个类提示的信息数据，不加也能正常使用

    <!--处理ConfigurationProperties有关的元数据-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

    HelloController:加上一个对象的属性，和一个方法

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.SchoolInfo;
    4. import org.springframework.beans.factory.annotation.Value;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8.  
    9. import javax.annotation.Resource;
    10.  
    11. @Controller
    12. public class HelloController {
    13.     //声明属性，使用注解读取数据
    14.     @Value("${server.port}")
    15.     private Integer port;
    16.  
    17.     @Value("${server.servlet.context-path}")
    18.     private String contextPath;
    19.  
    20.     @Value("${school.name}")
    21.     private String name;
    22.  
    23.     @Value("${site}")
    24.     private String site;
    25.  
    26.     @Resource //注解自动注入
    27.     private SchoolInfo info;
    28.  
    29.     //读取配置文件中的数据
    30.     @RequestMapping("/data")
    31.     @ResponseBody
    32.     public String queryData(){
    33.         return name+",site="+site+",项目的访问地址="+contextPath+",使用的端口="+port;
    34.     }
    35.  
    36.     @RequestMapping("/info")
    37.     @ResponseBody
    38.     public String queryInfo(){
    39.         return "SchoolInfo这个对象="+info.toString();
    40.     }
    41. }

     

     在浏览器输入地址：

     

  • 相关阅读:
    Jmix 中 REST API 的两种实现
    关于SQL优化
    小白学Python：提取Word中的所有图片，只需要1行代码
    ARM接口编程—WDT(exynos 4412平台)
    【HTML】web worker
    React通过ref获取子组件的数据和方法
    第八章 时序检查(下)
    【PAT甲级 - C++题解】1093 Count PAT‘s
    ES6快速入门（三）--拓展运算符
    【编程题】【Scratch三级】2021.12跳高比赛
  • 原文地址：https://blog.csdn.net/dengfengling999/article/details/125524231