Spring源码分析——资源访问利器Resource之接口和抽象类分析

从今天开始，一步步走上源码分析的路。刚开始肯定要从简单着手。我们先从Java发展史上最强大的框架——Spring、、、旗下的资源抽象接口Resource开始吧。

　　我看了好多分析Spring源码的，每每一开始就是Spring IOC、AOP、BeanFactory这样的Spring典型模块，实在看厌了，这些暂且留到以后。我的想法是，分析就分析别人没分析过的，或者以不同的角度来分析别人分析过的。

　　可能很多用了Spring多年的程序员对Resource都了解有限，毕竟访问资源一般是搭建web工程框架的时候的事情。不过了解它也是非常有好处的。

　　这个接口的作用是可以让我们更方便操纵底层资源。因为JDK操纵底层资源基本就是 java.net.URL 、java.io.File 、java.util.Properties这些。取资源基本是根据绝对路径或当前类的相对路径来取。从类路径或Web容器上下文中获取资源的时候也不方便。Resource接口提供了更强大的访问底层资源的能力。

　　废话不多说，看源码之前先来看一下Resource的类结构。

一、类结构

一、Resource接口

　　如图，Resouce接口并不是一个根接口，它继承了一个简单的父接口 InputStreamSource，这个接口只有一个方法，用以返回一个输入流：

InputStream getInputStream() throws IOException;

　　来，直接上Resource接口的源码，中文是我根据英文注释自己翻译的，如下：

public interface Resource extends InputStreamSource {

    boolean exists();      //  资源是否存在

    boolean isReadable();  //  资源是否可读

    boolean isOpen();      //  资源所代表的句柄是否被一个stream打开了

    URL getURL() throws IOException;   //  返回资源的URL的句柄

    URI getURI() throws IOException;   //  返回资源的URI的句柄

    File getFile() throws IOException; //  返回资源的File的句柄

    long contentLength() throws IOException;   //  资源内容的长度

    long lastModified() throws IOException;    //  资源最后的修改时间

    Resource createRelative(String relativePath) throws IOException;   //根据资源的相对路径创建新资源

    String getFilename();  //  资源的文件名

    String getDescription();   //资源的描述

}

　　这个没什么好说的，继续！

二、抽象类AbstractResource

　　对于任何的接口而言，这个直接抽象类是重中之重，里面浓缩了接口的大部分公共实现。翻译后如下：

public abstract class AbstractResource implements Resource {

    public boolean exists() {  //判断文件是否存在，若判断过程产生异常（因为会调用SecurityManager来判断），就关闭对应的流
        try {
            return getFile().exists();
        }
        catch (IOException ex) {
            try {
                InputStream is = getInputStream();  //getInputStream()方法会被子类重写，
                is.close();
                return true;
            }
            catch (Throwable isEx) {
                return false;
            }
        }
    }

    public boolean isReadable() {  //  直接返回true，可读
        return true;
    }

    public boolean isOpen() {  //  直接返回false，未被打开
        return false;
    }

    public URL getURL() throws IOException {        //  留给子类重写
        throw new FileNotFoundException(getDescription() + " cannot be resolved to URL");
    }

    public URI getURI() throws IOException {   //返回url
        URL url = getURL();
        try {
            return ResourceUtils.toURI(url);     //将url格式化后返回
        }
        catch (URISyntaxException ex) {
            throw new NestedIOException("Invalid URI [" + url + "]", ex);
        }
    }

    public File getFile() throws IOException {     //  留给子类重写
        throw new FileNotFoundException(getDescription() + " cannot be resolved to absolute file path");
    }

    // 这个资源内容长度实际就是资源的字节长度，通过全部读取一遍来判断。这个方法调用起来很占资源啊！
    public long contentLength() throws IOException {
        InputStream is = this.getInputStream();
        Assert.state(is != null, "resource input stream must not be null");   //断言
        try {
            long size = 0;
            byte[] buf = new byte[255];
            int read;
            while((read = is.read(buf)) != -1) {
                size += read;
            }
            return size;
        }
        finally {
            try {
                is.close();
            }
            catch (IOException ex) {
            }
        }
    }

    public long lastModified() throws IOException {    // 返回资源的最后修改时间
        long lastModified = getFileForLastModifiedCheck().lastModified();
        if (lastModified == 0L) {
            throw new FileNotFoundException(getDescription() +
                    " cannot be resolved in the file system for resolving its last-modified timestamp");
        }
        return lastModified;
    }

    // 这是Resource接口所没有的方法，注释的意思是“返回文件，给时间戳检查”，要求子类重写...
    protected File getFileForLastModifiedCheck() throws IOException {
        return getFile();
    }

    public Resource createRelative(String relativePath) throws IOException {   //  留给子类重写
        throw new FileNotFoundException("Cannot create a relative resource for " + getDescription());
    }

    public String getFilename() {  //  默认返回空（假设资源没有文件名），除非子类重写
        return null;
    }

    @Override
    public String toString() {     //  toString返回文件描述
        return getDescription();
    }

    @Override
    public boolean equals(Object obj) {    //  equals比较的就是2个资源描述是否一样
        return (obj == this ||
            (obj instanceof Resource && ((Resource) obj).getDescription().equals(getDescription())));
    }

    @Override
    public int hashCode() {    //  返回资源描述的HashCode
        return getDescription().hashCode();
    }

}

结论：

　　1、增加了一个方法，protected File getFileForLastModifiedCheck() throws IOException，要求子类实现，如果子类未实现，那么直接返回资源文件。这个方法的具体作用，后面再看实现类。

　　2、方法 contentLength() ，是一个很比较重量级的方法，它通过将资源全部读取一遍来判断资源的字节数。255字节的缓冲数组来读取。子类一般会重写。（调整一下缓冲数组的大小？）

　　3、getDescription() 是这个抽象类唯一没有实现的接口方法，留给子类去实现，资源文件默认的equals()、hashCode() 都通过这个来判断。

　　4、InputStreamSource这个祖先接口的唯一方法 getInputStream()也没有被实现，留给子类。

三、Resource的子接口ContextResource和WritableResource

　　这两个接口继承于Resource，拥有Resource的全部方法。其中，ContextResource接口增加了一个方法：

String getPathWithinContext(); //  返回上下文内的路径

　　这个方法使得它的实现类有了返回当前上下文路径的能力。

　　WritableResource接口增加了2个方法：

    boolean isWritable();  //  是否可写

    OutputStream getOutputStream() throws IOException; //返回资源的写入流

　　这个方法使得它的实现类拥有了写资源的能力。

四、重要的抽象类AbstractFileResolvingResource

　　这个抽象类继承自AbstractResource，重写了AbstractResource的大部分方法。

/*
* Copyright 2002-2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.springframework.core.io;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;

import org.springframework.util.ResourceUtils;

/**
* Abstract base class for resources which resolve URLs into File references,
* such as {@link UrlResource} or {@link ClassPathResource}.
*
* <p>Detects the "file" protocol as well as the JBoss "vfs" protocol in URLs,
* resolving file system references accordingly.
*
* @author Juergen Hoeller
* @since 3.0
*/
public abstract class AbstractFileResolvingResource extends AbstractResource {

@Override
public File getFile() throws IOException { // 通过资源的URL得到资源本身，是文件就返回文件，否则返回描述
URL url = getURL();
if (url.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
return VfsResourceDelegate.getResource(url).getFile();
}
return ResourceUtils.getFile(url, getDescription());
}

@Override
protected File getFileForLastModifiedCheck() throws IOException { //从<压缩文件地址>中获取文件
URL url = getURL();
if (ResourceUtils.isJarURL(url)) {
URL actualUrl = ResourceUtils.extractJarFileURL(url);
if (actualUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
return VfsResourceDelegate.getResource(actualUrl).getFile();
}
return ResourceUtils.getFile(actualUrl, "Jar URL");
}
else {
return getFile();
}
}

protected File getFile(URI uri) throws IOException { // 通过资源uri获取文件
if (uri.getScheme().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
return VfsResourceDelegate.getResource(uri).getFile();
}
return ResourceUtils.getFile(uri, getDescription());
}

@Override
public boolean exists() { //判断资源是否存在，如果是文件Url,直接获取文件判断，否则，建立连接来判断。
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution...
return getFile().exists();
}
else {
// Try a URL connection content-length header...
URLConnection con = url.openConnection();
ResourceUtils.useCachesIfNecessary(con);
HttpURLConnection httpCon =
(con instanceof HttpURLConnection ? (HttpURLConnection) con : null);
if (httpCon != null) {
httpCon.setRequestMethod("HEAD");
int code = httpCon.getResponseCode();
if (code == HttpURLConnection.HTTP_OK) {
return true;
}
else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
return false;
}
}
if (con.getContentLength() >= 0) {
return true;
}
if (httpCon != null) {
// no HTTP OK status, and no content-length header: give up
httpCon.disconnect();
return false;
}
else {
// Fall back to stream existence: can we open the stream?
InputStream is = getInputStream();
is.close();
return true;
}
}
}
catch (IOException ex) {
return false;
}
}

@Override
public boolean isReadable() { // 是否可读
try {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution...
File file = getFile();
return (file.canRead() && !file.isDirectory());
}
else {
return true;
}
}
catch (IOException ex) {
return false;
}
}

@Override
public long contentLength() throws IOException {
URL url = getURL();
if (ResourceUtils.isFileURL(url)) {
// Proceed with file system resolution...
return getFile().length();
}
else {
// Try a URL connection content-length header...
URLConnection con = url.openConnection();
ResourceUtils.useCachesIfNecessary(con);
if (con instanceof HttpURLConnection) {
((HttpURLConnection) con).setRequestMethod("HEAD");
}
return con.getContentLength();
}
}

@Override
public long lastModified() throws IOException {
URL url = getURL();
if (ResourceUtils.isFileURL(url) || ResourceUtils.isJarURL(url)) {
// Proceed with file system resolution...
return super.lastModified();
}
else {
// Try a URL connection last-modified header...
URLConnection con = url.openConnection();
ResourceUtils.useCachesIfNecessary(con);
if (con instanceof HttpURLConnection) {
((HttpURLConnection) con).setRequestMethod("HEAD");
}
return con.getLastModified();
}
}

/**
* Inner delegate class, avoiding a hard JBoss VFS API dependency at runtime.
*/
private static class VfsResourceDelegate {

public static Resource getResource(URL url) throws IOException {
return new VfsResource(VfsUtils.getRoot(url));
}

public static Resource getResource(URI uri) throws IOException {
return new VfsResource(VfsUtils.getRoot(uri));
}
}

}

　　这个抽象类的子类都需要重写继承自AbstractResource的getURL()方法。因为绝大多数方法都依赖这个方法，进行资源在url上的操作。

　　所以在查看资源情况的时候，需要根据url建立连接来查看。

　　PS：框架感觉大都是这样，不难，设计模式也运用的不多。却有一种大巧不工、重剑无锋的感觉，因为代码运用真的非常简练。

　　　　分析源码，很大程度上也锻炼了自己的英文文档阅读能力。共勉。

时间： 2024-10-12 04:09:22

Spring源码分析——资源访问利器Resource之接口和抽象类分析的相关文章

攻城狮在路上（贰） Spring（三）--- Spring 资源访问利器Resource接口

Spring为了更好的满足各种底层资源的访问需求.设计了一个Resource接口,提供了更强的访问底层资源的能力.Spring框架使用Resource装载各种资源,包括配置文件资源.国际化属性文件资源等.一.Resource接口的主要方法有: boolean exists():资源是否存在. boolean isOpen():资源是否打开. URL getURL():如果底层资源可以表示为URL,该方法返回对应的URL对象. File getFile():如果底层资源对应一个文件,该方法返回对应

Spring源码分析（八）AbstractBeanDefinition属性

摘要:本文结合<Spring源码深度解析>来分析Spring 5.0.6版本的源代码.若有描述错误之处,欢迎指正. 在上一篇中已经完成了XML文档到GenericBeanDefiniton的转化,也就是说,XML中所有的配置都在GenericBeanDefinition的实例类中找到了对应的位置. GenericBeanDefinition只是子类实现,大部分的属性都保存在了AbstractBeanDefinition中,下面我们看下这个类: public abstract class Abs

【spring源码分析】IOC容器初始化（一）

前言:spring主要就是对bean进行管理,因此IOC容器的初始化过程非常重要,搞清楚其原理不管在实际生产或面试过程中都十分的有用.在[spring源码分析]准备工作中已经搭建好spring的环境,并利用xml配置形式对类进行了实例化.在test代码中有一个非常关键的类ClassPathXmlApplicationContext,在这个类中实现了IOC容器的初始化,因此我们从ClassPathXmlApplicationContext入手开始研究IOC的初始化过程. 1.ClassPathXm

Spring源码分析 之浅谈设计模式

一直想专门写个Spring源码的博客,工作了,可以全身性的投入到互联网行业中.虽然加班很严重,但是依然很开心.趁着凌晨有时间,总结总结. 首先spring,相信大家都很熟悉了. 1.轻量级  零配置,API使用简单 2.面向Bean  只需要编写普通的Bean(一个Bean代表一个对象) 3.松耦合 充分利用AOP思想 )(各自可以独立开发,然后整合起来运行) 4.万能胶 与主流框架无缝集成 (Mybatis dubbo等等 ) 5.设计模式 将Java中经典的设计模式运用的淋漓尽致 Sprin

spring源码分析(一)IoC、DI

创建日期:2016.08.06 修改日期:2016.08.07 - 2016.08.12 交流QQ:992591601 参考书籍:<spring源码深度解析>.<spring技术内幕> 参考文章:http://www.cnblogs.com/xing901022/p/4178963.html http://www.myexception.cn/program/1031276.html http://blog.csdn.net/qian_348840260/article/detai

Spring源码分析——BeanFactory体系之抽象类、类分析（二）

上一篇分析了BeanFactory体系的2个类,SimpleAliasRegistry和DefaultSingletonBeanRegistry——Spring源码分析——BeanFactory体系之抽象类.类分析(一),今天继续分析. 一.工厂Bean注册支持——FactoryBeanRegistrySupport 废话不多说,直接看我注释的源码: /* * Copyright 2002-2012 the original author or authors. * * Licensed und

Spring源码分析——BeanFactory体系之抽象类、类分析（一）

上一篇介绍了BeanFactory体系的所有接口——Spring源码分析——BeanFactory体系之接口详细分析,本篇就接着介绍BeanFactory体系的抽象类和接口. 一.BeanFactory的基本类体系结构(类为主): 上图可与 Spring源码分析——BeanFactory体系之接口详细分析 的图结合分析,一个以接口为主,一个以类为主(PS:Spring的体系结构要分析清楚,不得不曲线救国啊!不然27寸屏幕给我画估计都装不下.). 具体: 1.7层的类体系继承. 2.Abstrac

【Spring源码分析】Bean加载流程概览

代码入口 之前写文章都会啰啰嗦嗦一大堆再开始,进入[Spring源码分析]这个板块就直接切入正题了. 很多朋友可能想看Spring源码,但是不知道应当如何入手去看,这个可以理解:Java开发者通常从事的都是Java Web的工作,对于程序员来说,一个Web项目用到Spring,只是配置一下配置文件而已,Spring的加载过程相对是不太透明的,不太好去找加载的代码入口. 下面有很简单的一段代码可以作为Spring代码加载的入口: 1 ApplicationContext ac = new Clas

【Spring源码分析】配置文件读取流程

前言 Spring配置文件读取流程本来是和http://www.cnblogs.com/xrq730/p/6285358.html一文放在一起的,这两天在看Spring自定义标签的时候,感觉对Spring配置文件读取流程还是研究得不够,因此将Spring配置文件读取流程部分从之前的文章拆出来单独成为一文. 为了看一下Spring配置文件加载流程,先定义一个bean.xml: 1 <?xml version="1.0" encoding="UTF-8"?>