Spring加载bean配置文件的schemas文件（懒加载）

曾经终败给现在 2021-09-28 20:46 774阅读 0赞

最近在调试Spring源码时，看到加载Spring的xml文件-schema部分，

里面使用了懒加载的写法（PluggableSchemaResolver的getSchemaMappings方法）

为了能更好理解这个懒加载（里面获取到的Map是单例的），我依葫芦画瓢，写了一个简化版的懒汉式单例（采用双重检查锁）。

下面是类以及单元测试

  1. import java.util.HashMap;
  2. import java.util.Map;
  4. /**
  5.  * Created by shucheng on 2019-5-31 上午 10:24
  6.  */
  7. public class MySchema {
  9.     public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";
  11.     private final ClassLoader classLoader;
  13.     private String schemaMappingsLocation;
  15.     private Map<String, String> schemaMappings;
  17.     public MySchema(ClassLoader classLoader) {
  18.         this.classLoader = classLoader;
  19.         this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
  20.     }
  22.     public Map<String, String> getSchemaMappings() {
  23.         Map<String, String> schemaMappings = this.schemaMappings;
  24.         // 如果schemaMappings不为null，则直接返回数据，不需要重新创建对象
  25.         if (schemaMappings == null) {
  26.             // System.out.println("线程" + Thread.currentThread().getName() + "进入if判断");
  27.             synchronized (this) {
  28.                 // System.out.println("线程" + Thread.currentThread().getName() + "进入同步锁");
  29.                 // System.out.println("线程" + Thread.currentThread().getName() + "\n" +
  30.                         "schemaMappings=====" + (schemaMappings != null ? schemaMappings.hashCode() : null) + "\n" +
  31.                         "this.schemaMappings=====" + (this.schemaMappings != null ? this.schemaMappings.hashCode() : null));
  33.                 schemaMappings = this.schemaMappings;
  34.                 if (schemaMappings == null) {
  35.                     System.out.println("开始加载schemaMappingsLocation");
  36.                     Map<String, String> map = new HashMap();
  37.                     map.put("1", "张三");
  38.                     map.put("2", "李四");
  39.                     map.put("3", "王五");
  40.                     map.put("4", "赵六");
  41.                     map.put("5", "钱七");
  43.                     schemaMappings = new HashMap<>();
  44.                     schemaMappings.putAll(map);
  45.                     System.out.println("schemaMappingsLocation加载中");
  47.                     this.schemaMappings = schemaMappings;
  48.                     System.out.println("schemaMappingsLocation加载完成");
  49.                 }
  50.             }
  51.         }
  52.         // System.out.println("线程" + Thread.currentThread().getName() + "======class为" + schemaMappings.getClass().hashCode() + "=====" + schemaMappings);
  53.         return schemaMappings;
  54.     }
  56.     @Override
  57.     public String toString() {
  58.         return "MySchema{" +
  59.                 "schemaMappings=" + getSchemaMappings() +
  60.                 '}';
  61.     }
  62. }
  64. import org.junit.Test;
  66. import java.util.Map;
  68. /**
  69.  * Created by shucheng on 2019-5-31 上午 10:23
  70.  */
  71. public class MyTest {
  73.     // 简单测试
  74.     @Test
  75.     public void test() {
  76.         MySchema m = new MySchema(getClass().getClassLoader());
  77.         System.out.println(m);
  78.         // System.out.println(m.toString());
  79.     }
  81.     // 模拟多线程（3个线程）测试
  82.     // 参考链接：https://www.jb51.net/article/130924.htm
  83.     // 另外还参考了MyBatis3.5.1源码里的单元测试org.apache.ibatis.io.VFSTest#getInstanceShouldNotBeNullInMultiThreadEnv
  84.     @Test
  85.     public void testMultiThread() {
  86.         final int threadCount = 20;
  87.         Thread[] threads = new Thread[threadCount];
  88.         InstanceGetterProcedure procedure = new InstanceGetterProcedure(new MySchema(getClass().getClassLoader()));
  90.         for (int i = 0; i < threads.length; i++) {
  91.             String threadName = "Thread##" + i;
  92.             threads[i] = new Thread(procedure, threadName);
  93.         }
  95.         for (Thread thread : threads) {
  96.             thread.start();
  97.         }
  98.     }
  100.     private class InstanceGetterProcedure implements Runnable {
  102.         private MySchema mySchema;
  103.         Map<String, String> schemaMappings;
  105.         public InstanceGetterProcedure() {
  106.         }
  108.         public InstanceGetterProcedure(MySchema mySchema) {
  109.             this.mySchema = mySchema;
  110.         }
  112.         @Override
  113.         public void run() {
  114.             // 获取schemaMappings
  115.             schemaMappings = mySchema.getSchemaMappings();
  116.         }
  117.     }
  118. }

这里我重点说下多线程的情况：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5OTk4MDk_size_16_color_FFFFFF_t_70

这个属性被赋过两次值，这点我开始很疑惑，一直想能否把第33行去掉。答案当然是不能去掉（因为去掉的话，多线程情况下有可能返回的不是单例） 根源就是getSchemaMappings方法加锁只是对部分代码加锁，第23行就没有加锁，完全有可能出现多个线程进来后，每个线程的schemaMappings属性都为null

这一点可以通过调用MyTest的testMultiThread单元测试方法来证实，多调用几次就会碰到我所说的情况，下图是我碰到的一次

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5OTk4MDk_size_16_color_FFFFFF_t_70 1

去看这个问题的起因：

我之所以会注意到这点，是因为我在用idea调试PluggableSchemaResolver中★★★位置（第93行）时，看到schemaMappings的值为null；但是当这个位置向下再执行一行代码后，鼠标放到schemaMappings上发现已经有结果了。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5OTk4MDk_size_16_color_FFFFFF_t_70 2

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5OTk4MDk_size_16_color_FFFFFF_t_70 3

20190531145846336.png

这种现象让我感到很奇怪，因为这行代码并没有直接操作schemaMappings属性，本身这个类也没有被代理，只是一个普通方法。

然后我在这个类当中继续搜索schemaMappings，发现有一个getSchemaMappings方法（里面直接操作了schemaMappings属性），而这个方法被两个地方（toString和resolveEntity，后面这个和我看到的现象无关，和实际解析xml时先加载schemas有关）调用了。这时我猜想debug时，idea会监控类以及其中变量，我想到现象是idea监控类的时候调用了toString方法（因为要在Variables显示类的有关信息）

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5OTk4MDk_size_16_color_FFFFFF_t_70 4

如果我直接运行单元测试，去掉所有断点，发现在★★★位置后初始化完schemaMappingsLocation变量后，直接在加上System.out.println(“==========================” + schemaMappings);来运行，发现打印出来的是空的

这就证实了我前面猜想的debug过程中idea会调用监控类的toString是对的，所以我一开始看到的现象也就解释得通了

附PuggableSchemaResolver的部分源码：

  1. public class PluggableSchemaResolver implements EntityResolver {
  3.     /**
  4.      * The location of the file that defines schema mappings.
  5.      * Can be present in multiple JAR files.
  6.      *
  7.      * 默认 {@link #schemaMappingsLocation} 地址
  8.      */
  9.     public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";
  12.     private static final Log logger = LogFactory.getLog(PluggableSchemaResolver.class);
  14.     @Nullable
  15.     private final ClassLoader classLoader;
  17.     /**
  18.      * Schema文件地址
  19.      */
  20.     private final String schemaMappingsLocation;
  22.     /** Stores the mapping of schema URL -> local schema path. */
  23.     @Nullable
  24.     private volatile Map<String, String> schemaMappings; // namespaceURI与Schema文件地址的映射集合
  27.     /**
  28.      * Loads the schema URL -> schema file location mappings using the default
  29.      * mapping file pattern "META-INF/spring.schemas".
  30.      * @param classLoader the ClassLoader to use for loading
  31.      * (can be {@code null}) to use the default ClassLoader)
  32.      * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
  33.      */
  34.     public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
  35.         this.classLoader = classLoader;
  36.         // ★★★
  37.         this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
  38.         // System.out.println("==========================" + schemaMappings);
  39.     }
  41.     /**
  42.      * Loads the schema URL -> schema file location mappings using the given
  43.      * mapping file pattern.
  44.      * @param classLoader the ClassLoader to use for loading
  45.      * (can be {@code null}) to use the default ClassLoader)
  46.      * @param schemaMappingsLocation the location of the file that defines schema mappings
  47.      * (must not be empty)
  48.      * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
  49.      */
  50.     public PluggableSchemaResolver(@Nullable ClassLoader classLoader, String schemaMappingsLocation) {
  51.         // 暂时用不到，这里省略具体内容
  52.     }
  55.     @Override
  56.     @Nullable
  57.     public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws IOException {
  58.         // 暂时用不到，这里省略具体内容
  59.     }
  61.     /**
  62.      * Load the specified schema mappings lazily.
  63.      */
  64.     private Map<String, String> getSchemaMappings() {
  65.         Map<String, String> schemaMappings = this.schemaMappings;
  66.         if (schemaMappings == null) {
  67.             synchronized (this) {
  68.                 schemaMappings = this.schemaMappings;
  69.                 if (schemaMappings == null) {
  70.                     // System.out.println("开始加载schemaMappingsLocation");
  71.                     if (logger.isTraceEnabled()) {
  72.                         logger.trace("Loading schema mappings from [" + this.schemaMappingsLocation + "]");
  73.                     }
  74.                     try {
  75.                         Properties mappings =
  76.                                 PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);
  77.                         if (logger.isTraceEnabled()) {
  78.                             logger.trace("Loaded schema mappings: " + mappings);
  79.                         }
  80.                         schemaMappings = new ConcurrentHashMap<>(mappings.size());
  81.                         CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
  82.                         this.schemaMappings = schemaMappings;
  83.                         // System.out.println("schemaMappingsLocation加载完成");
  84.                     }
  85.                     catch (IOException ex) {
  86.                         throw new IllegalStateException(
  87.                                 "Unable to load schema mappings from location [" + this.schemaMappingsLocation + "]", ex);
  88.                     }
  89.                 }
  90.             }
  91.         }
  92.         return schemaMappings;
  93.     }
  96.     @Override
  97.     public String toString() {
  98.         return "EntityResolver using schema mappings " + getSchemaMappings();
  99.     }
  101. }

发表评论

表情：
评论列表 （有 0 条评论，774人围观）

还没有评论，来说两句吧...

相关阅读