linux resource和source的区别 source 与resource

spring ioc容器设计实现离不开资源，如URL资源、File资源资源、ClassPath相关资源、服务器相关资源（JBoss AS 5.x上的VFS资源）等等很多资源。而我们如何去定义这些资源就是一个需要考虑的问题了。spring定义了一个统一的接口Resource来定义这些资源，并且定义了资源的共有操作。具体看看spring关于资源定义的接口以及实现类关系如下所示：

 

具体图片如下：，为了区分接口和类，其中红色表示接口，绿色表示实现类。

下面我们从上图的第一个层次开始具体来看看这些接口或者类的功能。

1.InputStreamSource接口。

public interface InputStreamSource {
　　/**
     * 获取输入流
     * @return
     */
    InputStream getInputStream() throws IOException;
}

2.Resource接口，这个接口主要定义了资源的一些特性，比如是否存在，是否可读等。我这里展示的是我自己参考写的一个，不一定包括原来类所有的方法定义。

/**
 * 定位资源的接口
 * @author wxe
 * @since 1.0.0
 */
public interface Resource extends InputStreamSource {/**
     * 资源是否存在
     * @return
     */
    boolean exists();
    
    /**
     * 资源是否可读
     * @return
     */
    boolean isReadable();
    
    /**
     * 资源是否已经打开
     * @return
     */
    boolean isOpen();
    
    /**
     * 获取资源所在的url
     * @return
     * @throws IOException
     */
    URL getURL() throws IOException;
    
    /**
     * 获取资源所在文件
     * @return
     * @throws IOException
     */
    File getFile() throws IOException;
    
    /**
     * 获取文件名称
     * @return
     */
    String getFilename();
    
    /**
     * 根据相对位置获取资源
     * @param relativePath
     * @return
     * @throws IOException
     */
    Resource createRelative(String relativePath) throws IOException;
}

 3.ContextResource类，这个类主要定义了从应用上下文中获取资源。

/**
 * 用于从封闭的上下文中获取资源，比如从ServletContext中获取，当然也可以从classpath或者相对文件系统路径中获取
 * @author wxe
 * @since 1.0.0
 */
public interface ContextResource extends Resource {
    
    /**
     * 从上下文中获取资源
     * @return
     */
    String getPathWithinContext();

}

View Code

4.WritableResource类，这个类让资源变成可写的，只有两个实现类：PathResource和FileSystemResource，下面就会介绍到。

/**
 * 用于该实现类拥有写资源的能力
 * @author wxe
 * @since 1.0.0
 */
public interface WritableResource extends Resource {
    /**
     * 资源是否可写
     * @return
     */
    boolean isWritable();
    
    /**
     * 获取输出流
     * @return
     * @throws IOException
     */
    OutputStream getOutputStream() throws IOException;

}

5.AbstractResource类，这类是Resource的第一个实现类，这个类定义了如何实现Resource中定义资源的一些操作，但是不是所有的方法都实现了，这是一种精妙的编程技巧。Resource类中定义的接口方法很多，没有必要所有的方法都去实现，可以抽取出来作为一种默认实现，其他可以看子类自己如何实现。这样，通过继承 AbstractResource，可以有针对性的实现自己需要的方法。

package com.wang.spring.beans.resource;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * Resource的抽象实现
 * @author wxe
 * @since 1.0.0
 */
public abstract class AbstractResource implements Resource {

    @Override
    public boolean exists() {
        try {
            return getFile().exists();
        } catch (IOException e) {
            try {
                InputStream is = getInputStream();
                is.close();
                return true;
            } catch (Exception e2) {
                return false;
            }
        }
    }

    @Override
    public boolean isReadable() {
        return true;
    }

    @Override
    public boolean isOpen() {
        return false;//直接返回false,表示资源未被打开
    }
    @Override
    public boolean equals(Object obj){
        if (obj == this) {
            return true;
        }
        
        if (obj instanceof Resource && ((Resource) obj).getDescription().equals(getDescription())) {
            return true;
        }
        
        return false;
    }
    
    @Override
    public int hashCode() {
        return getDescription().hashCode();
    }
    
    /**************************************************需要子类实现的方法 *****************************************************/

    @Override
    public InputStream getInputStream() throws IOException {
        return null;
    }
    
    @Override
    public URL getURL() throws IOException {
        throw new FileNotFoundException(" cannot be resolved to URL");
    }

    @Override
    public File getFile() throws IOException {
        throw new FileNotFoundException(" cannot be resolved to absolute file path");
    }

    @Override
    public String getFilename() {
        return null;
    }

    @Override
    public Resource createRelative(String relativePath) throws IOException {
        throw new FileNotFoundException("Cannot create a relative resource for ");
    }

}

View Code

 到此为止，我们的前三层已经描述完了。现在来分析一下第四层和第五层真正的实现。

6.AbstractFileResolvingResource类，主要用于将URL解析为File文件的资源实现类。这里并不是源码，是写了一些最主要的方法。

package com.wang.spring.beans.resource;

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

import com.wang.spring.utils.ResourceUtils;

/**
 * 用于解析URL成为文件引用的资源实现类
 * @author wxe
 * @since 1.0.0
 */
public abstract class AbstractFileResolvingResource extends AbstractResource {
    /**
     * 通过URL获取当前文件
     */
    @Override
    public File getFile() throws IOException {
        URL url = getURL();
        //源码支持JBOss vfs文件，因对这个不了解，所以并未分析
        return ResourceUtils.getFile(url, getDescription());//URL资源转换为File
    }
    
    
    
    @Override
    public boolean exists() {
        try {
            URL url = getURL();
            if (ResourceUtils.isFileURL(url)) {
                return this.getFile().exists();//如果是文件系统，直接由File判断存在性
            } else {
                URLConnection con = url.openConnection();
                HttpURLConnection httpCon =
                        (con instanceof HttpURLConnection ? (HttpURLConnection) con : null);
                if (httpCon != null) {
                    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 (Exception e) {
            return false;
        }
    }
    
    
    @Override
    public boolean isReadable(){
        try {
            URL url = getURL();
            if (ResourceUtils.isFileURL(url)) {
                try {
                    File file = getFile();
                    return (file.canRead() && !file.isDirectory());//文件是否可读，而且不是目录
                } catch (Exception e) {
                    return false;
                }
                
            } else {
                return true;
            }
        } catch (Exception e) {
            return false;
        }
        
    }
    
    
    
    
    
    /**********************************************************************未实现************************************************/
    @Override
    public URL getURL() throws IOException {
        throw new FileNotFoundException(getDescription() + " cannot be resolved to URL");
    }

}

View Code

 7.BeanDefinitionResource类，这个类是针对BeanDefinition类定义的资源，里面有对BeanDefinition的引用，只提供了一个获取BeanDefinition的方法，其他有关Resource的方法并未实现。

/*
 * Copyright 2002-2012 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.beans.factory.support;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.core.io.AbstractResource;
import org.springframework.util.Assert;

/**
 * Descriptive {@link org.springframework.core.io.Resource} wrapper for
 * a {@link org.springframework.beans.factory.config.BeanDefinition}.
 *
 * @author Juergen Hoeller
 * @since 2.5.2
 * @see org.springframework.core.io.DescriptiveResource
 */
class BeanDefinitionResource extends AbstractResource {

    private final BeanDefinition beanDefinition;


    /**
     * Create a new BeanDefinitionResource.
     * @param beanDefinition the BeanDefinition objectto wrap
     */
    public BeanDefinitionResource(BeanDefinition beanDefinition) {
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        this.beanDefinition = beanDefinition;
    }

    /**
     * Return the wrapped BeanDefinition object.
     */
    public final BeanDefinition getBeanDefinition() {
        return this.beanDefinition;
    }


    @Override
    public boolean exists() {
        return false;
    }

    @Override
    public boolean isReadable() {
        return false;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        throw new FileNotFoundException(
                "Resource cannot be opened because it points to " + getDescription());
    }

    @Override
    public String getDescription() {
        return "BeanDefinition defined in " + this.beanDefinition.getResourceDescription();
    }


    /**
     * This implementation compares the underlying BeanDefinition.
     */
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof BeanDefinitionResource &&
                        ((BeanDefinitionResource) obj).beanDefinition.equals(this.beanDefinition)));
    }

    /**
     * This implementation returns the hash code of the underlying BeanDefinition.
     */
    @Override
    public int hashCode() {
        return this.beanDefinition.hashCode();
    }

}

View Code

8.ByteArrayResource类，这个类主要是对字节数组资源的定义。主要是对一个不可变字节数组和描述的封装。

/*
 * Copyright 2002-2012 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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/**
 * {@link Resource} implementation for a given byte array.
 * Creates a ByteArrayInputStreams for the given byte array.
 *
 * <p>Useful for loading content from any given byte array,
 * without having to resort to a single-use {@link InputStreamResource}.
 * Particularly useful for creating mail attachments from local content,
 * where JavaMail needs to be able to read the stream multiple times.
 *
 * @author Juergen Hoeller
 * @since 1.2.3
 * @see java.io.ByteArrayInputStream
 * @see InputStreamResource
 * @see org.springframework.mail.javamail.MimeMessageHelper#addAttachment(String, InputStreamSource)
 */
public class ByteArrayResource extends AbstractResource {

    private final byte[] byteArray;

    private final String description;


    /**
     * Create a new ByteArrayResource.
     * @param byteArray the byte array to wrap
     */
    public ByteArrayResource(byte[] byteArray) {
        this(byteArray, "resource loaded from byte array");
    }

    /**
     * Create a new ByteArrayResource.
     * @param byteArray the byte array to wrap
     * @param description where the byte array comes from
     */
    public ByteArrayResource(byte[] byteArray, String description) {
        if (byteArray == null) {
            throw new IllegalArgumentException("Byte array must not be null");
        }
        this.byteArray = byteArray;
        this.description = (description != null ? description : "");
    }

    /**
     * Return the underlying byte array.
     */
    public final byte[] getByteArray() {
        return this.byteArray;
    }


    /**
     * This implementation always returns {@code true}.
     */
    @Override
    public boolean exists() {
        return true;
    }

    /**
     * This implementation returns the length of the underlying byte array.
     */
    @Override
    public long contentLength() {
        return this.byteArray.length;
    }

    /**
     * This implementation returns a ByteArrayInputStream for the
     * underlying byte array.
     * @see java.io.ByteArrayInputStream
     */
    @Override
    public InputStream getInputStream() throws IOException {
        return new ByteArrayInputStream(this.byteArray);
    }

    /**
     * This implementation returns the passed-in description, if any.
     */
    @Override
    public String getDescription() {
        return this.description;
    }


    /**
     * This implementation compares the underlying byte array.
     * @see java.util.Arrays#equals(byte[], byte[])
     */
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof ByteArrayResource && Arrays.equals(((ByteArrayResource) obj).byteArray, this.byteArray)));
    }

    /**
     * This implementation returns the hash code based on the
     * underlying byte array.
     */
    @Override
    public int hashCode() {
        return (byte[].class.hashCode() * 29 * this.byteArray.length);
    }

}

View Code

9.DescriptiveResource类，这个类实际只是对资源描述的定义，既不是可读，实际文件也是不存在的，其他Resource接口中的方法也并未实现。当一个方法需要你传递一个资源对象，但又不会在方法中真正读取该对象的时候，如果没有合适的资源对象作为参数，就创建一个 DescriptiveResource 资源做参数。

/*
 * Copyright 2002-2012 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.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Simple {@link Resource} implementation that holds a resource description
 * but does not point to an actually readable resource.
 *
 * <p>To be used as placeholder if a {@code Resource} argument is
 * expected by an API but not necessarily used for actual reading.
 *
 * @author Juergen Hoeller
 * @since 1.2.6
 */
public class DescriptiveResource extends AbstractResource {

    private final String description;


    /**
     * Create a new DescriptiveResource.
     * @param description the resource description
     */
    public DescriptiveResource(String description) {
        this.description = (description != null ? description : "");
    }


    @Override
    public boolean exists() {
        return false;
    }

    @Override
    public boolean isReadable() {
        return false;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        throw new FileNotFoundException(
                getDescription() + " cannot be opened because it does not point to a readable resource");
    }

    @Override
    public String getDescription() {
        return this.description;
    }


    /**
     * This implementation compares the underlying description String.
     */
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof DescriptiveResource && ((DescriptiveResource) obj).description.equals(this.description)));
    }

    /**
     * This implementation returns the hash code of the underlying description String.
     */
    @Override
    public int hashCode() {
        return this.description.hashCode();
    }

}

View Code

10.FileSystemResource类，这是一个用来描述文件系统资源的类，这里面主要引用了File以及path,最重要的一点，他实现了WritableResource接口，所以该类具有可写的能力。而且里面实现了创建相对资源的方法：createRelative（String relativePath）

利用 StringUtils.applyRelativePath(this.path, relativePath) 方法来创建资源绝对路径，主要操作是截取 path 的最后一个文件分隔符 ‘/’ 前面的内容与 relativePath 拼接，然后基于新的路径构造资源对象。

package com.wang.spring.beans.resource;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URL;

import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.util.StringUtils;

/**
 * 文件系统资源
 * @author wxe
 * @since 1.0.0
 */
public class FileSystemResource extends AbstractResource implements WritableResource {
    
    private final File file;
    
    private final String path;
    
    public FileSystemResource(File file){
        this.file = file;
        this.path = file.getPath();
    }
    
    public FileSystemResource(String path) {
        this.file = new File(path);
        this.path = path;
    }
    
    @Override
    public boolean exists() {
        return this.file.exists();
    }
    
    @Override
    public boolean isReadable() {
        return (this.file.canRead() && !this.file.isDirectory());
    }
    
    @Override
    public InputStream getInputStream() throws IOException {
        return new FileInputStream(this.file);
    }
    
    @Override
    public URL getURL() throws IOException {
        return this.file.toURI().toURL();
    }
    
    public URI getURI() throws IOException {
        return this.file.toURI();
    }
    
    @Override
    public Resource createRelative(String relativePath) {
        String pathToUse = StringUtils.applyRelativePath(this.path, relativePath);
        return new FileSystemResource(pathToUse);
    }
    
    /*********************************实现WritableResource接口，因此具有写能力****************************************/
    @Override
    public boolean isWritable() {
        return (this.file.canWrite() && !this.file.isDirectory());
    }
    
    @Override
    public OutputStream getOutputStream() throws IOException {
        return new FileOutputStream(this.file);
    }
    

    @Override
    public String getDescription() {
        return "";
    }
    
    public final String getPath() {
        return this.path;
    }
    
    public final File getFile(){
        return this.file;
    }

    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof FileSystemResource && this.path.equals(((FileSystemResource) obj).path)));
    }

    @Override
    public int hashCode() {
        return this.path.hashCode();
    }

}

View Code

InputStreamResource类，主要定义InputStream流之类的资源，其中有一个read属性，主要用来控制不可重复性后去资源。其中，我们知道InputStream在文件中是最底层的描述，越是在最低层，需要考虑的问题就越多，所以Spring 明确表示，如果有相应的上层实现则不推荐直接使用 InputStreamResource。

package com.wang.spring.beans.resource;

import java.io.IOException;
import java.io.InputStream;

/**
 * @author wxe
 * @since 1.0.0
 */
public class InputStreamResource extends AbstractResource {
    
    private final InputStream inputStream;//注入对InputStream的引用

    private final String description;

    private boolean read = false;//初始为不可重复获取
    
    public InputStreamResource(InputStream inputStream) {
        this(inputStream, "resource loaded through InputStream");
    }
    
    public InputStreamResource (InputStream inputStream,String description){
        if (inputStream == null) {
            throw new IllegalArgumentException("InputStream must not be null");
        }
        this.inputStream = inputStream;
        this.description = description;
    }

    @Override
    public boolean exists() {
        return true;
    }

    @Override
    public boolean isOpen() {
        return true;
    }
    
    @Override
    public InputStream getInputStream() throws IOException, IllegalStateException {
        if (this.read) {
            throw new IllegalStateException("InputStream has already been read - " +
                    "do not use InputStreamResource if a stream needs to be read multiple times");
        }
        this.read = true;//获取流的时候，将其设置为ture,表示inputStream已经被获取
        return this.inputStream;
    }
    
    @Override
    public String getDescription() {
        return this.description;
    }
    
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof InputStreamResource && ((InputStreamResource) obj).inputStream.equals(this.inputStream)));
    }

    @Override
    public int hashCode() {
        return this.inputStream.hashCode();
    }
}

View Code

12.PathResource类，主要用来定义基于path的路径，该类注入了Path的引用。该类也是实现了WritableResource接口，也是具有可写能力的。

/*
 * Copyright 2002-2013 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.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.springframework.util.Assert;

/**
 * {@link Resource} implementation for {@code java.nio.file.Path} handles.
 * Supports resolution as File, and also as URL.
 * Implements the extended {@link WritableResource} interface.
 *
 * @author Philippe Marschall
 * @since 4.0
 * @see java.nio.file.Path
 */
public class PathResource extends AbstractResource implements WritableResource {

    private final Path path;


    /**
     * Create a new PathResource from a Path handle.
     * <p>Note: Unlike {@link FileSystemResource}, when building relative resources
     * via {@link #createRelative}, the relative path will be built <i>underneath</i> the
     * given root:
     * e.g. Paths.get("C:/dir1/"), relative path "dir2" -> "C:/dir1/dir2"!
     * @param path a Path handle
     */
    public PathResource(Path path) {
        Assert.notNull(path, "Path must not be null");
        this.path = path.normalize();
    }

    /**
     * Create a new PathResource from a Path handle.
     * <p>Note: Unlike {@link FileSystemResource}, when building relative resources
     * via {@link #createRelative}, the relative path will be built <i>underneath</i> the
     * given root:
     * e.g. Paths.get("C:/dir1/"), relative path "dir2" -> "C:/dir1/dir2"!
     * @param path a path
     * @see java.nio.file.Paths#get(String, String...)
     */
    public PathResource(String path) {
        Assert.notNull(path, "Path must not be null");
        this.path = Paths.get(path).normalize();
    }

    /**
     * Create a new PathResource from a Path handle.
     * <p>Note: Unlike {@link FileSystemResource}, when building relative resources
     * via {@link #createRelative}, the relative path will be built <i>underneath</i> the
     * given root:
     * e.g. Paths.get("C:/dir1/"), relative path "dir2" -> "C:/dir1/dir2"!
     * @see java.nio.file.Paths#get(URI)
     * @param uri a path URI
     */
    public PathResource(URI uri) {
        Assert.notNull(uri, "URI must not be null");
        this.path = Paths.get(uri).normalize();
    }


    /**
     * Return the file path for this resource.
     */
    public final String getPath() {
        return this.path.toString();
    }

    /**
     * This implementation returns whether the underlying file exists.
     * @see org.springframework.core.io.PathResource#exists()
     */
    @Override
    public boolean exists() {
        return Files.exists(this.path);
    }

    /**
     * This implementation checks whether the underlying file is marked as readable
     * (and corresponds to an actual file with content, not to a directory).
     * @see java.nio.file.Files#isReadable(Path)
     * @see java.nio.file.Files#isDirectory(Path, java.nio.file.LinkOption...)
     */
    @Override
    public boolean isReadable() {
        return (Files.isReadable(this.path) && !Files.isDirectory(this.path));
    }

    /**
     * This implementation opens a InputStream for the underlying file.
     * @see java.nio.file.spi.FileSystemProvider#newInputStream(Path, OpenOption...)
     */
    @Override
    public InputStream getInputStream() throws IOException {
        if(!exists()) {
            throw new FileNotFoundException(getPath() + " (No such file or directory)");
        }
        if(Files.isDirectory(this.path)) {
            throw new FileNotFoundException(getPath() + " (Is a directory)");
        }
        return Files.newInputStream(this.path);
    }

    /**
     * This implementation returns a URL for the underlying file.
     * @see java.nio.file.Path#toUri()
     * @see java.net.URI#toURL()
     */
    @Override
    public URL getURL() throws IOException {
        return this.path.toUri().toURL();
    }

    /**
     * This implementation returns a URI for the underlying file.
     * @see java.nio.file.Path#toUri()
     */
    @Override
    public URI getURI() throws IOException {
        return this.path.toUri();
    }

    /**
     * This implementation returns the underlying File reference.
     */
    @Override
    public File getFile() throws IOException {
        try {
            return this.path.toFile();
        }
        catch (UnsupportedOperationException ex) {
            // only Paths on the default file system can be converted to a File
            // do exception translation for cases where conversion is not possible
            throw new FileNotFoundException(this.path + " cannot be resolved to "
                    + "absolute file path");
        }
    }

    /**
     * This implementation returns the underlying File's length.
     */
    @Override
    public long contentLength() throws IOException {
        return Files.size(this.path);
    }

    /**
     * This implementation returns the underlying File's timestamp.
     * @see java.nio.file.Files#getLastModifiedTime(Path, java.nio.file.LinkOption...)
     */
    @Override
    public long lastModified() throws IOException {
        // we can not use the super class method since it uses conversion to a File and
        // only Paths on the default file system can be converted to a File
        return Files.getLastModifiedTime(path).toMillis();
    }

    /**
     * This implementation creates a FileResource, applying the given path
     * relative to the path of the underlying file of this resource descriptor.
     * @see java.nio.file.Path#resolve(String)
     */
    @Override
    public Resource createRelative(String relativePath) throws IOException {
        return new PathResource(this.path.resolve(relativePath));
    }

    /**
     * This implementation returns the name of the file.
     * @see java.nio.file.Path#getFileName()
     */
    @Override
    public String getFilename() {
        return this.path.getFileName().toString();
    }

    @Override
    public String getDescription() {
        return "path [" + this.path.toAbsolutePath() + "]";
    }

    // implementation of WritableResource

    /**
     * This implementation checks whether the underlying file is marked as writable
     * (and corresponds to an actual file with content, not to a directory).
     * @see java.nio.file.Files#isWritable(Path)
     * @see java.nio.file.Files#isDirectory(Path, java.nio.file.LinkOption...)
     */
    @Override
    public boolean isWritable() {
        return Files.isWritable(this.path) && !Files.isDirectory(this.path);
    }

    /**
     * This implementation opens a OutputStream for the underlying file.
     * @see java.nio.file.spi.FileSystemProvider#newOutputStream(Path, OpenOption...)
     */
    @Override
    public OutputStream getOutputStream() throws IOException {
        if(Files.isDirectory(this.path)) {
            throw new FileNotFoundException(getPath() + " (Is a directory)");
        }
        return Files.newOutputStream(this.path);
    }


    /**
     * This implementation compares the underlying Path references.
     */
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof PathResource && this.path.equals(((PathResource) obj).path)));
    }

    /**
     * This implementation returns the hash code of the underlying Path reference.
     */
    @Override
    public int hashCode() {
        return this.path.hashCode();
    }

}

View Code

 13.VfsResource类，主要用来定义JBOSS上的VFS资源。

/*
 * Copyright 2002-2014 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.URI;
import java.net.URL;

import org.springframework.core.NestedIOException;
import org.springframework.util.Assert;

/**
 * JBoss VFS based {@link Resource} implementation.
 *
 * <p>As of Spring 4.0, this class supports VFS 3.x on JBoss AS 6+ (package
 * {@code org.jboss.vfs}) and is in particular compatible with JBoss AS 7 and
 * WildFly 8.
 *
 * @author Ales Justin
 * @author Juergen Hoeller
 * @author Costin Leau
 * @since 3.0
 * @see org.jboss.vfs.VirtualFile
 */
public class VfsResource extends AbstractResource {

    private final Object resource;


    public VfsResource(Object resource) {
        Assert.notNull(resource, "VirtualFile must not be null");
        this.resource = resource;
    }


    @Override
    public InputStream getInputStream() throws IOException {
        return VfsUtils.getInputStream(this.resource);
    }

    @Override
    public boolean exists() {
        return VfsUtils.exists(this.resource);
    }

    @Override
    public boolean isReadable() {
        return VfsUtils.isReadable(this.resource);
    }

    @Override
    public URL getURL() throws IOException {
        try {
            return VfsUtils.getURL(this.resource);
        }
        catch (Exception ex) {
            throw new NestedIOException("Failed to obtain URL for file " + this.resource, ex);
        }
    }

    @Override
    public URI getURI() throws IOException {
        try {
            return VfsUtils.getURI(this.resource);
        }
        catch (Exception ex) {
            throw new NestedIOException("Failed to obtain URI for " + this.resource, ex);
        }
    }

    @Override
    public File getFile() throws IOException {
        return VfsUtils.getFile(this.resource);
    }

    @Override
    public long contentLength() throws IOException {
        return VfsUtils.getSize(this.resource);
    }

    @Override
    public long lastModified() throws IOException {
        return VfsUtils.getLastModified(this.resource);
    }

    @Override
    public Resource createRelative(String relativePath) throws IOException {
        if (!relativePath.startsWith(".") && relativePath.contains("/")) {
            try {
                return new VfsResource(VfsUtils.getChild(this.resource, relativePath));
            }
            catch (IOException ex) {
                // fall back to getRelative
            }
        }

        return new VfsResource(VfsUtils.getRelative(new URL(getURL(), relativePath)));
    }

    @Override
    public String getFilename() {
        return VfsUtils.getName(this.resource);
    }

    @Override
    public String getDescription() {
        return this.resource.toString();
    }

    @Override
    public boolean equals(Object obj) {
        return (obj == this || (obj instanceof VfsResource && this.resource.equals(((VfsResource) obj).resource)));
    }

    @Override
    public int hashCode() {
        return this.resource.hashCode();
    }

}

View Code

14.ClassPathResource类，主要定义了ClassPath路径下的资源，基于 ClassLoader 或 Class 来定位加载资源。整个类的核心在于如何依据 ClassLoader 或 Class 进行资源定位，主要体现在 resolveURL() 方法。

package com.wang.resource.classes;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

import com.wang.resource.abstractclass.AbstractResource;

/**
 * 主要针对classpath文件夹下的xml文件进行解析
 * 
 * @author wxe
 * @since 1.0.0
 */
public class ClassPathResource extends AbstractResource {

    private final String path;

    private ClassLoader classLoader;

    private Class<?> clazz;

    public ClassPathResource(String path) {
        this(path, (ClassLoader) null);
    }

    public ClassPathResource(String path, ClassLoader classLoader) {
        String pathToUse = path;
        if (pathToUse.startsWith("/")) {
            pathToUse = pathToUse.substring(1);
        }
        this.path = pathToUse;
        this.classLoader = (classLoader != null ? classLoader : Thread
                .currentThread().getContextClassLoader());
    }

    public final String getPath() {
        return this.path;
    }
    
    public final ClassLoader getClassLoader() {
        return (this.clazz != null ? this.clazz.getClassLoader() : this.classLoader);
    }
    
    @Override
    public boolean exists() {
        return resolveURL() != null;
    }
    
    @Override
    public URL getURL() throws IOException {
        URL url = resolveURL();
        if (url == null) {
            throw new FileNotFoundException(getDescription() + " cannot be resolved to URL because it does not exist");
        }
        return url;
    }
    
    /**
     * 有两种获取资源方法，第一种是通过ClassLoader,第二种是Class
     * @return
     */
    protected URL resolveURL() {
        if (this.clazz != null) {
            return this.clazz.getResource(this.path);
        }
        else if (this.classLoader != null) {
            return this.classLoader.getResource(this.path);
        }
        else {
            return ClassLoader.getSystemResource(this.path);
        }
    }
    /**
     * 通过Class获取输入流资源
     */
    @Override
    public InputStream getInputStream() throws IOException {
        InputStream is;
        
        if (this.clazz != null) {
            is = this.clazz.getResourceAsStream(this.path);
        }
        else if(this.classLoader != null){
            is = this.classLoader.getResourceAsStream(this.path);
        }
        else{
            is = ClassLoader.getSystemResourceAsStream(this.path);
        }
        
        if (is == null) {
            throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
        }
        return is;
    }

}

View Code

15.ServletContextResource类，这个是获取servlet上下文中的资源。

/*
 * Copyright 2002-2012 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.web.context.support;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import javax.servlet.ServletContext;

import org.springframework.core.io.AbstractFileResolvingResource;
import org.springframework.core.io.ContextResource;
import org.springframework.core.io.Resource;
import org.springframework.util.Assert;
import org.springframework.util.ResourceUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.util.WebUtils;

/**
 * {@link org.springframework.core.io.Resource} implementation for
 * {@link javax.servlet.ServletContext} resources, interpreting
 * relative paths within the web application root directory.
 *
 * <p>Always supports stream access and URL access, but only allows
 * {@code java.io.File} access when the web application archive
 * is expanded.
 *
 * @author Juergen Hoeller
 * @since 28.12.2003
 * @see javax.servlet.ServletContext#getResourceAsStream
 * @see javax.servlet.ServletContext#getResource
 * @see javax.servlet.ServletContext#getRealPath
 */
public class ServletContextResource extends AbstractFileResolvingResource implements ContextResource {

    private final ServletContext servletContext;

    private final String path;


    /**
     * Create a new ServletContextResource.
     * <p>The Servlet spec requires that resource paths start with a slash,
     * even if many containers accept paths without leading slash too.
     * Consequently, the given path will be prepended with a slash if it
     * doesn't already start with one.
     * @param servletContext the ServletContext to load from
     * @param path the path of the resource
     */
    public ServletContextResource(ServletContext servletContext, String path) {
        // check ServletContext
        Assert.notNull(servletContext, "Cannot resolve ServletContextResource without ServletContext");
        this.servletContext = servletContext;

        // check path
        Assert.notNull(path, "Path is required");
        String pathToUse = StringUtils.cleanPath(path);
        if (!pathToUse.startsWith("/")) {
            pathToUse = "/" + pathToUse;
        }
        this.path = pathToUse;
    }

    /**
     * Return the ServletContext for this resource.
     */
    public final ServletContext getServletContext() {
        return this.servletContext;
    }

    /**
     * Return the path for this resource.
     */
    public final String getPath() {
        return this.path;
    }


    /**
     * This implementation checks {@code ServletContext.getResource}.
     * @see javax.servlet.ServletContext#getResource(String)
     */
    @Override
    public boolean exists() {
        try {
            URL url = this.servletContext.getResource(this.path);
            return (url != null);
        }
        catch (MalformedURLException ex) {
            return false;
        }
    }

    /**
     * This implementation delegates to {@code ServletContext.getResourceAsStream},
     * which returns {@code null} in case of a non-readable resource (e.g. a directory).
     * @see javax.servlet.ServletContext#getResourceAsStream(String)
     */
    @Override
    public boolean isReadable() {
        InputStream is = this.servletContext.getResourceAsStream(this.path);
        if (is != null) {
            try {
                is.close();
            }
            catch (IOException ex) {
                // ignore
            }
            return true;
        }
        else {
            return false;
        }
    }

    /**
     * This implementation delegates to {@code ServletContext.getResourceAsStream},
     * but throws a FileNotFoundException if no resource found.
     * @see javax.servlet.ServletContext#getResourceAsStream(String)
     */
    @Override
    public InputStream getInputStream() throws IOException {
        InputStream is = this.servletContext.getResourceAsStream(this.path);
        if (is == null) {
            throw new FileNotFoundException("Could not open " + getDescription());
        }
        return is;
    }

    /**
     * This implementation delegates to {@code ServletContext.getResource},
     * but throws a FileNotFoundException if no resource found.
     * @see javax.servlet.ServletContext#getResource(String)
     */
    @Override
    public URL getURL() throws IOException {
        URL url = this.servletContext.getResource(this.path);
        if (url == null) {
            throw new FileNotFoundException(
                    getDescription() + " cannot be resolved to URL because it does not exist");
        }
        return url;
    }

    /**
     * This implementation resolves "file:" URLs or alternatively delegates to
     * {@code ServletContext.getRealPath}, throwing a FileNotFoundException
     * if not found or not resolvable.
     * @see javax.servlet.ServletContext#getResource(String)
     * @see javax.servlet.ServletContext#getRealPath(String)
     */
    @Override
    public File getFile() throws IOException {
        URL url = this.servletContext.getResource(this.path);
        if (url != null && ResourceUtils.isFileURL(url)) {
            // Proceed with file system resolution...
            return super.getFile();
        }
        else {
            String realPath = WebUtils.getRealPath(this.servletContext, this.path);
            return new File(realPath);
        }
    }

    /**
     * This implementation creates a ServletContextResource, applying the given path
     * relative to the path of the underlying file of this resource descriptor.
     * @see org.springframework.util.StringUtils#applyRelativePath(String, String)
     */
    @Override
    public Resource createRelative(String relativePath) {
        String pathToUse = StringUtils.applyRelativePath(this.path, relativePath);
        return new ServletContextResource(this.servletContext, pathToUse);
    }

    /**
     * This implementation returns the name of the file that this ServletContext
     * resource refers to.
     * @see org.springframework.util.StringUtils#getFilename(String)
     */
    @Override
    public String getFilename() {
        return StringUtils.getFilename(this.path);
    }

    /**
     * This implementation returns a description that includes the ServletContext
     * resource location.
     */
    @Override
    public String getDescription() {
        return "ServletContext resource [" + this.path + "]";
    }

    @Override
    public String getPathWithinContext() {
        return this.path;
    }


    /**
     * This implementation compares the underlying ServletContext resource locations.
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof ServletContextResource) {
            ServletContextResource otherRes = (ServletContextResource) obj;
            return (this.servletContext.equals(otherRes.servletContext) && this.path.equals(otherRes.path));
        }
        return false;
    }

    /**
     * This implementation returns the hash code of the underlying
     * ServletContext resource location.
     */
    @Override
    public int hashCode() {
        return this.path.hashCode();
    }

}

View Code

16.UrlResource类，这个主要通过解析URL获取资源。主要考虑的是 “file:” 协议.

/*
 * Copyright 2002-2013 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.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;

import org.springframework.util.Assert;
import org.springframework.util.ResourceUtils;
import org.springframework.util.StringUtils;

/**
 * {@link Resource} implementation for {@code java.net.URL} locators.
 * Obviously supports resolution as URL, and also as File in case of
 * the "file:" protocol.
 *
 * @author Juergen Hoeller
 * @since 28.12.2003
 * @see java.net.URL
 */
public class UrlResource extends AbstractFileResolvingResource {

    /**
     * Original URI, if available; used for URI and File access.
     */
    private final URI uri;

    /**
     * Original URL, used for actual access.
     */
    private final URL url;

    /**
     * Cleaned URL (with normalized path), used for comparisons.
     */
    private final URL cleanedUrl;


    /**
     * Create a new UrlResource based on the given URI object.
     * @param uri a URI
     * @throws MalformedURLException if the given URL path is not valid
     */
    public UrlResource(URI uri) throws MalformedURLException {
        Assert.notNull(uri, "URI must not be null");
        this.uri = uri;
        this.url = uri.toURL();
        this.cleanedUrl = getCleanedUrl(this.url, uri.toString());
    }

    /**
     * Create a new UrlResource based on the given URL object.
     * @param url a URL
     */
    public UrlResource(URL url) {
        Assert.notNull(url, "URL must not be null");
        this.url = url;
        this.cleanedUrl = getCleanedUrl(this.url, url.toString());
        this.uri = null;
    }

    /**
     * Create a new UrlResource based on a URL path.
     * <p>Note: The given path needs to be pre-encoded if necessary.
     * @param path a URL path
     * @throws MalformedURLException if the given URL path is not valid
     * @see java.net.URL#URL(String)
     */
    public UrlResource(String path) throws MalformedURLException {
        Assert.notNull(path, "Path must not be null");
        this.uri = null;
        this.url = new URL(path);
        this.cleanedUrl = getCleanedUrl(this.url, path);
    }

    /**
     * Create a new UrlResource based on a URI specification.
     * <p>The given parts will automatically get encoded if necessary.
     * @param protocol the URL protocol to use (e.g. "jar" or "file" - without colon);
     * also known as "scheme"
     * @param location the location (e.g. the file path within that protocol);
     * also known as "scheme-specific part"
     * @throws MalformedURLException if the given URL specification is not valid
     * @see java.net.URI#URI(String, String, String)
     */
    public UrlResource(String protocol, String location) throws MalformedURLException  {
        this(protocol, location, null);
    }

    /**
     * Create a new UrlResource based on a URI specification.
     * <p>The given parts will automatically get encoded if necessary.
     * @param protocol the URL protocol to use (e.g. "jar" or "file" - without colon);
     * also known as "scheme"
     * @param location the location (e.g. the file path within that protocol);
     * also known as "scheme-specific part"
     * @param fragment the fragment within that location (e.g. anchor on an HTML page,
     * as following after a "#" separator)
     * @throws MalformedURLException if the given URL specification is not valid
     * @see java.net.URI#URI(String, String, String)
     */
    public UrlResource(String protocol, String location, String fragment) throws MalformedURLException  {
        try {
            this.uri = new URI(protocol, location, fragment);
            this.url = this.uri.toURL();
            this.cleanedUrl = getCleanedUrl(this.url, this.uri.toString());
        }
        catch (URISyntaxException ex) {
            MalformedURLException exToThrow = new MalformedURLException(ex.getMessage());
            exToThrow.initCause(ex);
            throw exToThrow;
        }
    }

    /**
     * Determine a cleaned URL for the given original URL.
     * @param originalUrl the original URL
     * @param originalPath the original URL path
     * @return the cleaned URL
     * @see org.springframework.util.StringUtils#cleanPath
     */
    private URL getCleanedUrl(URL originalUrl, String originalPath) {
        try {
            return new URL(StringUtils.cleanPath(originalPath));
        }
        catch (MalformedURLException ex) {
            // Cleaned URL path cannot be converted to URL
            // -> take original URL.
            return originalUrl;
        }
    }


    /**
     * This implementation opens an InputStream for the given URL.
     * It sets the "UseCaches" flag to {@code false},
     * mainly to avoid jar file locking on Windows.
     * @see java.net.URL#openConnection()
     * @see java.net.URLConnection#setUseCaches(boolean)
     * @see java.net.URLConnection#getInputStream()
     */
    @Override
    public InputStream getInputStream() throws IOException {
        URLConnection con = this.url.openConnection();
        ResourceUtils.useCachesIfNecessary(con);
        try {
            return con.getInputStream();
        }
        catch (IOException ex) {
            // Close the HTTP connection (if applicable).
            if (con instanceof HttpURLConnection) {
                ((HttpURLConnection) con).disconnect();
            }
            throw ex;
        }
    }

    /**
     * This implementation returns the underlying URL reference.
     */
    @Override
    public URL getURL() throws IOException {
        return this.url;
    }

    /**
     * This implementation returns the underlying URI directly,
     * if possible.
     */
    @Override
    public URI getURI() throws IOException {
        if (this.uri != null) {
            return this.uri;
        }
        else {
            return super.getURI();
        }
    }

    /**
     * This implementation returns a File reference for the underlying URL/URI,
     * provided that it refers to a file in the file system.
     * @see org.springframework.util.ResourceUtils#getFile(java.net.URL, String)
     */
    @Override
    public File getFile() throws IOException {
        if (this.uri != null) {
            return super.getFile(this.uri);
        }
        else {
            return super.getFile();
        }
    }

    /**
     * This implementation creates a UrlResource, applying the given path
     * relative to the path of the underlying URL of this resource descriptor.
     * @see java.net.URL#URL(java.net.URL, String)
     */
    @Override
    public Resource createRelative(String relativePath) throws MalformedURLException {
        if (relativePath.startsWith("/")) {
            relativePath = relativePath.substring(1);
        }
        return new UrlResource(new URL(this.url, relativePath));
    }

    /**
     * This implementation returns the name of the file that this URL refers to.
     * @see java.net.URL#getFile()
     * @see java.io.File#getName()
     */
    @Override
    public String getFilename() {
        return new File(this.url.getFile()).getName();
    }

    /**
     * This implementation returns a description that includes the URL.
     */
    @Override
    public String getDescription() {
        return "URL [" + this.url + "]";
    }


    /**
     * This implementation compares the underlying URL references.
     */
    @Override
    public boolean equals(Object obj) {
        return (obj == this ||
            (obj instanceof UrlResource && this.cleanedUrl.equals(((UrlResource) obj).cleanedUrl)));
    }

    /**
     * This implementation returns the hash code of the underlying URL reference.
     */
    @Override
    public int hashCode() {
        return this.cleanedUrl.hashCode();
    }

}

View Code

到此为止，Resource完结了，说实话内心真的很佩服写这个接口的，那么多资源都能考虑到，用起来也很方便。接下来就要讲述一下如何加载这些对应的资源。

所以说，假如有一个文件位于类路径下，我们就可以通过以下三种方式获取：

ClassPathResource：以classpath的类路径方式访问。

FileSystemResource：以文件系统绝对路径的方式访问。

ServletContextResource：以web应用的根目录方式访问。