public class BeanScopeModel {
    public BeanScopeModel(String beanScope) {
        System.out.println(String.format("create beanScopeModel，[scope = %s],[this = %s]", beanScope, this));
    }
}

public class BeanScopeModelController {
    public static void main(String[] args) {
        System.out.println("spring容器准备启动...");
        String beanXml = "classpath:/spring/applicationContext.xml";
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(beanXml);
        System.out.println("spring容器启动完成...");
        System.out.println("开始从容器中获取bean...");
        BeanScopeModel beanScopeModel1 = applicationContext.getBean("singletonBean", BeanScopeModel.class);
        BeanScopeModel beanScopeModel2 = applicationContext.getBean("singletonBean", BeanScopeModel.class);
        BeanScopeModel beanScopeModel3 = applicationContext.getBean("singletonBean", BeanScopeModel.class);
        System.out.println(String.format("beanScopeModel1 == beanScopeModel2 ? %s",(beanScopeModel1 == beanScopeModel2)));
        System.out.println(String.format("beanScopeModel1 == beanScopeModel3 ? %s",(beanScopeModel1 == beanScopeModel3)));
        System.out.println("从容器中获取bean结束...");
    }
}

package org.springframework.beans.factory.config;
import org.springframework.beans.factory.ObjectFactory;
public interface Scope {
    // 返回当前作用域中name对应的bean对象
    // name：需要检索的bean的名称
    // objectFactory：如果name对应的bean在当前作用域中没有找到，那么可以调用ObjectFactory来创建这个对象
    Object get(String name, ObjectFactory<?> objectFactory);
    // 将name对应的bean从当前作用域中移除
    Object remove(String name);
    // 用于注册销毁回调，如果想要销毁相应的对象，则由spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象
    void registerDestructionCallback(String name, Runnable callback);
    // 用于解析相应的上下文数据，比如request作用域将返回request中的属性
    Object resolveContextualObject(String var1);
    // 作用域的会话标识，比如session作用域将是sessionId
    String getConversationId();
}

// 向容器中注册自定义的scope
// scopeName：自定义的scope名称
// scope：自定义的scope对象
void registerScope(String scopeName, Scope scope);

package com.zeh.main.scope;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
 * 功能描述 自定义本地线程级别的bean scope，不同的线程对象中的bean实例是不同的，同一个线程对象中的同名bean实例是同一个实例。
 *
 * @since 2021-05-07
 */
public class ThreadScope implements Scope {
    // 定义一个常量，表示当前自定义作用域的名称，在定义bean的时候可以给scope属性使用
    public static final String THREAD_SCOPE = "thread";
    // 定义一个ThreadLocal成员，用来作为每个线程对象中的缓存容器
    private ThreadLocal<Map<String, Object>> beanMap = new ThreadLocal() {
        @Override
        protected Map<String, Object> initialValue() {
            return new HashMap<String, Object>();
        }
    };
    @Override
    public Object get(String s, ObjectFactory<?> objectFactory) {
        Object object = beanMap.get().get(s);
        if (Objects.isNull(object)) {
            object = objectFactory.getObject();
            beanMap.get().put(s, object);
        }
        return object;
    }
    @Override
    public Object remove(String s) {
        return this.beanMap.get().remove(s);
    }
    @Override
    public void registerDestructionCallback(String s, Runnable runnable) {
        // bean作用域结束的时候调用该方法，用于bean清理
        System.out.println("当前bean的作用域结束，bean is " + s);
    }
    @Override
    public Object resolveContextualObject(String s) {
        return null;
    }
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }
}

package com.zeh.main.pojo;
public class BeanScopeModel {
    public BeanScopeModel(String beanScope) {
        System.out.println(String.format("线程:%s create beanScopeModel，[scope = %s],[this = %s]", Thread.currentThread(), beanScope, this));
    }
}

package com.zeh.main.controller;
import com.zeh.main.scope.ThreadScope;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.concurrent.TimeUnit;

public class BeanScopeModelController {
    public static void main(String[] args) throws InterruptedException {
        String beanXml = "classpath:/spring/applicationContext.xml";
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();
        // 设置配置文件位置
        applicationContext.setConfigLocation(beanXml);
        // 启动容器
        applicationContext.refresh();
        // 向容器中注册自定义的scope
        applicationContext.getBeanFactory().registerScope(ThreadScope.THREAD_SCOPE, new ThreadScope());
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread() + ";" + applicationContext.getBean("threadBean"));
                System.out.println(Thread.currentThread() + ";" + applicationContext.getBean("threadBean"));
            }).start();
            TimeUnit.SECONDS.sleep(1);
        }
    }
}