# 技术栈知识点巩固——Spring
技术栈知识点巩固——Spring
文章目录
- 技术栈知识点巩固——Spring
-
- Spring 依赖注入
- BeanFactory和 ApplicationContext有什么区别
- Spring IOC 的理解，其初始化过程
- Spring Bean 的生命周期
- Spring 循环注入的原理？
- @Qualifier注解
- Spring 是如何管理事务的，事务管理机制？
-
- 声明式事务
- 编程式事务
- Spring AOP（面向切面编程）
- Spring Bean的作用域
- Spring框架中的单例bean是线程安全的吗?
- 你怎样定义类的作用域？
- 什么是 Swagger？你用 Spring Boot 实现了它吗？
- Spring的Controller是单例还是多例，怎么保证并发的安全。
- 说一下Spring的核心模块
- spring 中有多少种IOC 容器？
- Spring Boot 自动配置原理是什么？
- RequestMapping 和 GetMapping
- Spring Boot异常处理？
- Spring Boot 中如何解决跨域问题
- Spring Boot打成的 jar 和普通的jar有什么区别呢?
- Springboot启动
- SpringBoot 资源初始化方法（启动后执行）
- Spring 事件机制
- SpringBoot服务监控
- SpringBoot定时任务
- 获取当前的容器上下文
- banner.txt（自定义控制台输出）
- Spring 开发中实用的技巧
Spring 依赖注入
- 基于构造函数的依赖注入
/**
* 构造方法注入 Bean
*/
private final UserService userService;
public BeanInjectionServiceImpl(UserService userService) {
logger.info("=====> 构造方法注入 Bean!");
this.userService = userService;
}
- 基于
Set函数的依赖注入
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.li.entity.Student">
<property name="name" value="张三"/>
<property name="id" value="20"/>
bean>
beans>
@Test
public void test1() {
ClassPathResource resource = new ClassPathResource("StudentBean.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(resource);
Student student = factory.getBean(Student.class);
logger.info("当前 Stundet :{}", student);
}
- 注入集合
<bean id="student" class="com.li.entity.Student">
<property name="name" value="张三"/>
<property name="id" value="20"/>
<property name="list">
<list>
<value>数学value>
<value>英语value>
list>
property>
bean>
@Test
public void test2() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("StundetBeanOne.xml");
Student bean = applicationContext.getBean(Student.class);
logger.info("当前 Student :{}", bean);
}
BeanFactory和 ApplicationContext有什么区别
-
在
Spring中，BeanFactory是IoC容器的核心接口。 -
ApplicationContext是BeanFactory的子接口，也被称为Spring上下文。Application Context是spring中较高级的容器。 -
两者详细比较见：https://blog.csdn.net/qq_37248504/article/details/113704298
Spring IOC 的理解，其初始化过程
SpringIOC：控制反转，将对象的创建，装配，管理等一系列操作交给Spring容器（BeanFactory、ApplicationContext）进行处理。开发者只需要从容器中拿到对象使用。- 读取相关
Bean的配置、定义文件配置BeanFactory。 - 通过
refresh()方法完成。
容器初始化
-
prepareRefresh()：容器刷新前的准备、设置上下文状态、获取属性等。 -
prepareBeanFactory(beanFactory)：配置标准的beanFactory，设置ClassLoader，设置SpEL表达式解析器，添加忽略注入的接口，添加bean，添加bean后置处理器等。 -
postProcessBeanFactory(beanFactory)：所有的beanDefinition已经加载，但是还没有实例化。允许在子类中对beanFactory进行扩展处理。比如添加ware相关接口自动装配设置，添加后置处理器等，是子类扩展prepareBeanFactory(beanFactory)的方法。在应用上下文的内部bean factory初始化之后修改bean factory。 -
registerBeanPostProcessors(beanFactory)：实例化和注册beanFactory中扩展了BeanPostProcessor的bean。将BeanPostProcessor注册到BeanFactory中，并没有执行 -
initMessageSource()：初始化国际化工具类MessageSource -
initApplicationEventMulticaster()：初始化事件广播器 -
onRefresh()：模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。 -
registerListeners()：注册监听器 -
finishBeanFactoryInitialization(beanFactory)：实例化所有剩余的（非懒加载）单例
比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化。实例化的过程各种BeanPostProcessor开始起作用。 -
finishRefresh()：refresh做完之后需要做的其他事情。清除上下文资源缓存（如扫描中的ASM元数据） 初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）。发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作。 -
容器初始化详见：https://blog.csdn.net/qq_37248504/article/details/113704298
Spring Bean 的生命周期
- 实例化
Bean：对于BeanFactory容器，请求的Bean没有初始化的时候，容器会调用createBean()进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。 - 属性赋值：为
bean设置相关属性和依赖。 - 初始化
Bean：在返回Bean之前做一些处理 - 调用
BeanNameAware的setBeanName() - 调用
BeanFactoryAware的setBeanFactory() - 调用
ApplicationContextAware的setAllicationContext() - 调用
BeanPostProcessor的前置处理方法 - 调用
InitializingBean的afterPropertiesSet() - 调用自定义的
init-method方法 - 调用
BeanPostProcessor的后置处理方法 - 销毁：先注册销毁的相关调用接口，使用，执行自定义的销毁方法
Spring 循环注入的原理？
- 实例化，填充属性（注入依赖），初始化完成。
spring在创建BeanA的时候会先去一级缓存获取，如果一级缓存没有则再从二级缓存中获取，如果二级缓存也没有，则再从三级缓存中获取，如果还获取不到，则实例化一个A，然后放入三级缓存，然后填充属性，此刻发现依赖B，于是创建B，同样的经过上述步骤，由于每级缓存都获取不到，于是实例化B，然后填充属性，发现依赖A，然后依次去每级缓存中获取，由于三级缓存中已经有一个A，于是B可以顺利注入依赖，并被正确的初始化，然后递归返回，于是A也可以被正确的初始化了。
@Qualifier注解
@Autowired通过Bean的类型注入Bean，当容器中含有多个相同类型的Bean时候，可以使用@Qualifier指定Bean的名称@Resource通过Bean的Name进行注入，是Java中的注解。- 常用注解的使用详见：https://blog.csdn.net/qq_37248504/article/details/108859121
Spring 是如何管理事务的，事务管理机制？
事务管理器
PlatformTransactionmanger：commit()提交事务、rollback()回滚事务、getTransaction()获取事务的状态。
事务定义信息
TransactionDefinition：用来定义事务相关的属性（事务隔离级别、事务传播方式、超时时间、是否只读）。
事务具体运行状态
TransactionStatus：判断事务是否完成、当前事务是否是一个新事务等。
声明式事务
- 不需要在业务逻辑代码中编写事务相关代码，只需要在配置文件配置或使用注解
@Transaction，这种方式对代码没有侵入性。
编程式事务
-
需要手动写事务提交等相关的代码
-
事务传播机制等内容见博客：https://blog.csdn.net/qq_37248504/article/details/107008217
Spring AOP（面向切面编程）
- 通过
Aop可以将一些非业务代码、公共的代码和业务代码进行解耦操作，定义切点、定义切面，在切面中进行公共方法的处理。使用切面操作，可以减少系统的重复代码，降低模块之间的耦合度，有利于后期的维护开发。
Aop元素
-
切点（
PoinCut）：从哪些类哪个方法切入，可以配合注解使用。 -
通知（
Advice）：在方法执行前、或者执行后进行需要的操作。 -
切面（
Aspect）：整个切面中进行切点和通知的操作，编写代码。 -
织入（
Weaving）：由Spring完成，创建代理对象。 -
Aop注解方式记录接口日志见例子见博客：https://blog.csdn.net/qq_37248504/article/details/102926592
Spring Bean的作用域
singleton:单例，默认作用域。prototype:原型，每次创建一个新对象。request:请求，每次Http请求创建一个新对象，适用于WebApplicationContext环境下。session:会话，同一个会话共享一个实例，不同会话使用不用的实例。global-session:全局会话，所有会话共享一个实例。
Spring框架中的单例bean是线程安全的吗?
- 对于单例的
Bean，所有的线程共享一个单例实例Bean。大多数时候Bean都是无状态的Bean，所以是安全的。 - 对于原型（
Prototype）类型的Bean，每次请求都会创建一个新的Bean，这样就可以保证线程安全了。 Scope范围测试：当使用原型模式的时候，普通变量可以做到线程安全，但是静态变量是有问题的。所以使用还是得要按照实际开发结合。
@RestController
@RequestMapping("/spring/testone")
@Scope(value = "prototype")
public class SpringTestTwoController {
private static final Logger logger = LoggerFactory.getLogger(BeanTestController.class);
private int a = 0;
private static int b = 0;
@RequestMapping("/test1")
public void test1() {
logger.info("普通变量 a:{} 静态变量 b:{}", ++a, ++b);
}
@RequestMapping("/test2")
public void test2() {
logger.info("普通变量 a:{} 静态变量 b:{}", ++a, ++b);
}
}
你怎样定义类的作用域？
- 当
Spring要在需要的时候每次生产一个，新的bean实例，bean的scope属性被指定为prototype。另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope属性 必须设为singleton。 bean的作用域的种类可见上面的知识点。
什么是 Swagger？你用 Spring Boot 实现了它吗？
Swagger是接口API文档，可以更加清晰的看到接口的参数、类型等。Swagger的使用请见：https://blog.csdn.net/qq_37248504/article/details/106773321Swagger常用注解请见博客：https://blog.csdn.net/qq_37248504/article/details/106797105
Spring的Controller是单例还是多例，怎么保证并发的安全。
Controller默认是单例的，正因为单例所以不是线程安全的。- 可以使用原型模式，通过注解
@Scope(“prototype”)定义变量等。 - 可以使用
ThreadLocal。
说一下Spring的核心模块
-
spring-core:基础API模块，如资源管理，泛型处理。 -
spring-beans:Spring Bean相关，依赖查找，依赖注入。 -
spring-aop:动态代理，aop字节码提升。 -
spring-context:事件驱动，注解驱动，模块驱动。 -
spring-expression:spring表达式语音模块。
spring 中有多少种IOC 容器？
BeanFactory：Spring底层的基础容器。常用的BeanFactory是XmlBeanFactory,根据xml定义的内容创建bean。Application：ApplicationContext在BeanFactory的基础上构建，是相对比较高 级的容器实现，除了拥有BeanFactory的所有支持，ApplicationContext还提供了其他高级，比如事件发布、国际化信息支持等。- 两种容器的差别详细请见博客：https://blog.csdn.net/qq_37248504/article/details/113704298
Spring Boot 自动配置原理是什么？
- 加载
@SpringBootApplication
@SpringBootApplication
@EnableCaching
@EnableScheduling
@MapperScan("com.li.springbootproject.mapper")
public class TestProjectApplication {
public static void main(String[] args) {
SpringApplication.run(TestProjectApplication.class);
}
}
@SpringBootApplication注解：开启自动配置功能
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}
AutoConfigurationImportSelector选择器给Spring容器中导入一下组件。
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}
- 扫描
java jar包类路径下的META-INF/spring.factories文件 - 将类路径下
META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到Spring容器中。
RequestMapping 和 GetMapping
-
RequestMapping不仅能相应Post请求，还能相应Get请求。GetMapping只能相应get请求。 -
其它常用注解，详细见博客：https://blog.csdn.net/qq_37248504/article/details/108859121
Spring Boot异常处理？
- 详细见博客：https://blog.csdn.net/qq_37248504/article/details/107009798
Spring Boot 中如何解决跨域问题
-
跨域：浏览器不能执行其他网站的脚本。
-
解决办法：使用
nginx做代理，代理到同一个域下；再后端配置拦截器做请求拦截校验处理。 -
详细见博客：https://blog.csdn.net/qq_37248504/article/details/107347488
Spring Boot打成的 jar 和普通的jar有什么区别呢?
SpringBoot打的jar包不能被其他类引用，不能被其他项目所依赖。SpringBoot打包成的可执行jar解压后，在\BOOT-INF\classes目录下才是我们的代码。
Springboot启动
SpringBoot主要通过实例化SpringApplication来启动，启动的过程中主要进行：配置属性、获取监听器、发布应用开始启动事件、初始化输入参数、配置环境、输出banner、创建上下文、预处理上下文、刷新容器、发布应用已启动事件。
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
this.configureHeadlessProperty();
// 启动监听器
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();
Collection exceptionReporters;
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
//第二步，根据SpringApplicationRunListeners以及参数来准备环境
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
this.configureIgnoreBeanInfo(environment);
// 在控制台打印 banner
Banner printedBanner = this.printBanner(environment);
// 创建 Spring 容器
context = this.createApplicationContext();
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
// Spring 容器 前置处理
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 刷新容器
this.refreshContext(context);
// Spring 容器后置处理
this.afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
}
// 发出结束执行的事件
listeners.started(context);
// 执行 Runners
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
this.handleRunFailure(context, var10, exceptionReporters, listeners);
throw new IllegalStateException(var10);
}
try {
listeners.running(context);
// 返回容器
return context;
} catch (Throwable var9) {
this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
SpringBoot 资源初始化方法（启动后执行）
-
@Order标识类的顺序，数字越小越靠前。 -
实现
ApplicationRunner接口
@Component
@Order(1)
public class TestProjectApplicationRunner implements ApplicationRunner {
private static final Logger logger = LoggerFactory.getLogger(TestProjectApplicationRunner.class);
@Autowired
private Environment environment;
@Override
public void run(ApplicationArguments args) throws Exception {
logger.info("----------> TestProjectApplicationRunner 初始化！");
logger.info("----------> 当前服务端口为：{}",environment.getProperty("server.port"));
}
}
- 实现
CommandLineRunner接口
@Component
@Order(2)
public class TestProjectCommandLineRunner implements CommandLineRunner {
private static final Logger logger = LoggerFactory.getLogger(TestProjectCommandLineRunner.class);
private Environment environment;
public TestProjectCommandLineRunner(Environment environment) {
this.environment = environment;
}
@Override
public void run(String... args) throws Exception {
logger.info("----------> TestProjectCommandLineRunner 初始化！");
logger.info("----------> 当前服务端口为：{}",environment.getProperty("server.port"));
}
}
Spring 事件机制
- 事件：自定义事件需要继承
ApplicationEvent,可以用来传递需要处理的数据。 - 事件监听者：事件监听器接口,事件的业务逻辑封装在监听器里面。
- 事件发布：
ApplicationEventPublisherAware通过实现这个接口,来触发事件。 SpringBoot事件同步异步处理详见博客：https://blog.csdn.net/qq_37248504/article/details/115269995
SpringBoot服务监控
Spring Boot Admin用来管理和监控Spring Boot应用程序。应用程序向我们的Spring Boot Admin Client注册（通过HTTP）或使用SpringCloud（例如Eureka，Consul）发现UI是Spring Boot Actuator端点上的Vue.js应用程序 。- 详细配置请移步：https://blog.csdn.net/qq_37248504/article/details/109346898
SpringBoot定时任务
Quartz定时任务框架：https://blog.csdn.net/qq_37248504/article/details/106874496Scheduled定时任务器：https://blog.csdn.net/qq_37248504/article/details/106874449
获取当前的容器上下文
- 实现
ApplicationContextAware接口，重写setApplicationContext()在这个方法中可以拿到上下文ApplicationContext。
@Component
public class SpringContextUtils implements ApplicationContextAware {
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
// 在这里可以拿到当前容器的上下文
}
}
- 直接注入
@Autowired
private ApplicationContext applicationContext;
banner.txt（自定义控制台输出）
- 只需要在
classpath路径下创建一个banner.txt即可。 - 在线生成网站：https://www.bootschool.net/ascii
Spring 开发中实用的技巧
- 详细请看：https://blog.csdn.net/qq_37248504/article/details/113896952