最详细的SpringIOC装配流程

1，了解BeanFactory和FactoryBean

BeanFactory接口：它是IoC容器的顶级接口，是IoC容器的底层基础实现，也是访问Spring容器的根接口，负责对bean的创建，访问等工作。
FactoryBean接口：它是一个可以返回bean的实例的工厂bean，实现这个接口可以对bean进行一些额外的操作。

2,了解模版方法模式【设计模式】

定义一个操作中的骨架，而将一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。
组成：具体方法， 钩子方法， 抽象方法
该模式的主要优点如下。
1. 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
2. 它在父类中提取了公共的部分代码，便于代码复用。
3. 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

/**
 * @program: 模版方法模式
 * @author: XiaZQ
 **/
public abstract class Work {

    public void start(){
        transTool();
        carry();
        working();
    }

    //抽象
    protected abstract void transTool();

    //具体
    public void working(){

        System.out.println("大家都努力都工作");
    }

    //钩子
    protected void carry(){}
}



public class AWorker extends Work{
    @Override
    protected void transTool() {
        System.out.println("A员工穷，今天走路上班");
    }
}

public class BWorker extends Work{
    @Override
    protected void transTool() {
        System.out.println("B员工开车");
    }

    @Override
    protected void carry() {
        System.out.println("B员工顺便带了个鸡腿");
    }
}


    public static void main(String[] args) {
        Work aworker = new AWorker();
        Work bworker = new BWorker();
        aworker.start();
        bworker.start();
    }

3，熟悉责任链模式

责任链模式属于行为模式，为请求创建了一个接收者对象的链，这种模式给于请求的类型，对请求的发送者和接收者进行解耦。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依次类推。或者如果某个接收者处理完之后，还需要传递到下一个接收者继续处理或者返回处理完毕

/**
 * @description: 事件对象
 * @author: XiaZQ
 * @create: 2022-05-27 16:21
 **/
@Data
public class ResbEvent {

    private String name;

    private Integer days;

}



/**
 * @description: 责任链模式
 * @author: XiaZQ
 * @create: 2022-05-27 16:22
 **/
public abstract class Leader {

    protected Leader nextLeader;

    protected void nextLeader(Leader leader){
        this.nextLeader = leader;
    }

    protected abstract void approve(ResbEvent resbEvent);

}


/**
 * @description: 一级审批
 * @author: XiaZQ
 * @create: 2022-05-27 16:24
 **/
public class SmallLeader extends Leader{


    @Override
    protected void approve(ResbEvent resbEvent) {

        Integer days = resbEvent.getDays();
        if (days < 3){
            System.out.println("请假合理  准予；；；；；；");
            return;
        }
        if (nextLeader != null){
            System.out.println("Small:请假时间太长  我没权利");
            nextLeader.approve(resbEvent);
        }

    }
}

/**
 * @description: 二级审批
 * @author: XiaZQ
 * @create: 2022-05-27 16:24
 **/
public class BigLeader extends Leader{


    @Override
    protected void approve(ResbEvent resbEvent) {

        Integer days = resbEvent.getDays();
        if (days > 3){
            System.out.println("虽然时间比较长，，，但是看你表现不错，准予；；；；；；");
            return;
        }
    }
}

/**
 * @description: 测试
 * @author: XiaZQ
 * @create: 2022-05-27 16:26
 **/
public class ResTest {

    public static void main(String[] args) {
        SmallLeader smallLeader = new SmallLeader();

        BigLeader bigLeader = new BigLeader();
        ResbEvent resbEvent = new ResbEvent();
        resbEvent.setDays(4);
        smallLeader.nextLeader(bigLeader);
        smallLeader.approve(resbEvent);
    }
}

4，熟悉监听器模式

1、事件源 event source： 用来注册，发布事件
2、事件对象 event： 事件本身
3、事件监听器 event listener

/**
 * @description: 事件对象
 * @author: XiaZQ
 * @create: 2022-05-27 16:11
 **/

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Event {

    private String eventType;

}
/**
 * @description: 事件源
 * @author: XiaZQ
 * @create: 2022-05-27 16:15
 **/
public class EventSource {

    private List<ClickListener> listenerList = Lists.newArrayList();

    public void register(ClickListener clickListener){
        Optional.ofNullable(clickListener).ifPresent(listenerList::add);
    }


    public void publish(Event event){
        listenerList.forEach(listener -> listener.listen(event));
    }
}

/**
 * @description: 点击事件监听
 * @author: XiaZQ
 * @create: 2022-05-27 16:12
 **/
public abstract class ClickListener {

    protected abstract void listen(Event event);
}

/**
 * @description: 监听器：监听单击事件
 * @author: XiaZQ
 * @create: 2022-05-27 16:13
 **/
public class SingleClickListener extends ClickListener{


    @Override
    protected void listen(Event event) {
        if (StringUtils.equals(event.getEventType(),"single")){
            System.out.println("此时监听到单击---------------");
        }
    }
}

/**
 * @program: pitfall_test
 * @description:  监听器：监听双击事件
 * @author: XiaZQ
 * @create: 2022-05-27 16:14
 **/
public class DoubleClickListener extends ClickListener{
    @Override
    protected void listen(Event event) {
        if (StringUtils.equals(event.getEventType(),"double")){
            System.out.println("此时监听到双击---------------");
        }
    }
}


/**
 * @description: 测试
 * @author: XiaZQ
 * @create: 2022-05-27 16:17
 **/
public class ListenTest {

    public static void main(String[] args) {
        SingleClickListener singleClickListener = new SingleClickListener();
        DoubleClickListener doubleClickListener = new DoubleClickListener();
        EventSource eventSource = new EventSource();
        eventSource.register(singleClickListener);
        eventSource.register(doubleClickListener);
        eventSource.publish(new Event("double"));
    }
}

5,认识后置处理器

    1，BeanFactoryPostProcessor
           可通过该处理器给bean提前注入
    2，BeanDefinitionRegistryPostProcessor
           用户可主动定义
    3，BeanPostProcessor

6,refresh()开始进入IOC

refresh：

循环依赖

createBean：

populateBean：

整体流程