1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class PropertiesDemo {
    public static void main(String[] args) throws Exception {
      // 这个文件的路径在什么地方
        File file = new File("");
        System.out.println(file.getAbsolutePath());

        File propertiesFile = new File("D:\\GuPao_IDEA_xiaomage_workspace\\GP-public\\java-resource\\src\\main\\resources\\application.properties");
        Properties properties = new Properties();
        properties.load(new FileReader(propertiesFile));
        String appName = properties.getProperty("spring.application.name");
        System.out.println(appName);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
     * System properties. The following properties are guaranteed to be defined:
     * <dl>
     * <dt>java.version         <dd>Java version number
     * <dt>java.version.date    <dd>Java version date
     * <dt>java.vendor          <dd>Java vendor specific string
     * <dt>java.vendor.url      <dd>Java vendor URL
     * <dt>java.vendor.version  <dd>Java vendor version
     * <dt>java.home            <dd>Java installation directory
     * <dt>java.class.version   <dd>Java class version number
     * <dt>java.class.path      <dd>Java classpath
     * <dt>os.name              <dd>Operating System Name
     * <dt>os.arch              <dd>Operating System Architecture
     * <dt>os.version           <dd>Operating System Version
     * <dt>file.separator       <dd>File separator ("/" on Unix)
     * <dt>path.separator       <dd>Path separator (":" on Unix)
     * <dt>line.separator       <dd>Line separator ("\n" on Unix)
     * <dt>user.name            <dd>User account name
     * <dt>user.home            <dd>User home directory
     * <dt>user.dir             <dd>User's current working directory
     * </dl>
     */

1
class WinNTFileSystem extends FileSystem {

1
        System.err.println(System.getProperty("java.class.path"));

1
2
3
4
5
6
7
8
9
10
11
public class PropertiesDemo {
    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("application.properties");
        Properties properties = new Properties();
        properties.load(inputStream);
        String appName = properties.getProperty("spring.application.name");
        System.out.println(appName);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) throws IOException {
    // URL https://start.spring.io/

    RestTemplate restTemplate = new RestTemplate();
    InputStream inputStream = restTemplate.execute("https://start.spring.io/",
                                                   HttpMethod.GET,
                                                   request -> {
                                                   },
                                                   Response -> Response.getBody());
    // 正常来说应该从相应体里边拿出来
    InputStreamReader reader = new InputStreamReader(inputStream, "UTF-8");
    System.out.println(reader);
}

1
2
3
4
5
6
7
transient URLStreamHandler handler;
public final InputStream openStream() throws java.io.IOException {
    return openConnection().getInputStream();
}
public URLConnection openConnection() throws java.io.IOException {
    return handler.openConnection(this);
}

1
2
3
4
5
public static void main(String[] args) throws MalformedURLException {
    File file = new File("src/main/resources/application.properties");
    URL url = file.toURI().toURL();
    System.out.println(url);
}

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) throws Exception {
    File file = new File("src/main/resources/application.properties");
    URL fileUrl = file.toURI().toURL();
    URLConnection urlConnection = fileUrl.openConnection();

    InputStream inputStreamFromURL = urlConnection.getInputStream();

    String context = StreamUtils.copyToString(inputStreamFromURL, Charset.forName("UTF-8"));
    System.out.println(context);
}

1
2
public URL(String protocol, String host, int port, String file,
               URLStreamHandler handler) throws MalformedURLException {

1
2
3
4
5
6
URL url = new URL("https://start.spring.io/");      // https
URL ftpurl = new URL("ftp://ftp.baidu.com");        // ftp
URL jarurl = new URL("jar://jar.baidu.com");        // jar 协议
URL wetchat = new URL("webchat://...");             // 微信协议
URL dubboURL = new URL("dubbo://...");              // dubbo 协议
URL classpathURL = new URL("classpath:/");          /// classpath

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private static class DefaultFactory implements URLStreamHandlerFactory {
        private static String PREFIX = "sun.net.www.protocol";

        public URLStreamHandler createURLStreamHandler(String protocol) {
            String name = PREFIX + "." + protocol + ".Handler";
            try {
                @SuppressWarnings("deprecation")
                Object o = Class.forName(name).newInstance();
                return (URLStreamHandler)o;
            } catch (ClassNotFoundException x) {
                // ignore
            } catch (Exception e) {
                // For compatibility, all Exceptions are ignored.
                // any number of exceptions can get thrown here
            }
            return null;
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private static class DefaultFactory implements URLStreamHandlerFactory {
    private static String PREFIX = "sun.net.www.protocol";

    public URLStreamHandler createURLStreamHandler(String protocol) {
        String name = PREFIX + "." + protocol + ".Handler";
        try {
            @SuppressWarnings("deprecation")
            Object o = Class.forName(name).newInstance();
            return (URLStreamHandler)o;
        } catch (ClassNotFoundException x) {
            // ignore
        } catch (Exception e) {
            // For compatibility, all Exceptions are ignored.
            // any number of exceptions can get thrown here
        }
        return null;
    }
}

1
2
3
4
5
6
public static void main(String[] args) {
    // 装载这个类的文件
    ClassLoader classLoader = ApplicationContext.class.getClassLoader();
    URL url = classLoader.getResource("META-INF/license.txt");
    System.out.println(url);
}

1
jar:file:/D:/anzhuang/DevInstall/repository/org/springframework/spring-web/5.0.11.RELEASE/spring-web-5.0.11.RELEASE.jar!/META-INF/license.txt

1
2
3
4
5
6
7
8
9
10
11
12
public class ClasspathDemo {
    public static void main(String[] args) throws IOException {
        // Spring Classpath protocol
        // classpath:/META-INF/license.txt
        URL url = new URL("classpath:/META-INF/license.txt");

        URLConnection urlConnection = url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        String context = StreamUtils.copyToString(inputStream, Charset.forName("UTF-8"));
        System.out.println(context);
    }
}

1
classLoader.getResource("META-INF/license.txt");

1
 URL url = new URL("classpath:/META-INF/license.txt");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public interface Resource extends InputStreamSource {
    boolean exists();

    default boolean isReadable() {
        return true;
    }

    default boolean isOpen() {
        return false;
    }

    default boolean isFile() {
        return false;
    }

    URL getURL() throws IOException;

    URI getURI() throws IOException;

    File getFile() throws IOException;

    default ReadableByteChannel readableChannel() throws IOException {
        return Channels.newChannel(this.getInputStream());
    }

    long contentLength() throws IOException;

    long lastModified() throws IOException;

    Resource createRelative(String var1) throws IOException;

    @Nullable
    String getFilename();

    String getDescription();
}

1
2
3
public interface InputStreamSource {
    InputStream getInputStream() throws IOException;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ResourceDemo {
    public static void main(String[] args) throws IOException {
        // Resource
        // FileSystemResource
        // ClassPathResource
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        Resource resource = resourceLoader
                .getResource("classpath:/application.properties");

        InputStream inputStream = resource.getInputStream();
        String content = StreamUtils.copyToString(inputStream, Charset.forName("UTF-8"));
        System.out.println(content);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public Resource getResource(String location) {
    Assert.notNull(location, "Location must not be null");
    Iterator var2 = this.protocolResolvers.iterator();

    Resource resource;
    do {
        if (!var2.hasNext()) {
            if (location.startsWith("/")) {
                return this.getResourceByPath(location);
            }

            if (location.startsWith("classpath:")) {
                return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
            }

            try {
                URL url = new URL(location);
                return (Resource)(ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
            } catch (MalformedURLException var5) {
                return this.getResourceByPath(location);
            }
        }

        ProtocolResolver protocolResolver = (ProtocolResolver)var2.next();
        resource = protocolResolver.resolve(location, this);
    } while(resource == null);

    return resource;
}

protected Resource getResourceByPath(String path) {
    return new DefaultResourceLoader.ClassPathContextResource(path, this.getClassLoader());
}