Spring的学习笔记

Spring是什么？

Spring是一个轻量级控制反转(IOC)和面向切面(AOP)的容器框架。

Spring相关概念

Spring Bean的加载

我们先了解下Spring Bean的生命周期

先思考下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy；

Spring bean的 生命周期也差不多，只是增加了一些装载方式

Spring对bean进行实例化，默认bean是单例；

Spring对bean进行依赖注入；

如果bean实现了BeanNameAware接口，spring将bean的id传给setBeanName()方法；

如果bean实现了BeanFactoryAware接口，spring将调用setBeanFactory方法，将BeanFactory实例传进来；

如果bean实现了ApplicationContextAware接口，它的setApplicationContext()方法将被调用，将应用上下文的引用传入到bean中；

如果bean实现了BeanPostProcessor接口，它的postProcessBeforeInitialization方法将被调用；

如果bean实现了InitializingBean接口，spring将调用它的afterPropertiesSet接口方法，类似的如果bean使用了init-method属性声明了初始化方法，该方法也会被调用；

如果bean实现了BeanPostProcessor接口，它的postProcessAfterInitialization接口方法将被调用；

此时bean已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；

若bean实现了DisposableBean接口，spring将调用它的distroy()接口方法。同样的，如果bean使用了destroy-method属性声明了销毁方法，则该方法被调用；

上面是拷贝的，下面讲讲自己的理解：
单词解释：Aware：有意识的，我更喜欢理解为知觉，所以BeanNameAware，BeanFactoryAware 这2个接口可以理解为为SpringBean增加知觉。
顾名思义，BeanNameAware可以让bean知道自己的名字。
BeanFactoryAware 可以让bean知道自己属于哪个工厂实例信息。
ApplicationContextAware 可以让bean知道自己的容器信息。
BeanPostProcessor 接口 的理解，BeanPostProcessor 有before和after 2个方法可以实现，用于bean实例在初始化前后，增加一些操作。参考链接：https://www.jianshu.com/p/1417eefd2ab1
InitializingBean 接口和init-method属性声明，都是Bean实例在初始化的时候所做的操作，InitializingBean 优先于 init-method属性声明执行。
DisposableBean 接口可以Bean被销毁前执行一些操作。

控制反转(IOC)

ioc：Inversionof Control（中文：控制反转）是 spring 的核心，对于 spring 框架来说，就是由 spring 来负责控制对象的生命周期和对象间的关系。

简单来说，控制指的是当前对象对内部成员的控制权；控制反转指的是，这种控制权不由当前对象管理了，由其他（类,第三方容器）来管理。

理解：一般我们要使用一个实例，要先去new这个对象，这可以理解为“控制正转”，那控制反转就是，这些对象都已经创建好在容器里了，你要用的时候，只是容器往你的类里注入，主动权在容器，而非在你的类里。

依赖注入（DI）和控制反转（IOC）是同一概念吗？
依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

@Autowired原理

如类图所示，Spring中有一个AutowiredAnnotationBeanPostProcessor 实现了BeanPostProcessor 接口，AutowiredAnnotationBeanPostProcessor 会扫描容器里，带有@Autowired注解的地方，然后在初始化的时候，对Bean进行注入。
@Autowired 按 byType 自动注入
@Resource 默认按 byName
@Qualifier 只能和 @Autowired 结合使用，是对 @Autowired 有益的补充

@Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。
@Service 通常作用在业务层，但是目前该功能与 @Component 相同。
@Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。
@Repository、@Component、@Service 和 @Constroller 注解，Spring 会自动创建相应的 BeanDefinition 对象，并注册到 ApplicationContext 中。这些类就成了 Spring 受管组件。这三个注解除了作用于不同软件层次的类，其使用方式与 @Repository 是完全相同的。

面向切面(AOP)

aop 是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
简单来说就是统一处理某一“切面”（类）的问题的编程思想，比如统一处理日志、异常等。

AOP的基本概念

(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知
(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用
(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around
(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
(5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

日志AOP示例：

@Slf4j
@Aspect
@Component
public class GlobalLogHandler {

    @Pointcut("@annotation(org.springframework.stereotype.Component)")//连接点是@RequestMapping注解的方法
    private void webPointcut() {}

    @AfterThrowing(pointcut = "webPointcut()", throwing = "e")//切点在webpointCut()
    public void handleThrowing(JoinPoint joinPoint, Exception e) {//controller类抛出的异常在这边捕获
        log.error(e.getMessage(),e);
    }

    @Around(value = "execution(* com.usetid..*..*.dubbo..*.*(..))")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        long startTime = System.currentTimeMillis();
        String className =pjp.getTarget().getClass().getName();
        String methodName = pjp.getSignature().getName();
        // 日志记录
//        log(pjp);
        dubboLog(pjp);
        // exec
        Object result = pjp.proceed();
        // 统计时间
        long totalTime = System.currentTimeMillis() - startTime;
        log.info(String.format("结束执行类[%s]，方法[%s],返回参数[%s],耗时[%s]",className,methodName,result,new Double(totalTime) / 1000));
        return result;
    }
}

循环依赖问题

摘自：https://blog.csdn.net/qq_36381855/article/details/79752689
1.什么是循环依赖？

循环依赖–>循环引用。—>即2个或以上bean 互相持有对方，最终形成闭环。
eg：A依赖B，B依赖C，C又依赖A。【注意：这里不是函数的循环调用【是个死循环，除非有终结条件】，是对象相互依赖关系】

2.Spring是如何解决循环依赖问题的呢？

Spring是先将Bean对象实例化【依赖无参构造函数】—>再设置对象的属性。

当Spring实例化了StudentA、StudentB、StudentC后，紧接着会去设置对象的属性，此时StudentA依赖StudentB，就会去Map中取出存在里面的单例StudentB对象，以此类推，不会出来循环的问题喽。

Spring的单例对象的初始化主要分为三步：

1. createBeanInstance：实例化，其实也就是 调用对象的构造方法实例化对象
2. populateBean：填充属性，这一步主要是多bean的依赖属性进行填充
3. initializeBean：调用spring xml中的init() 方法。

从上面讲述的单例bean初始化步骤我们可以知道，循环依赖主要发生在第一、第二步。也就是构造器循环依赖和field循环依赖。

那么我们要解决循环引用也应该从初始化过程着手，对于单例来说，在Spring容器整个生命周期内，有且只有一个对象，所以很容易想到这个对象应该存在Cache中，Spring为了解决单例的循环依赖问题，使用了三级缓存。
三级缓存分别指：
一级缓存： singletonObjects：单例对象的cache
二级缓存： earlySingletonObjects ：提前暴光的单例对象的Cache 。【用于检测循环引用，与singletonFactories互斥】
三级缓存： singletonFactories ： 单例对象工厂的cache

我们在创建bean的时候，首先想到的是从cache中获取这个单例的bean，这个缓存就是singletonObjects

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

上面的代码需要解释两个参数：

isSingletonCurrentlyInCreation()判断当前单例bean是否正在创建中，也就是没有初始化完成(比如A的构造器依赖了B对象所以得先去创建B对象， 或则在A的populateBean过程中依赖了B对象，得先去创建B对象，这时的A就是处于创建中的状态。)
allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象
分析getSingleton()的整个过程，Spring首先从一级缓存singletonObjects中获取。如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()(三级缓存)获取，如果获取到了则：

this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);

从singletonFactories中移除，并放入earlySingletonObjects中。其实也就是从三级缓存移动到了二级缓存。
从上面三级缓存的分析，我们可以知道，Spring解决循环依赖的诀窍就在于singletonFactories这个三级cache。这个cache的类型是ObjectFactory，定义如下

public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

这个接口在下面被引用

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

这里就是解决循环依赖的关键，这段代码发生在createBeanInstance之后，也就是说单例对象此时已经被创建出来(调用了构造器)。这个对象已经被生产出来了，虽然还不完美（还没有进行初始化的第二步和第三步），但是已经能被人认出来了（根据对象引用能定位到堆中的对象），所以Spring此时将这个对象提前曝光出来让大家认识，让大家使用。