java冷知识：URL扩展协议与spring Resource的关联

╰+哭是因爲堅強的太久メ 2022-04-10 03:51 296阅读 0赞

在java中有一个非常重要的类URL（Uniform Resource Locator）中文名为**统一资源定位符**，它可以标识本地的文件资源或类路径资源（xml文件、properties文件）,也可以标识网络资源（http、ftp）。

首先我们在项目中经常可以看到下面这样的代码，对，非常普通！

@Test
    public void go_loadPrjFile() {	
    	URL url = Resource_test.class.getResource("/com/example/a.txt");
    	System.out.println(url);//file:/C:/Users/fei.chen/Desktop/demo/target/test-classes/com/example/a.txt
    	System.out.println(Resource_test.class.getResource("a.txt"));//file:/C:/Users/fei.chen/Desktop/demo/target/test-classes/com/example/jvm/net/a.txt
    	System.out.println(Resource_test.class.getClassLoader().getResource("application.properties"));//file:/C:/Users/fei.chen/Desktop/demo/target/test-classes/application.properties
    	System.out.println(Resource_test.class.getClassLoader().getResource("/com/example/a.txt"));//null
    	System.out.println("输入1：url.handler.getClass().getName()=?");
    }
    @Test
    public void go_httpRequest() {
        String url = "https://start.spring.io/";
        RestTemplate restTemplate = new RestTemplate();
        try (InputStream inputStream = restTemplate.execute(url, HttpMethod.GET, request -> {
        }, response -> {
            return response.getBody();
        })) {
            System.out.println("输入2："+inputStream);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

这里思考几个问题？

**1. ClassLoader.getResourceAsStream为何可以读取到本地文件资源？**

通过指定命令行参数实现，运行时java.exe -classpath 项目的类根路径（C:\\Users\\fei.chen\\Desktop\\demo\\target\\test-classes），它包含了你项目类路径，可以理解到这一层基本上到位了。

**2. Resource\_test.getResource和Thread.currentThread().getContextClassLoader().getResource读取路径有何不同？**

这个其实是考用法，本身没有啥技术含量，看源码都会知道。but，你看过了么，从输出结果中已经知道，**.class**是从类的相对路径中读取，可以识别/（代表项目的类根路径），**ClassLoader**默认是从项目的类根路径读取，不能识别/。

**3. 代码输入1和输入2会输出什么呢？**

没错重点来了，输入1的结果为 sun.net.www.protocol.file.Handler，也就是说go\_loadPrjFile中所有获得的URL都是通过它完成的（协议都是file），而输入2的结果为sun.net.www.protocol.http.HttpURLConnection$HttpInputStream@77f80c04，go\_httpRequest的协议是http。那HttpURLConnection又是什么鬼？

## URL拓展协议 ##

<table> 
 <tbody> 
  <tr> 
   <td style="width:224px;">URLConnection</td> 
   <td style="width:617px;"><a href="https://docs.oracle.com/javase/8/docs/api/java/net/URLConnection.html" rel="nofollow">不赘述</a></td> 
  </tr> 
  <tr> 
   <td style="width:224px;">URLStreamHandler</td> 
   <td style="width:617px;"><a href="https://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandler.html" rel="nofollow">不赘述</a></td> 
  </tr> 
  <tr> 
   <td style="width:224px;">URLStreamHandlerFactory</td> 
   <td style="width:617px;"><a href="https://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html" rel="nofollow">不赘述</a></td> 
  </tr> 
 </tbody> 
</table>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70][]

这样做有什么好处呢？当然是通过url可以构建统一的编程模型。

<table> 
 <tbody> 
  <tr> 
   <td>协议</td> 
   <td>实现</td> 
   <td style="width:536px;">演示</td> 
  </tr> 
  <tr> 
   <td>file</td> 
   <td>sun.net.www.protocol.file.Handler</td> 
   <td style="width:536px;">URL url = new URL("file:/META-INF/license.txt");</td> 
  </tr> 
  <tr> 
   <td>ftp</td> 
   <td>sun.net.www.protocol.ftp.Handler</td> 
   <td style="width:536px;">URL url = new URL("ftp:/META-INF/license.txt");</td> 
  </tr> 
  <tr> 
   <td>jar</td> 
   <td>sun.net.www.protocol.jar.Handler</td> 
   <td style="width:536px;">...</td> 
  </tr> 
  <tr> 
   <td>mailto</td> 
   <td>sun.net.www.protocol.mailto.Handler</td> 
   <td style="width:536px;">...</td> 
  </tr> 
  <tr> 
   <td>http</td> 
   <td>sun.net.www.protocol.http.Handler</td> 
   <td style="width:536px;">...</td> 
  </tr> 
  <tr> 
   <td>https</td> 
   <td>sun.net.www.protocol.https.Handler</td> 
   <td style="width:536px;">..</td> 
  </tr> 
 </tbody> 
</table>

//源码引自sun.misc;
    public class Launcher {
    	private static class Factory implements URLStreamHandlerFactory {
            private static String PREFIX = "sun.net.www.protocol";
            private Factory() {
            }
    	//通过模式：sun.net.www.protocol.${protocol}.Handler
            public URLStreamHandler createURLStreamHandler(String var1) {
                String var2 = PREFIX + "." + var1 + ".Handler";
                try {
                    Class var3 = Class.forName(var2);
                    return (URLStreamHandler)var3.newInstance();
                } catch (ReflectiveOperationException var4) {
                    throw new InternalError("could not load " + var1 + "system protocol handler", var4);
                }
            }
        }
    }
    //使用也比较简单
    @Test
    public void go_buildURL() throws IOException {
        File file = new File("src/test/resources/application.properties");
        URL fileURL = file.toURI().toURL();
        URLConnection urlConnection = fileURL.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        String content = StreamUtils.copyToString(inputStream, Charset.forName("UTF-8"));
        System.out.println(content);
    }

到这里基本上已经豁然开朗，这里提问一个问题：spring中经常用到这样的new URL("classpath:/META-INF/license.txt")，它是怎么实现的，sun底层好像是不支持这种协议的？

没错，它是不支持，会报错：java.net.MalformedURLException: unknown protocol: classpath....，那我们还是向下看吧。

## spring Resource ##

spring的资源定义都是通过核心接口[Resource][]的，它有几个比较重要的类

<table> 
 <tbody> 
  <tr> 
   <td>Resource</td> 
   <td style="width:576px;">核心接口是：<br> InputStream getInputStream()</td> 
  </tr> 
  <tr> 
   <td>ResourceLoader</td> 
   <td style="width:576px;"> <p>核心接口是：</p> <p>Resource getResource(String location);</p> </td> 
  </tr> 
  <tr> 
   <td>ProtocolResolver</td> 
   <td style="width:576px;"> <p>核心接口是：</p> <p>Resource resolve(String location, ResourceLoader resourceLoader)</p> </td> 
  </tr> 
 </tbody> 
</table>

//用法
    @Test
    public void go_loadClasspathFile() throws IOException {
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        Resource resource = resourceLoader.getResource("classpath:/META-INF/license.txt");
        System.out.println(resource.getURL());
    
        //拓展协议
        ((DefaultResourceLoader) resourceLoader).addProtocolResolver(new ProtocolResolver() {
            private static final String PROTOCOL_PREFIX = "cp:/";
    
            @Override
            public Resource resolve(String location, ResourceLoader resourceLoader) {
                if (location.startsWith(PROTOCOL_PREFIX)) {
                    String classpath = ResourceLoader.CLASSPATH_URL_PREFIX + location.substring(PROTOCOL_PREFIX.length());
                    return resourceLoader.getResource(classpath);
                }
                return null;
            }
        });
        Resource resource1 = resourceLoader.getResource("cp:/application.properties");
        System.out.println(resource1.getURL());
    }
    //源码引自org.springframework.core.io
    public class DefaultResourceLoader implements ResourceLoader {
    
    	private ClassLoader classLoader;
    	private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet<ProtocolResolver>(4);
    	public DefaultResourceLoader() {
    		this.classLoader = ClassUtils.getDefaultClassLoader();
    	}
    	public DefaultResourceLoader(ClassLoader classLoader) {
    		this.classLoader = classLoader;
    	}
    	public void setClassLoader(ClassLoader classLoader) {
    		this.classLoader = classLoader;
    	}
    	@Override
    	public ClassLoader getClassLoader() {
    		return (this.classLoader != null ? this.classLoader : ClassUtils.getDefaultClassLoader());
    	}
    
    	//核心方法1：可以自定义实现拓展协议
    	public void addProtocolResolver(ProtocolResolver resolver) {
    		Assert.notNull(resolver, "ProtocolResolver must not be null");
    		this.protocolResolvers.add(resolver);
    	}
    	public Collection<ProtocolResolver> getProtocolResolvers() {
    		return this.protocolResolvers;
    	}
        //核心方法2：封装了sun的URL拓展协议，还支持/与CLASSPATH_URL
    	@Override
    	public Resource getResource(String location) {
    		Assert.notNull(location, "Location must not be null");
    
    		for (ProtocolResolver protocolResolver : this.protocolResolvers) {
    			Resource resource = protocolResolver.resolve(location, this);
    			if (resource != null) {
    				return resource;
    			}
    		}
    
    		if (location.startsWith("/")) {
    			return getResourceByPath(location);
    		}
    		else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
    			return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
    		}
    		else {
    			try {
    				// 封装sun的
    				URL url = new URL(location);
    				return new UrlResource(url);
    			}
    			catch (MalformedURLException ex) {
    				// No URL -> resolve as resource path.
    				return getResourceByPath(location);
    			}
    		}
    	}
    	protected Resource getResourceByPath(String path) {
    		return new ClassPathContextResource(path, getClassLoader());
    	}
    }

总结，URL拓展协议非常重要，可以将spring在他的基础上给与拓展，再遇到这样的new URL("dubbo://192.168.1.2:20080")也就不陌生了。![85157535][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0c29mdGNoZW5mZWk_size_16_color_FFFFFF_t_70]: /images/20220403/a4dc80c2141c40b9bc11181220f23947.png
[Resource]: https://docs.spring.io/spring/docs/3.0.x/reference/resources.html
[85157535]: /images/20220403/710bfbf02d1a4d03bbd14e72ba8d8d9a.png