从零开始的知识巩固（【2021】4.spring）

最新推荐文章于 2022-05-19 00:35:00 发布

、wook

最新推荐文章于 2022-05-19 00:35:00 发布

阅读量259

点赞数 1

分类专栏：从零开始的知识巩固文章标签： spring java 面试

本文链接：https://blog.youkuaiyun.com/evelynnJava/article/details/116948975

版权

从零开始的知识巩固专栏收录该内容

10 篇文章

订阅专栏

文章目录

1.spring是什么？
2.谈谈对IOC的理解
3.谈谈对AOP的理解
4.BeanFactory和ApplicationContext有什么区别？
5.描述一下Spring Bean的生命周期？
6.解释下Spring支持的几种bean的作用域
7.Spring框架中的单例Bean是线程安全的么？
8.Spring 框架中都用到了哪些设计模式？
9.Spring事务的实现方式和原理以及隔离级别？
10.spring事务什么时候会失效?

前言

本专栏系列文章仅用于个人学习总结,从零开始逐步到常见服务框架。觉得基础的大佬可以提前离开。欢迎各位大佬评论指教，如有不当之处请及时联系调整 ~

本专栏工作之余抽空更新…

上一篇文章地址：3.线程、并发相关
下一篇文章地址：5.springmvc、springBoot、mybatis

Spring

1.spring是什么？

Spring是一个轻量级的控制反转（IoC)和面向切面（AOP）的容器框架。（装javaBean）

2.谈谈对IOC的理解

需知： ioc容器实际上就是个map（key，value），里面存的是各种对象（在xml里配置的bean节点、@repository、@service、@controller、@component），在项目启动的时候会读取配置文件里面的bean节点，根据全限定类名使用反射创建对象放到map里、扫描到标记上述注解的类、通过反射创建对象放到map里。

这个时候map里就有各种对象了，接下来我们在代码里需要用到里面的对象时，再通过 DI 依赖注入（autowired、resource等注解）。

控制反转：
没有引入IOC容器之前： 对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。
引入IOC容器之后： 对象A与对象B之间失去了直接联系，当对象A运行到需要对象B的时候，IOC容器会主动获取/创建一个对象B注入到对象A需要的地方。

通过前后的对比，不难看出来：对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，全部对象的控制权全部上缴给“第三方”IOC容器。

依赖注入：
“获得依赖对象的过程被反转了”。控制被反转之后，获得依赖对象的过程由自身管理变为了由IOC容器主动注入。依赖注入是实现IOC的方法，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

扩展： DI注入方式要知道的点（了解即可）

① 默认根据类型（实现类）找Bean注入,如果有多个实现类时根据对象名（默认为类名，首字母小写）注入;
② 多个实现类时，若因为开发者将对象名更改，导致无法匹配会直接报错。伪代码如下：

@Service("wook测试1")
public class UserInfoImpl implements UserInfoService {
}
@Service("wook测试2")
public class UserInfoImpl implements UserInfoService {
}

说明：原本UserInfoImpl默认对象名为 userInfoImpl,但开发将实现类标记为@Service(“wook测试1”）会将UserInfoImpl的对象名修改为 wook测试1，此时匹配不到也就报错了，解决方式为同时使用@Autowired及@Qualifier 注解

 @Autowired
 @Qualifier("wooprk测试1") //指定注入伪代码中第一个实现类
 UserInfoService userInfoService;

3.谈谈对AOP的理解

AOP能将程序中的交叉业务逻辑（比如安全，日志，事务等大多模块都具备的操作），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去。AOP可以对某个对象或某些对象的功能进行增强，比如对方法进行增强，可以在执行某个方法之前额外的做一些事情，在某个方法执行之后额外的做一些事情。

如果使用寻常做法，直接在业务中写日志操作，耦合较高；重复代码多；不利于复用。

4.BeanFactory和ApplicationContext有什么区别？

前言：：ApplicationContext是BeanFactory的子接口，功能肯定更丰富。

BeanFactory是没有能力去扫描配置类,xml,注解等,他主要的作用就是根据 BeanDefinition去getBean()

BeanFactory：

BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。

小缺点：不容易发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。

BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

ApplicationContext：
① 继承MessageSource，因此支持国际化。
② 统一的资源文件访问方式。（Resource接口）
③ 提供在监听器中注册bean的事件。
④ 同时加载多个配置文件。
⑤ 载入多个（有继承关系）上下文，使得每一个上下文都专注于一个特定的层次，比如应用的web层。

ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。（ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean，确保当你需要的时候，你就不用等待，因为它们已经创建好了。）

相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

BeanFactory 和 ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

Application重要的2个扩展点:

BeanFactoryPostProcessor: getBean之前，工厂的后置处理器, 修改 Bean定义(修改BeanDefinition , 即 XXApplicationContext中的已经添加的定义)
BeanPostProcessor: 在getBean中,即Bean生命周期的处理器

5.描述一下Spring Bean的生命周期？

实例化Bean对象，这个时候Bean的对象是非常低级的，基本不能够被我们使用，因为连最基本的属性都没有设置，可以理解为连Autowired注解都是没有解析的；
填充属性，当做完这一步，Bean对象基本是完整的了，可以理解为Autowired注解已经解析完毕，依赖注入完成了；
如果Bean实现了BeanNameAware接口，则调用setBeanName方法；
如果Bean实现了BeanClassLoaderAware接口，则调用setBeanClassLoader方法；
如果Bean实现了BeanFactoryAware接口，则调用setBeanFactory方法；
调用BeanPostProcessor的postProcessBeforeInitialization方法；
如果Bean实现了InitializingBean接口，调用afterPropertiesSet方法；
如果Bean定义了init-method方法，则调用Bean的init-method方法；
调用BeanPostProcessor的postProcessAfterInitialization方法；当进行到这一步，Bean已经被准备就绪了，一直停留在应用的上下文中，直到被销毁；
如果应用的上下文被销毁了，如果Bean实现了DisposableBean接口，则调用destroy方法，如果Bean定义了destory-method声明了销毁方法也会被调用。

6.解释下Spring支持的几种bean的作用域

singleton： 默认，每个容器（父子容器等）中只有一个bean的实例，单例的模式由BeanFactory自身来维护。该对象的生命周期是与Spring IOC容器一致的（但BeanFactory在第一次被注入时才会创建）。
prototype： 为每一个bean请求提供一个实例。在每次注入时都会创建一个新的对象
request： bean被定义为在每个HTTP请求中创建一个单例对象，也就是说在单个请求中都会复用这一个单例对象。
session： 与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。
application： bean被定义为在ServletContext的生命周期中复用一个单例对象。
websocket： bean被定义为在websocket的生命周期中复用一个单例对象。

其实还有一个global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。（了解即可，实际上prototype作用域很少用）

7.Spring框架中的单例Bean是线程安全的么？

需知： Spring中的Bean默认是单例模式的，框架并没有对bean进行多线程的封装处理。

有线程安全问题的情况：
如果Bean是有状态的（例如Service中，定了成员变量 count 用来计数），那就需要开发人员自己来进行线程安全的保证，最简单的办法就是改变bean的作用域把 "singleton"改为’‘protopyte’ 这样每次请求Bean就相当于是 new Bean() 这样就可以保证线程的安全了。

Spring是如何保证事务获取同一个Connection的？
Dao会操作数据库Connection，Connection是带有状态的，比如说数据库事务，Spring的事务管理器使用Threadlocal为不同线程维护了一套独立的connection副本，保证线程之间不会互相影响。

结论： 不要在bean中声明任何有状态的实例变量或类变量，如果必须如此，那么就使用ThreadLocal把变量变为线程私有的，如果bean的实例变量或类变量或static修饰的需要在多个线程之间共享，那么就只能使用synchronized、lock、CAS等这些实现线程同步的方法了。

8.Spring 框架中都用到了哪些设计模式？

简单工厂： 由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

工厂方法： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。

实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是，spring会在使用getBean()调用获得该bean时，会自动调用该bean的getObject()方法，所以返回的不是factory这个bean，而是这个bean.getOjbect()方法的返回值。

单例模式： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

spring对单例的实现： spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是任意的java对象。

适配器模式：

Spring定义了一个适配接口，使得每一种Controller有一种对应的适配器实现类，让适配器代替controller执行相应的方法。这样在扩展Controller时，只需要增加一个适配器类就完成了SpringMVC的扩展了。

装饰器模式： 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。

动态代理：

切面在应用运行的时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象创建动态的创建一个代理对象。SpringAOP就是以这种方式织入切面的。

织入：把切面应用到目标对象并创建新的代理对象的过程。

观察者模式：

spring的事件驱动模型使用的是观察者模式，Spring中Observer模式常用的地方是listener的实现

策略模式： 与工厂模式有点像，但工厂解决的是创建的过程策略解决的是动作。

Spring框架的资源访问Resource接口。该接口提供了更强的资源访问能力，Spring 框架本身大量使用了Resource 接口来访问底层资源。

模板方法： 父类定义了骨架（调用哪些方法及顺序），某些特定方法由子类实现。

最大的好处：代码复用，减少重复代码。除了子类要实现的特定方法，其他方法及方法调用顺序都在父类中预先写好了。

9.Spring事务的实现方式和原理以及隔离级别？

需知： 在使用Spring框架时，可以有两种使用事务的方式，一种是编程式的，一种是申明式的，@Transactional注解就是申明式的。

在一个方法上加了@Transactional注解后，Spring会基于这个类生成一个代理对象（@Autowired 注入处打断点，可发现变为了代理对象），会将这个代理对象作为bean，当在使用这个代理对象的方法时，如果这个方法上存在@Transactional注解，那么代理逻辑会先把事务的自动提交设置为false，然后再去执行原本的业务逻辑方法，如果执行业务逻辑方法没有出现异常，那么代理逻辑中就会将事务进行提交，如果执行业务逻辑方法出现了异常，那么则会将事务进行回滚。

针对哪些异常回滚事务是可以配置的，可以利用@Transactional注解中的rollbackFor属性进行配置，默认情况下会对RuntimeException和Error进行回滚。

spring事务隔离级别就是数据库的隔离级别： 外加一个默认级别

read uncommitted（未提交读）
read committed（提交读、不可重复读）
repeatable read（可重复读）
serializable（可串行化）

如果spring配置的隔离级别与数据库不同，以spring为准。（除非数据库不支持spring配置的该级别）

spring的事务传播行为：

事务传播行为类型	外部不存在事务	外部存在事务	使用方式
REQUIRED（默认）	开启新的事务	融合到外部事务中	@Transactional(propagation = Propagation.REQUIRED)适用增删改查
SUPPORTS	不开启新的事务	融合到外部事务中	@Transactional(propagation = Propagation.SUPPORTS)适用查询
REQUIRES_NEW	开启新的事务	挂起外部事务，创建新的事务	@Transactional(propagation = Propagation.REQUIRES_NEW)适用内部事务和外部事务不存在业务关联情况，如日志
NOT_SUPPORTED	不开启新的事务	挂起外部事务	@Transactional(propagation = Propagation.NOT_SUPPORTED)不常用
NEVER	不开启新的事务	抛出异常	@Transactional(propagation = Propagation.NEVER )不常用
MANDATORY	抛出异常	融合到外部事务中	@Transactional(propagation = Propagation.MANDATORY)不常用
NESTED	开启新的事务	融合到外部事务中,SavePoint机制，外层影响内层，内层不会影响外层	@Transactional(propagation = Propagation.NESTED)不常用

挂起说明： 假设B方法设置了 NOT_SUPPORTED，当A方法（有事务）调用B方法时，A方法的事务将被挂起（方法B中的任何操作，都不归A事务管），B方法执行完后，A事务恢复。

手动回滚事务：

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

10.spring事务什么时候会失效?

需知： spring原理是基于AOP，所以分析AOP失效的情况即可。

失效的五种情况：

1.发生自调用，类里面使用this调用本类的方法（this通常省略），此时这个this对象不是代理类，而是UserService对象本身！

解决方法很简单，让那个this变成UserService的代理类即可！

2.方法不是public修饰

@Transactional 只能用于 public 的方法上，否则事务不会失效，如果要用在非 public 方法上，可以开启 AspectJ 代理模式替换原本的spring aop。

3.数据库不支持事务，例如myisam引擎。(mysql默认为Innodb）
4.没有被spring管理。
5.异常被捕获，事务不会回滚(或者抛出的异常没有被定义，默认为RuntimeException)