首页 > 其他分享 >SpringBoot

SpringBoot

时间：2023-11-02 10:48:23浏览次数：39  
标签：SpringBoot 配置文件 配置 private springframework org import

1. SrpingBoot入门及原理

Spring是如何简化Java开发的

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

  1. 基于POJO的轻量级和最小侵入性编程，所有东西都是bean；
  2. 通过IOC，依赖注入（DI）和面向接口实现松耦合；
  3. 基于切面（AOP）和惯例进行声明式编程；
  4. 通过切面和模版减少样式代码，RedisTemplate，xxxTemplate；

什么是SpringBoot

为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。

多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring
Boot 应用中这些第三方库几乎可以零配置的开箱即用。

Spring Boot的主要优点：

  • 为所有Spring开发者更快的入门
  • 开箱即用，提供各种默认配置来简化项目配置
  • 内嵌式容器简化Web项目
  • 没有冗余代码生成和XML配置的要求

2. HelloWorld

创建基础项目说明

项目创建方式一：使用Spring Initializr 的 Web页面创建项目

  1. 打开 https://start.spring.io/
  2. 填写项目信息
  3. 点击”Generate Project“按钮生成项目；下载此项目
  4. 解压项目包，并用IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。

项目结构分析：

通过上面步骤完成了基础项目的创建。就会自动生成以下文件

  1. 程序的主启动类
  2. 一个 application.properties 配置文件
  3. 一个 测试类
  4. 一个 pom.xml

pom.xml 分析

打开 pom.xml ，看看Spring Boot项目的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.1.5</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example.springboot.study</groupId>
	<artifactId>springboot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<!-- 打包插件 -->
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

编写HTTP接口

  1. 在主程序的同级目录下，新建一个controller包，一定要在同级目录下，否则识别不到
  2. 在包中新建一个HelloController类
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }
}

@RestController 是@controller和@ResponseBody 的结合

@Controller 将当前修饰的类注入SpringBoot IOC容器，使得从该类所在的项目跑起来的过程中，这个类就被实例化。
@ResponseBody 它的作用简短截说就是指该类中所有的API接口返回的数据，甭管你对应的方法返回Map或是其他Object，它会以Json字符串的形式返回给客户端

  1. 编写完毕后，从主程序启动项目，浏览器发起请求，看页面返回；控制台输出了 Tomcat 访问的端口号！

将项目打成jar包，点击 maven的 package

​ 如果打包成功，则会在target目录下生成一个 jar 包

​ 打成了jar包后，就可以在任何地方运行了！ java -jar xxx.jar

如何更改启动时显示的字符拼成的字母，SpringBoot呢？ 也就是 banner 图案；

只需一步：到项目下的 resources 目录下新建一个banner.txt 即可。
图案可以到：https://www.bootschool.net/ascii 这个网站生成，然后拷贝到文件中即可！

3. 运行原理探究

3.1 Pom.xml

父依赖

其中它主要是依赖一个父项目，主要是管理项目的资源过滤及插件！

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

启动器 spring-boot-starter

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

springboot-boot-starter-xxx：就是spring-boot的场景启动器

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

3.2 主启动类

默认的主启动类

@SpringBootApplication
public class SpringbootApplication {

	public static void main(String[] args) {
		//以为是启动了一个方法，没想到启动了一个服务
		SpringApplication.run(SpringbootApplication.class, args);
	}

}

@SpringBootApplication

作用：标注在某个类上说明这个类是SpringBoot的主配置类 ， SpringBoot就应该运行这个类的main方
法来启动SpringBoot应用；

进入这个注解：可以看到上面还有很多其他注解!

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

public @interface SpringBootApplication {
    //......
}

@ComponentScan

这个注解在Spring中很重要 ,它对应XML配置中的元素。
作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

@SpringBootConfiguration

作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；
我们继续进去这个注解查看

@Configuration
public @interface SpringBootConfiguration {
}

@Component
public @interface Configuration {
}

这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；

里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

我们回到 SpringBootApplication 注解中继续看。

@EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ； @EnableAutoConfiguration
告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解接续查看：

@AutoConfigurationPackage ： 自动配置包

@Import({AutoConfigurationPackages.Registrar.class})
public @interface AutoConfigurationPackage {
}

@import ：Spring底层注解@import ， 给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；
这个分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；
AutoConfigurationImportSelector ： 自动配置导入选择器，那么它会导入哪些组件的选择器呢？

spring.factories

全局搜索 spring.factories

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

image-20231030144332970

我们在上面的自动配置类随便找一个打开看看，比如 ： WebMvcAutoConfiguration

image-20231030152700088

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看
着熟悉一下！
所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中
对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了
@Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容
器中。

结论：

  1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
  2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作
  3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
  4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
  5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

3.3 SpringApplication

不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplication
public class SpringbootApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringbootApplication.class, args);
	}
}

SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication

这个类主要做了以下四件事情：

  1. 推断应用的类型是普通的项目还是Web项目
  2. 查找并加载所有可用初始化器 ， 设置到initializers属性中
  3. 找出所有的应用程序监听器，设置到listeners属性中
  4. 推断并设置main方法的定义类，找到运行的主类

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // ......
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

run方法

image-20231030152558070

3.4 Yaml语法学习

配置文件

SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的

  • application.properties
    • 语法结构 ： key=value
  • application.yml
    • 语法结构 ：key：空格 value

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

比如我们可以在配置文件中修改Tomcat 默认启动的端口号！测试一下！

server.port=8081

yaml 概述

YAML是 "YAML Ain't a Markup Language" （YAML不是一种标记语言）的递归缩写。

这种语言以数据做为中心，而不是以标记语言为重点！

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml传统xml配置：

<server>
	<port>8081<port>
</server>

yaml配置：

server：
    prot: 8080

yml基础语法

说明：语法要求严格！

1、空格不能省略

2、以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。

3、属性和值的大小写都是十分敏感的。

字面量：普通的值 [ 数字，布尔值，字符串 ]

字面量直接写在后面就可以 ， 字符串默认不用加上双引号或者单引号；

k: v

注意：

  • “ ” 双引号，不会转义字符串里面的特殊字符 ， 特殊字符会作为本身想表示的意思； 比如 ： name: "kuang \n shen" 输出 ： kuang 换行 shen
  • '' 单引号，会转义特殊字符 ， 特殊字符最终会变成和普通字符一样输出 比如 ： name: ‘kuang \n shen’ 输出 ： kuang \n shen

对象、Map（键值对）

#对象、Map格式
k:
 v1:
 v2:

在下一行来写对象的属性和值得关系，注意缩进；比如：

student:
	name: qinjiang
	age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）

用 - 值表示数组中的一个元素,比如：

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

修改SpringBoot的默认端口号

配置文件中添加，端口号的参数，就可以切换端口；

server:
	port: 8082

3.5 注入配置文件

yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

Yaml注入配置文件

  1. 在springboot项目中的resources目录下新建一个文件 application.yml
  2. 编写一个实体类 Dog；
package com.example.springboot.study.springboot.entity;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class Dog {
    @Value("阿黄")
    private String name;
    @Value("18")
    private Integer age;
}

3、在SpringBoot的测试类下注入狗狗输出一下；

@SpringBootTest
class SpringbootApplicationTests {
	@Autowired
	Dog dog;

	@Test
	void contextLoads() {
		System.out.println(dog);
	}
}

image-20231031145908299

4、我们在编写一个复杂一点的实体类：Person 类

package com.example.springboot.study.springboot.entity;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;
/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Data
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

5、我们来使用yaml配置的方式进行注入，大家写的时候注意区别和优势，我们编写一个yaml配置

person:
  name: qinjiang
  age: 3
  happy: false
  birth: 2000/01/01
  maps: {k1: v1,k2: v2}
  lists:
    - code
    - girl
    - music
  dog:
    name: 旺财
    age: 1

7、我们刚才已经把person这个对象的所有值都写好了，我们现在来注入到我们的类中！

package com.example.springboot.study.springboot;

import com.example.springboot.study.springboot.entity.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringbootApplicationTests {
	@Autowired
	Person person;

	@Test
	void contextLoads() {
		System.out.println(person);
	}
}

image-20231031150743803

yaml配置注入到实体类完全OK！

课堂测试：
1、将配置文件的key 值 和 属性的值设置为不一样，则结果输出为null，注入失败
2、在配置一个person2，然后将 @ConfigurationProperties(prefix = "person2") 指向我们的
person2；

加载指定配置文件

@PropertySource ：加载指定的配置文件；

@configurationProperties：默认从全局配置文件中获取值；

1、我们去在resources目录下新建一个person.properties文件

name=kuangshen

2、然后在我们的代码中指定加载person.properties文件

package com.example.springboot.study.springboot.entity;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;

@Data
@Component
//@ConfigurationProperties(prefix = "person2")
@PropertySource(value = "classpath:person.properties")
public class Person {
    @Value("${name}")
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

image-20231031151723975

配置文件占位符

person:
  name: qinjiang${random.uuid} # 随机uuid
  age: ${random.int} # 随机int
  happy: false
  birth: 2000/01/01
  maps: {k1: v1,k2: v2}
  lists:
    - code
    - girl
    - music
  dog:
    # 引用person.hello 的值，如果不存在就用 ：后面的值，即 other，然后拼接上_旺财
    name: ${person.hello:other}_旺财
    age: 1

image-20231031152127912

回顾properties配置

【注意】properties配置文件在写中文的时候，会有乱码 ， 我们需要去IDEA中设置编码格式为UTF-8；
settings-->File Encodings 中配置；

测试步骤：

1、新建一个实体类User

package com.example.springboot.study.springboot.entity;

import lombok.Data;
import org.springframework.stereotype.Component;

@Data
@Component
public class User {
    private String name;
    private int age;
    private String sex;
}

2、编辑配置文件 user.properties

user1.name=kuangshen
user1.age=18
user1.sex=男

3、我们在User类上使用@Value来进行注入！

package com.example.springboot.study.springboot.entity;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Data
@Component
@PropertySource(value = "classpath:user.properties")
public class User {
    //直接使用@value
    @Value("${user.name}") //从配置文件中取值
    private String name;
    @Value("#{9*2}") // #{SPEL} Spring表达式
    private int age;
    @Value("男") // 字面量
    private String sex;
}

4、Springboot测试

package com.example.springboot.study.springboot;

import com.example.springboot.study.springboot.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringbootApplicationTests {
	@Autowired
	User user;

	@Test
	void contextLoads() {
		System.out.println(user);
	}
}

image-20231031154007222

对比小结

@Value这个使用起来并不友好！我们需要为每个属性单独注解赋值，比较麻烦；我们来看个功能对比图

image-20231031154109965

1、@ConfigurationProperties只需要写一次即可 ， @Value则需要每个字段都添加 \

2、松散绑定：这个什么意思呢? 比如我的yml中写的last-name，这个和lastName是一样的， - 后面跟着的字母默认是大写的。这就是松散绑定。可以测试一下

3、JSR303数据校验 ， 这个就是我们可以在字段是增加一层过滤器验证 ， 可以保证数据的合法性
4、复杂类型封装，yml中可以封装对象 ， 使用value就不支持

结论：

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

JSR303数据校验

Springboot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处
理。我们这里来写个注解让我们的name只能支持Email格式；

@Email注解的使用方法

  1. 添加依赖
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
</dependency>

image-20231031172642044

使用数据校验，可以保证数据的正确性； 下面列出一些常见的使用

@NotNull(message="名字不能为空")
private String userName;
@Max(value=120,message="年龄最大不能查过120")
private int age;
@Email(message="邮箱格式错误")
private String email;

空检查
@Null 验证对象是否为null
@NotNull 验证对象是否不为null, 无法查检长度为0的字符串
@NotBlank 检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空
格.
@NotEmpty 检查约束元素是否为NULL或者是EMPTY.

Booelan检查
@AssertTrue 验证 Boolean 对象是否为 true
@AssertFalse 验证 Boolean 对象是否为 false

长度检查
@Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内
@Length(min=, max=) string is between min and max included.

日期检查
@Past 验证 Date 和 Calendar 对象是否在当前时间之前
@Future 验证 Date 和 Calendar 对象是否在当前时间之后
@Pattern 验证 String 对象是否符合正则表达式的规则

.......等等
除此以外，我们还可以自定义一些数据校验规则

3.6 多环境切换

profile是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境；

多配置文件

我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml , 用来指定多个环境版本；

例如：application-test.properties 代表测试环境配置 application-dev.properties 代表开发环境配置
但是Springboot并不会直接启动这些配置文件，它默认使用application.properties主配置文件；

Spring配置

在application.yml中添加配置

#选择要激活那个环境块
spring:
  profiles:
    active:
      - "@activated.profile@"

在application-dev.yml中添加配置

# application-dev.yml
server:
  port: 9001

在application-prod.yml中添加配置

# application-prod.yml
server:
  port: 9002

Maven 配置

<profiles>
		<profile>
			<id>dev</id>
			<properties>
				<activated.profile>dev</activated.profile>
			</properties>
		</profile>
		<profile>
			<id>test</id>
			<properties>
				<activated.profile>test</activated.profile>
			</properties>
		</profile>
		<profile>
			<id>pro</id>
			<properties>
				<activated.profile>pro</activated.profile>
			</properties>
			<!--默认开发环境-->
			<activation>
				<activeByDefault>true</activeByDefault>
			</activation>
		</profile>
	</profiles>

标签：SpringBoot,配置文件,配置,private,springframework,org,import
From： https://www.cnblogs.com/KxWanna/p/17804842.html

相关文章

  • gin框架curd 和java springboot crud 的比较及性能
    Gin框架与SpringBoot框架的CURD比较Ginvs.SpringBoot:简介Gin(Go语言):Gin是用于构建Web应用程序和API的轻量级、高性能框架，使用Go编程语言。它以简洁和高性能而闻名。SpringBoot(Java):SpringBoot是一个用于构建基于Java的Web应用程序的开源Java框架。它简化了使......
  • Java后台微信点餐小程序2023年最新版笔记Springboot+Mysql+Freemarker+Bootstrap
    由于之前的Java后台微信点餐小程序有些知识点过时了，所以今天重新出一版，把里面过时的知识点更新下第一章，技术选型(重要)在开始学习之前，要记得安装jdk8和mysql8，后面的笔记里也会具体讲解怎么安装，但是jdk8和mysql8必须和石头哥保持一致。1,后台技术选型：JDK8(必须保持一致)Mysql8(必......
  • SpringBoot数据响应、分层解耦、三层架构
    响应数据@ResponseBody类型：方法注解、类注解位置：Controller方法、类上作用：将方法返回值直接响应，如果返回值类型是实体对象/集合，将会转换为json格式响应说明：@RestController=@Controller+@ResponseBody统一响应结果步骤：获取员工数据，返回统一响应结果，在页面渲染......
  • Jenkins+Docker 一键自动化部署 SpringBoot 项目
    Jenkins和Docker是现代软件开发中非常流行的工具，可以帮助我们自动化构建、测试和部署应用程序。SpringBoot是一种流行的Java框架，可以帮助开发人员快速开发Web应用程序。在本文中，我们将介绍如何使用Jenkins和Docker一键自动化部署SpringBoot应用程序。准备工作首先，你需要安装并配......
  • springboot web使用mybatis访问mysql库
    思想：重点：springboot项目可以配置mybatis必须的内容。默认配置文件为“main/resources/application.properties”(yml为其另一种写法，感兴趣自己去查)一切编码跟普通的mybatis相同。注意：xml文件最好放在资源文件夹resources下面，以便编译时直接复制。由此引起需要在springboot......
  • java实现文件夹上传功能实例代码(SpringBoot框架)
    前言有时我们后台管理等服务可能会有这样一个简单需求，就是根据文件夹将整个文件夹下的所有资源都上传到我们的服务器上，本人也是搜索了大量资料，最终以最简单便捷的方式实现该功能，具体操作步骤如下一、前端如何设置上传组件并将资源上传到后台服务这里的项目框架为若依VUE版本......
  • SpringBoot中，为什么不直接使用一个Service写功能，而是Service接口+ServiceImpl实现类？
    当项目比较简单的时候，需求明确，变更不频繁或者几乎不怎么修改的时候，用第一种就好了当项目比较复杂，需求变更多的时候，用第二种比较好service层=service接口+serviceImpl实现类这种方式好处：1、解耦合2、便于扩展例如：publicinterfaceHumanService{StringgetName();}@Serv......
  • Gradle8.4构建SpringBoot多模块项目
    Gradle8.4构建SpringBoot多模块项目一、基本1、版本这个版本是Jdk8最后一个SpringBoot版本软件版本Gradle8.4SpringBoot2.7.15JDK82、Gradle基本介绍2.1、使用Wrapper方式构建好处：统一gradle的版本好处：不用安装gradle就可以使用Maven也是一样的......
  • 一文详解 springboot 项目启动时异步执行初始化逻辑
    你知道的越多，你不知道的越多点赞再看，养成习惯文章目录前言代码实现定义异步处理工具类实现java线程池新建AppInit实现ApplicationRunner接口完成启动项目时异步数据初始化前言前面的工作中，为了提高地区数据的响应时间，需要加载全国区划数据到redis中缓存起来，这个过程希......
  • SpringBoot事件驱动开发
    应用启动过程生命周期事件感知（9大事件）、应用运行中事件感知（无数种）事件发布：ApplicationEventPublisherAware或注入：ApplicationEventMulticaster事件监听：组件+@EventListener场景：当用户登录后，我们需要为用户增加一个积分、随机获取一张优惠券、增加日志等，传统的开发模式......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99