@Slf4j
@Component
@RequestScope
public class RequestScopeEntity {

    public RequestScopeEntity() {
        log.info("############ Create RequestScopeEntity ############");
    }

    public void doRequestBusiness() {
        log.info(Thread.currentThread() + " do current request business");
    }
}

@Slf4j
@RestController
@RequestMapping("scope2")
public class ScopeController2 {

    /**
     * 实际注入的是 Spring CGLIB 为 RequestScopeEntity 创建的一个代理对象，
     * 可以通过打印该对象的 Class 对象的名称来验证，针对每个请求，都会创建一个
     * 实际的 RequestScopeEntity 对象，然后将对这个代理对象方法的调用委托给
     * 新创建的 RequestScopeEntity 对象
     */
    @Autowired
    private RequestScopeEntity requestScopeEntity;

    @GetMapping("user")
    public String userInfo() {
        requestScopeEntity.doRequestBusiness();
        int scopeEntityHash = requestScopeEntity.hashCode();
        log.info("[scope2], requestScopeEntity:[{}], class:[{}]", scopeEntityHash, requestScopeEntity.getClass().getSimpleName());
        return scopeEntityHash;
    }
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {

	/**
	 * The set of profiles for which the annotated component should be registered.
	 */
	String[] value();

}

class ProfileCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		if (context.getEnvironment() != null) {
			MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
			if (attrs != null) {
                // 获取 @Profile 注解中的 value 属性值，即 bean 定义时指定所属的 profiles
				for (Object value : attrs.get("value")) {
                    // 判断是否激活
					if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
						return true;
					}
				}
				return false;
			}
		}
		return true;
	}

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Profile("production")
public @interface Production {
    
}

ConfigurableApplicationContext ctx = new GenericApplicationContext();

// MutablePropertySources api exposes a number of methods that allow for precise manipulation of the set of property sources
MutablePropertySources sources = ctx.getEnvironment().getPropertySources();

// MyPropertySource is a custom PropertySource implementation
sources.addFirst(new MyPropertySource());

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(PropertySources.class) // 允许重复使用
public @interface PropertySource {
    
	String name() default "";

	String[] value();

	boolean ignoreResourceNotFound() default false;

	String encoding() default "";

	Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;
}

@Configuration
@PropertySource("classpath:/com/myco/${spring.profiles.active:st}/app.properties")
public class AppConfig {

    @Autowired
    Environment env;

    @Bean
    public TestBean testBean() {
        TestBean testBean = new TestBean();
        testBean.setName(env.getProperty("testbean.name"));
        return testBean;
    }
}

@Override
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);

               /* 
               *
               *  在这里处理 PropertySource 
               *
               */
			// 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) {
			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;
		}
	}
}

@Component
public class FactoryMethodComponent {

    // 定义 bean，其它方法级别的 Spring 注解也可以指定在这里，如 @Lazy，@Scope
    @Bean
    @Qualifier("public")
    public TestBean publicInstance() {
        return new TestBean("publicInstance");
    }
    
    // 正常的 Spring 组件方法
    public void doWork() {
        // Component method implementation omitted
    }
}

package com.example.springboot.demo.component;

import com.example.springboot.demo.entity.UserInfo;
import org.springframework.beans.factory.InjectionPoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;

/**
 * @author guo
 * @date 2021/7/10
 */
@Component
public class FactoryMethodComponent {

    /**
     * 声明一个 InjectionPoint（或者是子类 DependencyDescriptor）类型的对象作为工厂方法的参数，可以用来访问
     * 触发当前 bean 创建的注入点, 但是这只适用于 bean 实例实际的创建，而不是对已存在实例的注入。所以在 prototype bean
     * 的场景下意义比较大
     *
     * @param injectionPoint
     * @return
     */
    @Bean
    @Scope("prototype")
    public UserInfo userInfo(InjectionPoint injectionPoint) {
        System.out.println("prototype instance for " + injectionPoint.getMember());
        return new UserInfo();
    }

    @Bean
    public PropertiesFactoryBean overrideProperties(@Autowired ResourceLoader resourceLoader,
                                                    @Autowired UserInfo userInfo) {

        System.out.println("inject userInfo from overrideProperties:" + userInfo.hashCode());

        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(resourceLoader.getResource("classpath:override.properties"));
        propertiesFactoryBean.setFileEncoding("UTF-8");
        return propertiesFactoryBean;
    }

    @Bean
    public PropertiesFactoryBean applicationProperties(@Autowired ResourceLoader resourceLoader,
                                                       @Autowired UserInfo userInfo) {

        System.out.println("inject userInfo from applicationProperties:" + userInfo.hashCode());
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(resourceLoader.getResource("classpath:application.properties"));
        propertiesFactoryBean.setFileEncoding("UTF-8");
        return propertiesFactoryBean;
    }

}

prototype instance for public org.springframework.beans.factory.config.PropertiesFactoryBean com.example.springboot.demo.component.FactoryMethodComponent.overrideProperties(org.springframework.core.io.ResourceLoader,com.example.springboot.demo.entity.UserInfo)

inject userInfo from overrideProperties:542895457

prototype instance for public org.springframework.beans.factory.config.PropertiesFactoryBean com.example.springboot.demo.component.FactoryMethodComponent.applicationProperties(org.springframework.core.io.ResourceLoader,com.example.springboot.demo.entity.UserInfo)

inject userInfo from applicationProperties:2049646260

@Configuration
public class AppConfig {

    @Bean
    public BeanOne beanOne() {
        return new BeanOne(beanTwo());
    }

    @Bean
    public BeanTwo beanTwo() {
        return new BeanTwo();
    }
}

/**
 * {@link EnableAutoConfiguration Auto-configuration} for
 * {@link PropertySourcesPlaceholderConfigurer}.
 *
 * @author Phillip Webb
 * @author Dave Syer
 * @since 1.5.0
 */
@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class PropertyPlaceholderAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
	public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
		return new PropertySourcesPlaceholderConfigurer();
	}

}

List<String> collectResult = IntStream.rangeClosed(1, 20)
        .mapToObj(String::valueOf)
        .collect(
    			// 这里可以替换为 Collectors.toList(), 这里是为了打印每个函数执行线程的上下文
                Collector.of(
                        () -> {
                            List<String> strings = new ArrayList<>();
                            System.out.println(Thread.currentThread() + " create supplier ");
                            return strings;
                        }, (l, e) -> {
                            System.out.println(Thread.currentThread() + " accumulate " + e);
                            l.add(e);
                        }, (left, right) -> {
                            System.out.println(Thread.currentThread() + " combine");
                            left.addAll(right);
                            return left;
                        }, Collector.Characteristics.IDENTITY_FINISH));

List<String> collectResult = IntStream.rangeClosed(1, 20)
        .mapToObj(String::valueOf)
        .parallel()
        .collect(
                Collector.of(
                        () -> {
                            ArrayList<String> strings = new ArrayList<>();
                            System.out.println(Thread.currentThread() + " create supplier ");
                            return strings;
                        }, (l, e) -> {
                            System.out.println(Thread.currentThread() + " accumulate " + e);
                            l.add(e);
                        }, (left, right) -> {
                            System.out.println(Thread.currentThread() + " combine");
                            left.addAll(right);
                            return left;
                        }, Collector.Characteristics.IDENTITY_FINISH));

List<String> collectResult = IntStream.rangeClosed(1, 20)
        .parallel()
        .mapToObj(String::valueOf)
        .collect(
                Collector.of(
                        () -> {
                            CopyOnWriteArrayList<String> strings = new CopyOnWriteArrayList<>();
                            System.out.println(Thread.currentThread() + " create supplier ");
                            return strings;
                        }, (l, e) -> {
                            System.out.println(Thread.currentThread() + " accumulate " + e);
                            l.add(e);
                        }, (left, right) -> {
                            System.out.println(Thread.currentThread() + " combine");
                            left.addAll(right);
                            return left;
                        }, Collector.Characteristics.IDENTITY_FINISH,
                        Collector.Characteristics.CONCURRENT,
                        Collector.Characteristics.UNORDERED));

while (true) {
    List<String> collectResult = IntStream.rangeClosed(1, 20)
            .parallel()
            .mapToObj(String::valueOf)
            .collect(
                    Collector.of(
                            () -> {
                                // 使用 ArrayList 作为中间结果容器
                                List<String> strings = new ArrayList<>();
                                System.out.println(Thread.currentThread() + " create supplier ");
                                return strings;
                            }, (l, e) -> {
                                System.out.println(Thread.currentThread() + " accumulate " + e);
                                l.add(e);
                            }, (left, right) -> {
                                System.out.println(Thread.currentThread() + " combine");
                                left.addAll(right);
                                return left;
                            }, Collector.Characteristics.IDENTITY_FINISH,
                            Collector.Characteristics.CONCURRENT,
                            Collector.Characteristics.UNORDERED));

    // ArrayList 并发修改,可能会引起某个元素为 Null
    if (collectResult.stream().anyMatch(Objects::isNull)) {
        System.err.println("ERROR Null Element");
        break;
    }
}

List<String> l = new ArrayList(Arrays.asList("one", "two"));
Stream<String> sl = l.stream();
l.add("three");
String s = sl.collect(joining(" ")); // 最终 s 的结果为 'one two three'

Set<Integer> seen = Collections.synchronizedSet(new HashSet<>());

stream.parallel().map(e -> { if (seen.add(e)) return 0; else return e; })...

ArrayList<String> results = new ArrayList<>();
    stream.filter(s -> pattern.matcher(s).matches())
          .forEach(s -> results.add(s));  // Unnecessary use of side-effects!

// 运行在并行流的情况下, ArrayList 不是线程安全的, 会导致不正确的结果或者抛出异常, 添加同步机制,会导致数据竞争

     List<String>results =
         stream.filter(s -> pattern.matcher(s).matches())
               .collect(Collectors.toList());  // No side-effects!
// 使用无副作用的 toList 收集器, 更安全