SpringBoot是一个简化 Spring 应用程序开发的框架，它的主要目标是减少 Spring 应用程序的配置和开发复杂性，使我们能够更快地构建、测试和部署 Spring 应用。简单来说，它通过提供默认配置、自动化配置和嵌入式服务器等功能，简化了传统Spring 应用的繁琐配置过程。有人将一些依赖关系、默认配置都梳理好了，我们直接一个引用就搞定了，这就是它的本质。
可以不需要，内置了 Tomcat/ Jetty 等容器。
JavaWeb是 Java 语言的 Web 开发技术，主要用于开发 Web 应用程序，包括基于浏览器的客户端和基于服务器的 Web 服务器。
Spring是一个轻量级的开源开发框架，主要用于管理 Java 应用程序中的组件和对象，并提供各种服务，如事务管理、安全控制、面向切面编程和远程访问等。它是一个综合性框架，可应用于所有类型的 Java 应用程序。
SpringMVC是 Spring 框架中的一个模块，用于开发 Web 应用程序并实现 MVC（模型-视图-控制器）设计模式，它将请求和响应分离，从而使得应用程序更加模块化、可扩展和易于维护。
Spring Boot是基于 Spring 框架开发的用于开发 Web 应用程序的框架，它帮助开发人员快速搭建和配置一个独立的、可执行的、基于 Spring 的应用程序，从而减少了繁琐和重复的配置工作。
综上所述，JavaWeb是基于 Java 语言的 Web 开发技术，而 Spring 是一个综合性的开发框架，SpringMVC用于开发 Web 应用程序实现 MVC 设计模式，而 Spring Boot 是基于 Spring 的 Web 应用程序开发框架。
相关原理可以查看：两种方式启动原理
java -jar xxx.jar 命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。BOOT-INFclasses 目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。Spring Boot的可执行JAR文件之所以可以直接运行，原因如下：
在开发分布式Springboot项目时， 自定义Starter是一定会用到的。以下是创建自定义Spring Boot Starter的基本步骤：
自定义一个Spring Boot Starter需要遵循上述步骤，其中创建META-INF/spring.factories文件是关键，因为它告诉Spring Boot如何自动装配您的功能。这样，其他项目可以方便地引入您的Starter，实现功能的快速集成。
SpringBoot是快速开发的Spring框架，SpringCloud是完整的微服务框架，SpringCloud依赖于SpringBoot。
启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：
@SpringBootApplication：这个注解是Spring Boot最核心的注解，用在 Spring Boot的主类上，标识这是一个 Spring Boot 应用，用来开启 Spring Boot 的各项能力
@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
@ComponentScan：Spring组件扫描。
@Repository：用于标注数据访问组件，即DAO组件。
@Service：一般用于修饰service层的组件
@RestController：用于标注控制层组件(如struts中的action)，表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器；它是@Controller和@ResponseBody的合集。
@ResponseBody：表示该方法的返回结果直接写入HTTP response body中
@Component：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Bean：相当于XML中的
@AutoWired：byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。
@Qualifier：当有多个同一类型的Bean时，可以用@Qualifier("name")来指定。与@Autowired配合使用
@Resource(name="name",type="type")：没有括号内内容的话，默认byName。与@Autowired干类似的事。
@RequestMapping：RequestMapping是一个用来处理请求地址映射的注解；提供路由信息，负责URL到Controller中的具体函数的映射，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
@RequestParam：用在方法的参数前面。
@RequestBody：将 HTTP 请求体中的数据绑定到方法参数上。Spring 会将JSON、XML或其他格式的请求体转换为Java 对象，并将其传递给控制器方法的参数。
@PathVariable：Spring MVC 中用于从URI 模板中提取变量值的注解。它的主要作用是在处理 HTTP请求时，从请求的URL 路径中捕获变量，并将其绑定到控制器方法的参数上
@Scope：用于声明一个SpringBean实例的作用域
@Primary：当同一个对象有多个实例时，优先选择该实例。
@PostConstruct： 用于修饰方法，当对象实例被创建并且依赖注入完成后执行，可用于对象实例的初始化操作。
@PreDestroy：用于修饰方法，当对象实例将被Spring容器移除时执行，可用于对象实例持有资源的释放。
@EnableTransactionManagement：启用Spring基于注解的事务管理功能，需要和@Configuration注解一起使用。
@Transactional：表示方法和类需要开启事务，当作用与类上时，类中所有方法均会开启事务，当作用于方法上时，方法开启事务，方法上的注解无法被子类所继承。
@ControllerAdvice：常与@ExceptionHandler注解一起使用，用于捕获全局异常，能作用于所有controller中。
@ExceptionHandler：修饰方法时，表示该方法为处理全局异常的方法。
@Profile：用于定义一组 Bean 的配置文件所属的环境，比如 dev 通常表示开发环境，prod 表示生产环境
@Validated 和 @Valid 都是用于在 Spring 中执行对象验证的注解，但它们的使用场景和特性有一些区别：
在 Spring 框架中，@Vàlue 注解用于注入外部化的配置值到 Spring 管理的 Bean 中。通过 @Value 注解，可以将属性文件、环境变量、系统属性等外部资源中的值注入到 Spring Bean 的字段、方法参数或构造函数参数中。
@Value的解析就是在bean初始化阶段。BeanPostProcessor定义了bean初始化前后用户可以对bean进行操作的接口方法，它的一个重要实现类AutowiredAnnotationBeanPostProcessor为bean中的@Autowired和@Value注解的注入功能提供支持。
是 Spring 中用于加载外部属性文件(如.properties 文件)的注解。
它的主要作用是让 Spring 应用程序可以从外部的属性文件中读取配置，并将这些属性注入到 Spring 的 Environment 中，从而实现应用的外部化配置，使得应用程序在不同环境下更容易管理和维护。方便通过@Value 或 Environment 对象获取属性值
这个注解用于在 Spring 应用中定时执行方法。它可以将某个方法标记为一个定时任务，并根据设定的时间间隔、固定速率、或 Cron 表达式来定时触发该方法的执行。
主要作用:
@Cacheable 和 @CacheEvict 是Spring中用于缓存操作的两个重要注解，主要用于提高系统性能，通过减少对数据库等外部资源的频繁访问。
作用于有条件地装配 Bean。
可以根据特定的条件来决定某个 Bean 是否应该被加载到 Spring 容器中。例如可以根据环境(如开发、测试、生产)或特定上下文条件动态装配 Bean，实现动态加载
主要作用:
@Lazy 的两种用法：
通过标注在方法上， @EventListener 可以使方法自动监听特定类型的事件，它用于监听和处理事件。并在事件发布时触发执行，它提供了一种松耦合的方式来处理应用中的事件，避免事件发布者和监听者之间的直接依赖关系，
使用场景：
@Async 注解的核心原理是基于Spring AOP的动态代理机制，结合线程池实现异步任务调度，通过合理的线程池配置和异常处理，可以高效地实现异步操作。
@Async失效的主要原因包括内部调用绕过代理、方法非 public、未启用异步支持、返回值类型不匹配、异常处理不当、线程池配置错误以及对象未被 Spring 管埋等
Spring JavaConfig 是 Spring 社区的产品，Spring 3.0引入了他，它提供了配置 Spring IOC 容器的纯Java 方法。因此它有助于避免使用 XML 配置。
使用 JavaConfig 的优点在于：
常用的Java config：
SpringBoot默认使用CGLIB 原因如下：
SpringBoot 应用的启动流程都封装在 SpringApplication.run方法中，它的大部分逻辑都是复用 Spring 启动的流程，只不过在它的基础上做了大量的扩展在启动的过程中有一个刷新上下文的动作，这个方法内会触发 webserver 的创建，此时就会创建并启动内嵌的 web服务，默认的 web 服务就是 tomcat
Spring Boot 的启动过程几个核心步骤：
在 application.properties 中设置属性 debug=true，可以在控制台查看已启用和未启用的自动配置。
@SpringBootApplication是@Configuration、@EnableAutoConfiguration和@ComponentScan的组合。
@Configuration表示该类是Java配置类。
@ComponentScan开启自动扫描符合条件的bean（添加了@Controller、@Service等注解）。
@EnableAutoConfiguration会根据类路径中的jar依赖为项目进行自动配置，比如添加了spring-boot-starter-web依赖，会自动添加Tomcat和Spring MVC的依赖，然后Spring Boot会对Tomcat和Spring MVC进行自动配置（spring.factories EnableAutoConfiguration配置了WebMvcAutoConfiguration）。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}
EnableAutoConfiguration主要由 @AutoConfigurationPackage，@Import(EnableAutoConfigurationImportSelector.class)这两个注解组成的。
@AutoConfigurationPackage用于将启动类所在的包里面的所有组件注册到spring容器。
@Import 将EnableAutoConfigurationImportSelector注入到spring容器中，EnableAutoConfigurationImportSelector通过SpringFactoriesLoader从类路径下去读取META-INF/spring.factories文件信息，此文件中有一个key为org.springframework.boot.autoconfigure.EnableAutoConfiguration，定义了一组需要自动配置的bean。
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,
这些配置类不是都会被加载，会根据xxxAutoConfiguration上的@ConditionalOnClass等条件判断是否加载，符合条件才会将相应的组件被加载到spring容器。（比如mybatis-spring-boot-starter，会自动配置sqlSessionFactory、sqlSessionTemplate、dataSource等mybatis所需的组件）
@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
AnnotatedElement.class }) //类路径存在EnableAspectJAutoProxy等类文件，才会加载此配置类
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
public static class JdkDynamicAutoProxyConfiguration {
}
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
public static class CglibAutoProxyConfiguration {
}
}
全局配置文件中的属性如何生效，比如：server.port=8081，是如何生效的？
@ConfigurationProperties的作用就是将配置文件的属性绑定到对应的bean上。全局配置的属性如：server.port等，通过@ConfigurationProperties注解，绑定到对应的XxxxProperties bean，通过这个 bean 获取相应的属性（serverProperties.getPort()）。
//server.port = 8080
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
private Integer port;
private InetAddress address;
@NestedConfigurationProperty
private final ErrorProperties error = new ErrorProperties();
private Boolean useForwardHeaders;
private String serverHeader;
//...
}
简单总结如下：
实现当某个类存在时，自动配置这个类的bean，并且可以在application.properties中配置bean的属性。
（1）新建Maven项目spring-boot-starter-hello，修改pom.xml如下：
4.0.0
com.tyson
spring-boot-starter-hello
1.0-SNAPSHOT
org.springframework.boot
spring-boot-autoconfigure
1.3.0.M1
junit
junit
3.8.1
（2）属性配置
public class HelloService {
private String msg;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String sayHello() {
return "hello" + msg;
}
}
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix="hello")
public class HelloServiceProperties {
private static final String MSG = "world";
private String msg = MSG;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
（3）自动配置类
import com.tyson.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties(HelloServiceProperties.class) //1
@ConditionalOnClass(HelloService.class) //2
@ConditionalOnProperty(prefix="hello", value = "enabled", matchIfMissing = true) //3
public class HelloServiceAutoConfiguration {
@Autowired
private HelloServiceProperties helloServiceProperties;
@Bean
@ConditionalOnMissingBean(HelloService.class) //4
public HelloService helloService() {
HelloService helloService = new HelloService();
helloService.setMsg(helloServiceProperties.getMsg());
return helloService;
}
}
（4）注册配置
想要自动配置生效，需要注册自动配置类。在 src/main/resources 下新建 META-INF/spring.factories。添加以下内容：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.tyson.config.HelloServiceAutoConfiguration
""是为了换行后仍然能读到属性。若有多个自动配置，则用逗号隔开。
（5）使用starter
在 Spring Boot 项目的 pom.xml 中添加：
com.tyson
spring-boot-starter-hello
1.0-SNAPSHOT
运行类如下：
import com.tyson.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@SpringBootApplication
public class SpringbootDemoApplication {
@Autowired
public HelloService helloService;
@RequestMapping("/")
public String index() {
return helloService.getMsg();
}
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
}
在项目中没有配置 HelloService bean，但是我们可以注入这个bean，这是通过自动配置实现的。
在 application.properties 中添加 debug 属性，运行配置类，在控制台可以看到：
HelloServiceAutoConfiguration matched:
- @ConditionalOnClass found required class 'com.tyson.service.HelloService' (OnClassCondition)
- @ConditionalOnProperty (hello.enabled) matched (OnPropertyCondition)
HelloServiceAutoConfiguration#helloService matched:
- @ConditionalOnMissingBean (types: com.tyson.service.HelloService; SearchStrategy: all) did not find any beans (OnBeanCondition)
可以在 application.properties 中配置 msg 的内容：
hello.msg=Seven
它们两者的区别就在于书写格式，对配置而言效果是一样的，就是个人偏好问题。
循环依赖大家都知道，也被折磨过，在 SpringBoot2.6.0的版本默认禁止了循环依赖，如果程序中出现循环依赖就会报错。
当然并没有一锤子打死，也提供了开启允许循环依赖的配置，只需要在配置文件中开启即可：
spring:
main:
allow-circular-references: true
那SpringBoot为什么要要禁止呢？我们都知道Spring解决循环依赖的方式是通过三级缓存，光学这个三级缓存我们就煞费苦心，其实说白了他是一种给程序员擦屁股的行为.
其实对象之间的关系如果是互相依赖是一种不合理的设计，避免你做出这种不合理的依赖，SpringBoot进而禁止循环依赖。
详情请看Tomcat线程池详解
SpringBoot默认的内嵌容器是Tomcat，也就是我们的程序实际上是运行在Tomcat里的。所以与其说SpringBoot可以处理多少请求，到不如说Tomcat可以处理多少请求。
在SpringBoot中处理请求数量相关的参数有四个：
Spring Boot 支持 Java Util Logging, Log4j2, Lockback 作为日志框架，如果你使用 Starters 启动器，Spring Boot 将使用 Logback 作为默认日志框架，但是不管是那种日志框架他都支持将配置文件输出到控制台或者文件中。
SpringBoot的事物很简单，首先使用注解EnableTransactionManagement开启事物之后，然后在Service方法上添加注解Transactional便可。
在SpringBoot中使用异步调用是很简单的，只需要在方法上使用@Async注解即可实现方法的异步调用。 注意：需要在启动类加入@EnableAsync使异步调用@Async注解生效。
那应该如何解决？
setter方法进行属性复制。这种方式虽然代码量较大，但能提供最好的性能和灵活性@Builder注解提供的Builder模式来简化对象创建和属性赋值。类似的问题：希望将数据库中已有的固定内容，打入到 Redis 缓存中，请问如何处理?
简单来看可以有三种：
@Value("${my.custom.property}")
private String myProperty;
@Component
@ConfigurationProperties(prefix = "my.custom")
public class MyCustomProperties {
private String property;
}
@Autowired
private Environment env;
public void someMethod() {
String value = env.getProperty("my.custom.property");
}
YAML 配置和传统的 properties 配置相比之下，有这些优势：
缺点就是不支持 @PropertySource 注解导入自定义的 YAML 配置。
Spring Boot 推荐使用 Java 配置而非 XML 配置，但是 Spring Boot 中也可以使用 XML 配置，通过 @ImportResource 注解可以引入一个 XML 配置。
单纯做 Spring Boot 开发，可能不太容易遇到 bootstrap.properties 配置文件，但是在结合Spring Cloud 时，这个配置就会经常遇到了，特别是在需要加载一些远程配置文件的时侯。
spring boot 核心的两个配置文件：
简单优先级：命令行参数 > JAR包外的 application-{profile}.properties > JAR包外的 aplitcation.properties > JAR包内的 aplication-{profile}.properties > JAR包内的aplication.properties
注意：当 application.properties和 application.yml 同时存在，同样的参数，最终生效的是 application.properties 中的配置
Spring Boot 在启动时加载配置属性的完整优先级顺序可参考如下的官方文档：从上到下，优先级逐渐降低，即下面的配置，同样的参数会被上面的配置所覆盖
在项目的开发中，有些配置文件在开发、测试或者生产等不同环境中可能是不同的，例如数据库连接、redis的配置等等。那我们如何在不同环境中自动实现配置的切换呢？Spring给我们提供了profiles机制给我们提供的就是来回切换配置文件的功能
Spring Profiles 允许用户根据配置文件（dev，test，prod 等）来注册 bean。因此，当应用程序在开发中运行时，只有某些 bean 可以加载，而在 PRODUCTION中，某些其他 bean 可以加载。假设我们的要求是 Swagger 文档仅适用于 QA 环境，并且禁用所有其他文档。这可以使用配置文件来完成。Spring Boot 使得使用配置文件非常简单。
先在properties配置文件中配置两个数据源，创建分包mapper，使用@ConfigurationProperties读取properties中的配置，使用@MapperScan注册到对应的mapper包中 。
第一种方式是在service层的@TransactionManager中使用transactionManager指定DataSourceConfig中配置的事务。
第二种是使用jta-atomikos实现分布式事务管理。
新创建一个 Spring Boot 项目，默认都是有 parent 的，这个 parent 就是 spring-boot-starter-parent ，spring-boot-starter-parent 主要有如下作用：
总结就是打包用的
跨域可以在前端通过 JSONP 来解决，但是 JSONP 只可以发送 GET 请求，无法发送其他类型的请求，在 RESTful 风格的应用中，就显得非常鸡肋，因此我们推荐在后端通过 （CORS，Crossorigin resource sharing） 来解决跨域问题。这种解决方案并非 Spring Boot 特有的，在传统的SSM 框架中，就可以通过 CORS 来解决跨域问题
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
.maxAge(3600);
}
}
Spring boot actuator 是 spring 启动框架中的重要功能之一。Spring boot 监视器可帮助您访问生产环境中正在运行的应用程序的当前状态。有几个指标必须在生产环境中进行检查和监控。即使一些外部应用程序可能正在使用这些服务来向相关人员触发警报消息。监视器模块公开了一组可直接作为 HTTP URL 访问的REST 端点来检查状态。
在项目中我通常是使用拦截器来进行权限校验、日志记录、处理异常等问题。
具体实现如下：
Spring 提供了一种使用 ControllerAdvice 处理异常的非常有用的方法。 我们通过实现一个ControlerAdvice 类，来处理控制器类抛出的所有异常。
在 Spring Boot 中使用定时任务主要有两种不同的方式，一个就是使用 Spring 中的 @Scheduled注解，另一个则是使用第三方框架 Quartz。使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。
Spring Boot 的事件机制，实际上是基于 Spring 的事件机制实现的，通过发布-订阅模式，主要用于应用程序中各个组件之间进行消息传递和解耦，通过事件发布和监听机制，实现了不同组件之间的松耦合，简化模块化开发和维护，例如我们可以通过监听 Spring 应用上下文的启动和关闭事件，进行相应的初始化和清理操作，而不需要修改 sping 源码
作用总结：
本文来自在线网站：seven的菜鸟成长之路，作者：seven，转载请注明原文链接：www.seven97.top
登录查看全部
参与评论
手机查看
返回顶部