• SpringBoot简单整理

    目录

    SpringBoot

    理解：

    SpringBoot优点

    快速搭建springboot应用程序

    pom内的parent标签

    @SpringBootApplication

    @SpringBootApplication包含三大主要的注解

    @ComponentScan注解

    @EnableAutoConfiguration注解

    @SpringBootTest注解

    自定义SpringApplication

    在springApplication内获得bean 

    注解配置spring容器

    从容器中获取组件

    条件装配

    子注解 

    经典注解@ConditionalOnBean使用案例

    配置文件的使用

    properties文件语法

    yaml文件语法

    配置文件的加载顺序

    其他约定配置文件加载顺序

    设置默认配置文件读取

    普通方式 

    注解方式

    动态为属性赋值

    properties文件为属性动态赋值

    yml文件为属性动态赋值

    yml文件内特殊属性动态赋值

    springboot环境分割

    单文件形式

    分文件形式

    热部署

    springboot日志的使用

    springboot默认日志配置

    日志的级别

    日志的输出格式

    静态资源访问

    静态资源访问前缀

    改变放入静态资源文件的目录

    设置静态资源映射

    静态欢迎页

    网站图标

    SpringBoot

    含义：是框架的框架，简化了常规框架的配置方式，只需要很少的代码便可实现大量的功能

    作用：SpringBoot基于spring开发，能快速创建出生产级别的Spring，让以后用Spring开发变得简单

    理解：

    关于SpringBoot有一句很出名的话就是约定大于配置，采用springboot可以大大简化开发模式，它集成了大量常用的第三方库配置，所有你想集成的常用框架他都有对应的组件支持，例如：Redis、MongoDB、Dubbo、kafka、ES等。springboot应用中这些第三方库几乎可以零配置的开箱即用，大部分的springboot应用都只需要非常少量的配置代码，开发者能够专注于业务逻辑。另外springboot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性问题得到了很好的解决。 

    注意：

    • SpringBoot底层是Spring框架
    • SpringBoot是整合Spring技术栈的一站式框架
    • SpringBoot是简化Spring技术栈的快速开发脚手架 

    SpringBoot优点

    • 创建独立Spring应用（不用写spring配置文件）
    • 内嵌web服务器
    • 自动starter依赖，简化构建配置
    • 自动配置Spring以及第三方功能
    • 提供生产级别的监控、健康检查及外部化配置
    • 无代码生成、无需编写XML，开箱即用

    快速搭建springboot应用程序

    创建一个maven项目

    导入依赖

    1.     <!--引入父maven项目，集成父maven项目的所有配置信息-->
    2.     <!--parent标签里面提供了spring集成所有其他第三方框架的所有依赖-->
    3.     <parent>
    4.         <groupId>org.springframework.boot</groupId>
    5.         <artifactId>spring-boot-starter-parent</artifactId>
    6.         <version>2.3.5.RELEASE</version>
    7.     </parent>
    8.     <dependencies>
    9.         <!--web工程依赖集——使用springmvc构建web应用程序，使用tomcat为默认嵌入容器-->
    10.         <dependency>
    11.             <groupId>org.springframework.boot</groupId>
    12.             <artifactId>spring-boot-starter-web</artifactId>
    13.             <version>2.7.3</version>
    14.         </dependency>
    15.         <!--springboot测试文件依赖-->
    16.         <dependency>
    17.             <groupId>org.springframework.boot</groupId>
    18.             <artifactId>spring-boot-starter-test</artifactId>
    19.             <scope>test</scope>
    20.         </dependency>
    21.     </dependencies>
    22.     <build>
    23.         <plugins>
    24.             <!--部署springboot的插件-->
    25.             <!--用于运行命令时指定main方法启动类在哪里-->
    26.             <plugin>
    27.                 <groupId>org.springframework.boot</groupId>
    28.                 <artifactId>spring-boot-maven-plugin</artifactId>
    29.             </plugin>
    30.         </plugins>
    31.     </build>
    1. @RestController
    2. @RequestMapping("/test")
    3. public class HelloController {
    4.     @RequestMapping("/hello")
    5.     public String asyHi(){
    6.         return "hello world";
    7.     }
    8. }

    在所有类的外层创建启动类

    1. //标记成springboot的启动类
    2. @SpringBootApplication
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         SpringApplication.run(Application.class, args);
    6.     }
    7. }

    将启动端口号改为8088，为项目加虚拟路径为app

    1. #resources目录下（编译后会编译到classes文件中）
    2. #application.properties（文件名必须固定为application）文件内
    3. server.port=8088
    4. #为项目加虚拟路径
    5. server.servlet.context-path=/app
    6. #初始化懒加载，所有的bean在spring容器初始化的时候将不会去创建这些bean，而是在我们使用的时候才会创建
    7. spring.main.lazy-initialization=true

    使用maven命令打包后在对应包所在文件中使用java -jar 完整包名 --server.port=8087命令开启服务

    访问路径：localhost:8087/app/test/hello

    注意：这里用直接配置的端口号覆盖了原来的配置端口，这样运行的信息会通过main函数的args参数传递下去 ，进而实现端口配置

    测试类

    1. //在主启动类所在同名包路径的同包或子包中
    2. //提前已经将User类交给spring容器管理了
    3. @SpringBootTest
    4. public class TestSpringBoot {
    5.     @Autowired
    6.     private User user;
    7.     //注意@Test注解用import org.junit.jupiter.api.Test;
    8.     @Test
    9.     public void test1(){
    10.         System.out.println(user.getName());
    11.     }
    12. }

    pom内的parent标签

    作用：引入父maven项目，使该项目继承了父maven项目的所有配置信息

    点开[spring-boot-starter-parent]依赖，然后发现其内部也有父maven项目——[spring-boot-dependencies]，点进该父maven项目发现第三方库所有的版本号都在这里维护了；所以它就用该种方式帮我们管理了第三方库之间的版本冲突问题，以及我们会用到的所有依赖信息也都在这里引入进来了；以后我们导入已有的依赖就可以不用写版本号了

    @SpringBootApplication

    被该注解修饰的类，为springboot的启动类（入口）；因为springboot的所有自动配置都是从该注解开始的

    @SpringBootApplication包含三大主要的注解

    • @ComponentScan(包路径)：包扫描注解
    • @EnableAutoConfiguration：实现自动配置的注解
    • @SpringBootConfiguration：实现spring配置文件的功能，标识该类实现容器功能

    @ComponentScan注解

    规则：Spring底层解析配置类的时候会扫描当前包的路径，默认是主启动类所在的包路径，以后写代码必须在主启动类所在包路径的同包或子包中编程

    @EnableAutoConfiguration注解

    规则：该注解用来加载SpringBoot-start-xxx的启动项，当主启动类的执行时，则会开始加载启动项中的配置，实现自动化配置

    注意：这里的开箱即用中SpringBoot-start-xxx的启动项为箱，@EnableAutoConfiguration自动化配置为即用

    @SpringBootTest注解

    作用：当运行测试类中@Test注解标识的方法时springboot程序启动，springboot程序启动，内部spring容器启动，基于ioc管理对象，DI注入对象；进而可以在任意测试类中注入想要的对象

    注意：

    • 使用@Test注解的包必须为import org.junit.jupiter.api.Test才能实现一键启动
    • 测试类用@SpringBootTest注解标识，并且测试类的包路径在主启动类所在同名包路径的同包或子包中才能实现一键启动

    自定义SpringApplication

    1. @SpringBootApplication
    2. public class Application {
    3.     public static void main(String[] args) {
    4.         SpringApplication app = new SpringApplication(Application.class);
    5.         //关闭springboot的启动横幅
    6.         app.setBannerMode(Banner.Mode.OFF);
    7.         //一键启动springboot
    8.         app.run(args);
    9.     }
    10. }

    在springApplication内获得bean 

    注解配置spring容器

    1. //告诉springboot这是一个配置类，这里的proxyBeanMethods值默认为true(代理bean的方法，为true后那么获得到的bean返回的对象就全一样)
    2. @Configuration(proxyBeanMethods = true)
    3. //组件扫描（将该包下被标识的的组件交给该容器来保存）
    4. @ComponentScan("cn.tedu.springboot.service")
    5. //向容器中导入指定类型的组件——默认组件的名字为全类名
    6. @Import({People.class, Student.class})
    7. public class MyConfig {
    8.     @Bean//给容器添加组件，组件id默认为方法名，组件为方法的返回值，组件名也可以改变@Bean("app")——组件名为app
    9.     public String fly(){
    10.         return "hello world";
    11.     }
    12. }

    从容器中获取组件

    1. @SpringBootApplication
    2. public class MainApplication {
    3. 	public static void main(String[] args) {
    4. 		//返回ioc容器
    5. 		ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class);
    6. 		//获取容器里的组件
    7. 		String fly = run.getBean("fly", String.class);
    8. 		System.out.println(fly);
    9. 		//获取容器组件(配置类本身也是组件)
    10. 		MyConfig bean = run.getBean(MyConfig.class);
    11. 		System.out.println(bean);//cn.tedu.springboot.config.MyConfig$$EnhancerBySpringCGLIB$$7bfb7bcb@3fc4a116
    12. 		//获取Import组件
    13. 		People people = run.getBean(People.class);
    14. 		System.out.println(people);
    15. 	}
    16. }

    条件装配

    含义：满足Conditional条件的时候就会向容器中注入容器中注入相关组件

    注解：@Conditional

    子注解 

    经典注解@ConditionalOnBean使用案例

    1. @Configuration(proxyBeanMethods = true)
    2. //从resouses目录下的beans.xml导入资源
    3. @ImportResource("classpath:beans.xml")
    4. public class MyConfig {
    5.     //当容器中有people这个组件时再注册该组件（也可以直接通过类名注入——value属性）
    6.     //该注解也可以标注在类上
    7.     @ConditionalOnBean(name = "people")
    8.     public String fly(){
    9.         return "hello world";
    10.     }
    11.     @Bean("people")
    12.     public People getPeople(){
    13.         return new People();
    14.     }
    15. }

    配置文件的使用

    SpringBoot使用一个全局配置文件也称核心配置文件（application文件），配置文件在约定的情况下名字是固定的

    配置文件的作用：修改springboot自动配置的默认值；springboot在底层都给我们配置好

    • application.properties
    • application.yaml

    properties文件语法

    • 数据结构类型：key=value（特别注意不要有空格）
    • 程序读取该文件时默认采用ISO-8859-1编码
    • 所有的的key都必须完整，不能缩进
    • 注释用#
    1. server.port=8088
    2. server.servlet.context-path=/app

    yaml文件语法

    • 写法为key：value（注意冒号和value之间有空格）
    • 层级代码结构，应注意缩进
    • 文件读取时默认采用UTF-8编码
    • 注释用#
    1. server:
    2.   port: 8088
    3.   servlet:
    4.     context-path: /app

    配置文件的加载顺序

    spring-boot-starter-parent内

    1.         <includes>
    2.           <include>**/application*.yml</include>
    3.           <include>**/application*.yaml</include>
    4.           <include>**/application*.properties</include>
    5.         </includes>

    注意：配置文件加载顺序是针对共有的配置，如果两种文件有相同的配置则会以优先级高的文件配置为准，若优先级低的配置文件有优先级高的配置文件所没有的属性，则该属性也可用

    其他约定配置文件加载顺序

    1. 直接子目录/config（命令行直接配置子目录）
    2. 项目根目录/config
    3. 项目根目录
    4. classpath根目录的config
    5. classpath根目录

    设置默认配置文件读取

    1. #app.properties文件内
    2. server.port=8888

    注意：约定的配置优先级最高（application） 

    普通方式 

    1. @SpringBootApplication
    2. public class SpWebApplication {
    3. 	public static void main(String[] args) throws Exception {
    4. 		SpringApplication application = new SpringApplication(SpWebApplication.class);
    5. 		Properties properties = new Properties();
    6. 		//通过当前类加载器获得app.properties文件内容
    7. 		InputStream stream = SpWebApplication.class.getClassLoader().getResourceAsStream("app.properties");
    8. 		properties.load(stream);
    9. 		//设置默认配置文件
    10. 		application.setDefaultProperties(properties);
    11. 		application.run(args);
    12. 	}
    13. }

    注解方式

    1. @SpringBootApplication
    2. @PropertySource("classpath:/app.properties")
    3. public class SpWebApplication {
    4. 	public static void main(String[] args) throws Exception {
    5. 		SpringApplication application = new SpringApplication(SpWebApplication.class);
    6. 		application.run(args);
    7. 	}
    8. }

    动态为属性赋值

    properties文件为属性动态赋值

    1. #mysql.properties文件内
    2. mysql.username=名字
    3. mysql.password=123
    1. @RestController
    2. @PropertySource(value = "classpath:/mysql.properties",encoding = "UTF-8")
    3. public class TestController {
    4.     @Value("${mysql.username:lili}")
    5.     private String username;
    6.     @Value("${mysql.password}")
    7.     private String password;
    8.     @RequestMapping("/test")
    9.     public String getMsg(){
    10.         return username+password;
    11.     }
    12. }

    访问路径：localhost:8080/test

    注意：

    • @PropertySource注解用于将该文件交给spring容器管理，它主要用来读取properties文件
    • @PropertySource注解若不设置编码，则默认为iso-8859-1编码，其内的value值应为文件路径
    • @Value作用是给属性动态赋值，若属性被赋予了默认值，则默认值被value注解内的值覆盖
    • @Value("${mysql.username:lili}")内的lili为没有读到mysql.username的值时给定username的默认值
    • @ConfigurationProperties(prefix = "mysql")注解加载类上面，作用是将mysql为前缀的pro文件属性与类中的属性进行映射，属性相同则不用写value注解（上面2个属性均能映射）
    • @Value内支持sel表达式

    yml文件为属性动态赋值

    前言：只要是application的配置文件(yml、properties)都是springboot的核心配置文件，springboot已经对其进行管理，就不需要再交给spring来管理了

    1. #application.yaml文件内
    2. mysql:
    3.   username: 名字
    4.   password: 234
    1. @RestController
    2. public class TestController {
    3.     @Value("${mysql.username}")
    4.     private String username;
    5.     @Value("${mysql.password}")
    6.     private String password;
    7.     @RequestMapping("/test")
    8.     public String getMsg(){
    9.         return username+password;
    10.     }
    11. }

     访问路径：localhost:8080/test

    注意：yaml文件读取时默认采用utf-8形式编码

    yml文件内特殊属性动态赋值

    1. #application.yaml内
    2. server:
    3.   port: 8888
    4. mysql:
    5.   #数组写法
    6.   hobbies: [足球,篮球] #数组写法1
    7.   pets: #数组写法2
    8.     - cat
    9.     - dog
    10.   #map写法
    11.   girlFriend:
    12.     18: 范凉凉
    13.     20: 地里冷吧
    14.   boyFriend: {18: 张三, 20: 李四}
    15.   #随机值写法
    16.   number: ${random.int[1,100]} #随机值范围1-100岁

    类比properties文件

    1. #application.properties文件内
    2. server.port=8888
    3. #数组写法
    4. mysql.hobbies=唱歌,跳舞
    5. #map集合写法
    6. mysql.girlFriend.18=范凉凉
    7. mysql.girlFriend.20=迪丽冷吧
    8. #随机数写法
    9. mysql.number=${random.int[1,100]}
    1. @Data
    2. @RestController
    3. @ConfigurationProperties(prefix = "mysql")
    4. public class TestController {
    5.     private List<String> hobbies;
    6.     private List<String> pets;
    7.     private Map<Integer,String> girlFriend;
    8.     private Map<Integer,String> boyFriend;
    9.     private Integer number;
    10.     @RequestMapping("/test")
    11.     public String getMsg(){
    12.         return "爱好为："+hobbies+"\n宠物为"+pets;
    13.     }
    14.     @RequestMapping("/friend")
    15.     public String getFriend(){
    16.         return "朋友为："+girlFriend+boyFriend;
    17.     }
    18.     @RequestMapping("/random")
    19.     public String getNumber(){
    20.         return "随机值为"+number;
    21.     }
    22. }

    注意：

    • 使用时要为具体实体类属性加set方法
    • @ConfigurationProperties注解常用于bean属性的yml配置文件的绑定
    • yml文件内可以设置随机值
    • yml文件不支持sel表达式，但是支持属性引用以及对随机数的引用
    • 特殊属性的动态赋值尽量不用@Value注解

    springboot环境分割

    前言：

    • 可以用在yml文件内也可以用在properties文件内
    • @Profile("环境名称")注解用在spring容器中的bean上，当触发某种环境，那么被标记为该环境的bean将会生效，其他环境的bean将不会生效

    单文件形式

    1. #application.yaml文件内
    2. spring:
    3.   profiles:
    4.     active: dev
    5. ---
    6. server:
    7.   port: 8888
    8. spring:
    9.   config:
    10.     activate:
    11.       on-profile: dev
    12. ---
    13. server:
    14.   port: 6666
    15. spring:
    16.   config:
    17.     activate:
    18.       on-profile: test

    注意：

    • 每个环境之间用---来分割
    • active对应哪个环境下的on-profile那么就使用哪个环境的配置
    • dev（开发环境）、prod（生产环境）、test（测试环境）

    分文件形式

    1. #application.yaml文件内
    2. spring:
    3.   profiles:
    4.     active: dev
    1. #application-dev.yaml文件内
    2. server:
    3.   port: 8888
    1. #application-test.yaml文件内
    2. server:
    3.   port: 6666

    注意：

    • active对应所要用的环境名称
    • 文件起名：application-环境名称.yaml
    • 环境名称的名字可以随意写，但约定优于配置

    热部署

    前言：为了进一步提高开发效率，springboot为我们提供了全局项目热部署，日后在开发过程中修改了部分代码及相关配置文件后，不需要每次重启修改生效，在项目中开启了spring全局热部署之后只需要修改之后等待几秒钟即可使修改生效

    引入热部署依赖

    1. 		<!--devtools热部署-->
    2. 		<dependency>
    3. 			<groupId>org.springframework.boot</groupId>
    4. 			<artifactId>spring-boot-devtools</artifactId>
    5. 			<optional>true</optional>
    6. 		</dependency>

    idea中配置 

    1. idea中File | Settings | Build, Execution, Deployment | Compiler开启自动编译
    2. ctrl+shift+alt+/，选择Registry，勾上Compile autoMake allow when app running

    springboot日志的使用

    日志门面：不实现日志功能，只是用来整合日志的（日志抽象层）

    理解：市面上的日志框架非常混乱，一个项目内多个模块可能用不同的日志框架，所以引出日志门面

    使用：左边选一个门面，右边选一个实现

    注意：

    • springboot底层spring，spring默认用jcl门面，而springboot选用了slf4j门面和logback日志实现
    • 以后开发的时候，日志记录方法的调用，不应该直接调用日志的实现类，而是调用日志抽象层里面的方法

    springboot默认日志配置

    1. @SpringBootTest
    2. class Springboot3ApplicationTests {
    3. 	//日志记录器
    4. 	Logger logger = LoggerFactory.getLogger(getClass());
    5. 	@Test
    6. 	void contextLoads() {
    7.         String s=":";
    8.         String msg="message";
    9.         logger.trace("trace{}{}",s,msg);
    10.         logger.debug("debug{}{}",s,msg);
    11.         logger.info("info{}{}",s,msg);
    12.         logger.warn("warn{}{}",s,msg);
    13.         logger.error("error{}{}",s,msg);
    14. 	}
    15. }

    日志级别：trace

    注意：

    • 日志打印规则——只打印比日志级别高的日志信息
    • logger方法里面字符串内的{}为占位符(可以写多个)；分别按顺序依次表示后面的数据
    • springboot默认日志级别为info级别 

    日志的级别

    1. #application.properties文件内
    2. #将cn.tedu包下的文件日志级别调为trace级别
    3. logging.level.cn.tedu=trace
    4. #将打印的日志文件输出到具体位置
    5. # 直接输出当前项目下的springboot.log文件中,如果不想在当前项目下生成日志文件，那么指定绝对路径
    6. logging.file.name=springboot.log
    1. #application.properties文件内
    2. #将cn.tedu包下的文件日志级别调为trace级别
    3. logging.level.cn.tedu=trace
    4. #指定日志生成在文件的哪个目录，默认日志文件名为spring.log
    5. #根目录下的spring/log目录里
    6. logging.file.path=/spring/log

    日志的输出格式

    1. #application.properties文件内
    2. #将cn.tedu包下的文件日志级别调为trace级别
    3. logging.level.cn.tedu=trace
    4. logging.file.name=springboot.log
    5. #在控制台输出的日志格式
    6. logging.pattern.console=[%thread] %msg %n
    7. #在文件中日志输出的格式
    8. logging.pattern.file=%d{yyyy-MM-dd} [%thread] %msg %n

    静态资源访问

    前言：只要静态资源放在类路径下：static or public or resources or META-INF/resources这些目录中，那么接下来浏览器就可以直接访问（当前项目根路径/+静态资源名）

    原理：静态资源映射/**

    请求进来，先去找controller，看能不能处理，不能处理的所有请求就会交给静态资源处理器，然后静态资源就会按照以上文件内的名字进行查找，若静态资源能找到，那么就会访问，若不能找到，那么就会404

    静态资源访问前缀

    1. #application.yml文件内
    2. spring:
    3.   mvc:
    4.     #为静态资源加访问前缀，默认为/**
    5.     static-path-pattern: /res/** #表示res下的所有请求都是静态资源请求

    注意：以上说明访问res下的东西才会映射到static or public or resources or META-INF/resources这些目录中，去查找对应的文件

    改变放入静态资源文件的目录

    1. #application.yml文件内
    2. spring:
    3.   mvc:
    4.     #为静态资源加访问前缀，默认为/**
    5.     static-path-pattern: /res/** #表示res下的所有请求都是静态资源请求
    6.   #修改将静态资源放入/app内可以直接访问
    7.   web:
    8.     resources:
    9.       static-locations: [classpath:/app] #传递的是一个数组

    设置静态资源映射

    1. //说明其为一个配置类
    2. @Configuration
    3. public class WebMvcConfig extends WebMvcConfigurationSupport {
    4.     //设置静态资源映射
    5.     @Override
    6.     protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    7.         //将路径中有backend的请求映射到classpath下的backend路径后面
    8.         registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
    9.         registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");
    10.     }
    11. }

    静态欢迎页

    • 静态资源路径下的index.html（可以配置静态资源路径，但不可配置静态资源访问前缀）
    • controller方法返回的index

    网站图标

    将图标改为favicon.ico放入到springboot的静态目录中，那么以后访问该网页就自动有这个图标（可以配置静态资源路径，但不可配置静态资源访问前缀）

    注意：这个图标在同一次会话中共享

  • 相关阅读:
    2023研究生数学建模D题思路代码 区域双碳目标与路径规划研究
    Springboot+Vue项目-基于Java+MySQL的图书馆管理系统(附源码+演示视频+LW)
    【Axure视频教程】折线图
    C++：类和对象（二）
    面试官：这就是你理解的Java多线程基础？
    域名解析常见问题（上）
    Unity中Shader的GI的直接光实现
    JAVA语言都有哪些特点
    超全面的前端工程化配置指南
    Vue Admin Template关闭eslint校验，lintOnSave：false设置无效解决办法
  • 原文地址：https://blog.csdn.net/m0_60027772/article/details/125804094