Spring注解式编程

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.7.RELEASE</version>
  </dependency>

@Component
public class User {
    private String userName;
    private Integer email;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getEmail() {
        return email;
    }

    public void setEmail(Integer email) {
        this.email = email;
    }

    public String sayHello() {
        return "hello";
    }
}

@Configuration
public class Configuration {
    @Bean
    public User user() {
        return new User();
    }
}

public class AnnotationConfigApplicationContextDemo {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Configuration.class);
        User user = applicationContext.getBean(User.class);
        String s = user.sayHello();
        System.out.println(s);
    }
}

public AnnotationConfigApplicationContext() {
        //初始化Bean的读取和扫描器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
}
public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
        //父类中this.beanFactory = new DefaultListableBeanFactory() 创建BeanFactory
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        //注册bean配置类
        register(annotatedClasses);
        //刷新上下文
        refresh();
    }
public AnnotationConfigApplicationContext(String... basePackages) {
        this();
       //配置扫描包的路径
        scan(basePackages);
        refresh();
    }

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
        //将配置类信息转成AnnotatedGenericBeanDefinition 
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        //@Conditional装配条件判断是否跳过注册
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
        //设置回调
        abd.setInstanceSupplier(instanceSupplier);
        //解析Bean的作用域，默认singleton
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        //生成bean配置类的name
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

        //通用注解解析 Lazy, primary DependsOn, Role ,Description这五个注解
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
       //@Qualifier特殊限定符处理
        if (qualifiers != null) {
            for (Class<? extends Annotation> qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    //如果配置@Primary 则@Autowired 注入首选
                    abd.setPrimary(true);
                }
                else if (Lazy.class == qualifier) {
                    //如果配置@Lazy 则IOC容器启动时不创建bean
                    abd.setLazyInit(true);
                }
                else {
                    //其他注解加到abd中
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        //自定义注册Bean，在applicationContext创建后使用lambda创建
       //applicationContext.registerBean(User.class, () -> new User());
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }
        //根据BeanName和abd封装一个BeanDefinitionHolder
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        //创建代理对象
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        //注册Bean ->DefaultListableBeanFactory.registerBeanDefinition()
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                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
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }