/**
 * 通过 {@link org.springframework.beans.factory.ObjectProvider} 进行依赖查找
 */
public class ObjectProviderDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(ObjectProviderDemo.class);
        applicationContext.refresh();
        lookupByObjectProvider(applicationContext);
        applicationContext.close();
    }

    @Bean
    public String helloWorld() {
        return "Hello World";
    }
    private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
        System.out.println(objectProvider.getObject());
    }
}

public class HierarchicalDependencyLookupDemo {


    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();

        HierarchicalBeanFactory parentBeanFactory = createParentBeanFactory();

        beanFactory.setParentBeanFactory(parentBeanFactory);

        displayContainsLocalBean(beanFactory, "user"); //false
        displayContainsLocalBean(parentBeanFactory, "user"); //true
        
        displayContainsBean(beanFactory, "user"); //true
        displayContainsBean(parentBeanFactory,"user");//true

        applicationContext.refresh();
        applicationContext.close();
    }


    private static void displayContainsBean(HierarchicalBeanFactory beanFactory, String beanName) {
        System.out.printf("当前 BeanFactory [%s] 是否包含  bean[name:%s]  %s\n", beanFactory, beanName, containsBean(beanFactory,beanName));

    }

    private static boolean containsBean(HierarchicalBeanFactory beanFactory, String beanName) {
        BeanFactory parentBeanFactory = beanFactory.getParentBeanFactory();
        if (parentBeanFactory instanceof HierarchicalBeanFactory) {
            HierarchicalBeanFactory parentHierarchicalBeanFactory = HierarchicalBeanFactory.class.cast(parentBeanFactory);
            if (containsBean(parentHierarchicalBeanFactory, beanName)) {
                return true;
            }
        }
        return beanFactory.containsLocalBean(beanName);
    }

    private static void displayContainsLocalBean(HierarchicalBeanFactory parentBeanFactory, String user) {
        System.out.printf("当前 BeanFactory [%s] 是否包含 Local bean[name:%s]  %s\n", parentBeanFactory, user, parentBeanFactory.containsLocalBean(user));
    }

    private static HierarchicalBeanFactory createParentBeanFactory() {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        String location = "classpath:applicationContext-lookup.xml";
        reader.loadBeanDefinitions(location);
        return beanFactory;
    }
}

/**
 * 通过 {@link org.springframework.beans.factory.ObjectProvider} 进行依赖查找
 */
public class ObjectProviderDemo {


    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(ObjectProviderDemo.class);
        applicationContext.refresh();

        lookupByObjectProvider(applicationContext);
        lookupIfAvailable(applicationContext);
        lookupByStream(applicationContext);
        applicationContext.close();
    }

    private static void lookupByStream(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
//        Iterator<String> iterator = objectProvider.iterator();
//        while(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        objectProvider.stream().forEach(System.out::println);
    }

    private static void lookupIfAvailable(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<User> userObjectProvider = applicationContext.getBeanProvider(User.class);
        User user = userObjectProvider.getIfAvailable(User::new);
        System.out.println(user);

    }

    @Bean
    @Primary
    public String helloWorld() {
        return "Hello World";
    }

    @Bean
    public String message(){
        return "message";
    }

    private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
        System.out.println(objectProvider.getObject());
    }
}

import com.github.springframework.models.User;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TypeSafetyDependencyLookupDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(TypeSafetyDependencyLookupDemo.class);
        applicationContext.refresh();

        displayBeanFactoryGetBean(applicationContext);
        displayObjectFactoryGetObject(applicationContext);
        displayObjectProviderIfAvailable(applicationContext);

        displayListableBeanFactoryGetBeansOfType(applicationContext);

        displayObjectProviderStreamOps(applicationContext);
        applicationContext.close();
    }

    public static void displayObjectProviderStreamOps(AnnotationConfigApplicationContext beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectProviderStreamOps", ()->userObjectFactory.forEach(System.out::println));
    }

    public static void displayListableBeanFactoryGetBeansOfType(ListableBeanFactory beanFactory){
        printException("displayListableBeanFactoryGetBeansOfType", ()->beanFactory.getBeansOfType(User.class));
    }

    public static void displayObjectProviderIfAvailable(BeanFactory beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectProviderIfAvailable", ()->userObjectFactory.getIfAvailable());
    }

    public static void displayObjectFactoryGetObject(BeanFactory beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectFactoryGetObject", ()->userObjectFactory.getObject());
    }

    public static void displayBeanFactoryGetBean(BeanFactory beanFactory){
        printException("displayBeanFactoryGetBean",()->beanFactory.getBean(User.class));
    }

    public static void printException(String source, Runnable run){
        System.out.println("Source From : " + source);
        System.out.println("======================================");
        try{
            run.run();
        }catch (BeansException e){
            e.printStackTrace();
        }
    }
}

        //bean definition builder.
BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);

beanDefinitionBuilder.addPropertyValue("id",1L);
beanDefinitionBuilder.addPropertyValue("name","lisi");

BeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();

GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
genericBeanDefinition.setBeanClass(User.class);

MutablePropertyValues propertyValues = new MutablePropertyValues();
//        propertyValues.addPropertyValue("id",2L);
//        propertyValues.addPropertyValue("name","zhaowu");

propertyValues.add("id",2L)
        .add("name","zhaowu");
genericBeanDefinition.setPropertyValues(propertyValues);

/**
 * Generate a bean name for the given bean definition, unique within the
 * given bean factory.
 * @param definition the bean definition to generate a bean name for
 * @param registry the bean factory that the definition is going to be
 * registered with (to check for existing bean names)
 * @param isInnerBean whether the given bean definition will be registered
 * as inner bean or as top-level bean (allowing for special name generation
 * for inner beans versus top-level beans)
 * @return the generated bean name
 * @throws BeanDefinitionStoreException if no unique name can be generated
 * for the given bean definition
 */
public static String generateBeanName(
        BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
        throws BeanDefinitionStoreException {

    String generatedBeanName = definition.getBeanClassName();
    if (generatedBeanName == null) {
        if (definition.getParentName() != null) {
            generatedBeanName = definition.getParentName() + "$child";
        }
        else if (definition.getFactoryBeanName() != null) {
            generatedBeanName = definition.getFactoryBeanName() + "$created";
        }
    }
    if (!StringUtils.hasText(generatedBeanName)) {
        throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
                "'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
    }

    String id = generatedBeanName;
    if (isInnerBean) {
        // Inner bean: generate identity hashcode suffix.
        id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
    }
    else {
        // Top-level bean: use plain class name with unique suffix if necessary.
        return uniqueBeanName(generatedBeanName, registry);
    }
    return id;
}

/**
 * Turn the given bean name into a unique bean name for the given bean factory,
 * appending a unique counter as suffix if necessary.
 * @param beanName the original bean name
 * @param registry the bean factory that the definition is going to be
 * registered with (to check for existing bean names)
 * @return the unique bean name to use
 * @since 5.1
 */
public static String uniqueBeanName(String beanName, BeanDefinitionRegistry registry) {
    String id = beanName;
    int counter = -1;

    // Increase counter until the id is unique.
    while (counter == -1 || registry.containsBeanDefinition(id)) {
        counter++;
        id = beanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
    }
    return id;
}

@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    if (definition instanceof AnnotatedBeanDefinition) {
        String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
        if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            return beanName;
        }
    }
    // Fallback: generate a unique default bean name.
    return buildDefaultBeanName(definition, registry);
}

/**
 * Derive a default bean name from the given bean definition.
 * <p>The default implementation simply builds a decapitalized version
 * of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".
 * <p>Note that inner classes will thus have names of the form
 * "outerClassName.InnerClassName", which because of the period in the
 * name may be an issue if you are autowiring by name.
 * @param definition the bean definition to build a bean name for
 * @return the default bean name (never {@code null})
 */
protected String buildDefaultBeanName(BeanDefinition definition) {
    String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    String shortClassName = ClassUtils.getShortName(beanClassName);
    return Introspector.decapitalize(shortClassName);
}

public class AnnotationBeanDefinitionDemo {


    public static void main(String[] args) {

        //create factory bean
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        //register config class.
        applicationContext.register(Config.class);

        //refresh
        applicationContext.refresh();

        //getUser
        System.out.println(applicationContext.getBean(User.class));
    }



    static class Config{
        @Bean
        public User user(){
            User user = new User();
            user.setId(1L);
            user.setName("Ann: zhangsan");
            return user;
        }
    }
}

public class AnnotationBeanDefinitionDemo {
    public static void main(String[] args) {
        //create factory bean
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        //register config class.
        applicationContext.register(Config.class);

        //refresh
        applicationContext.refresh();

        //
        System.out.println(applicationContext.getBean(Config.class));
    }
    @Component
    static class Config{
        @Bean
        public User user(){
            User user = new User();
            user.setId(1L);
            user.setName("Ann: zhangsan");
            return user;
        }
    }
}

static void beanDefinitionRegistry(BeanDefinitionRegistry registry, String name) {
    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
    beanDefinitionBuilder.addPropertyValue("id", 1L)
            .addPropertyValue("name", "Reg: zhangsan");
    if (StringUtils.hasText(name)) {
        registry.registerBeanDefinition(name, beanDefinitionBuilder.getBeanDefinition());
    } else {
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinitionBuilder.getBeanDefinition(),registry);
    }
}

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.register(Config.class);
beanDefinitionRegistry(applicationContext,"REG:ZhangSan:Name");
beanDefinitionRegistry(applicationContext,null);
applicationContext.refresh();
System.out.println(applicationContext.getBeansOfType(Config.class));
System.out.println(applicationContext.getBeansOfType(User.class));
System.out.println(applicationContext.getBeansOfType(AnnotationApplicationContextDemo.class));

public class User2 {

    private Long id;

    private String name;
    
    public static User2 getInstance(){
        return new User2();
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");

User2 user = applicationContext.getBean("user-by-static-method", User2.class);

public interface UserFactory {
    default User2 createuser() {
        return new User2();
    }
}

public class DefaultUserFactory implements UserFactory {
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");
User2 user3 = applicationContext.getBean("user-by-instance-method", User2.class);

public class UserFactoryBean implements FactoryBean<User2> {

    @Override
    public User2 getObject() throws Exception {
        return User2.getInstance();
    }

    @Override
    public Class<?> getObjectType() {
        return User2.class;
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");
User2 user2 = applicationContext.getBean("user-by-factory-method", User2.class);

public static void demoServiceLoader() {
    ServiceLoader<UserFactory> serviceLoader = ServiceLoader.load(UserFactory.class, Thread.currentThread().getContextClassLoader());
    displayServiceLoad(serviceLoader);
}

public static void displayServiceLoad(ServiceLoader<UserFactory> serviceLoader) {
    Iterator<UserFactory> iterator = serviceLoader.iterator();
    while (iterator.hasNext()) {
        UserFactory userFactory = iterator.next();
        System.out.println(userFactory.createuser());
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/sp-bean-creation-context.xml");
ServiceLoader<UserFactory> serviceLoader = applicationContext.getBean("userFactoryServiceLoader", ServiceLoader.class);
displayServiceLoad(serviceLoader);

AutowireCapableBeanFactory beanFactory = applicationContext.getAutowireCapableBeanFactory();
UserFactory userFactory = beanFactory.createBean(DefaultUserFactory.class);
System.out.println(userFactory.createuser());

public class DefaultUserFactory implements UserFactory, InitializingBean {

    public DefaultUserFactory() {
        System.out.println("DefaultUserFactory Constructor Called.");
    }

    @PostConstruct
    public void init(){
        System.out.println("DefaultUserFactory PostConstructor Called.");
    }

    public void initUserFactory(){
        System.out.println("DefaultUserFactory initUserFactory Called.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("DefaultUserFactory afterPropertiesSet called.");
    }
}

@Configuration
public class BeanInitializationDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(BeanInitializationDemo.class);
        applicationContext.refresh();
        UserFactory userFactory = applicationContext.getBean(UserFactory.class)
        System.out.println(userFactory.createuser());
        applicationContext.close();
    }

    @Bean(initMethod = "initUserFactory")
    public DefaultUserFactory userFactory(){
        return new DefaultUserFactory();
    }
}

UserFactory userFactory = new DefaultUserFactory();
ConfiguableListableBeanFactory factory = applicationContext.getBeanFactory();
factory.registerSingleton("userFactory", userFactory);

UserFactory userFactory = applicationContext.getBean("UserFactory",UserFactory.class);