README.md · daizhiheng123/aloha-spring

# aloha-spring

## 一、项目简介

本项目是一个学习Spring源码的项目，完成了一个简易的Spring框架，实现了AOP和IoC等基本功能

参照学习的GitHub开源项目 [mini-spring](https://github.com/DerekYRC/mini-spring)

参考书籍[《精通Spring 4.x》](https://book.douban.com/subject/26952826/)

**搭建测试环境**

将项目clone下来，并安装到本地仓库，创建一个测试模块并引入依赖，如下图

![image-20230721230523517](img/image-20230721230523517.png)

## 二、IoC

### 1. 封装Bean的定义信息

#### PropertyValue

> 用于封装每个对象的属性名与属性值

#### BeanReference

> 某个对象中并不是所有的属性都是基本类型，还有可能是引用类型，这个引用类型往往是Spring容器中的对象。所以使用这个类来获得Spring容器中的引用类型

####  BeanDefinition

> 用于封装创建对象所需的必要信息，例如对象的Class类型，对象的成员变量属性值，对象是否为单例，以及对象的初始化和销毁方法
>
> 只有拥有了BeanDefinition Spring才能给我们创建出来对象

### 2. 读取BeanDefinition

#### Resource

> 用来抽象文件资源，例如xml、properties类型的文件等，bean的定义信息往往封装在这些信息中，可以通过 **`Resource`**获取文件资源的流，之后便可以通过流获取Bean的具体定义信息了

#### ResourceLoader

> 用来获取 **`Resource`**接口的实现类

#### BeanDefinitionRegistry

> 主要用于注册 **`BeanDefinition`**，有一个较为重要的实现类 **`DefaultListableBeanFactory`**

#### BeanDefinitionReader

> 用于获取 **`BeanDefinitionRegistry`** ，并提供了向 **`BeanDefinitionRegistry`**中注册 BeanDefinition 的能力，一个重要的实现类是 **`XmlBeanDefinitionReader`**

### 3. 通过BeanDefinition创建对象

#### InstantiationStrategy

> 通过 **`BeanDefinition`**创建对象，使用了策略模式，可以选择创建对象的方法：反射、CGLIB

### 4. 存放Bean对象

#### SingletonBeanRegistry

> 提供注册和获取单例Bean的能力，一个实现类 **`DefaultSingletonBeanRegistry`**中拥有三个对象缓存池，也就是通常说的三级缓存

### 5. 获取Bean对象

#### BeanFactory

> 定义了基本的获取Bean对象的方式，例如根据 beanName 获取，根据类型获取等等，它的一些子接口，提供了一些例如自动配置和列出所有Bean对象的能力等，一个较为重要的实现类 **`DefaultListableBeanFactory`**

**案例1**

使用 xml 文件定义bean的一些信息，并通过BeanFactory获取

test01.xml

![image-20230722170251540](img/image-20230722170251540.png)

**测试类**

![image-20230722170840544](img/image-20230722170840544.png)

> 通过这个案例，可以发现 Spring 容器的基本功能已经实现了

### 6. Bean 处理器

#### BeanFactoryPostProcessor

> 在bean实例化前，修改bean的定义信息，是容器的一个拓展机制

#### BeanPostProcessor

> 在bean实例化后并且填充完属性值后，执行 **`Before`** 方法，之后会执行 初始化 方法，最后执行 **`After`**方法

**案例2.1**

创建两个类，并让其实现BeanPostProcessor，并自定义before方法和after方法

![image-20230722222043214](img/image-20230722222043214.png)

![image-20230722222055865](img/image-20230722222055865.png)

在测试类中添加BeanPostProcessor

![image-20230722222234858](img/image-20230722222234858.png)

**案例2.2**

当某个BeanPostProcessor的Before或者After方法返回值为null时，那么后续的BeanPostProcessor便不会继续执行

测试

![image-20230722222644326](img/image-20230722222644326.png)

### 7. Bean 的初始化

> 重点在于Bean的初始化方法，因为这在开发中经常使用，在Bean的后置处理器的Before方法执行后执行，可以通过实现 **`InitializingBean`**或者指定 **`init-method`** 方法来指定初始化方法

**案例3**

创建一个实现了 InitializingBean 的方法，并在依赖注入后在 afterPropertiesSet() 中获取注入的对象

![image-20230723214703401](img/image-20230723214703401.png)

test03.xml

![image-20230723214906608](img/image-20230723214906608.png)

测试

![image-20230723215040843](img/image-20230723215040843.png)

### 8. Aware 感知器接口

> Aware 的一系列子接口提供了获取Spring容器中一系相关对象的能力

**案例4**

![image-20230723222802543](img/image-20230723222802543.png)

test04.xml

![image-20230723222816862](img/image-20230723222816862.png)

![image-20230723222853879](img/image-20230723222853879.png)

> 实现 BeanFactoryAware 的类获取到了BeanFactory

### 9. ApplicationContext

> 到目前为止，已经演示了Spring的很多功能，但是会发现都是直接操作 BeanFactory的实现类来实现的。其实BeanFactory是面向框架内部使用的，还有很多的功能不够人性，比如需要自己传入 BeanDefinitionReader，需要手动添加 BeanPostProcessor等。所以Spring提供了一个面向用户使用的接口 ApplicationContexrt，ApplicationContext会预先实例化单例Bean；而不像之前直接使用BeanFactory那样在getBean时才创建。
>
> 在aloha-spring 中简化了一部分ApplicationContext的功能，具体可见 AbstractApplicationContext#refresh()方法

**案例5**

只需要将后置处理器放入容器中即可，无需再手动添加

test05.xml

![image-20230724211740467](img/image-20230724211740467.png)

Application会预先实例化单例Bean

在UserDao中添加如下的无参构造函数

![image-20230724212216645](img/image-20230724212216645.png)

在测试类中仅仅创建一个ApplicationContext

![image-20230724212407726](img/image-20230724212407726.png)

### 10. FactoryBean

> FactoryBean可以将对象创建的具体细节交给用户自己去实现

案例6

![image-20230724220220047](img/image-20230724220220047.png)

![image-20230724220303262](img/image-20230724220303262.png)

![image-20230724220346752](img/image-20230724220346752.png)

### 11. 容器事件与事件监听

#### ApplicationEventPublisher

> 用于发送事件，一个实现类就是 ApplicationContext 的实现类

#### ApplicationContextEvent

> 用户可以通过继承这个类然后自定义事件，发送的事件主要由监听者获取并做处理

#### ApplicationListener

> 用户实现这个接口，并且在接口的泛型中指定事件的类型，当ApplicationEventPublisher发送对应的事件时，监听者可以拿到事件对象做相应的处理

#### ApplicationEventMulticaster

> 用于管理事件和监听者的关系，当使用ApplicationEventPublisher发布事件时会调用这个接口的多播方法，将事件广播给所有感兴趣的监听者

### 12. 包扫描

> 在aloha-spring中使用配置文件的方法实现包扫描，大体的思路是：读取到待扫描的包下的所有类，寻找到拥有 @Component 等注解，并封装一个 BeanDefinition 放到 Bean定义信息的注册中心中

![image-20230726183632677](img/image-20230726183632677.png)

![image-20230726184259635](img/image-20230726184259635.png)

### 13. 自动注入

**InstantiationAwareBeanPostProcessor**

> 在说明自动注入的功能实现前，先说明 **InstantiationAwareBeanPostProcessor** 这个接口，
>
> 这个接口是 BeanPostProcessor 的子接口，有以下几个方法
>
> - **`postProcessBeforeInstantiation`**：实例化bean之前，相当于new这个bean之前
> - **`postProcessAfterInstantiation`**：  实例化bean之后，相当于new这个bean之后
> - **`postProcessPropertyValues`**：           bean已经实例化完成，在属性注入时阶段触发
>   - 以上三个是这个接口新增的方法
> - **`postProcessBeforeInitialization`**：执行初始化方法之前
> - **`postProcessAfterInitialization`**：  执行初始化方法之后
>
> 
>
> 属性注入是在方法：**`postProcessPropertyValues`** 中实现的，在给Bean设置属性前，扫描Bean中所有的成员变量，如果发现有自动注入的注解，就去BeanFactory中获取依赖的对象并给Bean设置上

![image-20230726193221046](img/image-20230726193221046.png)

**案例7：**

> 融合前三小节，在一个包下创建事件监听器和对应的事件，并使用包扫描，依赖注入；完成容器事件的监听

配置包扫描

![image-20230726195443011](img/image-20230726195443011.png)

创建用户注册事件，继承自 ApplicationContextEvent

![image-20230726194924313](img/image-20230726194924313.png)

创建用户注册事件监听器，并将这个监听器加入到容器中

![image-20230726195752975](img/image-20230726195752975.png)

注册用户信息上下文

![image-20230726200533817](img/image-20230726200533817.png)

创建用户注册服务，并将用户信息上下文对象注入

![image-20230726200929262](img/image-20230726200929262.png)

测试

![image-20230726201203970](img/image-20230726201203970.png)

> 至此，IoC的功能已经基本实现，目前的依赖注入都是不存在循环引用的关系的，那如果两个对象之间相互依赖，注入还能成功吗？在Spring框架中肯定是可以的那aloha-spring可以吗？下一小节揭晓

### 14. Bean的生命周期

## 三、AOP

### 1. 基本概念

**JointPoint**

> 程序执行过程中某个特定位置，需要两个信息确定：
>
> + 用方法表示的程序执行点
> + 用相对位置表示的方位(在方法执行前、后)
>
> 在Spring中方法由Pointcut确定，方位由具体的Advice确定

**Pointcut**

> 一个类可以有多个JointPoint，而我们所感兴趣的JointPoint才是Pointcut，通过Pointcut确定连接点。但是Pointcut只能定位到感兴趣的类的目标方法，而具体的方位需要通过具体的Advice才能知道

**Advice**

> 前面提到要知道一个JointPoint的方位，需要Advice；其实Advice包含两部分：增强逻辑和增强逻辑执行的具体位置，是在目标类的目标方法执行前还是执行后等

**Target**

> 目标类，代理是以方法为单位的(Spring中)，但是方法需要在类中定义

**PointcutAdvisor**

> 切面，特指 一个Pointcut和一个Advice

**Aspect**

> 切面，一个Pointcut多个Advice，由多个 Advisor 组成

### 2. 相关类

**TargetSource**

> 封装被代理的对象

**AdvisedSupport**

> 包含TargetSource以及切面和其他一些切面的配置信息

**AopProxy**

> 获取代理对象的接口，有两个实现类 **JdkDynamicAopProxy** 和 **CglibAopProxy** 对应两种动态代理的方法 JDK动态代理和CGLIB动态代理

**ProxyFactory**

> 继承自 AdvisedSupport，用于创建代理

**案例8**

```java
@Slf4j
public class Test08 {

public static void main(String[] args) {

// 需要被代理的目标对象
        Test08 target = new Test08();

// 创建一个切面
        AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor();
        String expression = "execution(* service(..))";
        advisor.setExpression(expression);
        advisor.setAdvice(new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                log.info("Begin");
                Object result = invocation.proceed();
                log.info("End");
                return result;
            }
        });

ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTargetSource(new TargetSource(target)); // 添加目标对象
        proxyFactory.addAdvisor(advisor); // 添加切面
        Test08 proxy = (Test08) proxyFactory.getProxy(); // 获取代理
        proxy.service();
    }

public void service() {
        log.info("业务代理");
    }
}
```

**执行结果**

### 3. 融入Bean生命周期

> 通过之前在IoC部分的学习，我们知道通过 BeanPostProcessor 可以修改一个Bean的内容甚至是替换这个Bean对象，所以只要在一个Bean使用前将其替换为代理对象即可；复习Bean的生命周期可知，在BeanPostProcessor的PostProcessAfterInitialization方法中将Bean替换为代理对象即可，具体参见
>
> **`com.aloha.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator`**

### 4. 实现AspectJ自动代理

**AnnotationAwareAspectJAutoProxyCreator**

> 在参考项目mini-spring中只实现了基于AOP联盟的相关自动代理类DefaultAdvisorAutoProxyCreator，使用这种方式创建代理很麻烦，需要手动创建Advice和Advisor最后再组装起来。所以在aloha-spring中模仿Spring使用AspectJ的相关规范实现基于注解的自动代理，目前只实现了支持@Around通知

**具体思路：**

+ 首先思考我们想要实现什么：添加一个@Around注解就可以让框架自动为我们创建Advisor
+ 有了目标，着手处理
  + 找到带有@Around注解的类
  + 所以需要扫描整个beanFactory并判断是否添加了@Aspect注解
  + 遍历该类中所有的方法，判断是否添加了@Around注解
  + 获取@Around中的表达式创建对应的Advisor

具体实现见：

**`com.aloha.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory`**

**`com.aloha.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator`**

**案例9**

创建一个用于标记需要被拦截的方法的注解

![image-20230803131155372](img/image-20230803131155372.png)

创建切面，添加一个@Around注解并指明自定义的注解

![image-20230803131230481](img/image-20230803131230481.png)

在目标类的目标方法上添加自定义注解

![image-20230803131450221](img/image-20230803131450221.png)

配置文件 test09.xml

![image-20230803131635176](img/image-20230803131635176.png)

测试

![image-20230803131740306](img/image-20230803131740306.png)

### 5. 循环依赖的解决

> 案例：如果一个类A中依赖类B，同时类B中也依赖类A，这时在容器中去获取A，发现A需要B，这时会getBean去获取B，在创建B时又发现需要A，就又会去getBean获取A，就这样发生了循环依赖
>
> 我们发现，循环依赖发生的位置在填充对象属性时，那么如果我们在添加属性之前，在Bean实例化出来后将将它缓存起来，是不是就可以解决了。
>
> 以上是set注入循环依赖的解决方案，本项目中未实现构造注入，不过构造注入的方式和set注入有异曲同工之妙，例如 A依赖B，B依赖A，可以在A中使用B的ObjectFactory替代B，达到一个延时创建的目的

![](img/循环依赖解决.png)

**案例10**

模拟在开发中经常使用的一种解决事务失效的方法，自己注入自己的代理对象

![image-20230804100150753](img/image-20230804100150753.png)

test10.xml

![image-20230804100225908](img/image-20230804100225908.png)

测试

![image-20230804100407251](img/image-20230804100407251.png)

daizhiheng123/aloha-spring

简介

发行版

贡献者

近期动态

daizhiheng123/aloha-spring .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

daizhiheng123/aloha-spring