2021年12月27日

1、说说你对Spring 的理解？

Spring 使创建 Java 企业应用程序变得更加容易。它提供了在企业环境中接受 Java 语言所需的一切,，并支持 Groovy 和 Kotlin 作为 JVM 上的替代语言，并可根据应用程序的需要灵活地创建多种体系结构。 从 Spring Framework 5.0 开始，Spring 需要 JDK 8(Java SE 8+)，并且已经为 JDK 9 提供了现成的支持。

Spring支持各种应用场景， 在大型企业中, 应用程序通常需要运行很长时间，而且必须运行在 jdk 和应用服务器上，这种场景开发人员无法控制其升级周期。 其他可能作为一个单独的jar嵌入到服务器去运行，也有可能在云环境中。还有一些可能是不需要服务器的独立应用程序(如批处理或集成的工作任务)。

Spring 是开源的。它拥有一个庞大而且活跃的社区，提供不同范围的，真实用户的持续反馈。这也帮助Spring不断地改进,不断发展。

Spring不仅是一个框架，还是一个容器，还是一个生态。

2.谈谈SpringIOC的理解，原理与实现

总：
控制反转：理论思想，原来的对象是有使用者来进行控制的，有了spring之后，可以把整个对象交给spring来帮我们进行管理
     DI：依赖注入,把对应的属性的值注入到具体的对象中, @Autowired, populateBean完成属性值的注入容器:存储对象,使用map结构来存储,在spring中一般存在三级缓存, singletonObjects存放完整的bean对象,
     整个bean的生命周期,从创建到使用到销毁的过程全部都是由容器来管理(bean的生命周期).
分：
1、一般聊ioc容器的时候要涉及到容器的创建过程(beanFactory,DefaultListableBeanFactory) ,向bean工厂中设置一些参(BeanPostProcessor,Aware接口的子类)等等属性
2、加载解析bean对象,准备要创建的bean对象的定义对象beanDefinition,(xml或者注解的解析过程)
3, beanFactoryPostProcessor的处理,此处是扩展点, PlaceHolderConfigurSupport,ConfigurationClassPostProcessor
4, BeanPostProcessor的注册功能,方便后续对bean对象完成具体的扩展功能转。
5、通过反射的方式讲BeanDefinition对象实例化成具体的bean对象,
6, bean对象的初始化过程(填充属性,调用aware子类的方法,调用BeanPostProcessor前置处理方法,调用init-mehtod方法,调用BeanPostProcessor的后置处理方法)
7、生成完整的bean对象,通过getBean方法可以直接获取,
8、销毁过程
面试官,这是我对ioc的整体理解,包含了一些详细的处理过程,您看一下有什么问题,可以指点我一下(允许你把整个流程说完)

  老师,我没看过源码怎么办?
  具体的细节我记不太清了,但是spring中的bean都是通过反射的方式生成的,同时其中包含了很多的扩展点,比如最常用的对BeanFactory的扩展,对bean的扩展(对占位符的处理) ,我们在公司对这方面的使用是比较多的,除此之外, ioc中最核心的也就是填充具体bean的属性,和生命周期(背一下)。

3.谈一下SpringIOC的底层实现

底层实现：工作原理,过程,数据结构,流程,设计模式,设计思想
你对他的理解和你了解过的实现过程
反射,工厂,设计模式(会的说,不会的不说) ,
关键的几个方法
createBeanFactory,
getBean,
doGetBean,
createBean,
doCreateBean,
createBeanInstance(getDeclaredConstructor,newinstance),
populateBean,
initializingBean
1、先通过createBeanFactory创建出一个Bean工厂(DefaultListableBeanFactory)
2、开始循环创建对象,因为容器中的bean默认都是单例的,所以优先通过getBean,doGetBean从容器中查找,找不到的话,
3、通过createBean,doCreateBean方法,以反射的方式创建对象,一般情况下使用的是无参的构造方法(getDeclaredConstructor,newlnstance)
4、进行对象的属性填充populateBean5、进行其他的初始化操作(initializingBean)

4、说说你对Aop的理解？

AOP全称叫做 Aspect Oriented Programming 面向切面编程。它是为解耦而生的，解耦是程序员编码开发过程中一直追求的境界，AOP在业务类的隔离上，绝对是做到了解耦，在这里面有几个核心的概念：

• 切面（Aspect）: 指关注点模块化，这个关注点可能会横切多个对象。事务管理是企业级Java应用中有关横切关注点的例子。 在Spring AOP中，切面可以使用通用类基于模式的方式（schema-based approach）或者在普通类中以@Aspect注解（@AspectJ 注解方式）来实现。
• 连接点（Join point）: 在程序执行过程中某个特定的点，例如某个方法调用的时间点或者处理异常的时间点。在Spring AOP中，一个连接点总是代表一个方法的执行。
• 通知（Advice）: 在切面的某个特定的连接点上执行的动作。通知有多种类型，包括“around”, “before” and “after”等等。通知的类型将在后面的章节进行讨论。 许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链。
• 切点（Pointcut）: 匹配连接点的断言。通知和切点表达式相关联，并在满足这个切点的连接点上运行（例如，当执行某个特定名称的方法时）。切点表达式如何和连接点匹配是AOP的核心：Spring默认使用AspectJ切点语义。
• 引入（Introduction）: 声明额外的方法或者某个类型的字段。Spring允许引入新的接口（以及一个对应的实现）到任何被通知的对象上。例如，可以使用引入来使bean实现 IsModified接口， 以便简化缓存机制（在AspectJ社区，引入也被称为内部类型声明（inter））。
• 目标对象（Target object）: 被一个或者多个切面所通知的对象。也被称作被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，那么这个对象永远是一个被代理（proxied）的对象。
• AOP代理（AOP proxy）:AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。
• 织入（Weaving）: 把切面连接到其它的应用程序类型或者对象上，并创建一个被被通知的对象的过程。这个过程可以在编译时（例如使用AspectJ编译器）、类加载时或运行时中完成。 Spring和其他纯Java AOP框架一样，是在运行时完成织入的。

这些概念都太学术了，如果更简单的解释呢，其实非常简单：

任何一个系统都是由不同的组件组成的，每个组件负责一块特定的功能，当然会存在很多组件是跟业务无关的，例如日志、事务、权限等核心服务组件，这些核心服务组件经常融入到具体的业务逻辑中，如果我们为每一个具体业务逻辑操作都添加这样的代码，很明显代码冗余太多，因此我们需要将这些公共的代码逻辑抽象出来变成一个切面，然后注入到目标对象（具体业务）中去，AOP正是基于这样的一个思路实现的，通过动态代理的方式，将需要注入切面的对象进行代理，在进行调用的时候，将公共的逻辑直接添加进去，而不需要修改原有业务的逻辑代码，只需要在原来的业务逻辑基础之上做一些增强功能即可。

5.Spring的AOP的底层实现原理？

动态代理
aop是ioc的一个扩展功能,先有的ioc,再有的aop,只是在ioc的整个流程中新增的一个扩展点而已: BeanPostProcessor
总： aop概念,应用场景,动态代理
分：bean的创建过程中有一个步骤可以对bean进行扩展实现, aop本身就是一个扩展功能,所以在BeanPostProcessor的后置处理方法中来进行实现
1、代理对象的创建过程(advice,切面,切点)
2、通过jdk或者cglib的方式来生成代理对象
3、在执行方法调用的时候,会调用到生成的字节码文件中,直接回找到DynamicAdvisoredinterceptor类中的intercept方法,从此方法开始执行
4、根据之前定义好的通知来生成拦截器链
5、从拦截器链中依次获取每一个通知开始进行执行,在执行过程中,为了方便找到下一个通知是哪个,会有一个CglibMethodInvocation的对象,找的时候是从-1的位置一次开始查找并且执行的。

6.描述一下bean的生命周期

1、实例化bean对象
 通过反射的方式进行对象的创建，此时的创建只是在堆空间中申请空间，属性都是默认值
2、设置对象属性
 给对象中的属性进行值的设置工作
3、检查Aware相关接口并设置相关依赖
 如果对象中需要引用容器内部的对象，那么需要调用aware接口的子类方法来进行统一的设置
4、BeanPostProcessor的前置处理
 对生成的bean对象进行前置的处理工作
5、检查是否是InitializingBean的子类来决定是否调用afterPropertiesSet方法
 判断当前bean对象是否设置了InitializingBean接口，然后进行属性的设置等基本工作
6、检查是否配置有自定义的init-method方法
 如果当前bean对象定义了初始化方法，那么在此处调用初始化方法
7、BeanPostProcessor后置处理
 对生成的bean对象进行后置的处理工作
8、注册必要的Destruction相关回调接口
 为了方便对象的销毁，在此处调用注销的回调接口，方便对象进行销毁操作
9、获取并使用bean对象
 通过容器来获取对象并进行使用
10、是否实现DisposableBean接口
 判断是否实现了DisposableBean接口，并调用具体的方法来进行对象的销毁工作
11、是否配置有自定义的destory方法
 如果当前bean对象定义了销毁方法，那么在此处调用销毁方法

7.Spring启动流程（容器和对象的创建流程）

1、创建容器
2、加载配置文件，封装成BeanDefinition
3、准备工作（prepareRefresh()）
4、创建beanFactory（obtainFreshBeanFactory()）
 1、设置一个序列化ID
 2、定制一个beanFactory，设置相关属性
 3、加载配置文件（loadBeanDefinitions）
5、beanFactory准备工作（属性值设置等）（prepareBeanFactory(beanFactory)）
6、调用执行BeanFactoryPostProcessor（invokeBeanFactoryPostProcessors(beanFactory)）实例化前的操作：
7、注册BeanFactoryPostProcessor（registerBeanPostProcessors(beanFactory)）
8、国家化操作（initMessageSource()）
9、初始化事件监听多路广播器（initApplicationEventMulticaster()）
10、注册监听器（registerListeners()）
11、实例化bean（finishBeanFactoryInitialization(beanFactory)非懒加载）
 1、实例化bean（doCreateBean（））没有设置值（） 默认单例
12、初始化bean（finishRefresh()）
 1、设置属性值（populateBean(beanName, mbd, instanceWrapper)）
 2、调用Aware接口的方法（invokeAwareMethods(beanName, bean)）设置BeanFactory属性值
 3、before（applyBeanPostProcessorsBeforeInitialization(bean, beanName)）设置ApplicationContext等其他属性值
 4、调用初始化方法init（invokeInitMethods(beanName, wrappedBean, mbd)）此方法初始化
 5、after（applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)）此方法
 6、返回完整对象

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // 准备用于刷新的上下文。
            // 刷新前的预处理;
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // 告诉子类刷新内部bean工厂。
            // 获取BeanFactory；默认实现是DefaultListableBeanFactory，在创建容器的时候创建的
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // 准备在此上下文中使用的bean工厂。
            // BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器，BeanPostProcessor和XXXAware自动装配等）
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // 允许在上下文子类中对bean工厂进行后处理。
                // BeanFactory准备工作完成后进行的后置处理工作  
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                // 调用在上下文中注册为bean的工厂处理器。
                // 执行BeanFactoryPostProcessor的方法；
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                // 注册拦截bean创建的bean处理器。
                // 注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // 为此上下文初始化消息源。
                // 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
                initMessageSource();

                // Initialize event multicaster for this context.
                // 为这个上下文初始化事件多播器。
                // 初始化事件派发器
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                // 在特定的上下文子类中初始化其他特殊bean。
                // 子类重写这个方法，在容器刷新的时候可以自定义逻辑；如创建Tomcat，Jetty等WEB服务器
                onRefresh();

                // Check for listener beans and register them.
                // 检查并注册侦听器bean。
                // 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 实例化所有剩余的(非lazy-init)单例。
                // 初始化所有剩下的非懒加载的单例bean
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                // 最后一步:发布相应的事件。
                // 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                // 销毁已经创建的单例以避免资源悬空。
                destroyBeans();

                // Reset 'active' flag.
                // 重置“活跃”的旗帜。
                cancelRefresh(ex);

                // Propagate exception to caller.
                // 将异常传播给调用者。
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // 在Spring的核心中重置公共内省缓存，因为我们
                // might not ever need metadata for singleton beans anymore...
                // 可能再也不需要单例bean的元数据了……
                resetCommonCaches();
            }
        }
    }

• prepareRefresh方法

表示在真正做refresh操作之前需要准备做的事情：

• 设置Spring容器的启动时间，
• 开启活跃状态，撤销关闭状态，。
• 初始化context environment（上下文环境）中的占位符属性来源。
• 验证环境信息里一些必须存在的属性

• ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

让这个类（AbstractApplicationContext）的子类刷新内部bean工厂。

• AbstractRefreshableApplicationContext容器：实际上就是重新创建一个bean工厂，并设置工厂的一些属性。
• GenericApplicationContext容器：获取创建容器的就创建的bean工厂，并且设置工厂的ID.

• prepareBeanFactory方法
  上一步已经把工厂建好了，但是还不能投入使用，因为工厂里什么都没有，还需要配置一些东西。看看这个方法的注释

/**
* Configure the factory's standard context characteristics,
* such as the context's ClassLoader and post-processors.
* @param beanFactory the BeanFactory to configure
*/

他说配置这个工厂的标准环境，比如context的类加载器和post-processors后处理器。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //设置BeanFactory的类加载器
        beanFactory.setBeanClassLoader(getClassLoader());
        //设置支持表达式解析器
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        //添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        //设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xx,因为ApplicationContextAwareProcessor#invokeAwareInterfaces已经把这5个接口的实现工作做了
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

        //注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
        //其他组件中可以通过 @autowired 直接注册使用
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        //添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        //给BeanFactory中注册一些能用的组件；
        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
            //环境信息ConfigurableEnvironment
            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
          //系统属性，systemProperties【Map<String, Object>】
            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
          //系统环境变量systemEnvironment【Map<String, Object>】
            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
        }
    }

• postProcessBeanFactory方法

上面对bean工厂进行了许多配置，现在需要对bean工厂进行一些处理。不同的Spring容器做不同的操作。比如GenericWebApplicationContext容器的操作会在BeanFactory中添加ServletContextAwareProcessor用于处理ServletContextAware类型的bean初始化的时候调用setServletContext或者setServletConfig方法(跟ApplicationContextAwareProcessor原理一样)。

• invokeBeanFactoryPostProcessors方法

invokeBeanFactoryPostProcessors方法总结来说就是从Spring容器中找出BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的实现类并按照一定的规则顺序进行执行。 其中ConfigurationClassPostProcessor这个BeanDefinitionRegistryPostProcessor优先级最高，它会对项目中的@Configuration注解修饰的类(@Component、@ComponentScan、@Import、@ImportResource修饰的类也会被处理)进行解析，解析完成之后把这些bean注册到BeanFactory中。需要注意的是这个时候注册进来的bean还没有实例化。

• initMessageSource方法

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）,这个接口提供了消息处理功能。主要用于国际化/i18n。

• initApplicationEventMulticaster方法

在Spring容器中初始化事件广播器，事件广播器用于事件的发布。
程序首先会检查bean工厂中是否有bean的名字和这个常量(applicationEventMulticaster)相同的，如果没有则说明没有那么就使用默认的ApplicationEventMulticaster 的实现：SimpleApplicationEventMulticaster

• onRefresh方法

一个模板方法，不同的Spring容器做不同的事情。
比如web程序的容器ServletWebServerApplicationContext中会调用createWebServer方法去创建内置的Servlet容器。
目前SpringBoot只支持3种内置的Servlet容器：

• Tomcat
• Jetty
• Undertow

• registerListeners方法

注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布给相匹配的监听器。

protected void registerListeners() {
        //1、从容器中拿到所有已经创建的ApplicationListener
        for (ApplicationListener<?> listener : getApplicationListeners()) {
            //2、将每个监听器添加到事件派发器中；
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        // 1.获取所有还没有创建的ApplicationListener
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            //2、将每个监听器添加到事件派发器中；
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        // earlyApplicationEvents 中保存之前的事件，
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (earlyEventsToProcess != null) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                //3、派发之前步骤产生的事件；
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

• finishBeanFactoryInitialization方法

实例化BeanFactory中已经被注册但是未实例化的所有实例(懒加载的不需要实例化)。
比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化。
实例化的过程各种BeanPostProcessor开始起作用。
后面在详细分析此步骤

• finishRefresh方法

refresh做完之后需要做的其他事情。

• 初始化生命周期处理器，并设置到Spring容器中(LifecycleProcessor)
• 调用生命周期处理器的onRefresh方法，这个方法会找出Spring容器中实现了SmartLifecycle接口的类并进行start方法的调用
• 发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作

如果是web容器ServletWebServerApplicationContext还会启动web服务和发布消息

protected void finishRefresh() {
        super.finishRefresh();
        WebServer webServer = startWebServer();
        if (webServer != null) {
            publishEvent(new ServletWebServerInitializedEvent(webServer, this));
        }
    }

8.Spring是如何解决循环依赖问题的

三级缓存、提前暴露对象、aop

总：什么是循环依赖问题, A依赖B,B依赖A
分：先说明bean的创建过程:实例化,初始化(填充属性)
1、先创建A对象,实例化A对象,此时A对象中的b属性为空,填充属性b
2、从容器中查找B对象,如果找到了,直接赋值不存在循环依赖问题(不通) ,找不到直接创建B对象
3、实例化B对象,此时B对象中的a属性为空,填充属性a
4、从容器中查找A对象,找不到,直接创建

形成闭环的原因

此时,如果仔细琢磨的话,会发现A对象是存在的,只不过此时的A对象不是一个完整的状态,只完成了实例化但是未完成初始化,如果在程序调用过程中,拥有了某个对象的引用,能否在后期给他完成赋值操作,可以优先把非完整状态的对象优先赋值,等待后续操作来完成赋值,相当于提前暴露了某个不完整对象的引用,所以解决问题的核心在于实例化和初始化分开操作,这也是解决循环依赖问题的关键，

当所有的对象都完成实例化和初始化操作之后,还要把完整对象放到容器中,此时在容器中存在对象的几个状态,完成实例化三但未完成初始化,完整状态,因为都在容器中,所以要使用不同的map结构来进行存储,此时就有了一级缓存和二级缓存，如果一级缓存中有了,那么二级缓存中就不会存在同名的对象,因为他们的查找顺序是1, 2, 3这样的方式来查找的。一级缓存中放的是完整对象,二级缓存中放的是非完整对象

为什么需要三级缓存?三级缓存的yglue类型是ObjectFactory,是一个函数式接口,存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个.

如果一个对象需要被代理,或者说需要生成代理对象,那么要不要优先生成一个普通对象?要

普通对象和代理对象是不能同时出现在容器中的,因此当一个对象需要被代理的时候,就要使用代理对象覆盖掉之前的普通对象,在实际的调用过程中,是没有办法确定什么时候对象被使用,所以就要求当某个对象被调用的时候,优先判断此对象是否需要被代理,类似于一种回调机制的实现,

因此传入lambda表达式的时候,可以通过lambda表达式来执行对象的覆盖过程, getEarlyBeanReference()因此,所有的bean对象在创建的时候都要优先放到三级缓存中,在后续的使用过程中,如果需要被代理则返回代理对象,如果不需要被代理,则直接返回普通对象

9.缓存的放置时间和删除时间

三级缓存：createBeanInstance之后: addSingletonFactory·
二级缓存：第一次从三级缓存确定对象是代理对象还是普通对象的时候,同时删除三级缓存getsingleton
一级缓存：生成完整对象之后放到一级缓存,删除二三级缓存:addSingletonl

10.Bean Factory与FactoryBean有什么区别

相同点：都是用来创建bean对象的
不同点：使用BeanFactory创建对象的时候,必须要遵循严格的生命周期流程,太复杂了, ,如果想要简单的自定义某个对象的创建,同时创建完成的对象想交给spring来管理,那么就需要实现FactroyBean接口了
  isSingleton:是否是单例对象
  getObjectType:获取返回对象的类型
  getObject:自定义创建对象的过程(new,反射,动态代理)

2021年2月28日

11.Spring中用到的设计模式

1.单例模式: 比如在创建bean的时候。
2.原型模式:指定作用域为prototype
3.工厂模式: 在各种BeanFactory以及ApplicationContext创建中都用到了
4.模板方法: 在各种BeanFactory以及ApplicationContext实现中也都用到了
5.策略模式: 加载资源文件的方式，使用了不同的方法，比如：ClassPathResourece，FileSystemResource，ServletContextResource，UrlResource但他们都有共同的借口Resource；在Aop的实现中，采用了两种不同的方式，JDK动态代理和CGLIB代理
6.观察者模式: spring中的ApplicationEvent，ApplicationListener,ApplicationEventPublisher
7.配器模式: MethodBeforeAdviceAdapter,ThrowsAdviceAdapter,AfterReturningAdapter
8.装饰者模式: 源码中类型带Wrapper或者Decorator的都是
9.责任链模式:使用aop的时候会先生成一个拦截器链
10.代理模式：Spring AOP 利用了 AspectJ AOP实现的! AspectJ AOP 的底层用了动态代理
11.委托者模式: delegate

12.Spring的事务是如何回滚的？

spring的事务管理是如何实现的?
总：spring的事务是由aop来实现的,首先要生成具体的代理对象,然后按照aop的整套流程来执行具体的操作逻辑,正常情况下要通过通知来完成核心功能,但是事务不是通过通知来实现的,而是通过一个TransactionInterceptor来实现的,然后调用invoke来实现具体的逻辑
分:：
1、先做准备工作,解析各个方法上事务相关的属性,根据具体的属性来判断是否开始新事务
2、当需要开启的时候,获取数据库连接,关闭自动提交功能,开起事务
3、执行具体的sq1逻辑操作
4、在操作过程中,如果执行失败了,那么会通过completeTransactionAfterThrowing看来完成事务的回滚操作,回滚的具体逻辑是通过doRollBack方法来实现的,实现的时候也是要先获取连接对象,通过连接对象来回滚
5、如果执行过程中,没有任何意外情况的发生,那么通过commitTransactionAfterReturning来完成事务的提交操作,提交的具体逻辑是通过doCommit方法来实现的,实现的时候也是要获取连接,通过连接对象来提交
6、当事务执行完毕之后需要清除相关的事务信息cleanupTransactionlnfo
如果想要聊的更加细致的话,需要知道Transactionlnfo,TransactionStatus,

13、谈一下Spring事务传播

传播特性有几种?7种(Required,Requires_new,nested,Support,Not_Support,Never,Mandatory)

REQUIRED：默认的传播特性，如果当前没有事务，则新建一个事务，如果当前存在事务，则加入这个事务
SUPPORTS：当前存在事务，则加入当前事务，如果当前没有事务，则以非事务的方式执行
MANDATORY：当前存在事务，则加入当前事务，如果当前事务不存在，则抛出异常
REQUIRED_NEW：创建一个新事务，如果存在当前事务，则挂起改事务
NOT_SUPPORTED：以非事务方式执行，如果存在当前事务，则挂起当前事务
NEVER：不使用事务，如果当前事务存在，则抛出异常
NESTED：如果当前事务存在，则在嵌套事务中执行，否则REQUIRED的操作一样

NESTED和REQUIRED_NEW的区别：

REQUIRED_NEW是新建一个事务并且新开始的这个事务与原有事务无关，而NESTED则是当前存在事务时会开启一个嵌套事务，在NESTED情况下，父事务回滚时，子事务也会回滚，而REQUIRED_NEW情况下，原有事务回滚，不会影响新开启的事务

NESTED和REQUIRED的区别：

REQUIRED情况下，调用方存在事务时，则被调用方和调用方使用同一个事务，那么被调用方出现异常时，由于共用一个事务，所以无论是否catch异常，事务都会回滚，而在NESTED情况下，被调用方发生异常时，调用方可以catch其异常，这样只有子事务回滚，父事务不会回滚。

某一个事务嵌套另一个事务的时候怎么办?

A方法调用B方法, AB方法都有事务,并且传播特性不同,那么A如果有异常, B怎么办, B如果有异常, A怎么办?

总:事务的传播特性指的是不同方法的嵌套调用过程中,事务应该如何进行处理,是用同一个事务还是不同的事务,当出现异常的时候会回滚还是提交,两个方法之间的相关影响,在日常工作中,使用比较多的是required, Requires_new,nested
分:
1、先说事务的不同分类,可以分为三类:支持当前事务,不支持当前事务,嵌套事务
2、如果外层方法是required,内层方法是, required,requires_new,nested
3、如果外层方法是require,内层方法是, required,requires_new,nested

核心处理逻辑非常简单：

1、判断内外方法是否是同一个事务：
是：异常统一在外层方法处理
不是：内层方法有可能影响到外层方法,但是外层方法是不会影响内层方法的
(大致可以这么理解,但是有个别情况不同, nested)

14、spring事务什么时候会失效？

1、bean对象没有被spring容器管理
2、方法的访问修饰符不是public
3、自身调用问题
4、数据源没有配置事务管理器
5、数据库不支持事务
6、异常被捕获
7、异常类型错误或者配置错误

15、spring事务的隔离级别有哪些？

spring中的事务隔离级别就是数据库的隔离级别，有以下几种：
read uncommitted：读未提交
read committed：读已提交
repeatable read：可重复读
serializable：串行化
在进行配置的时候，如果数据库和spring代码中的隔离级别不同，那么以spring的配置为主。

16、说一下使用spring的优势？

1、Spring通过DI、AOP和消除样板式代码来简化企业级Java开发
2、Spring框架之外还存在一个构建在核心框架之上的庞大生态圈，它将Spring扩展到不同的领域，如Web服务、REST、移动开发以及NoSQL
3、低侵入式设计，代码的污染极低
4、独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺
5、Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦
6、Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式处理，从而提供了更好的复用
7、Spring的ORM和DAO提供了与第三方持久层框架的的良好整合，并简化了底层的数据库访问
8、Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

17、如何实现一个IOC容器?

IOC(Inversion of Control),意思是控制反转，不是什么技术，而是一种设计思想，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。
在传统的程序设计中，我们直接在对象内部通过new进行对象创建，是程序主动去创建依赖对象，而IOC是有专门的容器来进行对象的创建，即IOC容器来控制对象的创建。
在传统的应用程序中，我们是在对象中主动控制去直接获取依赖对象，这个是正转，反转是由容器来帮忙创建及注入依赖对象，在这个过程过程中，由容器帮我们查找级注入依赖对象，对象只是被动的接受依赖对象。
1、先准备一个基本的容器对象，包含一些map结构的集合，用来方便后续过程中存储具体的对象
2、进行配置文件的读取工作或者注解的解析工作，将需要创建的bean对象都封装成BeanDefinition对象存储在容器中
3、容器将封装好的BeanDefinition对象通过反射的方式进行实例化，完成对象的实例化工作
4、进行对象的初始化操作，也就是给类中的对应属性值就行设置，也就是进行依赖注入，完成整个对象的创建，变成一个完整的bean对象，存储在容器的某个map结构中
5、通过容器对象来获取对象，进行对象的获取和逻辑处理工作
6、提供销毁操作，当对象不用或者容器关闭的时候，将无用的对象进行销毁

18、spring、springmvc、springboot的区别是什么？

spring和springMvc：

1、spring是一个一站式的轻量级的java开发框架，核心是控制反转（IOC）和面向切面（AOP），针对于开发的WEB层(springMvc)、业务层(Ioc)、持久层(jdbcTemplate)等都提供了多种配置解决方案；
2、springMvc是spring基础之上的一个MVC框架，主要处理web开发的路径映射和视图渲染，属于spring框架中WEB层开发的一部分；

springMvc和springBoot：

1、springMvc属于一个企业WEB开发的MVC框架，涵盖面包括前端视图开发、文件配置、后台接口逻辑开发等，XML、config等配置相对比较繁琐复杂；
2、springBoot框架相对于springMvc框架来说，更专注于开发微服务后台接口，不开发前端视图，同时遵循默认优于配置，简化了插件配置流程，不需要配置xml，相对springmvc，大大简化了配置流程；

总结：

1、Spring 框架就像一个家族，有众多衍生产品例如 boot、security、jpa等等。但他们的基础都是Spring的ioc、aop等. ioc 提供了依赖注入的容器， aop解决了面向横切面编程，然后在此两者的基础上实现了其他延伸产品的高级功能；
2、springMvc主要解决WEB开发的问题，是基于Servlet 的一个MVC框架，通过XML配置，统一开发前端视图和后端逻辑；
3、由于Spring的配置非常复杂，各种XML、JavaConfig、servlet处理起来比较繁琐，为了简化开发者的使用，从而创造性地推出了springBoot框架，默认优于配置，简化了springMvc的配置流程；但区别于springMvc的是，springBoot专注于单体微服务接口开发，和前端解耦，虽然springBoot也可以做成springMvc前后台一起开发，但是这就有点不符合springBoot框架的初衷了；

19、Spring框架中的单例Bean是线程安全的么？

Spring中的Bean对象默认是单例的，框架并没有对bean进行多线程的封装处理
如果Bean是有状态的，那么就需要开发人员自己来保证线程安全的保证，最简单的办法就是改变bean的作用域把singleton改成prototype，这样每次请求bean对象就相当于是创建新的对象来保证线程的安全
有状态就是由数据存储的功能
无状态就是不会存储数据，你想一下，我们的controller，service和dao本身并不是线程安全的，只是调用里面的方法，而且多线程调用一个实例的方法，会在内存中复制遍历，这是自己线程的工作内存，是最安全的。
因此在进行使用的时候，不要在bean中声明任何有状态的实例变量或者类变量，如果必须如此，也推荐大家使用ThreadLocal把变量变成线程私有，如果bean的实例变量或者类变量需要在多个线程之间共享，那么就只能使用synchronized，lock，cas等这些实现线程同步的方法了。

20、Spring是如何简化开发的？

1.基于POJO的轻量级和最小侵入性编程
2.通过依赖注入和面向接口实现松耦合
3.基于切面和惯例进行声明式编程
4.通过切面和模板减少样板式代码

2021年12月29日

21、spring支持的bean作用域有哪些？

① singleton
使用该属性定义Bean时，IOC容器仅创建一个Bean实例，IOC容器每次返回的是同一个Bean实例。
② prototype
使用该属性定义Bean时，IOC容器可以创建多个Bean实例，每次返回的都是一个新的实例。
③ request
该属性仅对HTTP请求产生作用，使用该属性定义Bean时，每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。
④ session
该属性仅用于HTTP Session，同一个Session共享一个Bean实例。不同Session使用不同的实例。
⑤ global-session
该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。

22、spring事务的实现方式原理是什么？

1、在使用Spring框架的时候，可以有两种事务的实现方式，一种是编程式事务，有用户自己通过代码来控制事务的处理逻辑，还有一种是声明式事务，通过@Transactional注解来实现。
2、其实事务的操作本来应该是由数据库来进行控制，但是为了方便用户进行业务逻辑的操作，spring对事务功能进行了扩展实现，一般我们很少会用编程式事务，更多的是通过添加@Transactional注解来进行实现，当添加此注解之后事务的自动功能就会关闭，有spring框架来帮助进行控制。
3、其实事务操作是AOP的一个核心体现，当一个方法添加@Transactional注解之后，spring会基于这个类生成一个代理对象，会将这个代理对象作为bean，当使用这个代理对象的方法的时候，如果有事务处理，那么会先把事务的自动提交给关系，然后去执行具体的业务逻辑，如果执行逻辑没有出现异常，那么代理逻辑就会直接提交，如果出现任何异常情况，那么直接进行回滚操作，当然用户可以控制对哪些异常进行回滚操作。
TransactionInterceptor

23、如何理解springboot中的starter？

1、使用spring+springmvc框架进行开发的时候，如果需要引入mybatis框架，那么需要在xml中定义需要的bean对象，这个过程很明显是很麻烦的，如果需要引入额外的其他组件，那么也需要进行复杂的配置，因此在springboot中引入了starter
2、starter就是一个jar包，写一个@Configuration的配置类，将这些bean定义在其中，然后再starter包的META-INF/spring.factories中写入配置类，那么springboot程序在启动的时候就会按照约定来加载该配置类
3、开发人员只需要将相应的starter包依赖进应用中，进行相关的属性配置，就可以进行代码开发，而不需要单独进行bean对象的配置

24、SpringBoot自动装配原理

空

25、BeanFactory和ApplicationContext有什么区别

相同：

• Spring提供了两种不同的IOC 容器，一个是BeanFactory，另外一个是ApplicationContext，它们都是Java interface，ApplicationContext继承于BeanFactory(ApplicationContext继承ListableBeanFactory。
• 它们都可以用来配置XML属性，也支持属性的自动注入。
• 而ListableBeanFactory继承BeanFactory)，BeanFactory 和 ApplicationContext 都提供了一种方式，使用getBean("bean name")获取bean。

不同：

• 当你调用getBean()方法时，BeanFactory仅实例化bean，而ApplicationContext 在启动容器的时候实例化单例bean，不会等待调用getBean()方法时再实例化。
• BeanFactory不支持国际化，即i18n，但ApplicationContext提供了对它的支持。
• BeanFactory与ApplicationContext之间的另一个区别是能够将事件发布到注册为监听器的bean。
• BeanFactory 的一个核心实现是XMLBeanFactory 而ApplicationContext 的一个核心实现是ClassPathXmlApplicationContext，Web容器的环境我们使用WebApplicationContext并且增加了getServletContext 方法。
• 如果使用自动注入并使用BeanFactory，则需要使用API注册AutoWiredBeanPostProcessor，如果使用ApplicationContext，则可以使用XML进行配置。
• 简而言之，BeanFactory提供基本的IOC和DI功能，而ApplicationContext提供高级功能，BeanFactory可用于测试和非生产使用，但ApplicationContext是功能更丰富的容器实现，应该优于BeanFactory