//根据beanName获取容器中的Bean实例，需要手动强转
UserService userService = (UserService) applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例，如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例，指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService", 
UserService.class);

String currentTimeStr = "2023-08-27 07:20:00";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(currentTimeStr);

//加载mybatis核心配置文件，使用Spring静态工厂方式
InputStream in = Resources.getResourceAsStream(“mybatis-conifg.xml”);
//创建SqlSessionFactoryBuilder对象，使用Spring无参构造方式
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//调用SqlSessionFactoryBuilder的build方法，使用Spring实例工厂方式
SqlSessionFactory sqlSessionFactory = builder.build(in);

public class DefaultListableBeanFactory extends ... implements ... {
  //存储<bean>标签对应的BeanDefinition对象
  //key:是Bean的beanName，value:是Bean定义对象BeanDefinition
  private final Map<String, BeanDefinition> beanDefinitionMap;
} 

public class DefaultSingletonBeanRegistry extends ... implements ... {
  //存储Bean实例的单例池
  ////key:是Bean的beanName，value:是Bean的实例对象
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
}

public interface BeanFactoryPostProcessor {
  void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory);
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException{
    System.out.println("MyBeanFactoryPostProcessor执行了...");
  }
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    BeanDefinition userDaoBD = beanFactory.getBeanDefinition(“userDao”);//获得UserDao定义对象
    userDaoBD.setBeanClassName("com.itheima.dao.impl.UserDaoImpl2"); //修改class
    //userDaoBD.setInitMethodName(methodName); //修改初始化方法
    //userDaoBD.setLazyInit(true); //修改是否懒加载
    //... 省略其他的设置方式 ...
  }
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    //强转成子类DefaultListableBeanFactory
    if(configurableListableBeanFactory instanceof DefaultListableBeanFactory){
      DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) 
      configurableListableBeanFactory;
      BeanDefinition beanDefinition = new RootBeanDefinition();
      beanDefinition.setBeanClassName("com.itheima.dao.UserDaoImpl2");
      //进行注册操作
      beanFactory.registerBeanDefinition("userDao2",beanDefinition);
    }
  }
}

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {}
  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
    BeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClassName("com.itheima.dao.UserDaoImpl2");
    beanDefinitionRegistry.registerBeanDefinition("userDao2",beanDefinition);
  }
}

public interface BeanPostProcessor {
  @Nullable
  //在属性注入完毕，init初始化方法执行之前被回调
  default Object postProcessBeforeInitialization(Object bean, String beanName) throws 
BeansException {
    return bean;
  }
  @Nullable
  //在初始化方法执行之后，被添加到单例池singletonObjects之前被回调
  default Object postProcessAfterInitialization(Object bean, String beanName) throws 
BeansException {
    return bean;
  }
}

public class UserServiceImpl implements UserService{
  public void setUserDao(UserDao userDao) {}
}
public class UserDaoImpl implements UserDao{
  public void setUserService(UserService userService){}
}

public class DefaultSingletonBeanRegistry ... {
  //1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存"
  Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
  //2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为"二级缓存"
  Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
  //3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为"三级缓存"
  Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
}

public interface UserMapper {
  List<User> findAll();
}

ClassPathxmlApplicationContext applicationContext =
    new ClassPathxmlApplicationContext("applicationContext.xml");
UserMapper userMapper = applicationContext.getBean(UserMapper.class);
List<User> all = userMapper.findAll();
System.out.println(all);

SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean{
  public void afterPropertiesSet() throws Exception {
    //创建SqlSessionFactory对象
    this.sqlSessionFactory = this.buildSqlSessionFactory();
  }
  public SqlSessionFactory getObject() throws Exception {
    return this.sqlSessionFactory;
  }
}

class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean{
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
  }
}

class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
    } else {
      this.processBeanDefinitions(beanDefinitions);
    }
  }
  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    //设置Mapper的beanClass是org.mybatis.spring.mapper.MapperFactoryBean
    definition.setBeanClass(this.mapperFactoryBeanClass);
    definition.setAutowireMode(2); //设置MapperBeanFactory 进行自动注入
  }
}

class ClassPathBeanDefinitionScanner{
  public int scan(String... basePackages) {
    this.doScan(basePackages);
  }
  protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //将扫描到的类注册到beanDefinitionMap中，此时beanClass是当前类全限定名
    this.registerBeanDefinition(definitionHolder, this.registry);
    return beanDefinitions;
  }
}

UserMapper userMapper = applicationContext.getBean(UserMapper.class);

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
  public MapperFactoryBean(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }
  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    this.sqlSessionTemplate = this.createSqlSessionTemplate(sqlSessionFactory);
  }
  public T getObject() throws Exception {
    return this.getSqlSession().getMapper(this.mapperInterface);
  }
}

//如果是默认命名空间
if (delegate.isDefaultNamespace(ele)) {
  this.parseDefaultElement(ele, delegate);
//否则是自定义命名空间
} else {
  delegate.parseCustomElement(ele);
}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
  if (delegate.nodeNameEquals(ele, "import")) {
    this.importBeanDefinitionResource(ele);
  } else if (delegate.nodeNameEquals(ele, "alias")) {
    this.processAliasRegistration(ele);
  } else if (delegate.nodeNameEquals(ele, "bean")) {
    this.processBeanDefinition(ele, delegate);
  } else if (delegate.nodeNameEquals(ele, "beans")) {
    this.doRegisterBeanDefinitions(ele);
  }
}

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
  //解析命名空间
  String namespaceUri = this.getNamespaceURI(ele);
  //获得命名空间解析器
  NamespaceHandler handler =    this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
  //解析执行的标签
  return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

public class ContextNamespaceHandler extends NamespaceHandlerSupport {
  public ContextNamespaceHandler() {
}
  public void init() {
    this.registerBeanDefinitionParser("property-placeholder", new 
PropertyPlaceholderBeanDefinitionParser());
    this.registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
    this.registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
    this.registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
    this.registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
    this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    this.registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
    this.registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
  }
}

public class HaohaoNamespaceHandler extends NamespaceHandlerSupport {
  @Override
  public void init() {
    this.registerBeanDefinitionParser("annotation-driven",new HaohaoBeanDefinitionParser());
  }
}

public class HaohaoBeanDefinitionParser implements BeanDefinitionParser {
  public BeanDefinition parse(Element element, ParserContext parserContext) {
    //创建HaohaoBeanPostProcessor的BeanDefinition
    RootBeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClass(HaohaoBeanPostProcessor.class);
    //注册HaohaoBeanPostProcessor
parserContext.getRegistry().registerBeanDefinition("haohaoBeanPostProcessor",beanDefinition);
    return beanDefinition;
}}

public class HaohaoBeanPostProcessor implements BeanPostProcessor {
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws 
BeansException {
     System.out.println("自动注入HaohaoBeanPostProcessor成功");
     return bean;
  }
}

//获取方式：applicationContext.getBean("userDao");
@Component("userDao")
public class UserDaoImpl implements UserDao {
}
//获取方式：applicationContext.getBean("userDaoImpl");
@Component
public class UserDaoImpl implements UserDao {
}

//匹配当前Bean
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}

@Autowired
@Qualifier("userDao2")
private UserDao userDao;

@Autowired
@Qualifier("userDao2")
public void setUserDao(UserDao userDao){
  System.out.println(userDao);
}

@Resource
private UserDao userDao;

@Resource(name = "userDao2")
public void setUserDao(UserDao userDao){
  System.out.println(userDao);
}

//将方法返回值Bean实例以@Bean注解指定的名称存储到Spring容器中
@Bean("dataSource")
public DataSource dataSource(){
  DruidDataSource dataSource = new DruidDataSource();
  dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
  dataSource.setUsername("root");
  dataSource.setPassword("root");
  return dataSource;
}

@Bean
@Autowired //根据类型匹配参数
public Object objectDemo01(UserDao userDao){
  System.out.println(userDao);
  return new Object();
}
@Bean
public Object objectDemo02(@Qualifier("userDao") UserDao userDao,
@Value("${jdbc.username}") String username){
  System.out.println(userDao);
  System.out.println(username);
  return new Object();
}

@Configuration
public class ApplicationContextConfig {}

@Configuration
@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class ApplicationContextConfig {}

@Configuration
@ComponentScan
@PropertySource({"classpath:jdbc.properties","classpath:xxx.properties"})
public class ApplicationContextConfig {}

@Configuration
@ComponentScan
@PropertySource("classpath:jdbc.properties")
@Import(OtherConfig.class)
public class ApplicationContextConfig {}

@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
@Primary
public class UserDaoImpl2 implements UserDao{}

@Configuration
@ComponentScan("com.itheima")
@MapperScan("com.itheima.mapper")
public class ApplicationContextConfig {
  @Bean
  public DataSource dataSource(){
    DruidDataSource dataSource = new DruidDataSource();
    //省略部分代码
    return dataSource;}
  @Bean
  public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
    SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(dataSource);
    return sqlSessionFactoryBean;
}}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MapperScannerRegistrar.class})
@Repeatable(MapperScans.class)
public @interface MapperScan {
  String[] value() default {};
  String[] basePackages() default {};
  Class<?>[] basePackageClasses() default {};
  Class<? extends Annotation> annotationClass() default Annotation.class;
  // ... ...
}

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, 
ResourceLoaderAware {
  //默认执行registerBeanDefinitions方法
  void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry, String beanName) {
    BeanDefinitionBuilder builder = 
    BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    //... 省略其他代码 ...
    //注册BeanDefinition
     registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
  }
}

@Configuration
@ComponentScan("com.itheima")
@Import({MyImportSelector.class})
public class ApplicationContextConfig {
}

public class MyImportSelector implements ImportSelector {
  @Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //返回要进行注册的Bean的全限定名数组
    return new String[]{User2.class.getName()};
  }
}

public class MyImportSelector implements ImportSelector {
  @Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //获得指定类型注解的全部信息
    Map<String, Object> annotationAttributes = 
annotationMetadata.getAnnotationAttributes(ComponentScan.class.getName());
    //获得全部信息中basePackages信息
    String[] basePackages = (String[]) annotationAttributes.get("basePackages");
    //打印结果是com.itheima
    System.out.println(basePackages[0]);
    return new String[]{User2.class.getName()};
  }
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
BeanDefinitionRegistry registry) {
    //使用给定的BeanDefinitionRegistry参数，手动注册BeanDefinition
    BeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClassName("com.itheima.pojo.User2");
    registry.registerBeanDefinition("user2",beanDefinition);
  }
}