# spring_bean

**Repository Path**: guozhuangzhuang1/spring

## Basic Information

- **Project Name**: spring_bean
- **Description**: 实现了简单的AOP和IOC，基于Bean的生命周期
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-04-19
- **Last Updated**: 2025-05-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Spring

## README

# 本项目可助理解Bean创建的过程及生命周期



## 生命周期

**首先扫描配置类进行配置导入，创建spring容器**



**推断构造方法**

如果只有一个构造方法就使用这一个

如果有多个，就判断是否有@Autowired指定的构造方法，如果没有再看是否有无参构造，如果都没有就报错



**然后在配置的范围内扫描注解**，把对象通过默认的构造方法进行反射创建出来，根据类上的注解再进行对象更多详细信息的设置，比如beanName，scope等等

然后放进beandefinationMaps中

```java
//bean的定义池
public static ConcurrentHashMap<String,BeanDefination> beandefinationMaps=new ConcurrentHashMap<>();
```

之后就是进行属性注入，对bean进行的一些定制化操作等等

```java
Object createBean(String beanName,BeanDefination beanDefination) throws Exception {
    Class clazz= (Class) beanDefination.getClazz();
    Object instance=clazz.getDeclaredConstructor().newInstance();

    //依赖注入
    for (Field declaredField : clazz.getDeclaredFields()) {
        //判断属性上面有没有autowired注解
        if(declaredField.isAnnotationPresent(Autowired.class)){
            //进行属性的赋值
            Object bean=getBean(declaredField.getName());
            declaredField.setAccessible(true);
            declaredField.set(instance,bean);
        }
    }
    //判断是否实现了BeanNameAware接口    aware回调
    if(instance instanceof BeanNameAware){
        ((BeanNameAware) instance).setBeanName(beanName);
    }

    //BeanPostProcessor前置方法
    for (BeanPostProcessor beanPostProcessor:beanPostProcessorslist){
        instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
    }

    //初始化
    if(instance instanceof InitializingBean){
        ((InitializingBean) instance).afterPropertiesSet();
    }


    //BeanPostProcessor后置方法
    for (BeanPostProcessor beanPostProcessor:beanPostProcessorslist){
        instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
    }
    return instance;
}
```

**AOP操作**

判断是否要对Bean进行AOP操作

如果是切点之类的Bean的话就不用，其他的Bean就判断是否有相应的切点

1. 从spring容器中找出所有的切面

2. 然后拿着普通业务Bean对象去找有没有相对应的切点



如果不需要进行代理就把刚开始生成的Bean返回，如果需要代理就需要结合相应的切点进行代理对象的创建，最后返回代理对象。



一个Bean中的属性在依赖注入后就会有值，但是在aop后生成的代理对象却是没有值的，但是我们可以在进行代理的过程中对值进行操作，因为在进行代理操作中，操作的对象是target对象，是原本生成的Bean

实际是使用到了BeanPostProcessor后置方法

```java
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if(beanName.equals("userservice")){
        Object proxyInstance=Proxy.newProxyInstance(ZzpostProcess.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("进行代理");
                return method.invoke(bean,args);
            }
        });
       return proxyInstance;
    }
    System.out.println(beanName+"初始化后-----------------------");
    return bean;
}
```

使用了JDK的动态代理





## Bug

![1649907769406](https://picture-zz.oss-cn-beijing.aliyuncs.com/1649907769406.png)